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

fastapi_fastkit/backend/interactive/selectors.py

@@ -0,0 +1,241 @@
+# --------------------------------------------------------------------------
+# Selection logic and UI rendering for interactive mode
+#
+# Provides:
+# - Table-based option displays using rich
+# - Multi-select prompts
+# - Confirmation dialogs
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+from typing import Any, Dict, List, Optional
+
+from rich.panel import Panel
+from rich.table import Table
+
+from fastapi_fastkit.utils.main import console
+
+
+def render_selection_table(
+    title: str, options: Dict[str, str], show_numbers: bool = True
+) -> None:
+    """
+    Render a selection table using rich.
+
+    Args:
+        title: Table title
+        options: Dictionary of option_key: description
+        show_numbers: Whether to show numbered options (for single-select)
+    """
+    table = Table(title=title, show_header=True, header_style="bold magenta")
+
+    if show_numbers:
+        table.add_column("Option", style="cyan", no_wrap=True)
+    table.add_column("Name", style="green")
+    table.add_column("Description", style="yellow")
+
+    for i, (key, description) in enumerate(options.items(), 1):
+        if show_numbers:
+            table.add_row(str(i), key, description)
+        else:
+            table.add_row(key, description)
+
+    console.print(table)
+
+
+def render_feature_options(
+    category: str, options: List[str], descriptions: Dict[str, str]
+) -> None:
+    """
+    Render feature options for multi-select.
+
+    Args:
+        category: Feature category name
+        options: List of option names
+        descriptions: Dictionary of option descriptions
+    """
+    console.print(f"\n[bold cyan]{category}[/bold cyan]")
+    console.print(
+        "[dim]Select options by entering numbers (comma-separated, e.g., 1,3,4)[/dim]\n"
+    )
+
+    for i, option in enumerate(options, 1):
+        desc = descriptions.get(option, "")
+        console.print(f"  [cyan]{i}[/cyan]. {option} [dim]{desc}[/dim]")
+
+
+def multi_select_prompt(
+    title: str, options: List[str], descriptions: Optional[Dict[str, str]] = None
+) -> List[int]:
+    """
+    Multi-select prompt with comma-separated input.
+
+    Args:
+        title: Prompt title
+        options: List of options
+        descriptions: Optional descriptions for each option
+
+    Returns:
+        List of selected indices (0-based)
+    """
+    descriptions = descriptions or {}
+
+    console.print(f"\n[bold]{title}[/bold]")
+    render_feature_options(title, options, descriptions)
+
+    while True:
+        selected = console.input(
+            "\n[cyan]Your choice (or press Enter to skip):[/cyan] "
+        ).strip()
+
+        if not selected:
+            return []
+
+        try:
+            # Parse comma-separated numbers
+            indices = [int(x.strip()) for x in selected.split(",") if x.strip()]
+
+            # Validate indices
+            if all(1 <= idx <= len(options) for idx in indices):
+                # Convert to 0-based indices
+                return [idx - 1 for idx in indices]
+            else:
+                console.print(
+                    f"[red]Invalid selection. Please enter numbers between 1 and {len(options)}[/red]"
+                )
+        except ValueError:
+            console.print(
+                "[red]Invalid input. Please enter comma-separated numbers (e.g., 1,3,4)[/red]"
+            )
+
+
+def confirm_selections(config: Dict[str, Any]) -> bool:
+    """
+    Display summary and confirm all selections.
+
+    Args:
+        config: Complete project configuration
+
+    Returns:
+        True if user confirms, False otherwise
+    """
+    table = Table(
+        title="📋 Project Configuration Summary",
+        show_header=True,
+        header_style="bold magenta",
+    )
+    table.add_column("Setting", style="cyan", no_wrap=True)
+    table.add_column("Value", style="green")
+
+    # Basic information
+    table.add_row("Project Name", config.get("project_name", "N/A"))
+    table.add_row("Author", config.get("author", "N/A"))
+    table.add_row("Email", config.get("author_email", "N/A"))
+    table.add_row("Description", config.get("description", "N/A"))
+
+    # Template
+    if config.get("base_template"):
+        table.add_row("Base Template", config["base_template"])
+
+    # Database
+    db_info = config.get("database", {})
+    if db_info.get("type") != "None":
+        table.add_row("Database", db_info.get("type", "None"))
+
+    # Authentication
+    auth_type = config.get("authentication", "None")
+    if auth_type != "None":
+        table.add_row("Authentication", auth_type)
+
+    # Async tasks
+    task_type = config.get("async_tasks", "None")
+    if task_type != "None":
+        table.add_row("Async Tasks", task_type)
+
+    # Caching
+    cache_type = config.get("caching", "None")
+    if cache_type != "None":
+        table.add_row("Caching", cache_type)
+
+    # Monitoring
+    monitoring_type = config.get("monitoring", "None")
+    if monitoring_type != "None":
+        table.add_row("Monitoring", monitoring_type)
+
+    # Testing
+    testing_type = config.get("testing", "None")
+    if testing_type != "None":
+        table.add_row("Testing", testing_type)
+
+    # Utilities
+    utilities = config.get("utilities", [])
+    if utilities:
+        table.add_row("Utilities", ", ".join(utilities))
+
+    # Custom packages
+    custom = config.get("custom_packages", [])
+    if custom:
+        table.add_row("Custom Packages", ", ".join(custom))
+
+    # Package manager
+    table.add_row("Package Manager", config.get("package_manager", "uv"))
+
+    console.print("\n")
+    console.print(table)
+    console.print("\n")
+
+    # Show total dependencies count
+    total_deps = len(config.get("all_dependencies", []))
+    console.print(f"[bold cyan]Total dependencies to install:[/bold cyan] {total_deps}")
+
+    # Ask for confirmation
+    response = (
+        console.input(
+            "\n[bold yellow]Proceed with project creation? [Y/n]:[/bold yellow] "
+        )
+        .strip()
+        .lower()
+    )
+
+    return response in ["y", "yes", ""]
+
+
+def display_feature_catalog(
+    catalog: Dict[str, Dict[str, List[str]]], descriptions: Dict[str, str]
+) -> None:
+    """
+    Display the complete feature catalog.
+
+    Args:
+        catalog: Package catalog from settings
+        descriptions: Feature descriptions from settings
+    """
+    panel = Panel(
+        "[bold cyan]FastAPI-fastkit Feature Catalog[/bold cyan]\n\n"
+        "Available features and their associated packages for interactive project creation.",
+        title="📚 Feature Catalog",
+        border_style="cyan",
+    )
+    console.print(panel)
+
+    for category, options in catalog.items():
+        if category == "utilities":
+            continue  # Skip utilities as they may have empty package lists
+
+        desc = descriptions.get(category, category.title())
+        table = Table(title=f"{desc}", show_header=True, header_style="bold yellow")
+        table.add_column("Option", style="cyan", no_wrap=True)
+        table.add_column("Packages", style="green")
+
+        for option_name, packages in options.items():
+            if option_name == "None":
+                continue
+            pkg_list = (
+                ", ".join(packages)
+                if packages
+                else "[dim](No additional packages)[/dim]"
+            )
+            table.add_row(option_name, pkg_list)
+
+        console.print("\n")
+        console.print(table)

