py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/buildcommands/builders/environment.py

@@ -0,0 +1,81 @@
+"""Environment detection and Python executable resolution utilities."""
+
+import os
+import subprocess
+from pathlib import Path
+
+from ....exceptions import CommandError
+from ....utils.logging import log_error, log_info
+from ....utils.platform_adapter import PlatformAdapter
+from ....utils.workspace_detector import WorkspaceDetector
+
+
+class EnvironmentDetector:
+    """Detect project environment and resolve Python executable paths."""
+
+    @staticmethod
+    def is_rust_enabled() -> bool:
+        """
+        Check if Rust is enabled for this project.
+
+        Returns:
+            bool: True if Rust is enabled, False otherwise.
+        """
+        rust_dir = os.path.join(os.getcwd(), "rust")
+        cargo_toml = os.path.join(rust_dir, "Cargo.toml")
+        return os.path.exists(cargo_toml)
+
+    @staticmethod
+    def _create_venv() -> None:
+        """Create virtual environment using uv."""
+        try:
+            # Use uv to create virtual environment
+            cmd = ["uv", "venv"]
+            subprocess.run(
+                cmd,
+                check=True,
+                capture_output=False,
+                text=True,
+            )
+            log_info("✓ Virtual environment created successfully")
+        except subprocess.CalledProcessError as e:
+            log_error(f"Failed to create virtual environment: {e}")
+            raise CommandError(f"Failed to create virtual environment: {e}")
+        except Exception as e:
+            log_error(f"Unexpected error creating virtual environment: {e}")
+            raise CommandError(f"Failed to create virtual environment: {e}")
+
+    def resolve_python_executable(self) -> tuple[str | None, bool]:
+        """
+        Resolve the appropriate Python executable for the current environment.
+
+        Returns:
+            tuple: (python_executable_path, is_workspace) where:
+                - python_executable_path: Path to Python executable or None
+                - is_workspace: True if running in a workspace environment
+        """
+        detector = WorkspaceDetector()
+        is_workspace = detector.detect(Path.cwd())
+
+        if not is_workspace:
+            log_info("Not in uv workspace environment")
+            return "python", False
+
+        log_info("✓ uv workspace environment detected")
+        venv_root = detector.get_venv_path(Path.cwd())
+
+        if venv_root is None:
+            try:
+                venv_str = detector.get_active_venv_path_str(Path.cwd())
+                venv_root = Path(venv_str)
+            except Exception:
+                venv_root = None
+
+        if venv_root is None:
+            log_info("No venv found, creating local .venv for build...")
+            self._create_venv()
+            venv_root = Path(".venv")
+
+        if PlatformAdapter.is_windows():
+            return str((venv_root / "Scripts" / "python.exe").resolve()), True
+        return str((venv_root / "bin" / "python").resolve()), True

wl_cli/commands/buildcommands/builders/rust_builder.py

@@ -0,0 +1,39 @@
+"""Rust build utilities using maturin."""
+
+import subprocess
+
+from ....utils.logging import log_info, log_info_pair
+from ....utils.subprocess import run_command
+
+
+class RustBuilder:
+    """Handle Rust build processes using maturin."""
+
+    @staticmethod
+    def run_maturin_build(python_executable: str | None) -> None:
+        """Run maturin build process."""
+        command = ["maturin", "build", "--release", "--out", "dist"]
+        if python_executable:
+            command.extend(["-i", python_executable])
+        log_info(f"Trying to build with: {' '.join(command)}")
+        subprocess.run(command, check=True, capture_output=False, text=True)
+
+    @staticmethod
+    def run_maturin_develop() -> None:
+        """Run maturin develop for incremental builds."""
+        log_info_pair(
+            "Using maturin develop to build and install editable package...",
+            "使用 maturin develop 构建和安装可编辑包...",
+        )
+        # 使用maturin的原生增量编译功能
+        run_command(["maturin", "develop", "--skip-install"], capture_output=False)
+
+    @staticmethod
+    def build_full(python_executable: str | None) -> None:
+        """Perform a full build with maturin."""
+        RustBuilder.run_maturin_build(python_executable)
+
+    @staticmethod
+    def build_incremental() -> None:
+        """Perform an incremental build with maturin develop."""
+        RustBuilder.run_maturin_develop()

