py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/workspace_detector/__init__.py

@@ -0,0 +1,28 @@
+from .core import WorkspaceDetector
+from .detection_strategies import (
+    check_init_workspace,
+    check_pyproject_workspace,
+    check_tree_workspace,
+    check_uv_lock_workspace,
+    is_valid_version,
+    parse_root_packages,
+)
+from .exceptions import WorkspaceDetectionError
+from .types import ValidationResult, WorkspaceDetectionRules
+from .venv_resolver import get_active_venv_path, get_active_venv_path_str, get_venv_path
+
+__all__ = [
+    "WorkspaceDetectionError",
+    "WorkspaceDetectionRules",
+    "ValidationResult",
+    "WorkspaceDetector",
+    "check_pyproject_workspace",
+    "check_uv_lock_workspace",
+    "check_init_workspace",
+    "check_tree_workspace",
+    "parse_root_packages",
+    "is_valid_version",
+    "get_venv_path",
+    "get_active_venv_path_str",
+    "get_active_venv_path",
+]

wl_cli/utils/workspace_detector/core.py

@@ -0,0 +1,161 @@
+from pathlib import Path
+
+from ..subprocess_utils import SubprocessExecutor
+from .detection_strategies import (
+    check_init_workspace,
+    check_pyproject_workspace,
+    check_tree_workspace,
+    check_uv_lock_workspace,
+)
+from .types import ValidationResult, WorkspaceDetectionRules
+from .venv_resolver import get_active_venv_path_str, get_venv_path
+
+
+class WorkspaceDetector:
+    def __init__(self, rules: WorkspaceDetectionRules | None = None) -> None:
+        self._executor = SubprocessExecutor()
+        self._cache: dict[str, bool] = {}
+        self._rules: WorkspaceDetectionRules = {
+            "use_pyproject": True,
+            "use_uv_lock": True,
+            "use_uv_init": True,
+            "use_uv_tree": True,
+            "uv_tree_min_roots": 2,
+        }
+        if rules:
+            self._rules.update(rules)
+
+    def detect(self, project_root: Path | None = None) -> bool:
+        """Whether ``project_root`` looks like a uv workspace.
+
+        Worst case is bounded: the file checks are local I/O, and the two
+        ``uv`` probes each carry ``UV_PROBE_TIMEOUT_SECONDS``, so a wedged
+        ``uv`` costs at most ``2 x`` that value (30 s) before detection
+        answers ``False`` -- never an unbounded wait (#184). The strategies
+        keep their order; the bound is the probes', not a skipped probe's.
+        """
+        start = (project_root or Path(self._rules.get("cwd", "."))).resolve()
+        key = str(start)
+        if key in self._cache:
+            return self._cache[key]
+
+        try:
+            root = self._find_workspace_root(start)
+
+            if self._rules.get("use_pyproject", True) and check_pyproject_workspace(
+                root
+            ):
+                self._cache[key] = True
+                return True
+
+            if self._rules.get("use_uv_lock", True) and check_uv_lock_workspace(root):
+                self._cache[key] = True
+                return True
+
+            if self._rules.get("use_uv_init", True) and check_init_workspace(
+                root, self._executor
+            ):
+                self._cache[key] = True
+                return True
+
+            min_roots = int(self._rules.get("uv_tree_min_roots", 2))
+            if self._rules.get("use_uv_tree", True) and check_tree_workspace(
+                root, self._executor, min_roots
+            ):
+                self._cache[key] = True
+                return True
+
+            self._cache[key] = False
+            return False
+        except Exception:
+            self._cache[key] = False
+            return False
+
+    def validate(self, project_root: Path | None = None) -> ValidationResult:
+        root = self._find_workspace_root(
+            (project_root or Path(self._rules.get("cwd", "."))).resolve()
+        )
+        detected = self.detect(root)
+        details: dict[str, str] = {}
+        pyproject_path = root / "pyproject.toml"
+        uv_lock_path = root / "uv.lock"
+        details["pyproject.exists"] = str(pyproject_path.exists())
+        details["uv.lock.exists"] = str(uv_lock_path.exists())
+        details["apps.exists"] = str((root / "apps").exists())
+        details["packages.exists"] = str((root / "packages").exists())
+        return ValidationResult(valid=detected, details=details)
+
+    def get_config(self) -> WorkspaceDetectionRules:
+        return self._rules.copy()
+
+    def resolve_path(self, path: str | Path, project_root: Path | None = None) -> Path:
+        root = self._find_workspace_root(
+            (project_root or Path(self._rules.get("cwd", "."))).resolve()
+        )
+        p = Path(path)
+        if p.is_absolute():
+            return p
+        resolved = (root / p).resolve()
+        return resolved
+
+    def get_venv_path(self, project_root: Path | None = None) -> Path | None:
+        root = self._find_workspace_root(
+            (project_root or Path(self._rules.get("cwd", "."))).resolve()
+        )
+        return get_venv_path(root, self._executor)
+
+    def get_active_venv_path_str(self, project_root: Path | None = None) -> str:
+        root = self._find_workspace_root(
+            (project_root or Path(self._rules.get("cwd", "."))).resolve()
+        )
+        return get_active_venv_path_str(root)
+
+    def getActiveVenvPath(self, project_root: Path | None = None) -> str:
+        """
+        Alias for get_active_venv_path_str to support backward compatibility.
+
+        This method uses camelCase naming for backward compatibility.
+        """
+        return self.get_active_venv_path_str(project_root)
+
+    def _find_workspace_root(self, start: Path) -> Path:
+        cur = start
+        try:
+            while True:
+                if self._rules.get("use_pyproject", True) and check_pyproject_workspace(
+                    cur
+                ):
+                    return cur
+                if self._rules.get("use_uv_lock", True) and check_uv_lock_workspace(
+                    cur
+                ):
+                    return cur
+                if cur.parent == cur:
+                    return start
+                cur = cur.parent
+        except Exception:
+            return start
+
+    def getConfig(self) -> WorkspaceDetectionRules:
+        """
+        Alias for get_config to support backward compatibility.
+
+        This method uses camelCase naming for backward compatibility.
+        """
+        return self.get_config()
+
+    def resolvePath(self, path: str | Path, project_root: Path | None = None) -> Path:
+        """
+        Alias for resolve_path to support backward compatibility.
+
+        This method uses camelCase naming for backward compatibility.
+        """
+        return self.resolve_path(path, project_root)
+
+    def getVenvPath(self, project_root: Path | None = None) -> Path | None:
+        """
+        Alias for get_venv_path to support backward compatibility.
+
+        This method uses camelCase naming for backward compatibility.
+        """
+        return self.get_venv_path(project_root)