fastapi_fastkit/backend/interactive/validators.py

@@ -0,0 +1,163 @@
+# --------------------------------------------------------------------------
+# Input validation utilities for interactive mode
+#
+# Provides validation functions for:
+# - Package names
+# - Project names
+# - Feature compatibility checking
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+from fastapi_fastkit.utils.main import REGEX as EMAIL_REGEX
+
+
+def validate_package_name(package: str) -> bool:
+    """
+    Validate package name format.
+
+    Checks if the package name follows basic PyPI package naming conventions.
+    Does not validate existence on PyPI (that will be added in v1.2.1+).
+
+    Args:
+        package: Package name to validate
+
+    Returns:
+        True if format is valid, False otherwise
+    """
+    if not package or not isinstance(package, str):
+        return False
+
+    # Remove version specifiers and extras for validation
+    package_name = re.split(r"[<>=!\[]", package)[0].strip()
+
+    # Basic package name pattern: letters, numbers, hyphens, underscores, dots
+    # Must start with letter or number
+    pattern = r"^[a-zA-Z0-9][a-zA-Z0-9._-]*$"
+
+    return bool(re.match(pattern, package_name))
+
+
+def validate_project_name(name: str) -> Tuple[bool, Optional[str]]:
+    """
+    Validate project name.
+
+    Args:
+        name: Project name to validate
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    if not name:
+        return False, "Project name cannot be empty"
+
+    if not name.replace("_", "").replace("-", "").isalnum():
+        return (
+            False,
+            "Project name must contain only letters, numbers, hyphens, and underscores",
+        )
+
+    if name[0].isdigit():
+        return False, "Project name cannot start with a number"
+
+    # Check for Python keywords
+    import keyword
+
+    if keyword.iskeyword(name):
+        return False, f"Project name '{name}' is a Python keyword"
+
+    return True, None
+
+
+def validate_email_format(email: str) -> bool:
+    """
+    Validate email address format using utils/main.py REGEX pattern.
+
+    Args:
+        email: Email address to validate
+
+    Returns:
+        True if format is valid, False otherwise
+    """
+    if not email:
+        return False
+
+    return bool(re.match(EMAIL_REGEX, email))
+
+
+def validate_feature_compatibility(
+    config: Dict[str, Any],
+) -> Tuple[bool, Optional[str]]:
+    """
+    Check compatibility between selected features.
+
+    Validates that selected features don't have conflicting requirements.
+
+    Args:
+        config: Project configuration dictionary
+
+    Returns:
+        Tuple of (is_compatible, warning_message)
+    """
+    warnings = []
+
+    # Check if FastAPI-Users is selected with database
+    if config.get("authentication") == "FastAPI-Users":
+        db_type = config.get("database", {}).get("type", "None")
+        if db_type == "None":
+            warnings.append(
+                "FastAPI-Users requires a database. Consider selecting PostgreSQL or MySQL."
+            )
+
+    # Check if Celery is selected with Redis
+    if config.get("async_tasks") == "Celery" or config.get("async_tasks") == "Dramatiq":
+        # These already include Redis in their dependencies
+        pass
+
+    # Check if caching Redis is selected along with task queue Redis
+    cache_type = config.get("caching", "None")
+    task_type = config.get("async_tasks", "None")
+    if cache_type == "Redis" and task_type in ["Celery", "Dramatiq"]:
+        # This is actually compatible, just a note
+        warnings.append(
+            "Info: Redis will be used for both caching and task queue (shared dependency)."
+        )
+
+    # If there are warnings, return them
+    if warnings:
+        return True, " | ".join(warnings)
+
+    return True, None
+
+
+def sanitize_custom_packages(packages: List[str]) -> List[str]:
+    """
+    Clean and deduplicate custom package list.
+
+    Args:
+        packages: List of package names (possibly with duplicates or empty strings)
+
+    Returns:
+        Cleaned list of unique package names
+    """
+    if not packages:
+        return []
+
+    # Remove empty strings and strip whitespace
+    cleaned = [pkg.strip() for pkg in packages if pkg and pkg.strip()]
+
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_packages = []
+    for pkg in cleaned:
+        pkg_lower = pkg.lower()
+        if pkg_lower not in seen:
+            seen.add(pkg_lower)
+            unique_packages.append(pkg)
+
+    # Validate each package name
+    valid_packages = [pkg for pkg in unique_packages if validate_package_name(pkg)]
+
+    return valid_packages

fastapi_fastkit/backend/main.py

@@ -308,6 +308,67 @@ def _process_pyproject_file(
         raise BackendExceptions(f"Failed to process pyproject.toml: {e}")
 
 
+def update_setup_py_dependencies(project_dir: str, dependencies: List[str]) -> None:
+    """
+    Update setup.py file's install_requires list with new dependencies.
+
+    This function finds and updates the install_requires list in setup.py
+    to match the dependencies selected during interactive mode.
+
+    :param project_dir: Path to the project directory
+    :param dependencies: List of dependency specifications
+    """
+    setup_py_path = os.path.join(project_dir, "setup.py")
+
+    if not os.path.exists(setup_py_path):
+        debug_log("setup.py not found, skipping dependency update", "info")
+        return
+
+    try:
+        with open(setup_py_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Build the new install_requires list
+        deps_str = ",\n    ".join(f'"{dep}"' for dep in dependencies)
+
+        # Try to replace existing install_requires first (with type annotation)
+        pattern = r"install_requires:\s*list\[str\]\s*=\s*\[(.*?)\]"
+        if re.search(pattern, content, re.DOTALL):
+            content = re.sub(
+                pattern,
+                f"install_requires: list[str] = [\n    {deps_str},\n]",
+                content,
+                flags=re.DOTALL,
+            )
+            debug_log(
+                "Updated install_requires with type annotation in setup.py", "info"
+            )
+        else:
+            # Fallback: try without type annotation
+            pattern_old = r"install_requires\s*=\s*\[(.*?)\]"
+            if re.search(pattern_old, content, re.DOTALL):
+                content = re.sub(
+                    pattern_old,
+                    f"install_requires = [\n    {deps_str},\n]",
+                    content,
+                    flags=re.DOTALL,
+                )
+                debug_log("Updated install_requires in setup.py", "info")
+            else:
+                debug_log("Could not find install_requires in setup.py", "warning")
+                return
+
+        # Write updated content
+        with open(setup_py_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        print_info(f"Updated setup.py with {len(dependencies)} dependencies")
+
+    except (OSError, UnicodeDecodeError) as e:
+        debug_log(f"Error updating setup.py dependencies: {e}", "error")
+        print_warning(f"Could not update setup.py: {e}")
+
+
 def create_venv_with_manager(project_dir: str, manager_type: str = "pip") -> str:
     """
     Create a virtual environment using the specified package manager.