wl_cli/commands/buildcommands/builders/stubs.py

@@ -0,0 +1,58 @@
+"""Type stubs generation and management utilities."""
+
+import os
+import shutil
+from pathlib import Path
+
+from ....commands.format.python_formatter import generate_type_stubs
+from ....utils.logging import log_error, log_info
+from ....utils.uv_tool import is_running_in_uv_tool
+
+
+class StubsManager:
+    """Manage type stubs generation and copying."""
+
+    @staticmethod
+    def generate_and_copy_stubs() -> None:
+        """Generate type stubs and copy them to the appropriate locations."""
+        try:
+            root = Path.cwd()
+            src_path = root / "src"
+            typings_path = root / "typings"
+
+            if not src_path.exists():
+                if not is_running_in_uv_tool():
+                    log_info(f"Target {src_path} does not exist, skipping...")
+                return
+
+            log_info(f"Generating type stubs for {src_path} -> {typings_path}")
+            generate_type_stubs(
+                str(src_path), str(typings_path), os.environ.copy(), quiet=False
+            )
+            log_info("✓ Type stubs generated")
+
+            package_root = src_path / "wl_cli"
+            stub_root = typings_path / "wl_cli"
+
+            if stub_root.exists():
+                for pyi in stub_root.rglob("*.pyi"):
+                    rel = pyi.relative_to(stub_root)
+                    dest = package_root / rel
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(pyi, dest)
+                log_info("✓ Type stubs copied into package source")
+            else:
+                for pyi in typings_path.rglob("*.pyi"):
+                    try:
+                        parts = list(pyi.parts)
+                        if "wl_cli" in parts:
+                            idx = parts.index("wl_cli")
+                            rel = Path(*parts[idx + 1 :])
+                            dest = package_root / rel
+                            dest.parent.mkdir(parents=True, exist_ok=True)
+                            shutil.copy2(pyi, dest)
+                    except Exception:
+                        continue
+
+        except Exception as e:
+            log_error(f"Failed to generate type stubs: {e}")

wl_cli/commands/buildcommands/dist.py

