Type Hints & Static Verification

def process_transaction(
    account_id: str,
    amount: float,
    tags: list[str] | None = None
) -> dict[str, str | float]:
    active_tags = tags or []
    return {
        "account_id": account_id,
        "balance_change": amount,
        "tag_count": len(active_tags)
    }

res = process_transaction("ACC-402", 150.75, ["payroll", "cleared"])
print("Transaction record:", res)
print("Type annotations:", process_transaction.__annotations__)

class UserProfile:
    username: str
    age: int
    is_verified: bool = False

# Inspect class attributes and expected types
print("UserProfile annotations:")
for field_name, expected_type in UserProfile.__annotations__.items():
    print(f"  - {field_name}: {expected_type.__name__}")

def validate_payload(data: dict, schema_cls: type) -> bool:
    for field, expected in schema_cls.__annotations__.items():
        if field in data and not isinstance(data[field], expected):
            print(f"Validation error: {field} must be {expected.__name__}")
            return False
    return True

print("Valid payload:", validate_payload({"username": "ada", "age": 36}, UserProfile))
print("Invalid payload:", validate_payload({"username": "ada", "age": "thirty-six"}, UserProfile))

from typing import Literal, TypedDict

HTTPMethod = Literal["GET", "POST", "PUT", "DELETE"]

class RequestConfig(TypedDict):
    url: str
    method: HTTPMethod
    timeout: int

def execute_request(config: RequestConfig) -> str:
    return f"Executing {config['method']} to {config['url']} (timeout={config['timeout']}s)"

cfg: RequestConfig = {
    "url": "https://api.pylabs.dev/v1/health",
    "method": "GET",
    "timeout": 5
}

print(execute_request(cfg))

from typing import List

def get_longest_word(words: List[str]) -> str:
    return max(words, key=len)

print("Longest:", get_longest_word(["python", "typescript", "rust"]))

# Service integration layer
def handle_request(payload: dict) -> dict:
    return {"status": "success", "processed": True}

# High-resilience production pattern
import time

def process_stream(events: list) -> int:
    processed = 0
    for event in events:
        if event:
            processed += 1
    return processed