fastapi-toolsets 0.4.0__py3-none-any.whl → 0.5.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.4.0"
+__version__ = "0.5.0"

fastapi_toolsets/cli/__init__.py

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

fastapi_toolsets/cli/app.py

@@ -1,97 +1,25 @@
 """Main CLI application."""
 
-import importlib.util
-import sys
-from pathlib import Path
-from typing import Annotated
-
 import typer
 
-from .commands import fixtures
+from .config import load_config
 
-app = typer.Typer(
-    name="fastapi-utils",
+cli = typer.Typer(
+    name="manager",
     help="CLI utilities for FastAPI projects.",
     no_args_is_help=True,
 )
 
-# Register built-in commands
-app.add_typer(fixtures.app, name="fixtures")
-
-
-def register_command(command: typer.Typer, name: str) -> None:
-    """Register a custom command group.
-
-    Args:
-        command: Typer app for the command group
-        name: Name for the command group
+_config = load_config()
 
-    Example:
-        # In your project's cli.py:
-        import typer
-        from fastapi_toolsets.cli import app, register_command
+if _config.fixtures:
+    from .commands.fixtures import fixture_cli
 
-        my_commands = typer.Typer()
+    cli.add_typer(fixture_cli, name="fixtures")
 
-        @my_commands.command()
-        def seed():
-            '''Seed the database.'''
-            ...
 
-        register_command(my_commands, "db")
-        # Now available as: fastapi-utils db seed
-    """
-    app.add_typer(command, name=name)
-
-
-@app.callback()
-def main(
-    ctx: typer.Context,
-    config: Annotated[
-        Path | None,
-        typer.Option(
-            "--config",
-            "-c",
-            help="Path to project config file (Python module with fixtures registry).",
-            envvar="FASTAPI_TOOLSETS_CONFIG",
-        ),
-    ] = None,
-) -> None:
+@cli.callback()
+def main(ctx: typer.Context) -> None:
     """FastAPI utilities CLI."""
     ctx.ensure_object(dict)
-
-    if config:
-        ctx.obj["config_path"] = config
-        # Load the config module
-        config_module = _load_module_from_path(config)
-        ctx.obj["config_module"] = config_module
-
-
-def _load_module_from_path(path: Path) -> object:
-    """Load a Python module from a file path.
-
-    Handles both absolute and relative imports by adding the config's
-    parent directory to sys.path temporarily.
-    """
-    path = path.resolve()
-
-    # Add the parent directory to sys.path to support relative imports
-    parent_dir = str(
-        path.parent.parent
-    )  # Go up two levels (e.g., from app/cli_config.py to project root)
-    if parent_dir not in sys.path:
-        sys.path.insert(0, parent_dir)
-
-    # Also add immediate parent for direct module imports
-    immediate_parent = str(path.parent)
-    if immediate_parent not in sys.path:
-        sys.path.insert(0, immediate_parent)
-
-    spec = importlib.util.spec_from_file_location("config", path)
-    if spec is None or spec.loader is None:
-        raise typer.BadParameter(f"Cannot load module from {path}")
-
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["config"] = module
-    spec.loader.exec_module(module)
-    return module
+    ctx.obj["config"] = _config

fastapi_toolsets/cli/commands/fixtures.py

@@ -1,55 +1,29 @@
 """Fixture management commands."""
 
-import asyncio
 from typing import Annotated
 
 import typer
+from rich.console import Console
+from rich.table import Table
 
-from ...fixtures import Context, FixtureRegistry, LoadStrategy, load_fixtures_by_context
+from ...fixtures import Context, LoadStrategy, load_fixtures_by_context
+from ..config import CliConfig
+from ..utils import async_command
 
-app = typer.Typer(
+fixture_cli = typer.Typer(
     name="fixtures",
     help="Manage database fixtures.",
     no_args_is_help=True,
 )
+console = Console()
 
 
-def _get_registry(ctx: typer.Context) -> FixtureRegistry:
-    """Get fixture registry from context."""
-    config = ctx.obj.get("config_module") if ctx.obj else None
-    if config is None:
-        raise typer.BadParameter(
-            "No config provided. Use --config to specify a config file with a 'fixtures' registry."
-        )
-
-    registry = getattr(config, "fixtures", None)
-    if registry is None:
-        raise typer.BadParameter(
-            "Config module must have a 'fixtures' attribute (FixtureRegistry instance)."
-        )
-
-    if not isinstance(registry, FixtureRegistry):
-        raise typer.BadParameter(
-            f"'fixtures' must be a FixtureRegistry instance, got {type(registry).__name__}"
-        )
-
-    return registry
-
+def _get_config(ctx: typer.Context) -> CliConfig:
+    """Get CLI config from context."""
+    return ctx.obj["config"]
 
-def _get_db_context(ctx: typer.Context):
-    """Get database context manager from config."""
-    config = ctx.obj.get("config_module") if ctx.obj else None
-    if config is None:
-        raise typer.BadParameter("No config provided.")
 
-    get_db_context = getattr(config, "get_db_context", None)
-    if get_db_context is None:
-        raise typer.BadParameter("Config module must have a 'get_db_context' function.")
-
-    return get_db_context
-
-
-@app.command("list")
+@fixture_cli.command("list")
 def list_fixtures(
     ctx: typer.Context,
     context: Annotated[
@@ -62,64 +36,28 @@ def list_fixtures(
     ] = None,
 ) -> None:
     """List all registered fixtures."""
-    registry = _get_registry(ctx)
-
-    if context:
-        fixtures = registry.get_by_context(context)
-    else:
-        fixtures = registry.get_all()
+    config = _get_config(ctx)
+    registry = config.get_fixtures_registry()
+    fixtures = registry.get_by_context(context) if context else registry.get_all()
 
     if not fixtures:
-        typer.echo("No fixtures found.")
+        print("No fixtures found.")
         return
 
-    typer.echo(f"\n{'Name':<30} {'Contexts':<30} {'Dependencies'}")
-    typer.echo("-" * 80)
+    table = Table("Name", "Contexts", "Dependencies")
 
     for fixture in fixtures:
         contexts = ", ".join(fixture.contexts)
         deps = ", ".join(fixture.depends_on) if fixture.depends_on else "-"
-        typer.echo(f"{fixture.name:<30} {contexts:<30} {deps}")
+        table.add_row(fixture.name, contexts, deps)
 
-    typer.echo(f"\nTotal: {len(fixtures)} fixture(s)")
+    console.print(table)
+    print(f"\nTotal: {len(fixtures)} fixture(s)")
 
 
-@app.command("graph")
-def show_graph(
-    ctx: typer.Context,
-    fixture_name: Annotated[
-        str | None,
-        typer.Argument(help="Show dependencies for a specific fixture."),
-    ] = None,
-) -> None:
-    """Show fixture dependency graph."""
-    registry = _get_registry(ctx)
-
-    if fixture_name:
-        try:
-            order = registry.resolve_dependencies(fixture_name)
-            typer.echo(f"\nDependency chain for '{fixture_name}':\n")
-            for i, name in enumerate(order):
-                indent = "  " * i
-                arrow = "└─> " if i > 0 else ""
-                typer.echo(f"{indent}{arrow}{name}")
-        except KeyError:
-            typer.echo(f"Fixture '{fixture_name}' not found.", err=True)
-            raise typer.Exit(1)
-    else:
-        # Show full graph
-        fixtures = registry.get_all()
-
-        typer.echo("\nFixture Dependency Graph:\n")
-        for fixture in fixtures:
-            deps = (
-                f" -> [{', '.join(fixture.depends_on)}]" if fixture.depends_on else ""
-            )
-            typer.echo(f"  {fixture.name}{deps}")
-
-
-@app.command("load")
-def load(
+@fixture_cli.command("load")
+@async_command
+async def load(
     ctx: typer.Context,
     contexts: Annotated[
         list[str] | None,
@@ -141,16 +79,12 @@ def load(
     ] = False,
 ) -> None:
     """Load fixtures into the database."""
-    registry = _get_registry(ctx)
-    get_db_context = _get_db_context(ctx)
+    config = _get_config(ctx)
+    registry = config.get_fixtures_registry()
+    get_db_context = config.get_db_context()
 
-    # Parse contexts
-    if contexts:
-        context_list = contexts
-    else:
-        context_list = [Context.BASE]
+    context_list = contexts if contexts else [Context.BASE]
 
-    # Parse strategy
     try:
         load_strategy = LoadStrategy(strategy)
     except ValueError:
@@ -159,67 +93,27 @@ def load(
         )
         raise typer.Exit(1)
 
-    # Resolve what will be loaded
     ordered = registry.resolve_context_dependencies(*context_list)
 
     if not ordered:
-        typer.echo("No fixtures to load for the specified context(s).")
+        print("No fixtures to load for the specified context(s).")
         return
 
-    typer.echo(f"\nFixtures to load ({load_strategy.value} strategy):")
+    print(f"\nFixtures to load ({load_strategy.value} strategy):")
     for name in ordered:
         fixture = registry.get(name)
         instances = list(fixture.func())
         model_name = type(instances[0]).__name__ if instances else "?"
-        typer.echo(f"  - {name}: {len(instances)} {model_name}(s)")
+        print(f"  - {name}: {len(instances)} {model_name}(s)")
 
     if dry_run:
-        typer.echo("\n[Dry run - no changes made]")
+        print("\n[Dry run - no changes made]")
         return
 
-    typer.echo("\nLoading...")
-
-    async def do_load():
-        async with get_db_context() as session:
-            result = await load_fixtures_by_context(
-                session, registry, *context_list, strategy=load_strategy
-            )
-            return result
-
-    result = asyncio.run(do_load())
+    async with get_db_context() as session:
+        result = await load_fixtures_by_context(
+            session, registry, *context_list, strategy=load_strategy
+        )
 
     total = sum(len(items) for items in result.values())
-    typer.echo(f"\nLoaded {total} record(s) successfully.")
-
-
-@app.command("show")
-def show_fixture(
-    ctx: typer.Context,
-    name: Annotated[str, typer.Argument(help="Fixture name to show.")],
-) -> None:
-    """Show details of a specific fixture."""
-    registry = _get_registry(ctx)
-
-    try:
-        fixture = registry.get(name)
-    except KeyError:
-        typer.echo(f"Fixture '{name}' not found.", err=True)
-        raise typer.Exit(1)
-
-    typer.echo(f"\nFixture: {fixture.name}")
-    typer.echo(f"Contexts: {', '.join(fixture.contexts)}")
-    typer.echo(
-        f"Dependencies: {', '.join(fixture.depends_on) if fixture.depends_on else 'None'}"
-    )
-
-    # Show instances
-    instances = list(fixture.func())
-    if instances:
-        model_name = type(instances[0]).__name__
-        typer.echo(f"\nInstances ({len(instances)} {model_name}):")
-        for instance in instances[:10]:  # Limit to 10
-            typer.echo(f"  - {instance!r}")
-        if len(instances) > 10:
-            typer.echo(f"  ... and {len(instances) - 10} more")
-    else:
-        typer.echo("\nNo instances (empty fixture)")
+    print(f"\nLoaded {total} record(s) successfully.")

fastapi_toolsets/cli/config.py

@@ -0,0 +1,92 @@
+"""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()

fastapi_toolsets/cli/utils.py

@@ -0,0 +1,27 @@
+"""CLI utility functions."""
+
+import asyncio
+import functools
+from collections.abc import Callable, Coroutine
+from typing import Any, ParamSpec, TypeVar
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def async_command(func: Callable[P, Coroutine[Any, Any, T]]) -> Callable[P, T]:
+    """Decorator to run an async function as a sync CLI command.
+
+    Example:
+        @fixture_cli.command("load")
+        @async_command
+        async def load(ctx: typer.Context) -> None:
+            async with get_db_context() as session:
+                await load_fixtures(session, registry)
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        return asyncio.run(func(*args, **kwargs))
+
+    return wrapper

fastapi_toolsets/crud/__init__.py

@@ -4,7 +4,6 @@ from ..exceptions import NoSearchableFieldsError
 from .factory import CrudFactory
 from .search import (
     SearchConfig,
-    SearchFieldType,
     get_searchable_fields,
 )
 
@@ -13,5 +12,4 @@ __all__ = [
     "get_searchable_fields",
     "NoSearchableFieldsError",
     "SearchConfig",
-    "SearchFieldType",
 ]

fastapi_toolsets/crud/factory.py

@@ -17,6 +17,7 @@ from ..exceptions import NotFoundError
 from .search import SearchConfig, SearchFieldType, build_search_filters
 
 ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+JoinType = list[tuple[type[DeclarativeBase], Any]]
 
 
 class AsyncCrud(Generic[ModelType]):
@@ -55,6 +56,8 @@ class AsyncCrud(Generic[ModelType]):
         session: AsyncSession,
         filters: list[Any],
         *,
+        joins: JoinType | None = None,
+        outer_join: bool = False,
         with_for_update: bool = False,
         load_options: list[Any] | None = None,
     ) -> ModelType:
@@ -63,6 +66,8 @@ class AsyncCrud(Generic[ModelType]):
         Args:
             session: DB async session
             filters: List of SQLAlchemy filter conditions
+            joins: List of (model, condition) tuples for joining related tables
+            outer_join: Use LEFT OUTER JOIN instead of INNER JOIN
             with_for_update: Lock the row for update
             load_options: SQLAlchemy loader options (e.g., selectinload)
 
@@ -73,7 +78,15 @@ class AsyncCrud(Generic[ModelType]):
             NotFoundError: If no record found
             MultipleResultsFound: If more than one record found
         """
-        q = select(cls.model).where(and_(*filters))
+        q = select(cls.model)
+        if joins:
+            for model, condition in joins:
+                q = (
+                    q.outerjoin(model, condition)
+                    if outer_join
+                    else q.join(model, condition)
+                )
+        q = q.where(and_(*filters))
         if load_options:
             q = q.options(*load_options)
         if with_for_update:
@@ -90,6 +103,8 @@ class AsyncCrud(Generic[ModelType]):
         session: AsyncSession,
         filters: list[Any] | None = None,
         *,
+        joins: JoinType | None = None,
+        outer_join: bool = False,
         load_options: list[Any] | None = None,
     ) -> ModelType | None:
         """Get the first matching record, or None.
@@ -97,12 +112,21 @@ class AsyncCrud(Generic[ModelType]):
         Args:
             session: DB async session
             filters: List of SQLAlchemy filter conditions
+            joins: List of (model, condition) tuples for joining related tables
+            outer_join: Use LEFT OUTER JOIN instead of INNER JOIN
             load_options: SQLAlchemy loader options
 
         Returns:
             Model instance or None
         """
         q = select(cls.model)
+        if joins:
+            for model, condition in joins:
+                q = (
+                    q.outerjoin(model, condition)
+                    if outer_join
+                    else q.join(model, condition)
+                )
         if filters:
             q = q.where(and_(*filters))
         if load_options:
@@ -116,6 +140,8 @@ class AsyncCrud(Generic[ModelType]):
         session: AsyncSession,
         *,
         filters: list[Any] | None = None,
+        joins: JoinType | None = None,
+        outer_join: bool = False,
         load_options: list[Any] | None = None,
         order_by: Any | None = None,
         limit: int | None = None,
@@ -126,6 +152,8 @@ class AsyncCrud(Generic[ModelType]):
         Args:
             session: DB async session
             filters: List of SQLAlchemy filter conditions
+            joins: List of (model, condition) tuples for joining related tables
+            outer_join: Use LEFT OUTER JOIN instead of INNER JOIN
             load_options: SQLAlchemy loader options
             order_by: Column or list of columns to order by
             limit: Max number of rows to return
@@ -135,6 +163,13 @@ class AsyncCrud(Generic[ModelType]):
             List of model instances
         """
         q = select(cls.model)
+        if joins:
+            for model, condition in joins:
+                q = (
+                    q.outerjoin(model, condition)
+                    if outer_join
+                    else q.join(model, condition)
+                )
         if filters:
             q = q.where(and_(*filters))
         if load_options:
@@ -254,17 +289,29 @@ class AsyncCrud(Generic[ModelType]):
         cls: type[Self],
         session: AsyncSession,
         filters: list[Any] | None = None,
+        *,
+        joins: JoinType | None = None,
+        outer_join: bool = False,
     ) -> int:
         """Count records matching the filters.
 
         Args:
             session: DB async session
             filters: List of SQLAlchemy filter conditions
+            joins: List of (model, condition) tuples for joining related tables
+            outer_join: Use LEFT OUTER JOIN instead of INNER JOIN
 
         Returns:
             Number of matching records
         """
         q = select(func.count()).select_from(cls.model)
+        if joins:
+            for model, condition in joins:
+                q = (
+                    q.outerjoin(model, condition)
+                    if outer_join
+                    else q.join(model, condition)
+                )
         if filters:
             q = q.where(and_(*filters))
         result = await session.execute(q)
@@ -275,17 +322,30 @@ class AsyncCrud(Generic[ModelType]):
         cls: type[Self],
         session: AsyncSession,
         filters: list[Any],
+        *,
+        joins: JoinType | None = None,
+        outer_join: bool = False,
     ) -> bool:
         """Check if a record exists.
 
         Args:
             session: DB async session
             filters: List of SQLAlchemy filter conditions
+            joins: List of (model, condition) tuples for joining related tables
+            outer_join: Use LEFT OUTER JOIN instead of INNER JOIN
 
         Returns:
             True if at least one record matches
         """
-        q = select(cls.model).where(and_(*filters)).exists().select()
+        q = select(cls.model)
+        if joins:
+            for model, condition in joins:
+                q = (
+                    q.outerjoin(model, condition)
+                    if outer_join
+                    else q.join(model, condition)
+                )
+        q = q.where(and_(*filters)).exists().select()
         result = await session.execute(q)
         return bool(result.scalar())
 
@@ -295,6 +355,8 @@ class AsyncCrud(Generic[ModelType]):
         session: AsyncSession,
         *,
         filters: list[Any] | None = None,
+        joins: JoinType | None = None,
+        outer_join: bool = False,
         load_options: list[Any] | None = None,
         order_by: Any | None = None,
         page: int = 1,
@@ -307,6 +369,8 @@ class AsyncCrud(Generic[ModelType]):
         Args:
             session: DB async session
             filters: List of SQLAlchemy filter conditions
+            joins: List of (model, condition) tuples for joining related tables
+            outer_join: Use LEFT OUTER JOIN instead of INNER JOIN
             load_options: SQLAlchemy loader options
             order_by: Column or list of columns to order by
             page: Page number (1-indexed)
@@ -319,7 +383,7 @@ class AsyncCrud(Generic[ModelType]):
         """
         filters = list(filters) if filters else []
         offset = (page - 1) * items_per_page
-        joins: list[Any] = []
+        search_joins: list[Any] = []
 
         # Build search filters
         if search:
@@ -330,11 +394,21 @@ class AsyncCrud(Generic[ModelType]):
                 default_fields=cls.searchable_fields,
             )
             filters.extend(search_filters)
-            joins.extend(search_joins)
 
         # Build query with joins
         q = select(cls.model)
-        for join_rel in joins:
+
+        # Apply explicit joins
+        if joins:
+            for model, condition in joins:
+                q = (
+                    q.outerjoin(model, condition)
+                    if outer_join
+                    else q.join(model, condition)
+                )
+
+        # Apply search joins (always outer joins for search)
+        for join_rel in search_joins:
             q = q.outerjoin(join_rel)
 
         if filters:
@@ -352,8 +426,20 @@ class AsyncCrud(Generic[ModelType]):
         pk_col = cls.model.__mapper__.primary_key[0]
         count_q = select(func.count(func.distinct(getattr(cls.model, pk_col.name))))
         count_q = count_q.select_from(cls.model)
-        for join_rel in joins:
+
+        # Apply explicit joins to count query
+        if joins:
+            for model, condition in joins:
+                count_q = (
+                    count_q.outerjoin(model, condition)
+                    if outer_join
+                    else count_q.join(model, condition)
+                )
+
+        # Apply search joins to count query
+        for join_rel in search_joins:
             count_q = count_q.outerjoin(join_rel)
+
         if filters:
             count_q = count_q.where(and_(*filters))
 
@@ -404,6 +490,20 @@ def CrudFactory(
 
         # With search
         result = await UserCrud.paginate(session, search="john")
+
+        # With joins (inner join by default):
+        users = await UserCrud.get_multi(
+            session,
+            joins=[(Post, Post.user_id == User.id)],
+            filters=[Post.published == True],
+        )
+
+        # With outer join:
+        users = await UserCrud.get_multi(
+            session,
+            joins=[(Post, Post.user_id == User.id)],
+            outer_join=True,
+        )
     """
     cls = type(
         f"Async{model.__name__}Crud",

fastapi_toolsets/crud/search.py

@@ -129,11 +129,12 @@ def build_search_filters(
         else:
             column = field
 
-        # Build the filter
+        # Build the filter (cast to String for non-text columns)
+        column_as_string = column.cast(String)
         if config.case_sensitive:
-            filters.append(column.like(f"%{query}%"))
+            filters.append(column_as_string.like(f"%{query}%"))
         else:
-            filters.append(column.ilike(f"%{query}%"))
+            filters.append(column_as_string.ilike(f"%{query}%"))
 
     if not filters:
         return [], []

fastapi_toolsets/exceptions/__init__.py

@@ -1,4 +1,5 @@
 from .exceptions import (
+    ApiError,
     ApiException,
     ConflictError,
     ForbiddenError,
@@ -10,11 +11,12 @@ from .exceptions import (
 from .handler import init_exceptions_handlers
 
 __all__ = [
-    "init_exceptions_handlers",
-    "generate_error_responses",
+    "ApiError",
     "ApiException",
     "ConflictError",
     "ForbiddenError",
+    "generate_error_responses",
+    "init_exceptions_handlers",
     "NoSearchableFieldsError",
     "NotFoundError",
     "UnauthorizedError",

fastapi_toolsets/fixtures/registry.py

@@ -50,8 +50,16 @@ class FixtureRegistry:
             ]
     """
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        contexts: list[str | Context] | None = None,
+    ) -> None:
         self._fixtures: dict[str, Fixture] = {}
+        self._default_contexts: list[str] | None = (
+            [c.value if isinstance(c, Context) else c for c in contexts]
+            if contexts
+            else None
+        )
 
     def register(
         self,
@@ -85,10 +93,14 @@ class FixtureRegistry:
             fn: Callable[[], Sequence[DeclarativeBase]],
         ) -> Callable[[], Sequence[DeclarativeBase]]:
             fixture_name = name or cast(Any, fn).__name__
-            fixture_contexts = [
-                c.value if isinstance(c, Context) else c
-                for c in (contexts or [Context.BASE])
-            ]
+            if contexts is not None:
+                fixture_contexts = [
+                    c.value if isinstance(c, Context) else c for c in contexts
+                ]
+            elif self._default_contexts is not None:
+                fixture_contexts = self._default_contexts
+            else:
+                fixture_contexts = [Context.BASE.value]
 
             self._fixtures[fixture_name] = Fixture(
                 name=fixture_name,
@@ -102,6 +114,32 @@ class FixtureRegistry:
             return decorator(func)
         return decorator
 
+    def include_registry(self, registry: "FixtureRegistry") -> None:
+        """Include another `FixtureRegistry` in the same current `FixtureRegistry`.
+
+        Args:
+            registry: The `FixtureRegistry` to include
+
+        Raises:
+            ValueError: If a fixture name already exists in the current registry
+
+        Example:
+            registry = FixtureRegistry()
+            dev_registry = FixtureRegistry()
+
+            @dev_registry.register
+            def dev_data():
+                return [...]
+
+            registry.include_registry(registry=dev_registry)
+        """
+        for name, fixture in registry._fixtures.items():
+            if name in self._fixtures:
+                raise ValueError(
+                    f"Fixture '{name}' already exists in the current registry"
+                )
+            self._fixtures[name] = fixture
+
     def get(self, name: str) -> Fixture:
         """Get a fixture by name."""
         if name not in self._fixtures:

{fastapi_toolsets-0.4.0.dist-info → fastapi_toolsets-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-toolsets
-Version: 0.4.0
+Version: 0.5.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.5.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+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/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/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/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
+fastapi_toolsets/fixtures/__init__.py,sha256=i5N6dt4LLVxhC0fBNhDTokuqUf43oXJChBkVMQ94hLA,328
+fastapi_toolsets/fixtures/enum.py,sha256=02T4CrkH3-A3mPxpHaLzBQD4yzqExwjycaDBJr1ameA,715
+fastapi_toolsets/fixtures/registry.py,sha256=O5BlaPh-BOZQmq-Yi0GWD-pYmAtdeIxUc-QJxoPGu5M,6587
+fastapi_toolsets/fixtures/utils.py,sha256=DlsGBVl0zyxtKX5E3CEcV7rhzBYng6KD5hELD7bK0wo,4711
+fastapi_toolsets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_toolsets/pytest/__init__.py,sha256=0GnnFxWNfpaShBBYsfRGIgSygwC1eo8TydmXCA3tmoM,188
+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.4.0.dist-info → fastapi_toolsets-0.5.0.dist-info}/WHEEL

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

fastapi_toolsets-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+manager = fastapi_toolsets.cli:cli
+

fastapi_toolsets-0.4.0.dist-info/RECORD

@@ -1,26 +0,0 @@
-fastapi_toolsets/__init__.py,sha256=gzOvHPBZ5Kdja8XWMQM-zTxHKPJ7M7ptud7tUsd9bws,820
-fastapi_toolsets/cli/__init__.py,sha256=QAcrenphE7D5toid_Kn777Cy1icSOWiEBjSE_oCuU4o,111
-fastapi_toolsets/cli/app.py,sha256=G3y3PNN3biHs8GtiiGsrX2X8nXNjkrsUhHLXQo2-MXc,2588
-fastapi_toolsets/cli/commands/__init__.py,sha256=BogehmsY6olwLdfIBzviuppXP1LLl9znnxtmji3eLwI,29
-fastapi_toolsets/cli/commands/fixtures.py,sha256=qiC2dcrJ_Rb1PRzx6EycTFQQXwa_GQUVoptpx4chf9k,6679
-fastapi_toolsets/crud/__init__.py,sha256=LRR57jsFna2IqSj6aTomMzFcaQbx7WVo5lnfhcTSU1g,369
-fastapi_toolsets/crud/factory.py,sha256=c5aH2c38Qa44pQ3XKoJTcRox5x4rD4tuEJQ5DKFjSnc,13014
-fastapi_toolsets/crud/search.py,sha256=a46SGMg484uv2DruNfEB-Rq6lJRi_K-Nr8tFTWQ2ouY,4530
-fastapi_toolsets/db.py,sha256=YUj5CrxCnREg7AqpJLNrLR2RDIOCS7stQCNOSS3cRho,5619
-fastapi_toolsets/exceptions/__init__.py,sha256=wlV4pVXuGdOtUvlThRJXmEc8g8Nmwt8MOMG_A-3j9zw,451
-fastapi_toolsets/exceptions/exceptions.py,sha256=hu8_lvE9KmnYID9YgJqlzZMkCD0kASPrGAmN1hUe2bY,5086
-fastapi_toolsets/exceptions/handler.py,sha256=IXfKiIr_LPo-11PRpOIrNRAXBkeQ5TdLcu3Gy-r6ChU,5916
-fastapi_toolsets/fixtures/__init__.py,sha256=i5N6dt4LLVxhC0fBNhDTokuqUf43oXJChBkVMQ94hLA,328
-fastapi_toolsets/fixtures/enum.py,sha256=02T4CrkH3-A3mPxpHaLzBQD4yzqExwjycaDBJr1ameA,715
-fastapi_toolsets/fixtures/registry.py,sha256=lfoLdC6aZeJQR7_l0g_P5Y6DChbs8_zAgLQsR0Plmfg,5276
-fastapi_toolsets/fixtures/utils.py,sha256=DlsGBVl0zyxtKX5E3CEcV7rhzBYng6KD5hELD7bK0wo,4711
-fastapi_toolsets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastapi_toolsets/pytest/__init__.py,sha256=0GnnFxWNfpaShBBYsfRGIgSygwC1eo8TydmXCA3tmoM,188
-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.4.0.dist-info/licenses/LICENSE,sha256=V2jCjI-VPB-veGY2Ktb0sU4vT_TldRciZ9lCE98bMoE,1063
-fastapi_toolsets-0.4.0.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
-fastapi_toolsets-0.4.0.dist-info/entry_points.txt,sha256=pNU38Nn_DXBgYd-nLZCizMvrrdaPhHmkRwouDoBqvzw,63
-fastapi_toolsets-0.4.0.dist-info/METADATA,sha256=cRTaYwgiAEVdU_DD4lG7idF6agtcxgSHpFsFIwp-7HY,4221
-fastapi_toolsets-0.4.0.dist-info/RECORD,,

fastapi_toolsets-0.4.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-fastapi-toolsets = fastapi_toolsets.cli:app
-