@@ -0,0 +1,326 @@
+"""Build dist command for WL Commands."""
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+import tomllib
+
+if TYPE_CHECKING:
+    from wl_cli.utils.workspace_detector.types import WorkspaceDetectionRules
+
+import click
+
+from ...exceptions import CommandError
+from ...utils.logging import log_error, log_info
+from ...utils.platform_adapter import PlatformAdapter
+from ...utils.uv_workspace import is_uv_workspace
+from ...utils.workspace_detector import WorkspaceDetectionError, WorkspaceDetector
+from .. import Command
+from ..format.python_formatter import generate_type_stubs
+
+
+class BuildDistCommand(Command):
+    """Command to build distribution packages."""
+
+    @property
+    def name(self) -> str:
+        """Return the command name."""
+        return "dist"
+
+    @property
+    def help(self) -> str:
+        """Return the command help text."""
+        return "Build distribution packages"
+
+    def execute(self, *_: Any, **kwargs: Any) -> None:
+        """Execute the build dist command."""
+        # Determine the platform and run the appropriate build command
+        created_venv = False  # Track if we created a new venv
+        try:
+            log_info("Building distribution packages...")
+            detector = WorkspaceDetector(self._build_rules(kwargs))
+            is_workspace = detector.detect(Path.cwd())
+            self._validate_workspace(detector, is_workspace, kwargs)
+            python_executable, created_venv = self._resolve_python_executable(
+                detector, is_workspace
+            )
+            self._generate_type_stubs()
+            self._run_build(python_executable)
+            self._cleanup_stubs()
+            self._cleanup_venv_if_needed(is_workspace, created_venv)
+            log_info("✓ Distribution packages built successfully")
+        except subprocess.CalledProcessError as e:
+            log_error(f"Failed to build distribution packages: {e}")
+            raise CommandError(f"Build dist failed with return code {e.returncode}")
+        except FileNotFoundError:
+            log_error(
+                "Build backend not found. Pure-Python projects need uv; Rust "
+                "projects need maturin. Ensure it is installed and in PATH."
+            )
+            raise CommandError("Build backend not found")
+        except WorkspaceDetectionError as e:
+            log_error(f"Workspace detection error: {e}")
+            raise CommandError(f"Build dist failed: {e}")
+        except Exception as e:
+            log_error(f"Unexpected error during build dist: {e}")
+            raise CommandError(f"Build dist failed: {e}")
+
+    def _detect_uv_workspace(self) -> bool:
+        """
+        Detect if we are in a uv workspace.
+        This is kept for backward compatibility with tests.
+
+        Returns:
+            bool: True if in a uv workspace, False otherwise.
+        """
+        return is_uv_workspace()
+
+    def _create_venv(self) -> None:
+        """Create virtual environment using uv."""
+        try:
+            # Use uv to create virtual environment
+            cmd = ["uv", "venv"]
+            subprocess.run(
+                cmd,
+                check=True,
+                capture_output=False,
+                text=True,
+            )
+            log_info("✓ Virtual environment created successfully")
+        except subprocess.CalledProcessError as e:
+            log_error(f"Failed to create virtual environment: {e}")
+            raise CommandError(f"Failed to create virtual environment: {e}")
+        except Exception as e:
+            log_error(f"Unexpected error creating virtual environment: {e}")
+            raise CommandError(f"Failed to create virtual environment: {e}")
+
+    def _build_rules(self, kwargs: dict[str, object]) -> "WorkspaceDetectionRules":
+        return cast(
+            "WorkspaceDetectionRules",
+            {
+                "uv_tree_min_roots": kwargs.get("ws_min_roots", 2),
+                "use_uv_tree": not kwargs.get("ws_disable_tree", False),
+                "use_uv_init": not kwargs.get("ws_disable_init", False),
+                "use_pyproject": not kwargs.get("ws_disable_pyproject", False),
+                "use_uv_lock": not kwargs.get("ws_disable_uv_lock", False),
+            },
+        )
+
+    def _validate_workspace(
+        self, detector: WorkspaceDetector, is_workspace: bool, kwargs: dict[str, object]
+    ) -> None:
+        validation = detector.validate(Path.cwd())
+        if not is_workspace and validation.details.get("pyproject.exists") == "True":
+            msg = "Detected pyproject but workspace detection failed; check tool.uv.workspace"
+            if kwargs.get("ws_strict", False):
+                log_error(msg)
+                raise CommandError(msg)
+            else:
+                log_info(f"Warning: {msg}")
+
+    def _resolve_python_executable(
+        self, detector: WorkspaceDetector, is_workspace: bool
+    ) -> tuple[str | None, bool]:
+        """Resolve Python executable and track if we created a new venv."""
+        if not is_workspace:
+            log_info("Not in uv workspace environment")
+            return None, False
+        log_info("✓ uv workspace environment detected")
+        venv_root = detector.get_venv_path(Path.cwd())
+        created_venv = False
+        if venv_root is None:
+            try:
+                venv_str = detector.getActiveVenvPath(Path.cwd())
+                venv_root = Path(venv_str)
+            except Exception:
+                venv_root = None
+        if venv_root is None:
+            log_info("No venv found, creating local .venv for build...")
+            self._create_venv()
+            venv_root = Path(".venv")
+            created_venv = True
+        if PlatformAdapter.is_windows():
+            return str((venv_root / "Scripts" / "python.exe").resolve()), created_venv
+        return str((venv_root / "bin" / "python").resolve()), created_venv
+
+    def _uses_maturin(self) -> bool:
+        """Return True when the project is a maturin/Rust distribution.
+
+        A pure-Python project (the normal case after #226) has neither a
+        maturin backend nor a ``rust/Cargo.toml``; it must build with
+        ``uv build`` and needs no Rust toolchain.
+        """
+        root = Path.cwd()
+        data: dict[str, Any] = {}
+        pyproject = root / "pyproject.toml"
+        if pyproject.exists():
+            try:
+                data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+            except (OSError, tomllib.TOMLDecodeError):
+                data = {}
+        build_system = data.get("build-system") or {}
+        backend = str(build_system.get("build-backend") or "").lower()
+        return "maturin" in backend or (root / "rust" / "Cargo.toml").exists()
+
+    def _run_build(self, python_executable: str | None) -> None:
+        """Build the distribution with the project's own backend.
+
+        Rust/maturin projects keep using maturin; everything else (including
+        ``wl`` itself) uses ``uv build``.
+        """
+        if self._uses_maturin():
+            command = ["maturin", "build", "--release", "--out", "dist"]
+            if python_executable:
+                command.extend(["-i", python_executable])
+        else:
+            command = ["uv", "build", "--out-dir", "dist"]
+            if python_executable:
+                command.extend(["--python", python_executable])
+        log_info(f"Trying to build with: {' '.join(command)}")
+        subprocess.run(command, check=True, capture_output=False, text=True)
+
+    def _generate_type_stubs(self) -> None:
+        root = Path.cwd()
+        src_path = root / "src"
+        typings_path = root / "typings"
+        env = os.environ.copy()
+        if not src_path.exists():
+            log_error(f"Source directory not found for stubs: {src_path}")
+            return
+        log_info(f"Generating type stubs for {src_path} -> {typings_path}")
+        try:
+            generate_type_stubs(str(src_path), str(typings_path), env, quiet=False)
+            log_info("✓ Type stubs generated")
+
+            # Copy generated .pyi into package src so they are included in wheel
+            package_root = src_path / "wl_cli"
+            stub_root = typings_path / "wl_cli"
+            if stub_root.exists():
+                for pyi in stub_root.rglob("*.pyi"):
+                    rel = pyi.relative_to(stub_root)
+                    dest = package_root / rel
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(pyi, dest)
+                log_info("✓ Type stubs copied into package source")
+            else:
+                # Fallback: copy all .pyi under typings preserving structure relative to src
+                for pyi in typings_path.rglob("*.pyi"):
+                    try:
+                        # attempt to find 'wl_cli' segment
+                        parts = list(pyi.parts)
+                        if "wl_cli" in parts:
+                            idx = parts.index("wl_cli")
+                            rel = Path(*parts[idx + 1 :])
+                            dest = package_root / rel
+                            dest.parent.mkdir(parents=True, exist_ok=True)
+                            shutil.copy2(pyi, dest)
+                    except Exception:
+                        continue
+        except Exception as e:
+            log_error(f"Failed to generate type stubs: {e}")
+
+    def _cleanup_stubs(self) -> None:
+        try:
+            root = Path.cwd()
+            typings_path = root / "typings"
+            if typings_path.exists():
+                shutil.rmtree(typings_path, ignore_errors=True)
+                log_info("✓ typings directory removed")
+            src_path = root / "src"
+            if src_path.exists():
+                removed = 0
+                for p in src_path.rglob("*.pyi"):
+                    try:
+                        p.unlink()
+                        removed += 1
+                    except Exception:
+                        pass
+                if removed:
+                    log_info(f"✓ Removed {removed} .pyi files from src")
+        except Exception as e:
+            log_error(f"Failed to cleanup stubs: {e}")
+
+    def _cleanup_venv_if_needed(self, is_workspace: bool, created_venv: bool) -> None:
+        """Clean up .venv directory if in uv workspace environment.
+
+        Args:
+            is_workspace: Whether we are in a uv workspace environment
+            created_venv: Whether we created a new venv during this build
+        """
+        if not is_workspace:
+            # In non-workspace environments, preserve the user's existing venv
+            return
+
+        venv_path = Path.cwd() / ".venv"
+        if venv_path.exists():
+            # Only remove .venv if we created it during this build
+            # Preserve user's existing venv if it was already there
+            if created_venv:
+                try:
+                    log_info(
+                        "Removing temporary .venv directory created during build..."
+                    )
+                    shutil.rmtree(venv_path, ignore_errors=True)
+                    log_info("✓ Temporary .venv directory removed")
+                except Exception as e:
+                    log_error(f"Failed to remove .venv directory: {e}")
+            else:
+                log_info(
+                    "Preserving existing .venv directory (not created during this build)"
+                )
+        else:
+            log_info("No .venv directory to remove")
+
+
+@click.command(name="builddist", help="Build distribution packages")
+@click.option(
+    "--ws-min-roots",
+    type=int,
+    default=2,
+    help="Minimum root packages to consider workspace (uv tree)",
+)
+@click.option(
+    "--ws-disable-tree", is_flag=True, default=False, help="Disable uv tree detection"
+)
+@click.option(
+    "--ws-disable-init", is_flag=True, default=False, help="Disable uv init detection"
+)
+@click.option(
+    "--ws-disable-pyproject",
+    is_flag=True,
+    default=False,
+    help="Disable pyproject workspace detection",
+)
+@click.option(
+    "--ws-disable-uv-lock",
+    is_flag=True,
+    default=False,
+    help="Disable uv.lock detection",
+)
+@click.option(
+    "--ws-strict",
+    is_flag=True,
+    default=False,
+    help="Fail build on abnormal workspace structure",
+)
+def builddist_command(
+    ws_min_roots,
+    ws_disable_tree,
+    ws_disable_init,
+    ws_disable_pyproject,
+    ws_disable_uv_lock,
+    ws_strict,
+):
+    """Build distribution packages."""
+    cmd = BuildDistCommand()
+    cmd.execute(
+        ws_min_roots=ws_min_roots,
+        ws_disable_tree=ws_disable_tree,
+        ws_disable_init=ws_disable_init,
+        ws_disable_pyproject=ws_disable_pyproject,
+        ws_disable_uv_lock=ws_disable_uv_lock,
+        ws_strict=ws_strict,
+    )

