fastapi-toolsets 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

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/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/cli/app.py

@@ -2,17 +2,23 @@
 
 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 .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")
@@ -22,4 +28,3 @@ if _config.fixtures:
 def main(ctx: typer.Context) -> None:
     """FastAPI utilities CLI."""
     ctx.ensure_object(dict)
-    ctx.obj["config"] = _config

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/cli/config.py

@@ -1,52 +1,28 @@
-"""CLI configuration."""
+"""CLI configuration and dynamic imports."""
 
 import importlib
 import sys
-import tomllib
-from dataclasses import dataclass
-from pathlib import Path
 
 import typer
 
+from .pyproject import find_pyproject, load_pyproject
 
-@dataclass
-class CliConfig:
-    """CLI configuration loaded from pyproject.toml."""
 
-    fixtures: str | None = None
-    db_context: str | None = None
+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 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."
-            )
+def import_from_string(import_path: str):
+    """Import an object from a string path like 'module.submodule:attribute'.
 
-        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'."""
+    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'"
@@ -54,10 +30,7 @@ def _import_from_string(import_path: str):
 
     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)
+    _ensure_project_in_path()
 
     try:
         module = importlib.import_module(module_path)
@@ -72,21 +45,63 @@ def _import_from_string(import_path: str):
     return getattr(module, attr_name)
 
 
