FastAPI-fastkit 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

fastapi_fastkit/__init__.py

@@ -1,10 +1 @@
-__version__ = "0.0.1"
-
-import os
-
-from rich.console import Console
-
-if "PYTEST_CURRENT_TEST" in os.environ:
-    console = Console(no_color=True)
-else:
-    console = Console()
+__version__ = 'v0.1.1'

fastapi_fastkit/backend/inspector.py

@@ -0,0 +1,203 @@
+# --------------------------------------------------------------------------
+# The Module inspect FastAPI template is appropriate
+#
+# This module will be read by Github Action when contributor
+#   makes a PR of adding new FastAPI template.
+#
+# First, check a FastAPI template is formed a valid template form with .py-tpl extension
+#   & dependencies requirements.
+# Second, check a FastAPI template has a proper FastAPI server implementation.
+#   main.py module must have a FastAPI app creation. like `app = FastAPI()`
+# Third, check a FastAPI template has passed all the tests.
+#
+# This module create temporary named 'temp' directory at src/fastapi_fastkit/backend
+#   and copy a template to Funtional FastAPI application into the temp directory.
+# After the inspection, it will be deleted.
+#
+# This module include virtual environment creation & installation of dependencies.
+# Depending on the volume in which the template is implemented and the number of dependencies,
+#   it may take some time to complete the inspection.
+#
+# @author bnbong
+# --------------------------------------------------------------------------
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List
+
+from fastapi_fastkit.backend.main import (
+    create_venv,
+    find_template_core_modules,
+    install_dependencies,
+)
+from fastapi_fastkit.backend.transducer import copy_and_convert_template
+from fastapi_fastkit.utils.main import print_error, print_success, print_warning
+
+
+class TemplateInspector:
+    def __init__(self, template_path: str):
+        self.template_path = Path(template_path)
+        self.errors: List[str] = []
+        self.warnings: List[str] = []
+        self.temp_dir = os.path.join(os.path.dirname(__file__), "temp")
+
+        # Create temp directory and copy template
+        os.makedirs(self.temp_dir, exist_ok=True)
+        copy_and_convert_template(str(self.template_path), self.temp_dir)
+
+    def __del__(self) -> None:
+        """Cleanup temp directory when inspector is destroyed."""
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+
+    def inspect_template(self) -> bool:
+        """Inspect the template is valid FastAPI application."""
+        checks = [
+            self._check_file_structure,
+            self._check_file_extensions,
+            self._check_dependencies,
+            self._check_fastapi_implementation,
+            self._test_template,
+        ]
+
+        for check in checks:
+            if not check():
+                return False
+        return True
+
+    def _check_file_structure(self) -> bool:
+        """Check the required file and directory structure."""
+        required_paths = [
+            "tests",
+            "requirements.txt-tpl",
+            "setup.py-tpl",
+            "README.md-tpl",
+        ]
+
+        for path in required_paths:
+            if not (self.template_path / path).exists():
+                self.errors.append(f"Missing required path: {path}")
+                return False
+        return True
+
+    def _check_file_extensions(self) -> bool:
+        """Check all Python files have .py-tpl extension."""
+        for path in self.template_path.rglob("*"):
+            if path.is_file() and path.suffix == ".py":
+                self.errors.append(f"Found .py file instead of .py-tpl: {path}")
+                return False
+        return True
+
+    def _check_dependencies(self) -> bool:
+        """Check the dependencies in both setup.py-tpl and requirements.txt-tpl."""
+        req_path = self.template_path / "requirements.txt-tpl"
+        setup_path = self.template_path / "setup.py-tpl"
+
+        if not req_path.exists():
+            self.errors.append("requirements.txt-tpl not found")
+            return False
+        if not setup_path.exists():
+            self.errors.append("setup.py-tpl not found")
+            return False
+
+        with open(req_path) as f:
+            deps = f.read().splitlines()
+            package_names = [dep.split("==")[0] for dep in deps if dep]
+            if "fastapi" not in package_names:
+                self.errors.append(
+                    "FastAPI dependency not found in requirements.txt-tpl"
+                )
+                return False
+        return True
+
+    def _check_fastapi_implementation(self) -> bool:
+        """Check if the template has a proper FastAPI server implementation."""
+        core_modules = find_template_core_modules(self.temp_dir)
+
+        if not core_modules["main"]:
+            self.errors.append("main.py not found in template")
+            return False
+
+        with open(core_modules["main"]) as f:
+            content = f.read()
+            if "FastAPI" not in content or "app" not in content:
+                self.errors.append("FastAPI app creation not found in main.py")
+                return False
+        return True
+
+    def _test_template(self) -> bool:
+        """Run the tests in the converted template directory."""
+        test_dir = Path(self.temp_dir) / "tests"
+        if not test_dir.exists():
+            self.errors.append("Tests directory not found")
+            return False
+
+        try:
+            # Create virtual environment
+            venv_path = create_venv(self.temp_dir)
+
+            # Install dependencies
+            install_dependencies(self.temp_dir, venv_path)
+
+            # Run tests using the venv's pytest
+            if os.name == "nt":  # Windows
+                pytest_path = os.path.join(venv_path, "Scripts", "pytest")
+            else:  # Linux/Mac
+                pytest_path = os.path.join(venv_path, "bin", "pytest")
+
+            result = subprocess.run(
+                [pytest_path, str(test_dir)],
+                capture_output=True,
+                text=True,
+                cwd=self.temp_dir,
+            )
+
+            if result.returncode != 0:
+                self.errors.append(f"Tests failed: {result.stderr}")
+                return False
+
+        except Exception as e:
+            self.errors.append(f"Error running tests: {e}")
+            return False
+
+        return True
+
+
+def inspect_template(template_path: str) -> Dict[str, Any]:
+    """Run the template inspection and return the result."""
+    inspector = TemplateInspector(template_path)
+    is_valid = inspector.inspect_template()
+    result: dict[str, Any] = {
+        "valid": is_valid,
+        "errors": inspector.errors,
+        "warnings": inspector.warnings,
+    }
+
+    if result["valid"]:
+        print_success("Template inspection passed successfully! ✨")
+    elif result["errors"]:
+        error_messages = [str(error) for error in result["errors"]]
+        print_error(
+            "Template inspection failed with following errors:\n"
+            + "\n".join(f"- {error}" for error in error_messages)
+        )
+
+    if result["warnings"]:
+        warning_messages = [str(warning) for warning in result["warnings"]]
+        print_warning(
+            "Template has following warnings:\n"
+            + "\n".join(f"- {warning}" for warning in warning_messages)
+        )
+
+    return result
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python inspector.py <template_dir>")
+        sys.exit(1)
+
+    template_dir = sys.argv[1]
+    inspect_template(template_dir)

