py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/test_utils/test_filter.py

@@ -0,0 +1,36 @@
+"""Test filter for managing which test files to skip."""
+
+from typing import cast
+
+
+class TestFilter:
+    """Filter for test files to skip during test runs."""
+
+    def __init__(self):
+        """Initialize the test filter."""
+        self._excludes: list[str] = self._load_excludes()
+
+    def _load_excludes(self) -> list[str]:
+        """Load the list of test files to exclude from configuration."""
+        from ...utils.config import get_config
+
+        excludes = get_config("test_excludes", [])
+        return cast("list[str]", excludes)
+
+    def _get_default_excludes(self) -> list[str]:
+        """Get the default list of test files to exclude."""
+        return []
+
+    def get_excludes(self) -> list[str]:
+        """Get the list of test files to exclude."""
+        return self._excludes
+
+    def add_exclude(self, test_file: str) -> None:
+        """Add a test file to the exclusion list."""
+        if test_file not in self._excludes:
+            self._excludes.append(test_file)
+
+    def remove_exclude(self, test_file: str) -> None:
+        """Remove a test file from the exclusion list."""
+        if test_file in self._excludes:
+            self._excludes.remove(test_file)

wl_cli/utils/uv_run.py

@@ -0,0 +1,79 @@
+"""The ``uv run`` launcher fallback, shared by its callers (#165).
+
+``uv run <tool>`` has one failure mode that says nothing about ``<tool>``:
+``uv`` itself could not be started, so the child never ran. Callers recover by
+re-running the child directly. The rule lives here -- in ``utils`` -- so that
+``utils/pre_commit.py`` can share it with the formatters without importing a
+formatter back out of ``commands``.
+"""
+
+from pathlib import Path
+
+from .subprocess_utils import SubprocessExecutor, SubprocessResult
+
+
+def uv_unavailable(result: SubprocessResult) -> bool:
+    """Whether the ``uv`` launcher never got as far as running its child.
+
+    Deliberately **not** a substring sniff of ``result.stderr``. The old test
+    read ``"not found" in stderr and "uv" in stderr``, which fires on any *child*
+    that quotes the command line back -- ``uv run: ruff: not found`` is uv
+    working perfectly and ruff missing, yet it sent the tool re-running outside
+    its environment. What actually means "the launcher was not there" is
+    :attr:`SubprocessResult.launch_error`, the field set only when the
+    executable could not be started at all (#100). ``127`` is kept as a
+    belt-and-braces spelling of a shell's "command not found", which an executor
+    without ``shell=True`` never produces itself.
+
+    The same discriminator, under the ``Ruff`` name, guards the dead-code
+    detector and fixer (#150/#153) -- see ``DeadCodeFixer._ruff_unavailable``
+    for why those copies stay spelled out (#155 M2).
+
+    Args:
+        result: The finished subprocess result.
+
+    Returns:
+        True when the process never ran.
+    """
+    if result.launch_error is not None:
+        return True
+    return result.returncode == 127
+
+
+def run_uv_command(
+    executor: SubprocessExecutor,
+    command: list[str],
+    *,
+    env: dict[str, str] | None = None,
+    cwd: Path | None = None,
+    quiet: bool = False,
+) -> SubprocessResult:
+    """Run ``command``, retrying it without its ``uv run`` prefix if uv is absent.
+
+    The executor is passed in rather than built here: each caller keeps its own
+    patch point and its own environment preparation (the formatters prepare one
+    per command; the pre-commit run prepares one per run).
+
+    Args:
+        executor: The executor that runs both attempts.
+        command: The command, optionally led by ``uv run``.
+        env: Environment for the child.
+        cwd: Working directory for the child.
+        quiet: Whether to capture the child's output.
+
+    Returns:
+        The result of the direct re-run when the launcher was unavailable and
+        the re-run did not itself raise; otherwise the original result.
+    """
+    result = executor.run(command, env=env, cwd=cwd, quiet=quiet)
+    if (
+        len(command) >= 2
+        and command[0] == "uv"
+        and command[1] == "run"
+        and uv_unavailable(result)
+    ):
+        try:
+            return executor.run(command[2:], env=env, cwd=cwd, quiet=quiet)
+        except Exception:
+            pass
+    return result

