FastAPI-fastkit 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

fastapi_fastkit/backend/package_managers/__init__.py

@@ -0,0 +1,22 @@
+# --------------------------------------------------------------------------
+# Package Managers Module - FastAPI-fastkit
+# Provides abstraction layer for different package managers (pip, uv, pdm, poetry)
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+
+from .base import BasePackageManager
+from .factory import PackageManagerFactory
+from .pdm_manager import PdmManager
+from .pip_manager import PipManager
+from .poetry_manager import PoetryManager
+from .uv_manager import UvManager
+
+__all__ = [
+    "BasePackageManager",
+    "PackageManagerFactory",
+    "PipManager",
+    "PdmManager",
+    "UvManager",
+    "PoetryManager",
+]

fastapi_fastkit/backend/package_managers/base.py

@@ -0,0 +1,150 @@
+# --------------------------------------------------------------------------
+# Base Package Manager - Abstract class for package manager implementations
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+import subprocess
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class BasePackageManager(ABC):
+    """
+    Abstract base class for package managers.
+
+    All package manager implementations must inherit from this class
+    and implement the required abstract methods.
+    """
+
+    def __init__(self, project_dir: str):
+        """
+        Initialize package manager for a specific project.
+
+        :param project_dir: Path to the project directory
+        """
+        self.project_dir = Path(project_dir)
+        self.name = self.__class__.__name__.replace("Manager", "").lower()
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """
+        Check if the package manager is available on the system.
+
+        :return: True if package manager is installed and available
+        """
+        pass
+
+    @abstractmethod
+    def get_dependency_file_name(self) -> str:
+        """
+        Get the name of the dependency file for this package manager.
+
+        :return: Dependency file name (e.g., 'requirements.txt', 'pyproject.toml')
+        """
+        pass
+
+    @abstractmethod
+    def create_virtual_environment(self) -> str:
+        """
+        Create a virtual environment for the project.
+
+        :return: Path to the created virtual environment
+        :raises: Exception if virtual environment creation fails
+        """
+        pass
+
+    @abstractmethod
+    def install_dependencies(self, venv_path: str) -> None:
+        """
+        Install dependencies using the package manager.
+
+        :param venv_path: Path to the virtual environment
+        :raises: Exception if dependency installation fails
+        """
+        pass
+
+    @abstractmethod
+    def generate_dependency_file(
+        self,
+        dependencies: List[str],
+        project_name: str = "",
+        author: str = "",
+        author_email: str = "",
+        description: str = "",
+    ) -> None:
+        """
+        Generate a dependency file with the given dependencies and metadata.
+
+        :param dependencies: List of dependency specifications
+        :param project_name: Name of the project
+        :param author: Author name
+        :param author_email: Author email
+        :param description: Project description
+        """
+        pass
+
+    @abstractmethod
+    def add_dependency(self, dependency: str, dev: bool = False) -> None:
+        """
+        Add a new dependency to the project.
+
+        :param dependency: Dependency specification
+        :param dev: Whether this is a development dependency
+        """
+        pass
+
+    def get_executable_path(
+        self, executable_name: str, venv_path: Optional[str] = None
+    ) -> str:
+        """
+        Get the full path to an executable, considering virtual environment.
+
+        :param executable_name: Name of the executable
+        :param venv_path: Path to virtual environment (optional)
+        :return: Full path to the executable
+        """
+        import os
+
+        if venv_path:
+            if os.name == "nt":  # Windows
+                return os.path.join(venv_path, "Scripts", f"{executable_name}.exe")
+            else:  # Unix-based
+                return os.path.join(venv_path, "bin", executable_name)
+        else:
+            return executable_name
+
+    def run_command(
+        self, command: List[str], **kwargs: Any
+    ) -> subprocess.CompletedProcess[str]:
+        """
+        Run a command with proper error handling.
+
+        :param command: Command to run as list of strings
+        :param kwargs: Additional keyword arguments for subprocess.run
+        :return: CompletedProcess instance
+        :raises: subprocess.CalledProcessError on failure
+        """
+        default_kwargs: Dict[str, Any] = {
+            "check": True,
+            "capture_output": True,
+            "text": True,
+            "cwd": str(self.project_dir),
+        }
+        default_kwargs.update(kwargs)
+
+        return subprocess.run(command, **default_kwargs)
+
+    def get_dependency_file_path(self) -> Path:
+        """
+        Get the full path to the dependency file.
+
+        :return: Path to the dependency file
+        """
+        return self.project_dir / self.get_dependency_file_name()
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}({self.project_dir})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