fastapi_fastkit/backend/main.py

@@ -0,0 +1,191 @@
+# --------------------------------------------------------------------------
+# The Module defines backend operations for FastAPI-fastkit CLI.
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+import os
+import subprocess
+
+from fastapi_fastkit import console
+from fastapi_fastkit.core.exceptions import BackendExceptions, TemplateExceptions
+from fastapi_fastkit.core.settings import settings
+from fastapi_fastkit.utils.main import print_error, print_info
+
+
+def find_template_core_modules(project_dir: str) -> dict[str, str]:
+    """
+    Find core module files in the template project structure.
+    Returns a dictionary with paths to main.py, setup.py, and config files.
+    """
+    core_modules = {"main": "", "setup": "", "config": ""}
+    template_config = settings.TEMPLATE_PATHS["config"]
+
+    # Find main.py
+    for path in settings.TEMPLATE_PATHS["main"]:
+        full_path = os.path.join(project_dir, path)
+        if os.path.exists(full_path):
+            core_modules["main"] = full_path
+            break
+
+    # Find setup.py
+    for path in settings.TEMPLATE_PATHS["setup"]:
+        full_path = os.path.join(project_dir, path)
+        if os.path.exists(full_path):
+            core_modules["setup"] = full_path
+            break
+
+    # Find config files (settings.py or config.py)
+    if isinstance(template_config, dict):
+        for config_file in template_config.get("files", []):
+            for base_path in template_config.get("paths", []):
+                full_path = os.path.join(project_dir, base_path, config_file)
+                if os.path.exists(full_path):
+                    core_modules["config"] = full_path
+                    break
+            if core_modules["config"]:
+                break
+
+    return core_modules
+
+
+def inject_project_metadata(
+    target_dir: str,
+    project_name: str,
+    author: str,
+    author_email: str,
+    description: str,
+) -> None:
+    """
+    Inject project metadata into template files after template conversion.
+    """
+    try:
+        core_modules = find_template_core_modules(target_dir)
+
+        # Inject metadata to main.py
+        if core_modules["main"]:
+            with open(core_modules["main"], "r+") as f:
+                content = f.read()
+                content = content.replace("app_title", f'"{project_name}"')
+                content = content.replace("app_description", f'"{description}"')
+                f.seek(0)
+                f.write(content)
+                f.truncate()
+
+        # Inject metadata to setup.py
+        if core_modules["setup"]:
+            with open(core_modules["setup"], "r+") as f:
+                content = f.read()
+                content = content.replace("<project_name>", project_name, 1)
+                content = content.replace("<description>", description, 1)
+                content = content.replace("<author>", author, 1)
+                content = content.replace("<author_email>", author_email, 1)
+                f.seek(0)
+                f.write(content)
+                f.truncate()
+
+        # Inject metadata to config files
+        if core_modules["config"]:
+            with open(core_modules["config"], "r+") as f:
+                content = f.read()
+                content = content.replace("<project_name>", project_name)
+                content = content.replace("<description>", description)
+                f.seek(0)
+                f.write(content)
+                f.truncate()
+
+    except Exception as e:
+        print_error(f"Error during metadata injection: {e}")
+        raise TemplateExceptions("Failed to inject metadata")
+
+
+def create_venv(project_dir: str) -> str:
+    """Create a virtual environment."""
+    try:
+        with console.status("[bold green]Setting up project environment..."):
+            console.print("[yellow]Creating virtual environment...[/yellow]")
+            venv_path = os.path.join(project_dir, ".venv")
+            subprocess.run(["python", "-m", "venv", venv_path], check=True)
+
+        if os.name == "nt":
+            activate_venv = f"    {os.path.join(venv_path, 'Scripts', 'activate.bat')}"
+        else:
+            activate_venv = f"    source {os.path.join(venv_path, 'bin', 'activate')}"
+
+        print_info(
+            "venv created at "
+            + venv_path
+            + "\nTo activate the virtual environment, run:\n\n"
+            + activate_venv,
+        )
+        return venv_path
+
+    except Exception as e:
+        print_error(f"Error during venv creation: {e}")
+        raise BackendExceptions("Failed to create venv")
+
+
+def install_dependencies(project_dir: str, venv_path: str) -> None:
+    """Install project dependencies in the virtual environment."""
+    try:
+        if os.name == "nt":  # Windows
+            pip_path = os.path.join(venv_path, "Scripts", "pip")
+        else:  # Linux/Mac
+            pip_path = os.path.join(venv_path, "bin", "pip")
+
+        with console.status("[bold green]Installing dependencies..."):
+            subprocess.run(
+                [pip_path, "install", "-r", "requirements.txt"],
+                cwd=project_dir,
+                check=True,
+            )
+        if os.name == "nt":
+            activate_venv = f"    {os.path.join(venv_path, 'Scripts', 'activate.bat')}"
+        else:
+            activate_venv = f"    source {os.path.join(venv_path, 'bin', 'activate')}"
+
+        print_info(
+            "Dependencies installed successfully."
+            + "\nTo activate the virtual environment, run:\n\n"
+            + activate_venv,
+        )
+
+    except Exception as e:
+        print_error(f"Error during dependency installation: {e}")
+        raise BackendExceptions("Failed to install dependencies")
+
+
+def read_template_stack(template_path: str) -> list[str]:
+    """
+    Read the install_requires from setup.py-tpl in the template directory.
+    Returns a list of required packages.
+
+    :param template_path: Path to the template directory
+    :return: List of required packages
+    """
+    setup_path = os.path.join(template_path, "setup.py-tpl")
+    if not os.path.exists(setup_path):
+        return []
+
+    try:
+        with open(setup_path, "r") as f:
+            content = f.read()
+            # Find the install_requires section using proper string matching
+            if "install_requires: list[str] = [" in content:
+                start_idx = content.find("install_requires: list[str] = [") + len(
+                    "install_requires: list[str] = ["
+                )
+                end_idx = content.find("]", start_idx)
+                if start_idx != -1 and end_idx != -1:
+                    deps_str = content[start_idx:end_idx]
+                    # Clean and parse the dependencies
+                    deps = [
+                        dep.strip().strip("'").strip('"')
+                        for dep in deps_str.split(",")
+                        if dep.strip() and not dep.isspace()
+                    ]
+                    return [dep for dep in deps if dep]  # Remove empty strings
+    except Exception as e:
+        print_error(f"Error reading template dependencies: {e}")
+        return []
+
+    return []