-def load_config() -> CliConfig:
-    """Load CLI configuration from pyproject.toml."""
-    pyproject_path = Path.cwd() / "pyproject.toml"
+def get_config_value(key: str, required: bool = False):
+    """Get a configuration value from pyproject.toml.
 
-    if not pyproject_path.exists():
-        return CliConfig()
+    Args:
+        key: The configuration key in [tool.fastapi-toolsets].
+        required: If True, raises an error when the key is missing.
 
-    try:
-        with open(pyproject_path, "rb") as f:
-            data = tomllib.load(f)
+    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)
 
-        tool_config = data.get("tool", {}).get("fastapi-toolsets", {})
-        return CliConfig(
-            fixtures=tool_config.get("fixtures"),
-            db_context=tool_config.get("db_context"),
+    if required and value is None:
+        raise typer.BadParameter(
+            f"No '{key}' configured. "
+            f"Add '{key}' to [tool.fastapi-toolsets] in pyproject.toml."
         )
-    except Exception:
-        return CliConfig()
+
+    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/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/dependencies/__init__.py

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

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.dist-info → fastapi_toolsets-0.6.0.dist-info}/METADATA

@@ -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.dist-info → fastapi_toolsets-0.6.0.dist-info}/RECORD

@@ -1,14 +1,17 @@
-fastapi_toolsets/__init__.py,sha256=OLAcxL7oaBcCFw2nD7oCp9JXiI9SCjLvwEkuG4_5TGc,820
-fastapi_toolsets/cli/__init__.py,sha256=CGLeg0ud6-cKZwvE_qNKw9tXmzVfFCJD-U2eMdQ7InI,123
-fastapi_toolsets/cli/app.py,sha256=cpBDDYPngjTv9ui6FaXrTzD4kfKyBBlqMQBT9wWdjuk,483
+fastapi_toolsets/__init__.py,sha256=9FN3OLnVkKUsOTCa5C14L7b867Y0vSZZXUcDdvsItqY,820
+fastapi_toolsets/cli/__init__.py,sha256=tlmq_tIoqwWou2dk6Ur4fQUtb0Rl3MglTJEVHyUgfz4,95
+fastapi_toolsets/cli/app.py,sha256=LcY38gRW1yIylOVre82IHCPH4Wcg6I5Z1LoeR71vgCk,700
 fastapi_toolsets/cli/commands/__init__.py,sha256=BogehmsY6olwLdfIBzviuppXP1LLl9znnxtmji3eLwI,29
-fastapi_toolsets/cli/commands/fixtures.py,sha256=yBOMlrMRrMk0y-WD6YYXzIrMKGtM0egNVC-vG5GA9Bs,3348
-fastapi_toolsets/cli/config.py,sha256=tRpvi2NnSEwPlDjyacMCHIapH61ONCp-24vpCxm4ElM,2678
+fastapi_toolsets/cli/commands/fixtures.py,sha256=3AqlTU3qyyxsOE7XGsDMHlsQ7QNYikLM58JTjHJQugo,2827
+fastapi_toolsets/cli/config.py,sha256=ZFnmGzQOePiAVKSwgHcF_wnvCWSba119fVjc6mJZgXs,3060
+fastapi_toolsets/cli/pyproject.py,sha256=9OKDjZvMEGfpiBq3dgtMZc0IemPisXme8h77-a6o1jA,1153
 fastapi_toolsets/cli/utils.py,sha256=KsW-FW9tBCAjUd_qludXa1jy8ch8TpkT-_ltcO0DWVs,733
 fastapi_toolsets/crud/__init__.py,sha256=XSl_2k5qfjr0ZFtS7JgNtiNJmZjYL8bDh9BE5qrDyw0,325
 fastapi_toolsets/crud/factory.py,sha256=wBtmFNC7cqzeZfyJLKW-lj3Dd0zo15bZfeTNA1DvqNE,16663
 fastapi_toolsets/crud/search.py,sha256=OAhbkuDan-elAWyAUz0msieZxYkE76fpJYwaA1BRTQ8,4635
 fastapi_toolsets/db.py,sha256=YUj5CrxCnREg7AqpJLNrLR2RDIOCS7stQCNOSS3cRho,5619
+fastapi_toolsets/dependencies/__init__.py,sha256=jw_EZDuuwNPTS3MKhf66Z24Kd53r76RKbHzhl-_UVhI,158
+fastapi_toolsets/dependencies/factory.py,sha256=WL38Xc2BIeXXSlpuhHzy2gHS-rNFcUzjidE78SoItgk,3984
 fastapi_toolsets/exceptions/__init__.py,sha256=vNP19B7aaVKnBpRXG_fdCZ0P_GlPDiZDYydPLxfdhD0,481
 fastapi_toolsets/exceptions/exceptions.py,sha256=hu8_lvE9KmnYID9YgJqlzZMkCD0kASPrGAmN1hUe2bY,5086
 fastapi_toolsets/exceptions/handler.py,sha256=IXfKiIr_LPo-11PRpOIrNRAXBkeQ5TdLcu3Gy-r6ChU,5916
@@ -21,8 +24,8 @@ fastapi_toolsets/pytest/__init__.py,sha256=0GnnFxWNfpaShBBYsfRGIgSygwC1eo8TydmXC
 fastapi_toolsets/pytest/plugin.py,sha256=lbEiumS2zi7jARY6eYBUPAlfKCplbLFrZXcmp0-RkcA,6892
 fastapi_toolsets/pytest/utils.py,sha256=VqkxtbpEU8w7-0xfcZG0m8Tpn3LtdnvAJMyqWS7WtIw,3447
 fastapi_toolsets/schemas.py,sha256=LBzrq4s5VWYeQqlUfOEvWDtpFdO8scgY0LRypk9KUAE,2639
-fastapi_toolsets-0.5.0.dist-info/licenses/LICENSE,sha256=V2jCjI-VPB-veGY2Ktb0sU4vT_TldRciZ9lCE98bMoE,1063
-fastapi_toolsets-0.5.0.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
-fastapi_toolsets-0.5.0.dist-info/entry_points.txt,sha256=I-wL3xlhglq38WG6WDitgmE4Hstk9tmSUf4eIjz9ckk,54
-fastapi_toolsets-0.5.0.dist-info/METADATA,sha256=5s38SOEaDNo7Qkn70UQpOtNhqFPwHDUQ72gyoTahlyE,4221
-fastapi_toolsets-0.5.0.dist-info/RECORD,,
+fastapi_toolsets-0.6.0.dist-info/licenses/LICENSE,sha256=V2jCjI-VPB-veGY2Ktb0sU4vT_TldRciZ9lCE98bMoE,1063
+fastapi_toolsets-0.6.0.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
+fastapi_toolsets-0.6.0.dist-info/entry_points.txt,sha256=I-wL3xlhglq38WG6WDitgmE4Hstk9tmSUf4eIjz9ckk,54
+fastapi_toolsets-0.6.0.dist-info/METADATA,sha256=sOE5365KN7O-ZsasgNDoWO9kj_pBu-RfuwkNlmlDWgs,4240
+fastapi_toolsets-0.6.0.dist-info/RECORD,,

{fastapi_toolsets-0.5.0.dist-info → fastapi_toolsets-0.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.28
+Generator: uv 0.9.29
 Root-Is-Purelib: true
 Tag: py3-none-any