Version 3.1.0

feat: add M2M helpers (#247 )
feat: add get_field_by_attr fixtures helper (#245 )
2026-04-16 06:36:26 +02:00 · 2026-04-12 12:48:32 -04:00 · 2026-04-12 18:46:57 +02:00 · 2026-04-12 17:12:08 +02:00 · 2026-04-12 17:04:44 +02:00 · 2026-04-09 10:01:30 +02:00
36 changed files with 1085 additions and 3345 deletions
--- a/docs/examples/authentication.md
+++ b/docs/examples/authentication.md
@@ -1 +0,0 @@
 # Authentication
--- a/docs/module/db.md
+++ b/docs/module/db.md
@@ -118,6 +118,57 @@ async def clean(db_session):
    await cleanup_tables(session=db_session, base=Base)
 ```
 ## Many-to-Many helpers
 SQLAlchemy's ORM collection API triggers lazy-loads when you append to a relationship inside a savepoint (e.g. inside `lock_tables` or a nested `get_transaction`). The three `m2m_*` helpers bypass the ORM collection entirely and issue direct SQL against the association table.
 ### `m2m_add` — insert associations
 [`m2m_add`](../reference/db.md#fastapi_toolsets.db.m2m_add) inserts one or more rows into a secondary table without touching the ORM collection:
 ```python
 from fastapi_toolsets.db import lock_tables, m2m_add
 async with lock_tables(session, [Tag]):
    tag = await TagCrud.create(session, TagCreate(name="python"))
    await m2m_add(session, post, Post.tags, tag)
 ```
 Pass `ignore_conflicts=True` to silently skip associations that already exist:
 ```python
 await m2m_add(session, post, Post.tags, tag, ignore_conflicts=True)
 ```
 ### `m2m_remove` — delete associations
 [`m2m_remove`](../reference/db.md#fastapi_toolsets.db.m2m_remove) deletes specific association rows. Removing a non-existent association is a no-op:
 ```python
 from fastapi_toolsets.db import get_transaction, m2m_remove
 async with get_transaction(session):
    await m2m_remove(session, post, Post.tags, tag1, tag2)
 ```
 ### `m2m_set` — replace the full set
 [`m2m_set`](../reference/db.md#fastapi_toolsets.db.m2m_set) atomically replaces all associations: it deletes every existing row for the owner instance then inserts the new set. Passing no related instances clears the association entirely:
 ```python
 from fastapi_toolsets.db import get_transaction, m2m_set
 # Replace all tags
 async with get_transaction(session):
    await m2m_set(session, post, Post.tags, tag_a, tag_b)
 # Clear all tags
 async with get_transaction(session):
    await m2m_set(session, post, Post.tags)
 ```
 All three helpers raise `TypeError` if the relationship attribute is not a Many-to-Many (i.e. has no secondary table).
 ---
 [:material-api: API Reference](../reference/db.md)
--- a/docs/module/security.md
+++ b/docs/module/security.md
@@ -1,267 +0,0 @@
 # Security
 Composable authentication helpers for FastAPI that use `Security()` for OpenAPI documentation and accept user-provided validator functions with full type flexibility.
 ## Overview
 The `security` module provides four auth source classes and a `MultiAuth` factory. Each class wraps a FastAPI security scheme for OpenAPI and accepts a validator function called as:
 ```python
 await validator(credential, **kwargs)
 ```
 where `kwargs` are the extra keyword arguments provided at instantiation (roles, permissions, enums, etc.). The validator returns the authenticated identity (e.g. a `User` model) which becomes the route dependency value.
 ```python
 from fastapi import Security
 from fastapi_toolsets.security import BearerTokenAuth
 async def verify_token(token: str, *, role: str) -> User:
    user = await db.get_by_token(token)
    if not user or user.role != role:
        raise UnauthorizedError()
    return user
 bearer_admin = BearerTokenAuth(verify_token, role="admin")
@app.get("/admin")
 async def admin_route(user: User = Security(bearer_admin)):
    return user
 ```
 ## Auth sources
 ### [`BearerTokenAuth`](../reference/security.md#fastapi_toolsets.security.BearerTokenAuth)
 Reads the `Authorization: Bearer <token>` header. Wraps `HTTPBearer` for OpenAPI.
 ```python
 from fastapi_toolsets.security import BearerTokenAuth
 bearer = BearerTokenAuth(validator=verify_token)
@app.get("/me")
 async def me(user: User = Security(bearer)):
    return user
 ```
 #### Token prefix
 The optional `prefix` parameter restricts a `BearerTokenAuth` instance to tokens
 that start with a given string. The prefix is **kept** in the value passed to the
 validator — store and compare tokens with their prefix included.
 This lets you deploy multiple `BearerTokenAuth` instances in the same application
 and disambiguate them efficiently in `MultiAuth`:
 ```python
 user_bearer = BearerTokenAuth(verify_user, prefix="user_")  # matches "Bearer user_..."
 org_bearer  = BearerTokenAuth(verify_org,  prefix="org_")   # matches "Bearer org_..."
 ```
 Use [`generate_token()`](#token-generation) to create correctly-prefixed tokens.
 #### Token generation
 `BearerTokenAuth.generate_token()` produces a secure random token ready to store
 in your database and return to the client. If a prefix is configured it is
 prepended automatically:
 ```python
 bearer = BearerTokenAuth(verify_token, prefix="user_")
 token = bearer.generate_token()   # e.g. "user_Xk3mN..."
 await db.store_token(user_id, token)
 return {"access_token": token, "token_type": "bearer"}
 ```
 The client sends `Authorization: Bearer user_Xk3mN...` and the validator receives
 the full token (prefix included) to compare against the stored value.
 ### [`CookieAuth`](../reference/security.md#fastapi_toolsets.security.CookieAuth)
 Reads a named cookie. Wraps `APIKeyCookie` for OpenAPI.
 ```python
 from fastapi_toolsets.security import CookieAuth
 cookie_auth = CookieAuth("session", validator=verify_session)
@app.get("/me")
 async def me(user: User = Security(cookie_auth)):
    return user
 ```
 ### [`OAuth2Auth`](../reference/security.md#fastapi_toolsets.security.OAuth2Auth)
 Reads the `Authorization: Bearer <token>` header and registers the token endpoint
 in OpenAPI via `OAuth2PasswordBearer`.
 ```python
 from fastapi_toolsets.security import OAuth2Auth
 oauth2_auth = OAuth2Auth(token_url="/token", validator=verify_token)
@app.get("/me")
 async def me(user: User = Security(oauth2_auth)):
    return user
 ```
 ### [`OpenIDAuth`](../reference/security.md#fastapi_toolsets.security.OpenIDAuth)
 Reads the `Authorization: Bearer <token>` header and registers the OpenID Connect
 discovery URL in OpenAPI via `OpenIdConnect`. Token validation is fully delegated
 to your validator — use any OIDC / JWT library (`authlib`, `python-jose`, `PyJWT`).
 ```python
 from fastapi_toolsets.security import OpenIDAuth
 async def verify_google_token(token: str, *, audience: str) -> User:
    payload = jwt.decode(token, google_public_keys, algorithms=["RS256"],
                         audience=audience)
    return User(email=payload["email"], name=payload["name"])
 google_auth = OpenIDAuth(
    "https://accounts.google.com/.well-known/openid-configuration",
    verify_google_token,
    audience="my-client-id",
 )
@app.get("/me")
 async def me(user: User = Security(google_auth)):
    return user
 ```
 The discovery URL is used **only for OpenAPI documentation** — no requests are made
 to it by this class. You are responsible for fetching and caching the provider's
 public keys in your validator.
 Multiple providers work naturally with `MultiAuth`:
 ```python
 multi = MultiAuth(google_auth, github_auth)
@app.get("/data")
 async def data(user: User = Security(multi)):
    return user
 ```
 ## Typed validator kwargs
 All auth classes forward extra instantiation keyword arguments to the validator.
 Arguments can be any type — enums, strings, integers, etc. The validator returns
 the authenticated identity, which FastAPI injects directly into the route handler.
 ```python
 async def verify_token(token: str, *, role: Role, permission: str) -> User:
    user = await decode_token(token)
    if user.role != role or permission not in user.permissions:
        raise UnauthorizedError()
    return user
 bearer = BearerTokenAuth(verify_token, role=Role.ADMIN, permission="billing:read")
 ```
 Each auth instance is self-contained — create a separate instance per distinct
 requirement instead of passing requirements through `Security(scopes=[...])`.
 ### Using `.require()` inline
 If declaring a new top-level variable per role feels verbose, use `.require()` to
 create a configured clone directly in the route decorator. The original instance
 is not mutated:
 ```python
 bearer = BearerTokenAuth(verify_token)
@app.get("/admin/stats")
 async def admin_stats(user: User = Security(bearer.require(role=Role.ADMIN))):
    return {"message": f"Hello admin {user.name}"}
@app.get("/profile")
 async def profile(user: User = Security(bearer.require(role=Role.USER))):
    return {"id": user.id, "name": user.name}
 ```
 `.require()` kwargs are merged over existing ones — new values win on conflict.
 The `prefix` (for `BearerTokenAuth`) and cookie name (for `CookieAuth`) are
 always preserved.
 `.require()` instances work transparently inside `MultiAuth`:
 ```python
 multi = MultiAuth(
    user_bearer.require(role=Role.USER),
    org_bearer.require(role=Role.ADMIN),
 )
 ```
 ## MultiAuth
 [`MultiAuth`](../reference/security.md#fastapi_toolsets.security.MultiAuth) combines
 multiple auth sources into a single callable. Sources are tried in order; the
 first one that finds a credential wins.
 ```python
 from fastapi_toolsets.security import MultiAuth
 multi = MultiAuth(user_bearer, org_bearer, cookie_auth)
@app.get("/data")
 async def data_route(user = Security(multi)):
    return user
 ```
 ### Using `.require()` on MultiAuth
 `MultiAuth` also supports `.require()`, which propagates the kwargs to every
 source that implements it. Sources that do not (e.g. custom `AuthSource`
 subclasses) are passed through unchanged:
 ```python
 multi = MultiAuth(bearer, cookie)
@app.get("/admin")
 async def admin(user: User = Security(multi.require(role=Role.ADMIN))):
    return user
 ```
 This is equivalent to calling `.require()` on each source individually:
 ```python
 # These two are identical
 multi.require(role=Role.ADMIN)
 MultiAuth(
    bearer.require(role=Role.ADMIN),
    cookie.require(role=Role.ADMIN),
 )
 ```
 ### Prefix-based dispatch
 Because `extract()` is pure string matching (no I/O), prefix-based source
 selection is essentially free. Only the matching source's validator (which may
 involve DB or network I/O) is ever called:
 ```python
 user_bearer = BearerTokenAuth(verify_user, prefix="user_")
 org_bearer  = BearerTokenAuth(verify_org,  prefix="org_")
 multi = MultiAuth(user_bearer, org_bearer)
 # "Bearer user_alice" → only verify_user runs, receives "user_alice"
 # "Bearer org_acme"   → only verify_org runs, receives "org_acme"
 ```
 Tokens are stored and compared **with their prefix** — use `generate_token()` on
 each source to issue correctly-prefixed tokens:
 ```python
 user_token = user_bearer.generate_token()  # "user_..."
 org_token  = org_bearer.generate_token()   # "org_..."
 ```
 ---
 [:material-api: API Reference](../reference/security.md)
--- a/docs/reference/db.md
+++ b/docs/reference/db.md
@@ -13,6 +13,9 @@ from fastapi_toolsets.db import (
    create_db_context,
    get_transaction,
    lock_tables,
    m2m_add,
    m2m_remove,
    m2m_set,
    wait_for_row_change,
 )
 ```
@@ -32,3 +35,9 @@ from fastapi_toolsets.db import (
 ## ::: fastapi_toolsets.db.create_database
 ## ::: fastapi_toolsets.db.cleanup_tables
 ## ::: fastapi_toolsets.db.m2m_add
 ## ::: fastapi_toolsets.db.m2m_remove
 ## ::: fastapi_toolsets.db.m2m_set
--- a/docs/reference/security.md
+++ b/docs/reference/security.md
@@ -1,28 +0,0 @@
 # `security`
 Here's the reference for the authentication helpers provided by the `security` module.
 You can import them directly from `fastapi_toolsets.security`:
 ```python
 from fastapi_toolsets.security import (
    AuthSource,
    BearerTokenAuth,
    CookieAuth,
    OAuth2Auth,
    OpenIDAuth,
    MultiAuth,
 )
 ```
 ## ::: fastapi_toolsets.security.AuthSource
 ## ::: fastapi_toolsets.security.BearerTokenAuth
 ## ::: fastapi_toolsets.security.CookieAuth
 ## ::: fastapi_toolsets.security.OAuth2Auth
 ## ::: fastapi_toolsets.security.OpenIDAuth
 ## ::: fastapi_toolsets.security.MultiAuth
--- a/docs_src/examples/authentication/init.py
+++ b/docs_src/examples/authentication/init.py
--- a/docs_src/examples/authentication/app.py
+++ b/docs_src/examples/authentication/app.py
@@ -1,9 +0,0 @@
 from fastapi import FastAPI
 from fastapi_toolsets.exceptions import init_exceptions_handlers
 from .routes import router
 app = FastAPI()
 init_exceptions_handlers(app=app)
 app.include_router(router=router)
--- a/docs_src/examples/authentication/crud.py
+++ b/docs_src/examples/authentication/crud.py
@@ -1,9 +0,0 @@
 from fastapi_toolsets.crud import CrudFactory
 from .models import OAuthAccount, OAuthProvider, Team, User, UserToken
 TeamCrud = CrudFactory(model=Team)
 UserCrud = CrudFactory(model=User)
 UserTokenCrud = CrudFactory(model=UserToken)
 OAuthProviderCrud = CrudFactory(model=OAuthProvider)
 OAuthAccountCrud = CrudFactory(model=OAuthAccount)
--- a/docs_src/examples/authentication/db.py
+++ b/docs_src/examples/authentication/db.py
@@ -1,15 +0,0 @@
 from fastapi import Depends
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
 from fastapi_toolsets.db import create_db_context, create_db_dependency
 DATABASE_URL = "postgresql+asyncpg://postgres:postgres@localhost:5432/postgres"
 engine = create_async_engine(url=DATABASE_URL, future=True)
 async_session_maker = async_sessionmaker(bind=engine, expire_on_commit=False)
 get_db = create_db_dependency(session_maker=async_session_maker)
 get_db_context = create_db_context(session_maker=async_session_maker)
 SessionDep = Depends(get_db)
--- a/docs_src/examples/authentication/models.py
+++ b/docs_src/examples/authentication/models.py
@@ -1,105 +0,0 @@
 import enum
 from datetime import datetime
 from uuid import UUID
 from sqlalchemy import (
    Boolean,
    DateTime,
    Enum,
    ForeignKey,
    Integer,
    String,
    UniqueConstraint,
 )
 from sqlalchemy.dialects.postgresql import UUID as PG_UUID
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
 from fastapi_toolsets.models import TimestampMixin, UUIDMixin
 class Base(DeclarativeBase, UUIDMixin):
    type_annotation_map = {
        str: String(),
        int: Integer(),
        UUID: PG_UUID(as_uuid=True),
        datetime: DateTime(timezone=True),
    }
 class UserRole(enum.Enum):
    admin = "admin"
    moderator = "moderator"
    user = "user"
 class Team(Base, TimestampMixin):
    __tablename__ = "teams"
    name: Mapped[str] = mapped_column(String, unique=True, index=True)
    users: Mapped[list["User"]] = relationship(back_populates="team")
 class User(Base, TimestampMixin):
    __tablename__ = "users"
    username: Mapped[str] = mapped_column(String, unique=True, index=True)
    email: Mapped[str | None] = mapped_column(
        String, unique=True, index=True, nullable=True
    )
    hashed_password: Mapped[str | None] = mapped_column(String, nullable=True)
    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
    role: Mapped[UserRole] = mapped_column(Enum(UserRole), default=UserRole.user)
    team_id: Mapped[UUID | None] = mapped_column(ForeignKey("teams.id"), nullable=True)
    team: Mapped["Team | None"] = relationship(back_populates="users")
    oauth_accounts: Mapped[list["OAuthAccount"]] = relationship(back_populates="user")
    tokens: Mapped[list["UserToken"]] = relationship(back_populates="user")
 class UserToken(Base, TimestampMixin):
    """API tokens for a user (multiple allowed)."""
    __tablename__ = "user_tokens"
    user_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"))
    # Store hashed token value
    token_hash: Mapped[str] = mapped_column(String, unique=True, index=True)
    name: Mapped[str | None] = mapped_column(String, nullable=True)
    expires_at: Mapped[datetime | None] = mapped_column(
        DateTime(timezone=True), nullable=True
    )
    user: Mapped["User"] = relationship(back_populates="tokens")
 class OAuthProvider(Base, TimestampMixin):
    """Configurable OAuth2 / OpenID Connect provider."""
    __tablename__ = "oauth_providers"
    slug: Mapped[str] = mapped_column(String, unique=True, index=True)
    name: Mapped[str] = mapped_column(String)
    client_id: Mapped[str] = mapped_column(String)
    client_secret: Mapped[str] = mapped_column(String)
    discovery_url: Mapped[str] = mapped_column(String, nullable=False)
    scopes: Mapped[str] = mapped_column(String, default="openid email profile")
    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
    accounts: Mapped[list["OAuthAccount"]] = relationship(back_populates="provider")
 class OAuthAccount(Base, TimestampMixin):
    """OAuth2 / OpenID Connect account linked to a user."""
    __tablename__ = "oauth_accounts"
    __table_args__ = (
        UniqueConstraint("provider_id", "subject", name="uq_oauth_provider_subject"),
    )
    user_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"))
    provider_id: Mapped[UUID] = mapped_column(ForeignKey("oauth_providers.id"))
    # OAuth `sub` / OpenID subject identifier
    subject: Mapped[str] = mapped_column(String)
    user: Mapped["User"] = relationship(back_populates="oauth_accounts")
    provider: Mapped["OAuthProvider"] = relationship(back_populates="accounts")
--- a/docs_src/examples/authentication/routes.py
+++ b/docs_src/examples/authentication/routes.py
@@ -1,122 +0,0 @@
 from typing import Annotated
 from uuid import UUID
 import bcrypt
 from fastapi import APIRouter, Form, HTTPException, Response, Security
 from fastapi_toolsets.dependencies import PathDependency
 from .crud import UserCrud, UserTokenCrud
 from .db import SessionDep
 from .models import OAuthProvider, User, UserToken
 from .schemas import (
    ApiTokenCreateRequest,
    ApiTokenResponse,
    RegisterRequest,
    UserCreate,
    UserResponse,
 )
 from .security import auth, cookie_auth, create_api_token
 ProviderDep = PathDependency(
    model=OAuthProvider,
    field=OAuthProvider.slug,
    session_dep=SessionDep,
    param_name="slug",
 )
 def hash_password(password: str) -> str:
    return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
 def verify_password(plain: str, hashed: str) -> bool:
    return bcrypt.checkpw(plain.encode(), hashed.encode())
 router = APIRouter(prefix="/auth")
@router.post("/register", response_model=UserResponse, status_code=201)
 async def register(body: RegisterRequest, session: SessionDep):
    existing = await UserCrud.first(
        session=session, filters=[User.username == body.username]
    )
    if existing:
        raise HTTPException(status_code=409, detail="Username already taken")
    user = await UserCrud.create(
        session=session,
        obj=UserCreate(
            username=body.username,
            email=body.email,
            hashed_password=hash_password(body.password),
        ),
    )
    return user
@router.post("/token", status_code=204)
 async def login(
    session: SessionDep,
    response: Response,
    username: Annotated[str, Form()],
    password: Annotated[str, Form()],
 ):
    user = await UserCrud.first(session=session, filters=[User.username == username])
    if (
        not user
        or not user.hashed_password
        or not verify_password(password, user.hashed_password)
    ):
        raise HTTPException(status_code=401, detail="Invalid credentials")
    if not user.is_active:
        raise HTTPException(status_code=403, detail="Account disabled")
    cookie_auth.set_cookie(response, str(user.id))
@router.post("/logout", status_code=204)
 async def logout(response: Response):
    cookie_auth.delete_cookie(response)
@router.get("/me", response_model=UserResponse)
 async def me(user: User = Security(auth)):
    return user
@router.post("/tokens", response_model=ApiTokenResponse, status_code=201)
 async def create_token(
    body: ApiTokenCreateRequest,
    user: User = Security(auth),
 ):
    raw, token_row = await create_api_token(
        user.id, name=body.name, expires_at=body.expires_at
    )
    return ApiTokenResponse(
        id=token_row.id,
        name=token_row.name,
        expires_at=token_row.expires_at,
        created_at=token_row.created_at,
        token=raw,
    )
@router.delete("/tokens/{token_id}", status_code=204)
 async def revoke_token(
    session: SessionDep,
    token_id: UUID,
    user: User = Security(auth),
 ):
    if not await UserTokenCrud.first(
        session=session,
        filters=[UserToken.id == token_id, UserToken.user_id == user.id],
    ):
        raise HTTPException(status_code=404, detail="Token not found")
    await UserTokenCrud.delete(
        session=session,
        filters=[UserToken.id == token_id, UserToken.user_id == user.id],
    )
--- a/docs_src/examples/authentication/schemas.py
+++ b/docs_src/examples/authentication/schemas.py
@@ -1,64 +0,0 @@
 from datetime import datetime
 from uuid import UUID
 from pydantic import EmailStr
 from fastapi_toolsets.schemas import PydanticBase
 class RegisterRequest(PydanticBase):
    username: str
    password: str
    email: EmailStr | None = None
 class UserResponse(PydanticBase):
    id: UUID
    username: str
    email: str | None
    role: str
    is_active: bool
    model_config = {"from_attributes": True}
 class ApiTokenCreateRequest(PydanticBase):
    name: str | None = None
    expires_at: datetime | None = None
 class ApiTokenResponse(PydanticBase):
    id: UUID
    name: str | None
    expires_at: datetime | None
    created_at: datetime
    # Only populated on creation
    token: str | None = None
    model_config = {"from_attributes": True}
 class OAuthProviderResponse(PydanticBase):
    slug: str
    name: str
    model_config = {"from_attributes": True}
 class UserCreate(PydanticBase):
    username: str
    email: str | None = None
    hashed_password: str | None = None
 class UserTokenCreate(PydanticBase):
    user_id: UUID
    token_hash: str
    name: str | None = None
    expires_at: datetime | None = None
 class OAuthAccountCreate(PydanticBase):
    user_id: UUID
    provider_id: UUID
    subject: str
--- a/docs_src/examples/authentication/security.py
+++ b/docs_src/examples/authentication/security.py
@@ -1,100 +0,0 @@
 import hashlib
 from datetime import datetime, timezone
 from uuid import UUID
 from fastapi import HTTPException
 from sqlalchemy.orm import selectinload
 from fastapi_toolsets.exceptions import UnauthorizedError
 from fastapi_toolsets.security import (
    APIKeyHeaderAuth,
    BearerTokenAuth,
    CookieAuth,
    MultiAuth,
 )
 from .crud import UserCrud, UserTokenCrud
 from .db import get_db_context
 from .models import User, UserRole, UserToken
 from .schemas import UserTokenCreate
 SESSION_COOKIE = "session"
 SECRET_KEY = "123456789"
 def _hash_token(token: str) -> str:
    return hashlib.sha256(token.encode()).hexdigest()
 async def _verify_token(token: str, role: UserRole | None = None) -> User:
    async with get_db_context() as db:
        user_token = await UserTokenCrud.first(
            session=db,
            filters=[UserToken.token_hash == _hash_token(token)],
            load_options=[selectinload(UserToken.user)],
        )
        if user_token is None or not user_token.user.is_active:
            raise UnauthorizedError()
        if user_token.expires_at and user_token.expires_at < datetime.now(timezone.utc):
            raise UnauthorizedError()
        user = user_token.user
        if role is not None and user.role != role:
            raise HTTPException(status_code=403, detail="Insufficient permissions")
        return user
 async def _verify_cookie(user_id: str, role: UserRole | None = None) -> User:
    async with get_db_context() as db:
        user = await UserCrud.first(
            session=db,
            filters=[User.id == UUID(user_id)],
        )
    if not user or not user.is_active:
        raise UnauthorizedError()
    if role is not None and user.role != role:
        raise HTTPException(status_code=403, detail="Insufficient permissions")
    return user
 bearer_auth = BearerTokenAuth(
    validator=_verify_token,
    prefix="ctf_",
 )
 header_auth = APIKeyHeaderAuth(
    name="X-API-Key",
    validator=_verify_token,
 )
 cookie_auth = CookieAuth(
    name=SESSION_COOKIE,
    validator=_verify_cookie,
    secret_key=SECRET_KEY,
 )
 auth = MultiAuth(bearer_auth, header_auth, cookie_auth)
 async def create_api_token(
    user_id: UUID,
    *,
    name: str | None = None,
    expires_at: datetime | None = None,
 ) -> tuple[str, UserToken]:
    raw = bearer_auth.generate_token()
    async with get_db_context() as db:
        token_row = await UserTokenCrud.create(
            session=db,
            obj=UserTokenCreate(
                user_id=user_id,
                token_hash=_hash_token(raw),
                name=name,
                expires_at=expires_at,
            ),
        )
    return raw, token_row
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-toolsets"
-version = "3.0.3"
+version = "3.1.0"
 description = "Production-ready utilities for FastAPI applications"
 readme = "README.md"
 license = "MIT"
@@ -66,7 +66,6 @@ manager = "fastapi_toolsets.cli.app:cli"
 dev = [
    {include-group = "tests"},
    {include-group = "docs"},
    {include-group = "docs-src"},
    "fastapi-toolsets[all]",
    "prek>=0.3.8",
    "ruff>=0.1.0",
@@ -85,9 +84,6 @@ docs = [
    "mkdocstrings-python>=2.0.2",
    "zensical>=0.0.30",
 ]
 docs-src = [
    "bcrypt>=4.0.0",
 ]
 [build-system]
 requires = ["uv_build>=0.10,<0.12.0"]
--- a/src/fastapi_toolsets/init.py
+++ b/src/fastapi_toolsets/init.py
@@ -21,4 +21,4 @@ Example usage:
        return Response(data={"user": user.username}, message="Success")
 """
-__version__ = "3.0.3"
+__version__ = "3.1.0"
--- a/src/fastapi_toolsets/crud/init.py
+++ b/src/fastapi_toolsets/crud/init.py
@@ -15,13 +15,12 @@ from ..types import (
    OrderFieldType,
    SearchFieldType,
 )
-from .factory import AsyncCrud, CrudFactory, lateral_load
+from .factory import AsyncCrud, CrudFactory
 from .search import SearchConfig, get_searchable_fields
 __all__ = [
    "AsyncCrud",
    "CrudFactory",
    "lateral_load",
    "FacetFieldType",
    "get_searchable_fields",
    "InvalidFacetFilterError",
--- a/src/fastapi_toolsets/crud/factory.py
+++ b/src/fastapi_toolsets/crud/factory.py
@@ -10,32 +10,15 @@ from collections.abc import Awaitable, Callable, Sequence
 from datetime import date, datetime
 from decimal import Decimal
 from enum import Enum
-from typing import Any, ClassVar, Generic, Literal, NamedTuple, Self, cast, overload
+from typing import Any, ClassVar, Generic, Literal, Self, cast, overload
 from fastapi import Query
 from pydantic import BaseModel
-from sqlalchemy import (
+from sqlalchemy import Date, DateTime, Float, Integer, Numeric, Uuid, and_, func, select
    Date,
    DateTime,
    Float,
    Integer,
    Numeric,
    Uuid,
    and_,
    func,
    select,
    true,
 )
 from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.exc import NoResultFound
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import (
+from sqlalchemy.orm import DeclarativeBase, QueryableAttribute, selectinload
    DeclarativeBase,
    QueryableAttribute,
    RelationshipProperty,
    contains_eager,
    selectinload,
 )
 from sqlalchemy.sql.base import ExecutableOption
 from sqlalchemy.sql.roles import WhereHavingRole
@@ -52,7 +35,6 @@ from ..schemas import (
 from ..types import (
    FacetFieldType,
    JoinType,
    LateralJoinType,
    M2MFieldType,
    ModelType,
    OrderByClause,
@@ -133,78 +115,6 @@ def _apply_joins(q: Any, joins: JoinType | None, outer_join: bool) -> Any:
    return q
 class _ResolvedLateral(NamedTuple):
    joins: LateralJoinType
    eager: list[ExecutableOption]
 class _LateralLoad:
    """Marker used inside ``default_load_options`` for lateral join loading.
    Supports only Many:One and One:One relationships (single row per parent).
    """
    __slots__ = ("rel_attr",)
    def __init__(self, rel_attr: QueryableAttribute) -> None:
        prop = rel_attr.property
        if not isinstance(prop, RelationshipProperty):
            raise TypeError(
                f"lateral_load() requires a relationship attribute, got {type(prop).__name__}. "
                "Example: lateral_load(User.team)"
            )
        if prop.secondary is not None:
            raise ValueError(
                f"lateral_load({rel_attr}) does not support Many:Many relationships. "
                "Use selectinload() instead."
            )
        if prop.uselist:
            raise ValueError(
                f"lateral_load({rel_attr}) does not support One:Many relationships. "
                "Use selectinload() instead."
            )
        self.rel_attr = rel_attr
 def lateral_load(rel_attr: QueryableAttribute) -> _LateralLoad:
    """Mark a Many:One or One:One relationship for lateral join loading.
    Raises ``ValueError`` for One:Many or Many:Many relationships.
    """
    return _LateralLoad(rel_attr)
 def _build_lateral_from_relationship(
    rel_attr: QueryableAttribute,
 ) -> tuple[Any, Any, ExecutableOption]:
    """Introspect a Many:One relationship and build (lateral_subquery, true(), contains_eager)."""
    prop = rel_attr.property
    target_class = prop.mapper.class_
    parent_class = prop.parent.class_
    conditions = [
        getattr(target_class, remote_col.key) == getattr(parent_class, local_col.key)
        for local_col, remote_col in prop.local_remote_pairs
    ]
    lateral_sub = (
        select(target_class)
        .where(and_(*conditions))
        .correlate(parent_class)
        .lateral(f"_lateral_{prop.key}")
    )
    return lateral_sub, true(), contains_eager(rel_attr, alias=lateral_sub)
 def _apply_lateral_joins(q: Any, lateral_joins: LateralJoinType | None) -> Any:
    """Apply lateral subqueries as LEFT JOIN LATERAL to preserve all parent rows."""
    if not lateral_joins:
        return q
    for subquery, condition in lateral_joins:
        q = q.outerjoin(subquery, condition)
    return q
 def _apply_search_joins(q: Any, search_joins: list[Any]) -> Any:
    """Apply relationship-based outer joins (from search/filter_by) to a query."""
    seen: set[str] = set()
@@ -222,17 +132,12 @@ class AsyncCrud(Generic[ModelType]):
    Subclass this and set the `model` class variable, or use `CrudFactory`.
    """
    _resolved_lateral: ClassVar[_ResolvedLateral | None] = None
    model: ClassVar[type[DeclarativeBase]]
    searchable_fields: ClassVar[Sequence[SearchFieldType] | None] = None
    facet_fields: ClassVar[Sequence[FacetFieldType] | None] = None
    order_fields: ClassVar[Sequence[OrderFieldType] | None] = None
    m2m_fields: ClassVar[M2MFieldType | None] = None
-    default_load_options: ClassVar[Sequence[ExecutableOption | _LateralLoad] | None] = (
+    default_load_options: ClassVar[Sequence[ExecutableOption] | None] = None
        None
    )
    lateral_joins: ClassVar[LateralJoinType | None] = None
    cursor_column: ClassVar[Any | None] = None
    @classmethod
@@ -256,48 +161,14 @@ class AsyncCrud(Generic[ModelType]):
            ):
                cls.searchable_fields = [pk_col, *raw_fields]
        raw_default_opts = cls.__dict__.get("default_load_options", None)
        if raw_default_opts:
            joins: LateralJoinType = []
            eager: list[ExecutableOption] = []
            clean: list[ExecutableOption] = []
            for opt in raw_default_opts:
                if isinstance(opt, _LateralLoad):
                    lat_sub, condition, eager_opt = _build_lateral_from_relationship(
                        opt.rel_attr
                    )
                    joins.append((lat_sub, condition))
                    eager.append(eager_opt)
                else:
                    clean.append(opt)
            if joins:
                cls._resolved_lateral = _ResolvedLateral(joins=joins, eager=eager)
                cls.default_load_options = clean or None
    @classmethod
    def _get_lateral_joins(cls) -> LateralJoinType | None:
        """Merge manual lateral_joins with ones resolved from default_load_options."""
        resolved = cls._resolved_lateral
        all_lateral = [
            *(cls.lateral_joins or []),
            *(resolved.joins if resolved else []),
        ]
        return all_lateral or None
    @classmethod
    def _resolve_load_options(
        cls, load_options: Sequence[ExecutableOption] | None
    ) -> Sequence[ExecutableOption] | None:
-        """Return merged load options."""
+        """Return load_options if provided, else fall back to default_load_options."""
        if load_options is not None:
-            return list(load_options) or None
+            return load_options
-        resolved = cls._resolved_lateral
+        return cls.default_load_options
        # default_load_options is cleaned of _LateralLoad markers in __init_subclass__,
        # but its declared type still includes them — cast to reflect the runtime invariant.
        base = cast(list[ExecutableOption], cls.default_load_options or [])
        lateral = resolved.eager if resolved else []
        merged = [*base, *lateral]
        return merged or None
    @classmethod
    async def _reload_with_options(
@@ -990,8 +861,6 @@ class AsyncCrud(Generic[ModelType]):
        """
        q = select(cls.model)
        q = _apply_joins(q, joins, outer_join)
        if load_options is None:
            q = _apply_lateral_joins(q, cls._get_lateral_joins())
        q = q.where(and_(*filters))
        if resolved := cls._resolve_load_options(load_options):
            q = q.options(*resolved)
@@ -1064,8 +933,6 @@ class AsyncCrud(Generic[ModelType]):
        """
        q = select(cls.model)
        q = _apply_joins(q, joins, outer_join)
        if load_options is None:
            q = _apply_lateral_joins(q, cls._get_lateral_joins())
        if filters:
            q = q.where(and_(*filters))
        if resolved := cls._resolve_load_options(load_options):
@@ -1111,8 +978,6 @@ class AsyncCrud(Generic[ModelType]):
        """
        q = select(cls.model)
        q = _apply_joins(q, joins, outer_join)
        if load_options is None:
            q = _apply_lateral_joins(q, cls._get_lateral_joins())
        if filters:
            q = q.where(and_(*filters))
        if resolved := cls._resolve_load_options(load_options):
@@ -1435,10 +1300,6 @@ class AsyncCrud(Generic[ModelType]):
        # Apply explicit joins
        q = _apply_joins(q, joins, outer_join)
        # Apply lateral joins (Many:One relationship loading, excluded from count query)
        if load_options is None:
            q = _apply_lateral_joins(q, cls._get_lateral_joins())
        # Apply search joins (always outer joins for search)
        q = _apply_search_joins(q, search_joins)
@@ -1537,9 +1398,7 @@ class AsyncCrud(Generic[ModelType]):
                tables.
            outer_join: Use LEFT OUTER JOIN instead of INNER JOIN.
            load_options: SQLAlchemy loader options. Falls back to
-                ``default_load_options`` (including any lateral joins) when not
+                ``default_load_options`` when not provided.
                provided. When explicitly supplied, the caller takes full control
                and lateral joins are skipped.
            order_by: Additional ordering applied after the cursor column.
            items_per_page: Number of items per page (default 20).
            search: Search query string or SearchConfig object.
@@ -1596,10 +1455,6 @@ class AsyncCrud(Generic[ModelType]):
        # Apply explicit joins
        q = _apply_joins(q, joins, outer_join)
        # Apply lateral joins (Many:One relationship loading)
        if load_options is None:
            q = _apply_lateral_joins(q, cls._get_lateral_joins())
        # Apply search joins (always outer joins)
        q = _apply_search_joins(q, search_joins)
--- a/src/fastapi_toolsets/db.py
+++ b/src/fastapi_toolsets/db.py
@@ -4,11 +4,13 @@ import asyncio
 from collections.abc import AsyncGenerator, Callable
 from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from enum import Enum
-from typing import Any, TypeVar
+from typing import Any, TypeVar, cast
-from sqlalchemy import text
+from sqlalchemy import Table, delete, text, tuple_
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
 from sqlalchemy.orm.relationships import RelationshipProperty
 from .exceptions import NotFoundError
@@ -20,6 +22,9 @@ __all__ = [
    "create_db_dependency",
    "get_transaction",
    "lock_tables",
    "m2m_add",
    "m2m_remove",
    "m2m_set",
    "wait_for_row_change",
 ]
@@ -339,3 +344,140 @@ async def wait_for_row_change(
        current = {col: getattr(instance, col) for col in watch_cols}
        if current != initial:
            return instance
 def _m2m_prop(rel_attr: QueryableAttribute) -> RelationshipProperty:  # type: ignore[type-arg]
    """Return the validated M2M RelationshipProperty for *rel_attr*.
    Raises TypeError if *rel_attr* is not a Many-to-Many relationship.
    """
    prop = rel_attr.property
    if not isinstance(prop, RelationshipProperty) or prop.secondary is None:
        raise TypeError(
            f"m2m helpers require a Many-to-Many relationship attribute, "
            f"got {rel_attr!r}. Use a relationship with a secondary table."
        )
    return prop
 async def m2m_add(
    session: AsyncSession,
    instance: DeclarativeBase,
    rel_attr: QueryableAttribute,
    *related: DeclarativeBase,
    ignore_conflicts: bool = False,
 ) -> None:
    """Insert rows into a Many-to-Many association table without loading the ORM collection.
    Args:
        session: DB async session.
        instance: The "owner" side model instance (e.g. the ``A`` in ``A.b_list``).
        rel_attr: The M2M relationship attribute on the model class (e.g. ``A.b_list``).
        *related: One or more related instances to associate with ``instance``.
        ignore_conflicts: When ``True``, silently skip rows that already exist
            in the association table (``ON CONFLICT DO NOTHING``).
    Raises:
        TypeError: If ``rel_attr`` is not a Many-to-Many relationship.
    """
    prop = _m2m_prop(rel_attr)
    if not related:
        return
    secondary = cast(Table, prop.secondary)
    assert secondary is not None  # guaranteed by _m2m_prop
    sync_pairs = prop.secondary_synchronize_pairs
    assert sync_pairs is not None  # set whenever secondary is set
    # synchronize_pairs:           [(parent_col, assoc_col), ...]
    # secondary_synchronize_pairs: [(related_col, assoc_col), ...]
    rows: list[dict[str, Any]] = []
    for rel_instance in related:
        row: dict[str, Any] = {}
        for parent_col, assoc_col in prop.synchronize_pairs:
            row[assoc_col.name] = getattr(instance, cast(str, parent_col.key))
        for related_col, assoc_col in sync_pairs:
            row[assoc_col.name] = getattr(rel_instance, cast(str, related_col.key))
        rows.append(row)
    stmt = pg_insert(secondary).values(rows)
    if ignore_conflicts:
        stmt = stmt.on_conflict_do_nothing()
    await session.execute(stmt)
 async def m2m_remove(
    session: AsyncSession,
    instance: DeclarativeBase,
    rel_attr: QueryableAttribute,
    *related: DeclarativeBase,
 ) -> None:
    """Remove rows from a Many-to-Many association table without loading the ORM collection.
    Args:
        session: DB async session.
        instance: The "owner" side model instance (e.g. the ``A`` in ``A.b_list``).
        rel_attr: The M2M relationship attribute on the model class (e.g. ``A.b_list``).
        *related: One or more related instances to disassociate from ``instance``.
    Raises:
        TypeError: If ``rel_attr`` is not a Many-to-Many relationship.
    """
    prop = _m2m_prop(rel_attr)
    if not related:
        return
    secondary = cast(Table, prop.secondary)
    assert secondary is not None  # guaranteed by _m2m_prop
    related_pairs = prop.secondary_synchronize_pairs
    assert related_pairs is not None  # set whenever secondary is set
    parent_where = [
        assoc_col == getattr(instance, cast(str, parent_col.key))
        for parent_col, assoc_col in prop.synchronize_pairs
    ]
    if len(related_pairs) == 1:
        related_col, assoc_col = related_pairs[0]
        related_values = [getattr(r, cast(str, related_col.key)) for r in related]
        related_where = assoc_col.in_(related_values)
    else:
        assoc_cols = [ac for _, ac in related_pairs]
        rel_cols = [rc for rc, _ in related_pairs]
        related_values_t = [
            tuple(getattr(r, cast(str, rc.key)) for rc in rel_cols) for r in related
        ]
        related_where = tuple_(*assoc_cols).in_(related_values_t)
    await session.execute(delete(secondary).where(*parent_where, related_where))
 async def m2m_set(
    session: AsyncSession,
    instance: DeclarativeBase,
    rel_attr: QueryableAttribute,
    *related: DeclarativeBase,
 ) -> None:
    """Replace the entire Many-to-Many association set atomically.
    Args:
        session: DB async session.
        instance: The "owner" side model instance (e.g. the ``A`` in ``A.b_list``).
        rel_attr: The M2M relationship attribute on the model class (e.g. ``A.b_list``).
        *related: The new complete set of related instances.
    Raises:
        TypeError: If ``rel_attr`` is not a Many-to-Many relationship.
    """
    prop = _m2m_prop(rel_attr)
    secondary = cast(Table, prop.secondary)
    assert secondary is not None  # guaranteed by _m2m_prop
    parent_where = [
        assoc_col == getattr(instance, cast(str, parent_col.key))
        for parent_col, assoc_col in prop.synchronize_pairs
    ]
    await session.execute(delete(secondary).where(*parent_where))
    if related:
        await m2m_add(session, instance, rel_attr, *related)
--- a/src/fastapi_toolsets/fixtures/init.py
+++ b/src/fastapi_toolsets/fixtures/init.py
@@ -2,12 +2,18 @@
 from .enum import LoadStrategy
 from .registry import Context, FixtureRegistry
-from .utils import get_obj_by_attr, load_fixtures, load_fixtures_by_context
+from .utils import (
    get_field_by_attr,
    get_obj_by_attr,
    load_fixtures,
    load_fixtures_by_context,
 )
 __all__ = [
    "Context",
    "FixtureRegistry",
    "LoadStrategy",
    "get_field_by_attr",
    "get_obj_by_attr",
    "load_fixtures",
    "load_fixtures_by_context",
--- a/src/fastapi_toolsets/fixtures/utils.py
+++ b/src/fastapi_toolsets/fixtures/utils.py
@@ -250,6 +250,31 @@ def get_obj_by_attr(
        ) from None
 def get_field_by_attr(
    fixtures: Callable[[], Sequence[ModelType]],
    attr_name: str,
    value: Any,
    *,
    field: str = "id",
 ) -> Any:
    """Get a single field value from a fixture object matched by an attribute.
    Args:
        fixtures: A fixture function registered via ``@registry.register``
            that returns a sequence of SQLAlchemy model instances.
        attr_name: Name of the attribute to match against.
        value: Value to match.
        field: Attribute name to return from the matched object (default: ``"id"``).
    Returns:
        The value of ``field`` on the first matching model instance.
    Raises:
        StopIteration: If no matching object is found in the fixture group.
    """
    return getattr(get_obj_by_attr(fixtures, attr_name, value), field)
 async def load_fixtures(
    session: AsyncSession,
    registry: FixtureRegistry,
--- a/src/fastapi_toolsets/pytest/plugin.py
+++ b/src/fastapi_toolsets/pytest/plugin.py
@@ -1,11 +1,13 @@
 """Pytest plugin for using FixtureRegistry fixtures in tests."""
 from collections.abc import Callable, Sequence
-from typing import Any
+from typing import Any, cast
 import pytest
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import DeclarativeBase, selectinload
 from sqlalchemy.orm.interfaces import ExecutableOption, ORMOption
 from ..db import get_transaction
 from ..fixtures import FixtureRegistry, LoadStrategy
@@ -112,7 +114,7 @@ def _create_fixture_function(
                elif strategy == LoadStrategy.MERGE:
                    merged = await session.merge(instance)
                    loaded.append(merged)
-                elif strategy == LoadStrategy.SKIP_EXISTING:
+                elif strategy == LoadStrategy.SKIP_EXISTING:  # pragma: no branch
                    pk = _get_primary_key(instance)
                    if pk is not None:
                        existing = await session.get(type(instance), pk)
@@ -125,6 +127,11 @@ def _create_fixture_function(
                        session.add(instance)
                        loaded.append(instance)
        if loaded:  # pragma: no branch
            load_options = _relationship_load_options(type(loaded[0]))
            if load_options:
                return await _reload_with_relationships(session, loaded, load_options)
        return loaded
    # Update function signature to include dependencies
@@ -141,6 +148,54 @@ def _create_fixture_function(
    return created_func
 def _relationship_load_options(model: type[DeclarativeBase]) -> list[ExecutableOption]:
    """Build selectinload options for all direct relationships on a model."""
    return [
        selectinload(getattr(model, rel.key)) for rel in model.__mapper__.relationships
    ]
 async def _reload_with_relationships(
    session: AsyncSession,
    instances: list[DeclarativeBase],
    load_options: list[ExecutableOption],
 ) -> list[DeclarativeBase]:
    """Reload instances in a single bulk query with relationship eager-loading.
    Uses one SELECT … WHERE pk IN (…) so selectinload can batch all relationship
    queries — 1 + N_relationships round-trips regardless of how many instances
    there are, instead of one session.get() per instance.
    Preserves the original insertion order.
    """
    model = type(instances[0])
    mapper = model.__mapper__
    pk_cols = mapper.primary_key
    if len(pk_cols) == 1:
        pk_attr = getattr(model, pk_cols[0].key)
        pks = [getattr(inst, pk_cols[0].key) for inst in instances]
        result = await session.execute(
            select(model).where(pk_attr.in_(pks)).options(*load_options)
        )
        by_pk = {getattr(row, pk_cols[0].key): row for row in result.unique().scalars()}
        return [by_pk[pk] for pk in pks]
    # Composite PK: fall back to per-instance reload
    reloaded: list[DeclarativeBase] = []
    for instance in instances:
        pk = _get_primary_key(instance)
        refreshed = await session.get(
            model,
            pk,
            options=cast(list[ORMOption], load_options),
            populate_existing=True,
        )
        if refreshed is not None:  # pragma: no branch
            reloaded.append(refreshed)
    return reloaded
 def _get_primary_key(instance: DeclarativeBase) -> Any | None:
    """Get the primary key value of a model instance."""
    mapper = instance.__class__.__mapper__
--- a/src/fastapi_toolsets/security/init.py
+++ b/src/fastapi_toolsets/security/init.py
@@ -1,24 +0,0 @@
 """Authentication helpers for FastAPI using Security()."""
 from .abc import AuthSource
 from .oauth import (
    oauth_build_authorization_redirect,
    oauth_decode_state,
    oauth_encode_state,
    oauth_fetch_userinfo,
    oauth_resolve_provider_urls,
 )
 from .sources import APIKeyHeaderAuth, BearerTokenAuth, CookieAuth, MultiAuth
 __all__ = [
    "APIKeyHeaderAuth",
    "AuthSource",
    "BearerTokenAuth",
    "CookieAuth",
    "MultiAuth",
    "oauth_build_authorization_redirect",
    "oauth_decode_state",
    "oauth_encode_state",
    "oauth_fetch_userinfo",
    "oauth_resolve_provider_urls",
 ]
--- a/src/fastapi_toolsets/security/abc.py
+++ b/src/fastapi_toolsets/security/abc.py
@@ -1,53 +0,0 @@
 """Abstract base class for authentication sources."""
 import inspect
 from abc import ABC, abstractmethod
 from typing import Any, Callable
 from fastapi import Request
 from fastapi.security import SecurityScopes
 from fastapi_toolsets.exceptions import UnauthorizedError
 def _ensure_async(fn: Callable[..., Any]) -> Callable[..., Any]:
    """Wrap *fn* so it can always be awaited, caching the coroutine check at init time."""
    if inspect.iscoroutinefunction(fn):
        return fn
    async def wrapper(*args: Any, **kwargs: Any) -> Any:
        return fn(*args, **kwargs)
    return wrapper
 class AuthSource(ABC):
    """Abstract base class for authentication sources."""
    def __init__(self) -> None:
        """Set up the default FastAPI dependency signature."""
        source = self
        async def _call(
            request: Request,
            security_scopes: SecurityScopes,  # noqa: ARG001
        ) -> Any:
            credential = await source.extract(request)
            if credential is None:
                raise UnauthorizedError()
            return await source.authenticate(credential)
        self._call_fn: Callable[..., Any] = _call
        self.__signature__ = inspect.signature(_call)
    @abstractmethod
    async def extract(self, request: Request) -> str | None:
        """Extract the raw credential from the request without validating."""
    @abstractmethod
    async def authenticate(self, credential: str) -> Any:
        """Validate a credential and return the authenticated identity."""
    async def __call__(self, **kwargs: Any) -> Any:
        """FastAPI dependency dispatch."""
        return await self._call_fn(**kwargs)
--- a/src/fastapi_toolsets/security/oauth.py
+++ b/src/fastapi_toolsets/security/oauth.py
@@ -1,140 +0,0 @@
 """OAuth 2.0 / OIDC helper utilities."""
 import base64
 from typing import Any
 from urllib.parse import urlencode
 import httpx
 from fastapi.responses import RedirectResponse
 _discovery_cache: dict[str, dict] = {}
 async def oauth_resolve_provider_urls(
    discovery_url: str,
 ) -> tuple[str, str, str | None]:
    """Fetch the OIDC discovery document and return endpoint URLs.
    Args:
        discovery_url: URL of the provider's ``/.well-known/openid-configuration``.
    Returns:
        A ``(authorization_url, token_url, userinfo_url)`` tuple.
        *userinfo_url* is ``None`` when the provider does not advertise one.
    """
    if discovery_url not in _discovery_cache:
        async with httpx.AsyncClient() as client:
            resp = await client.get(discovery_url)
            resp.raise_for_status()
            _discovery_cache[discovery_url] = resp.json()
    cfg = _discovery_cache[discovery_url]
    return (
        cfg["authorization_endpoint"],
        cfg["token_endpoint"],
        cfg.get("userinfo_endpoint"),
    )
 async def oauth_fetch_userinfo(
    *,
    token_url: str,
    userinfo_url: str,
    code: str,
    client_id: str,
    client_secret: str,
    redirect_uri: str,
 ) -> dict[str, Any]:
    """Exchange an authorization code for tokens and return the userinfo payload.
    Performs the two-step OAuth 2.0 / OIDC token exchange:
    1. POSTs the authorization *code* to *token_url* to obtain an access token.
    2. GETs *userinfo_url* using that access token as a Bearer credential.
    Args:
        token_url: Provider's token endpoint.
        userinfo_url: Provider's userinfo endpoint.
        code: Authorization code received from the provider's callback.
        client_id: OAuth application client ID.
        client_secret: OAuth application client secret.
        redirect_uri: Redirect URI that was used in the authorization request.
    Returns:
        The JSON payload returned by the userinfo endpoint as a plain ``dict``.
    """
    async with httpx.AsyncClient() as client:
        token_resp = await client.post(
            token_url,
            data={
                "grant_type": "authorization_code",
                "code": code,
                "client_id": client_id,
                "client_secret": client_secret,
                "redirect_uri": redirect_uri,
            },
            headers={"Accept": "application/json"},
        )
        token_resp.raise_for_status()
        access_token = token_resp.json()["access_token"]
        userinfo_resp = await client.get(
            userinfo_url,
            headers={"Authorization": f"Bearer {access_token}"},
        )
        userinfo_resp.raise_for_status()
        return userinfo_resp.json()
 def oauth_build_authorization_redirect(
    authorization_url: str,
    *,
    client_id: str,
    scopes: str,
    redirect_uri: str,
    destination: str,
 ) -> RedirectResponse:
    """Return an OAuth 2.0 authorization ``RedirectResponse``.
    Args:
        authorization_url: Provider's authorization endpoint.
        client_id: OAuth application client ID.
        scopes: Space-separated list of requested scopes.
        redirect_uri: URI the provider should redirect back to after authorization.
        destination: URL the user should be sent to after the full OAuth flow
            completes (encoded as ``state``).
    Returns:
        A :class:`~fastapi.responses.RedirectResponse` to the provider's
        authorization page.
    """
    params = urlencode(
        {
            "client_id": client_id,
            "response_type": "code",
            "scope": scopes,
            "redirect_uri": redirect_uri,
            "state": oauth_encode_state(destination),
        }
    )
    return RedirectResponse(f"{authorization_url}?{params}")
 def oauth_encode_state(url: str) -> str:
    """Base64url-encode a URL to embed as an OAuth ``state`` parameter."""
    return base64.urlsafe_b64encode(url.encode()).decode()
 def oauth_decode_state(state: str | None, *, fallback: str) -> str:
    """Decode a base64url OAuth ``state`` parameter.
    Handles missing padding (some providers strip ``=``).
    Returns *fallback* if *state* is absent, the literal string ``"null"``,
    or cannot be decoded.
    """
    if not state or state == "null":
        return fallback
    try:
        padded = state + "=" * (4 - len(state) % 4)
        return base64.urlsafe_b64decode(padded).decode()
    except Exception:
        return fallback
--- a/src/fastapi_toolsets/security/sources/init.py
+++ b/src/fastapi_toolsets/security/sources/init.py
@@ -1,8 +0,0 @@
 """Built-in authentication source implementations."""
 from .header import APIKeyHeaderAuth
 from .bearer import BearerTokenAuth
 from .cookie import CookieAuth
 from .multi import MultiAuth
 __all__ = ["APIKeyHeaderAuth", "BearerTokenAuth", "CookieAuth", "MultiAuth"]
--- a/src/fastapi_toolsets/security/sources/bearer.py
+++ b/src/fastapi_toolsets/security/sources/bearer.py
@@ -1,120 +0,0 @@
 """Bearer token authentication source."""
 import inspect
 import secrets
 from typing import Annotated, Any, Callable
 from fastapi import Depends
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer, SecurityScopes
 from fastapi_toolsets.exceptions import UnauthorizedError
 from ..abc import AuthSource, _ensure_async
 class BearerTokenAuth(AuthSource):
    """Bearer token authentication source.
    Wraps :class:`fastapi.security.HTTPBearer` for OpenAPI documentation.
    The validator is called as ``await validator(credential, **kwargs)``
    where ``kwargs`` are the extra keyword arguments provided at instantiation.
    Args:
        validator: Sync or async callable that receives the credential and any
            extra keyword arguments, and returns the authenticated identity
            (e.g. a ``User`` model). Should raise
            :class:`~fastapi_toolsets.exceptions.UnauthorizedError` on failure.
        prefix: Optional token prefix (e.g. ``"user_"``). If set, only tokens
            whose value starts with this prefix are matched. The prefix is
            **kept** in the value passed to the validator — store and compare
            tokens with their prefix included. Use :meth:`generate_token` to
            create correctly-prefixed tokens. This enables multiple
            ``BearerTokenAuth`` instances in the same app (e.g. ``"user_"``
            for user tokens, ``"org_"`` for org tokens).
        **kwargs: Extra keyword arguments forwarded to the validator on every
            call (e.g. ``role=Role.ADMIN``).
    """
    def __init__(
        self,
        validator: Callable[..., Any],
        *,
        prefix: str | None = None,
        **kwargs: Any,
    ) -> None:
        self._validator = _ensure_async(validator)
        self._prefix = prefix
        self._kwargs = kwargs
        self._scheme = HTTPBearer(auto_error=False)
        async def _call(
            security_scopes: SecurityScopes,  # noqa: ARG001
            credentials: Annotated[
                HTTPAuthorizationCredentials | None, Depends(self._scheme)
            ] = None,
        ) -> Any:
            if credentials is None:
                raise UnauthorizedError()
            return await self._validate(credentials.credentials)
        self._call_fn = _call
        self.__signature__ = inspect.signature(_call)
    async def _validate(self, token: str) -> Any:
        """Check prefix and call the validator."""
        if self._prefix is not None and not token.startswith(self._prefix):
            raise UnauthorizedError()
        return await self._validator(token, **self._kwargs)
    async def extract(self, request: Any) -> str | None:
        """Extract the raw credential from the request without validating.
        Returns ``None`` if no ``Authorization: Bearer`` header is present,
        the token is empty, or the token does not match the configured prefix.
        The prefix is included in the returned value.
        """
        auth = request.headers.get("Authorization", "")
        if not auth.startswith("Bearer "):
            return None
        token = auth[7:]
        if not token:
            return None
        if self._prefix is not None and not token.startswith(self._prefix):
            return None
        return token
    async def authenticate(self, credential: str) -> Any:
        """Validate a credential and return the identity.
        Calls ``await validator(credential, **kwargs)`` where ``kwargs`` are
        the extra keyword arguments provided at instantiation.
        """
        return await self._validate(credential)
    def require(self, **kwargs: Any) -> "BearerTokenAuth":
        """Return a new instance with additional (or overriding) validator kwargs."""
        return BearerTokenAuth(
            self._validator,
            prefix=self._prefix,
            **{**self._kwargs, **kwargs},
        )
    def generate_token(self, nbytes: int = 32) -> str:
        """Generate a secure random token for this auth source.
        Returns a URL-safe random token. If a prefix is configured it is
        prepended — the returned value is what you store in your database
        and return to the client as-is.
        Args:
            nbytes: Number of random bytes before base64 encoding. The
                resulting string is ``ceil(nbytes * 4 / 3)`` characters
                (43 chars for the default 32 bytes). Defaults to 32.
        Returns:
            A ready-to-use token string (e.g. ``"user_Xk3..."``).
        """
        token = secrets.token_urlsafe(nbytes)
        if self._prefix is not None:
            return f"{self._prefix}{token}"
        return token
--- a/src/fastapi_toolsets/security/sources/cookie.py
+++ b/src/fastapi_toolsets/security/sources/cookie.py
@@ -1,139 +0,0 @@
 """Cookie-based authentication source."""
 import base64
 import hashlib
 import hmac
 import inspect
 import json
 import time
 from typing import Annotated, Any, Callable
 from fastapi import Depends, Request, Response
 from fastapi.security import APIKeyCookie, SecurityScopes
 from fastapi_toolsets.exceptions import UnauthorizedError
 from ..abc import AuthSource, _ensure_async
 class CookieAuth(AuthSource):
    """Cookie-based authentication source.
    Wraps :class:`fastapi.security.APIKeyCookie` for OpenAPI documentation.
    Optionally signs the cookie with HMAC-SHA256 to provide stateless, tamper-
    proof sessions without any database entry.
    Args:
        name: Cookie name.
        validator: Sync or async callable that receives the cookie value
            (plain, after signature verification when ``secret_key`` is set)
            and any extra keyword arguments, and returns the authenticated
            identity.
        secret_key: When provided, the cookie is HMAC-SHA256 signed.
            :meth:`set_cookie` embeds an expiry and signs the payload;
            :meth:`extract` verifies the signature and expiry before handing
            the plain value to the validator.  When ``None`` (default), the raw
            cookie value is passed to the validator as-is.
        ttl: Cookie lifetime in seconds (default 24 h).  Only used when
            ``secret_key`` is set.
        **kwargs: Extra keyword arguments forwarded to the validator on every
            call (e.g. ``role=Role.ADMIN``).
    """
    def __init__(
        self,
        name: str,
        validator: Callable[..., Any],
        *,
        secret_key: str | None = None,
        ttl: int = 86400,
        **kwargs: Any,
    ) -> None:
        self._name = name
        self._validator = _ensure_async(validator)
        self._secret_key = secret_key
        self._ttl = ttl
        self._kwargs = kwargs
        self._scheme = APIKeyCookie(name=name, auto_error=False)
        async def _call(
            security_scopes: SecurityScopes,  # noqa: ARG001
            value: Annotated[str | None, Depends(self._scheme)] = None,
        ) -> Any:
            if value is None:
                raise UnauthorizedError()
            plain = self._verify(value)
            return await self._validator(plain, **self._kwargs)
        self._call_fn = _call
        self.__signature__ = inspect.signature(_call)
    def _hmac(self, data: str) -> str:
        if self._secret_key is None:
            raise RuntimeError("_hmac called without secret_key configured")
        return hmac.new(
            self._secret_key.encode(), data.encode(), hashlib.sha256
        ).hexdigest()
    def _sign(self, value: str) -> str:
        data = base64.urlsafe_b64encode(
            json.dumps({"v": value, "exp": int(time.time()) + self._ttl}).encode()
        ).decode()
        return f"{data}.{self._hmac(data)}"
    def _verify(self, cookie_value: str) -> str:
        """Return the plain value, verifying HMAC + expiry when signed."""
        if not self._secret_key:
            return cookie_value
        try:
            data, sig = cookie_value.rsplit(".", 1)
        except ValueError:
            raise UnauthorizedError()
        if not hmac.compare_digest(self._hmac(data), sig):
            raise UnauthorizedError()
        try:
            payload = json.loads(base64.urlsafe_b64decode(data))
            value: str = payload["v"]
            exp: int = payload["exp"]
        except Exception:
            raise UnauthorizedError()
        if exp < int(time.time()):
            raise UnauthorizedError()
        return value
    async def extract(self, request: Request) -> str | None:
        return request.cookies.get(self._name)
    async def authenticate(self, credential: str) -> Any:
        plain = self._verify(credential)
        return await self._validator(plain, **self._kwargs)
    def require(self, **kwargs: Any) -> "CookieAuth":
        """Return a new instance with additional (or overriding) validator kwargs."""
        return CookieAuth(
            self._name,
            self._validator,
            secret_key=self._secret_key,
            ttl=self._ttl,
            **{**self._kwargs, **kwargs},
        )
    def set_cookie(self, response: Response, value: str) -> None:
        """Attach the cookie to *response*, signing it when ``secret_key`` is set."""
        cookie_value = self._sign(value) if self._secret_key else value
        response.set_cookie(
            self._name,
            cookie_value,
            httponly=True,
            samesite="lax",
            max_age=self._ttl,
        )
    def delete_cookie(self, response: Response) -> None:
        """Clear the session cookie (logout)."""
        response.delete_cookie(self._name, httponly=True, samesite="lax")
--- a/src/fastapi_toolsets/security/sources/header.py
+++ b/src/fastapi_toolsets/security/sources/header.py
@@ -1,67 +0,0 @@
 """API key header authentication source."""
 import inspect
 from typing import Annotated, Any, Callable
 from fastapi import Depends, Request
 from fastapi.security import APIKeyHeader, SecurityScopes
 from fastapi_toolsets.exceptions import UnauthorizedError
 from ..abc import AuthSource, _ensure_async
 class APIKeyHeaderAuth(AuthSource):
    """API key header authentication source.
    Wraps :class:`fastapi.security.APIKeyHeader` for OpenAPI documentation.
    The validator is called as ``await validator(api_key, **kwargs)``
    where ``kwargs`` are the extra keyword arguments provided at instantiation.
    Args:
        name: HTTP header name that carries the API key (e.g. ``"X-API-Key"``).
        validator: Sync or async callable that receives the API key and any
            extra keyword arguments, and returns the authenticated identity.
            Should raise :class:`~fastapi_toolsets.exceptions.UnauthorizedError`
            on failure.
        **kwargs: Extra keyword arguments forwarded to the validator on every
            call (e.g. ``role=Role.ADMIN``).
    """
    def __init__(
        self,
        name: str,
        validator: Callable[..., Any],
        **kwargs: Any,
    ) -> None:
        self._name = name
        self._validator = _ensure_async(validator)
        self._kwargs = kwargs
        self._scheme = APIKeyHeader(name=name, auto_error=False)
        async def _call(
            security_scopes: SecurityScopes,  # noqa: ARG001
            api_key: Annotated[str | None, Depends(self._scheme)] = None,
        ) -> Any:
            if api_key is None:
                raise UnauthorizedError()
            return await self._validator(api_key, **self._kwargs)
        self._call_fn = _call
        self.__signature__ = inspect.signature(_call)
    async def extract(self, request: Request) -> str | None:
        """Extract the API key from the configured header."""
        return request.headers.get(self._name) or None
    async def authenticate(self, credential: str) -> Any:
        """Validate a credential and return the identity."""
        return await self._validator(credential, **self._kwargs)
    def require(self, **kwargs: Any) -> "APIKeyHeaderAuth":
        """Return a new instance with additional (or overriding) validator kwargs."""
        return APIKeyHeaderAuth(
            self._name,
            self._validator,
            **{**self._kwargs, **kwargs},
        )
--- a/src/fastapi_toolsets/security/sources/multi.py
+++ b/src/fastapi_toolsets/security/sources/multi.py
@@ -1,119 +0,0 @@
 """MultiAuth: combine multiple authentication sources into a single callable."""
 import inspect
 from typing import Any, cast
 from fastapi import Request
 from fastapi.security import SecurityScopes
 from fastapi_toolsets.exceptions import UnauthorizedError
 from ..abc import AuthSource
 class MultiAuth:
    """Combine multiple authentication sources into a single callable.
    Sources are tried in order; the first one whose
    :meth:`~AuthSource.extract` returns a non-``None`` credential wins.
    Its :meth:`~AuthSource.authenticate` is called and the result returned.
    If a credential is found but the validator raises, the exception propagates
    immediately — the remaining sources are **not** tried. This prevents
    silent fallthrough on invalid credentials.
    If no source provides a credential,
    :class:`~fastapi_toolsets.exceptions.UnauthorizedError` is raised.
    The :meth:`~AuthSource.extract` method of each source performs only
    string matching (no I/O), so prefix-based dispatch is essentially free.
    Any :class:`~AuthSource` subclass — including user-defined ones — can be
    passed as a source.
    Args:
        *sources: Auth source instances to try in order.
    Example::
        user_bearer = BearerTokenAuth(verify_user, prefix="user_")
        org_bearer  = BearerTokenAuth(verify_org,  prefix="org_")
        cookie      = CookieAuth("session", verify_session)
        multi = MultiAuth(user_bearer, org_bearer, cookie)
        @app.get("/data")
        async def data_route(user = Security(multi)):
            return user
        # Apply a shared requirement to all sources at once
        @app.get("/admin")
        async def admin_route(user = Security(multi.require(role=Role.ADMIN))):
            return user
    """
    def __init__(self, *sources: AuthSource) -> None:
        self._sources = sources
        async def _call(
            request: Request,
            security_scopes: SecurityScopes,  # noqa: ARG001
            **kwargs: Any,  # noqa: ARG001  — absorbs scheme values injected by FastAPI
        ) -> Any:
            for source in self._sources:
                credential = await source.extract(request)
                if credential is not None:
                    return await source.authenticate(credential)
            raise UnauthorizedError()
        self._call_fn = _call
        # Build a merged signature that includes the security-scheme Depends()
        # parameters from every source so FastAPI registers them in OpenAPI docs.
        seen: set[str] = {"request", "security_scopes"}
        merged: list[inspect.Parameter] = [
            inspect.Parameter(
                "request",
                inspect.Parameter.POSITIONAL_OR_KEYWORD,
                annotation=Request,
            ),
            inspect.Parameter(
                "security_scopes",
                inspect.Parameter.POSITIONAL_OR_KEYWORD,
                annotation=SecurityScopes,
            ),
        ]
        for i, source in enumerate(sources):
            for name, param in inspect.signature(source).parameters.items():
                if name in seen:
                    continue
                merged.append(param.replace(name=f"_s{i}_{name}"))
                seen.add(name)
        self.__signature__ = inspect.Signature(merged, return_annotation=Any)
    async def __call__(self, **kwargs: Any) -> Any:
        return await self._call_fn(**kwargs)
    def require(self, **kwargs: Any) -> "MultiAuth":
        """Return a new :class:`MultiAuth` with kwargs forwarded to each source.
        Calls ``.require(**kwargs)`` on every source that supports it. Sources
        that do not implement ``.require()`` (e.g. custom :class:`~AuthSource`
        subclasses) are passed through unchanged.
        New kwargs are merged over each source's existing kwargs — new values
        win on conflict::
            multi = MultiAuth(bearer, cookie)
            @app.get("/admin")
            async def admin(user = Security(multi.require(role=Role.ADMIN))):
                return user
        """
        new_sources = tuple(
            cast(Any, source).require(**kwargs)
            if hasattr(source, "require")
            else source
            for source in self._sources
        )
        return MultiAuth(*new_sources)
--- a/src/fastapi_toolsets/types.py
+++ b/src/fastapi_toolsets/types.py
@@ -16,7 +16,6 @@ SchemaType = TypeVar("SchemaType", bound=BaseModel)
 # CRUD type aliases
 JoinType = list[tuple[type[DeclarativeBase] | Any, Any]]
 LateralJoinType = list[tuple[Any, Any]]
 M2MFieldType = Mapping[str, QueryableAttribute[Any]]
 OrderByClause = ColumnElement[Any] | QueryableAttribute[Any]
--- a/tests/test_crud.py
+++ b/tests/test_crud.py
@@ -6,15 +6,9 @@ import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
-from fastapi_toolsets.crud import CrudFactory, PaginationType, lateral_load
+from fastapi_toolsets.crud import CrudFactory, PaginationType
-from fastapi_toolsets.crud.factory import (
+from fastapi_toolsets.crud.factory import AsyncCrud, _CursorDirection
    AsyncCrud,
    _CursorDirection,
    _LateralLoad,
    _ResolvedLateral,
 )
 from fastapi_toolsets.exceptions import NotFoundError
 from fastapi_toolsets.schemas import PydanticBase
 from .conftest import (
    EventCreate,
@@ -57,12 +51,6 @@ from .conftest import (
 )
 class UserWithRoleRead(PydanticBase):
    id: uuid.UUID
    username: str
    role: RoleRead | None = None
 class TestCrudFactory:
    """Tests for CrudFactory."""
@@ -220,11 +208,11 @@ class TestResolveLoadOptions:
        assert crud._resolve_load_options(None) is None
    def test_empty_list_overrides_default(self):
-        """An explicit empty list disables default_load_options (no options applied)."""
+        """An empty list is a valid override and disables default_load_options."""
        default = [selectinload(User.role)]
        crud = CrudFactory(User, default_load_options=default)
-        # Empty list replaces default; None and [] are both falsy → no options applied
+        # Empty list is not None, so it should replace default
-        assert not crud._resolve_load_options([])
+        assert crud._resolve_load_options([]) == []
 class TestResolveSearchColumns:
@@ -371,6 +359,13 @@ class TestDefaultLoadOptionsIntegration:
        self, db_session: AsyncSession
    ):
        """default_load_options loads relationships automatically on offset_paginate()."""
        from fastapi_toolsets.schemas import PydanticBase
        class UserWithRoleRead(PydanticBase):
            id: uuid.UUID
            username: str
            role: RoleRead | None = None
        UserWithDefaultLoad = CrudFactory(
            User, default_load_options=[selectinload(User.role)]
        )
@@ -2467,7 +2462,12 @@ class TestCursorPaginateExtraOptions:
    @pytest.mark.anyio
    async def test_with_load_options(self, db_session: AsyncSession):
        """cursor_paginate passes load_options to the query."""
-        from fastapi_toolsets.schemas import CursorPagination
+        from fastapi_toolsets.schemas import CursorPagination, PydanticBase
        class UserWithRoleRead(PydanticBase):
            id: uuid.UUID
            username: str
            role: RoleRead | None = None
        role = await RoleCrud.create(db_session, RoleCreate(name="manager"))
        for i in range(3):
@@ -2833,445 +2833,3 @@ class TestPaginate:
        assert isinstance(result.pagination, OffsetPagination)
        assert result.pagination.total_count is None
 class TestLateralLoadValidation:
    """lateral_load() raises immediately for bad relationship types."""
    def test_valid_many_to_one_returns_marker(self):
        """lateral_load() on a Many:One rel returns a _LateralLoad with rel_attr set."""
        marker = lateral_load(User.role)
        assert isinstance(marker, _LateralLoad)
        assert marker.rel_attr is User.role
    def test_raises_type_error_for_plain_column(self):
        """lateral_load() raises TypeError when passed a plain column."""
        with pytest.raises(TypeError, match="relationship attribute"):
            lateral_load(User.username)
    def test_raises_value_error_for_many_to_many(self):
        """lateral_load() raises ValueError for Many:Many (secondary table)."""
        with pytest.raises(ValueError, match="Many:Many"):
            lateral_load(Post.tags)
    def test_raises_value_error_for_one_to_many(self):
        """lateral_load() raises ValueError for One:Many (uselist=True)."""
        with pytest.raises(ValueError, match="One:Many"):
            lateral_load(Role.users)
 class TestLateralLoadInSubclass:
    """lateral_load() markers in default_load_options are processed at class definition."""
    def test_marker_extracted_from_default_load_options(self):
        """_LateralLoad is removed from default_load_options and stored in _resolved_lateral."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        assert UserLateralCrud.default_load_options is None
        assert UserLateralCrud._resolved_lateral is not None
    def test_resolved_lateral_has_one_join_and_eager(self):
        """_resolved_lateral contains exactly one join and one eager option."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        resolved = UserLateralCrud._resolved_lateral
        assert isinstance(resolved, _ResolvedLateral)
        assert len(resolved.joins) == 1
        assert len(resolved.eager) == 1
    def test_regular_options_preserved_alongside_lateral(self):
        """Non-lateral opts stay in default_load_options; lateral marker is extracted."""
        regular = selectinload(User.role)
        class UserMixedCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role), regular]
        assert UserMixedCrud._resolved_lateral is not None
        assert UserMixedCrud.default_load_options == [regular]
    def test_no_lateral_leaves_default_load_options_untouched(self):
        """When no lateral marker is present, default_load_options is unchanged."""
        opts = [selectinload(User.role)]
        class UserNormalCrud(AsyncCrud[User]):
            model = User
            default_load_options = opts
        assert UserNormalCrud.default_load_options is opts
        assert UserNormalCrud._resolved_lateral is None
    def test_no_default_load_options_leaves_resolved_lateral_none(self):
        """_resolved_lateral stays None when default_load_options is not set."""
        class UserPlainCrud(AsyncCrud[User]):
            model = User
        assert UserPlainCrud._resolved_lateral is None
 class TestResolveLoadOptionsWithLateral:
    """_resolve_load_options always appends lateral eager options."""
    def test_lateral_eager_included_when_no_call_site_opts(self):
        """contains_eager from lateral_load is returned when load_options=None."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        resolved = UserLateralCrud._resolve_load_options(None)
        assert resolved is not None
        assert len(resolved) == 1  # the contains_eager
    def test_call_site_opts_bypass_lateral_eager(self):
        """When call-site load_options are provided, lateral eager is NOT appended."""
        extra = selectinload(User.role)
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        resolved = UserLateralCrud._resolve_load_options([extra])
        assert resolved is not None
        assert len(resolved) == 1  # only the call-site option; lateral eager skipped
    def test_lateral_eager_appended_to_default_load_options(self):
        """default_load_options (regular) + lateral eager are both returned."""
        regular = selectinload(User.role)
        class UserMixedCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role), regular]
        resolved = UserMixedCrud._resolve_load_options(None)
        assert resolved is not None
        assert len(resolved) == 2
 class TestGetLateralJoins:
    """_get_lateral_joins merges auto-resolved and manual lateral_joins."""
    def test_returns_none_when_no_lateral_configured(self):
        """Returns None when neither lateral_joins nor lateral_load is set."""
        class UserPlainCrud(AsyncCrud[User]):
            model = User
        assert UserPlainCrud._get_lateral_joins() is None
    def test_returns_resolved_lateral_joins(self):
        """Returns the join tuple built from lateral_load()."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        joins = UserLateralCrud._get_lateral_joins()
        assert joins is not None
        assert len(joins) == 1
    def test_manual_lateral_joins_included(self):
        """Manual lateral_joins class var is included in _get_lateral_joins."""
        from sqlalchemy import select, true
        manual_sub = select(Role).where(Role.id == User.role_id).lateral("_manual_role")
        class UserManualCrud(AsyncCrud[User]):
            model = User
            lateral_joins = [(manual_sub, true())]
        joins = UserManualCrud._get_lateral_joins()
        assert joins is not None
        assert len(joins) == 1
    def test_manual_and_auto_lateral_joins_merged(self):
        """Both manual lateral_joins and auto-resolved from lateral_load are combined."""
        from sqlalchemy import select, true
        manual_sub = select(Role).where(Role.id == User.role_id).lateral("_manual_role")
        class UserBothCrud(AsyncCrud[User]):
            model = User
            lateral_joins = [(manual_sub, true())]
            default_load_options = [lateral_load(User.role)]
        joins = UserBothCrud._get_lateral_joins()
        assert joins is not None
        assert len(joins) == 2
 class TestLateralLoadIntegration:
    """lateral_load() in real DB queries: relationship loaded, pagination correct."""
    @pytest.mark.anyio
    async def test_get_loads_relationship(self, db_session: AsyncSession):
        """get() populates the relationship via lateral join."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
        user = await UserCrud.create(
            db_session,
            UserCreate(username="alice", email="alice@test.com", role_id=role.id),
        )
        fetched = await UserLateralCrud.get(db_session, [User.id == user.id])
        assert fetched.role is not None
        assert fetched.role.name == "admin"
    @pytest.mark.anyio
    async def test_get_null_fk_preserved(self, db_session: AsyncSession):
        """User with null role_id still returned (LEFT JOIN behaviour)."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        user = await UserCrud.create(
            db_session, UserCreate(username="bob", email="bob@test.com")
        )
        fetched = await UserLateralCrud.get(db_session, [User.id == user.id])
        assert fetched is not None
        assert fetched.role is None
    @pytest.mark.anyio
    async def test_first_loads_relationship(self, db_session: AsyncSession):
        """first() populates the relationship via lateral join."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="editor"))
        await UserCrud.create(
            db_session,
            UserCreate(username="carol", email="carol@test.com", role_id=role.id),
        )
        user = await UserLateralCrud.first(db_session)
        assert user is not None
        assert user.role is not None
        assert user.role.name == "editor"
    @pytest.mark.anyio
    async def test_get_multi_loads_relationship(self, db_session: AsyncSession):
        """get_multi() populates the relationship via lateral join for all rows."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="member"))
        for i in range(3):
            await UserCrud.create(
                db_session,
                UserCreate(
                    username=f"user{i}", email=f"u{i}@test.com", role_id=role.id
                ),
            )
        users = await UserLateralCrud.get_multi(db_session)
        assert len(users) == 3
        assert all(u.role is not None and u.role.name == "member" for u in users)
    @pytest.mark.anyio
    async def test_offset_paginate_correct_count(self, db_session: AsyncSession):
        """offset_paginate total_count is not inflated by the lateral join."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
        for i in range(5):
            await UserCrud.create(
                db_session,
                UserCreate(
                    username=f"user{i}", email=f"u{i}@test.com", role_id=role.id
                ),
            )
        result = await UserLateralCrud.offset_paginate(
            db_session, schema=UserWithRoleRead, items_per_page=10
        )
        assert result.pagination.total_count == 5
        assert len(result.data) == 5
    @pytest.mark.anyio
    async def test_offset_paginate_loads_relationship(self, db_session: AsyncSession):
        """offset_paginate serializes relationship data loaded via lateral."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
        await UserCrud.create(
            db_session,
            UserCreate(username="alice", email="alice@test.com", role_id=role.id),
        )
        result = await UserLateralCrud.offset_paginate(
            db_session, schema=UserWithRoleRead, items_per_page=10
        )
        assert result.data[0].role is not None
        assert result.data[0].role.name == "admin"
    @pytest.mark.anyio
    async def test_offset_paginate_mixed_null_fk(self, db_session: AsyncSession):
        """offset_paginate returns all users including those with null role_id."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
        await UserCrud.create(
            db_session,
            UserCreate(username="with_role", email="a@test.com", role_id=role.id),
        )
        await UserCrud.create(
            db_session, UserCreate(username="no_role", email="b@test.com")
        )
        result = await UserLateralCrud.offset_paginate(
            db_session, schema=UserWithRoleRead, items_per_page=10
        )
        assert result.pagination.total_count == 2
    @pytest.mark.anyio
    async def test_cursor_paginate_loads_relationship(self, db_session: AsyncSession):
        """cursor_paginate populates the relationship via lateral join."""
        class UserLateralCursorCrud(AsyncCrud[User]):
            model = User
            cursor_column = User.id
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
        for i in range(3):
            await UserCrud.create(
                db_session,
                UserCreate(
                    username=f"user{i}", email=f"u{i}@test.com", role_id=role.id
                ),
            )
        result = await UserLateralCursorCrud.cursor_paginate(
            db_session, schema=UserWithRoleRead, items_per_page=10
        )
        assert len(result.data) == 3
        assert all(item.role is not None for item in result.data)
    @pytest.mark.anyio
    async def test_offset_paginate_with_search_and_lateral(
        self, db_session: AsyncSession
    ):
        """search filter works alongside lateral join."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
            searchable_fields = [User.username]
        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
        await UserCrud.create(
            db_session,
            UserCreate(username="alice", email="a@test.com", role_id=role.id),
        )
        await UserCrud.create(
            db_session, UserCreate(username="bob", email="b@test.com", role_id=role.id)
        )
        result = await UserLateralCrud.offset_paginate(
            db_session, schema=UserWithRoleRead, search="alice", items_per_page=10
        )
        assert result.pagination.total_count == 1
        assert result.data[0].username == "alice"
    @pytest.mark.anyio
    async def test_first_call_site_load_options_bypasses_lateral(
        self, db_session: AsyncSession
    ):
        """When load_options is provided, lateral join is skipped (no conflict)."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="admin"))
        user = await UserCrud.create(
            db_session,
            UserCreate(username="alice", email="alice@test.com", role_id=role.id),
        )
        # Passing explicit load_options bypasses the lateral join — role loaded via selectinload
        fetched = await UserLateralCrud.first(
            db_session,
            filters=[User.id == user.id],
            load_options=[selectinload(User.role)],
        )
        assert fetched is not None
        assert fetched.role is not None
        assert fetched.role.name == "admin"
    @pytest.mark.anyio
    async def test_get_multi_call_site_load_options_bypasses_lateral(
        self, db_session: AsyncSession
    ):
        """When load_options is provided, lateral join is skipped (no conflict)."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="viewer"))
        for i in range(2):
            await UserCrud.create(
                db_session,
                UserCreate(username=f"u{i}", email=f"u{i}@test.com", role_id=role.id),
            )
        # Passing explicit load_options bypasses the lateral join — role loaded via selectinload
        users = await UserLateralCrud.get_multi(
            db_session, load_options=[selectinload(User.role)]
        )
        assert len(users) == 2
        assert all(u.role is not None and u.role.name == "viewer" for u in users)
    @pytest.mark.anyio
    async def test_offset_paginate_call_site_load_options_bypasses_lateral(
        self, db_session: AsyncSession
    ):
        """When load_options is provided, lateral join is skipped (no conflict)."""
        class UserLateralCrud(AsyncCrud[User]):
            model = User
            default_load_options = [lateral_load(User.role)]
        role = await RoleCrud.create(db_session, RoleCreate(name="editor"))
        for i in range(3):
            await UserCrud.create(
                db_session,
                UserCreate(username=f"e{i}", email=f"e{i}@test.com", role_id=role.id),
            )
        # Passing explicit load_options bypasses the lateral join — role loaded via selectinload
        result = await UserLateralCrud.offset_paginate(
            db_session,
            schema=UserWithRoleRead,
            items_per_page=10,
            load_options=[selectinload(User.role)],
        )
        assert result.pagination.total_count == 3
        assert all(item.role is not None for item in result.data)
--- a/tests/test_db.py
+++ b/tests/test_db.py
@@ -4,10 +4,26 @@ import asyncio
 import uuid
 import pytest
-from sqlalchemy import text
+from sqlalchemy import (
    Column,
    ForeignKey,
    ForeignKeyConstraint,
    String,
    Table,
    Uuid,
    select,
    text,
 )
 from sqlalchemy.engine import make_url
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import (
    DeclarativeBase,
    Mapped,
    mapped_column,
    relationship,
    selectinload,
 )
 from fastapi_toolsets.db import (
    LockMode,
@@ -17,12 +33,15 @@ from fastapi_toolsets.db import (
    create_db_dependency,
    get_transaction,
    lock_tables,
    m2m_add,
    m2m_remove,
    m2m_set,
    wait_for_row_change,
 )
 from fastapi_toolsets.exceptions import NotFoundError
 from fastapi_toolsets.pytest import create_db_session
-from .conftest import DATABASE_URL, Base, Role, RoleCrud, User, UserCrud
+from .conftest import DATABASE_URL, Base, Post, Role, RoleCrud, Tag, User, UserCrud
 class TestCreateDbDependency:
@@ -81,6 +100,21 @@ class TestCreateDbDependency:
        await engine.dispose()
    @pytest.mark.anyio
    async def test_no_commit_when_not_in_transaction(self):
        """Dependency skips commit if the session is no longer in a transaction on exit."""
        engine = create_async_engine(DATABASE_URL, echo=False)
        session_factory = async_sessionmaker(engine, expire_on_commit=False)
        get_db = create_db_dependency(session_factory)
        async for session in get_db():
            # Manually commit — session exits the transaction
            await session.commit()
            assert not session.in_transaction()
            # The dependency's post-yield path must not call commit again (no error)
        await engine.dispose()
    @pytest.mark.anyio
    async def test_update_after_lock_tables_is_persisted(self):
        """Changes made after lock_tables exits (before endpoint returns) are committed.
@@ -480,3 +514,417 @@ class TestCleanupTables:
        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as session:
            # Should not raise
            await cleanup_tables(session, EmptyBase)
 class TestM2MAdd:
    """Tests for m2m_add helper."""
    @pytest.mark.anyio
    async def test_adds_single_related(self, db_session: AsyncSession):
        """Associates one related instance via the secondary table."""
        user = User(username="m2m_author", email="m2m@test.com")
        db_session.add(user)
        await db_session.flush()
        post = Post(title="Post A", author_id=user.id)
        tag = Tag(name="python")
        db_session.add_all([post, tag])
        await db_session.flush()
        async with get_transaction(db_session):
            await m2m_add(db_session, post, Post.tags, tag)
        result = await db_session.execute(
            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
        )
        loaded = result.scalar_one()
        assert len(loaded.tags) == 1
        assert loaded.tags[0].id == tag.id
    @pytest.mark.anyio
    async def test_adds_multiple_related(self, db_session: AsyncSession):
        """Associates multiple related instances in a single call."""
        user = User(username="m2m_author2", email="m2m2@test.com")
        db_session.add(user)
        await db_session.flush()
        post = Post(title="Post B", author_id=user.id)
        tag1 = Tag(name="web")
        tag2 = Tag(name="api")
        tag3 = Tag(name="async")
        db_session.add_all([post, tag1, tag2, tag3])
        await db_session.flush()
        async with get_transaction(db_session):
            await m2m_add(db_session, post, Post.tags, tag1, tag2, tag3)
        result = await db_session.execute(
            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
        )
        loaded = result.scalar_one()
        assert {t.id for t in loaded.tags} == {tag1.id, tag2.id, tag3.id}
    @pytest.mark.anyio
    async def test_noop_for_empty_related(self, db_session: AsyncSession):
        """Calling with no related instances is a no-op."""
        user = User(username="m2m_author3", email="m2m3@test.com")
        db_session.add(user)
        await db_session.flush()
        post = Post(title="Post C", author_id=user.id)
        db_session.add(post)
        await db_session.flush()
        async with get_transaction(db_session):
            await m2m_add(db_session, post, Post.tags)  # no related instances
        result = await db_session.execute(
            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
        )
        loaded = result.scalar_one()
        assert loaded.tags == []
    @pytest.mark.anyio
    async def test_ignore_conflicts_true(self, db_session: AsyncSession):
        """Duplicate inserts are silently skipped when ignore_conflicts=True."""
        user = User(username="m2m_author4", email="m2m4@test.com")
        db_session.add(user)
        await db_session.flush()
        post = Post(title="Post D", author_id=user.id)
        tag = Tag(name="duplicate_tag")
        db_session.add_all([post, tag])
        await db_session.flush()
        async with get_transaction(db_session):
            await m2m_add(db_session, post, Post.tags, tag)
        # Second call with ignore_conflicts=True must not raise
        async with get_transaction(db_session):
            await m2m_add(db_session, post, Post.tags, tag, ignore_conflicts=True)
        result = await db_session.execute(
            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
        )
        loaded = result.scalar_one()
        assert len(loaded.tags) == 1
    @pytest.mark.anyio
    async def test_ignore_conflicts_false_raises(self, db_session: AsyncSession):
        """Duplicate inserts raise IntegrityError when ignore_conflicts=False (default)."""
        user = User(username="m2m_author5", email="m2m5@test.com")
        db_session.add(user)
        await db_session.flush()
        post = Post(title="Post E", author_id=user.id)
        tag = Tag(name="conflict_tag")
        db_session.add_all([post, tag])
        await db_session.flush()
        async with get_transaction(db_session):
            await m2m_add(db_session, post, Post.tags, tag)
        with pytest.raises(IntegrityError):
            async with get_transaction(db_session):
                await m2m_add(db_session, post, Post.tags, tag)
    @pytest.mark.anyio
    async def test_non_m2m_raises_type_error(self, db_session: AsyncSession):
        """Passing a non-M2M relationship attribute raises TypeError."""
        user = User(username="m2m_author6", email="m2m6@test.com")
        db_session.add(user)
        await db_session.flush()
        role = Role(name="type_err_role")
        db_session.add(role)
        await db_session.flush()
        with pytest.raises(TypeError, match="Many-to-Many"):
            await m2m_add(db_session, user, User.role, role)
    @pytest.mark.anyio
    async def test_works_inside_lock_tables(self, db_session: AsyncSession):
        """m2m_add works correctly inside a lock_tables nested transaction."""
        user = User(username="m2m_lock_author", email="m2m_lock@test.com")
        db_session.add(user)
        await db_session.flush()
        async with lock_tables(db_session, [Tag]):
            tag = Tag(name="locked_tag")
            db_session.add(tag)
            await db_session.flush()
            post = Post(title="Post Lock", author_id=user.id)
            db_session.add(post)
            await db_session.flush()
            await m2m_add(db_session, post, Post.tags, tag)
        result = await db_session.execute(
            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
        )
        loaded = result.scalar_one()
        assert len(loaded.tags) == 1
        assert loaded.tags[0].name == "locked_tag"
 class _LocalBase(DeclarativeBase):
    pass
 _comp_assoc = Table(
    "_comp_assoc",
    _LocalBase.metadata,
    Column("owner_id", Uuid, ForeignKey("_comp_owners.id"), primary_key=True),
    Column("item_group", String(50), primary_key=True),
    Column("item_code", String(50), primary_key=True),
    ForeignKeyConstraint(
        ["item_group", "item_code"],
        ["_comp_items.group_id", "_comp_items.item_code"],
    ),
 )
 class _CompOwner(_LocalBase):
    __tablename__ = "_comp_owners"
    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
    items: Mapped[list["_CompItem"]] = relationship(secondary=_comp_assoc)
 class _CompItem(_LocalBase):
    __tablename__ = "_comp_items"
    group_id: Mapped[str] = mapped_column(String(50), primary_key=True)
    item_code: Mapped[str] = mapped_column(String(50), primary_key=True)
 class TestM2MRemove:
    """Tests for m2m_remove helper."""
    async def _setup(
        self, session: AsyncSession, username: str, email: str, *tag_names: str
    ):
        """Create a user, post, and tags; associate all tags with the post."""
        user = User(username=username, email=email)
        session.add(user)
        await session.flush()
        post = Post(title=f"Post {username}", author_id=user.id)
        tags = [Tag(name=n) for n in tag_names]
        session.add(post)
        session.add_all(tags)
        await session.flush()
        async with get_transaction(session):
            await m2m_add(session, post, Post.tags, *tags)
        return post, tags
    async def _load_tags(self, session: AsyncSession, post: Post) -> list[Tag]:
        result = await session.execute(
            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
        )
        return result.scalar_one().tags
    @pytest.mark.anyio
    async def test_removes_single(self, db_session: AsyncSession):
        """Removes one association, leaving others intact."""
        post, (tag1, tag2) = await self._setup(
            db_session, "rm_author1", "rm1@test.com", "tag_rm_a", "tag_rm_b"
        )
        async with get_transaction(db_session):
            await m2m_remove(db_session, post, Post.tags, tag1)
        remaining = await self._load_tags(db_session, post)
        assert len(remaining) == 1
        assert remaining[0].id == tag2.id
    @pytest.mark.anyio
    async def test_removes_multiple(self, db_session: AsyncSession):
        """Removes multiple associations in one call."""
        post, (tag1, tag2, tag3) = await self._setup(
            db_session, "rm_author2", "rm2@test.com", "tag_rm_c", "tag_rm_d", "tag_rm_e"
        )
        async with get_transaction(db_session):
            await m2m_remove(db_session, post, Post.tags, tag1, tag3)
        remaining = await self._load_tags(db_session, post)
        assert len(remaining) == 1
        assert remaining[0].id == tag2.id
    @pytest.mark.anyio
    async def test_noop_for_empty_related(self, db_session: AsyncSession):
        """Calling with no related instances is a no-op."""
        post, (tag,) = await self._setup(
            db_session, "rm_author3", "rm3@test.com", "tag_rm_f"
        )
        async with get_transaction(db_session):
            await m2m_remove(db_session, post, Post.tags)
        remaining = await self._load_tags(db_session, post)
        assert len(remaining) == 1
    @pytest.mark.anyio
    async def test_idempotent_for_missing_association(self, db_session: AsyncSession):
        """Removing a non-existent association does not raise."""
        post, (tag1,) = await self._setup(
            db_session, "rm_author4", "rm4@test.com", "tag_rm_g"
        )
        tag2 = Tag(name="tag_rm_h")
        db_session.add(tag2)
        await db_session.flush()
        # tag2 was never associated — should not raise
        async with get_transaction(db_session):
            await m2m_remove(db_session, post, Post.tags, tag2)
        remaining = await self._load_tags(db_session, post)
        assert len(remaining) == 1
    @pytest.mark.anyio
    async def test_non_m2m_raises_type_error(self, db_session: AsyncSession):
        """Passing a non-M2M relationship attribute raises TypeError."""
        user = User(username="rm_author5", email="rm5@test.com")
        db_session.add(user)
        await db_session.flush()
        role = Role(name="rm_type_err_role")
        db_session.add(role)
        await db_session.flush()
        with pytest.raises(TypeError, match="Many-to-Many"):
            await m2m_remove(db_session, user, User.role, role)
    @pytest.mark.anyio
    async def test_removes_composite_pk_related(self):
        """Composite-PK branch: DELETE uses tuple IN when related side has multi-col PK."""
        engine = create_async_engine(DATABASE_URL, echo=False)
        async with engine.begin() as conn:
            await conn.run_sync(_LocalBase.metadata.create_all)
        session_factory = async_sessionmaker(engine, expire_on_commit=False)
        try:
            async with session_factory() as session:
                owner = _CompOwner()
                item1 = _CompItem(group_id="g1", item_code="c1")
                item2 = _CompItem(group_id="g1", item_code="c2")
                session.add_all([owner, item1, item2])
                await session.flush()
                async with get_transaction(session):
                    await m2m_add(session, owner, _CompOwner.items, item1, item2)
                async with get_transaction(session):
                    await m2m_remove(session, owner, _CompOwner.items, item1)
                await session.commit()
            async with session_factory() as verify:
                from sqlalchemy import select
                from sqlalchemy.orm import selectinload
                result = await verify.execute(
                    select(_CompOwner)
                    .where(_CompOwner.id == owner.id)
                    .options(selectinload(_CompOwner.items))
                )
                loaded = result.scalar_one()
                assert len(loaded.items) == 1
                assert (loaded.items[0].group_id, loaded.items[0].item_code) == (
                    "g1",
                    "c2",
                )
        finally:
            async with engine.begin() as conn:
                await conn.run_sync(_LocalBase.metadata.drop_all)
            await engine.dispose()
 class TestM2MSet:
    """Tests for m2m_set helper."""
    async def _load_tags(self, session: AsyncSession, post: Post) -> list[Tag]:
        result = await session.execute(
            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
        )
        return result.scalar_one().tags
    @pytest.mark.anyio
    async def test_replaces_existing_set(self, db_session: AsyncSession):
        """Replaces the full association set atomically."""
        user = User(username="set_author1", email="set1@test.com")
        db_session.add(user)
        await db_session.flush()
        post = Post(title="Post Set A", author_id=user.id)
        tag1 = Tag(name="tag_set_a")
        tag2 = Tag(name="tag_set_b")
        tag3 = Tag(name="tag_set_c")
        db_session.add_all([post, tag1, tag2, tag3])
        await db_session.flush()
        async with get_transaction(db_session):
            await m2m_add(db_session, post, Post.tags, tag1, tag2)
        async with get_transaction(db_session):
            await m2m_set(db_session, post, Post.tags, tag3)
        remaining = await self._load_tags(db_session, post)
        assert len(remaining) == 1
        assert remaining[0].id == tag3.id
    @pytest.mark.anyio
    async def test_clears_all_when_no_related(self, db_session: AsyncSession):
        """Passing no related instances clears all associations."""
        user = User(username="set_author2", email="set2@test.com")
        db_session.add(user)
        await db_session.flush()
        post = Post(title="Post Set B", author_id=user.id)
        tag = Tag(name="tag_set_d")
        db_session.add_all([post, tag])
        await db_session.flush()
        async with get_transaction(db_session):
            await m2m_add(db_session, post, Post.tags, tag)
        async with get_transaction(db_session):
            await m2m_set(db_session, post, Post.tags)
        remaining = await self._load_tags(db_session, post)
        assert remaining == []
    @pytest.mark.anyio
    async def test_set_on_empty_then_populate(self, db_session: AsyncSession):
        """m2m_set works on a post with no existing associations."""
        user = User(username="set_author3", email="set3@test.com")
        db_session.add(user)
        await db_session.flush()
        post = Post(title="Post Set C", author_id=user.id)
        tag1 = Tag(name="tag_set_e")
        tag2 = Tag(name="tag_set_f")
        db_session.add_all([post, tag1, tag2])
        await db_session.flush()
        async with get_transaction(db_session):
            await m2m_set(db_session, post, Post.tags, tag1, tag2)
        remaining = await self._load_tags(db_session, post)
        assert {t.id for t in remaining} == {tag1.id, tag2.id}
    @pytest.mark.anyio
    async def test_non_m2m_raises_type_error(self, db_session: AsyncSession):
        """Passing a non-M2M relationship attribute raises TypeError."""
        user = User(username="set_author4", email="set4@test.com")
        db_session.add(user)
        await db_session.flush()
        role = Role(name="set_type_err_role")
        db_session.add(role)
        await db_session.flush()
        with pytest.raises(TypeError, match="Many-to-Many"):
            await m2m_set(db_session, user, User.role, role)
--- a/tests/test_fixtures.py
+++ b/tests/test_fixtures.py
@@ -10,6 +10,7 @@ from fastapi_toolsets.fixtures import (
    Context,
    FixtureRegistry,
    LoadStrategy,
    get_field_by_attr,
    get_obj_by_attr,
    load_fixtures,
    load_fixtures_by_context,
@@ -951,6 +952,41 @@ class TestGetObjByAttr:
            get_obj_by_attr(self.roles, "id", "not-a-uuid")
 class TestGetFieldByAttr:
    """Tests for get_field_by_attr helper function."""
    def setup_method(self):
        self.registry = FixtureRegistry()
        self.role_id_1 = uuid.uuid4()
        self.role_id_2 = uuid.uuid4()
        role_id_1 = self.role_id_1
        role_id_2 = self.role_id_2
        @self.registry.register
        def roles() -> list[Role]:
            return [
                Role(id=role_id_1, name="admin"),
                Role(id=role_id_2, name="user"),
            ]
        self.roles = roles
    def test_returns_id_by_default(self):
        """Returns the id field when no field is specified."""
        result = get_field_by_attr(self.roles, "name", "admin")
        assert result == self.role_id_1
    def test_returns_specified_field(self):
        """Returns the requested field instead of id."""
        result = get_field_by_attr(self.roles, "id", self.role_id_2, field="name")
        assert result == "user"
    def test_no_match_raises_stop_iteration(self):
        """Propagates StopIteration from get_obj_by_attr when no match found."""
        with pytest.raises(StopIteration, match="No object with name=missing"):
            get_field_by_attr(self.roles, "name", "missing")
 class TestGetPrimaryKey:
    """Unit tests for the _get_primary_key helper (composite PK paths)."""
--- a/tests/test_pytest.py
+++ b/tests/test_pytest.py
@@ -1,17 +1,18 @@
 """Tests for fastapi_toolsets.pytest module."""
 import uuid
 from typing import cast
 import pytest
 from fastapi import Depends, FastAPI
 from httpx import AsyncClient
-from sqlalchemy import select, text
+from sqlalchemy import ForeignKey, String, select, text
 from sqlalchemy.engine import make_url
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import selectinload
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
 from fastapi_toolsets.db import get_transaction
-from fastapi_toolsets.fixtures import Context, FixtureRegistry
+from fastapi_toolsets.fixtures import Context, FixtureRegistry, LoadStrategy
 from fastapi_toolsets.pytest import (
    create_async_client,
    create_db_session,
@@ -19,9 +20,23 @@ from fastapi_toolsets.pytest import (
    register_fixtures,
    worker_database_url,
 )
 from fastapi_toolsets.pytest.plugin import (
    _get_primary_key,
    _relationship_load_options,
    _reload_with_relationships,
 )
 from fastapi_toolsets.pytest.utils import _get_xdist_worker
-from .conftest import DATABASE_URL, Base, Role, RoleCrud, User, UserCrud
+from .conftest import (
    DATABASE_URL,
    Base,
    IntRole,
    Permission,
    Role,
    RoleCrud,
    User,
    UserCrud,
 )
 test_registry = FixtureRegistry()
@@ -136,14 +151,8 @@ class TestGeneratedFixtures:
    async def test_fixture_relationships_work(
        self, db_session: AsyncSession, fixture_users: list[User]
    ):
-        """Loaded fixtures have working relationships."""
+        """Loaded fixtures have working relationships directly accessible."""
-        # Load user with role relationship
+        user = next(u for u in fixture_users if u.id == USER_ADMIN_ID)
        user = await UserCrud.get(
            db_session,
            [User.id == USER_ADMIN_ID],
            load_options=[selectinload(User.role)],
        )
        assert user.role is not None
        assert user.role.name == "plugin_admin"
@@ -177,6 +186,15 @@ class TestGeneratedFixtures:
        assert users[0].username == "plugin_admin"
        assert users[1].username == "plugin_user"
    @pytest.mark.anyio
    async def test_fixture_auto_loads_relationships(
        self, db_session: AsyncSession, fixture_users: list[User]
    ):
        """Fixtures automatically eager-load all direct relationships."""
        user = next(u for u in fixture_users if u.username == "plugin_admin")
        assert user.role is not None
        assert user.role.name == "plugin_admin"
    @pytest.mark.anyio
    async def test_multiple_fixtures_in_same_test(
        self,
@@ -516,3 +534,192 @@ class TestCreateWorkerDatabase:
            )
            assert result.scalar() is None
        await engine.dispose()
 class _LocalBase(DeclarativeBase):
    pass
 class _Group(_LocalBase):
    __tablename__ = "_test_groups"
    id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
    name: Mapped[str] = mapped_column(String(50))
 class _CompositeItem(_LocalBase):
    """Model with composite PK and a relationship — exercises the fallback path."""
    __tablename__ = "_test_composite_items"
    group_id: Mapped[uuid.UUID] = mapped_column(
        ForeignKey("_test_groups.id"), primary_key=True
    )
    item_code: Mapped[str] = mapped_column(String(50), primary_key=True)
    group: Mapped["_Group"] = relationship()
 class TestGetPrimaryKey:
    """Unit tests for _get_primary_key — no DB needed."""
    def test_single_pk_returns_value(self):
        rid = uuid.UUID("00000000-0000-0000-0000-000000000001")
        role = Role(id=rid, name="x")
        assert _get_primary_key(role) == rid
    def test_composite_pk_all_set_returns_tuple(self):
        perm = Permission(subject="posts", action="read")
        assert _get_primary_key(perm) == ("posts", "read")
    def test_composite_pk_partial_none_returns_none(self):
        perm = Permission(subject=None, action="read")
        assert _get_primary_key(perm) is None
    def test_composite_pk_all_none_returns_none(self):
        perm = Permission(subject=None, action=None)
        assert _get_primary_key(perm) is None
 class TestRelationshipLoadOptions:
    """Unit tests for _relationship_load_options — no DB needed."""
    def test_empty_for_model_with_no_relationships(self):
        assert _relationship_load_options(IntRole) == []
    def test_returns_options_for_model_with_relationships(self):
        opts = _relationship_load_options(User)
        assert len(opts) >= 1
 class TestFixtureStrategies:
    """Integration tests covering INSERT, SKIP_EXISTING, empty fixture, no-rels model."""
    @pytest.mark.anyio
    async def test_empty_fixture_returns_empty_list(self, db_session: AsyncSession):
        """Fixture function returning [] produces an empty list."""
        registry = FixtureRegistry()
        @registry.register()
        def empty() -> list[Role]:
            return []
        local_ns: dict = {}
        register_fixtures(registry, local_ns, session_fixture="db_session")
        inner = local_ns["fixture_empty"].__wrapped__  # type: ignore[attr-defined]
        result = await inner(db_session=db_session)
        assert result == []
    @pytest.mark.anyio
    async def test_insert_strategy_no_relationships(self, db_session: AsyncSession):
        """INSERT strategy adds instances; model with no rels skips reload (line 135)."""
        registry = FixtureRegistry()
        @registry.register()
        def int_roles() -> list[IntRole]:
            return [IntRole(name="insert_role")]
        local_ns: dict = {}
        register_fixtures(
            registry,
            local_ns,
            session_fixture="db_session",
            strategy=LoadStrategy.INSERT,
        )
        inner = local_ns["fixture_int_roles"].__wrapped__  # type: ignore[attr-defined]
        result = await inner(db_session=db_session)
        assert len(result) == 1
        assert result[0].name == "insert_role"
    @pytest.mark.anyio
    async def test_skip_existing_inserts_new_record(self, db_session: AsyncSession):
        """SKIP_EXISTING inserts when the record does not yet exist."""
        registry = FixtureRegistry()
        role_id = uuid.uuid4()
        @registry.register()
        def new_roles() -> list[Role]:
            return [Role(id=role_id, name="skip_new")]
        local_ns: dict = {}
        register_fixtures(
            registry,
            local_ns,
            session_fixture="db_session",
            strategy=LoadStrategy.SKIP_EXISTING,
        )
        inner = local_ns["fixture_new_roles"].__wrapped__  # type: ignore[attr-defined]
        result = await inner(db_session=db_session)
        assert len(result) == 1
        assert result[0].id == role_id
    @pytest.mark.anyio
    async def test_skip_existing_returns_existing_record(
        self, db_session: AsyncSession
    ):
        """SKIP_EXISTING returns the existing DB record when PK already present."""
        role_id = uuid.uuid4()
        existing = Role(id=role_id, name="already_there")
        db_session.add(existing)
        await db_session.flush()
        registry = FixtureRegistry()
        @registry.register()
        def dup_roles() -> list[Role]:
            return [Role(id=role_id, name="should_not_overwrite")]
        local_ns: dict = {}
        register_fixtures(
            registry,
            local_ns,
            session_fixture="db_session",
            strategy=LoadStrategy.SKIP_EXISTING,
        )
        inner = local_ns["fixture_dup_roles"].__wrapped__  # type: ignore[attr-defined]
        result = await inner(db_session=db_session)
        assert len(result) == 1
        assert result[0].name == "already_there"
    @pytest.mark.anyio
    async def test_skip_existing_null_pk_inserts(self, db_session: AsyncSession):
        """SKIP_EXISTING with null PK (auto-increment) falls through to session.add()."""
        registry = FixtureRegistry()
        @registry.register()
        def auto_roles() -> list[IntRole]:
            return [IntRole(name="auto_int")]
        local_ns: dict = {}
        register_fixtures(
            registry,
            local_ns,
            session_fixture="db_session",
            strategy=LoadStrategy.SKIP_EXISTING,
        )
        inner = local_ns["fixture_auto_roles"].__wrapped__  # type: ignore[attr-defined]
        result = await inner(db_session=db_session)
        assert len(result) == 1
        assert result[0].name == "auto_int"
 class TestReloadWithRelationshipsCompositePK:
    """Integration test for _reload_with_relationships composite-PK fallback."""
    @pytest.mark.anyio
    async def test_composite_pk_fallback_loads_relationships(self):
        """Models with composite PKs are reloaded per-instance via session.get()."""
        async with create_db_session(DATABASE_URL, _LocalBase) as session:
            group = _Group(id=uuid.uuid4(), name="g1")
            session.add(group)
            await session.flush()
            item = _CompositeItem(group_id=group.id, item_code="A")
            session.add(item)
            await session.flush()
            load_opts = _relationship_load_options(_CompositeItem)
            assert load_opts  # _CompositeItem has 'group' relationship
            reloaded = await _reload_with_relationships(session, [item], load_opts)
            assert len(reloaded) == 1
            reloaded_item = cast(_CompositeItem, reloaded[0])
            assert reloaded_item.group is not None
            assert reloaded_item.group.name == "g1"
--- a/tests/test_security.py
+++ b/tests/test_security.py
--- a/uv.lock
+++ b/uv.lock
@@ -81,76 +81,6 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/3c/d7/8fb3044eaef08a310acfe23dae9a8e2e07d305edc29a53497e52bc76eca7/asyncpg-0.31.0-cp314-cp314t-win_amd64.whl", hash = "sha256:bd4107bb7cdd0e9e65fae66a62afd3a249663b844fa34d479f6d5b3bef9c04c3", size = 706062, upload-time = "2025-11-24T23:26:44.086Z" },
 ]
 [[package]]
 name = "bcrypt"
 version = "5.0.0"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/d4/36/3329e2518d70ad8e2e5817d5a4cac6bba05a47767ec416c7d020a965f408/bcrypt-5.0.0.tar.gz", hash = "sha256:f748f7c2d6fd375cc93d3fba7ef4a9e3a092421b8dbf34d8d4dc06be9492dfdd", size = 25386, upload-time = "2025-09-25T19:50:47.829Z" }
 wheels = [
    { url = "https://files.pythonhosted.org/packages/13/85/3e65e01985fddf25b64ca67275bb5bdb4040bd1a53b66d355c6c37c8a680/bcrypt-5.0.0-cp313-cp313t-macosx_10_12_universal2.whl", hash = "sha256:f3c08197f3039bec79cee59a606d62b96b16669cff3949f21e74796b6e3cd2be", size = 481806, upload-time = "2025-09-25T19:49:05.102Z" },
    { url = "https://files.pythonhosted.org/packages/44/dc/01eb79f12b177017a726cbf78330eb0eb442fae0e7b3dfd84ea2849552f3/bcrypt-5.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:200af71bc25f22006f4069060c88ed36f8aa4ff7f53e67ff04d2ab3f1e79a5b2", size = 268626, upload-time = "2025-09-25T19:49:06.723Z" },
    { url = "https://files.pythonhosted.org/packages/8c/cf/e82388ad5959c40d6afd94fb4743cc077129d45b952d46bdc3180310e2df/bcrypt-5.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:baade0a5657654c2984468efb7d6c110db87ea63ef5a4b54732e7e337253e44f", size = 271853, upload-time = "2025-09-25T19:49:08.028Z" },
    { url = "https://files.pythonhosted.org/packages/ec/86/7134b9dae7cf0efa85671651341f6afa695857fae172615e960fb6a466fa/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c58b56cdfb03202b3bcc9fd8daee8e8e9b6d7e3163aa97c631dfcfcc24d36c86", size = 269793, upload-time = "2025-09-25T19:49:09.727Z" },
    { url = "https://files.pythonhosted.org/packages/cc/82/6296688ac1b9e503d034e7d0614d56e80c5d1a08402ff856a4549cb59207/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bfd2a34de661f34d0bda43c3e4e79df586e4716ef401fe31ea39d69d581ef23", size = 289930, upload-time = "2025-09-25T19:49:11.204Z" },
    { url = "https://files.pythonhosted.org/packages/d1/18/884a44aa47f2a3b88dd09bc05a1e40b57878ecd111d17e5bba6f09f8bb77/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ed2e1365e31fc73f1825fa830f1c8f8917ca1b3ca6185773b349c20fd606cec2", size = 272194, upload-time = "2025-09-25T19:49:12.524Z" },
    { url = "https://files.pythonhosted.org/packages/0e/8f/371a3ab33c6982070b674f1788e05b656cfbf5685894acbfef0c65483a59/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_aarch64.whl", hash = "sha256:83e787d7a84dbbfba6f250dd7a5efd689e935f03dd83b0f919d39349e1f23f83", size = 269381, upload-time = "2025-09-25T19:49:14.308Z" },
    { url = "https://files.pythonhosted.org/packages/b1/34/7e4e6abb7a8778db6422e88b1f06eb07c47682313997ee8a8f9352e5a6f1/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_x86_64.whl", hash = "sha256:137c5156524328a24b9fac1cb5db0ba618bc97d11970b39184c1d87dc4bf1746", size = 271750, upload-time = "2025-09-25T19:49:15.584Z" },
    { url = "https://files.pythonhosted.org/packages/c0/1b/54f416be2499bd72123c70d98d36c6cd61a4e33d9b89562c22481c81bb30/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:38cac74101777a6a7d3b3e3cfefa57089b5ada650dce2baf0cbdd9d65db22a9e", size = 303757, upload-time = "2025-09-25T19:49:17.244Z" },
    { url = "https://files.pythonhosted.org/packages/13/62/062c24c7bcf9d2826a1a843d0d605c65a755bc98002923d01fd61270705a/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:d8d65b564ec849643d9f7ea05c6d9f0cd7ca23bdd4ac0c2dbef1104ab504543d", size = 306740, upload-time = "2025-09-25T19:49:18.693Z" },
    { url = "https://files.pythonhosted.org/packages/d5/c8/1fdbfc8c0f20875b6b4020f3c7dc447b8de60aa0be5faaf009d24242aec9/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:741449132f64b3524e95cd30e5cd3343006ce146088f074f31ab26b94e6c75ba", size = 334197, upload-time = "2025-09-25T19:49:20.523Z" },
    { url = "https://files.pythonhosted.org/packages/a6/c1/8b84545382d75bef226fbc6588af0f7b7d095f7cd6a670b42a86243183cd/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:212139484ab3207b1f0c00633d3be92fef3c5f0af17cad155679d03ff2ee1e41", size = 352974, upload-time = "2025-09-25T19:49:22.254Z" },
    { url = "https://files.pythonhosted.org/packages/10/a6/ffb49d4254ed085e62e3e5dd05982b4393e32fe1e49bb1130186617c29cd/bcrypt-5.0.0-cp313-cp313t-win32.whl", hash = "sha256:9d52ed507c2488eddd6a95bccee4e808d3234fa78dd370e24bac65a21212b861", size = 148498, upload-time = "2025-09-25T19:49:24.134Z" },
    { url = "https://files.pythonhosted.org/packages/48/a9/259559edc85258b6d5fc5471a62a3299a6aa37a6611a169756bf4689323c/bcrypt-5.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f6984a24db30548fd39a44360532898c33528b74aedf81c26cf29c51ee47057e", size = 145853, upload-time = "2025-09-25T19:49:25.702Z" },
    { url = "https://files.pythonhosted.org/packages/2d/df/9714173403c7e8b245acf8e4be8876aac64a209d1b392af457c79e60492e/bcrypt-5.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9fffdb387abe6aa775af36ef16f55e318dcda4194ddbf82007a6f21da29de8f5", size = 139626, upload-time = "2025-09-25T19:49:26.928Z" },
    { url = "https://files.pythonhosted.org/packages/f8/14/c18006f91816606a4abe294ccc5d1e6f0e42304df5a33710e9e8e95416e1/bcrypt-5.0.0-cp314-cp314t-macosx_10_12_universal2.whl", hash = "sha256:4870a52610537037adb382444fefd3706d96d663ac44cbb2f37e3919dca3d7ef", size = 481862, upload-time = "2025-09-25T19:49:28.365Z" },
    { url = "https://files.pythonhosted.org/packages/67/49/dd074d831f00e589537e07a0725cf0e220d1f0d5d8e85ad5bbff251c45aa/bcrypt-5.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48f753100931605686f74e27a7b49238122aa761a9aefe9373265b8b7aa43ea4", size = 268544, upload-time = "2025-09-25T19:49:30.39Z" },
    { url = "https://files.pythonhosted.org/packages/f5/91/50ccba088b8c474545b034a1424d05195d9fcbaaf802ab8bfe2be5a4e0d7/bcrypt-5.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f70aadb7a809305226daedf75d90379c397b094755a710d7014b8b117df1ebbf", size = 271787, upload-time = "2025-09-25T19:49:32.144Z" },
    { url = "https://files.pythonhosted.org/packages/aa/e7/d7dba133e02abcda3b52087a7eea8c0d4f64d3e593b4fffc10c31b7061f3/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:744d3c6b164caa658adcb72cb8cc9ad9b4b75c7db507ab4bc2480474a51989da", size = 269753, upload-time = "2025-09-25T19:49:33.885Z" },
    { url = "https://files.pythonhosted.org/packages/33/fc/5b145673c4b8d01018307b5c2c1fc87a6f5a436f0ad56607aee389de8ee3/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a28bc05039bdf3289d757f49d616ab3efe8cf40d8e8001ccdd621cd4f98f4fc9", size = 289587, upload-time = "2025-09-25T19:49:35.144Z" },
    { url = "https://files.pythonhosted.org/packages/27/d7/1ff22703ec6d4f90e62f1a5654b8867ef96bafb8e8102c2288333e1a6ca6/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7f277a4b3390ab4bebe597800a90da0edae882c6196d3038a73adf446c4f969f", size = 272178, upload-time = "2025-09-25T19:49:36.793Z" },
    { url = "https://files.pythonhosted.org/packages/c8/88/815b6d558a1e4d40ece04a2f84865b0fef233513bd85fd0e40c294272d62/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:79cfa161eda8d2ddf29acad370356b47f02387153b11d46042e93a0a95127493", size = 269295, upload-time = "2025-09-25T19:49:38.164Z" },
    { url = "https://files.pythonhosted.org/packages/51/8c/e0db387c79ab4931fc89827d37608c31cc57b6edc08ccd2386139028dc0d/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a5393eae5722bcef046a990b84dff02b954904c36a194f6cfc817d7dca6c6f0b", size = 271700, upload-time = "2025-09-25T19:49:39.917Z" },
    { url = "https://files.pythonhosted.org/packages/06/83/1570edddd150f572dbe9fc00f6203a89fc7d4226821f67328a85c330f239/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7f4c94dec1b5ab5d522750cb059bb9409ea8872d4494fd152b53cca99f1ddd8c", size = 334034, upload-time = "2025-09-25T19:49:41.227Z" },
    { url = "https://files.pythonhosted.org/packages/c9/f2/ea64e51a65e56ae7a8a4ec236c2bfbdd4b23008abd50ac33fbb2d1d15424/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0cae4cb350934dfd74c020525eeae0a5f79257e8a201c0c176f4b84fdbf2a4b4", size = 352766, upload-time = "2025-09-25T19:49:43.08Z" },
    { url = "https://files.pythonhosted.org/packages/d7/d4/1a388d21ee66876f27d1a1f41287897d0c0f1712ef97d395d708ba93004c/bcrypt-5.0.0-cp314-cp314t-win32.whl", hash = "sha256:b17366316c654e1ad0306a6858e189fc835eca39f7eb2cafd6aaca8ce0c40a2e", size = 152449, upload-time = "2025-09-25T19:49:44.971Z" },
    { url = "https://files.pythonhosted.org/packages/3f/61/3291c2243ae0229e5bca5d19f4032cecad5dfb05a2557169d3a69dc0ba91/bcrypt-5.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:92864f54fb48b4c718fc92a32825d0e42265a627f956bc0361fe869f1adc3e7d", size = 149310, upload-time = "2025-09-25T19:49:46.162Z" },
    { url = "https://files.pythonhosted.org/packages/3e/89/4b01c52ae0c1a681d4021e5dd3e45b111a8fb47254a274fa9a378d8d834b/bcrypt-5.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dd19cf5184a90c873009244586396a6a884d591a5323f0e8a5922560718d4993", size = 143761, upload-time = "2025-09-25T19:49:47.345Z" },
    { url = "https://files.pythonhosted.org/packages/84/29/6237f151fbfe295fe3e074ecc6d44228faa1e842a81f6d34a02937ee1736/bcrypt-5.0.0-cp38-abi3-macosx_10_12_universal2.whl", hash = "sha256:fc746432b951e92b58317af8e0ca746efe93e66555f1b40888865ef5bf56446b", size = 494553, upload-time = "2025-09-25T19:49:49.006Z" },
    { url = "https://files.pythonhosted.org/packages/45/b6/4c1205dde5e464ea3bd88e8742e19f899c16fa8916fb8510a851fae985b5/bcrypt-5.0.0-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c2388ca94ffee269b6038d48747f4ce8df0ffbea43f31abfa18ac72f0218effb", size = 275009, upload-time = "2025-09-25T19:49:50.581Z" },
    { url = "https://files.pythonhosted.org/packages/3b/71/427945e6ead72ccffe77894b2655b695ccf14ae1866cd977e185d606dd2f/bcrypt-5.0.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:560ddb6ec730386e7b3b26b8b4c88197aaed924430e7b74666a586ac997249ef", size = 278029, upload-time = "2025-09-25T19:49:52.533Z" },
    { url = "https://files.pythonhosted.org/packages/17/72/c344825e3b83c5389a369c8a8e58ffe1480b8a699f46c127c34580c4666b/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d79e5c65dcc9af213594d6f7f1fa2c98ad3fc10431e7aa53c176b441943efbdd", size = 275907, upload-time = "2025-09-25T19:49:54.709Z" },
    { url = "https://files.pythonhosted.org/packages/0b/7e/d4e47d2df1641a36d1212e5c0514f5291e1a956a7749f1e595c07a972038/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2b732e7d388fa22d48920baa267ba5d97cca38070b69c0e2d37087b381c681fd", size = 296500, upload-time = "2025-09-25T19:49:56.013Z" },
    { url = "https://files.pythonhosted.org/packages/0f/c3/0ae57a68be2039287ec28bc463b82e4b8dc23f9d12c0be331f4782e19108/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0c8e093ea2532601a6f686edbc2c6b2ec24131ff5c52f7610dd64fa4553b5464", size = 278412, upload-time = "2025-09-25T19:49:57.356Z" },
    { url = "https://files.pythonhosted.org/packages/45/2b/77424511adb11e6a99e3a00dcc7745034bee89036ad7d7e255a7e47be7d8/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5b1589f4839a0899c146e8892efe320c0fa096568abd9b95593efac50a87cb75", size = 275486, upload-time = "2025-09-25T19:49:59.116Z" },
    { url = "https://files.pythonhosted.org/packages/43/0a/405c753f6158e0f3f14b00b462d8bca31296f7ecfc8fc8bc7919c0c7d73a/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:89042e61b5e808b67daf24a434d89bab164d4de1746b37a8d173b6b14f3db9ff", size = 277940, upload-time = "2025-09-25T19:50:00.869Z" },
    { url = "https://files.pythonhosted.org/packages/62/83/b3efc285d4aadc1fa83db385ec64dcfa1707e890eb42f03b127d66ac1b7b/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e3cf5b2560c7b5a142286f69bde914494b6d8f901aaa71e453078388a50881c4", size = 310776, upload-time = "2025-09-25T19:50:02.393Z" },
    { url = "https://files.pythonhosted.org/packages/95/7d/47ee337dacecde6d234890fe929936cb03ebc4c3a7460854bbd9c97780b8/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f632fd56fc4e61564f78b46a2269153122db34988e78b6be8b32d28507b7eaeb", size = 312922, upload-time = "2025-09-25T19:50:04.232Z" },
    { url = "https://files.pythonhosted.org/packages/d6/3a/43d494dfb728f55f4e1cf8fd435d50c16a2d75493225b54c8d06122523c6/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:801cad5ccb6b87d1b430f183269b94c24f248dddbbc5c1f78b6ed231743e001c", size = 341367, upload-time = "2025-09-25T19:50:05.559Z" },
    { url = "https://files.pythonhosted.org/packages/55/ab/a0727a4547e383e2e22a630e0f908113db37904f58719dc48d4622139b5c/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3cf67a804fc66fc217e6914a5635000259fbbbb12e78a99488e4d5ba445a71eb", size = 359187, upload-time = "2025-09-25T19:50:06.916Z" },
    { url = "https://files.pythonhosted.org/packages/1b/bb/461f352fdca663524b4643d8b09e8435b4990f17fbf4fea6bc2a90aa0cc7/bcrypt-5.0.0-cp38-abi3-win32.whl", hash = "sha256:3abeb543874b2c0524ff40c57a4e14e5d3a66ff33fb423529c88f180fd756538", size = 153752, upload-time = "2025-09-25T19:50:08.515Z" },
    { url = "https://files.pythonhosted.org/packages/41/aa/4190e60921927b7056820291f56fc57d00d04757c8b316b2d3c0d1d6da2c/bcrypt-5.0.0-cp38-abi3-win_amd64.whl", hash = "sha256:35a77ec55b541e5e583eb3436ffbbf53b0ffa1fa16ca6782279daf95d146dcd9", size = 150881, upload-time = "2025-09-25T19:50:09.742Z" },
    { url = "https://files.pythonhosted.org/packages/54/12/cd77221719d0b39ac0b55dbd39358db1cd1246e0282e104366ebbfb8266a/bcrypt-5.0.0-cp38-abi3-win_arm64.whl", hash = "sha256:cde08734f12c6a4e28dc6755cd11d3bdfea608d93d958fffbe95a7026ebe4980", size = 144931, upload-time = "2025-09-25T19:50:11.016Z" },
    { url = "https://files.pythonhosted.org/packages/5d/ba/2af136406e1c3839aea9ecadc2f6be2bcd1eff255bd451dd39bcf302c47a/bcrypt-5.0.0-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:0c418ca99fd47e9c59a301744d63328f17798b5947b0f791e9af3c1c499c2d0a", size = 495313, upload-time = "2025-09-25T19:50:12.309Z" },
    { url = "https://files.pythonhosted.org/packages/ac/ee/2f4985dbad090ace5ad1f7dd8ff94477fe089b5fab2040bd784a3d5f187b/bcrypt-5.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddb4e1500f6efdd402218ffe34d040a1196c072e07929b9820f363a1fd1f4191", size = 275290, upload-time = "2025-09-25T19:50:13.673Z" },
    { url = "https://files.pythonhosted.org/packages/e4/6e/b77ade812672d15cf50842e167eead80ac3514f3beacac8902915417f8b7/bcrypt-5.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7aeef54b60ceddb6f30ee3db090351ecf0d40ec6e2abf41430997407a46d2254", size = 278253, upload-time = "2025-09-25T19:50:15.089Z" },
    { url = "https://files.pythonhosted.org/packages/36/c4/ed00ed32f1040f7990dac7115f82273e3c03da1e1a1587a778d8cea496d8/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f0ce778135f60799d89c9693b9b398819d15f1921ba15fe719acb3178215a7db", size = 276084, upload-time = "2025-09-25T19:50:16.699Z" },
    { url = "https://files.pythonhosted.org/packages/e7/c4/fa6e16145e145e87f1fa351bbd54b429354fd72145cd3d4e0c5157cf4c70/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a71f70ee269671460b37a449f5ff26982a6f2ba493b3eabdd687b4bf35f875ac", size = 297185, upload-time = "2025-09-25T19:50:18.525Z" },
    { url = "https://files.pythonhosted.org/packages/24/b4/11f8a31d8b67cca3371e046db49baa7c0594d71eb40ac8121e2fc0888db0/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f8429e1c410b4073944f03bd778a9e066e7fad723564a52ff91841d278dfc822", size = 278656, upload-time = "2025-09-25T19:50:19.809Z" },
    { url = "https://files.pythonhosted.org/packages/ac/31/79f11865f8078e192847d2cb526e3fa27c200933c982c5b2869720fa5fce/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:edfcdcedd0d0f05850c52ba3127b1fce70b9f89e0fe5ff16517df7e81fa3cbb8", size = 275662, upload-time = "2025-09-25T19:50:21.567Z" },
    { url = "https://files.pythonhosted.org/packages/d4/8d/5e43d9584b3b3591a6f9b68f755a4da879a59712981ef5ad2a0ac1379f7a/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:611f0a17aa4a25a69362dcc299fda5c8a3d4f160e2abb3831041feb77393a14a", size = 278240, upload-time = "2025-09-25T19:50:23.305Z" },
    { url = "https://files.pythonhosted.org/packages/89/48/44590e3fc158620f680a978aafe8f87a4c4320da81ed11552f0323aa9a57/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:db99dca3b1fdc3db87d7c57eac0c82281242d1eabf19dcb8a6b10eb29a2e72d1", size = 311152, upload-time = "2025-09-25T19:50:24.597Z" },
    { url = "https://files.pythonhosted.org/packages/5f/85/e4fbfc46f14f47b0d20493669a625da5827d07e8a88ee460af6cd9768b44/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:5feebf85a9cefda32966d8171f5db7e3ba964b77fdfe31919622256f80f9cf42", size = 313284, upload-time = "2025-09-25T19:50:26.268Z" },
    { url = "https://files.pythonhosted.org/packages/25/ae/479f81d3f4594456a01ea2f05b132a519eff9ab5768a70430fa1132384b1/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3ca8a166b1140436e058298a34d88032ab62f15aae1c598580333dc21d27ef10", size = 341643, upload-time = "2025-09-25T19:50:28.02Z" },
    { url = "https://files.pythonhosted.org/packages/df/d2/36a086dee1473b14276cd6ea7f61aef3b2648710b5d7f1c9e032c29b859f/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:61afc381250c3182d9078551e3ac3a41da14154fbff647ddf52a769f588c4172", size = 359698, upload-time = "2025-09-25T19:50:31.347Z" },
    { url = "https://files.pythonhosted.org/packages/c0/f6/688d2cd64bfd0b14d805ddb8a565e11ca1fb0fd6817175d58b10052b6d88/bcrypt-5.0.0-cp39-abi3-win32.whl", hash = "sha256:64d7ce196203e468c457c37ec22390f1a61c85c6f0b8160fd752940ccfb3a683", size = 153725, upload-time = "2025-09-25T19:50:34.384Z" },
    { url = "https://files.pythonhosted.org/packages/9f/b9/9d9a641194a730bda138b3dfe53f584d61c58cd5230e37566e83ec2ffa0d/bcrypt-5.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:64ee8434b0da054d830fa8e89e1c8bf30061d539044a39524ff7dec90481e5c2", size = 150912, upload-time = "2025-09-25T19:50:35.69Z" },
    { url = "https://files.pythonhosted.org/packages/27/44/d2ef5e87509158ad2187f4dd0852df80695bb1ee0cfe0a684727b01a69e0/bcrypt-5.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:f2347d3534e76bf50bca5500989d6c1d05ed64b440408057a37673282c654927", size = 144953, upload-time = "2025-09-25T19:50:37.32Z" },
    { url = "https://files.pythonhosted.org/packages/8a/75/4aa9f5a4d40d762892066ba1046000b329c7cd58e888a6db878019b282dc/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7edda91d5ab52b15636d9c30da87d2cc84f426c72b9dba7a9b4fe142ba11f534", size = 271180, upload-time = "2025-09-25T19:50:38.575Z" },
    { url = "https://files.pythonhosted.org/packages/54/79/875f9558179573d40a9cc743038ac2bf67dfb79cecb1e8b5d70e88c94c3d/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:046ad6db88edb3c5ece4369af997938fb1c19d6a699b9c1b27b0db432faae4c4", size = 273791, upload-time = "2025-09-25T19:50:39.913Z" },
    { url = "https://files.pythonhosted.org/packages/bc/fe/975adb8c216174bf70fc17535f75e85ac06ed5252ea077be10d9cff5ce24/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:dcd58e2b3a908b5ecc9b9df2f0085592506ac2d5110786018ee5e160f28e0911", size = 270746, upload-time = "2025-09-25T19:50:43.306Z" },
    { url = "https://files.pythonhosted.org/packages/e4/f8/972c96f5a2b6c4b3deca57009d93e946bbdbe2241dca9806d502f29dd3ee/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:6b8f520b61e8781efee73cba14e3e8c9556ccfb375623f4f97429544734545b4", size = 273375, upload-time = "2025-09-25T19:50:45.43Z" },
 ]
 [[package]]
 name = "certifi"
 version = "2026.1.4"
@@ -321,7 +251,7 @@ wheels = [
 [[package]]
 name = "fastapi-toolsets"
-version = "3.0.3"
+version = "3.1.0"
 source = { editable = "." }
 dependencies = [
    { name = "asyncpg" },
@@ -352,7 +282,6 @@ pytest = [
 [package.dev-dependencies]
 dev = [
    { name = "bcrypt" },
    { name = "coverage" },
    { name = "fastapi-toolsets", extra = ["all"] },
    { name = "httpx" },
@@ -372,9 +301,6 @@ docs = [
    { name = "mkdocstrings-python" },
    { name = "zensical" },
 ]
 docs-src = [
    { name = "bcrypt" },
 ]
 tests = [
    { name = "coverage" },
    { name = "httpx" },
@@ -401,7 +327,6 @@ provides-extras = ["cli", "metrics", "pytest", "all"]
 [package.metadata.requires-dev]
 dev = [
    { name = "bcrypt", specifier = ">=4.0.0" },
    { name = "coverage", specifier = ">=7.0.0" },
    { name = "fastapi-toolsets", extras = ["all"] },
    { name = "httpx", specifier = ">=0.25.0" },
@@ -421,7 +346,6 @@ docs = [
    { name = "mkdocstrings-python", specifier = ">=2.0.2" },
    { name = "zensical", specifier = ">=0.0.30" },
 ]
 docs-src = [{ name = "bcrypt", specifier = ">=4.0.0" }]
 tests = [
    { name = "coverage", specifier = ">=7.0.0" },
    { name = "httpx", specifier = ">=0.25.0" },
@@ -992,7 +916,7 @@ wheels = [
 [[package]]
 name = "pytest"
-version = "9.0.2"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -1001,9 +925,9 @@ dependencies = [
    { name = "pluggy" },
    { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 [[package]]
@@ -1140,27 +1064,27 @@ wheels = [
 [[package]]
 name = "ruff"
-version = "0.15.8"
+version = "0.15.9"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/14/b0/73cf7550861e2b4824950b8b52eebdcc5adc792a00c514406556c5b80817/ruff-0.15.8.tar.gz", hash = "sha256:995f11f63597ee362130d1d5a327a87cb6f3f5eae3094c620bcc632329a4d26e", size = 4610921, upload-time = "2026-03-26T18:39:38.675Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/97/e9f1ca355108ef7194e38c812ef40ba98c7208f47b13ad78d023caa583da/ruff-0.15.9.tar.gz", hash = "sha256:29cbb1255a9797903f6dde5ba0188c707907ff44a9006eb273b5a17bfa0739a2", size = 4617361, upload-time = "2026-04-02T18:17:20.829Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/92/c445b0cd6da6e7ae51e954939cb69f97e008dbe750cfca89b8cedc081be7/ruff-0.15.8-py3-none-linux_armv6l.whl", hash = "sha256:cbe05adeba76d58162762d6b239c9056f1a15a55bd4b346cfd21e26cd6ad7bc7", size = 10527394, upload-time = "2026-03-26T18:39:41.566Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1f/9cdfd0ac4b9d1e5a6cf09bedabdf0b56306ab5e333c85c87281273e7b041/ruff-0.15.9-py3-none-linux_armv6l.whl", hash = "sha256:6efbe303983441c51975c243e26dff328aca11f94b70992f35b093c2e71801e1", size = 10511206, upload-time = "2026-04-02T18:16:41.574Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/92/f1c662784d149ad1414cae450b082cf736430c12ca78367f20f5ed569d65/ruff-0.15.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:d3e3d0b6ba8dca1b7ef9ab80a28e840a20070c4b62e56d675c24f366ef330570", size = 10905693, upload-time = "2026-03-26T18:39:30.364Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/f6/32bfe3e9c136b35f02e489778d94384118bb80fd92c6d92e7ccd97db12ce/ruff-0.15.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4965bac6ac9ea86772f4e23587746f0b7a395eccabb823eb8bfacc3fa06069f7", size = 10923307, upload-time = "2026-04-02T18:17:08.645Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/f2/7a631a8af6d88bcef997eb1bf87cc3da158294c57044aafd3e17030613de/ruff-0.15.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6ee3ae5c65a42f273f126686353f2e08ff29927b7b7e203b711514370d500de3", size = 10323044, upload-time = "2026-03-26T18:39:33.37Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/25/de55f52ab5535d12e7aaba1de37a84be6179fb20bddcbe71ec091b4a3243/ruff-0.15.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:eaf05aad70ca5b5a0a4b0e080df3a6b699803916d88f006efd1f5b46302daab8", size = 10316722, upload-time = "2026-04-02T18:16:44.206Z" },
-    { url = "https://files.pythonhosted.org/packages/67/18/1bf38e20914a05e72ef3b9569b1d5c70a7ef26cd188d69e9ca8ef588d5bf/ruff-0.15.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdce027ada77baa448077ccc6ebb2fa9c3c62fd110d8659d601cf2f475858d94", size = 10629135, upload-time = "2026-03-26T18:39:44.142Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/690d75f3fd6278fe55fff7c9eb429c92d207e14b25d1cae4064a32677029/ruff-0.15.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9439a342adb8725f32f92732e2bafb6d5246bd7a5021101166b223d312e8fc59", size = 10623674, upload-time = "2026-04-02T18:16:50.951Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/e9/138c150ff9af60556121623d41aba18b7b57d95ac032e177b6a53789d279/ruff-0.15.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:12e617fc01a95e5821648a6df341d80456bd627bfab8a829f7cfc26a14a4b4a3", size = 10348041, upload-time = "2026-03-26T18:39:52.178Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/ec/176f6987be248fc5404199255522f57af1b4a5a1b57727e942479fec98ad/ruff-0.15.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9c5e6faf9d97c8edc43877c3f406f47446fc48c40e1442d58cfcdaba2acea745", size = 10351516, upload-time = "2026-04-02T18:16:57.206Z" },
-    { url = "https://files.pythonhosted.org/packages/02/f1/5bfb9298d9c323f842c5ddeb85f1f10ef51516ac7a34ba446c9347d898df/ruff-0.15.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:432701303b26416d22ba696c39f2c6f12499b89093b61360abc34bcc9bf07762", size = 11121987, upload-time = "2026-03-26T18:39:55.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fc/51cffbd2b3f240accc380171d51446a32aa2ea43a40d4a45ada67368fbd2/ruff-0.15.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7b34a9766aeec27a222373d0b055722900fbc0582b24f39661aa96f3fe6ad901", size = 11150202, upload-time = "2026-04-02T18:17:06.452Z" },
-    { url = "https://files.pythonhosted.org/packages/10/11/6da2e538704e753c04e8d86b1fc55712fdbdcc266af1a1ece7a51fff0d10/ruff-0.15.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d910ae974b7a06a33a057cb87d2a10792a3b2b3b35e33d2699fdf63ec8f6b17a", size = 11951057, upload-time = "2026-03-26T18:39:19.18Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/d4/25292a6dfc125f6b6528fe6af31f5e996e19bf73ca8e3ce6eb7fa5b95885/ruff-0.15.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:89dd695bc72ae76ff484ae54b7e8b0f6b50f49046e198355e44ea656e521fef9", size = 11988891, upload-time = "2026-04-02T18:17:18.575Z" },
-    { url = "https://files.pythonhosted.org/packages/83/f0/c9208c5fd5101bf87002fed774ff25a96eea313d305f1e5d5744698dc314/ruff-0.15.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2033f963c43949d51e6fdccd3946633c6b37c484f5f98c3035f49c27395a8ab8", size = 11464613, upload-time = "2026-03-26T18:40:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/13/e1/1eebcb885c10e19f969dcb93d8413dfee8172578709d7ee933640f5e7147/ruff-0.15.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce187224ef1de1bd225bc9a152ac7102a6171107f026e81f317e4257052916d5", size = 11480576, upload-time = "2026-04-02T18:16:52.986Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/22/d7f2fabdba4fae9f3b570e5605d5eb4500dcb7b770d3217dca4428484b17/ruff-0.15.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f29b989a55572fb885b77464cf24af05500806ab4edf9a0fd8977f9759d85b1", size = 11257557, upload-time = "2026-03-26T18:39:57.972Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/6b/a1548ac378a78332a4c3dcf4a134c2475a36d2a22ddfa272acd574140b50/ruff-0.15.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b0c7c341f68adb01c488c3b7d4b49aa8ea97409eae6462d860a79cf55f431b6", size = 11254525, upload-time = "2026-04-02T18:17:02.041Z" },
-    { url = "https://files.pythonhosted.org/packages/71/8c/382a9620038cf6906446b23ce8632ab8c0811b8f9d3e764f58bedd0c9a6f/ruff-0.15.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:ac51d486bf457cdc985a412fb1801b2dfd1bd8838372fc55de64b1510eff4bec", size = 11169440, upload-time = "2026-03-26T18:39:22.205Z" },
+    { url = "https://files.pythonhosted.org/packages/42/aa/4bb3af8e61acd9b1281db2ab77e8b2c3c5e5599bf2a29d4a942f1c62b8d6/ruff-0.15.9-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:55cc15eee27dc0eebdfcb0d185a6153420efbedc15eb1d38fe5e685657b0f840", size = 11204072, upload-time = "2026-04-02T18:17:13.581Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/0d/0994c802a7eaaf99380085e4e40c845f8e32a562e20a38ec06174b52ef24/ruff-0.15.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:c9861eb959edab053c10ad62c278835ee69ca527b6dcd72b47d5c1e5648964f6", size = 10605963, upload-time = "2026-03-26T18:39:46.682Z" },
+    { url = "https://files.pythonhosted.org/packages/69/48/d550dc2aa6e423ea0bcc1d0ff0699325ffe8a811e2dba156bd80750b86dc/ruff-0.15.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a6537f6eed5cda688c81073d46ffdfb962a5f29ecb6f7e770b2dc920598997ed", size = 10594998, upload-time = "2026-04-02T18:16:46.369Z" },
-    { url = "https://files.pythonhosted.org/packages/19/aa/d624b86f5b0aad7cef6bbf9cd47a6a02dfdc4f72c92a337d724e39c9d14b/ruff-0.15.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8d9a5b8ea13f26ae90838afc33f91b547e61b794865374f114f349e9036835fb", size = 10357484, upload-time = "2026-03-26T18:39:49.176Z" },
+    { url = "https://files.pythonhosted.org/packages/63/47/321167e17f5344ed5ec6b0aa2cff64efef5f9e985af8f5622cfa6536043f/ruff-0.15.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:6d3fcbca7388b066139c523bda744c822258ebdcfbba7d24410c3f454cc9af71", size = 10359769, upload-time = "2026-04-02T18:17:10.994Z" },
-    { url = "https://files.pythonhosted.org/packages/35/c3/e0b7835d23001f7d999f3895c6b569927c4d39912286897f625736e1fd04/ruff-0.15.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c2a33a529fb3cbc23a7124b5c6ff121e4d6228029cba374777bd7649cc8598b8", size = 10830426, upload-time = "2026-03-26T18:40:03.702Z" },
+    { url = "https://files.pythonhosted.org/packages/67/5e/074f00b9785d1d2c6f8c22a21e023d0c2c1817838cfca4c8243200a1fa87/ruff-0.15.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:058d8e99e1bfe79d8a0def0b481c56059ee6716214f7e425d8e737e412d69677", size = 10850236, upload-time = "2026-04-02T18:16:48.749Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/51/ab20b322f637b369383adc341d761eaaa0f0203d6b9a7421cd6e783d81b9/ruff-0.15.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:75e5cd06b1cf3f47a3996cfc999226b19aa92e7cce682dcd62f80d7035f98f49", size = 11345125, upload-time = "2026-03-26T18:39:27.799Z" },
+    { url = "https://files.pythonhosted.org/packages/76/37/804c4135a2a2caf042925d30d5f68181bdbd4461fd0d7739da28305df593/ruff-0.15.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:8e1ddb11dbd61d5983fa2d7d6370ef3eb210951e443cace19594c01c72abab4c", size = 11358343, upload-time = "2026-04-02T18:16:55.068Z" },
-    { url = "https://files.pythonhosted.org/packages/37/e6/90b2b33419f59d0f2c4c8a48a4b74b460709a557e8e0064cf33ad894f983/ruff-0.15.8-py3-none-win32.whl", hash = "sha256:bc1f0a51254ba21767bfa9a8b5013ca8149dcf38092e6a9eb704d876de94dc34", size = 10571959, upload-time = "2026-03-26T18:39:36.117Z" },
+    { url = "https://files.pythonhosted.org/packages/88/3d/1364fcde8656962782aa9ea93c92d98682b1ecec2f184e625a965ad3b4a6/ruff-0.15.9-py3-none-win32.whl", hash = "sha256:bde6ff36eaf72b700f32b7196088970bf8fdb2b917b7accd8c371bfc0fd573ec", size = 10583382, upload-time = "2026-04-02T18:17:04.261Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/a2/ef467cb77099062317154c63f234b8a7baf7cb690b99af760c5b68b9ee7f/ruff-0.15.8-py3-none-win_amd64.whl", hash = "sha256:04f79eff02a72db209d47d665ba7ebcad609d8918a134f86cb13dd132159fc89", size = 11743893, upload-time = "2026-03-26T18:39:25.01Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/56/5c7084299bd2cacaa07ae63a91c6f4ba66edc08bf28f356b24f6b717c799/ruff-0.15.9-py3-none-win_amd64.whl", hash = "sha256:45a70921b80e1c10cf0b734ef09421f71b5aa11d27404edc89d7e8a69505e43d", size = 11744969, upload-time = "2026-04-02T18:16:59.611Z" },
-    { url = "https://files.pythonhosted.org/packages/15/e2/77be4fff062fa78d9b2a4dea85d14785dac5f1d0c1fb58ed52331f0ebe28/ruff-0.15.8-py3-none-win_arm64.whl", hash = "sha256:cf891fa8e3bb430c0e7fac93851a5978fc99c8fa2c053b57b118972866f8e5f2", size = 11048175, upload-time = "2026-03-26T18:40:01.06Z" },
+    { url = "https://files.pythonhosted.org/packages/03/36/76704c4f312257d6dbaae3c959add2a622f63fcca9d864659ce6d8d97d3d/ruff-0.15.9-py3-none-win_arm64.whl", hash = "sha256:0694e601c028fd97dc5c6ee244675bc241aeefced7ef80cd9c6935a871078f53", size = 11005870, upload-time = "2026-04-02T18:17:15.773Z" },
 ]
 [[package]]
@@ -1304,26 +1228,26 @@ wheels = [
 [[package]]
 name = "ty"
-version = "0.0.27"
+version = "0.0.29"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f4/de/e5cf1f151cf52fe1189e42d03d90909d7d1354fdc0c1847cbb63a0baa3da/ty-0.0.27.tar.gz", hash = "sha256:d7a8de3421d92420b40c94fe7e7d4816037560621903964dd035cf9bd0204a73", size = 5424130, upload-time = "2026-03-31T19:07:20.806Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/d5/853561de49fae38c519e905b2d8da9c531219608f1fccc47a0fc2c896980/ty-0.0.29.tar.gz", hash = "sha256:e7936cca2f691eeda631876c92809688dbbab68687c3473f526cd83b6a9228d8", size = 5469221, upload-time = "2026-04-05T15:01:21.328Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/20/2a9ea661758bd67f2bfd54ce9daacb5a26c56c5f8b49fbd9a43b365a8a7d/ty-0.0.27-py3-none-linux_armv6l.whl", hash = "sha256:eb14456b8611c9e8287aa9b633f4d2a0d9f3082a31796969e0b50bdda8930281", size = 10571211, upload-time = "2026-03-31T19:07:23.28Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b7/911f9962115acfa24e3b2ec9d4992dd994c38e8769e1b1d7680bb4d28a51/ty-0.0.29-py3-none-linux_armv6l.whl", hash = "sha256:b8a40955f7660d3eaceb0d964affc81b790c0765e7052921a5f861ff8a471c30", size = 10568206, upload-time = "2026-04-05T15:01:19.165Z" },
-    { url = "https://files.pythonhosted.org/packages/da/b2/8887a51f705d075ddbe78ae7f0d4755ef48d0a90235f67aee289e9cee950/ty-0.0.27-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:02e662184703db7586118df611cf24a000d35dae38d950053d1dd7b6736fd2c4", size = 10427576, upload-time = "2026-03-31T19:07:15.499Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c3/fcae2167d4c77a97269f92f11d1b43b03617f81de1283d5d05b43432110c/ty-0.0.29-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6b6849adae15b00bbe2d3c5b078967dcb62eba37d38936b8eeb4c81a82d2e3b8", size = 10442530, upload-time = "2026-04-05T15:01:28.471Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/c3/79d88163f508fb709ce19bc0b0a66c7c64b53d372d4caa56172c3d9b3ae8/ty-0.0.27-py3-none-macosx_11_0_arm64.whl", hash = "sha256:be5fc2899441f7f8f7ef40f9ffd006075a5ff6b06c44e8d2aa30e1b900c12f51", size = 9870359, upload-time = "2026-03-31T19:07:36.852Z" },
+    { url = "https://files.pythonhosted.org/packages/97/33/5a6bfa240cfcb9c36046ae2459fa9ea23238d20130d8656ff5ac4d6c012a/ty-0.0.29-py3-none-macosx_11_0_arm64.whl", hash = "sha256:dcdd9b17209788152f7b7ea815eda07989152325052fe690013537cc7904ce49", size = 9915735, upload-time = "2026-04-05T15:01:10.365Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/4d/ed1b0db0e1e46b5ed4976bbfe0d1825faf003b4e3774ef28c785ed73e4bb/ty-0.0.27-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30231e652b14742a76b64755e54bf0cb1cd4c128bcaf625222e0ca92a2094887", size = 10380488, upload-time = "2026-03-31T19:07:31.268Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/1e/318f45fae232118e81a6306c30f50de42c509c412128d5bd231eab699ffb/ty-0.0.29-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d8ed4789bae78ffaf94462c0d25589a734cab0366b86f2bbcb1bb90e1a7a169", size = 10419748, upload-time = "2026-04-05T15:01:32.375Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/f2/20372f6d510b01570028433064880adec2f8abe68bf0c4603be61a560bef/ty-0.0.27-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5a119b1168f64261b3205a37e40b5b6c4aac8fd58e4587988f4e4b22c3c79847", size = 10390248, upload-time = "2026-03-31T19:07:28.345Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/a8/5687872e2ab5a0f7dd4fd8456eac31e9381ad4dc74961f6f29965ad4dd91/ty-0.0.29-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:91ec374b8565e0ad0900011c24641ebbef2da51adbd4fb69ff3280c8a7eceb02", size = 10394738, upload-time = "2026-04-05T15:01:06.473Z" },
-    { url = "https://files.pythonhosted.org/packages/45/4b/46b31a7311306be1a560f7f20fdc37b5bf718787f60626cd265d9b637554/ty-0.0.27-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e38f4e187b6975d2cbebf0f1eb1221f8f64f6e509bad14d7bb2a91afc97e4956", size = 10878479, upload-time = "2026-03-31T19:07:39.393Z" },
+    { url = "https://files.pythonhosted.org/packages/de/68/015d118097eeb95e6a44c4abce4c0a28b7b9dfb3085b7f0ee48e4f099633/ty-0.0.29-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:298a8d5faa2502d3810bbbb47a030b9455495b9921594206043c785dd61548cf", size = 10910613, upload-time = "2026-04-05T15:01:17.17Z" },
-    { url = "https://files.pythonhosted.org/packages/42/ba/5231a2a1fb1cebe053a25de8fded95e1a30a1e77d3628a9e58487297bafc/ty-0.0.27-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a07b1a8fbb23844f6d22091275430d9ac617175f34aa99159b268193de210389", size = 11461232, upload-time = "2026-03-31T19:07:02.518Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/01/47ce3c6c53e0670eadbe80756b167bf80ed6681d1ba57cfde2e8065a13d1/ty-0.0.29-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c8fba1a3524c6109d1e020d92301c79d41bf442fa8d335b9fa366239339cb70", size = 11475750, upload-time = "2026-04-05T15:01:30.461Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/37/558abab3e1f6670493524f61280b4dfcc3219555f13889223e733381dfab/ty-0.0.27-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d3ec4033031f240836bb0337274bac5c49dde312c7c6d7575451ed719bf8ffa3", size = 11133002, upload-time = "2026-03-31T19:07:18.371Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/cf/e361845b1081c9264ad5b7c963231bab03f2666865a9f2a115c4233f2137/ty-0.0.29-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c48adf88a70d264128c39ee922ed14a947817fced1e93c08c1a89c9244edcde", size = 11190055, upload-time = "2026-04-05T15:01:12.369Z" },
-    { url = "https://files.pythonhosted.org/packages/32/38/188c14a57f52160407ce62c6abb556011718fd0bcbe1dca690529ce84c46/ty-0.0.27-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:924a8849afd500d260bf5b7296165a05b7424fbb6b19113f30f3b999d682873f", size = 10986624, upload-time = "2026-03-31T19:07:13.066Z" },
+    { url = "https://files.pythonhosted.org/packages/79/12/0fb0857e9a62cb11586e9a712103877bbf717f5fb570d16634408cfdefee/ty-0.0.29-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ce0a7a0e96bc7b42518cd3a1a6a6298ef64ff40ca4614355c1aa807059b5c6f", size = 11020539, upload-time = "2026-04-05T15:01:37.022Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/f1/667a71393f47d2cd6ba9ed07541b8df3eb63aab1f2ee658e77d91b8362fa/ty-0.0.27-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d8270026c07e7423a1b3a3fd065b46ed1478748f0662518b523b57744f3fa025", size = 10366721, upload-time = "2026-03-31T19:07:00.131Z" },
+    { url = "https://files.pythonhosted.org/packages/20/36/5a26753802083f80cd125db6c4348ad42b3c982ec36e718e0bf4c18f75e5/ty-0.0.29-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a6ac86a05b4a3731d45365ab97780acc7b8146fa62fccb3cbe94fe6546c67a97", size = 10396399, upload-time = "2026-04-05T15:01:26.167Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/aa/8edafe41be898bda774249abc5be6edd733e53fb1777d59ea9331e38537d/ty-0.0.27-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e26e9735d3bdfd95d881111ad1cf570eab8188d8c3be36d6bcaad044d38984d8", size = 10412239, upload-time = "2026-03-31T19:07:05.297Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e6/b4e75b5752239ab3ab400f19faef4dbef81d05aab5d3419fda0c062a3765/ty-0.0.29-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:6bbbf53141af0f3150bf288d716263f1a3550054e4b3551ca866d38192ba9891", size = 10421461, upload-time = "2026-04-05T15:01:08.367Z" },
-    { url = "https://files.pythonhosted.org/packages/53/ff/8bafaed4a18d38264f46bdfc427de7ea2974cf9064e4e0bdb1b6e6c724e3/ty-0.0.27-py3-none-musllinux_1_2_i686.whl", hash = "sha256:7c09cc9a699810609acc0090af8d0db68adaee6e60a7c3e05ab80cc954a83db7", size = 10573507, upload-time = "2026-03-31T19:06:57.064Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/21/1084b5b609f9abed62070ec0b31c283a403832a6310c8bbc208bd45ee1e6/ty-0.0.29-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1c9e06b770c1d0ff5efc51e34312390db31d53fcf3088163f413030b42b74f84", size = 10599187, upload-time = "2026-04-05T15:01:23.52Z" },
-    { url = "https://files.pythonhosted.org/packages/16/2e/63a8284a2fefd08ab56ecbad0fde7dd4b2d4045a31cf24c1d1fcd9643227/ty-0.0.27-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:2d3e02853bb037221a456e034b1898aaa573e6374fbb53884e33cb7513ccb85a", size = 11090233, upload-time = "2026-03-31T19:07:34.139Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a1/ce19a2ca717bbcc1ee11378aba52ef70b6ce5b87245162a729d9fdc2360f/ty-0.0.29-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:0307fe37e3f000ef1a4ae230bbaf511508a78d24a5e51b40902a21b09d5e6037", size = 11121198, upload-time = "2026-04-05T15:01:15.22Z" },
-    { url = "https://files.pythonhosted.org/packages/14/d3/d6fa1cafdfa2b34dbfa304fc6833af8e1669fc34e24d214fa76d2a2e5a25/ty-0.0.27-py3-none-win32.whl", hash = "sha256:34e7377f2047c14dbbb7bf5322e84114db7a5f2cb470db6bee63f8f3550cfc1e", size = 9984415, upload-time = "2026-03-31T19:07:07.98Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/6b/f1430b279af704321566ce7ec2725d3d8258c2f815ebd93e474c64cd4543/ty-0.0.29-py3-none-win32.whl", hash = "sha256:7a2a898217960a825f8bc0087e1fdbaf379606175e98f9807187221d53a4a8ed", size = 9995331, upload-time = "2026-04-05T15:01:01.32Z" },
-    { url = "https://files.pythonhosted.org/packages/85/e6/dd4e27da9632b3472d5711ca49dbd3709dbd3e8c73f3af6db9c254235ca9/ty-0.0.27-py3-none-win_amd64.whl", hash = "sha256:3f7e4145aad8b815ed69b324c93b5b773eb864dda366ca16ab8693ff88ce6f36", size = 10961535, upload-time = "2026-03-31T19:07:10.566Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ef/3ef01c17785ff9a69378465c7d0faccd48a07b163554db0995e5d65a5a23/ty-0.0.29-py3-none-win_amd64.whl", hash = "sha256:fc1294200226b91615acbf34e0a9ad81caf98c081e9c6a912a31b0a7b603bc3f", size = 11023644, upload-time = "2026-04-05T15:01:04.432Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/1a/824b3496d66852ed7d5d68d9787711131552b68dce8835ce9410db32e618/ty-0.0.27-py3-none-win_arm64.whl", hash = "sha256:95bf8d01eb96bb2ba3ffc39faff19da595176448e80871a7b362f4d2de58476c", size = 10376689, upload-time = "2026-03-31T19:07:25.732Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/55/87280a994d6a2d2647c65e12abbc997ed49835794366153c04c4d9304d76/ty-0.0.29-py3-none-win_arm64.whl", hash = "sha256:f9794bbd1bb3ce13f78c191d0c89ae4c63f52c12b6daa0c6fe220b90d019d12c", size = 10428165, upload-time = "2026-04-05T15:01:34.665Z" },
 ]
 [[package]]
@@ -1400,7 +1324,7 @@ wheels = [
 [[package]]
 name = "zensical"
-version = "0.0.31"
+version = "0.0.32"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "click" },
@@ -1410,18 +1334,18 @@ dependencies = [
    { name = "pymdown-extensions" },
    { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d5/1a/9b6f5285c5aef648db38f9132f49a7059bd2c9d748f68ef0c52ed8afcff3/zensical-0.0.31.tar.gz", hash = "sha256:9c12f07bde70c4bfdb13d6cae1bedf8d18064d257a6e81128a152502b28a8fc3", size = 3891758, upload-time = "2026-04-01T11:30:21.88Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7a/94/4a49ca9329136445f4111fda60e4bfcbe68d95e18e9aa02e4606fba5df4a/zensical-0.0.32.tar.gz", hash = "sha256:0f857b09a2b10c99202b3712e1ffc4d1d1ffa4c7c2f1aa0fafb1346b2d8df604", size = 3891955, upload-time = "2026-04-07T11:41:29.203Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/db/cc4e555d2e816f2d91304ff969d62cc3a401ee477dbb7c720b874bec67d6/zensical-0.0.31-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:b489936d670733dd204f16b689a2acc0e45b69e42cc4901f5131ae57658b8fbc", size = 12419980, upload-time = "2026-04-01T11:29:44.01Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e1/dd03762447f1c2a4c8aff08e8f047ec17c73421714a0600ef71c361a5934/zensical-0.0.32-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:7ed181c76c03fec4c2dd5db207810044bf9c3fa87097fbdbabd633661e20fc70", size = 12416474, upload-time = "2026-04-07T11:40:55.888Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/c1/6789f73164c7f5821f5defb8a80b1dba8d5af24bdec7db36876793c5afd9/zensical-0.0.31-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:d9f678efc0d9918e45eeb8bc62847b2cce23db7393c8c59c1be6d1c064bbaacd", size = 12292301, upload-time = "2026-04-01T11:29:47.277Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/a6/2f1babb00842c6efa5ae755b3ab414e4688ae8e47bdd2e785c0c37ef625d/zensical-0.0.32-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:8cde82bf256408f75ae2b07bffcaac7d080b6aad5f7acf210c438cb7413c3081", size = 12292801, upload-time = "2026-04-07T11:40:59.648Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/9a/6a83ad209081a953e0285d5056e5452c4fbcabd2f104f3797d53e4bdd96f/zensical-0.0.31-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb2b50ecf674997f818e53f12f2a67875a21b0c79ed74c151dfaef2f1475e5bf", size = 12661472, upload-time = "2026-04-01T11:29:50.706Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/f1/d32706de06fd30fb07ae514222a79dd17d4578cd1634e5b692e0c790a61e/zensical-0.0.32-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:60e60e2358249b2a2c5e1c5c04586d8dbba27e577441cc9dd32fe8d879c6951e", size = 12658847, upload-time = "2026-04-07T11:41:02.347Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/4a/a82f5c81893b7a607cf9d439b75c3c3894b4ef4d3e92d5d818b4fa5c6f23/zensical-0.0.31-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6fb5c634fe88254770a2d4db5c05b06f1c3ee5e29d2ae3e7efdae8905e435b1d", size = 12603784, upload-time = "2026-04-01T11:29:53.623Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/42/a3daf4047c86382749a59795c4e7acd59952b4f6f37f329cd2d41cc37a0f/zensical-0.0.32-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ec79b4304009138e7a38ebe24e8a8e9dbc15d38922185f8a84470a7757d7b73f", size = 12604777, upload-time = "2026-04-07T11:41:05.227Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/1c/79c198628b8e006be32dfb1c5b73561757a349a6cf3069600a67ffa62495/zensical-0.0.31-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:94e64630552793274db1ec66c971e49a15ad351536d5d12de67ec6da7358ac50", size = 12959832, upload-time = "2026-04-01T11:29:56.736Z" },
+    { url = "https://files.pythonhosted.org/packages/59/11/4af61d3fb07713cd3f77981c1b3017a60c2b210b36f1b04353f9116d03ca/zensical-0.0.32-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fc92fa7d0860ec6d95426a5f545cfc5493c60f8ab44fcc11611a4251f34f1b70", size = 12956242, upload-time = "2026-04-07T11:41:07.58Z" },
-    { url = "https://files.pythonhosted.org/packages/db/9d/45839d9ca0f69622e8a3b944f2d8d7f7d2b7c2da78201079c4feb275feb6/zensical-0.0.31-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:738a2fd5832e3b3c10ff642eebaf89c89ca1d28e4451dad0f36fdac53c415577", size = 12704024, upload-time = "2026-04-01T11:29:59.836Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/34/e9b5f4376bbf460f8c07a77af59bd169c7c68ed719a074e6667ba41109f8/zensical-0.0.32-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07f69019396060e310c9c3b18747ce8982ad56d67fbab269b61e74a6a5bdcb4a", size = 12701954, upload-time = "2026-04-07T11:41:10.532Z" },
-    { url = "https://files.pythonhosted.org/packages/df/5f/451d7f4d94092bc38bd8d514826fb7b0329c188db506795b1d20bd07d517/zensical-0.0.31-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:bd601f6132e285ef6c3e4c3852be2094fc0473295a8080003db76a79760f84fb", size = 12837788, upload-time = "2026-04-01T11:30:03.048Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/43/a52e5dcb324f38a1d22f7fafd4eec273385d04de52a7ab5ac7b444cf2bdc/zensical-0.0.32-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d096c9ed20a48e5ff095eca218eef94f67e739cdf0abf7e1f7e232e78f6d980c", size = 12835464, upload-time = "2026-04-07T11:41:13.152Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/39/390a8fc384fb174ebd4450343a0aa2877b3a31ddcedf5ef0b8d26944e12c/zensical-0.0.31-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:dc3b6a9dfb5903c0aa779ef65cd6185add2b8aa1db237be840874b8c9db761b8", size = 12876822, upload-time = "2026-04-01T11:30:06.418Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/95/bede89ecb4932bbd29db7b61bf530a962aed09d3a8d5aa71a64af1d4920f/zensical-0.0.32-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:bf5576b7154bde18cebd9a7b065d3ab8b334c6e73d5b2e83abe2b17f9d00a992", size = 12876574, upload-time = "2026-04-07T11:41:16.085Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/60/640da2f095782cf38974cd851fb7afa62651d09a36543a1d8942b31aabdc/zensical-0.0.31-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:ddd4321b275e82c4897aa45b05038ce204b88fb311ad55f8c2af572173a9b56c", size = 13024036, upload-time = "2026-04-01T11:30:09.501Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e8/9b25fda22bf729ca2598cc42cefe9b20e751d12d23e35c70ea0c7939d20a/zensical-0.0.32-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:f33905a1e0b03a2ad548554a157b7f7c398e6f41012d1e755105ae2bc60eab8a", size = 13022702, upload-time = "2026-04-07T11:41:18.947Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/06/0564377cbfccea3653254adfa851c1b20d1696e4b16770c7b2e1dd1ef1d7/zensical-0.0.31-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:147ab4bc17f3088f703aa6c4b9c416411f4ea8ca64d26f6586beae49d97fd3c7", size = 12975505, upload-time = "2026-04-01T11:30:12.268Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/35/0c6d0b57187bd470a05e8a391c0edd1d690eb429e12b9755c99cf60a370e/zensical-0.0.32-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:0a73a53b1dd41fd239875a3cb57c4284747989c45b6933f18e9b51f1b5f3d8ef", size = 12975593, upload-time = "2026-04-07T11:41:21.436Z" },
-    { url = "https://files.pythonhosted.org/packages/35/4b/b8a0c4e5937cb05882dcce667798403e00897135080a69f92363e5e3ff9f/zensical-0.0.31-cp310-abi3-win32.whl", hash = "sha256:03fa11e629a308507693489541f43e751697784e94365e7435b02104aefd1c2c", size = 12011233, upload-time = "2026-04-01T11:30:15.496Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/2d/4e88bcefc33b7af22f0637fd002d3cf5384e8354f0a7f8a9dbfcd40cfa24/zensical-0.0.32-cp310-abi3-win32.whl", hash = "sha256:f8cb579bdb9b56f1704b93f4e17b42895c8cb466e8eec933fbe0153b5b1e3459", size = 12012163, upload-time = "2026-04-07T11:41:23.975Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/99/0eacdb466d344c0c86596932201268517be42f3e0bb6c78b2b0cd84c55f6/zensical-0.0.31-cp310-abi3-win_amd64.whl", hash = "sha256:d6621d4bb46af4143560045d4a18c8c76302db56bf1dbb6e2ce107d7fb643e09", size = 12207545, upload-time = "2026-04-01T11:30:19.054Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/ae/a80a2f15fd10201fe3dfd6b5cdf85351165f820cf5b29e3c3b24092c158c/zensical-0.0.32-cp310-abi3-win_amd64.whl", hash = "sha256:6d662f42b5d0eadfac6d281e9d86574bc7a9f812f1ed496335d15f2d581d4b28", size = 12205948, upload-time = "2026-04-07T11:41:27.056Z" },
 ]
Author	SHA1	Message	Date
d3vyce	94e7d79d06	Version 3.1.0	2026-04-12 12:48:32 -04:00
d3vyce	9268b576b4	feat: add M2M helpers (#247 )	2026-04-12 18:46:57 +02:00
d3vyce	863e6ce6e9	feat: add get_field_by_attr fixtures helper (#245 )	2026-04-12 17:12:08 +02:00
d3vyce	c7397faea4	feat: auto eager-load relationships in register_fixtures (#243 )	2026-04-12 17:04:44 +02:00
dependabot[bot]	aca3f62a6b	⬆ Bump ruff from 0.15.8 to 0.15.9 (#241 ) Bumps [ruff](https://github.com/astral-sh/ruff) from 0.15.8 to 0.15.9. - [Release notes](https://github.com/astral-sh/ruff/releases) - [Changelog](https://github.com/astral-sh/ruff/blob/main/CHANGELOG.md) - [Commits](https://github.com/astral-sh/ruff/compare/0.15.8...0.15.9) --- updated-dependencies: - dependency-name: ruff dependency-version: 0.15.9 dependency-type: direct:development update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-04-09 10:01:30 +02:00
dependabot[bot]	8030e1988c	⬆ Bump zensical from 0.0.31 to 0.0.32 (#240 ) Bumps [zensical](https://github.com/zensical/zensical) from 0.0.31 to 0.0.32. - [Release notes](https://github.com/zensical/zensical/releases) - [Commits](https://github.com/zensical/zensical/compare/v0.0.31...v0.0.32) --- updated-dependencies: - dependency-name: zensical dependency-version: 0.0.32 dependency-type: direct:development update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-04-09 10:01:14 +02:00
dependabot[bot]	e2c2c1c835	⬆ Bump ty from 0.0.27 to 0.0.29 (#239 ) Bumps [ty](https://github.com/astral-sh/ty) from 0.0.27 to 0.0.29. - [Release notes](https://github.com/astral-sh/ty/releases) - [Changelog](https://github.com/astral-sh/ty/blob/main/CHANGELOG.md) - [Commits](https://github.com/astral-sh/ty/compare/0.0.27...0.0.29) --- updated-dependencies: - dependency-name: ty dependency-version: 0.0.29 dependency-type: direct:development update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-04-09 10:01:02 +02:00
dependabot[bot]	025b954d01	⬆ Bump pytest from 9.0.2 to 9.0.3 (#238 ) Bumps [pytest](https://github.com/pytest-dev/pytest) from 9.0.2 to 9.0.3. - [Release notes](https://github.com/pytest-dev/pytest/releases) - [Changelog](https://github.com/pytest-dev/pytest/blob/main/CHANGELOG.rst) - [Commits](https://github.com/pytest-dev/pytest/compare/9.0.2...9.0.3) --- updated-dependencies: - dependency-name: pytest dependency-version: 9.0.3 dependency-type: direct:development update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-04-09 10:00:49 +02:00