fastapi_fastkit/cli.py

@@ -6,7 +6,6 @@
 import os
 import shutil
 import subprocess
-from logging import getLogger
 from typing import Union
 
 import click
@@ -14,23 +13,26 @@ from click.core import BaseCommand, Context
 from rich import print
 from rich.panel import Panel
 
+from fastapi_fastkit.backend.main import (
+    create_venv,
+    find_template_core_modules,
+    inject_project_metadata,
+    install_dependencies,
+    read_template_stack,
+)
+from fastapi_fastkit.backend.transducer import copy_and_convert_template
 from fastapi_fastkit.core.exceptions import CLIExceptions
 from fastapi_fastkit.core.settings import FastkitConfig
-from fastapi_fastkit.utils.inspector import delete_project
 from fastapi_fastkit.utils.logging import setup_logging
-from fastapi_fastkit.utils.transducer import copy_and_convert_template
-
-from . import __version__, console
-from .backend import (
+from fastapi_fastkit.utils.main import (
     create_info_table,
-    inject_project_metadata,
     print_error,
     print_success,
     print_warning,
     validate_email,
 )
 
-logger = getLogger(__name__)
+from . import __version__, console
 
 
 @click.group()
@@ -92,11 +94,12 @@ def echo(ctx: Context) -> None:
 
 
 @fastkit_cli.command()
-def list_templates() -> None:
+@click.pass_context
+def list_templates(ctx: Context) -> None:
     """
     Display the list of available templates.
     """
-    settings = FastkitConfig()
+    settings = ctx.obj["settings"]
     template_dir = settings.FASTKIT_TEMPLATE_ROOT
 
     if not os.path.exists(template_dir):
@@ -199,7 +202,15 @@ def startup(
 
     console.print("\n")
     console.print(table)
-    # click.echo("Project Stack: [FastAPI, Uvicorn, SQLAlchemy, Docker (optional)]")  # TODO : impl this?
+
+    template_deps = read_template_stack(target_template)
+    if template_deps:
+        deps_table = create_info_table(
+            "Template Dependencies",
+            {f"Dependency {i+1}": dep for i, dep in enumerate(template_deps)},
+        )
+        console.print("\n")
+        console.print(deps_table)
 
     confirm = click.confirm(
         "\nDo you want to proceed with project creation?", default=False
@@ -216,10 +227,14 @@ def startup(
 
         copy_and_convert_template(target_template, user_local, project_name)
 
+        venv_path = create_venv(project_dir)
+
         inject_project_metadata(
             project_dir, project_name, author, author_email, description
         )
 
+        install_dependencies(project_dir, venv_path)
+
         print_success(
             f"FastAPI project '{project_name}' from '{template}' has been created and saved to {user_local}!"
         )
@@ -234,65 +249,55 @@ def startup(
     prompt="Enter project name",
     help="Name of the new FastAPI project",
 )
-@click.option(
-    "--stack",
-    type=click.Choice(["minimal", "standard", "full"]),
-    prompt="Select stack",
-    help="Project stack configuration",
-)
-def startproject(project_name: str, stack: str) -> None:
+@click.pass_context
+def startproject(ctx: Context, project_name: str) -> None:
     """
-    Start a new FastAPI project.
-    Dependencies will be automatically installed based on the selected stack.
+    Start a empty FastAPI project setup.
+    This command will automatically create a new FastAPI project directory and a python virtual environment.
+    Dependencies will be automatically installed based on the selected stack at venv.
 
     :param project_name: Project name
-    :param stack: Project stack configuration
     :return: None
     """
-    settings = FastkitConfig()
+    settings = ctx.obj["settings"]
     project_dir = os.path.join(settings.USER_WORKSPACE, project_name)
 
     if os.path.exists(project_dir):
         print_error(f"Error: Project '{project_name}' already exists.")
         return
 
+    console.print("\n[bold]Available Stacks and Dependencies:[/bold]")
+
+    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)},
+        )
+        console.print(table)
+        console.print("\n")
+
+    stack = click.prompt(
+        "Select stack",
+        type=click.Choice(list(settings.PROJECT_STACKS.keys())),
+        show_choices=True,
+    )
+
     try:
         os.makedirs(project_dir)
 
         table = create_info_table(
-            f"Creating Project: {project_name}", {"Component": "Status"}
+            f"Creating Project: {project_name}", {"Component": "Collected"}
         )
 
-        dependencies = {
-            "minimal": ["fastapi", "uvicorn"],
-            "standard": ["fastapi", "uvicorn", "sqlalchemy", "alembic", "pytest"],
-            "full": [
-                "fastapi",
-                "uvicorn",
-                "sqlalchemy",
-                "alembic",
-                "pytest",
-                "redis",
-                "celery",
-                "docker-compose",
-            ],
-        }
-
         with open(os.path.join(project_dir, "requirements.txt"), "w") as f:
-            for dep in dependencies[stack]:
+            for dep in settings.PROJECT_STACKS[stack]:
                 f.write(f"{dep}\n")
                 table.add_row(dep, "✓")
 
         console.print(table)
 
-        with console.status("[bold green]Setting up project environment..."):
-            console.print("[yellow]Creating virtual environment...[/yellow]")
-            subprocess.run(["python", "-m", "venv", os.path.join(project_dir, "venv")])
-
-            console.print("[yellow]Installing dependencies...[/yellow]")
-            subprocess.run(
-                ["pip", "install", "-r", "requirements.txt"], cwd=project_dir
-            )
+        venv_path = create_venv(project_dir)
+        install_dependencies(project_dir, venv_path)
 
         print_success(f"Project '{project_name}' has been created successfully!")
 
@@ -353,7 +358,7 @@ def deleteproject(ctx: Context, project_name: str) -> None:
         return
 
     try:
-        delete_project(project_dir)
+        shutil.rmtree(project_dir)
         print_success(f"Project '{project_name}' has been deleted successfully!")
 
     except Exception as e:
@@ -393,6 +398,7 @@ def runserver(
     reload: bool = True,
     workers: int = 1,
 ) -> None:
+    # TODO : check where main.py is located and run it
     """
     Run the FastAPI server for the current project.
     [1.1.0 update TODO] Alternative Point : using FastAPI-fastkit's 'fastapi dev' command
@@ -406,14 +412,20 @@ def runserver(
     settings = ctx.obj["settings"]
     project_dir = settings.USER_WORKSPACE
 
-    app_path = os.path.join(project_dir, "main.py")
-    if not os.path.exists(app_path):
+    core_modules = find_template_core_modules(project_dir)
+    if not core_modules["main"]:
         print_error(f"Could not find 'main.py' in '{project_dir}'.")
         return
 
+    main_path = core_modules["main"]
+    if "src/" in main_path:
+        app_module = "src.main:app"
+    else:
+        app_module = "main:app"
+
     command = [
         "uvicorn",
-        "main:app",
+        app_module,
         "--host",
         host,
         "--port",

fastapi_fastkit/core/settings.py

@@ -20,6 +20,41 @@ class FastkitConfig:
     DEBUG_MODE: bool = False
     LOGGING_LEVEL: str = "DEBUG"
 
+    # Template Metadata Options
+    TEMPLATE_PATHS: dict[str, list[str] | dict[str, list[str]]] = {
+        "main": [
+            "src/main.py",
+            "main.py",
+        ],
+        "setup": [
+            "setup.py",
+            "src/setup.py",
+        ],
+        "config": {
+            "files": ["settings.py", "config.py"],
+            "paths": [
+                "src/core",
+                "src",
+                "",
+            ],
+        },
+    }
+
+    # Startproject Options
+    PROJECT_STACKS: dict[str, list[str]] = {
+        "minimal": ["fastapi", "uvicorn"],
+        "standard": ["fastapi", "uvicorn", "sqlalchemy", "alembic", "pytest"],
+        "full": [
+            "fastapi",
+            "uvicorn",
+            "sqlalchemy",
+            "alembic",
+            "pytest",
+            "redis",
+            "celery",
+        ],
+    }
+
     # Testing Options
     TEST_SERVER_PORT: int = 8000
     TEST_DEFAULT_TERMINAL_WIDTH: int = 80
@@ -105,3 +140,6 @@ class FastkitConfig:
         log_dir = os.path.dirname(cls.LOG_FILE_PATH)
         if not os.path.exists(log_dir):
             os.makedirs(log_dir)
+
+
+settings = FastkitConfig()