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

fastapi_fastkit/backend/project_builder/dependency_collector.py

@@ -0,0 +1,210 @@
+# --------------------------------------------------------------------------
+# Dependency collection and management
+#
+# Collects dependencies from:
+# - Base template (if selected)
+# - Database choice
+# - Authentication method
+# - Additional features
+# - Custom packages
+#
+# Handles deduplication and version conflict detection.
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+from typing import Any, Dict, List, Set
+
+
+class DependencyCollector:
+    """
+    Collects and manages project dependencies.
+
+    This class is responsible for gathering all dependencies from
+    various sources and ensuring they are properly deduplicated.
+    """
+
+    def __init__(self, settings: Any) -> None:
+        """
+        Initialize dependency collector.
+
+        Args:
+            settings: FastkitConfig instance
+        """
+        self.settings = settings
+        self.dependencies: Set[str] = set()
+
+    def collect_from_config(self, config: Dict[str, Any]) -> List[str]:
+        """
+        Collect all dependencies from configuration.
+
+        Args:
+            config: Project configuration dictionary
+
+        Returns:
+            Sorted list of all dependencies
+        """
+        # Reset dependencies
+        self.dependencies = set()
+
+        # Add base dependencies
+        self.add_base_dependencies()
+
+        # Add database dependencies
+        db_info = config.get("database", {})
+        if isinstance(db_info, dict) and db_info.get("type") != "None":
+            self.add_database_dependencies(db_info.get("type", ""))
+
+        # Add authentication dependencies
+        auth_type = config.get("authentication", "None")
+        if auth_type != "None":
+            self.add_authentication_dependencies(auth_type)
+
+        # Add async tasks dependencies
+        tasks_type = config.get("async_tasks", "None")
+        if tasks_type != "None":
+            self.add_async_tasks_dependencies(tasks_type)
+
+        # Add caching dependencies
+        cache_type = config.get("caching", "None")
+        if cache_type != "None":
+            self.add_caching_dependencies(cache_type)
+
+        # Add monitoring dependencies
+        monitoring_type = config.get("monitoring", "None")
+        if monitoring_type != "None":
+            self.add_monitoring_dependencies(monitoring_type)
+
+        # Add testing dependencies
+        testing_type = config.get("testing", "None")
+        if testing_type != "None":
+            self.add_testing_dependencies(testing_type)
+
+        # Add utilities dependencies
+        utilities = config.get("utilities", [])
+        for util in utilities:
+            self.add_utility_dependencies(util)
+
+        # Add custom packages
+        custom = config.get("custom_packages", [])
+        if custom:
+            self.dependencies.update(custom)
+
+        return self.get_final_dependencies()
+
+    def add_base_dependencies(self) -> None:
+        """Add core FastAPI dependencies."""
+        self.dependencies.update(
+            [
+                "fastapi",
+                "uvicorn",
+                "pydantic",
+                "pydantic-settings",
+            ]
+        )
+
+    def add_database_dependencies(self, db_type: str) -> None:
+        """
+        Add database-specific dependencies.
+
+        Args:
+            db_type: Database type name
+        """
+        catalog = self.settings.PACKAGE_CATALOG.get("database", {})
+        packages = catalog.get(db_type, [])
+        self.dependencies.update(packages)
+
+    def add_authentication_dependencies(self, auth_type: str) -> None:
+        """
+        Add authentication dependencies.
+
+        Args:
+            auth_type: Authentication type name
+        """
+        catalog = self.settings.PACKAGE_CATALOG.get("authentication", {})
+        packages = catalog.get(auth_type, [])
+        self.dependencies.update(packages)
+
+    def add_async_tasks_dependencies(self, tasks_type: str) -> None:
+        """
+        Add async tasks dependencies.
+
+        Args:
+            tasks_type: Task queue type name
+        """
+        catalog = self.settings.PACKAGE_CATALOG.get("async_tasks", {})
+        packages = catalog.get(tasks_type, [])
+        self.dependencies.update(packages)
+
+    def add_caching_dependencies(self, cache_type: str) -> None:
+        """
+        Add caching dependencies.
+
+        Args:
+            cache_type: Caching type name
+        """
+        catalog = self.settings.PACKAGE_CATALOG.get("caching", {})
+        packages = catalog.get(cache_type, [])
+        self.dependencies.update(packages)
+
+    def add_monitoring_dependencies(self, monitoring_type: str) -> None:
+        """
+        Add monitoring dependencies.
+
+        Args:
+            monitoring_type: Monitoring type name
+        """
+        catalog = self.settings.PACKAGE_CATALOG.get("monitoring", {})
+        packages = catalog.get(monitoring_type, [])
+        self.dependencies.update(packages)
+
+    def add_testing_dependencies(self, testing_type: str) -> None:
+        """
+        Add testing dependencies.
+
+        Args:
+            testing_type: Testing framework type name
+        """
+        catalog = self.settings.PACKAGE_CATALOG.get("testing", {})
+        packages = catalog.get(testing_type, [])
+        self.dependencies.update(packages)
+
+    def add_utility_dependencies(self, utility: str) -> None:
+        """
+        Add utility dependencies.
+
+        Args:
+            utility: Utility name
+        """
+        catalog = self.settings.PACKAGE_CATALOG.get("utilities", {})
+        packages = catalog.get(utility, [])
+        self.dependencies.update(packages)
+
+    def add_feature_dependencies(self, features: List[str]) -> None:
+        """
+        Add dependencies for selected features.
+
+        Args:
+            features: List of feature names
+        """
+        for feature in features:
+            # This is a generic method that can be extended
+            # Currently handled by specific methods above
+            pass
+
+    def get_final_dependencies(self) -> List[str]:
+        """
+        Return deduplicated, sorted dependency list.
+
+        Returns:
+            Sorted list of all dependencies
+        """
+        return sorted(list(self.dependencies))
+
+    def get_dependency_count(self) -> int:
+        """
+        Get the total number of dependencies.
+
+        Returns:
+            Count of unique dependencies
+        """
+        return len(self.dependencies)

