# Single Inheritance
class BaseRepository:
    def __init__(self, db):
        self.db = db

    def find_by_id(self, id: int):
        raise NotImplementedError

class UserRepository(BaseRepository):     # inherits BaseRepository
    def find_by_id(self, id: int):          # override
        return self.db.query(f"SELECT * FROM users WHERE id={id}")

    def find_by_email(self, email: str):
        return self.db.query(f"SELECT * FROM users WHERE email='{email}'")

# Multiple Inheritance
class TimestampMixin:
    def created_at(self): return "now"

class AuditMixin:
    def audit_log(self): return "logged"

class AuditedUserRepo(UserRepository, TimestampMixin, AuditMixin):
    pass

# Inspect MRO — shows lookup order
print(AuditedUserRepo.__mro__)
# (AuditedUserRepo, UserRepository, BaseRepository, TimestampMixin, AuditMixin, object)

# super() follows MRO — always prefer it over direct parent calls
class ExtendedRepo(UserRepository):
    def find_by_id(self, id: int):
        result = super().find_by_id(id)  # calls UserRepository.find_by_id
        return {"data": result, "cached": False}

# ❌ Inheritance approach — tightly coupled
class UserService(SQLAlchemyEngine):  # BAD: UserService IS a DB engine?
    pass

# ✅ Composition approach — loosely coupled, testable
class UserRepository:
    def __init__(self, db: AsyncSession):
        self.db = db                    # HAS-A database session

    async def get(self, user_id: int):
        return await self.db.get(User, user_id)

class EmailService:
    def __init__(self, smtp_host: str):
        self.smtp_host = smtp_host

    async def send(self, to: str, body: str): ...

class UserService:
    def __init__(
        self,
        repo: UserRepository,          # HAS-A repo
        email: EmailService,           # HAS-A email service
    ):
        self.repo = repo
        self.email = email

    async def register(self, user_data: dict):
        user = await self.repo.create(user_data)
        await self.email.send(user.email, "Welcome!")
        return user

# FastAPI DI wires this automatically:
# async def get_user_service(db=Depends(get_db)) -> UserService:
#     return UserService(repo=UserRepository(db), email=EmailService(...))

# Mixin: adds created_at / updated_at to any SQLAlchemy model
from datetime import datetime

class TimestampMixin:
    created_at: datetime = Field(default_factory=datetime.utcnow)
    updated_at: datetime = Field(default_factory=datetime.utcnow)

    def touch(self):
        self.updated_at = datetime.utcnow()

class SoftDeleteMixin:
    deleted_at: datetime | None = None

    def soft_delete(self):
        self.deleted_at = datetime.utcnow()

    def is_deleted(self) -> bool:
        return self.deleted_at is not None

# Use mixins to compose rich models cleanly
class UserModel(TimestampMixin, SoftDeleteMixin, BaseModel):
    id: int
    name: str
    email: str
    # inherits: created_at, updated_at, touch(), soft_delete(), is_deleted()

user = UserModel(id=1, name="Alice", email="a@b.com")
user.touch()          # update timestamp
user.soft_delete()    # mark as deleted without DB DELETE
print(user.is_deleted())  # True

from abc import ABC, abstractmethod
from typing import Generic, TypeVar

T = TypeVar('T')

# Abstract base — defines the interface (contract)
class BaseRepository(ABC, Generic[T]):

    @abstractmethod
    async def get(self, id: int) -> T | None: ...

    @abstractmethod
    async def create(self, data: dict) -> T: ...

    @abstractmethod
    async def delete(self, id: int) -> bool: ...

# Concrete implementation
class SQLUserRepository(BaseRepository[User]):
    def __init__(self, session: AsyncSession):
        self.session = session

    async def get(self, id: int) -> User | None:
        return await self.session.get(User, id)

    async def create(self, data: dict) -> User:
        user = User(**data)
        self.session.add(user)
        await self.session.commit()
        return user

    async def delete(self, id: int) -> bool:
        user = await self.get(id)
        if user:
            await self.session.delete(user)
            await self.session.commit()
            return True
        return False

# Can't instantiate abstract class:
# repo = BaseRepository()  → TypeError!
# Must use concrete: repo = SQLUserRepository(session)

# Benefit: swap implementations easily in tests
class InMemoryUserRepository(BaseRepository[User]):
    def __init__(self): self._store = {}
    async def get(self, id): return self._store.get(id)
    async def create(self, data): ...
    async def delete(self, id): ...

from typing import Optional, Union

# Optional — value can be str or None
def find_user(email: Optional[str] = None) -> Optional[dict]:
    if email is None:
        return None
    return {"email": email}

# Union — accepts multiple types
def process(value: Union[int, str]) -> str:
    return str(value)

# Python 3.10+ shorthand (preferred now)
def find_user(email: str | None = None) -> dict | None: ...
def process(value: int | str) -> str: ...

# FastAPI query params example:
# @app.get("/users")
# async def list_users(role: str | None = None):  ← optional filter
#     ...

from typing import Literal, Any, Generic, TypeVar

# Literal — only these exact values allowed
Status = Literal["active", "inactive", "pending"]

def set_status(status: Status) -> None: ...
set_status("active")    # ✅ OK
# set_status("deleted") → mypy error

# Any — opt out of type checking (avoid in production code)
def legacy_func(data: Any) -> Any:
    return data

# Generic — build reusable typed wrappers
T = TypeVar('T')

class APIResponse(Generic[T]):
    def __init__(self, data: T, message: str = "success"):
        self.data = data
        self.message = message
        self.success = True

# Typed responses for different resources
user_resp: APIResponse[User] = APIResponse(data=user)
list_resp: APIResponse[list[User]] = APIResponse(data=users)

# Pydantic v2 Generic Model (used in FastAPI responses)
from pydantic import BaseModel

class PaginatedResponse(BaseModel, Generic[T]):
    items: list[T]
    total: int
    page: int
    size: int

# @app.get("/users", response_model=PaginatedResponse[UserOut])

from typing import Protocol, runtime_checkable

@runtime_checkable
class Cacheable(Protocol):
    def cache_key(self) -> str: ...
    def to_dict(self) -> dict: ...

# Any class with these methods satisfies Cacheable
class UserDTO:
    def __init__(self, id: int, name: str):
        self.id = id; self.name = name

    def cache_key(self) -> str:
        return f"user:{self.id}"

    def to_dict(self) -> dict:
        return {"id": self.id, "name": self.name}

def cache_object(obj: Cacheable, redis): # accepts anything with cache_key+to_dict
    redis.set(obj.cache_key(), obj.to_dict())

user = UserDTO(1, "Alice")
print(isinstance(user, Cacheable))  # True (runtime check)
cache_object(user, redis_client)    # ✅ UserDTO never imports Cacheable

from typing import TypedDict, Required, NotRequired

# Define a typed dict shape
class UserDict(TypedDict):
    id: int
    name: str
    email: str

# With optional fields (Python 3.11+)
class UserUpdateDict(TypedDict, total=False):  # all keys optional
    name: str
    email: str

# Or mix required and optional (Python 3.11+)
class UserCreateDict(TypedDict):
    name: Required[str]
    email: Required[str]
    role: NotRequired[str]        # optional

def process_user(user: UserDict) -> str:
    return f"{user['name']} <{user['email']}>"

data: UserDict = {"id": 1, "name": "Alice", "email": "a@b.com"}
print(process_user(data))  # Alice <a@b.com>