wl_cli/utils/uv_tool.py

@@ -0,0 +1,117 @@
+"""UV Tool environment utilities for WL Commands."""
+
+import os
+from pathlib import Path
+
+
+def is_running_in_uv_tool() -> bool:
+    """Check if we are running in a UV Tool environment.
+
+    Returns:
+        bool: True if running in UV Tool environment, False otherwise.
+    """
+    return "UV_TOOL_DIR" in os.environ or "UV_PYTHON" in os.environ
+
+
+def get_uv_tool_python_path() -> str | None:
+    """Get the Python executable path from UV Tool environment.
+
+    Returns:
+        Optional[str]: Python executable path if in UV Tool environment, None otherwise.
+    """
+    if "UV_PYTHON" in os.environ:
+        return os.environ["UV_PYTHON"]
+
+    if "UV_TOOL_DIR" in os.environ:
+        # Try to find python executable in UV tool directory
+        uv_tool_dir = Path(os.environ["UV_TOOL_DIR"])
+
+        # First, try to get Python executable from sys.executable
+        import sys
+
+        if sys.executable:
+            return sys.executable
+
+        # If sys.executable is not available, try common locations
+        # Try parent directory of UV_TOOL_DIR
+        python_executable = uv_tool_dir.parent.parent / "python"
+        if python_executable.exists():
+            return str(python_executable)
+
+        # Try Windows-specific path
+        python_executable = uv_tool_dir.parent.parent / "python.exe"
+        if python_executable.exists():
+            return str(python_executable)
+
+        # Try to find python in PATH
+        import shutil
+
+        python_path = shutil.which("python")
+        if python_path:
+            return python_path
+
+    return None
+
+
+def get_uv_tool_bin_path() -> Path | None:
+    """Get the bin directory path from UV Tool environment.
+
+    Returns:
+        Optional[Path]: Bin directory path if in UV Tool environment, None otherwise.
+    """
+    if "UV_TOOL_DIR" in os.environ:
+        uv_tool_dir = Path(os.environ["UV_TOOL_DIR"])
+        return uv_tool_dir
+
+    return None
+
+
+def get_uv_tool_env() -> dict[str, str]:
+    """Get environment variables for UV Tool environment.
+
+    Returns:
+        dict[str, str]: Environment variables for UV Tool environment.
+    """
+    env = os.environ.copy()
+
+    # Add UV Tool bin directory to PATH if not already present
+    uv_tool_bin = get_uv_tool_bin_path()
+    if uv_tool_bin:
+        path = env.get("PATH", "")
+        if str(uv_tool_bin) not in path:
+            env["PATH"] = f"{uv_tool_bin}{os.pathsep}{path}"
+
+    return env
+
+
+def should_use_direct_execution(command: list[str]) -> bool:
+    """Check if a command should be executed directly in UV Tool environment.
+
+    Args:
+        command: Command to check.
+
+    Returns:
+        bool: True if command should be executed directly, False otherwise.
+    """
+    if not is_running_in_uv_tool():
+        return False
+
+    # Check if it's an 'uv run' command
+    if len(command) >= 2 and command[0] == "uv" and command[1] == "run":
+        return True
+
+    return False
+
+
+def get_direct_command(command: list[str]) -> list[str]:
+    """Get the direct command by removing 'uv run' prefix.
+
+    Args:
+        command: Original command with 'uv run' prefix.
+
+    Returns:
+        list[str]: Command without 'uv run' prefix.
+    """
+    if len(command) >= 2 and command[0] == "uv" and command[1] == "run":
+        return command[2:]
+    return command

wl_cli/utils/uv_tree.py

