FastAPI-fastkit 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

fastapi_fastkit/backend/project_builder/config_generator.py

@@ -10,7 +10,6 @@
 #
 # @author bnbong bbbong9@gmail.com
 # --------------------------------------------------------------------------
-import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -179,11 +178,11 @@ class DynamicConfigGenerator:
         # App initialization
         project_name = self.config.get("project_name", "FastAPI App")
         description = self.config.get("description", "")
-        content_parts.append(f"app = FastAPI(")
+        content_parts.append("app = FastAPI(")
         content_parts.append(f'    title="{project_name}",')
         content_parts.append(f'    description="{description}",')
-        content_parts.append(f'    version="0.1.0",')
-        content_parts.append(f")")
+        content_parts.append('    version="0.1.0",')
+        content_parts.append(")")
         content_parts.append("")
 
         # App configuration
@@ -448,12 +447,20 @@ class DynamicConfigGenerator:
 
         return "\n".join(content)
 
-    def generate_docker_files(self) -> None:
-        """Generate Dockerfile and docker-compose.yml."""
+    def generate_docker_files(self, app_module: str = "src.main:app") -> None:
+        """Generate Dockerfile and docker-compose.yml.
+
+        The ``app_module`` is the ``module:attr`` string baked into the
+        Dockerfile's ``CMD`` (and into docker-compose's `command` if the
+        compose generator ever needs it). Architecture presets that put
+        the FastAPI app at a non-default location (e.g. ``domain-starter``
+        ships ``src/app/main.py``) must pass the matching dotted path so
+        the generated container actually starts.
+        """
         deployment = self.config.get("deployment", [])
 
         if "Docker" in deployment:
-            dockerfile_content = self._generate_dockerfile()
+            dockerfile_content = self._generate_dockerfile(app_module=app_module)
             dockerfile_path = self.project_dir / "Dockerfile"
             with open(dockerfile_path, "w") as f:
                 f.write(dockerfile_content)
@@ -464,8 +471,8 @@ class DynamicConfigGenerator:
             with open(compose_path, "w") as f:
                 f.write(compose_content)
 
-    def _generate_dockerfile(self) -> str:
-        """Generate Dockerfile content."""
+    def _generate_dockerfile(self, app_module: str = "src.main:app") -> str:
+        """Generate Dockerfile content with a layout-aware uvicorn target."""
         content = []
         content.append(
             "# --------------------------------------------------------------------------"
@@ -488,7 +495,7 @@ class DynamicConfigGenerator:
         content.append("")
         content.append("# Run application")
         content.append(
-            'CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"]'
+            f'CMD ["uvicorn", "{app_module}", "--host", "0.0.0.0", "--port", "8000"]'
         )
         content.append("")
 

fastapi_fastkit/backend/project_builder/preset_layout.py

@@ -0,0 +1,203 @@
+# --------------------------------------------------------------------------
+# Architecture-preset layout strategy for interactive project generation.
+#
+# Maps each architecture preset (issue #44) to the actual generation
+# decisions interactive ``init`` makes:
+#
+#   - which template ships as the base scaffold,
+#   - whether the dynamic ``main.py`` overlay should overwrite the shipped one,
+#   - where database / auth config files should land so they sit next to the
+#     template's existing structure rather than in a parallel ``src/config``,
+#   - and which feature combinations need a "you must wire this up manually"
+#     warning because the dynamic ``main.py`` overlay isn't applied.
+#
+# Keeping every preset's layout knowledge in one place lets the CLI flow stay
+# linear ("ask the strategist where to write the file") instead of growing a
+# branching maze of preset-specific if/else blocks.
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+# Canonical preset id used when a caller doesn't supply one. Picked to
+# preserve pre-#45 behaviour: interactive ``init`` historically deployed
+# ``fastapi-empty`` and regenerated ``src/main.py`` from feature flags.
+_FALLBACK_PRESET_ID: str = "minimal"
+
+
+@dataclass(frozen=True)
+class PresetProfile:
+    """Per-preset generation decisions. Treat as a value object."""
+
+    preset_id: str
+    base_template: str
+    regenerate_main: bool
+    main_py_relpath: str
+    db_config_relpath: str
+    auth_config_relpath: str
+    # Hint shown when ``regenerate_main`` is False and the user picked a
+    # feature whose dynamic main.py overlay won't run. Empty string means
+    # "no special note for this preset".
+    manual_wiring_note: str = ""
+    extra_warning_targets: Tuple[str, ...] = field(default_factory=tuple)
+
+
+_PRESET_PROFILES: Dict[str, PresetProfile] = {
+    "minimal": PresetProfile(
+        preset_id="minimal",
+        base_template="fastapi-empty",
+        regenerate_main=True,
+        main_py_relpath="src/main.py",
+        db_config_relpath="src/config/database.py",
+        auth_config_relpath="src/config/auth.py",
+    ),
+    "single-module": PresetProfile(
+        preset_id="single-module",
+        base_template="fastapi-single-module",
+        regenerate_main=True,
+        main_py_relpath="src/main.py",
+        db_config_relpath="src/config/database.py",
+        auth_config_relpath="src/config/auth.py",
+    ),
+    "classic-layered": PresetProfile(
+        preset_id="classic-layered",
+        base_template="fastapi-default",
+        regenerate_main=False,
+        main_py_relpath="src/main.py",
+        db_config_relpath="src/core/database.py",
+        auth_config_relpath="src/core/auth.py",
+        # CORS is intentionally NOT in this list: fastapi-default's shipped
+        # main.py already imports CORSMiddleware and adds it conditionally
+        # on settings.all_cors_origins, so the user only has to populate
+        # BACKEND_CORS_ORIGINS in .env — no code edits needed.
+        manual_wiring_note=(
+            "fastapi-default's shipped src/main.py is preserved. The "
+            "selections below need manual wiring there (CORS is already "
+            "wired — set BACKEND_CORS_ORIGINS in .env to activate it)."
+        ),
+        extra_warning_targets=("Rate-Limiting", "Prometheus"),
+    ),
+    "domain-starter": PresetProfile(
+        preset_id="domain-starter",
+        base_template="fastapi-domain-starter",
+        regenerate_main=False,
+        main_py_relpath="src/app/main.py",
+        db_config_relpath="src/app/core/database.py",
+        auth_config_relpath="src/app/core/auth.py",
+        manual_wiring_note=(
+            "fastapi-domain-starter's shipped src/app/main.py is preserved. "
+            "The selections below need manual wiring there (CORS is already "
+            "wired — set BACKEND_CORS_ORIGINS in .env to activate it)."
+        ),
+        extra_warning_targets=("Rate-Limiting", "Prometheus"),
+    ),
+}
+
+
+class PresetLayoutStrategist:
+    """Single source of truth for preset → generation-layout decisions."""
+
+    def __init__(self, preset_id: str | None) -> None:
+        # Empty / None / unknown ids fall back to ``minimal`` so older callers
+        # that pre-date the architecture-preset prompt keep working.
+        canonical = (preset_id or _FALLBACK_PRESET_ID).strip()
+        self.profile: PresetProfile = _PRESET_PROFILES.get(
+            canonical, _PRESET_PROFILES[_FALLBACK_PRESET_ID]
+        )
+
+    @classmethod
+    def supported_presets(cls) -> List[str]:
+        """Return the ordered list of preset ids the strategist understands."""
+        return list(_PRESET_PROFILES.keys())
+
+    @property
+    def preset_id(self) -> str:
+        return self.profile.preset_id
+
+    @property
+    def base_template(self) -> str:
+        return self.profile.base_template
+
+    @property
+    def should_regenerate_main(self) -> bool:
+        return self.profile.regenerate_main
+
+    def main_py_target(self, project_dir: str) -> Path:
+        """Absolute path where the dynamic main.py overlay should land."""
+        return Path(project_dir) / self.profile.main_py_relpath
+
+    @property
+    def app_module(self) -> str:
+        """Return the ``module:attr`` string uvicorn / Docker should target.
+
+        Derived from ``main_py_relpath`` so docker generation, runserver,
+        and any future container-orchestration code all agree on the
+        entrypoint a given preset produces.
+        """
+        # Strip the trailing ``.py`` and convert path separators to dots.
+        relpath = self.profile.main_py_relpath
+        if relpath.endswith(".py"):
+            relpath = relpath[: -len(".py")]
+        module_part = relpath.replace("/", ".").replace("\\", ".")
+        return f"{module_part}:app"
+
+    def db_config_target(self, project_dir: str) -> Path:
+        """Absolute path for the generated database config module."""
+        return Path(project_dir) / self.profile.db_config_relpath
+
+    def auth_config_target(self, project_dir: str) -> Path:
+        """Absolute path for the generated authentication config module."""
+        return Path(project_dir) / self.profile.auth_config_relpath
+
+    def compatibility_warnings(self, config: Dict[str, Any]) -> List[str]:
+        """Return user-facing warnings for unsupported preset/feature mixes.
+
+        The dynamic ``main.py`` overlay (CORS middleware wiring, Prometheus
+        instrumentation, rate-limit hookup) only runs for presets that
+        regenerate ``main.py``. For the other presets we keep the
+        template-shipped ``main.py`` intact and surface a single warning
+        listing the affected features so users know to wire them up
+        themselves rather than assuming the package install was enough.
+        """
+        if self.profile.regenerate_main:
+            return []
+
+        affected = self._affected_overlay_targets(config)
+        if not affected:
+            return []
+
+        warnings: List[str] = []
+        if self.profile.manual_wiring_note:
+            warnings.append(self.profile.manual_wiring_note)
+        warnings.append(
+            "Affected selections (packages installed, but no dynamic main.py "
+            "edits applied for the '"
+            + self.profile.preset_id
+            + "' preset): "
+            + ", ".join(affected)
+        )
+        return warnings
+
+    def _affected_overlay_targets(self, config: Dict[str, Any]) -> List[str]:
+        """Detect which of the user's selections rely on main.py overlay."""
+        triggered: List[str] = []
+        utilities = set(config.get("utilities") or [])
+
+        for target in self.profile.extra_warning_targets:
+            if target in {"CORS", "Rate-Limiting"}:
+                if target in utilities:
+                    triggered.append(target)
+            elif target == "Prometheus":
+                if config.get("monitoring") == "Prometheus":
+                    triggered.append(target)
+        return triggered
+
+
+__all__ = [
+    "PresetLayoutStrategist",
+    "PresetProfile",
+]

fastapi_fastkit/backend/transducer.py

@@ -10,7 +10,6 @@ import os
 import shutil
 from typing import Dict, Optional
 
-from fastapi_fastkit.core.settings import settings
 from fastapi_fastkit.utils.logging import debug_log, get_logger
 
 logger = get_logger(__name__)

fastapi_fastkit/cli.py

@@ -267,7 +267,7 @@ def startdemo(
     if template_deps:
         deps_table = create_info_table(
             "Template Dependencies",
-            {f"Dependency {i+1}": dep for i, dep in enumerate(template_deps)},
+            {f"Dependency {i + 1}": dep for i, dep in enumerate(template_deps)},
         )
         console.print("\n")
         console.print(deps_table)
@@ -334,7 +334,11 @@ def startdemo(
     "--interactive",
     is_flag=True,
     default=False,
-    help="Enable interactive mode for guided project setup with feature selection.",
+    help=(
+        "Enable interactive mode for guided project setup. Walks through an "
+        "architecture preset (minimal / single-module / classic-layered / "
+        "domain-starter, default: domain-starter), then feature selection."
+    ),
 )
 @click.option(
     "--project-name",
@@ -372,7 +376,11 @@ def init(
     """
     Start a FastAPI project setup.
 
-    Use --interactive for guided setup with dynamic feature selection.
+    Use --interactive for guided setup. Interactive mode prompts for an
+    architecture preset (``minimal`` / ``single-module`` / ``classic-layered``
+    / ``domain-starter`` — default: ``domain-starter``) and then walks
+    through feature selection (database, auth, testing, deployment, ...).
+
     Without --interactive, creates an empty project with predefined stacks.
 
     This command will automatically create a new FastAPI project directory
@@ -414,8 +422,17 @@ def init(
         try:
             user_local = settings.USER_WORKSPACE
 
-            # Use fastapi-empty template as base
-            template = "fastapi-empty"
+            # Pick the base template from the architecture preset chosen
+            # earlier in the interactive flow. Older callers without a
+            # preset fall back to ``minimal`` (= fastapi-empty), preserving
+            # pre-#45 behaviour.
+            from fastapi_fastkit.backend.project_builder import (
+                PresetLayoutStrategist,
+            )
+
+            preset_id = config.get("architecture_preset")
+            strategist = PresetLayoutStrategist(preset_id)
+            template = strategist.base_template
             template_dir = settings.FASTKIT_TEMPLATE_ROOT
             target_template = os.path.join(template_dir, template)
 
@@ -464,38 +481,44 @@ def init(
 
             generator = DynamicConfigGenerator(config, project_dir)
 
-            # Generate main.py with selected features
-            main_py_content = generator.generate_main_py()
-            main_py_path = os.path.join(project_dir, "src", "main.py")
-            if not os.path.exists(main_py_path):
-                main_py_path = os.path.join(project_dir, "main.py")
-
-            with open(main_py_path, "w") as f:
-                f.write(main_py_content)
+            # main.py overlay — only regenerated for presets that ship a
+            # placeholder app (minimal, single-module). For richer presets
+            # (classic-layered, domain-starter) we keep the template's
+            # router-aware main.py intact.
+            #
+            # The strategist's ``main_py_target`` is always ``src/main.py``
+            # for both regenerate-main presets, and both fastapi-empty and
+            # fastapi-single-module ship that file, so we can write
+            # straight to the strategist's path without a flat-``main.py``
+            # fallback branch.
+            if strategist.should_regenerate_main:
+                main_py_path = strategist.main_py_target(project_dir)
+                main_py_path.parent.mkdir(parents=True, exist_ok=True)
+                main_py_path.write_text(generator.generate_main_py())
+            else:
+                print_info(
+                    f"Preserving template-shipped main.py for preset "
+                    f"'{strategist.preset_id}'."
+                )
 
-            # Generate database configuration if selected
+            # Generate database configuration if selected — preset chooses
+            # where the file lives so it sits next to the existing structure.
             db_info = config.get("database", {})
             if isinstance(db_info, dict) and db_info.get("type") != "None":
                 db_config_content = generator.generate_database_config()
                 if db_config_content:
-                    db_config_path = os.path.join(
-                        project_dir, "src", "config", "database.py"
-                    )
-                    os.makedirs(os.path.dirname(db_config_path), exist_ok=True)
-                    with open(db_config_path, "w") as f:
-                        f.write(db_config_content)
+                    db_config_path = strategist.db_config_target(project_dir)
+                    db_config_path.parent.mkdir(parents=True, exist_ok=True)
+                    db_config_path.write_text(db_config_content)
 
             # Generate auth configuration if selected
             auth_type = config.get("authentication", "None")
             if auth_type != "None":
                 auth_config_content = generator.generate_auth_config()
                 if auth_config_content:
-                    auth_config_path = os.path.join(
-                        project_dir, "src", "config", "auth.py"
-                    )
-                    os.makedirs(os.path.dirname(auth_config_path), exist_ok=True)
-                    with open(auth_config_path, "w") as f:
-                        f.write(auth_config_content)
+                    auth_config_path = strategist.auth_config_target(project_dir)
+                    auth_config_path.parent.mkdir(parents=True, exist_ok=True)
+                    auth_config_path.write_text(auth_config_content)
 
             # Generate test configuration if testing selected
             testing_type = config.get("testing", "None")
@@ -509,9 +532,20 @@ def init(
             # Generate Docker files if deployment selected
             deployment = config.get("deployment", [])
             if deployment and deployment != ["None"]:
-                generator.generate_docker_files()
+                # Thread the preset-aware app module so the generated
+                # Dockerfile's ``CMD ["uvicorn", "<module>:app", ...]``
+                # matches the layout the user actually generated. Default
+                # ``src.main:app`` only works for minimal / single-module /
+                # classic-layered; domain-starter needs ``src.app.main:app``.
+                generator.generate_docker_files(app_module=strategist.app_module)
                 print_success("Generated Docker deployment files")
 
+            # Surface preset-specific warnings (e.g. "you picked a preset
+            # whose shipped main.py we kept; CORS/Prometheus must be wired
+            # manually").
+            for warning in strategist.compatibility_warnings(config):
+                print_warning(warning, title="Preset compatibility")
+
             print_success("Generated configuration files for selected stack")
 
             # Create virtual environment and install dependencies
@@ -579,7 +613,7 @@ def init(
     for stack_name, deps in settings.PROJECT_STACKS.items():
         table = create_info_table(
             f"{stack_name.upper()} Stack",
-            {f"Dependency {i+1}": dep for i, dep in enumerate(deps)},
+            {f"Dependency {i + 1}": dep for i, dep in enumerate(deps)},
         )
         console.print(table)
         console.print("\n")
@@ -819,6 +853,20 @@ def deleteproject(ctx: Context, project_name: str) -> None:
         print_error(f"Error during project deletion: {e}")
 
 
+def _derive_app_module(project_dir: str, main_path: str) -> str:
+    """Convert a discovered ``main.py`` path into a uvicorn ``module:attr``.
+
+    Templates can place ``main.py`` anywhere under the project (``main.py``,
+    ``src/main.py``, ``src/app/main.py``, ...). The previous ``"src/"`` /
+    ``""`` heuristic mis-mapped the domain-starter layout (``src/app/main.py``
+    → wrongly produced ``src.main:app``); deriving the dotted path from the
+    actual relative location avoids that drift for any future layout too.
+    """
+    rel_path = os.path.relpath(main_path, project_dir)
+    module_part = os.path.splitext(rel_path)[0].replace(os.sep, ".")
+    return f"{module_part}:app"
+
+
 @fastkit_cli.command()
 @click.option(
     "--host",
@@ -893,10 +941,7 @@ def runserver(
         return
 
     main_path = core_modules["main"]
-    if "src/" in main_path:
-        app_module = "src.main:app"
-    else:
-        app_module = "main:app"
+    app_module = _derive_app_module(project_dir, main_path)
 
     if venv_python:
         print_info(f"Using Python from virtual environment: {venv_python}")

fastapi_fastkit/core/settings.py

@@ -24,6 +24,7 @@ class FastkitConfig:
     TEMPLATE_PATHS: dict[str, list[str] | dict[str, list[str]]] = {
         "main": [
             "src/main.py",
+            "src/app/main.py",
             "main.py",
         ],
         "setup": [
@@ -37,12 +38,27 @@ class FastkitConfig:
             "files": ["settings.py", "config.py"],
             "paths": [
                 "src/core",
+                "src/app/core",
                 "src",
                 "",
             ],
         },
     }
 
+    # Architecture Presets (interactive ``init`` wizard)
+    #
+    # The preset shapes how the generated project is laid out (single file vs.
+    # layered vs. domain-oriented). Preset-specific generation logic lives in
+    # later issues — this catalog is the user-facing menu and the canonical
+    # set of preset ids persisted in the interactive config.
+    ARCHITECTURE_PRESETS: dict[str, str] = {
+        "minimal": "Smallest viable FastAPI app — a single app + a couple of files.",
+        "single-module": "Everything in one module; ideal for tiny scripts and prototypes.",
+        "classic-layered": "Layered split: api/routes, crud, schemas, core (a la fastapi-default).",
+        "domain-starter": "Domain-oriented: src/app/domains/<concept>/ with router/service/repository (recommended).",
+    }
+    DEFAULT_ARCHITECTURE_PRESET: str = "domain-starter"
+
     # Startproject Options
     PROJECT_STACKS: dict[str, list[str]] = {
         "minimal": ["fastapi", "uvicorn", "pydantic", "pydantic-settings"],

fastapi_fastkit/fastapi_project_template/README.md

@@ -18,37 +18,86 @@ template-name/
 │ ├── models/
 │ ├── routes/
 │ └── utils/
-├── tests/
+├── tests/                    # required
 ├── scripts/
-├── requirements.txt-tpl
-├── setup.py-tpl
-└── README.md-tpl
+├── pyproject.toml-tpl        # preferred primary metadata file (PEP 621)
+├── setup.py-tpl              # legacy alternative, still accepted
+├── requirements.txt-tpl      # optional when pyproject.toml-tpl declares deps
+└── README.md-tpl             # required
 ```
 
+The minimum required files for a modern template are `tests/`, `README.md-tpl`,
+and at least one metadata file (`pyproject.toml-tpl` or `setup.py-tpl`).
+`requirements.txt-tpl` is optional when the template's dependencies are
+declared under `[project].dependencies` in `pyproject.toml-tpl`.
+
+Modern templates **SHOULD** ship `pyproject.toml-tpl` as the primary metadata
+file. `setup.py-tpl` remains supported for backward compatibility.
+
 ### Key Requirements:
 
 1. All source files must use `.py-tpl` extension
-2. `setup.py` must include `fastapi-fastkit` string in project description
-   for example:
-   ```
-   ...
-   setup(
-      ...
-      description = "[fastapi-fastkit templated] <description>",
-      ...
-   )
-   ```
-3. `setup.py` must include `install_requires` section, it must include essential dependencies for the template project. Also, note that install_requires list must be type annotated.
-   for example:
+2. The template must declare `fastapi` as a dependency in at least one of:
+   - `pyproject.toml-tpl` under `[project].dependencies` (preferred)
+   - `requirements.txt-tpl`
+   - `setup.py-tpl` under `install_requires`
+3. `pyproject.toml-tpl` (preferred) should use PEP 621 metadata and carry the
+   FastAPI-fastkit identity markers so that `is_fastkit_project()` can tell
+   generated projects apart from unrelated FastAPI projects in the user's
+   workspace:
    ```
-   ...
-   install_requires: list[str] = [
-      ...
-   ],
+   [project]
+   name = "<project_name>"
+   version = "0.1.0"
+   description = "[FastAPI-fastkit templated] <description>"
+   dependencies = [
+       "fastapi>=0.115.0",
+       ...
+   ]
+
+   [tool.fastapi-fastkit]
+   managed = true
    ```
-4. Basic CRUD operations example
-5. Unit tests implementation
-6. API documentation (OpenAPI/Swagger)
+   The `[FastAPI-fastkit templated]` marker in `description` and the
+   `[tool.fastapi-fastkit]` table are both recognized by detection (any one
+   suffices; matching is case-insensitive). Metadata injection will also add
+   these markers at project-generation time if a template forgets them, but
+   authors should include them explicitly.
+4. Legacy templates using `setup.py-tpl` should:
+   - declare dependencies via a type-annotated `install_requires` list, e.g.
+     ```
+     install_requires: list[str] = [
+        ...
+     ]
+     ```
+   - include the `[FastAPI-fastkit templated]` marker in the project
+     description. Detection falls back to a case-insensitive scan for
+     `fastapi-fastkit` in `setup.py`, so this marker keeps legacy projects
+     identifiable:
+     ```
+     setup(
+        ...
+        description = "[FastAPI-fastkit templated] <description>",
+        ...
+     )
+     ```
+5. Basic CRUD operations example
+6. Unit tests implementation
+7. API documentation (OpenAPI/Swagger)
+
+## Available templates
+
+| Template | When to choose |
+|---|---|
+| `fastapi-default` | Quick CRUD demo with the classic layered layout (`api/routes`, `crud`, `schemas`). Good first stop. |
+| `fastapi-empty` | Minimal scaffold for users who want to add their own structure on top. |
+| `fastapi-single-module` | Single-file sandbox for tiny prototypes / scripts. |
+| `fastapi-async-crud` | Async-flavoured equivalent of `fastapi-default`. |
+| `fastapi-custom-response` | Demonstrates custom response formatting / envelope patterns. |
+| `fastapi-dockerized` | Adds a production-ready Dockerfile to the default layout. |
+| `fastapi-psql-orm` | PostgreSQL + SQLAlchemy + Alembic; pick this when you need a real database. |
+| `fastapi-mcp` | Model Context Protocol integration. |
+| `fastapi-domain-starter` | **Recommended modern default for medium-sized APIs.** Pyproject-first, domain-oriented layout (`src/app/domains/<concept>/`) with a clean transport / service / repository split, plus a built-in `/health` probe. |
 
 ## Base structure of modules template
 

fastapi_fastkit/fastapi_project_template/fastapi-async-crud/pyproject.toml-tpl

@@ -1,7 +1,7 @@
 [project]
 name = "<project_name>"
 version = "0.1.0"
-description = "<description>"
+description = "[FastAPI-fastkit templated] <description>"
 authors = [
     {name = "<author>", email = "<author_email>"},
 ]
@@ -41,6 +41,9 @@ dev = [
     "PyYAML>=6.0.2",
 ]
 
+[tool.fastapi-fastkit]
+managed = true
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

fastapi_fastkit/fastapi_project_template/fastapi-custom-response/pyproject.toml-tpl

@@ -1,7 +1,7 @@
 [project]
 name = "<project_name>"
 version = "0.1.0"
-description = "<description>"
+description = "[FastAPI-fastkit templated] <description>"
 authors = [
     {name = "<author>", email = "<author_email>"},
 ]
@@ -41,6 +41,9 @@ dev = [
     "PyYAML>=6.0.2",
 ]
 
+[tool.fastapi-fastkit]
+managed = true
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

fastapi_fastkit/fastapi_project_template/fastapi-default/pyproject.toml-tpl

@@ -1,7 +1,7 @@
 [project]
 name = "<project_name>"
 version = "0.1.0"
-description = "<description>"
+description = "[FastAPI-fastkit templated] <description>"
 authors = [
     {name = "<author>", email = "<author_email>"},
 ]
@@ -38,6 +38,9 @@ dev = [
     "PyYAML>=6.0.2",
 ]
 
+[tool.fastapi-fastkit]
+managed = true
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"