wl_cli/commands/buildcommands/test.py

@@ -0,0 +1,89 @@
+"""
+Test command for WL Commands.
+"""
+
+import subprocess
+import sys
+from typing import Any
+
+import click
+
+from ...exceptions import CommandError
+from ...utils.logging import log_error, log_info
+from ...utils.output_context import get_output_config
+from ...utils.subprocess import run_command
+from .. import Command
+
+
+class BuildTestCommand(Command):
+    """Command to build test environment and run unit tests."""
+
+    @property
+    def name(self) -> str:
+        """Return the command name."""
+        return "test"
+
+    @property
+    def help(self) -> str:
+        """Return the command help text."""
+        return "Build test environment and run unit tests"
+
+    def execute(self, *_: Any, **kwargs: Any) -> None:
+        """Execute the build test command."""
+        # Get output configuration
+        quiet = kwargs.get("quiet", False)
+        verbose = kwargs.get("verbose", False)
+        config = get_output_config(override_quiet=quiet, override_verbose=verbose)
+        concise = config.concise_mode
+
+        # Run tests using Python's unittest module directly
+        try:
+            if not concise:
+                log_info("Building test environment and running tests...")
+
+            # Use -v for verbose output when not concise
+            if config.verbose:
+                cmd = [
+                    sys.executable,
+                    "-m",
+                    "unittest",
+                    "discover",
+                    "-s",
+                    "tests",
+                    "-v",
+                ]
+            else:
+                cmd = [sys.executable, "-m", "unittest", "discover", "-s", "tests"]
+
+            # Run tests using python -m unittest discover
+            run_command(
+                cmd,
+                capture_output=False,
+            )
+
+            if not concise:
+                log_info("✓ Tests completed successfully")
+
+        except subprocess.CalledProcessError as e:
+            log_error(f"Failed to run tests: {e}")
+
+            raise CommandError(f"Test failed with return code {e.returncode}")
+        except FileNotFoundError:
+            log_error("Python interpreter not found.")
+
+            raise CommandError("Python interpreter not found")
+        except Exception as e:
+            log_error(f"Unexpected error during test execution: {e}")
+
+            raise CommandError(f"Test failed: {e}")
+
+
+@click.command(name="buildtest", help="Build test environment and run unit tests")
+@click.option(
+    "-q", "--quiet", is_flag=True, help="Suppress verbose output (concise mode)"
+)
+@click.option("-v", "--verbose", is_flag=True, help="Force verbose output")
+def buildtest_command(quiet: bool, verbose: bool) -> None:
+    """Build test environment and run unit tests."""
+    cmd = BuildTestCommand()
+    cmd.execute(quiet=quiet, verbose=verbose)

wl_cli/commands/clean/__init__.py

@@ -0,0 +1 @@
+"""Clean command module."""