wl_cli/utils/workspace_detector/detection_strategies.py

@@ -0,0 +1,107 @@
+from pathlib import Path
+
+from ..logging import log_warning_pair
+from ..subprocess_utils import SubprocessExecutor, SubprocessResult
+from ..uv_tree import is_valid_version as _is_valid_version
+from ..uv_tree import parse_uv_tree_roots
+
+#: Upper bound, in seconds, for the two ``uv`` *probes* behind this detector
+#: (``uv init --dry-run`` and ``uv tree``). Both are heuristics that normally
+#: answer in milliseconds, but on a runner whose ``uv`` blocks on a network
+#: fetch or on its cache lock they can hang forever -- three MRs silently hung
+#: >10 minutes on exactly this path (#184). Expiry is treated as "not
+#: detected", which costs a caller nothing it could have relied on, while an
+#: unbounded probe costs the whole ``wl test`` / ``wl init`` / ``wl build`` run.
+#: Only quick probes get a deadline: production commands stay unbounded.
+#: ``detect()`` can run both probes, so its worst case is ``2 x`` this
+#: value (30 s). The strategies keep their order -- the bound belongs to the
+#: probes, not to skipping one.
+UV_PROBE_TIMEOUT_SECONDS: float = 15.0
+
+
+def check_pyproject_workspace(root: Path) -> bool:
+    """检查pyproject.toml中是否包含workspace配置。"""
+    py = root / "pyproject.toml"
+    if not py.exists():
+        return False
+    try:
+        content = py.read_text(encoding="utf-8")
+        return "[tool.uv.workspace]" in content or "tool.uv.workspace" in content
+    except Exception:
+        return False
+
+
+def check_uv_lock_workspace(root: Path) -> bool:
+    """检查uv.lock文件是否包含足够多的包。"""
+    lock = root / "uv.lock"
+    if not lock.exists():
+        return False
+    try:
+        content = lock.read_text(encoding="utf-8")
+        count = content.count("[package]")
+        return count >= 5
+    except Exception:
+        return False
+
+
+def check_init_workspace(root: Path, executor: SubprocessExecutor) -> bool:
+    """使用uv init --dry-run检查是否已在工作区中。"""
+    try:
+        result = executor.run(
+            ["uv", "init", "--dry-run"],
+            cwd=root,
+            quiet=True,
+            cache_result=True,
+            timeout=UV_PROBE_TIMEOUT_SECONDS,
+        )
+        _warn_if_probe_timed_out("uv init --dry-run", root, result)
+        output = (result.stdout or "") + (result.stderr or "")
+        return result.success and ("is already a member of workspace" in output)
+    except Exception:
+        return False
+
+
+def check_tree_workspace(
+    root: Path, executor: SubprocessExecutor, min_roots: int = 2
+) -> bool:
+    """使用uv tree检查根包数量是否达到最小值。"""
+    try:
+        result = executor.run(
+            ["uv", "tree"],
+            cwd=root,
+            quiet=True,
+            cache_result=True,
+            timeout=UV_PROBE_TIMEOUT_SECONDS,
+        )
+        _warn_if_probe_timed_out("uv tree", root, result)
+        if not result.success or not result.stdout:
+            return False
+        lines = result.stdout.split("\n")
+        roots = parse_root_packages(lines)
+        return len(roots) >= min_roots
+    except Exception:
+        return False
+
+
+def _warn_if_probe_timed_out(probe: str, root: Path, result: SubprocessResult) -> None:
+    """让「探测超时」可见：否则它和「确实不是工作区」在调用方眼里一模一样。"""
+    if not result.timed_out:
+        return
+    # Language-neutral payload (a command and a path): both variants are
+    # identical by design.
+    log_warning_pair(
+        f"{probe} did not answer within {UV_PROBE_TIMEOUT_SECONDS:g}s in {root}; "
+        "treating the workspace probe as not detected",
+        f"{probe} 在 {root} 未于 {UV_PROBE_TIMEOUT_SECONDS:g} 秒内返回；"
+        "按未探测到工作区处理",
+    )
+
+
+def parse_root_packages(lines: list[str]) -> list[str]:
+    """从uv tree输出中解析根包（委派到共享解析器，见 #178）。"""
+    return parse_uv_tree_roots(lines)
+
+
+def is_valid_version(version: str) -> bool:
+    """检查版本字符串是否有效（委派到共享解析器，字符集不变）。"""
+    return _is_valid_version(version)

