[FEAT] add package managers option - uv, pdm, poetry

Author: bnbong

src/fastapi_fastkit/backend/main.py

@@ -5,11 +5,10 @@
 # --------------------------------------------------------------------------
 import os
 import re
-import subprocess
-import sys
-from typing import Dict, List, Optional
+from typing import Dict, List
 
 from fastapi_fastkit import console
+from fastapi_fastkit.backend.package_managers import PackageManagerFactory
 from fastapi_fastkit.backend.transducer import copy_and_convert_template_file
 from fastapi_fastkit.core.exceptions import BackendExceptions, TemplateExceptions
 from fastapi_fastkit.core.settings import settings
@@ -246,99 +245,94 @@ def _process_config_file(config_py: str, project_name: str) -> None:
         raise BackendExceptions(f"Failed to process config file: {e}")
 
 
+def create_venv_with_manager(project_dir: str, manager_type: str = "pip") -> str:
+    """
+    Create a virtual environment using the specified package manager.
+
+    :param project_dir: Path to the project directory
+    :param manager_type: Type of package manager to use
+    :return: Path to the virtual environment
+    :raises: BackendExceptions if virtual environment creation fails
+    """
+    try:
+        package_manager = PackageManagerFactory.create_manager(
+            manager_type, project_dir, auto_detect=True
+        )
+        return package_manager.create_virtual_environment()
+    except Exception as e:
+        debug_log(
+            f"Error creating virtual environment with {manager_type}: {e}", "error"
+        )
+        raise BackendExceptions(f"Failed to create virtual environment: {str(e)}")
+
+
 def create_venv(project_dir: str) -> str:
     """
     Create a Python virtual environment in the project directory.
 
+    This is a backward compatibility wrapper that uses pip by default.
+
     :param project_dir: Path to the project directory
     :return: Path to the virtual environment
     """
-    venv_path = os.path.join(project_dir, ".venv")
+    return create_venv_with_manager(project_dir, "pip")
 
-    try:
-        with console.status("[bold green]Creating virtual environment..."):
-            subprocess.run(
-                [sys.executable, "-m", "venv", venv_path],
-                check=True,
-                capture_output=True,
-                text=True,
-            )
 
-        debug_log(f"Virtual environment created at {venv_path}", "info")
-        print_success("Virtual environment created successfully")
-        return venv_path
+def install_dependencies_with_manager(
+    project_dir: str, venv_path: str, manager_type: str = "pip"
+) -> None:
+    """
+    Install dependencies using the specified package manager.
 
-    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")
-    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: {str(e)}")
+    :param project_dir: Path to the project directory
+    :param venv_path: Path to the virtual environment
+    :param manager_type: Type of package manager to use
+    :return: None
+    :raises: BackendExceptions if dependency installation fails
+    """
+    try:
+        package_manager = PackageManagerFactory.create_manager(
+            manager_type, project_dir, auto_detect=True
+        )
+        package_manager.install_dependencies(venv_path)
+    except Exception as e:
+        debug_log(f"Error installing dependencies with {manager_type}: {e}", "error")
+        raise BackendExceptions(f"Failed to install dependencies: {str(e)}")
 
 
 def install_dependencies(project_dir: str, venv_path: str) -> None:
     """
     Install dependencies in the virtual environment.
 
+    This is a backward compatibility wrapper that uses pip by default.
+
     :param project_dir: Path to the project directory
     :param venv_path: Path to the virtual environment
     :return: None
     """
-    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 = create_venv(project_dir)
-            if not venv_path:
-                raise BackendExceptions("Failed to create venv")
-
-        requirements_path = os.path.join(project_dir, "requirements.txt")
-        if not os.path.exists(requirements_path):
-            debug_log(f"Requirements file not found at {requirements_path}", "error")
-            print_error(f"Requirements file not found at {requirements_path}")
-            raise BackendExceptions("Requirements file not found")
-
-        # Determine pip path based on OS
-        if os.name == "nt":  # Windows
-            pip_path = os.path.join(venv_path, "Scripts", "pip")
-        else:  # Unix-based
-            pip_path = os.path.join(venv_path, "bin", "pip")
-
-        # Upgrade pip first
-        subprocess.run(
-            [pip_path, "install", "--upgrade", "pip"],
-            check=True,
-            capture_output=True,
-            text=True,
-        )
+    install_dependencies_with_manager(project_dir, venv_path, "pip")
 
-        # Install dependencies
-        with console.status("[bold green]Installing dependencies..."):
-            subprocess.run(
-                [pip_path, "install", "-r", "requirements.txt"],
-                cwd=project_dir,
-                check=True,
-                capture_output=True,
-                text=True,
-            )
 
-        debug_log("Dependencies installed successfully", "info")
-        print_success("Dependencies installed successfully")
-
-    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")
-    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: {str(e)}")
+def generate_dependency_file_with_manager(
+    project_dir: str, dependencies: List[str], manager_type: str = "pip"
+) -> None:
+    """
+    Generate a dependency file using the specified package manager.
+
+    :param project_dir: Path to the project directory
+    :param dependencies: List of dependency specifications
+    :param manager_type: Type of package manager to use
+    :return: None
+    :raises: BackendExceptions if dependency file generation fails
+    """
+    try:
+        package_manager = PackageManagerFactory.create_manager(
+            manager_type, project_dir, auto_detect=True
+        )
+        package_manager.generate_dependency_file(dependencies)
+    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)}")
 
 
 # ------------------------------------------------------------

src/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 [email protected]
+# --------------------------------------------------------------------------
+
+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",
+]

src/fastapi_fastkit/backend/package_managers/base.py

@@ -0,0 +1,139 @@
+# --------------------------------------------------------------------------
+# Base Package Manager - Abstract class for package manager implementations
+#
+# @author bnbong [email protected]
+# --------------------------------------------------------------------------
+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]) -> None:
+        """
+        Generate a dependency file with the given dependencies.
+
+        :param dependencies: List of dependency specifications
+        """
+        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__()