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

fastapi_fastkit/__init__.py

@@ -1 +1 @@
-__version__ = 'v1.1.4'
+__version__ = 'v1.2.0'

fastapi_fastkit/backend/inspector.py

@@ -26,13 +26,12 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
-import yaml  # type: ignore
+import yaml
 
 from fastapi_fastkit.backend.main import (
     create_venv,
     find_template_core_modules,
     inject_project_metadata,
-    install_dependencies,
     install_dependencies_with_manager,
 )
 from fastapi_fastkit.backend.transducer import copy_and_convert_template
@@ -50,17 +49,38 @@ class TemplateInspector:
     Uses context manager protocol for proper resource cleanup.
     """
 
-    def __init__(self, template_path: str):
+    def __init__(self, template_path: str, temp_base_dir: Optional[str] = None):
         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")
+        template_name = Path(template_path).name
+
+        # use temp_base_dir or fall back to backend directory (temp)
+        if temp_base_dir:
+            self.temp_dir = os.path.join(temp_base_dir, f"temp_{template_name}")
+        else:
+            self.temp_dir = os.path.join(
+                os.path.dirname(__file__), f"temp_{template_name}"
+            )
+
         self._cleanup_needed = False
         self.template_config: Optional[Dict[str, Any]] = None
 
     def __enter__(self) -> "TemplateInspector":
         """Enter context manager - create temp directory and copy template."""
         try:
+            # Clean up any existing temp directory for this template
+            if os.path.exists(self.temp_dir):
+                debug_log(
+                    f"Cleaning up existing temp directory: {self.temp_dir}", "info"
+                )
+                try:
+                    shutil.rmtree(self.temp_dir)
+                except OSError as e:
+                    debug_log(
+                        f"Failed to cleanup existing temp directory: {e}", "warning"
+                    )
+
             os.makedirs(self.temp_dir, exist_ok=True)
             copy_and_convert_template(str(self.template_path), self.temp_dir)
 
@@ -81,18 +101,142 @@ class TemplateInspector:
         self._cleanup()
 
     def _cleanup(self) -> None:
-        """Cleanup temp directory if it exists and cleanup is needed."""
+        """Cleanup temp directory."""
         if self._cleanup_needed and os.path.exists(self.temp_dir):
+            temp_dir_path = self.temp_dir
             try:
-                shutil.rmtree(self.temp_dir)
-                debug_log(f"Cleaned up temp directory {self.temp_dir}", "debug")
-            except OSError as e:
+                self._cleanup_docker_services()
+
+                import time
+
+                time.sleep(3)
+
+                self._force_cleanup_directory(temp_dir_path)
+
+            except Exception as e:
                 debug_log(
-                    f"Failed to cleanup temp directory {self.temp_dir}: {e}", "warning"
+                    f"Warning: Unexpected error during cleanup of {temp_dir_path}: {e}",
+                    "warning",
                 )
+                try:
+                    self._force_cleanup_directory(temp_dir_path)
+                except Exception:
+                    pass
             finally:
                 self._cleanup_needed = False
 
+    def _force_cleanup_directory(self, directory_path: str) -> None:
+        """Force cleanup of directory with multiple strategies."""
+        import stat
+        import time
+
+        max_retries = 5
+        for attempt in range(max_retries):
+            try:
+                shutil.rmtree(directory_path)
+                debug_log(
+                    f"Successfully cleaned up temp directory: {directory_path}", "info"
+                )
+                return
+            except (OSError, PermissionError) as e:
+                if attempt < max_retries - 1:
+                    debug_log(
+                        f"Attempt {attempt + 1} failed to cleanup {directory_path}: {e}",
+                        "warning",
+                    )
+
+                    try:
+                        self._fix_directory_permissions(directory_path)
+                        shutil.rmtree(directory_path)
+                        debug_log(
+                            f"Successfully cleaned up temp directory after permission fix: {directory_path}",
+                            "info",
+                        )
+                        return
+                    except Exception:
+                        pass
+
+                    try:
+                        self._remove_directory_contents(directory_path)
+                        os.rmdir(directory_path)
+                        debug_log(
+                            f"Successfully cleaned up temp directory by removing contents: {directory_path}",
+                            "info",
+                        )
+                        return
+                    except Exception:
+                        pass
+
+                    time.sleep(2)
+                else:
+                    debug_log(
+                        f"Failed to cleanup temp directory after {max_retries} attempts: {directory_path}",
+                        "warning",
+                    )
+                    try:
+                        import subprocess
+
+                        if os.name == "nt":  # Windows
+                            subprocess.run(
+                                ["rmdir", "/s", "/q", directory_path],
+                                check=False,
+                                shell=True,
+                            )
+                        else:  # Unix-like
+                            subprocess.run(["rm", "-rf", directory_path], check=False)
+                        debug_log(
+                            f"Force cleanup completed for: {directory_path}", "info"
+                        )
+                    except Exception:
+                        debug_log(
+                            f"All cleanup attempts failed for: {directory_path}",
+                            "warning",
+                        )
+
+    def _fix_directory_permissions(self, directory_path: str) -> None:
+        """Fix directory permissions to allow removal."""
+        import os
+        import stat
+
+        def fix_permissions(path: str) -> None:
+            try:
+                os.chmod(path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+            except Exception:
+                pass
+
+        # Fix permissions for directory and all contents
+        fix_permissions(directory_path)
+        for root, dirs, files in os.walk(directory_path):
+            fix_permissions(root)
+            for d in dirs:
+                fix_permissions(os.path.join(root, d))
+            for f in files:
+                fix_permissions(os.path.join(root, f))
+
+    def _remove_directory_contents(self, directory_path: str) -> None:
+        """Remove directory contents file by file."""
+        import os
+        import stat
+
+        for root, dirs, files in os.walk(directory_path, topdown=False):
+            # Remove files first
+            for file in files:
+                file_path = os.path.join(root, file)
+                try:
+                    os.chmod(file_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+                    os.remove(file_path)
+                except Exception:
+                    pass
+
+            # Remove directories
+            for dir_name in dirs:
+                dir_path = os.path.join(root, dir_name)
+                try:
+                    os.chmod(dir_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+                    os.rmdir(dir_path)
+                except Exception:
+                    pass
+
     def _load_template_config(self) -> Optional[Dict[str, Any]]:
         """Load template configuration from template-config.yml if available."""
         config_file = os.path.join(self.temp_dir, "template-config.yml")
@@ -1036,12 +1180,23 @@ class TemplateInspector:
         try:
             debug_log("Cleaning up Docker services", "info")
             subprocess.run(
-                ["docker-compose", "down", "-v"],
+                ["docker-compose", "down", "-v", "--remove-orphans"],
                 cwd=self.temp_dir,
                 capture_output=True,
                 text=True,
                 timeout=60,
             )
+
+            try:
+                subprocess.run(
+                    ["docker", "system", "prune", "-f"],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                )
+            except Exception:
+                pass
+
         except Exception as e:
             debug_log(f"Failed to cleanup Docker services: {e}", "warning")
 
@@ -1086,11 +1241,14 @@ class TemplateInspector:
         }
 
 
-def inspect_fastapi_template(template_path: str) -> Dict[str, Any]:
+def inspect_fastapi_template(
+    template_path: str, temp_base_dir: Optional[str] = None
+) -> Dict[str, Any]:
     """
     Convenience function to inspect a FastAPI template.
 
     :param template_path: Path to the template to inspect