wl_cli/utils/workspace_detector/exceptions.py

@@ -0,0 +1,5 @@
+class WorkspaceDetectionError(Exception):
+    """工作区检测错误异常。"""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

wl_cli/utils/workspace_detector/types.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import TypedDict
+
+
+class WorkspaceDetectionRules(TypedDict, total=False):
+    use_pyproject: bool
+    use_uv_lock: bool
+    use_uv_init: bool
+    use_uv_tree: bool
+    uv_tree_min_roots: int
+    cwd: str
+
+
+@dataclass
+class ValidationResult:
+    valid: bool
+    details: dict[str, str]

wl_cli/utils/workspace_detector/venv_resolver.py

@@ -0,0 +1,84 @@
+import os
+from pathlib import Path
+
+from ..logging import log_error, log_info
+from ..subprocess_utils import SubprocessExecutor
+from .exceptions import WorkspaceDetectionError
+
+
+def get_venv_path(root: Path, executor: SubprocessExecutor) -> Path | None:
+    """获取虚拟环境路径。"""
+    env_path = os.environ.get("VENV_PATH")
+    if env_path:
+        p = Path(env_path)
+        if p.exists():
+            return p.resolve()
+    local = root / ".venv"
+    if local.exists():
+        return local.resolve()
+    try:
+        res = executor.run(
+            [
+                "uv",
+                "run",
+                "python",
+                "-c",
+                "import sys;print(sys.executable)",
+            ],
+            cwd=root,
+            quiet=True,
+        )
+        if res.success and res.stdout:
+            exe = Path(res.stdout.strip())
+            parent = exe.parent
+            venv_dir = parent.parent
+            if venv_dir.exists():
+                return venv_dir.resolve()
+    except Exception:
+        return None
+    return None
+
+
+def get_active_venv_path_str(root: Path) -> str:
+    """获取当前激活的虚拟环境路径。"""
+    log_info(f"Workspace venv path resolution at: {root}")
+
+    # 检查工作区配置
+    py = root / "pyproject.toml"
+    uv_toml = root / "uv.toml"
+    ws_json = root / "workspace.json"
+    has_ws_conf = False
+    try:
+        if py.exists() and "tool.uv.workspace" in py.read_text(encoding="utf-8"):
+            has_ws_conf = True
+        if uv_toml.exists() or ws_json.exists():
+            has_ws_conf = True
+    except Exception:
+        pass
+    if not has_ws_conf:
+        log_error("Workspace configuration file not found or invalid")
+        raise WorkspaceDetectionError("Workspace configuration not found or invalid")
+
+    # 检查虚拟环境是否激活
+    venv_env = os.environ.get("VIRTUAL_ENV", "").strip()
+    if not venv_env:
+        log_error("Virtual environment is not activated (VIRTUAL_ENV not set)")
+        raise WorkspaceDetectionError("Virtual environment not activated")
+
+    venv_path = Path(venv_env)
+    if not venv_path.exists():
+        log_error(f"Activated virtual environment path does not exist: {venv_env}")
+        raise WorkspaceDetectionError(
+            "Activated virtual environment path does not exist"
+        )
+
+    resolved = venv_path.resolve()
+    # Use platform-appropriate path separators instead of forcing POSIX format
+    normalized = str(resolved)
+    log_info(f"Resolved virtual environment path: {normalized}")
+    return normalized
+
+
+def get_active_venv_path(root: Path) -> str:
+    """get_active_venv_path_str的别名，用于向后兼容。"""
+    return get_active_venv_path_str(root)

