FastAPI-fastkit 1.4.1__tar.gz → 1.5.0__tar.gz

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FastAPI-fastkit
-Version: 1.4.1
+Version: 1.5.0
 Summary: Fast, easy-to-use starter kit for new users of Python and FastAPI
 Author-Email: bnbong <bbbong9@gmail.com>
 License: MIT
@@ -20,6 +20,7 @@ Requires-Dist: pre-commit>=4.0.1; extra == "dev"
 Requires-Dist: mypy>=1.12.0; extra == "dev"
 Requires-Dist: isort>=5.13.2; extra == "dev"
 Requires-Dist: pygments>=2.20.0; extra == "dev"
+Requires-Dist: virtualenv>=21.7.13; extra == "dev"
 Requires-Dist: types-pyyaml>=6.0.12.20260408; extra == "dev"
 Description-Content-Type: text/markdown
 

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
 ]
 requires-python = ">=3.12"
 readme = "README.md"
-version = "1.4.1"
+version = "1.5.0"
 
 [project.license]
 text = "MIT"
@@ -32,6 +32,7 @@ dev = [
     "mypy>=1.12.0",
     "isort>=5.13.2",
     "pygments>=2.20.0",
+    "virtualenv>=21.7.13",
     "types-pyyaml>=6.0.12.20260408",
 ]
 
@@ -136,9 +137,11 @@ docs = [
     "pygments>=2.20.0",
     "requests>=2.33.0",
     "idna>=3.15",
+    "urllib3>=2.8.0",
     "pymdown-extensions>=11.0.1",
 ]
 translation = [
     "openai>=2.8.1",
     "anthropic>=0.74.0",
+    "anyio>=4.14.2",
 ]

fastapi_fastkit-1.5.0/src/fastapi_fastkit/__init__.py

@@ -0,0 +1 @@
+__version__ = 'v1.5.0'

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/backend/main.py

@@ -18,6 +18,7 @@ from fastapi_fastkit.backend.package_managers import PackageManagerFactory
 from fastapi_fastkit.backend.project_builder.preset_layout import (
     app_module_from_main_path,
 )
