Typing & Static Analysis — đưa kiểm tra kiểu vào Python

# Biến — dấu hai chấm sau tên
x: int = 5
name: str = "An"
active: bool = True
ratio: float = 3.14

# Function — annotate parameter và return
def greet(name: str, age: int) -> str:
    return f"Xin chào {name}, {age} tuổi"

# Return None tường minh khi function không trả gì
def log(msg: str) -> None:
    print(msg)

# Attribute trong class
class User:
    name: str
    age: int

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

nums: list[int] = [1, 2, 3]
names: list[str] = ["An", "Bình"]
ages: dict[str, int] = {"An": 22, "Bình": 30}

# Set
tags: set[str] = {"py", "ts"}

# Tuple — 2 nghĩa khác nhau
# 1) Fixed shape: tuple với type cho từng slot
pair: tuple[str, int] = ("age", 22)
point: tuple[float, float, float] = (1.0, 2.0, 3.0)

# 2) Variable length: tuple[T, ...]
many_ints: tuple[int, ...] = (1, 2, 3, 4)

# Nested
matrix: list[list[int]] = [[1, 2], [3, 4]]
config: dict[str, list[int]] = {"primes": [2, 3, 5]}

# Cách cũ (Python <3.10) — Optional từ typing
from typing import Optional

def find_user(uid: int) -> Optional[str]:
    if uid == 1:
        return "An"
    return None

# Cách mới (Python 3.10+, PEP 604) — toán tử |
def find_user(uid: int) -> str | None:
    if uid == 1:
        return "An"
    return None

# Hai cái HOÀN TOÀN tương đương — Optional[T] = T | None

from typing import Union

# Cũ
def parse_id(raw: Union[int, str]) -> int:
    return int(raw)

# Mới (3.10+)
def parse_id(raw: int | str) -> int:
    return int(raw)

# 3 type trở lên
def to_str(x: int | float | str | None) -> str:
    if x is None:
        return ""
    return str(x)

from typing import Any

x: Any = "hello"
x = 42                     # OK
x = [1, 2, 3]                # OK
x.whatever().chain()       # OK ở mypy, 💥 runtime nếu sai

# Any "lây lan": gán biến Any vào biến typed cũng OK
def get_data() -> Any:
    return {"k": 1}

n: int = get_data()       # OK (Any → int), nhưng runtime n là dict 💥

from typing import Never  # Python 3.11+. Trước đó: NoReturn

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

def infinite() -> Never:
    while True:
        do_something()

# Mypy hiểu: dòng sau fail() là "dead code"
def divide(a: int, b: int) -> float:
    if b == 0:
        fail("chia cho 0")
        # Mypy: ở đây code không thể đến được
    return a / b

from typing import Literal

Color = Literal["red", "green", "blue"]

def paint(c: Color) -> None:
    print(f"Sơn {c}")

paint("red")      # OK
paint("yellow")   # Mypy: Argument 1 has incompatible type "Literal['yellow']"

# Literal số, bool — cũng được
def flip(side: Literal[0, 1]) -> Literal[0, 1]:
    return 1 - side

# Discriminated union — pattern phổ biến
from typing import TypedDict

class SuccessResult(TypedDict):
    status: Literal["ok"]
    data: str

class ErrorResult(TypedDict):
    status: Literal["error"]
    message: str

Result = SuccessResult | ErrorResult

def handle(r: Result) -> str:
    if r["status"] == "ok":
        return r["data"]      # Narrow về SuccessResult
    else:
        return r["message"]   # Narrow về ErrorResult

from typing import Final

MAX_RETRIES: Final = 3
API_URL: Final[str] = "https://api.example.com"

MAX_RETRIES = 5   # Mypy: Cannot assign to final name "MAX_RETRIES"
# Nhưng runtime vẫn cho phép — Final chỉ là gợi ý cho tool

# Trong class — không cho override ở subclass
class Base:
    name: Final[str] = "Base"

class Sub(Base):
    name = "Sub"     # Mypy: Cannot override writable attribute "name"

# Cũ (Python <3.12) — TypeAlias từ typing
from typing import TypeAlias

UserId: TypeAlias = int
Coord: TypeAlias = tuple[float, float]
JsonValue: TypeAlias = str | int | float | bool | None | list["JsonValue"] | dict[str, "JsonValue"]

def find_user(uid: UserId) -> str | None: ...

# Mới (Python 3.12+, PEP 695) — keyword `type`
type UserId = int
type Coord = tuple[float, float]
type JsonValue = str | int | float | bool | None | list["JsonValue"] | dict[str, "JsonValue"]

def find_user(uid: UserId) -> str | None: ...

from typing import TypedDict, NotRequired

class User(TypedDict):
    name: str
    age: int
    email: str | None
    tags: NotRequired[list[str]]  # Optional field — 3.11+

u: User = {"name": "An", "age": 22, "email": None}  # OK, tags vắng được