wl_cli/vendors/config/.codespellrc

@@ -0,0 +1,2 @@
+[codespell]
+ignore-words-list = crate,assertIn

wl_cli/vendors/config/dependencies.toml

@@ -0,0 +1,10 @@
+[dependencies]
+default = [
+    "numpy>=1.20.0",
+    "scipy>=1.7.0",
+    "matplotlib>=3.5.0",
+    "cffi>=1.15.0",
+    "pyyaml>=6.0.0",
+    "toml>=0.10.2",
+    "data-science-types>=0.2.23",
+]

wl_cli/vendors/config/mypy.ini

@@ -0,0 +1,62 @@
+# MyPy configuration file for WL Commands
+# WL Commands 的 mypy 配置文件
+
+[mypy]
+# Python version to target (目标 Python 版本)
+python_version = 3.12
+
+# Baseline: ignore missing imports from untyped third-party libraries.
+# 基线：忽略未类型化第三方库的导入告警（import-untyped）。
+ignore_missing_imports = true
+
+# Error reporting settings (错误输出设置)
+show_error_codes = true
+show_error_context = true
+show_column_numbers = true
+pretty = true
+
+# Incremental mode for faster checks (增量检查，加快速度)
+incremental = true
+
+# Cache directory (缓存目录)
+cache_dir = .mypy_cache
+
+# Core warning flags — always ON (核心告警项，始终开启)
+warn_return_any = true
+warn_unused_configs = true
+warn_unused_ignores = true
+
+# ---------------------------------------------------------------------------
+# Tightening ladder (渐进收紧阶梯)
+# The stricter flags below are intentionally DISABLED (commented out) in the
+# baseline. Teams can progressively enable them as the codebase becomes fully
+# typed. 以下为渐进式收紧项：基线默认关闭，待代码完全类型化后逐项开启。
+# ---------------------------------------------------------------------------
+# allow_untyped_defs = false
+#   禁止未类型标注的函数定义 (Disallow untyped function definitions)
+# allow_untyped_calls = false
+#   禁止调用未类型标注的函数 (Disallow calls to untyped functions)
+# allow_untyped_decorators = false
+#   禁止未类型标注的装饰器 (Disallow untyped decorators)
+# allow_incomplete_defs = false
+#   禁止不完整的类型标注 (Disallow partially annotated definitions)
+# 注（2026-09-16）：此处曾把 strict_optional 列为 “future rung”，那是错的。
+# mypy 早已**默认开启** strict optional（CLI 只提供 `--no-strict-optional`），
+# 所以 `strict_optional = true` 是 **no-op**、不构成一档阶梯（只有显式 `= false` 才有意义）。
+# 日后若要加下一档，应挑一个真正有效的开关（如 disallow_untyped_defs），而不是这一条。
+# Rung 1 (enabled 2026-09): no_implicit_optional + warn_redundant_casts
+no_implicit_optional = true
+#   禁止隐式 Optional (Disallow implicit Optional)
+warn_redundant_casts = true
+#   警告冗余的强制类型转换 (Warn about redundant casts)
+
+# Exclude specific directories (排除目录)
+exclude =
+    __pycache__,
+    build,
+    dist,
+    *.egg-info,
+    .ruff_cache,
+    .venv,
+    .git,
+    rust/