fastapi_fastkit/backend/package_managers/factory.py

@@ -0,0 +1,151 @@
+# --------------------------------------------------------------------------
+# Package Manager Factory - Creates appropriate package manager instances
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+from typing import Dict, List, Optional, Type
+
+from fastapi_fastkit.core.exceptions import BackendExceptions
+from fastapi_fastkit.utils.logging import debug_log, get_logger
+
+from .base import BasePackageManager
+from .pdm_manager import PdmManager
+from .pip_manager import PipManager
+from .poetry_manager import PoetryManager
+from .uv_manager import UvManager
+
+logger = get_logger(__name__)
+
+
+class PackageManagerFactory:
+    """Factory for creating package manager instances."""
+
+    # Registry of available package managers
+    _managers: Dict[str, Type[BasePackageManager]] = {
+        "pip": PipManager,
+        "pdm": PdmManager,
+        "uv": UvManager,
+        "poetry": PoetryManager,
+    }
+
+    @classmethod
+    def create_manager(
+        self, manager_type: str, project_dir: str, auto_detect: bool = False
+    ) -> BasePackageManager:
+        """
+        Create a package manager instance.
+
+        :param manager_type: Type of package manager ('pip', 'uv', 'pdm', 'poetry')
+        :param project_dir: Path to the project directory
+        :param auto_detect: If True, auto-detect available package manager when requested type is not available
+        :return: Package manager instance
+        :raises: BackendExceptions if manager type is not supported or not available
+        """
+        manager_type = manager_type.lower()
+
+        # Check if requested manager type is supported
+        if manager_type not in self._managers:
+            available_managers = list(self._managers.keys())
+            error_msg = f"Unsupported package manager: {manager_type}. Available: {available_managers}"
+            debug_log(error_msg, "error")
+            raise BackendExceptions(error_msg)
+
+        # Create the manager instance
+        manager_class = self._managers[manager_type]
+        manager = manager_class(project_dir)
+
+        # Check if the manager is available on the system
+        if not manager.is_available():
+            if auto_detect:
+                debug_log(
+                    f"{manager_type} is not available, trying to auto-detect alternative",
+                    "warning",
+                )
+                return self._auto_detect_manager(project_dir, exclude=[manager_type])
+            else:
+                error_msg = (
+                    f"Package manager '{manager_type}' is not available on the system"
+                )
+                debug_log(error_msg, "error")
+                raise BackendExceptions(error_msg)
+
+        debug_log(f"Created {manager_type} package manager for {project_dir}", "info")
+        return manager
+
+    @classmethod
+    def _auto_detect_manager(
+        self, project_dir: str, exclude: Optional[List[str]] = None
+    ) -> BasePackageManager:
+        """
+        Auto-detect the best available package manager.
+
+        :param project_dir: Path to the project directory
+        :param exclude: List of manager types to exclude from detection
+        :return: Package manager instance
+        :raises: BackendExceptions if no package manager is available
+        """
+        exclude = exclude or []
+
+        # Priority order for auto-detection
+        detection_order = ["uv", "pdm", "poetry", "pip"]
+
+        for manager_type in detection_order:
+            if manager_type in exclude:
+                continue
+
+            if manager_type not in self._managers:
+                continue
+
+            manager_class = self._managers[manager_type]
+            manager = manager_class(project_dir)
+
+            if manager.is_available():
+                debug_log(f"Auto-detected package manager: {manager_type}", "info")
+                return manager
+
+        error_msg = "No package manager is available on the system"
+        debug_log(error_msg, "error")
+        raise BackendExceptions(error_msg)
+
+    @classmethod
+    def get_available_managers(self) -> list[str]:
+        """
+        Get list of available package managers on the current system.
+
+        :return: List of available package manager names
+        """
+        available = []
+
+        for manager_type, manager_class in self._managers.items():
+            # Create a temporary instance to check availability
+            # Using current directory as a dummy project path
+            temp_manager = manager_class(".")
+            if temp_manager.is_available():
+                available.append(manager_type)
+
+        return available
+
+    @classmethod
+    def register_manager(
+        self, name: str, manager_class: Type[BasePackageManager]
+    ) -> None:
+        """
+        Register a new package manager type.
+
+        :param name: Name of the package manager
+        :param manager_class: Package manager class
+        """
+        if not issubclass(manager_class, BasePackageManager):
+            raise ValueError(f"Manager class must inherit from BasePackageManager")
+
+        self._managers[name.lower()] = manager_class
+        debug_log(f"Registered package manager: {name}", "info")
+
+    @classmethod
+    def get_supported_managers(self) -> list[str]:
+        """
+        Get list of all supported package manager types.
+
+        :return: List of supported package manager names
+        """
+        return list(self._managers.keys())

