Type Hints & Static Typing with MyPy

def add(a: int, b: int) -> int:
    return a + b

age: int = 18
name: str = "Alice"
balance: float = 99.5

def greet(name: str) -> str:
    return f"Hello {name}"

def move(x: float, y: float) -> tuple[float, float]:
    return x, y

from typing import Optional

def get_user(id: int) -> Optional[str]:
    return "Alice" if id == 1 else None

from typing import Union

def parse(value: Union[str, int]) -> str:
    return str(value)

# Python 3.10+ supports a cleaner syntax:
def parse(value: str | int) -> str:
    return str(value)

users: list[str] = ["Alice", "Bob"]

scores: dict[str, int] = {
    "math": 95,
    "science": 88
}

matrix: list[list[int]] = [
    [1, 2, 3],
    [4, 5, 6]
]

from typing import Callable

def operate(x: int, y: int, fn: Callable[[int, int], int]) -> int:
    return fn(x, y)

class User:
    name: str
    age: int

    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    # Typed methods
    def birthday(self) -> None:
        self.age += 1

from dataclasses import dataclass

@dataclass
class Product:
    id: int
    price: float
    name: str

from typing import TypeVar, Generic

T = TypeVar("T")

class Box(Generic[T]):
    def __init__(self, value: T):
        self.value = value

# Use:
b1 = Box(10)
b2 = Box[str]("hello")

from typing import Protocol

class Flyer(Protocol):
    def fly(self) -> None: ...

class Bird:
    def fly(self): print("bird flies")

class Plane:
    def fly(self): print("plane flies")

def lift_off(obj: Flyer):
    obj.fly()

from typing import Literal

def move(direction: Literal["up", "down"]) -> None:
    print(direction)

def log(msg: str) -> None:
    print(msg)

from typing import NoReturn

def fail(msg: str) -> NoReturn:
    raise RuntimeError(msg)

pip install mypy

mypy your_file.py

[mypy]
strict = True
warn_unused_ignores = True
warn_return_any = True
disallow_untyped_defs = True
disallow_untyped_calls = True

from enum import Enum

class Status(Enum):
    SUCCESS = "success"
    FAIL = "fail"
    PENDING = "pending"

def handle(status: Status) -> None:
    print("Status:", status.value)

from typing import TypedDict

class UserData(TypedDict):
    id: int
    name: str
    verified: bool

user: UserData = {
    "id": 1,
    "name": "Boopie",
    "verified": True
}

from typing import Union

def process(x: Union[int, str]):
    if isinstance(x, int):
        return x + 10   # MyPy knows x is int here
    else:
        return x.upper()  # MyPy knows x is str here

Coordinates = tuple[float, float]
JsonDict = dict[str, "JSON"]

def move(point: Coordinates) -> None:
    ...

def load_user() -> dict | None:
    raise FileNotFoundError("User not found")

async def fetch(url: str) -> dict:
    ...

from typing import Awaitable

def queue_task(task: Awaitable[int]):
    ...

from typing import Generator

def countdown(n: int) -> Generator[int, None, None]:
    while n > 0:
        yield n
        n -= 1

from typing import ContextManager

def open_file() -> ContextManager[str]:
    return open("data.txt")

from typing import overload

@overload
def parse(data: int) -> str: ...
@overload
def parse(data: str) -> int: ...

def parse(data):
    if isinstance(data, int):
        return str(data)
    return int(data)

from typing import Final

API_KEY: Final = "XYZ123"

class User:
    @property
    def name(self) -> str:
        return self._name

class User:
    _token: str  # internal use

class Database(Protocol):
    def connect(self) -> None: ...
    def query(self, q: str) -> list[str]: ...

from typing import cast

value = cast(str, some_unknown_value)

from typing import TypedDict, Optional

class User(TypedDict):
    id: int
    name: str
    is_active: bool

def get_user(user_id: int) -> Optional[User]:
    ...

class UserRepo(Protocol):
    def get(self, user_id: int) -> dict: ...
    def save(self, user: dict) -> None: ...

class UserModel(TypedDict):
    id: int
    email: str
    verified: bool

class UserService:
    def __init__(self, repo: UserRepo):
        self.repo = repo

    def verify_user(self, user_id: int) -> UserModel:
        user = self.repo.get(user_id)
        user["verified"] = True
        self.repo.save(user)
        return user

class NotFoundError(Exception):
    pass

def get_user(user_id: int) -> dict:
    raise NotFoundError()

from typing import Generator

def batch_loader(data: list[int], size: int) -> Generator[list[int], None, None]:
    for i in range(0, len(data), size):
        yield data[i:i+size]

from typing import AsyncIterator

async def stream_events() -> AsyncIterator[str]:
    for i in range(100):
        yield f"event-{i}"

class Plugin(Protocol):
    name: str
    def run(self, data: bytes) -> bytes: ...

class ReadOnlyRepo(Protocol):
    def get(self, id: int) -> dict: ...

class WriteRepo(Protocol):
    def save(self, data: dict) -> None: ...

from typing import Literal, TypedDict

class Task(TypedDict):
    id: int
    status: Literal["pending", "running", "done"]

class CreateUserRequest(TypedDict):
    email: str
    password: str

class CreateUserResponse(TypedDict):
    id: int
    email: str
    verified: bool

def create_user(data: CreateUserRequest) -> CreateUserResponse:
    return {
        "id": 100,
        "email": data["email"],
        "verified": False,
    }

class FakeRepo(UserRepo):
    def __init__(self):
        self.saved = {}
    def get(self, id: int):
        return {"id": id, "verified": False}
    def save(self, data: dict):
        self.saved[data["id"]] = data

from pydantic import BaseModel

class User(BaseModel):
    id: int
    email: str
    verified: bool