wl_cli/vendors/config/pyproject_defaults.toml

@@ -0,0 +1,28 @@
+[project]
+name = "{{project_name}}"
+dynamic = ["version"]
+description = "{{project_name}} - Python项目"
+requires-python = ">=3.10"
+license = "MIT"
+readme = "README.md"
+authors = [{name = "Admin", email = "admin@example.com"}]
+
+[project.urls]
+Homepage = "https://github.com/example/{{project_name}}"
+Issues = "https://github.com/example/{{project_name}}/issues"
+
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[maturin]
+manifest-path = "rust/Cargo.toml"
+module-name = "{{python_name}}.lib.{{rust_name}}"
+python-source = "src"
+include = ["src/{{python_name}}/**/*"]
+bindings = "pyo3"
+features = ["pyo3/extension-module"]
+
+[build-system.setuptools]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

wl_cli/vendors/config/template_config.toml

@@ -0,0 +1,24 @@
+[core_templates]
+python_version = { src = "project/.python-version", dest = ".python-version" }
+license = { src = "project/LICENSE", dest = "LICENSE" }
+gitignore = { src = "project/.gitignore", dest = ".gitignore" }
+
+[pyproject_templates]
+workspace = { src = "project/pyproject.toml", dest = "pyproject.toml" }
+no_workspace = { src = "project/pyproject_no_workspace.toml", dest = "pyproject.toml" }
+workspace_root = { src = "project/pyproject_workspace.toml", dest = "pyproject.toml" }
+
+[rust_templates]
+init_py = { src = "rust/lib/__init__.py", dest = "src/{project_name}/lib/__init__.py" }
+rust_utils = { src = "rust/lib/rust_utils.py", dest = "src/{project_name}/lib/rust_utils.py", template = true }
+test_fallback = { src = "rust/tests/test_rust_fallback.py", dest = "tests/test_rust_fallback.py" }
+
+[sop_templates]
+rust_readme = { src = "sop_doc/rust-readme.md", dest = "rust/README.md" }
+python_sop = { src = "sop_doc/python-sop.md", dest = "src/{project_name}/lib/sop.md" }
+git_dev_sop = { src = "sop_doc/git-dev-sop.md", dest = "docs/git-dev-sop.md" }
+
+[config_templates]
+codespellrc = { src = "config/.codespellrc", dest = ".wl/.codespellrc" }
+mypy = { src = "config/mypy.ini", dest = ".wl/mypy.ini" }
+precommit = { src = "git/.pre-commit-config.yaml", dest = ".wl/.pre-commit-config.yaml" }

wl_cli/vendors/config/tool_configs.toml

@@ -0,0 +1,76 @@
+[tool.ruff]
+line-length = 88
+target-version = "py312"
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "W",
+    "F",
+    "I",
+    "N",
+    "UP",
+    "B",
+    "C4",
+    "SIM",
+    "TCH",
+    "PTH",
+    "PGH",
+    "PL",
+    "RUF",
+]
+ignore = [
+    "E501",
+    "PLR0913",
+    "PLR0915",
+]
+per-file-ignores = { "tests/*" = ["S101", "ARG"] }
+
+[tool.mypy]
+# Python version to target (PEP 8 compatible)
+python_version = "3.12"
+
+# Enable strict type checking following PEP 8
+type_checking_mode = "strict"
+
+# Error reporting settings
+show_error_codes = true
+show_error_context = true
+show_column_numbers = true
+pretty = true
+
+# Incremental mode for faster checks
+incremental = true
+
+# Cache directory
+cache_dir = ".mypy_cache"
+
+# Basic strictness settings
+warn_return_any = true
+warn_unused_configs = true
+warn_unused_ignores = true
+
+# Typing discipline settings
+allow_untyped_defs = false
+allow_untyped_calls = false
+allow_untyped_decorators = false
+allow_incomplete_defs = false
+strict_optional = true
+
+# Import settings
+no_implicit_optional = true
+
+# Error handling
+warn_redundant_casts = true
+
+# Exclude specific directories
+exclude = [
+    "__pycache__",
+    "build",
+    "dist",
+    "*.egg-info",
+    ".ruff_cache",
+    ".venv",
+    ".git",
+    "rust/"
+]