@@ -0,0 +1,71 @@
+"""Shared parsing of ``uv tree`` output.
+
+``uv tree`` prints one root row per workspace member, normally as
+``<name> v<version>``, followed by indented dependency rows drawn with box
+characters. Two detectors used to parse that output by hand with slightly
+different heuristics, so a root package whose name begins with ``v`` --
+``vite-app``, ``vue-lib``, ``virtualenv-*`` -- got two different wrong answers
+(#178). This module owns the one parser; both entry points delegate here.
+"""
+
+#: Leading characters of a dependency row in ``uv tree`` output.
+_TREE_PREFIXES: tuple[str, ...] = ("├", "└", "│", "─", "┌", "┐", "┬", "┴", "┼")
+
+
+def is_valid_version(version: str) -> bool:
+    """检查版本字符串是否有效。"""
+    if not version:
+        return False
+    return all(c.isalnum() or c in ".-+" for c in version)
+
+
+def _is_version_only_line(line: str) -> bool:
+    """判断整行是否只是版本号（如 ``v1.2.3``）。
+
+    ``uv tree`` 不会把裸版本号输出为根行，但旧解析器会把它们排除，这里保留该
+    约定。判定要求 ``v`` 前缀且后接数字，因此 ``vite-app`` 这类真实包名仍然
+    会被当作根包。
+    """
+    if not line.startswith(("v", "V")):
+        return False
+    candidate = line[1:]
+    return candidate[:1].isdigit() and is_valid_version(candidate)
+
+
+def _is_root_row(line: str) -> bool:
+    """判断一行是否可能是根包行（已去掉行尾空白）。"""
+    if not line or line[0].isspace():
+        return False
+    if line.startswith(_TREE_PREFIXES):
+        return False
+    return not (line.startswith("Resolved") or line.startswith("(*)"))
+
+
+def parse_uv_tree_roots(output: str | list[str]) -> list[str]:
+    """从 ``uv tree`` 输出中解析根包名。
+
+    Args:
+        output: ``uv tree`` 的原始输出，或其按行拆分后的列表。
+
+    Returns:
+        按输出顺序排列的根包名。``<name> v<version>`` 行贡献 ``name``；``" v"``
+        之后的部分必须形如版本（数字开头且通过 :func:`is_valid_version`），
+        因此名字里含 ``" v"`` 的包不会被静默截断。
+    """
+    lines = output.splitlines() if isinstance(output, str) else output
+    roots: list[str] = []
+    for raw in lines:
+        stripped = raw.rstrip()
+        if not _is_root_row(stripped):
+            continue
+        line = stripped.strip()
+        parts = line.rsplit(" v", 1)
+        if len(parts) == 2:
+            name, version = parts[0].strip(), parts[1].strip()
+            if name and version[:1].isdigit() and is_valid_version(version):
+                roots.append(name)
+            continue
+        if _is_version_only_line(line):
+            continue
+        roots.append(line)
+    return roots

wl_cli/utils/uv_workspace.py