fastapi_fastkit/cli.py

@@ -1,4 +1,3 @@
-# TODO : add a feature to automatically fix appropriate fastkit output console size
 # --------------------------------------------------------------------------
 # The Module defines main and core CLI operations for FastAPI-fastkit.
 #
@@ -9,13 +8,15 @@ import os
 import shutil
 import subprocess
 import sys
-from typing import Union
+from typing import Union, cast
 
 import click
-from click.core import BaseCommand, Context
+from click import Command, Context
 from rich import print
 from rich.panel import Panel
 
+from fastapi_fastkit.backend.interactive import InteractiveConfigBuilder
+from fastapi_fastkit.backend.interactive.selectors import display_feature_catalog
 from fastapi_fastkit.backend.main import (
     add_new_route,
     ask_create_project_folder,
@@ -31,6 +32,7 @@ from fastapi_fastkit.backend.main import (
 from fastapi_fastkit.core.exceptions import CLIExceptions
 from fastapi_fastkit.core.settings import FastkitConfig
 from fastapi_fastkit.utils.logging import get_logger, setup_logging
+from fastapi_fastkit.utils.main import console as utils_console
 from fastapi_fastkit.utils.main import (
     create_info_table,
     is_fastkit_project,
@@ -41,14 +43,16 @@ from fastapi_fastkit.utils.main import (
     validate_email,
 )
 
-from . import __version__, console
+console = utils_console
+
+from . import __version__
 
 
 @click.group()
 @click.option("--debug/--no-debug", default=False)
 @click.version_option(__version__, prog_name="fastapi-fastkit")
 @click.pass_context
-def fastkit_cli(ctx: Context, debug: bool) -> Union["BaseCommand", None]:
+def fastkit_cli(ctx: Context, debug: bool) -> Union["Command", None]:
     """
     main FastAPI-fastkit CLI operation group
     """
@@ -97,6 +101,7 @@ def echo(ctx: Context) -> None:
     Deploy FastAPI app foundation instantly at your local!
 
     ---
+
     - Project Maintainer : [link=mailto:bbbong9@gmail.com]bnbong(JunHyeok Lee)[/link]
     - Current Version : {__version__}
     - Github : [link]https://github.com/bnbong/FastAPI-fastkit[/link]
@@ -135,8 +140,7 @@ def list_templates(ctx: Context) -> None:
         print_warning("No available templates.")
         return
 
-    table = create_info_table("Available Templates")
-
+    template_data = {}
     for template in templates:
         template_path = os.path.join(template_dir, template)
         readme_path = os.path.join(template_path, "README.md-tpl")
@@ -148,11 +152,26 @@ def list_templates(ctx: Context) -> None:
                 if first_line.startswith("# "):
                     description = first_line[2:]
 
-        table.add_row(template, description)
+        template_data[template] = description
 
+    table = create_info_table("Available Templates", template_data)
     console.print(table)
 
 
+@fastkit_cli.command()
+@click.pass_context
+def list_features(ctx: Context) -> None:
+    """
+    Display the list of available features and packages in the catalog.
+
+    Shows all available features that can be selected during interactive
+    project creation, along with their associated packages.
+    """
+    settings = ctx.obj["settings"]
+
+    display_feature_catalog(settings.PACKAGE_CATALOG, settings.FEATURE_DESCRIPTIONS)
+
+
 @fastkit_cli.command(context_settings={"ignore_unknown_options": True})
 @click.argument("template", default="fastapi-default")
 @click.option(
@@ -293,23 +312,26 @@ def startdemo(
 
 @fastkit_cli.command(context_settings={"ignore_unknown_options": True})
 @click.option(
-    "--project-name",
-    prompt="Enter the project name",
-    help="The name of the new FastAPI project.",
+    "--interactive",
+    is_flag=True,
+    default=False,
+    help="Enable interactive mode for guided project setup with feature selection.",
 )
 @click.option(
-    "--author", prompt="Enter the author name", help="The name of the project author."
+    "--project-name",
+    default=None,
+    help="The name of the new FastAPI project.",
 )
+@click.option("--author", default=None, help="The name of the project author.")
 @click.option(
     "--author-email",
-    prompt="Enter the author email",
+    default=None,
     help="The email of the project author.",
     type=str,
-    callback=validate_email,
 )
 @click.option(
     "--description",
-    prompt="Enter the project description",
+    default=None,
     help="The description of the new FastAPI project.",
 )
 @click.option(
@@ -321,6 +343,7 @@ def startdemo(
 @click.pass_context
 def init(
     ctx: Context,
+    interactive: bool,
     project_name: str,
     author: str,
     author_email: str,
@@ -328,15 +351,190 @@ def init(
     package_manager: str,
 ) -> None:
     """
-    Start a empty FastAPI project setup.
-
-    This command will automatically create a new FastAPI project directory and a python virtual environment.
+    Start a FastAPI project setup.
 
-    Dependencies will be automatically installed based on the selected stack at venv.
+    Use --interactive for guided setup with dynamic feature selection.
+    Without --interactive, creates an empty project with predefined stacks.
 
-    Project metadata will be injected to the project files.
+    This command will automatically create a new FastAPI project directory
+    and a python virtual environment. Dependencies will be automatically
+    installed based on the selected features or stack.
     """
     settings = ctx.obj["settings"]
+
+    # Interactive mode - use InteractiveConfigBuilder
+    if interactive:
+        print_info("Starting interactive project setup...")
+
+        builder = InteractiveConfigBuilder(settings)
+        config = builder.run_interactive_flow()
+
+        # User cancelled
+        if not config:
+            return
+
+        # Extract configuration
+        project_name = cast(str, config.get("project_name", ""))
+        author = cast(str, config.get("author", ""))
+        author_email = cast(str, config.get("author_email", ""))
+        description = cast(str, config.get("description", ""))
+        package_manager = config.get(
+            "package_manager", settings.DEFAULT_PACKAGE_MANAGER
+        )
+        all_dependencies = config.get("all_dependencies", [])
+
+        # Check if project already exists
+        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
+
+        # Ask user whether to create a new project folder
+        create_project_folder = ask_create_project_folder(project_name)
+
+        try:
+            user_local = settings.USER_WORKSPACE
+
+            # Use fastapi-empty template as base
+            template = "fastapi-empty"
+            template_dir = settings.FASTKIT_TEMPLATE_ROOT
+            target_template = os.path.join(template_dir, template)
+
+            if not os.path.exists(target_template):
+                print_error(
+                    f"Template '{template}' does not exist in '{template_dir}'."
+                )
+                raise CLIExceptions(
+                    f"Template '{template}' does not exist in '{template_dir}'."
+                )
+
+            # Deploy template
+            project_dir, _ = deploy_template_with_folder_option(
+                target_template, user_local, project_name, create_project_folder
+            )
+
+            # Inject project metadata
+            inject_project_metadata(
+                project_dir, project_name, author, author_email, description
+            )
+
+            # Generate dependency file with collected dependencies
+            generate_dependency_file_with_manager(
+                project_dir,
+                all_dependencies,
+                package_manager,
+                project_name,
+                author,
+                author_email,
+                description,
+            )
+
+            # Update setup.py install_requires with selected dependencies
+            from fastapi_fastkit.backend.main import update_setup_py_dependencies
+
+            update_setup_py_dependencies(project_dir, all_dependencies)
+
+            print_success(
+                f"Generated dependency file with {len(all_dependencies)} packages"
+            )
+
+            # Generate stack-specific code and configurations
+            from fastapi_fastkit.backend.project_builder.config_generator import (
+                DynamicConfigGenerator,
+            )
+
+            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)
+
+            # Generate database configuration if selected
+            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)
+
+            # 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)
+
+            # Generate test configuration if testing selected
+            testing_type = config.get("testing", "None")
+            if testing_type != "None":
+                test_config_content = generator.generate_test_config()
+                if test_config_content:
+                    test_config_path = os.path.join(project_dir, "tests", "conftest.py")
+                    os.makedirs(os.path.dirname(test_config_path), exist_ok=True)
+                    with open(test_config_path, "w") as f:
+                        f.write(test_config_content)
+
+            # Generate Docker files if deployment selected
+            deployment = config.get("deployment", [])
+            if deployment and deployment != ["None"]:
+                generator.generate_docker_files()
+                print_success(f"Generated Docker deployment files")
+
+            print_success(f"Generated configuration files for selected stack")
+
+            # Create virtual environment and install dependencies
+            venv_path = create_venv_with_manager(project_dir, package_manager)
+            install_dependencies_with_manager(project_dir, venv_path, package_manager)
+
+            success_message = get_deployment_success_message(
+                template, project_name, user_local, create_project_folder
+            )
+            print_success(success_message)
+
+            print_info(
+                "To start your project, run 'fastkit runserver' at newly created FastAPI project directory"
+            )
+
+        except Exception as e:
+            if settings.DEBUG_MODE:
+                logger = get_logger()
+                logger.exception(f"Error during project creation in init: {str(e)}")
+            print_error(f"Error during project creation: {str(e)}")
+            if os.path.exists(project_dir):
+                shutil.rmtree(project_dir, ignore_errors=True)
+
+        return
+
+    # Non-interactive mode (original behavior)
+    # Require parameters if not interactive
+    if not project_name:
+        project_name = click.prompt("Enter the project name", type=str)
+    if not author:
+        author = click.prompt("Enter the author name", type=str)
+    if not author_email:
+        while True:
+            author_email = click.prompt("Enter the author email", type=str)
+            # Simple validation
+            if "@" in author_email and "." in author_email:
+                break
+            print_error("Invalid email format. Please try again.")
+    if not description:
+        description = click.prompt("Enter the project description", type=str)
+
     project_dir = os.path.join(settings.USER_WORKSPACE, project_name)
 
     if os.path.exists(project_dir):

fastapi_fastkit/core/settings.py

@@ -94,6 +94,80 @@ class FastkitConfig:
         },
     }
 
+    # Package Catalog for Interactive Mode (v1.2.0+)
+    # Based on recommendations from: https://github.com/mjhea0/awesome-fastapi
+    PACKAGE_CATALOG: dict[str, dict[str, list[str]]] = {
+        "database": {
+            "PostgreSQL": ["psycopg2-binary", "asyncpg", "sqlalchemy", "alembic"],
+            "MySQL": ["pymysql", "aiomysql", "sqlalchemy", "alembic"],
+            "MongoDB": ["motor", "beanie"],
+            "Redis": ["redis[hiredis]", "aioredis"],
+            "SQLite": ["sqlalchemy", "alembic"],
+            "None": [],
+        },
+        "authentication": {
+            "JWT": ["python-jose[cryptography]", "passlib[bcrypt]"],
+            "OAuth2": ["authlib"],
+            "FastAPI-Users": [
+                "fastapi-users[sqlalchemy]",
+                "python-jose[cryptography]",
+                "passlib[bcrypt]",
+            ],
+            "Session-based": ["itsdangerous"],
+            "None": [],
+        },
+        "async_tasks": {
+            "Celery": ["celery[redis]", "redis"],
+            "Dramatiq": ["dramatiq[redis]", "redis"],
+            "None": [],
+        },
+        "testing": {
+            "Basic": ["pytest", "pytest-asyncio", "httpx"],
+            "Coverage": ["pytest", "pytest-asyncio", "pytest-cov", "httpx"],
+            "Advanced": [
+                "pytest",
+                "pytest-asyncio",
+                "pytest-cov",
+                "httpx",
+                "faker",
+                "factory-boy",
+            ],
+            "None": [],
+        },
+        "caching": {
+            "Redis": ["redis[hiredis]", "fastapi-cache2"],
+            "None": [],
+        },
+        "monitoring": {
+            "Loguru": ["loguru"],
+            "OpenTelemetry": [
+                "opentelemetry-api",
+                "opentelemetry-sdk",
+                "opentelemetry-instrumentation-fastapi",
+            ],
+            "Prometheus": ["prometheus-client", "prometheus-fastapi-instrumentator"],
+            "None": [],
+        },
+        "utilities": {
+            "CORS": [],  # Built-in to FastAPI
+            "Rate-Limiting": ["slowapi"],
+            "Pagination": ["fastapi-pagination"],
+            "WebSocket": [],  # Built-in to FastAPI
+            "None": [],
+        },
+    }
+
+    # Feature descriptions for display in interactive mode
+    FEATURE_DESCRIPTIONS: dict[str, str] = {
+        "database": "Database and ORM selection",
+        "authentication": "User authentication and authorization",
+        "async_tasks": "Background task processing",
+        "testing": "Testing framework and tools",
+        "caching": "Response and data caching",
+        "monitoring": "Application monitoring and logging",
+        "utilities": "Additional utilities and middleware",
+    }
+
     # Testing Options
     TEST_SERVER_PORT: int = 8000
     TEST_DEFAULT_TERMINAL_WIDTH: int = 80

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

@@ -7,7 +7,7 @@ authors = [
 ]
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.9"
+requires-python = ">=3.12"
 dependencies = [
     "fastapi>=0.115.8",
     "uvicorn[standard]>=0.34.0",
@@ -16,6 +16,7 @@ dependencies = [
     "SQLAlchemy>=2.0.38",
     "python-dotenv>=1.0.1",
     "aiofiles>=24.1.0",
+    "fastapi-fastkit>=1.1.5",
 ]
 
 [project.optional-dependencies]

fastapi_fastkit/fastapi_project_template/fastapi-async-crud/requirements.txt-tpl

@@ -34,3 +34,4 @@ uvloop==0.21.0
 watchfiles==1.0.4
 websockets==15.0
 aiofiles>=24.1.0
+FastAPI-fastkit==1.1.5

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

@@ -7,7 +7,7 @@ authors = [
 ]
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.9"
+requires-python = ">=3.12"
 dependencies = [
     "fastapi>=0.115.8",
     "uvicorn[standard]>=0.34.0",
@@ -16,6 +16,7 @@ dependencies = [
     "SQLAlchemy>=2.0.38",
     "python-dotenv>=1.0.1",
     "aiofiles>=24.1.0",
+    "fastapi-fastkit>=1.1.5",
 ]
 
 [project.optional-dependencies]

fastapi_fastkit/fastapi_project_template/fastapi-custom-response/requirements.txt-tpl

@@ -34,3 +34,4 @@ uvicorn==0.34.0
 uvloop==0.21.0
 watchfiles==1.0.4
 websockets==15.0
+FastAPI-fastkit==1.1.5

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

@@ -7,7 +7,7 @@ authors = [
 ]
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.9"
+requires-python = ">=3.12"
 dependencies = [
     "fastapi>=0.115.8",
     "uvicorn[standard]>=0.34.0",
@@ -15,6 +15,7 @@ dependencies = [
     "pydantic-settings>=2.7.1",
     "SQLAlchemy>=2.0.38",
     "python-dotenv>=1.0.1",
+    "fastapi-fastkit>=1.1.5",
 ]
 
 [project.optional-dependencies]

fastapi_fastkit/fastapi_project_template/fastapi-default/requirements.txt-tpl

@@ -32,3 +32,4 @@ uvicorn==0.34.0
 uvloop==0.21.0
 watchfiles==1.0.4
 websockets==15.0
+FastAPI-fastkit==1.1.5