# Truy cập như dict bình thường
print(u["name"])   # "An"
u["age"] = 23      # OK
u["unknown"]      # Mypy: TypedDict "User" has no key "unknown"

# Mất type khi không annotate
data = json.loads(response)  # type: dict[str, Any] — không phải User!
# Phải cast/validate:
user: User = cast(User, data)

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> None: ...

class Circle:
    def draw(self) -> None:
        print("○")

class Square:
    def draw(self) -> None:
        print("□")

# Cả Circle và Square KHÔNG kế thừa Drawable
# Nhưng đều "match" shape (có draw() -> None) — đủ rồi

def render(items: list[Drawable]) -> None:
    for item in items:
        item.draw()

render([Circle(), Square()])   # Mypy OK — duck typing được type check!

from typing import Protocol, runtime_checkable

@runtime_checkable
class Closeable(Protocol):
    def close(self) -> None: ...

def safe_close(obj: object) -> None:
    if isinstance(obj, Closeable):  # Check runtime!
        obj.close()

# Python 3.12+ — cú pháp [T] sau tên
def first[T](items: list[T]) -> T:
    return items[0]

x: int = first([1, 2, 3])           # T = int
s: str = first(["a", "b"])             # T = str

# Nhiều type parameter
def swap[A, B](pair: tuple[A, B]) -> tuple[B, A]:
    a, b = pair
    return b, a

# Constraint: T phải là int hoặc float
def double[T: (int, float)](x: T) -> T:
    return x * 2

# Bound: T phải là subtype của Comparable
def sort_items[T: SupportsRichComparison](items: list[T]) -> list[T]:
    return sorted(items)

from typing import TypeVar

T = TypeVar("T")

def first(items: list[T]) -> T:
    return items[0]

# Constrained TypeVar
Num = TypeVar("Num", int, float)

def double(x: Num) -> Num:
    return x * 2

# Bound TypeVar
TComp = TypeVar("TComp", bound=SupportsRichComparison)

# Python 3.12+ — cú pháp class Name[T]:
class Stack[T]:
    def __init__(self) -> None:
        self.items: list[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()

s: Stack[int] = Stack()
s.push(1)
s.push("hello")    # Mypy: incompatible type

# Generic class với nhiều type parameter
class Pair[A, B]:
    def __init__(self, first: A, second: B) -> None:
        self.first = first
        self.second = second

p: Pair[str, int] = Pair("age", 22)

from typing import Generic, TypeVar

T = TypeVar("T")

class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: list[T] = []
    def push(self, item: T) -> None: self.items.append(item)
    def pop(self) -> T: return self.items.pop()

def format_id(x: int | str) -> str:
    if isinstance(x, str):
        return x.upper()       # mypy: x đã được narrow về str
    return str(x)                # mypy: x là int ở đây

def greet(name: str | None) -> str:
    if name is None:
        return "Khách"
    return name.upper()         # name đã được narrow về str

# assert cũng narrow
def process(x: int | None) -> int:
    assert x is not None
    return x + 1                  # x: int sau assert

from typing import TypeGuard

def is_str_list(x: list[object]) -> TypeGuard[list[str]]:
    return all(isinstance(item, str) for item in x)

def process(items: list[object]) -> None:
    if is_str_list(items):
        for s in items:
            print(s.upper())    # items đã được narrow về list[str]

# Python 3.13+ giới thiệu TypeIs — narrow chính xác hơn (cả 2 branch)
from typing import TypeIs   # 3.13+
def is_int(x: object) -> TypeIs[int]:
    return isinstance(x, int)

# Cài
pip install mypy
# hoặc với uv (chương 1)
uv pip install mypy

# Chạy
mypy app.py                     # 1 file
mypy src/                       # 1 folder
mypy --strict src/              # Strict mode — kiểm tra tối đa

# Output mẫu:
# app.py:12: error: Argument 1 to "greet" has incompatible type "int"; expected "str"
# Found 1 error in 1 file (checked 5 source files)

[tool.mypy]
python_version = "3.12"
strict = true
warn_return_any = true
warn_unused_ignores = true
disallow_untyped_defs = true
disallow_any_unimported = true
no_implicit_optional = true
check_untyped_defs = true
show_error_codes = true

# Bỏ qua thư viện không có type stub
[[tool.mypy.overrides]]
module = ["untyped_lib.*"]
ignore_missing_imports = true

npm install -g pyright
pyright src/
pyright --strict src/

# Config qua pyrightconfig.json hoặc pyproject.toml
[tool.pyright]
pythonVersion = "3.12"
typeCheckingMode = "strict"
reportMissingTypeStubs = true

def process(items: list[int]) -> int:
    total: int = 0                       # noise — mypy đã biết total: int
    i: int = 0                            # noise
    n: int = len(items)                   # noise
    while i < n:
        x: int = items[i]                  # noise
        squared: int = x * x                # noise
        total = total + squared
        i = i + 1
    return total

def process(items: list[int]) -> int:
    total = 0
    for x in items:
        total += x * x
    return total