@@ -0,0 +1,174 @@
+"""UV workspace detection utilities for WL Commands."""
+
+import subprocess
+from pathlib import Path
+
+from .logging import log_info
+from .subprocess_utils import SubprocessExecutor
+from .uv_tree import is_valid_version, parse_uv_tree_roots
+from .workspace_detector.detection_strategies import UV_PROBE_TIMEOUT_SECONDS
+
+
+class UVWorkspaceDetector:
+    """A utility class for detecting UV workspaces."""
+
+    def __init__(self):
+        self._subprocess_executor = SubprocessExecutor()
+        self._workspace_cache: dict[str, bool] = {}
+
+    def is_workspace(self, project_root: Path | None = None) -> bool:
+        """
+        Detect if we are in a uv workspace.
+
+        Args:
+            project_root: The project root directory. If None, uses current directory.
+
+        Returns:
+            True if in a workspace, False otherwise.
+        """
+        try:
+            if project_root is None:
+                project_root = Path.cwd()
+
+            project_root = project_root.resolve()
+            root_str = str(project_root)
+
+            # Check cache first
+            if root_str in self._workspace_cache:
+                return self._workspace_cache[root_str]
+
+            # Method 1: Check for uv.lock file which indicates a workspace
+            uv_lock_path = project_root / "uv.lock"
+            if uv_lock_path.exists() and uv_lock_path.is_file():
+                log_info("Debug: uv.lock file found, workspace detected")
+                self._workspace_cache[root_str] = True
+                return True
+
+            # Method 2: Use uv init command to check if we're already in a workspace
+            try:
+                # A wedged uv must read as "not detected", not as an
+                # infinite wait -- same bound as WorkspaceDetector (#184).
+                result = self._subprocess_executor.run(
+                    ["uv", "init", "--dry-run"],
+                    cwd=project_root,
+                    quiet=True,
+                    timeout=UV_PROBE_TIMEOUT_SECONDS,
+                )
+
+                if (
+                    result.success
+                    and "is already a member of workspace" in result.stderr
+                ):
+                    log_info("Debug: 'is already a member of workspace' detected")
+                    self._workspace_cache[root_str] = True
+                    return True
+            except (subprocess.SubprocessError, OSError, ValueError):
+                # Fall back to other methods if uv init fails
+                pass
+
+            # Method 3: Use uv tree command to check for multiple root packages
+            is_workspace_result = self._detect_workspace_via_tree(project_root)
+            self._workspace_cache[root_str] = is_workspace_result
+            return is_workspace_result
+
+        except (OSError, ValueError) as e:
+            log_info(f"Debug: Workspace detection error: {e}")
+            # Cache the result even for errors to avoid repeated failures
+            # Use a default key if root_str is not defined
+            cache_key = root_str if "root_str" in locals() else "error_default"
+            self._workspace_cache[cache_key] = False
+            return False
+
+    def _detect_workspace_via_tree(self, project_root: Path) -> bool:
+        """
+        Detect workspace using uv tree command.
+
+        Args:
+            project_root: The project root directory.
+
+        Returns:
+            True if workspace detected, False otherwise.
+        """
+        try:
+            result = self._subprocess_executor.run(
+                ["uv", "tree"],
+                cwd=project_root,
+                quiet=True,
+                timeout=UV_PROBE_TIMEOUT_SECONDS,
+            )
+
+            if not result.success:
+                log_info(f"Debug: uv tree command failed with code {result.returncode}")
+                return False
+
+            # Check for a workspace by counting root packages
+            # In a workspace, there would be multiple top-level packages
+            lines = result.stdout.split("\n") if result.stdout else []
+            root_packages = self._parse_root_packages(lines)
+
+            log_info(f"Debug: uv tree root packages: {root_packages}")
+            log_info(f"Debug: root packages count: {len(root_packages)}")
+
+            # There should be more than one root package in a workspace
+            if len(root_packages) > 1:
+                log_info("Debug: Multiple root packages found, workspace detected")
+                return True
+
+        except (subprocess.SubprocessError, OSError, ValueError) as e:
+            log_info(f"Debug: Workspace detection via tree error: {e}")
+            pass  # Ignore errors in workspace detection
+
+        log_info("Debug: No workspace detected via tree")
+        return False
+
+    def _parse_root_packages(self, lines: list[str]) -> list[str]:
+        """
+        Parse root packages from uv tree output.
+
+        Delegates to the shared parser so both detectors agree (#178).
+
+        Args:
+            lines: Lines from uv tree output.
+
+        Returns:
+            List of root package names.
+        """
+        return parse_uv_tree_roots(lines)
+
+    def _is_valid_version(self, version: str) -> bool:
+        """
+        Check if a version string is valid.
+
+        Args:
+            version: Version string to check.
+
+        Returns:
+            True if valid, False otherwise.
+        """
+        return is_valid_version(version)
+
+    def clear_cache(self) -> None:
+        """Clear the workspace detection cache."""
+        self._workspace_cache.clear()
+
+
+# Global instance
+_uv_workspace_detector = UVWorkspaceDetector()
+
+
+def is_uv_workspace(project_root: Path | None = None) -> bool:
+    """
+    Detect if we are in a uv workspace.
+
+    Args:
+        project_root: The project root directory. If None, uses current directory.
+
+    Returns:
+        True if in a workspace, False otherwise.
+    """
+    return _uv_workspace_detector.is_workspace(project_root)
+
+
+def clear_uv_workspace_cache() -> None:
+    """Clear the UV workspace detection cache."""
+    _uv_workspace_detector.clear_cache()

