wshobson/agents/python-type-safety

def get_user(user_id: str) -> User | None:
    """Return type makes 'might not exist' explicit."""
    ...
# Type checker enforces handling None case
user = get_user("123")
if user is None:
    raise UserNotFoundError("123")
print(user.name)  # Type checker knows user is User here

def get_user(user_id: str) -> User:
    """Retrieve user by ID."""
    ...
def process_batch(
    items: list[Item],
    max_workers: int = 4,
) -> BatchResult[ProcessedItem]:
    """Process items concurrently."""
    ...
class UserRepository:
    def __init__(self, db: Database) -> None:
        self._db = db
    async def find_by_id(self, user_id: str) -> User | None:
        """Return User if found, None otherwise."""
        ...
    async def find_by_email(self, email: str) -> User | None:
        ...
    async def save(self, user: User) -> User:
        """Save and return user with generated ID."""
        ...

# Preferred (3.10+)
def find_user(user_id: str) -> User | None:
    ...
def parse_value(v: str) -> int | float | str:
    ...
# Older style (still valid, needed for 3.9)
from typing import Optional, Union
def find_user(user_id: str) -> Optional[User]:
    ...

def process_user(user_id: str) -> UserData:
    user = find_user(user_id)
    if user is None:
        raise UserNotFoundError(f"User {user_id} not found")
    # Type checker knows user is User here, not User | None
    return UserData(
        name=user.name,
        email=user.email,
    )
def process_items(items: list[Item | None]) -> list[ProcessedItem]:
    # Filter and narrow types
    valid_items = [item for item in items if item is not None]
    # valid_items is now list[Item]
    return [process(item) for item in valid_items]

from typing import TypeVar, Generic
T = TypeVar("T")
E = TypeVar("E", bound=Exception)
class Result(Generic[T, E]):
    """Represents either a success value or an error."""
    def __init__(
        self,
        value: T | None = None,
        error: E | None = None,
    ) -> None:
        if (value is None) == (error is None):
            raise ValueError("Exactly one of value or error must be set")
        self._value = value
        self._error = error
    @property
    def is_success(self) -> bool:
        return self._error is None
    @property
    def is_failure(self) -> bool:
        return self._error is not None
    def unwrap(self) -> T:
        """Get value or raise the error."""
        if self._error is not None:
            raise self._error
        return self._value  # type: ignore[return-value]
    def unwrap_or(self, default: T) -> T:
        """Get value or return default."""
        if self._error is not None:
            return default
        return self._value  # type: ignore[return-value]
# Usage preserves types
def parse_config(path: str) -> Result[Config, ConfigError]:
    try:
        return Result(value=Config.from_file(path))
    except ConfigError as e:
        return Result(error=e)
result = parse_config("config.yaml")
if result.is_success:
    config = result.unwrap()  # Type: Config