fastapi-toolsets 0.2.0__tar.gz → 0.3.0__tar.gz

{fastapi_toolsets-0.2.0 → fastapi_toolsets-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-toolsets
-Version: 0.2.0
+Version: 0.3.0
 Summary: Reusable tools for FastAPI: async CRUD, fixtures, CLI, and standardized responses for SQLAlchemy + PostgreSQL
 Keywords: fastapi,sqlalchemy,postgresql
 Author: d3vyce

{fastapi_toolsets-0.2.0 → fastapi_toolsets-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-toolsets"
-version = "0.2.0"
+version = "0.3.0"
 description = "Reusable tools for FastAPI: async CRUD, fixtures, CLI, and standardized responses for SQLAlchemy + PostgreSQL"
 readme = "README.md"
 license = "MIT"

{fastapi_toolsets-0.2.0 → fastapi_toolsets-0.3.0}/src/fastapi_toolsets/__init__.py

@@ -21,4 +21,4 @@ Example usage:
         return Response(data={"user": user.username}, message="Success")
 """
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"

fastapi_toolsets-0.3.0/src/fastapi_toolsets/fixtures/__init__.py

@@ -0,0 +1,13 @@
+from .enum import LoadStrategy
+from .registry import Context, FixtureRegistry
+from .utils import get_obj_by_attr, load_fixtures, load_fixtures_by_context
+
+__all__ = [
+    "Context",
+    "FixtureRegistry",
+    "LoadStrategy",
+    "get_obj_by_attr",
+    "load_fixtures",
+    "load_fixtures_by_context",
+    "register_fixtures",
+]

fastapi_toolsets-0.3.0/src/fastapi_toolsets/fixtures/enum.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+
+class LoadStrategy(str, Enum):
+    """Strategy for loading fixtures into the database."""
+
+    INSERT = "insert"
+    """Insert new records. Fails if record already exists."""
+
+    MERGE = "merge"
+    """Insert or update based on primary key (SQLAlchemy merge)."""
+
+    SKIP_EXISTING = "skip_existing"
+    """Insert only if record doesn't exist (based on primary key)."""
+
+
+class Context(str, Enum):
+    """Predefined fixture contexts."""
+
+    BASE = "base"
+    """Base fixtures loaded in all environments."""
+
+    PRODUCTION = "production"
+    """Production-only fixtures."""
+
+    DEVELOPMENT = "development"
+    """Development fixtures."""
+
+    TESTING = "testing"
+    """Test fixtures."""

fastapi_toolsets-0.2.0/src/fastapi_toolsets/fixtures/fixtures.py → fastapi_toolsets-0.3.0/src/fastapi_toolsets/fixtures/registry.py

@@ -3,46 +3,15 @@
 import logging
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
-from enum import Enum
 from typing import Any, cast
 
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import DeclarativeBase
 
-from ..db import get_transaction
+from .enum import Context
 
 logger = logging.getLogger(__name__)
 
 
-class LoadStrategy(str, Enum):
-    """Strategy for loading fixtures into the database."""
-
-    INSERT = "insert"
-    """Insert new records. Fails if record already exists."""
-
-    MERGE = "merge"
-    """Insert or update based on primary key (SQLAlchemy merge)."""
-
-    SKIP_EXISTING = "skip_existing"
-    """Insert only if record doesn't exist (based on primary key)."""
-
-
-class Context(str, Enum):
-    """Predefined fixture contexts."""
-
-    BASE = "base"
-    """Base fixtures loaded in all environments."""
-
-    PRODUCTION = "production"
-    """Production-only fixtures."""
-
-    DEVELOPMENT = "development"
-    """Development fixtures."""
-
-    TESTING = "testing"
-    """Test fixtures."""
-
-
 @dataclass
 class Fixture:
     """A fixture definition with metadata."""
@@ -204,118 +173,3 @@ class FixtureRegistry:
             all_deps.update(deps)
 
         return self.resolve_dependencies(*all_deps)
-
-
-async def load_fixtures(
-    session: AsyncSession,
-    registry: FixtureRegistry,
-    *names: str,
-    strategy: LoadStrategy = LoadStrategy.MERGE,
-) -> dict[str, list[DeclarativeBase]]:
-    """Load specific fixtures by name with dependencies.
-
-    Args:
-        session: Database session
-        registry: Fixture registry
-        *names: Fixture names to load (dependencies auto-resolved)
-        strategy: How to handle existing records
-
-    Returns:
-        Dict mapping fixture names to loaded instances
-
-    Example:
-        # Loads 'roles' first (dependency), then 'users'
-        result = await load_fixtures(session, fixtures, "users")
-        print(result["users"])  # [User(...), ...]
-    """
-    ordered = registry.resolve_dependencies(*names)
-    return await _load_ordered(session, registry, ordered, strategy)
-
-
-async def load_fixtures_by_context(
-    session: AsyncSession,
-    registry: FixtureRegistry,
-    *contexts: str | Context,
-    strategy: LoadStrategy = LoadStrategy.MERGE,
-) -> dict[str, list[DeclarativeBase]]:
-    """Load all fixtures for specific contexts.
-
-    Args:
-        session: Database session
-        registry: Fixture registry
-        *contexts: Contexts to load (e.g., Context.BASE, Context.TESTING)
-        strategy: How to handle existing records
-
-    Returns:
-        Dict mapping fixture names to loaded instances
-
-    Example:
-        # Load base + testing fixtures
-        await load_fixtures_by_context(
-            session, fixtures,
-            Context.BASE, Context.TESTING
-        )
-    """
-    ordered = registry.resolve_context_dependencies(*contexts)
-    return await _load_ordered(session, registry, ordered, strategy)
-
-
-async def _load_ordered(
-    session: AsyncSession,
-    registry: FixtureRegistry,
-    ordered_names: list[str],
-    strategy: LoadStrategy,
-) -> dict[str, list[DeclarativeBase]]:
-    """Load fixtures in order."""
-    results: dict[str, list[DeclarativeBase]] = {}
-
-    for name in ordered_names:
-        fixture = registry.get(name)
-        instances = list(fixture.func())
-
-        if not instances:
-            results[name] = []
-            continue
-
-        model_name = type(instances[0]).__name__
-        loaded: list[DeclarativeBase] = []
-
-        async with get_transaction(session):
-            for instance in instances:
-                if strategy == LoadStrategy.INSERT:
-                    session.add(instance)
-                    loaded.append(instance)
-
-                elif strategy == LoadStrategy.MERGE:
-                    merged = await session.merge(instance)
-                    loaded.append(merged)
-
-                elif strategy == LoadStrategy.SKIP_EXISTING:
-                    pk = _get_primary_key(instance)
-                    if pk is not None:
-                        existing = await session.get(type(instance), pk)
-                        if existing is None:
-                            session.add(instance)
-                            loaded.append(instance)
-                    else:
-                        session.add(instance)
-                        loaded.append(instance)
-
-        results[name] = loaded
-        logger.info(f"Loaded fixture '{name}': {len(loaded)} {model_name}(s)")
-
-    return results
-
-
-def _get_primary_key(instance: DeclarativeBase) -> Any | None:
-    """Get the primary key value of a model instance."""
-    mapper = instance.__class__.__mapper__
-    pk_cols = mapper.primary_key
-
-    if len(pk_cols) == 1:
-        return getattr(instance, pk_cols[0].name, None)
-
-    pk_values = tuple(getattr(instance, col.name, None) for col in pk_cols)
-    if all(v is not None for v in pk_values):
-        return pk_values
-    return None

fastapi_toolsets-0.3.0/src/fastapi_toolsets/fixtures/utils.py

@@ -0,0 +1,149 @@
+import logging
+from collections.abc import Callable, Sequence
+from typing import Any, TypeVar
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import DeclarativeBase
+
+from ..db import get_transaction
+from .enum import LoadStrategy
+from .registry import Context, FixtureRegistry
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=DeclarativeBase)
+
+
+def get_obj_by_attr(
+    fixtures: Callable[[], Sequence[T]], attr_name: str, value: Any
+) -> T:
+    """Get a SQLAlchemy model instance by matching an attribute value.
+
+    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.
+
+    Returns:
+        The first model instance where the attribute matches the given value.
+
+    Raises:
+        StopIteration: If no matching object is found.
+    """
+    return next(obj for obj in fixtures() if getattr(obj, attr_name) == value)
+
+
+async def load_fixtures(
+    session: AsyncSession,
+    registry: FixtureRegistry,
+    *names: str,
+    strategy: LoadStrategy = LoadStrategy.MERGE,
+) -> dict[str, list[DeclarativeBase]]:
+    """Load specific fixtures by name with dependencies.
+
+    Args:
+        session: Database session
+        registry: Fixture registry
+        *names: Fixture names to load (dependencies auto-resolved)
+        strategy: How to handle existing records
+
+    Returns:
+        Dict mapping fixture names to loaded instances
+
+    Example:
+        # Loads 'roles' first (dependency), then 'users'
+        result = await load_fixtures(session, fixtures, "users")
+        print(result["users"])  # [User(...), ...]
+    """
+    ordered = registry.resolve_dependencies(*names)
+    return await _load_ordered(session, registry, ordered, strategy)
+
+
+async def load_fixtures_by_context(
+    session: AsyncSession,
+    registry: FixtureRegistry,
+    *contexts: str | Context,
+    strategy: LoadStrategy = LoadStrategy.MERGE,
+) -> dict[str, list[DeclarativeBase]]:
+    """Load all fixtures for specific contexts.
+
+    Args:
+        session: Database session
+        registry: Fixture registry
+        *contexts: Contexts to load (e.g., Context.BASE, Context.TESTING)
+        strategy: How to handle existing records
+
+    Returns:
+        Dict mapping fixture names to loaded instances
+
+    Example:
+        # Load base + testing fixtures
+        await load_fixtures_by_context(
+            session, fixtures,
+            Context.BASE, Context.TESTING
+        )
+    """
+    ordered = registry.resolve_context_dependencies(*contexts)
+    return await _load_ordered(session, registry, ordered, strategy)
+
+
+async def _load_ordered(
+    session: AsyncSession,
+    registry: FixtureRegistry,
+    ordered_names: list[str],
+    strategy: LoadStrategy,
+) -> dict[str, list[DeclarativeBase]]:
+    """Load fixtures in order."""
+    results: dict[str, list[DeclarativeBase]] = {}
+
+    for name in ordered_names:
+        fixture = registry.get(name)
+        instances = list(fixture.func())
+
+        if not instances:
+            results[name] = []
+            continue
+
+        model_name = type(instances[0]).__name__
+        loaded: list[DeclarativeBase] = []
+
+        async with get_transaction(session):
+            for instance in instances:
+                if strategy == LoadStrategy.INSERT:
+                    session.add(instance)
+                    loaded.append(instance)
+
+                elif strategy == LoadStrategy.MERGE:
+                    merged = await session.merge(instance)
+                    loaded.append(merged)
+
+                elif strategy == LoadStrategy.SKIP_EXISTING:
+                    pk = _get_primary_key(instance)
+                    if pk is not None:
+                        existing = await session.get(type(instance), pk)
+                        if existing is None:
+                            session.add(instance)
+                            loaded.append(instance)
+                    else:
+                        session.add(instance)
+                        loaded.append(instance)
+
+        results[name] = loaded
+        logger.info(f"Loaded fixture '{name}': {len(loaded)} {model_name}(s)")
+
+    return results
+
+
+def _get_primary_key(instance: DeclarativeBase) -> Any | None:
+    """Get the primary key value of a model instance."""
+    mapper = instance.__class__.__mapper__
+    pk_cols = mapper.primary_key
+
+    if len(pk_cols) == 1:
+        return getattr(instance, pk_cols[0].name, None)
+
+    pk_values = tuple(getattr(instance, col.name, None) for col in pk_cols)
+    if all(v is not None for v in pk_values):
+        return pk_values
+    return None

fastapi_toolsets-0.3.0/src/fastapi_toolsets/pytest/__init__.py

@@ -0,0 +1,8 @@
+from .plugin import register_fixtures
+from .utils import create_async_client, create_db_session
+
+__all__ = [
+    "create_async_client",
+    "create_db_session",
+    "register_fixtures",
+]

fastapi_toolsets-0.2.0/src/fastapi_toolsets/fixtures/pytest_plugin.py → fastapi_toolsets-0.3.0/src/fastapi_toolsets/pytest/plugin.py

@@ -59,7 +59,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import DeclarativeBase
 
 from ..db import get_transaction
-from .fixtures import FixtureRegistry, LoadStrategy
+from ..fixtures import FixtureRegistry, LoadStrategy
 
 
 def register_fixtures(

fastapi_toolsets-0.3.0/src/fastapi_toolsets/pytest/utils.py

@@ -0,0 +1,110 @@
+"""Pytest helper utilities for FastAPI testing."""
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
+
+from ..db import create_db_context
+
+
+@asynccontextmanager
+async def create_async_client(
+    app: Any,
+    base_url: str = "http://test",
+) -> AsyncGenerator[AsyncClient, None]:
+    """Create an async httpx client for testing FastAPI applications.
+
+    Args:
+        app: FastAPI application instance.
+        base_url: Base URL for requests. Defaults to "http://test".
+
+    Yields:
+        An AsyncClient configured for the app.
+
+    Example:
+        ```python
+        from fastapi import FastAPI
+        from fastapi_toolsets.pytest import create_async_client
+
+        app = FastAPI()
+
+        @pytest.fixture
+        async def client():
+            async with create_async_client(app) as c:
+                yield c
+
+        async def test_endpoint(client: AsyncClient):
+            response = await client.get("/health")
+            assert response.status_code == 200
+        ```
+    """
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url=base_url) as client:
+        yield client
+
+
+@asynccontextmanager
+async def create_db_session(
+    database_url: str,
+    base: type[DeclarativeBase],
+    *,
+    echo: bool = False,
+    expire_on_commit: bool = False,
+    drop_tables: bool = True,
+) -> AsyncGenerator[AsyncSession, None]:
+    """Create a database session for testing.
+
+    Creates tables before yielding the session and optionally drops them after.
+    Each call creates a fresh engine and session for test isolation.
+
+    Args:
+        database_url: Database connection URL (e.g., "postgresql+asyncpg://...").
+        base: SQLAlchemy DeclarativeBase class containing model metadata.
+        echo: Enable SQLAlchemy query logging. Defaults to False.
+        expire_on_commit: Expire objects after commit. Defaults to False.
+        drop_tables: Drop tables after test. Defaults to True.
+
+    Yields:
+        An AsyncSession ready for database operations.
+
+    Example:
+        ```python
+        from fastapi_toolsets.pytest import create_db_session
+        from app.models import Base
+
+        DATABASE_URL = "postgresql+asyncpg://user:pass@localhost/test_db"
+
+        @pytest.fixture
+        async def db_session():
+            async with create_db_session(DATABASE_URL, Base) as session:
+                yield session
+
+        async def test_create_user(db_session: AsyncSession):
+            user = User(name="test")
+            db_session.add(user)
+            await db_session.commit()
+        ```
+    """
+    engine = create_async_engine(database_url, echo=echo)
+
+    try:
+        # Create tables
+        async with engine.begin() as conn:
+            await conn.run_sync(base.metadata.create_all)
+
+        # Create session using existing db context utility
+        session_maker = async_sessionmaker(engine, expire_on_commit=expire_on_commit)
+        get_session = create_db_context(session_maker)
+
+        async with get_session() as session:
+            yield session
+
+        if drop_tables:
+            async with engine.begin() as conn:
+                await conn.run_sync(base.metadata.drop_all)
+    finally:
+        await engine.dispose()

fastapi_toolsets-0.2.0/src/fastapi_toolsets/fixtures/__init__.py

@@ -1,27 +0,0 @@
-from .fixtures import (
-    Context,
-    FixtureRegistry,
-    LoadStrategy,
-    load_fixtures,
-    load_fixtures_by_context,
-)
-from .utils import get_obj_by_attr
-
-__all__ = [
-    "Context",
-    "FixtureRegistry",
-    "LoadStrategy",
-    "get_obj_by_attr",
-    "load_fixtures",
-    "load_fixtures_by_context",
-    "register_fixtures",
-]
-
-
-# We lazy-load register_fixtures to avoid needing pytest when using fixtures CLI
-def __getattr__(name: str):
-    if name == "register_fixtures":
-        from .pytest_plugin import register_fixtures
-
-        return register_fixtures
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

fastapi_toolsets-0.2.0/src/fastapi_toolsets/fixtures/utils.py

@@ -1,26 +0,0 @@
-from collections.abc import Callable, Sequence
-from typing import Any, TypeVar
-
-from sqlalchemy.orm import DeclarativeBase
-
-T = TypeVar("T", bound=DeclarativeBase)
-
-
-def get_obj_by_attr(
-    fixtures: Callable[[], Sequence[T]], attr_name: str, value: Any
-) -> T:
-    """Get a SQLAlchemy model instance by matching an attribute value.
-
-    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.
-
-    Returns:
-        The first model instance where the attribute matches the given value.
-
-    Raises:
-        StopIteration: If no matching object is found.
-    """
-    return next(obj for obj in fixtures() if getattr(obj, attr_name) == value)