multi-lang-build 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

multi_lang_build/compiler/python.py

@@ -5,35 +5,33 @@ from typing import Final
 import shutil
 import subprocess
 import sys
-import venv
-import json
-import time
 
 from multi_lang_build.compiler.base import CompilerBase, BuildResult, CompilerInfo
 from multi_lang_build.mirror.config import (
-    get_mirror_config, 
     apply_mirror_environment,
-    PYPI_MIRROR_TSINGHUA,
-    PYPI_MIRROR_ALIYUN,
-    PYPI_MIRROR_DOUBAN,
-    PYPI_MIRROR_HUAWEI,
     DEFAULT_PIP_MIRROR,
 )
+from multi_lang_build.compiler.python_support import (
+    BuildSystemDetector,
+    DependencyInstaller,
+    VenvManager,
+    PythonCleaner,
+)
 
 
 class PythonCompiler(CompilerBase):
     """Compiler for Python projects with pip and poetry support."""
-    
+
     NAME: Final[str] = "python"
     DEFAULT_MIRROR: Final[str] = DEFAULT_PIP_MIRROR
-    
+
     def __init__(
-        self, 
+        self,
         python_path: str | None = None,
         mirror: str | None = None,
     ) -> None:
         """Initialize the Python compiler.
-        
+
         Args:
             python_path: Optional path to python executable. If None, uses sys.executable.
             mirror: Mirror configuration name (e.g., "pip", "pip_aliyun", "pip_douban", "pip_huawei").
@@ -42,20 +40,20 @@ class PythonCompiler(CompilerBase):
         self._python_path = python_path
         self._mirror = mirror
         self._version_cache: str | None = None
-    
+
     @property
     def name(self) -> str:
         """Get the compiler name."""
         return self.NAME
-    
+
     @property
     def version(self) -> str:
         """Get the Python version."""
         if self._version_cache:
             return self._version_cache
-        
+
         python_executable = self._get_executable_path()
-        
+
         try:
             result = subprocess.run(
                 [python_executable, "--version"],
@@ -67,19 +65,19 @@ class PythonCompiler(CompilerBase):
             self._version_cache = output.replace("Python ", "")
         except Exception:
             self._version_cache = sys.version.split()[0]
-        
+
         return self._version_cache
-    
+
     @property
     def supported_mirrors(self) -> list[str]:
         """Get list of supported mirror configurations."""
         return ["pip", "pip_aliyun", "pip_douban", "pip_huawei"]
-    
+
     @property
     def current_mirror(self) -> str:
         """Get the current mirror configuration name."""
         return self._mirror or "pip"
-    
+
     def get_info(self) -> CompilerInfo:
         """Get compiler information."""
         return {
@@ -89,15 +87,15 @@ class PythonCompiler(CompilerBase):
             "default_mirror": self.DEFAULT_MIRROR,
             "executable": self._get_executable_path(),
         }
-    
+
     def set_mirror(self, mirror: str) -> None:
         """Set the mirror configuration.
-        
+
         Args:
             mirror: Mirror configuration name (e.g., "pip", "pip_aliyun", "pip_douban", "pip_huawei")
         """
         self._mirror = mirror
-    
+
     def build(
         self,
         source_dir: Path,
@@ -122,20 +120,20 @@ class PythonCompiler(CompilerBase):
             BuildResult containing success status and output information.
         """
         python_executable = self._get_executable_path()
-        
+
         # Validate directories
         source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
         output_dir = self._validate_directory(output_dir, create_if_not_exists=True)
-        
+
         # Prepare environment
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             env = apply_mirror_environment("python", env)
             env = apply_mirror_environment("pip", env)
-        
+
         # Determine build system
-        build_system = self._detect_build_system(source_dir)
+        build_system = BuildSystemDetector.detect(source_dir)
 
         if build_system == "poetry":
             return self._build_with_poetry(
@@ -159,42 +157,7 @@ class PythonCompiler(CompilerBase):
                 output_path=None,
                 duration_seconds=0.0,
             )