+from fastapi_fastkit.backend.route_wiring import register_router, router_alias
 from fastapi_fastkit.backend.transducer import (
     copy_and_convert_template,
     copy_and_convert_template_file,
@@ -1464,6 +1465,16 @@ def _handle_api_router_file(
         if os.path.exists(api_source):
             copy_and_convert_template_file(api_source, api_router_file)
 
+        # The __init__ template may be empty; initialize the API router.
+        if os.path.exists(api_router_file):
+            with open(api_router_file, "r", encoding="utf-8") as f:
+                content = f.read()
+            if not content.strip():
+                with open(api_router_file, "w", encoding="utf-8") as f:
+                    f.write(
+                        "from fastapi import APIRouter\n\napi_router = APIRouter()\n"
+                    )
+
     # Update API router to include new route
     if os.path.exists(api_router_file):
         _update_api_router(api_router_file, route_name)
@@ -1484,23 +1495,22 @@ def _update_api_router(api_router_file: str, route_name: str) -> None:
         with open(api_router_file, "r", encoding="utf-8") as f:
             content = f.read()
 
-        route_import = f"from .routes import {route_name}"
+        alias = router_alias(api_router_file, "routes", route_name, route_name)
+        suffix = f" as {alias}" if alias != route_name else ""
+        route_import = f"from .routes import {route_name}{suffix}"
         route_include = (
-            f"api_router.include_router({route_name}.router, "
+            f"api_router.include_router({alias}.router, "
             f'prefix="/{route_name}", tags=["{route_name}"])'
         )
 
-        if (
-            route_import in content
-            and f"api_router.include_router({route_name}.router" in content
-        ):
-            return  # Already included
-
-        content = insert_import_line(content, route_import)
-        content = insert_statement_line(content, route_include)
-
-        with open(api_router_file, "w", encoding="utf-8") as f:
-            f.write(content)
+        register_router(
+            {
+                "api_dir": os.path.dirname(api_router_file),
+                "api_router_file": api_router_file,
+            },
+            route_import,
+            route_include,
+        )
 
         debug_log(f"Updated API router to include {route_name}", "info")
 
@@ -1594,7 +1604,9 @@ def _update_main_app(
         print_warning(f"Failed to update main.py: {e}")
 
 
-def add_new_route(project_dir: str, route_name: str) -> None:
+def add_new_route(
+    project_dir: str, route_name: str, layout: Optional[str] = None
+) -> None:
     """
     Add a new API route to an existing FastAPI project.
 
@@ -1604,37 +1616,20 @@ def add_new_route(project_dir: str, route_name: str) -> None:
 
     :param project_dir: Path to the project directory
     :param route_name: Name of the new route to add
+    :param layout: Explicit route layout, or None to select from preset metadata
     :raises BackendExceptions: If route addition fails
     """
     try:
-        # Setup paths
-        modules_dir = os.path.join(settings.FASTKIT_TEMPLATE_ROOT, "modules")
-        layout = resolve_project_layout(project_dir)
-        src_dir = layout["package_dir"]
-
-        # Ensure project structure exists
-        target_dirs = _ensure_project_structure(src_dir)
-
-        # Create route files
-        _create_route_files(
-            modules_dir, target_dirs, route_name, layout["package_module"]
+        # Import here to avoid a circular import with route_generators.
+        from fastapi_fastkit.backend.route_generators import (
+            get_route_generator,
+            resolve_route_layout,
         )
 
-        # Handle API router file
-        _handle_api_router_file(
-            target_dirs, modules_dir, route_name, layout["api_router_file"]
-        )
-
-        # Process init files
-        module_types = ["api/routes", "crud", "schemas"]
-        _process_init_files(modules_dir, target_dirs, module_types)
-
-        # Update main application
-        _update_main_app(
-            src_dir,
-            route_name,
-            router_module=layout["api_router_module"],
-            main_py_path=layout["main"],
+        route_layout = resolve_route_layout(project_dir, layout)
+        project_layout = resolve_project_layout(project_dir)
+        get_route_generator(route_layout).add_new_route(
+            project_dir, route_name, project_layout
         )
 
         debug_log(f"Successfully added new route: {route_name}", "info")

fastapi_fastkit-1.5.0/src/fastapi_fastkit/backend/route_generators.py

@@ -0,0 +1,163 @@
+# --------------------------------------------------------------------------
+# Route generators for fastkit addroute.
+# --------------------------------------------------------------------------
+import keyword
+import os
+from pathlib import Path
+from typing import Dict, Optional, Union
+
+from fastapi_fastkit.backend import main as backend
+from fastapi_fastkit.backend.project_builder.preset_layout import PresetLayoutStrategist
+from fastapi_fastkit.backend.route_wiring import register_router, router_alias
+from fastapi_fastkit.backend.transducer import copy_and_convert_template_file
+from fastapi_fastkit.core.exceptions import BackendExceptions
+from fastapi_fastkit.core.settings import settings
+from fastapi_fastkit.utils.main import print_warning, read_fastkit_metadata
+
+ROUTE_LAYOUTS = ("classic-layer", "domain")
+
+
+def resolve_route_layout(project_dir: str, layout: Optional[str] = None) -> str:
+    """Resolve the route layout from the option or project metadata."""
+    if layout is not None:
+        if layout not in ROUTE_LAYOUTS:
+            raise BackendExceptions(f"Unknown route layout: {layout!r}")
+        return layout
+
+    metadata = read_fastkit_metadata(project_dir)
+    preset = metadata.get("preset")
+    if not preset:
+        template = metadata.get("template")
+        domain_template = PresetLayoutStrategist("domain-starter").base_template
+        if template == domain_template:
+            return "domain"
+    if preset == "domain-starter":
+        return "domain"
+    if preset and preset not in ("classic-layered", "minimal", "single-module"):
+        print_warning(f"Unknown preset {preset!r}; using classic-layer route layout.")
+    return "classic-layer"
+
+
+def _validate_route_name(route_name: str) -> None:
+    """Validate the route module name."""
+    if not route_name.isidentifier() or keyword.iskeyword(route_name):
+        raise BackendExceptions(f"Route name {route_name!r} is not a Python identifier")
+
+
+class ClassicLayeredRouteGenerator:
+    """Generate api/routes, crud, and schemas modules."""
+
+    def add_new_route(
+        self, project_dir: str, route_name: str, project_layout: Dict[str, str]
+    ) -> None:
+        """Create route files and register the router."""
+        src_dir = project_layout["package_dir"]
+        _validate_route_name(route_name)
+        modules_dir = os.path.join(settings.FASTKIT_TEMPLATE_ROOT, "modules")
+        target_dirs = backend._ensure_project_structure(src_dir)
+        backend._create_route_files(
+            modules_dir, target_dirs, route_name, project_layout["package_module"]
+        )
+        backend._handle_api_router_file(
+            target_dirs, modules_dir, route_name, project_layout["api_router_file"]
+        )
+        backend._process_init_files(
+            modules_dir, target_dirs, ["api/routes", "crud", "schemas"]
+        )
+        backend._update_main_app(
+            src_dir,
+            route_name,
+            router_module=project_layout["api_router_module"],
+            main_py_path=project_layout["main"],
+        )
+
+
+class DomainRouteGenerator:
+    """Generate a domain module."""
+
+    def add_new_route(
+        self, project_dir: str, route_name: str, project_layout: Dict[str, str]
+    ) -> None:
+        """Create domain files and register the router."""
+        package = Path(project_layout["package_dir"])
+        _validate_route_name(route_name)
+        if not package.is_dir():
+            raise BackendExceptions(f"Source directory not found at {package}")
+
+        domain_module = _create_domain_files(package, route_name, project_layout)
+        alias = router_alias(
+            project_layout["api_router_file"],
+            domain_module,
+            "router",
+            f"{route_name}_router",
+        )
+        register_router(
+            project_layout,
+            f"from {domain_module} import router as {alias}",
+            f'api_router.include_router({alias}.router, prefix="/{route_name}", tags=["{route_name}"])',
+        )
+        backend._update_main_app(
+            str(package),
+            route_name,
+            router_module=project_layout["api_router_module"],
+            main_py_path=project_layout["main"],
+        )
+
+
+def _create_domain_files(
+    package: Path, route_name: str, project_layout: Dict[str, str]
+) -> str:
+    templates = Path(settings.FASTKIT_TEMPLATE_ROOT) / "modules" / "domain"
+    filenames = (
+        "__init__.py",
+        "models.py",
+        "schemas.py",
+        "repository.py",
+        "service.py",
+        "router.py",
+    )
+    for filename in filenames:
+        if not (templates / f"{filename}-tpl").is_file():
+            raise BackendExceptions(f"Missing domain template: {filename}-tpl")
+
+    domain_dir = package / "domains" / route_name
+    domain_dir.mkdir(parents=True, exist_ok=True)
+    domains_init = domain_dir.parent / "__init__.py"
+    if not domains_init.exists():
+        domains_init.write_text("", encoding="utf-8")
+    prefix = project_layout["package_module"]
+    domain_module = (
+        f"{prefix}.domains.{route_name}" if prefix else f"domains.{route_name}"
+    )
+    entity_class = (
+        "".join(part[:1].upper() + part[1:] for part in route_name.split("_")) or "_"
+    )
+    if keyword.iskeyword(entity_class):
+        entity_class += "Entity"
+    replacements = {
+        "<new_route>": route_name,
+        "<domain_module>": domain_module,
+        "<entity_class>": entity_class,
+    }
+    for filename in filenames:
+        target = domain_dir / filename
+        if target.exists():
+            print_warning(f"File {target} already exists, skipping...")
+            continue
+        if not copy_and_convert_template_file(
+            str(templates / f"{filename}-tpl"), str(target), replacements
+        ):
+            raise BackendExceptions(f"Failed to create domain file: {target}")
+
+    return domain_module
+
+
+def get_route_generator(
+    route_layout: str,
+) -> Union[ClassicLayeredRouteGenerator, DomainRouteGenerator]:
+    """Return the generator for the selected layout."""
+    if route_layout == "classic-layer":
+        return ClassicLayeredRouteGenerator()
+    if route_layout == "domain":
+        return DomainRouteGenerator()
+    raise BackendExceptions(f"Unknown route layout: {route_layout!r}")

fastapi_fastkit-1.5.0/src/fastapi_fastkit/backend/route_wiring.py

@@ -0,0 +1,117 @@
+"""Router registration helpers."""
+
+import ast
+from pathlib import Path
+from typing import Dict
+
+from fastapi_fastkit.utils.main import print_info
+
+
+def _parse_module(content: str) -> ast.Module:
+    try:
+        return ast.parse(content)
+    except SyntaxError:
+        statements: list[ast.stmt] = []
+        for line in content.splitlines():
+            try:
+                statements.extend(ast.parse(line.strip()).body)
+            except SyntaxError:
+                continue
+        return ast.Module(body=statements, type_ignores=[])
+
+
+def _router_argument(call: ast.Call) -> ast.expr | None:
+    if call.args:
+        return call.args[0]
+    return next((item.value for item in call.keywords if item.arg == "router"), None)
+
+
+def register_router(
+    project_layout: Dict[str, str], import_line: str, statement: str
+) -> None:
+    """Register a router in the API router module."""
+
+    from fastapi_fastkit.backend.main import insert_import_line, insert_statement_line
+
+    api_dir = Path(project_layout["api_dir"])
+    api_dir.mkdir(parents=True, exist_ok=True)
+    init = api_dir / "__init__.py"
+    if not init.exists():
+        init.write_text("", encoding="utf-8")
+    target = Path(project_layout["api_router_file"])
+    content = target.read_text(encoding="utf-8") if target.exists() else ""
+    if not content.strip():
+        content = "from fastapi import APIRouter\n\napi_router = APIRouter()\n"
+    registration = ast.parse(statement).body[0]
+    existing = None
+    if isinstance(registration, ast.Expr) and isinstance(registration.value, ast.Call):
+        expected = registration.value
+        expected_router = _router_argument(expected)
+        existing = next(
+            (
+                node
+                for node in ast.walk(_parse_module(content))
+                if isinstance(node, ast.Call)
+                and ast.dump(node.func) == ast.dump(expected.func)
+                and (argument := _router_argument(node)) is not None
+                and expected_router is not None
+                and ast.dump(argument) == ast.dump(expected_router)
+            ),
+            None,
+        )
+        if existing is not None:
+            current_options = {
+                item.arg: ast.dump(item.value)
+                for item in existing.keywords
+                if item.arg != "router"
+            }
+            expected_options = {
+                item.arg: ast.dump(item.value)
+                for item in expected.keywords
+                if item.arg != "router"
+            }
+            if (
+                current_options != expected_options
+                or existing.args[1:] != expected.args[1:]
+            ):
+                print_info(
+                    f"Keeping existing router registration in {target} with its current prefix and options."
+                )
+    updated = insert_import_line(content, import_line)
+    if existing is None:
+        updated = insert_statement_line(updated, statement)
+    if not target.exists() or updated != content:
+        target.write_text(updated, encoding="utf-8")
+
+
+def router_alias(file: str, module: str, name: str, preferred: str) -> str:
+    """Reuse the router import alias or choose an unused name."""
+
+    target = Path(file)
+    if not target.exists():
+        return preferred
+    tree = _parse_module(target.read_text(encoding="utf-8"))
+    occupied: set[str] = set()
+    for node in tree.body:
+        if isinstance(node, ast.ImportFrom):
+            for imported in node.names:
+                if node.module == module and imported.name == name:
+                    return imported.asname or name
+                occupied.add(imported.asname or imported.name)
+        elif isinstance(node, ast.Import):
+            occupied.update(
+                item.asname or item.name.split(".")[0] for item in node.names
+            )
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            occupied.add(node.name)
+        elif isinstance(node, (ast.Assign, ast.AnnAssign)):
+            targets = node.targets if isinstance(node, ast.Assign) else [node.target]
+            occupied.update(
+                target.id for target in targets if isinstance(target, ast.Name)
+            )
+    alias = preferred
+    counter = 2
+    while alias in occupied:
+        alias = f"{preferred}_{counter}"
+        counter += 1
+    return alias

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/cli.py

@@ -37,6 +37,7 @@ from fastapi_fastkit.backend.project_builder.config_schema import (
     ConfigSchemaError,
     normalize_project_config,
 )
+from fastapi_fastkit.backend.route_generators import resolve_route_layout
 from fastapi_fastkit.backend.scaffolder import (
     ProjectScaffolder,
     ScaffoldOptions,
@@ -829,8 +830,16 @@ def _init_from_config(
 @fastkit_cli.command()
 @click.argument("route_name")
 @click.argument("project_dir", default=".")
+@click.option(
+    "--layout",
+    type=click.Choice(["classic-layer", "domain"]),
+    default=None,
+    help="Route layout. Defaults to domain for domain-starter, otherwise classic-layer.",
+)
 @click.pass_context
-def addroute(ctx: Context, route_name: str, project_dir: str) -> None:
+def addroute(
+    ctx: Context, route_name: str, project_dir: str, layout: Optional[str]
+) -> None:
     """
     Add a new route to the FastAPI project.
 
@@ -879,12 +888,14 @@ def addroute(ctx: Context, route_name: str, project_dir: str) -> None:
         return
 
     try:
+        route_layout = resolve_route_layout(actual_project_dir, layout)
         # Show information about the operation
         table = create_info_table(
             "Adding New Route",
             {
                 "Project": project_name,
                 "Route Name": route_name,
+                "Layout": route_layout,
                 "Target Directory": actual_project_dir,
             },
         )
@@ -903,7 +914,7 @@ def addroute(ctx: Context, route_name: str, project_dir: str) -> None:
             return
 
         # Add the new route
-        add_new_route(actual_project_dir, route_name)
+        add_new_route(actual_project_dir, route_name, layout=route_layout)
 
         if project_dir == ".":
             print_success(

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/fastapi_project_template/fastapi-auth-jwt/pyproject.toml-tpl

@@ -19,7 +19,7 @@ dependencies = [
     "sqlmodel>=0.0.42",
     "SQLAlchemy>=2.0.52",
     "alembic>=1.19.1",
-    "PyJWT>=2.13.0",
+    "PyJWT>=2.15.1",
     "pwdlib[argon2]>=0.3.1",
     "psycopg[binary]>=3.3.5",
 ]

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/fastapi_project_template/fastapi-auth-jwt/requirements.txt-tpl

@@ -12,7 +12,7 @@ SQLAlchemy==2.0.52
 alembic==1.19.1
 psycopg[binary]==3.3.5
 # Authentication
-PyJWT==2.13.0
+PyJWT==2.15.1
 pwdlib[argon2]==0.3.1
 # Development & tests
 pytest==9.1.1

{fastapi_fastkit-1.4.1/src/fastapi_fastkit/fastapi_project_template/fastapi-sqlmodel → fastapi_fastkit-1.5.0/src/fastapi_fastkit/fastapi_project_template/fastapi-domain-starter}/src/app/api/router.py-tpl

@@ -11,5 +11,5 @@ from src.app.domains.items import router as items_router
 
 api_router = APIRouter()
 api_router.include_router(health.router)
-api_router.include_router(items_router.router)
+api_router.include_router(items_router.router, prefix="/items", tags=["items"])
 # fastkit:routes

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/fastapi_project_template/fastapi-domain-starter/src/app/domains/items/router.py-tpl

@@ -7,7 +7,7 @@ from fastapi import APIRouter, Depends, HTTPException, Response, status
 from src.app.domains.items.schemas import ItemCreate, ItemRead
 from src.app.domains.items.service import ItemNotFoundError, ItemService
 
-router = APIRouter(prefix="/items", tags=["items"])
+router = APIRouter()
 
 
 def get_item_service() -> ItemService:

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/fastapi_project_template/fastapi-domain-starter/tests/conftest.py-tpl

@@ -2,19 +2,31 @@
 # pytest fixtures for <project_name>.
 # --------------------------------------------------------------------------
 from collections.abc import Generator
+from importlib import import_module
+from pkgutil import iter_modules
 
 import pytest
 from fastapi.testclient import TestClient
+from src.app import domains
 from src.app.domains.items.repository import ItemRepository
 from src.app.main import app
 
 
-@pytest.fixture(autouse=True)
-def reset_items_store() -> Generator[None, None, None]:
-    """Each test starts with an empty items store."""
+def reset_stores() -> None:
     ItemRepository().reset()
+    for module in iter_modules(domains.__path__, prefix=f"{domains.__name__}."):
+        if module.ispkg:
+            domain = import_module(module.name)
+            reset = getattr(getattr(domain, "service", None), "reset_store", None)
+            if reset is not None:
+                reset()
+
+
+@pytest.fixture(autouse=True)
+def reset_domain_stores() -> Generator[None, None, None]:
+    reset_stores()
     yield
-    ItemRepository().reset()
+    reset_stores()
 
 
 @pytest.fixture

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/fastapi_project_template/fastapi-mcp/pyproject.toml-tpl

@@ -18,7 +18,7 @@ dependencies = [
     "fastapi-mcp>=0.3.7,<0.4.0",
     "mcp>=1.29.1,<2.0.0",
     "pwdlib[argon2]>=0.3.1",
-    "PyJWT[crypto]>=2.13.0",
+    "PyJWT[crypto]>=2.15.1",
     "python-multipart>=0.0.32",
 ]
 

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/fastapi_project_template/fastapi-mcp/requirements.txt-tpl

@@ -40,7 +40,7 @@ pydantic==2.13.5
 pydantic-core==2.46.5
 pydantic-settings==2.15.0
 pygments==2.21.0
-PyJWT==2.13.0
+PyJWT==2.15.1
 pytest==9.1.1
 pytest-cov==7.1.0
 python-dotenv==1.2.3
@@ -59,7 +59,7 @@ tomli==2.4.1
 typer==0.27.2
 typing-extensions==4.16.0
 typing-inspection==0.4.4
-urllib3==2.7.0
+urllib3==2.8.0
 uvicorn==0.52.4
 uvloop==0.22.1
 watchfiles==1.2.0

{fastapi_fastkit-1.4.1 → fastapi_fastkit-1.5.0}/src/fastapi_fastkit/fastapi_project_template/fastapi-mcp/setup.cfg-tpl

@@ -29,7 +29,7 @@ install_requires =
     pydantic>=2.10.6
     pydantic-settings>=2.7.1
     python-dotenv>=1.0.1
-    PyJWT[crypto]>=2.10.0
+    PyJWT[crypto]>=2.15.1
     pwdlib[argon2]>=0.3.1
     python-multipart>=0.0.17
 

fastapi_fastkit-1.5.0/src/fastapi_fastkit/fastapi_project_template/modules/domain/__init__.py-tpl

@@ -0,0 +1,10 @@
+# --------------------------------------------------------------------------
+# <new_route> domain.
+# --------------------------------------------------------------------------
+from <domain_module> import (  # noqa: F401
+    models,
+    repository,
+    router,
+    schemas,
+    service,
+)

fastapi_fastkit-1.5.0/src/fastapi_fastkit/fastapi_project_template/modules/domain/models.py-tpl

@@ -0,0 +1,11 @@
+# --------------------------------------------------------------------------
+# <new_route> domain models.
+# --------------------------------------------------------------------------
+
+from dataclasses import dataclass
+
+
+@dataclass
+class <entity_class>:
+    id: int
+    name: str