+    :param temp_base_dir: Base directory for temporary files (defaults to backend directory)
     :return: Inspection report dictionary
     """
     template_name = Path(template_path).name
@@ -1098,7 +1256,7 @@ def inspect_fastapi_template(template_path: str) -> Dict[str, Any]:
         f"Starting template inspection for {template_name} at {template_path}", "info"
     )
 
-    with TemplateInspector(template_path) as inspector:
+    with TemplateInspector(template_path, temp_base_dir) as inspector:
         is_valid = inspector.inspect_template()
         report = inspector.get_report()
 

fastapi_fastkit/backend/interactive/__init__.py

@@ -0,0 +1,51 @@
+# --------------------------------------------------------------------------
+# Interactive module for FastAPI-fastkit
+#
+# Provides interactive prompts and configuration building for dynamic
+# project creation.
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+from .config_builder import InteractiveConfigBuilder
+from .prompts import (
+    prompt_additional_features,
+    prompt_authentication_selection,
+    prompt_basic_info,
+    prompt_caching_selection,
+    prompt_custom_packages,
+    prompt_database_selection,
+    prompt_deployment_options,
+    prompt_monitoring_selection,
+    prompt_package_manager_selection,
+    prompt_template_selection,
+    prompt_testing_selection,
+    prompt_utilities_selection,
+)
+from .selectors import confirm_selections, multi_select_prompt, render_selection_table
+from .validators import (
+    sanitize_custom_packages,
+    validate_feature_compatibility,
+    validate_package_name,
+)
+
+__all__ = [
+    "InteractiveConfigBuilder",
+    "prompt_basic_info",
+    "prompt_template_selection",
+    "prompt_database_selection",
+    "prompt_authentication_selection",
+    "prompt_additional_features",
+    "prompt_testing_selection",
+    "prompt_deployment_options",
+    "prompt_custom_packages",
+    "prompt_caching_selection",
+    "prompt_monitoring_selection",
+    "prompt_utilities_selection",
+    "prompt_package_manager_selection",
+    "render_selection_table",
+    "multi_select_prompt",
+    "confirm_selections",
+    "validate_package_name",
+    "validate_feature_compatibility",
+    "sanitize_custom_packages",
+]

fastapi_fastkit/backend/interactive/config_builder.py

@@ -0,0 +1,186 @@
+# --------------------------------------------------------------------------
+# Build comprehensive project configuration from user selections
+#
+# Aggregates all user choices into a structured configuration dict
+# that can be consumed by the project builder.
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+from typing import Any, Dict, List
+
+from fastapi_fastkit.utils.main import console, print_warning
+
+from .prompts import (
+    prompt_additional_features,
+    prompt_basic_info,
+    prompt_template_selection,
+)
+from .selectors import confirm_selections
+from .validators import sanitize_custom_packages, validate_feature_compatibility
+
+
+class InteractiveConfigBuilder:
+    """
+    Builds project configuration from interactive prompts.
+
+    Orchestrates the entire interactive flow and aggregates all
+    user selections into a cohesive configuration dictionary.
+    """
+
+    def __init__(self, settings: Any) -> None:
+        """
+        Initialize the config builder.
+
+        Args:
+            settings: FastkitConfig instance
+        """
+        self.settings = settings
+        self.config: Dict[str, Any] = {}
+
+    def run_interactive_flow(self) -> Dict[str, Any]:
+        """
+        Execute full interactive flow and return config.
+
+        Returns:
+            Complete project configuration dictionary
+        """
+        console.print(
+            "\n[bold magenta]⚡ FastAPI-fastkit Interactive Project Setup ⚡[/bold magenta]\n"
+        )
+
+        # Step 1: Basic information
+        self._collect_basic_info()
+
+        # Step 2: Always use Empty template as base for interactive mode
+        # (Feature selection will build the project incrementally)
+        self.config["base_template"] = None  # None = Empty project
+
+        # Step 3: Feature selections
+        self._collect_feature_selections()
+
+        # Step 4: Build final configuration
+        final_config = self._build_final_config()
+
+        # Step 5: Validate compatibility
+        is_valid, warning = validate_feature_compatibility(final_config)
+        if warning:
+            print_warning(warning, title="Feature Compatibility")
+
+        # Step 6: Confirm selections
+        if confirm_selections(final_config):
+            return final_config
+        else:
+            print_warning("Project creation cancelled by user.")
+            return {}
+
+    def _collect_basic_info(self) -> None:
+        """Collect basic project information."""
+        basic_info = prompt_basic_info()
+        self.config.update(basic_info)
+
+    def _collect_template_selection(self) -> None:
+        """Collect template selection."""
+        template = prompt_template_selection(self.settings)
+        self.config["base_template"] = template
+
+    def _collect_feature_selections(self) -> None:
+        """Collect all feature selections."""
+        features = prompt_additional_features(self.settings)
+        self.config.update(features)
+
+    def _build_final_config(self) -> Dict[str, Any]:
+        """
+        Build and validate final configuration.
+
+        Returns:
+            Complete configuration dictionary with collected dependencies
+        """
+        # Collect all dependencies
+        all_deps = self._collect_all_dependencies()
+
+        # Add to config
+        self.config["all_dependencies"] = all_deps
+
+        return self.config
+
+    def _collect_all_dependencies(self) -> List[str]:
+        """
+        Collect all dependencies from selected features.
+
+        Returns:
+            Deduplicated list of all package dependencies
+        """
+        dependencies = set()
+
+        # Always add base FastAPI dependencies
+        dependencies.update(["fastapi", "uvicorn", "pydantic", "pydantic-settings"])
+
+        # Database dependencies
+        db_info = self.config.get("database", {})
+        if isinstance(db_info, dict) and db_info.get("packages"):
+            dependencies.update(db_info["packages"])
+
+        # Authentication dependencies
+        auth_type = self.config.get("authentication", "None")
+        if auth_type != "None":
+            auth_packages = self.settings.PACKAGE_CATALOG["authentication"].get(
+                auth_type, []
+            )
+            dependencies.update(auth_packages)
+
+        # Async tasks dependencies
+        tasks_type = self.config.get("async_tasks", "None")
+        if tasks_type != "None":
+            task_packages = self.settings.PACKAGE_CATALOG["async_tasks"].get(
+                tasks_type, []
+            )
+            dependencies.update(task_packages)
+
+        # Caching dependencies
+        cache_type = self.config.get("caching", "None")
+        if cache_type != "None":
+            cache_packages = self.settings.PACKAGE_CATALOG["caching"].get(
+                cache_type, []
+            )
+            dependencies.update(cache_packages)
+
+        # Monitoring dependencies
+        monitoring_type = self.config.get("monitoring", "None")
+        if monitoring_type != "None":
+            monitoring_packages = self.settings.PACKAGE_CATALOG["monitoring"].get(
+                monitoring_type, []
+            )
+            dependencies.update(monitoring_packages)
+
+        # Testing dependencies
+        testing_type = self.config.get("testing", "None")
+        if testing_type != "None":
+            testing_packages = self.settings.PACKAGE_CATALOG["testing"].get(
+                testing_type, []
+            )
+            dependencies.update(testing_packages)
+
+        # Utilities dependencies
+        utilities = self.config.get("utilities", [])
+        for util in utilities:
+            if util in self.settings.PACKAGE_CATALOG["utilities"]:
+                util_packages = self.settings.PACKAGE_CATALOG["utilities"][util]
+                dependencies.update(util_packages)
+
+        # Custom packages
+        custom_packages = self.config.get("custom_packages", [])
+        if custom_packages:
+            sanitized = sanitize_custom_packages(custom_packages)
+            dependencies.update(sanitized)
+
+        # Convert to sorted list
+        return sorted(list(dependencies))
+
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Get the current configuration.
+
+        Returns:
+            Current configuration dictionary
+        """
+        return self.config