-    
-    def _detect_build_system(self, source_dir: Path) -> str:
-        """Detect the build system used by the project.
-        
-        Args:
-            source_dir: Source directory to check
-            
-        Returns:
-            Build system name: "poetry", "setuptools", "pdm", or "none"
-        """
-        pyproject = source_dir / "pyproject.toml"
-        setup_py = source_dir / "setup.py"
-        setup_cfg = source_dir / "setup.cfg"
-        pdm_pyproject = source_dir / "pyproject.toml"
-        
-        # Check for poetry
-        if pyproject.exists():
-            try:
-                content = pyproject.read_text()
-                if "[tool.poetry]" in content:
-                    return "poetry"
-                if "[tool.pdm]" in content:
-                    return "pdm"
-            except Exception:
-                pass
-        
-        # Check for setuptools
-        if setup_py.exists() or setup_cfg.exists():
-            return "setuptools"
-        
-        # Check pdm
-        if pdm_pyproject.exists():
-            return "pdm"
-        
-        return "none"
-    
+
     def _build_with_poetry(
         self,
         python_executable: str,
@@ -250,10 +213,10 @@ class PythonCompiler(CompilerBase):
         else:
             # Legacy setup.py
             build_cmd = [python_executable, "setup.py", "bdist_wheel", "--dist-dir", str(output_dir)]
-        
+
         if extra_args:
             build_cmd.extend(extra_args)
-        
+
         return self._run_build(
             build_cmd,
             source_dir,
@@ -285,7 +248,7 @@ class PythonCompiler(CompilerBase):
             environment=env,
             stream_output=stream_output,
         )
-    
+
     def install_dependencies(
         self,
         source_dir: Path,
@@ -296,42 +259,37 @@ class PythonCompiler(CompilerBase):
         poetry: bool = False,
     ) -> BuildResult:
         """Install Python dependencies.
-        
+
         Args:
             source_dir: Source code directory
             environment: Additional environment variables
             mirror_enabled: Whether to use PyPI mirror
             dev: Include development dependencies
             poetry: Force using poetry
-            
+
         Returns:
             BuildResult containing success status and output information.
         """
         python_executable = self._get_executable_path()
-        
+
         source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
-        
+
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             env = apply_mirror_environment("pip", env)
-        
+
         # Check for poetry first
-        if poetry or (source_dir / "pyproject.toml").exists() and "poetry" in (source_dir / "pyproject.toml").read_text():
-            cmd = [python_executable, "-m", "poetry", "install"]
-            if dev:
-                cmd.append("--with=dev")
-            return self._run_build(cmd, source_dir, source_dir, environment=env)
-        
+        if poetry or BuildSystemDetector.is_poetry(source_dir):
+            return DependencyInstaller.install_poetry(
+                python_executable, source_dir, env, dev, True
+            )
+
         # Use pip
-        cmd = [python_executable, "-m", "pip", "install", "-r", str(source_dir / "requirements.txt")]
-        
-        if dev:
-            cmd.append("-r")
-            cmd.append(str(source_dir / "requirements-dev.txt"))
-        
-        return self._run_build(cmd, source_dir, source_dir, environment=env)
-    
+        return DependencyInstaller.install_pip(
+            python_executable, source_dir, env, dev, True
+        )
+
     def create_venv(
         self,
         directory: Path,
@@ -340,52 +298,17 @@ class PythonCompiler(CompilerBase):
         mirror_enabled: bool = True,
     ) -> BuildResult:
         """Create a virtual environment.
-        
+
         Args:
             directory: Directory to create the venv in
             python_path: Python interpreter to use
             mirror_enabled: Whether to configure pip mirror
-            
+
         Returns:
             BuildResult containing success status and output information.
         """
-        env_builder = venv.EnvBuilder(with_pip=True, clear=True)
-        
-        start_time = time.perf_counter()  # noqa: F821
-        
-        try:
-            env_builder.create(directory)
-            
-            # Configure pip mirror if enabled
-            if mirror_enabled:
-                pip_config_dir = directory / "pip.conf"
-                pip_config_dir.write_text(
-                    "[global]\n"
-                    "index-url = https://pypi.tuna.tsinghua.edu.cn/simple\n"
-                    "trusted-host = pypi.tuna.tsinghua.edu.cn\n"
-                )
-            
-            duration = time.perf_counter() - start_time  # noqa: F821
-            
-            return BuildResult(
-                success=True,
-                return_code=0,
-                stdout=f"Virtual environment created at {directory}",
-                stderr="",
-                output_path=directory,
-                duration_seconds=duration,
-            )
-        except Exception as e:
-            duration = time.perf_counter() - start_time  # noqa: F821
-            return BuildResult(
-                success=False,
-                return_code=-1,
-                stdout="",
-                stderr=f"Failed to create virtual environment: {str(e)}",
-                output_path=None,
-                duration_seconds=duration,
-            )
-    
+        return VenvManager.create(directory, python_path, mirror_enabled)
+
     def run_script(
         self,
         source_dir: Path,
@@ -395,145 +318,65 @@ class PythonCompiler(CompilerBase):
         mirror_enabled: bool = True,
     ) -> BuildResult:
         """Run a Python script or module.
-        
+
         Args:
             source_dir: Source code directory
             script_name: Script or module name to run
             environment: Additional environment variables
             mirror_enabled: Whether to use PyPI mirror
-            
+
         Returns:
             BuildResult containing success status and output information.
         """
         python_executable = self._get_executable_path()
-        
+
         source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
-        
+
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             env = apply_mirror_environment("pip", env)
-        
+
         return self._run_build(
             [python_executable, "-m", script_name],
             source_dir,
             source_dir,
             environment=env,
         )
-    
+
     def clean(self, directory: Path) -> bool:
         """Clean Python build artifacts in the specified directory.
-        
+
         Args:
             directory: Directory to clean
-            
+
         Returns:
             True if successful, False otherwise.
         """
-        import shutil
-        
-        try:
-            directory = self._validate_directory(directory, create_if_not_exists=False)
-            
-            # Remove __pycache__ directories
-            for pycache in directory.rglob("__pycache__"):
-                shutil.rmtree(pycache)
-            
-            # Remove .pyc files
-            for pyc in directory.rglob("*.pyc"):
-                pyc.unlink()
-            
-            # Remove .pytest_cache
-            pytest_cache = directory / ".pytest_cache"
-            if pytest_cache.exists():
-                shutil.rmtree(pytest_cache)
-            
-            # Remove .tox
-            tox_dir = directory / ".tox"
-            if tox_dir.exists():
-                shutil.rmtree(tox_dir)
-            
-            # Remove dist directory
-            dist_dir = directory / "dist"
-            if dist_dir.exists():
-                shutil.rmtree(dist_dir)
-            
-            # Remove build directory
-            build_dir = directory / "build"
-            if build_dir.exists():
-                shutil.rmtree(build_dir)
-            
-            # Remove *.egg-info directories
-            for egg_info in directory.rglob("*.egg-info"):
-                shutil.rmtree(egg_info)
-            
-            return True
-            
-        except Exception:
-            return False
-    
+        return PythonCleaner.clean(directory)
+
     def _get_executable_path(self) -> str:
         """Get the python executable path."""
         if self._python_path:
             return self._python_path
-        
+
         python_path = shutil.which("python3") or shutil.which("python")
         if python_path is None:
             return sys.executable
-        
+
         return python_path
-    
+
     @staticmethod
     def create(source_dir: Path, *, mirror_enabled: bool = True) -> "PythonCompiler":
         """Factory method to create a PythonCompiler instance.
-        
+
         Args:
             source_dir: Source directory for the project
             mirror_enabled: Whether to enable mirror acceleration by default
-            
+
         Returns:
             Configured PythonCompiler instance
         """
         compiler = PythonCompiler()
         return compiler
 
-
-def main() -> None:
-    """Python compiler CLI entry point."""
-    import argparse
-    import sys
-    
-    parser = argparse.ArgumentParser(description="Python Build Compiler")
-    parser.add_argument("source_dir", type=Path, help="Source directory")
-    parser.add_argument("-o", "--output", type=Path, required=True, help="Output directory")
-    parser.add_argument("--mirror", action="store_true", default=True, help="Enable PyPI mirror")
-    parser.add_argument("--no-mirror", dest="mirror", action="store_false", help="Disable PyPI mirror")
-    parser.add_argument("--install", action="store_true", help="Install dependencies only")
-    parser.add_argument("--dev", action="store_true", help="Include dev dependencies")
-    parser.add_argument("--poetry", action="store_true", help="Force using poetry")
-    parser.add_argument("--create-venv", type=Path, help="Create virtual environment at path")
-    
-    args = parser.parse_args()
-    
-    compiler = PythonCompiler()
-    
-    if args.create_venv:
-        result = compiler.create_venv(
-            args.create_venv,
-            mirror_enabled=args.mirror,
-        )
-    elif args.install:
-        result = compiler.install_dependencies(
-            args.source_dir,
-            mirror_enabled=args.mirror,
-            dev=args.dev,
-            poetry=args.poetry,
-        )
-    else:
-        result = compiler.build(
-            args.source_dir,
-            args.output,
-            mirror_enabled=args.mirror,
-        )
-    
-    sys.exit(0 if result["success"] else 1)

multi_lang_build/compiler/python_support/__init__.py

@@ -0,0 +1,13 @@
+"""Python compiler support modules."""
+
+from multi_lang_build.compiler.python_support.detector import BuildSystemDetector
+from multi_lang_build.compiler.python_support.installer import DependencyInstaller
+from multi_lang_build.compiler.python_support.venv import VenvManager
+from multi_lang_build.compiler.python_support.cleaner import PythonCleaner
+
+__all__ = [
+    "BuildSystemDetector",
+    "DependencyInstaller",
+    "VenvManager",
+    "PythonCleaner",
+]

multi_lang_build/compiler/python_support/cleaner.py

@@ -0,0 +1,56 @@
+"""Python build artifact cleaning utilities."""
+
+import shutil
+from pathlib import Path
+
+
+class PythonCleaner:
+    """Clean Python build artifacts."""
+
+    @staticmethod
+    def clean(directory: Path) -> bool:
+        """Clean Python build artifacts in the specified directory.
+
+        Args:
+            directory: Directory to clean
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        try:
+            # Remove __pycache__ directories
+            for pycache in directory.rglob("__pycache__"):
+                shutil.rmtree(pycache)
+
+            # Remove .pyc files
+            for pyc in directory.rglob("*.pyc"):
+                pyc.unlink()
+
+            # Remove .pytest_cache
+            pytest_cache = directory / ".pytest_cache"
+            if pytest_cache.exists():
+                shutil.rmtree(pytest_cache)
+
+            # Remove .tox
+            tox_dir = directory / ".tox"
+            if tox_dir.exists():
+                shutil.rmtree(tox_dir)
+
+            # Remove dist directory
+            dist_dir = directory / "dist"
+            if dist_dir.exists():
+                shutil.rmtree(dist_dir)
+
+            # Remove build directory
+            build_dir = directory / "build"
+            if build_dir.exists():
+                shutil.rmtree(build_dir)
+
+            # Remove *.egg-info directories
+            for egg_info in directory.rglob("*.egg-info"):
+                shutil.rmtree(egg_info)
+
+            return True
+
+        except Exception:
+            return False

multi_lang_build/compiler/python_support/cli.py

@@ -0,0 +1,46 @@
+"""Python compiler CLI entry point."""
+
+from pathlib import Path
+
+
+def main() -> None:
+    """Python compiler CLI entry point."""
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Python Build Compiler")
+    parser.add_argument("source_dir", type=Path, help="Source directory")
+    parser.add_argument("-o", "--output", type=Path, required=True, help="Output directory")
+    parser.add_argument("--mirror", action="store_true", default=True, help="Enable PyPI mirror")
+    parser.add_argument("--no-mirror", dest="mirror", action="store_false", help="Disable PyPI mirror")
+    parser.add_argument("--install", action="store_true", help="Install dependencies only")
+    parser.add_argument("--dev", action="store_true", help="Include dev dependencies")
+    parser.add_argument("--poetry", action="store_true", help="Force using poetry")
+    parser.add_argument("--create-venv", type=Path, help="Create virtual environment at path")
+
+    args = parser.parse_args()
+
+    from multi_lang_build.compiler.python import PythonCompiler
+
+    compiler = PythonCompiler()
+
+    if args.create_venv:
+        result = compiler.create_venv(
+            args.create_venv,
+            mirror_enabled=args.mirror,
+        )
+    elif args.install:
+        result = compiler.install_dependencies(
+            args.source_dir,
+            mirror_enabled=args.mirror,
+            dev=args.dev,
+            poetry=args.poetry,
+        )
+    else:
+        result = compiler.build(
+            args.source_dir,
+            args.output,
+            mirror_enabled=args.mirror,
+        )
+
+    sys.exit(0 if result["success"] else 1)

multi_lang_build/compiler/python_support/detector.py

@@ -0,0 +1,64 @@
+"""Python build system detection."""
+
+from pathlib import Path
+
+
+class BuildSystemDetector:
+    """Detect Python build systems (Poetry, setuptools, PDM)."""
+
+    @staticmethod
+    def detect(source_dir: Path) -> str:
+        """Detect the build system used by the project.
+
+        Args:
+            source_dir: Source directory to check
+
+        Returns:
+            Build system name: "poetry", "setuptools", "pdm", or "none"
+        """
+        pyproject = source_dir / "pyproject.toml"
+        setup_py = source_dir / "setup.py"
+        setup_cfg = source_dir / "setup.cfg"
+
+        # Check for poetry
+        if pyproject.exists():
+            try:
+                content = pyproject.read_text()
+                if "[tool.poetry]" in content:
+                    return "poetry"
+                if "[tool.pdm]" in content:
+                    return "pdm"
+            except Exception:
+                pass
+
+        # Check for setuptools
+        if setup_py.exists() or setup_cfg.exists():
+            return "setuptools"
+
+        # Check pdm
+        if pyproject.exists():
+            return "pdm"
+
+        return "none"
+
+    @staticmethod
+    def is_poetry(source_dir: Path) -> bool:
+        """Check if project uses Poetry."""
+        pyproject = source_dir / "pyproject.toml"
+        if not pyproject.exists():
+            return False
+        try:
+            return "[tool.poetry]" in pyproject.read_text()
+        except Exception:
+            return False
+
+    @staticmethod
+    def is_pdm(source_dir: Path) -> bool:
+        """Check if project uses PDM."""
+        pyproject = source_dir / "pyproject.toml"
+        if not pyproject.exists():
+            return False
+        try:
+            return "[tool.pdm]" in pyproject.read_text()
+        except Exception:
+            return False