fastapi-toolsets 0.5.0__tar.gz → 0.6.0__tar.gz

{fastapi_toolsets-0.5.0 → fastapi_toolsets-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-toolsets
-Version: 0.5.0
+Version: 0.6.0
 Summary: Reusable tools for FastAPI: async CRUD, fixtures, CLI, and standardized responses for SQLAlchemy + PostgreSQL
 Keywords: fastapi,sqlalchemy,postgresql
 Author: d3vyce
@@ -77,7 +77,7 @@ uv add fastapi-toolsets
 
 - **CRUD**: Generic async CRUD operations with `CrudFactory`
 - **Fixtures**: Fixture system with dependency management, context support and pytest integration
-- **CLI**: Django-like command-line interface for fixtures and custom commands
+- **CLI**: Django-like command-line interface with fixture management and custom commands support
 - **Standardized API Responses**: Consistent response format across your API
 - **Exception Handling**: Structured error responses with automatic OpenAPI documentation
 

{fastapi_toolsets-0.5.0 → fastapi_toolsets-0.6.0}/README.md

@@ -28,7 +28,7 @@ uv add fastapi-toolsets
 
 - **CRUD**: Generic async CRUD operations with `CrudFactory`
 - **Fixtures**: Fixture system with dependency management, context support and pytest integration
-- **CLI**: Django-like command-line interface for fixtures and custom commands
+- **CLI**: Django-like command-line interface with fixture management and custom commands support
 - **Standardized API Responses**: Consistent response format across your API
 - **Exception Handling**: Structured error responses with automatic OpenAPI documentation
 

{fastapi_toolsets-0.5.0 → fastapi_toolsets-0.6.0}/pyproject.toml

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

{fastapi_toolsets-0.5.0 → fastapi_toolsets-0.6.0}/src/fastapi_toolsets/__init__.py

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

{fastapi_toolsets-0.5.0 → fastapi_toolsets-0.6.0}/src/fastapi_toolsets/cli/__init__.py

@@ -1,6 +1,5 @@
 """CLI for FastAPI projects."""
 
-from .app import cli
 from .utils import async_command
 
-__all__ = ["async_command", "cli"]
+__all__ = ["async_command"]

fastapi_toolsets-0.6.0/src/fastapi_toolsets/cli/app.py

@@ -0,0 +1,30 @@
+"""Main CLI application."""
+
+import typer
+
+from .config import get_custom_cli
+from .pyproject import load_pyproject
+
+# Use custom CLI if configured, otherwise create default one
+_custom_cli = get_custom_cli()
+
+if _custom_cli is not None:
+    cli = _custom_cli
+else:
+    cli = typer.Typer(
+        name="manager",
+        help="CLI utilities for FastAPI projects.",
+        no_args_is_help=True,
+    )
+
+_config = load_pyproject()
+if _config.get("fixtures") and _config.get("db_context"):
+    from .commands.fixtures import fixture_cli
+
+    cli.add_typer(fixture_cli, name="fixtures")
+
+
+@cli.callback()
+def main(ctx: typer.Context) -> None:
+    """FastAPI utilities CLI."""
+    ctx.ensure_object(dict)

{fastapi_toolsets-0.5.0 → fastapi_toolsets-0.6.0}/src/fastapi_toolsets/cli/commands/fixtures.py

@@ -7,7 +7,7 @@ from rich.console import Console
 from rich.table import Table
 
 from ...fixtures import Context, LoadStrategy, load_fixtures_by_context
-from ..config import CliConfig
+from ..config import get_db_context, get_fixtures_registry
 from ..utils import async_command
 
 fixture_cli = typer.Typer(
@@ -18,27 +18,21 @@ fixture_cli = typer.Typer(
 console = Console()
 
 
-def _get_config(ctx: typer.Context) -> CliConfig:
-    """Get CLI config from context."""
-    return ctx.obj["config"]
-
-
 @fixture_cli.command("list")
 def list_fixtures(
     ctx: typer.Context,
     context: Annotated[
-        str | None,
+        Context | None,
         typer.Option(
             "--context",
             "-c",
-            help="Filter by context (base, production, development, testing).",
+            help="Filter by context.",
         ),
     ] = None,
 ) -> None:
     """List all registered fixtures."""
-    config = _get_config(ctx)
-    registry = config.get_fixtures_registry()
-    fixtures = registry.get_by_context(context) if context else registry.get_all()
+    registry = get_fixtures_registry()
+    fixtures = registry.get_by_context(context.value) if context else registry.get_all()
 
     if not fixtures:
         print("No fixtures found.")
@@ -60,17 +54,13 @@ def list_fixtures(
 async def load(
     ctx: typer.Context,
     contexts: Annotated[
-        list[str] | None,
-        typer.Argument(
-            help="Contexts to load (base, production, development, testing)."
-        ),
+        list[Context] | None,
+        typer.Argument(help="Contexts to load."),
     ] = None,
     strategy: Annotated[
-        str,
-        typer.Option(
-            "--strategy", "-s", help="Load strategy: merge, insert, skip_existing."
-        ),
-    ] = "merge",
+        LoadStrategy,
+        typer.Option("--strategy", "-s", help="Load strategy."),
+    ] = LoadStrategy.MERGE,
     dry_run: Annotated[
         bool,
         typer.Option(
@@ -79,19 +69,10 @@ async def load(
     ] = False,
 ) -> None:
     """Load fixtures into the database."""
-    config = _get_config(ctx)
-    registry = config.get_fixtures_registry()
-    get_db_context = config.get_db_context()
-
-    context_list = contexts if contexts else [Context.BASE]
+    registry = get_fixtures_registry()
+    db_context = get_db_context()
 
-    try:
-        load_strategy = LoadStrategy(strategy)
-    except ValueError:
-        typer.echo(
-            f"Invalid strategy: {strategy}. Use: merge, insert, skip_existing", err=True
-        )
-        raise typer.Exit(1)
+    context_list = [c.value for c in contexts] if contexts else [Context.BASE]
 
     ordered = registry.resolve_context_dependencies(*context_list)
 
@@ -99,7 +80,7 @@ async def load(
         print("No fixtures to load for the specified context(s).")
         return
 
-    print(f"\nFixtures to load ({load_strategy.value} strategy):")
+    print(f"\nFixtures to load ({strategy.value} strategy):")
     for name in ordered:
         fixture = registry.get(name)
         instances = list(fixture.func())
@@ -110,9 +91,9 @@ async def load(
         print("\n[Dry run - no changes made]")
         return
 
-    async with get_db_context() as session:
+    async with db_context() as session:
         result = await load_fixtures_by_context(
-            session, registry, *context_list, strategy=load_strategy
+            session, registry, *context_list, strategy=strategy
         )
 
     total = sum(len(items) for items in result.values())

fastapi_toolsets-0.6.0/src/fastapi_toolsets/cli/config.py

@@ -0,0 +1,107 @@
+"""CLI configuration and dynamic imports."""
+
+import importlib
+import sys
+
+import typer
+
+from .pyproject import find_pyproject, load_pyproject
+
+
+def _ensure_project_in_path():
+    """Add project root to sys.path if not installed in editable mode."""
+    pyproject = find_pyproject()
+    if pyproject:
+        project_root = str(pyproject.parent)
+        if project_root not in sys.path:
+            sys.path.insert(0, project_root)
+
+
+def import_from_string(import_path: str):
+    """Import an object from a string path like 'module.submodule:attribute'.
+
+    Raises:
+        typer.BadParameter: If the import path is invalid or import fails.
+    """
+    if ":" not in import_path:
+        raise typer.BadParameter(
+            f"Invalid import path '{import_path}'. Expected format: 'module:attribute'"
+        )
+
+    module_path, attr_name = import_path.rsplit(":", 1)
+
+    _ensure_project_in_path()
+
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError as e:
+        raise typer.BadParameter(f"Cannot import module '{module_path}': {e}")
+
+    if not hasattr(module, attr_name):
+        raise typer.BadParameter(
+            f"Module '{module_path}' has no attribute '{attr_name}'"
+        )
+
+    return getattr(module, attr_name)
+
+
+def get_config_value(key: str, required: bool = False):
+    """Get a configuration value from pyproject.toml.
+
+    Args:
+        key: The configuration key in [tool.fastapi-toolsets].
+        required: If True, raises an error when the key is missing.
+
+    Returns:
+        The configuration value, or None if not found and not required.
+
+    Raises:
+        typer.BadParameter: If required=True and the key is missing.
+    """
+    config = load_pyproject()
+    value = config.get(key)
+
+    if required and value is None:
+        raise typer.BadParameter(
+            f"No '{key}' configured. "
+            f"Add '{key}' to [tool.fastapi-toolsets] in pyproject.toml."
+        )
+
+    return value
+
+
+def get_fixtures_registry():
+    """Import and return the fixtures registry from config."""
+    from ..fixtures import FixtureRegistry
+
+    import_path = get_config_value("fixtures", required=True)
+    registry = import_from_string(import_path)
+
+    if not isinstance(registry, FixtureRegistry):
+        raise typer.BadParameter(
+            f"'fixtures' must be a FixtureRegistry instance, got {type(registry).__name__}"
+        )
+
+    return registry
+
+
+def get_db_context():
+    """Import and return the db_context function from config."""
+    import_path = get_config_value("db_context", required=True)
+    return import_from_string(import_path)
+
+
+def get_custom_cli() -> typer.Typer | None:
+    """Import and return the custom CLI Typer instance from config."""
+    import_path = get_config_value("custom_cli")
+    if not import_path:
+        return None
+
+    custom = import_from_string(import_path)
+
+    if not isinstance(custom, typer.Typer):
+        raise typer.BadParameter(
+            f"'custom_cli' must be a Typer instance, got {type(custom).__name__}"
+        )
+
+    return custom

fastapi_toolsets-0.6.0/src/fastapi_toolsets/cli/pyproject.py

@@ -0,0 +1,43 @@
+"""Pyproject.toml discovery and loading."""
+
+import tomllib
+from pathlib import Path
+
+TOOL_NAME = "fastapi-toolsets"
+
+
+def find_pyproject(start_path: Path | None = None) -> Path | None:
+    """Find pyproject.toml by walking up the directory tree.
+
+    Similar to how pytest, black, and ruff discover their config files.
+    """
+    path = (start_path or Path.cwd()).resolve()
+
+    for directory in [path, *path.parents]:
+        pyproject = directory / "pyproject.toml"
+        if pyproject.is_file():
+            return pyproject
+
+    return None
+
+
+def load_pyproject(path: Path | None = None) -> dict:
+    """Load tool configuration from pyproject.toml.
+
+    Args:
+        path: Explicit path to pyproject.toml. If None, searches up from cwd.
+
+    Returns:
+        The [tool.fastapi-toolsets] section as a dict, or empty dict if not found.
+    """
+    pyproject_path = path or find_pyproject()
+
+    if not pyproject_path:
+        return {}
+
+    try:
+        with open(pyproject_path, "rb") as f:
+            data = tomllib.load(f)
+        return data.get("tool", {}).get(TOOL_NAME, {})
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}

fastapi_toolsets-0.6.0/src/fastapi_toolsets/dependencies/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI dependency factories for database objects."""
+
+from .factory import BodyDependency, PathDependency
+
+__all__ = ["BodyDependency", "PathDependency"]

fastapi_toolsets-0.6.0/src/fastapi_toolsets/dependencies/factory.py

@@ -0,0 +1,139 @@
+"""Dependency factories for FastAPI routes."""
+
+import inspect
+from collections.abc import AsyncGenerator, Callable
+from typing import Any, TypeVar, cast
+
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import DeclarativeBase
+
+from ..crud import CrudFactory
+
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+SessionDependency = Callable[[], AsyncGenerator[AsyncSession, None]]
+
+
+def PathDependency(
+    model: type[ModelType],
+    field: Any,
+    *,
+    session_dep: SessionDependency,
+    param_name: str | None = None,
+) -> ModelType:
+    """Create a dependency that fetches a DB object from a path parameter.
+
+    Args:
+        model: SQLAlchemy model class
+        field: Model field to filter by (e.g., User.id)
+        session_dep: Session dependency function (e.g., get_db)
+        param_name: Path parameter name (defaults to model_field, e.g., user_id)
+
+    Returns:
+        A Depends() instance that resolves to the model instance
+
+    Raises:
+        NotFoundError: If no matching record is found
+
+    Example:
+        UserDep = PathDependency(User, User.id, session_dep=get_db)
+
+        @router.get("/user/{id}")
+        async def get(
+            user: User = UserDep,
+        ): ...
+    """
+    crud = CrudFactory(model)
+    name = (
+        param_name
+        if param_name is not None
+        else "{}_{}".format(model.__name__.lower(), field.key)
+    )
+    python_type = field.type.python_type
+
+    async def dependency(
+        session: AsyncSession = Depends(session_dep), **kwargs: Any
+    ) -> ModelType:
+        value = kwargs[name]
+        return await crud.get(session, filters=[field == value])
+
+    setattr(
+        dependency,
+        "__signature__",
+        inspect.Signature(
+            parameters=[
+                inspect.Parameter(
+                    name, inspect.Parameter.KEYWORD_ONLY, annotation=python_type
+                ),
+                inspect.Parameter(
+                    "session",
+                    inspect.Parameter.KEYWORD_ONLY,
+                    annotation=AsyncSession,
+                    default=Depends(session_dep),
+                ),
+            ]
+        ),
+    )
+
+    return cast(ModelType, Depends(cast(Callable[..., ModelType], dependency)))
+
+
+def BodyDependency(
+    model: type[ModelType],
+    field: Any,
+    *,
+    session_dep: SessionDependency,
+    body_field: str,
+) -> ModelType:
+    """Create a dependency that fetches a DB object from a body field.
+
+    Args:
+        model: SQLAlchemy model class
+        field: Model field to filter by (e.g., User.id)
+        session_dep: Session dependency function (e.g., get_db)
+        body_field: Name of the field in the request body
+
+    Returns:
+        A Depends() instance that resolves to the model instance
+
+    Raises:
+        NotFoundError: If no matching record is found
+
+    Example:
+        UserDep = BodyDependency(
+            User, User.ctfd_id, session_dep=get_db, body_field="user_id"
+        )
+
+        @router.post("/assign")
+        async def assign(
+            user: User = UserDep,
+        ): ...
+    """
+    crud = CrudFactory(model)
+    python_type = field.type.python_type
+
+    async def dependency(
+        session: AsyncSession = Depends(session_dep), **kwargs: Any
+    ) -> ModelType:
+        value = kwargs[body_field]
+        return await crud.get(session, filters=[field == value])
+
+    setattr(
+        dependency,
+        "__signature__",
+        inspect.Signature(
+            parameters=[
+                inspect.Parameter(
+                    body_field, inspect.Parameter.KEYWORD_ONLY, annotation=python_type
+                ),
+                inspect.Parameter(
+                    "session",
+                    inspect.Parameter.KEYWORD_ONLY,
+                    annotation=AsyncSession,
+                    default=Depends(session_dep),
+                ),
+            ]
+        ),
+    )
+
+    return cast(ModelType, Depends(cast(Callable[..., ModelType], dependency)))

fastapi_toolsets-0.5.0/src/fastapi_toolsets/cli/app.py

@@ -1,25 +0,0 @@
-"""Main CLI application."""
-
-import typer
-
-from .config import load_config
-
-cli = typer.Typer(
-    name="manager",
-    help="CLI utilities for FastAPI projects.",
-    no_args_is_help=True,
-)
-
-_config = load_config()
-
-if _config.fixtures:
-    from .commands.fixtures import fixture_cli
-
-    cli.add_typer(fixture_cli, name="fixtures")
-
-
-@cli.callback()
-def main(ctx: typer.Context) -> None:
-    """FastAPI utilities CLI."""
-    ctx.ensure_object(dict)
-    ctx.obj["config"] = _config

fastapi_toolsets-0.5.0/src/fastapi_toolsets/cli/config.py

@@ -1,92 +0,0 @@
-"""CLI configuration."""
-
-import importlib
-import sys
-import tomllib
-from dataclasses import dataclass
-from pathlib import Path
-
-import typer
-
-
-@dataclass
-class CliConfig:
-    """CLI configuration loaded from pyproject.toml."""
-
-    fixtures: str | None = None
-    db_context: str | None = None
-
-    def get_fixtures_registry(self):
-        """Import and return the fixtures registry."""
-        from ..fixtures import FixtureRegistry
-
-        if not self.fixtures:
-            raise typer.BadParameter(
-                "No fixtures registry configured. "
-                "Add 'fixtures' to [tool.fastapi-toolsets] in pyproject.toml."
-            )
-
-        registry = _import_from_string(self.fixtures)
-
-        if not isinstance(registry, FixtureRegistry):
-            raise typer.BadParameter(
-                f"'fixtures' must be a FixtureRegistry instance, got {type(registry).__name__}"
-            )
-
-        return registry
-
-    def get_db_context(self):
-        """Import and return the db_context function."""
-        if not self.db_context:
-            raise typer.BadParameter(
-                "No db_context configured. "
-                "Add 'db_context' to [tool.fastapi-toolsets] in pyproject.toml."
-            )
-        return _import_from_string(self.db_context)
-
-
-def _import_from_string(import_path: str):
-    """Import an object from a string path like 'module.submodule:attribute'."""
-    if ":" not in import_path:
-        raise typer.BadParameter(
-            f"Invalid import path '{import_path}'. Expected format: 'module:attribute'"
-        )
-
-    module_path, attr_name = import_path.rsplit(":", 1)
-
-    # Add cwd to sys.path for local imports
-    cwd = str(Path.cwd())
-    if cwd not in sys.path:
-        sys.path.insert(0, cwd)
-
-    try:
-        module = importlib.import_module(module_path)
-    except ImportError as e:
-        raise typer.BadParameter(f"Cannot import module '{module_path}': {e}")
-
-    if not hasattr(module, attr_name):
-        raise typer.BadParameter(
-            f"Module '{module_path}' has no attribute '{attr_name}'"
-        )
-
-    return getattr(module, attr_name)
-
-
-def load_config() -> CliConfig:
-    """Load CLI configuration from pyproject.toml."""
-    pyproject_path = Path.cwd() / "pyproject.toml"
-
-    if not pyproject_path.exists():
-        return CliConfig()
-
-    try:
-        with open(pyproject_path, "rb") as f:
-            data = tomllib.load(f)
-
-        tool_config = data.get("tool", {}).get("fastapi-toolsets", {})
-        return CliConfig(
-            fixtures=tool_config.get("fixtures"),
-            db_context=tool_config.get("db_context"),
-        )
-    except Exception:
-        return CliConfig()