fastapi_fastkit/backend/package_managers/pdm_manager.py

@@ -0,0 +1,275 @@
+# --------------------------------------------------------------------------
+# PDM Package Manager Implementation
+#
+# @author bnbong bbbong9@gmail.com
+# --------------------------------------------------------------------------
+import os
+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 .base import BasePackageManager
+
+logger = get_logger(__name__)
+
+
+class PdmManager(BasePackageManager):
+    """PDM package manager implementation."""
+
+    def is_available(self) -> bool:
+        """Check if PDM is available on the system."""
+        try:
+            subprocess.run(
+                ["pdm", "--version"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def get_dependency_file_name(self) -> str:
+        """Get the dependency file name for PDM."""
+        return "pyproject.toml"
+
+    def create_virtual_environment(self) -> str:
+        """
+        Create a virtual environment using PDM.
+
+        :return: Path to the virtual environment
+        :raises: BackendExceptions if virtual environment creation fails
+        """
+        venv_path = str(self.project_dir / ".venv")
+
+        try:
+            with console.status("[bold green]Creating virtual environment with PDM..."):
+                # PDM can create virtual environment in specific location
+                subprocess.run(
+                    ["pdm", "venv", "create", "--name", ".venv", sys.executable],
+                    cwd=str(self.project_dir),
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+
+            debug_log(f"Virtual environment created at {venv_path}", "info")
+            print_success("Virtual environment created successfully with PDM")
+            return venv_path
+
+        except subprocess.CalledProcessError as e:
+            debug_log(f"Error creating virtual environment: {e.stderr}", "error")
+            handle_exception(e, f"Error creating virtual environment: {str(e)}")
+            raise BackendExceptions("Failed to create venv with PDM")
+        except OSError as e:
+            debug_log(f"System error creating virtual environment: {e}", "error")
+            handle_exception(e, f"Error creating virtual environment: {str(e)}")
+            raise BackendExceptions(f"Failed to create venv with PDM: {str(e)}")
+
+    def install_dependencies(self, venv_path: str) -> None:
+        """
+        Install dependencies using PDM.
+
+        :param venv_path: Path to the virtual environment
+        :raises: BackendExceptions if dependency installation fails
+        """
+        try:
+            if not os.path.exists(venv_path):
+                debug_log(
+                    "Virtual environment does not exist. Creating it first.", "warning"
+                )
+                print_error("Virtual environment does not exist. Creating it first.")
+                venv_path = self.create_virtual_environment()
+                if not venv_path:
+                    raise BackendExceptions("Failed to create venv")
+
+            pyproject_path = self.get_dependency_file_path()
+            if not pyproject_path.exists():
+                debug_log(f"pyproject.toml file not found at {pyproject_path}", "error")
+                print_error(f"pyproject.toml file not found at {pyproject_path}")
+                raise BackendExceptions("pyproject.toml file not found")
+
+            # Install dependencies using PDM
+            with console.status("[bold green]Installing dependencies with PDM..."):
+                subprocess.run(
+                    ["pdm", "install"],
+                    cwd=str(self.project_dir),
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+
+            debug_log("Dependencies installed successfully with PDM", "info")
+            print_success("Dependencies installed successfully with PDM")
+
+        except subprocess.CalledProcessError as e:
+            debug_log(f"Error during dependency installation: {e.stderr}", "error")
+            handle_exception(e, f"Error during dependency installation: {str(e)}")
+            if hasattr(e, "stderr"):
+                print_error(f"Error details: {e.stderr}")
+            raise BackendExceptions("Failed to install dependencies with PDM")
+        except OSError as e:
+            debug_log(f"System error during dependency installation: {e}", "error")
+            handle_exception(e, f"Error during dependency installation: {str(e)}")
+            raise BackendExceptions(
+                f"Failed to install dependencies with PDM: {str(e)}"
+            )
+
+    def generate_dependency_file(
+        self,
+        dependencies: List[str],
+        project_name: str = "",
+        author: str = "",
+        author_email: str = "",
+        description: str = "",
+    ) -> None:
+        """
+        Generate a pyproject.toml file with the given dependencies and metadata.
+
+        :param dependencies: List of dependency specifications
+        :param project_name: Name of the project
+        :param author: Author name
+        :param author_email: Author email
+        :param description: Project description
+        """
+        pyproject_path = self.get_dependency_file_path()
+
+        try:
+            # Create dependencies list as TOML format
+            deps_toml = "[\n"
+            for dep in dependencies:
+                deps_toml += f'    "{dep}",\n'
+            deps_toml += "]"
+
+            # Create basic pyproject.toml content as string
+            pyproject_content = f"""[project]
+name = "{project_name or 'fastapi-project'}"
+version = "0.1.0"
+description = "{description or 'A FastAPI project'}"
+authors = [
+    {{name = "{author or 'Author'}", email = "{author_email or 'author@example.com'}"}},
+]
+dependencies = {deps_toml}
+requires-python = ">=3.8"
+readme = "README.md"
+license = {{text = "MIT"}}
+
+[build-system]
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[tool.pdm]
+"""
+
+            with open(pyproject_path, "w", encoding="utf-8") as f:
+                f.write(pyproject_content)
+
+            debug_log(
+                f"Generated {pyproject_path} with {len(dependencies)} dependencies",
+                "info",
+            )
+
+        except (OSError, UnicodeEncodeError) as e:
+            debug_log(f"Error generating pyproject.toml: {e}", "error")
+            raise BackendExceptions(f"Failed to generate pyproject.toml: {str(e)}")
+
+    def add_dependency(self, dependency: str, dev: bool = False) -> None:
+        """
+        Add a new dependency using PDM.
+
+        :param dependency: Dependency specification
+        :param dev: Whether this is a development dependency
+        """
+        try:
+            # Use PDM's add command to add dependency
+            cmd = ["pdm", "add"]
+            if dev:
+                cmd.append("--dev")
+            cmd.append(dependency)
+
+            subprocess.run(
+                cmd,
+                cwd=str(self.project_dir),
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            debug_log(
+                f"Added {'dev ' if dev else ''}dependency '{dependency}' with PDM",
+                "info",
+            )
+
+        except subprocess.CalledProcessError as e:
+            debug_log(f"Error adding dependency with PDM: {e}", "error")
+            raise BackendExceptions(f"Failed to add dependency with PDM: {str(e)}")
+        except OSError as e:
+            debug_log(f"System error adding dependency with PDM: {e}", "error")
+            raise BackendExceptions(f"Failed to add dependency with PDM: {str(e)}")
+
+    def initialize_project(
+        self, project_name: str, author: str, author_email: str, description: str
+    ) -> None:
+        """
+        Initialize a new PDM project with metadata.
+
+        :param project_name: Name of the project
+        :param author: Author name
+        :param author_email: Author email
+        :param description: Project description
+        """
+        try:
+            # Use PDM init command for interactive setup
+            subprocess.run(
+                ["pdm", "init", "--non-interactive"],
+                cwd=str(self.project_dir),
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            # Create or update pyproject.toml with provided metadata
+            pyproject_path = self.get_dependency_file_path()
+
+            # Create basic pyproject.toml with project metadata
+            pyproject_content = f"""[project]
+name = "{project_name}"
+version = "0.1.0"
+description = "{description}"
+authors = [
+    {{name = "{author}", email = "{author_email}"}},
+]
+dependencies = []
+requires-python = ">=3.8"
+readme = "README.md"
+license = {{text = "MIT"}}
+
+[build-system]
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[tool.pdm]
+"""
+
+            with open(pyproject_path, "w", encoding="utf-8") as f:
+                f.write(pyproject_content)
+
+            debug_log(f"Initialized PDM project: {project_name}", "info")
+
+        except subprocess.CalledProcessError as e:
+            debug_log(f"Error initializing PDM project: {e}", "error")
+            raise BackendExceptions(f"Failed to initialize PDM project: {str(e)}")
+        except (OSError, UnicodeEncodeError) as e:
+            debug_log(f"Error updating project metadata: {e}", "error")
+            raise BackendExceptions(f"Failed to update project metadata: {str(e)}")