wl_cli/utils/version/__init__.py

@@ -0,0 +1,15 @@
+"""Version management service."""
+
+from .pypi_version_checker import PyPIVersionChecker
+from .version_comparator import VersionComparator
+from .version_detectors import VersionDetector
+from .version_service import VersionService
+from .version_updater import VersionUpdater
+
+__all__ = [
+    "VersionService",
+    "VersionComparator",
+    "VersionDetector",
+    "VersionUpdater",
+    "PyPIVersionChecker",
+]

wl_cli/utils/version/pypi_version_checker.py

@@ -0,0 +1,95 @@
+"""
+PyPI version checking utilities for publish command.
+"""
+
+import asyncio
+import json
+from typing import cast
+from urllib import request
+from urllib.error import URLError
+
+from ...exceptions import CommandError
+from ..logging import log_info_pair
+
+
+class PyPIVersionChecker:
+    """Check versions against PyPI servers."""
+
+    def _get_pypi_version(self) -> str | None:
+        """Get the latest version from PyPI."""
+        package_name = "py_wlcli"
+        try:
+            url = f"https://pypi.org/pypi/{package_name}/json"
+            with request.urlopen(url) as response:
+                data = json.loads(response.read())
+            return cast("str | None", data["info"]["version"])
+        except (OSError, json.JSONDecodeError, KeyError, URLError):
+            # If we can't get the PyPI version, return None
+            return None
+
+    async def _get_pypi_version_async(self) -> str | None:
+        """Async get the latest version from PyPI."""
+        return await asyncio.to_thread(self._get_pypi_version)
+
+    def check_version_with_pypi(
+        self, repository: str, current_version: str, comparator
+    ) -> None:
+        """Check the current version against PyPI to ensure proper versioning."""
+        package_name = "py_wlcli"  # This should ideally be read from project config
+
+        try:
+            # Determine the repository URL
+            if repository == "pypi":
+                url = f"https://pypi.org/pypi/{package_name}/json"
+            else:
+                # For other repositories, we might need to get the URL from twine config
+                # For now, we'll assume it's TestPyPI
+                url = f"https://test.pypi.org/pypi/{package_name}/json"
+
+            log_info_pair(
+                f"Checking version on {repository} server...",
+                f"正在检查 {repository} 服务器上的版本...",
+            )
+
+            # Make request to PyPI API
+            with request.urlopen(url) as response:
+                data = json.loads(response.read())
+
+            # Get the latest version from PyPI
+            pypi_version = data["info"]["version"]
+            log_info_pair(
+                f"Latest version on {repository}: {pypi_version}",
+                f"{repository} 上的最新版本: {pypi_version}",
+            )
+
+            # Compare versions
+            if not comparator.is_version_increment_valid(pypi_version, current_version):
+                raise CommandError(
+                    f"Version check failed: Local version {current_version} "
+                    f"is not a valid increment from PyPI version {pypi_version}. "
+                    f"Version must be incremented and not skip numbers."
+                )
+
+            log_info_pair(
+                "✓ Version check passed",
+                "✓ 版本检查通过",
+            )
+
+        except URLError as e:
+            log_info_pair(
+                f"Warning: Could not check version on PyPI: {e}",
+                f"警告: 无法检查 PyPI 上的版本: {e}",
+            )
+        except (json.JSONDecodeError, KeyError) as e:
+            log_info_pair(
+                f"Warning: Version check failed: {e}",
+                f"警告: 版本检查失败: {e}",
+            )
+
+    async def check_version_with_pypi_async(
+        self, repository: str, current_version: str, comparator
+    ) -> None:
+        """Async check the current version against PyPI to ensure proper versioning."""
+        return await asyncio.to_thread(
+            self.check_version_with_pypi, repository, current_version, comparator
+        )