@@ -405,6 +466,22 @@ def generate_dependency_file_with_manager(
         package_manager.generate_dependency_file(
             dependencies, project_name, author, author_email, description
         )
+
+        # Also generate requirements.txt for pip compatibility (if not using pip)
+        if manager_type != "pip":
+            from pathlib import Path
+
+            requirements_path = Path(project_dir) / "requirements.txt"
+            try:
+                with open(requirements_path, "w", encoding="utf-8") as f:
+                    for dep in dependencies:
+                        f.write(f"{dep}\n")
+                debug_log("Generated requirements.txt for pip compatibility", "info")
+            except (OSError, UnicodeEncodeError) as e:
+                debug_log(
+                    f"Warning: Could not generate requirements.txt: {e}", "warning"
+                )
+
     except Exception as e:
         debug_log(f"Error generating dependency file with {manager_type}: {e}", "error")
         raise BackendExceptions(f"Failed to generate dependency file: {str(e)}")

fastapi_fastkit/backend/package_managers/pdm_manager.py

@@ -8,10 +8,14 @@ import subprocess
 import sys
 from typing import List
 
-from fastapi_fastkit import console
 from fastapi_fastkit.core.exceptions import BackendExceptions
 from fastapi_fastkit.utils.logging import debug_log, get_logger
-from fastapi_fastkit.utils.main import handle_exception, print_error, print_success
+from fastapi_fastkit.utils.main import (
+    console,
+    handle_exception,
+    print_error,
+    print_success,
+)
 
 from .base import BasePackageManager
 

fastapi_fastkit/backend/package_managers/pip_manager.py

@@ -8,10 +8,14 @@ import subprocess
 import sys
 from typing import List
 
-from fastapi_fastkit import console
 from fastapi_fastkit.core.exceptions import BackendExceptions
 from fastapi_fastkit.utils.logging import debug_log, get_logger
-from fastapi_fastkit.utils.main import handle_exception, print_error, print_success
+from fastapi_fastkit.utils.main import (
+    console,
+    handle_exception,
+    print_error,
+    print_success,
+)
 
 from .base import BasePackageManager
 

fastapi_fastkit/backend/package_managers/poetry_manager.py

@@ -6,10 +6,14 @@
 import subprocess
 from typing import List
 
-from fastapi_fastkit import console
 from fastapi_fastkit.core.exceptions import BackendExceptions
 from fastapi_fastkit.utils.logging import debug_log, get_logger
-from fastapi_fastkit.utils.main import handle_exception, print_error, print_success
+from fastapi_fastkit.utils.main import (
+    console,
+    handle_exception,
+    print_error,
+    print_success,
+)
 
 from .base import BasePackageManager
 

fastapi_fastkit/backend/package_managers/uv_manager.py

@@ -7,10 +7,14 @@ import os
 import subprocess
 from typing import List
 
-from fastapi_fastkit import console
 from fastapi_fastkit.core.exceptions import BackendExceptions
 from fastapi_fastkit.utils.logging import debug_log, get_logger
-from fastapi_fastkit.utils.main import handle_exception, print_error, print_success
+from fastapi_fastkit.utils.main import (
+    console,
+    handle_exception,
+    print_error,
+    print_success,
+)
 
 from .base import BasePackageManager
 

fastapi_fastkit/backend/project_builder/__init__.py

@@ -0,0 +1,17 @@
+# --------------------------------------------------------------------------
+# Project Builder module for FastAPI-fastkit
+#
+# Provides project building functionality including:
+# - Dependency collection and management
+# - Dynamic configuration file generation
+# - Template merging
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+from .config_generator import DynamicConfigGenerator
+from .dependency_collector import DependencyCollector
+
+__all__ = [
+    "DependencyCollector",
+    "DynamicConfigGenerator",
+]