add 3.12 features, inline script metadata, argparse

- README: recommend 3.12+
- typing.md: native generic syntax [T], type statement
- uv.md: PEP 723 inline script metadata (# /// script)
- patterns.md: argparse with subparsers

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

languages/python/README.md

···
 
 python is dynamically typed but increasingly written with static type hints. it has first-class async support but doesn't force it on you. it has a global interpreter lock but that matters less than people think for I/O-bound work.
 
-these notes focus on modern python (3.10+) - the patterns that emerge when you take typing seriously and use async where it makes sense.
+these notes assume python 3.12 or later. 3.12 introduced native generic syntax and the `type` statement - the typing story finally feels complete.
 
 ## the language
 

languages/python/patterns.md

···
 
 the wrapper's signature now includes `_filter`. IDEs and schema generators see it.
 
+## argparse for CLIs
+
+argparse is stdlib and sufficient for most CLIs. subparsers give you git-style commands:
+
+```python
+import argparse
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="my tool")
+    subparsers = parser.add_subparsers(dest="command")
+
+    list_parser = subparsers.add_parser("list", aliases=["ls"])
+    list_parser.add_argument("collection")
+    list_parser.add_argument("--limit", type=int, default=50)
+
+    args = parser.parse_args()
+
+    match args.command:
+        case "list" | "ls":
+            return do_list(args.collection, args.limit)
+        case _:
+            parser.print_help()
+            return 1
+
+    return 0
+```
+
+the pattern: parse once at the top, dispatch based on command, return exit codes.
+
 ## module-level singletons
 
 instantiate once, import everywhere:

languages/python/typing.md

···
 # typing
 
-modern python type hints - not just for IDEs, but for thinking clearly about code.
+python 3.12 made typing feel native. generics have real syntax, type aliases have a keyword, and you rarely need to import from `typing` anymore.
 
-## basics
+## the basics
 
-use `|` for unions, not `Optional`:
+use `|` for unions:
 
 ```python
-# yes
 def fetch(url: str, timeout: float | None = None) -> dict[str, Any]: ...
+```
+
+`from __future__ import annotations` at the top of files lets you reference types before they're defined and avoids some runtime costs.
+
+## type aliases
 
-# no
-from typing import Optional
-def fetch(url: str, timeout: Optional[float] = None) -> Dict[str, Any]: ...
+the `type` statement creates type aliases:
+
+```python
+type UserId = int
+type Handler = Callable[[Request], Response]
+type Result[T] = T | Error
 ```
 
-`from __future__ import annotations` at the top of every file. this defers evaluation so you can reference types before they're defined.
+clearer than `TypeAlias` annotations and supports generics directly.
 
 ## TypedDict
 
···
 
 ## generics
 
-for functions that work with any type:
+3.12 introduced native syntax for generics. no more `TypeVar`:
 
 ```python
-from typing import TypeVar
-
-T = TypeVar("T")
-
-def first(items: list[T]) -> T | None:
+def first[T](items: list[T]) -> T | None:
     return items[0] if items else None
 ```
 
···
 ```python
 from pydantic import BaseModel
 
-ModelT = TypeVar("ModelT", bound=BaseModel)
-
-def parse(data: dict, model: type[ModelT]) -> ModelT:
+def parse[M: BaseModel](data: dict, model: type[M]) -> M:
     return model.model_validate(data)
 ```
+
+the `[T]` declares the type parameter inline. `[M: BaseModel]` constrains it. this is real syntax, not a workaround.
 
 ## ParamSpec
 

languages/python/uv.md

···
 uv run --with git+https://github.com/prefecthq/prefect.git@branch#subdirectory=src/integrations/prefect-redis repro.py
 ```
 
+## inline script metadata
+
+PEP 723 lets you embed dependencies directly in a script:
+
+```python
+# /// script
+# dependencies = ["httpx", "rich"]
+# requires-python = ">=3.12"
+# ///
+
+import httpx
+from rich import print
+
+print(httpx.get("https://httpbin.org/get").json())
+```
+
+run with `uv run script.py` - uv reads the metadata and creates an environment with those dependencies. no pyproject.toml, no requirements.txt, just a self-contained script.
+
+this is how you share reproducible examples. put the dependencies in the file itself, and anyone with uv can run it.
+
 ## shareable one-liners
 
 no file needed: