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

fastapi_fastkit/backend/package_managers/poetry_manager.py

@@ -4,7 +4,7 @@
 # @author bnbong bbbong9@gmail.com
 # --------------------------------------------------------------------------
 import subprocess
-from typing import List
+from typing import List, Tuple
 
 from fastapi_fastkit.core.exceptions import BackendExceptions
 from fastapi_fastkit.utils.logging import debug_log, get_logger
@@ -19,6 +19,47 @@ from .base import BasePackageManager
 
 logger = get_logger(__name__)
 
+# PEP 440 version specifier operators, longest-match first so "===" beats "==".
+_PEP440_OPERATORS = ("===", "==", "!=", "<=", ">=", "~=", "<", ">")
+
+
+def _parse_pip_requirement(
+    requirement: str,
+) -> Tuple[str, List[str], str, str]:
+    """Parse a pip/PEP 508 requirement string.
+
+    Returns ``(name, extras, version_spec, marker)`` where ``version_spec``
+    includes the operator (e.g. ``">=1.2.3"``) or is empty when unspecified,
+    and ``marker`` is the environment marker without the leading semicolon.
+    """
+    req = requirement.strip()
+
+    marker = ""
+    if ";" in req:
+        req, marker = req.split(";", 1)
+        req = req.strip()
+        marker = marker.strip()
+
+    version_spec = ""
+    split_at = len(req)
+    for op in _PEP440_OPERATORS:
+        idx = req.find(op)
+        if idx != -1 and idx < split_at:
+            split_at = idx
+    if split_at < len(req):
+        version_spec = req[split_at:].strip()
+        req = req[:split_at].strip()
+
+    extras: List[str] = []
+    if "[" in req and req.endswith("]"):
+        bare_name, _, extras_part = req.partition("[")
+        extras = [
+            extra.strip() for extra in extras_part[:-1].split(",") if extra.strip()
+        ]
+        req = bare_name.strip()
+
+    return req, extras, version_spec, marker
+
 
 class PoetryManager(BasePackageManager):
     """Poetry package manager implementation."""
@@ -182,22 +223,42 @@ build-backend = "poetry.core.masonry.api"
         pyproject_path = self.get_dependency_file_path()
 
         try:
-            # Create dependencies section for Poetry
+            # Create dependencies section for Poetry. Parse each requirement as
+            # PEP 508 so non-``==`` specifiers (``>=``, ``~=``, ...), extras, and
+            # environment markers all round-trip to valid TOML.
             deps_section = ""
             for dep in dependencies:
-                # Convert pip-style to poetry-style
-                if "==" in dep:
-                    name, version = dep.split("==", 1)
-                    deps_section += f'{name} = "{version}"\n'
+                name_part, extras, version_spec, marker = _parse_pip_requirement(dep)
+                if not name_part:
+                    continue
+
+                if not version_spec:
+                    version_str = "*"
+                elif version_spec.startswith("=="):
+                    # Poetry treats a bare version as a pin; keep the old
+                    # formatting to avoid churn in generated files.
+                    version_str = version_spec[2:].strip()
+                else:
+                    version_str = version_spec
+
+                if extras or marker:
+                    parts = [f'version = "{version_str}"']
+                    if extras:
+                        extras_str = ", ".join(f'"{extra}"' for extra in extras)
+                        parts.append(f"extras = [{extras_str}]")
+                    if marker:
+                        escaped_marker = marker.replace('"', '\\"')
+                        parts.append(f'markers = "{escaped_marker}"')
+                    deps_section += f"{name_part} = {{{', '.join(parts)}}}\n"
                 else:
-                    deps_section += f'{dep} = "*"\n'
+                    deps_section += f'{name_part} = "{version_str}"\n'
 
             # Create basic pyproject.toml content for Poetry
             pyproject_content = f"""[tool.poetry]
-name = "{project_name or 'fastapi-project'}"
+name = "{project_name or "fastapi-project"}"
 version = "0.1.0"
-description = "{description or 'A FastAPI project'}"
-authors = ["{author or 'Author'} <{author_email or 'author@example.com'}>"]
+description = "{description or "A FastAPI project"}"
+authors = ["{author or "Author"} <{author_email or "author@example.com"}>"]
 readme = "README.md"
 license = "MIT"
 packages = [{{include = "src"}}]

fastapi_fastkit/backend/package_managers/uv_manager.py

@@ -160,11 +160,11 @@ class UvManager(BasePackageManager):
 
             # Create basic pyproject.toml content for UV
             pyproject_content = f"""[project]
-name = "{project_name or 'fastapi-project'}"
+name = "{project_name or "fastapi-project"}"
 version = "0.1.0"
-description = "{description or 'A FastAPI project'}"
+description = "{description or "A FastAPI project"}"
 authors = [
-    {{name = "{author or 'Author'}", email = "{author_email or 'author@example.com'}"}},
+    {{name = "{author or "Author"}", email = "{author_email or "author@example.com"}"}},
 ]
 dependencies = {deps_toml}
 requires-python = ">=3.8"

fastapi_fastkit/backend/project_builder/__init__.py

@@ -10,8 +10,11 @@
 # --------------------------------------------------------------------------
 from .config_generator import DynamicConfigGenerator
 from .dependency_collector import DependencyCollector
+from .preset_layout import PresetLayoutStrategist, PresetProfile
 
 __all__ = [
     "DependencyCollector",
     "DynamicConfigGenerator",
+    "PresetLayoutStrategist",
+    "PresetProfile",
 ]

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__)