Typing and Annotations

def ids(users: list[dict[str, str]]) -> list[str]:
    return [u["id"] for u in users]
ids([{"id": "1"}, {"id": "2"}])   # ['1', '2']

def find(name: str) -> str | None:
    return name if name else None
find("Ada")   # 'Ada'
find("")      # None

from typing import TypeVar
T = TypeVar("T", int, float)
def clamp(x: T, lo: T, hi: T) -> T:
    return max(lo, min(x, hi))
clamp(10, 0, 5)   # 5
clamp(1.5, 0.0, 1.0)   # 1.0

from typing import TypedDict
class UserDict(TypedDict):
    id: str
    name: str
u: UserDict = {"id": "1", "name": "Ada"}
u["name"]   # 'Ada'

from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from collections.abc import Sequence  # not needed at runtime here
TYPE_CHECKING   # False at runtime

from collections.abc import Callable
Handler = Callable[[str], int]
h: Handler = len
h("hi")   # 2

from typing import Literal
Mode = Literal["r", "w", "a"]
def open_mode(m: Mode) -> Mode:
    return m
open_mode("r")   # 'r'

from typing import NewType
UserId = NewType("UserId", str)
uid = UserId("u-1")
str(uid)   # 'u-1'

from typing import TypeGuard
def is_str_list(x: object) -> TypeGuard[list[str]]:
    return isinstance(x, list) and all(isinstance(i, str) for i in x)
is_str_list(["a", "b"])   # True
is_str_list([1, 2])       # False

from typing import Generic, TypeVar
T = TypeVar("T")
class Box(Generic[T]):
    def __init__(self, value: T) -> None:
        self.value = value
Box(42).value   # 42

from typing import cast
payload: object = {"id": 1}
user = cast(dict, payload)
user["id"]   # 1

from typing import overload
@overload
def parse(x: str) -> int: ...
@overload
def parse(x: bytes) -> int: ...
def parse(x: str | bytes) -> int:
    return int(x)
parse("10")    # 10
parse(b"10")   # 10

from typing import Self
class Builder:
    def __init__(self) -> None:
        self.name = ""
    def with_name(self, name: str) -> Self:
        self.name = name
        return self
Builder().with_name("Ada").name   # 'Ada'

from typing import Annotated, get_args, get_origin
UserId = Annotated[str, "path param"]
get_origin(UserId) is Annotated   # True
get_args(UserId)[0] is str        # True

from typing import Final
MAX_SIZE: Final = 1024
MAX_SIZE   # 1024