py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/self/services/windows_update.py

@@ -0,0 +1,174 @@
+"""
+Windows update functionality for self update command.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from ....utils.platform_adapter import PlatformAdapter
+
+
+class WindowsUpdate:
+    """Windows-specific update functionality for the wl command."""
+
+    def handle_access_error(self, uv_path: str = "") -> None:
+        """
+        Handle Windows access denied errors with either delayed update or manual instructions.
+        """
+        from wl_cli.utils.logging import log_info_pair
+
+        if PlatformAdapter.is_windows():
+            log_info_pair(
+                "Detected file in use error on Windows. Trying delayed update mechanism...",
+                "在Windows上检测到文件被占用错误。尝试延迟更新机制...",
+            )
+            if not uv_path:
+                # ``or ""`` keeps the declared ``str`` type honest; ``which``
+                # returns ``None`` when uv is absent. Behaviour is unchanged --
+                # both ``None`` and ``""`` fail the truthiness test below and
+                # fall through to the "Failed to find uv executable" branch.
+                uv_path = shutil.which("uv") or ""
+            if uv_path:
+                env = os.environ.copy()
+                env["PYTHONIOENCODING"] = "utf-8"
+                env["PYTHONLEGACYWINDOWSFSENCODING"] = "1"
+                self._run_delayed_update(uv_path, env)
+                return
+            else:
+                log_info_pair(
+                    "Failed to find uv executable for delayed update.",
+                    "无法找到uv可执行文件进行延迟更新。",
+                )
+
+        log_info_pair(
+            "Error updating wl command: Access denied. This is a common issue on Windows when trying to update a running tool.",
+            "错误：更新wl命令失败: 权限被拒绝。这是在Windows上尝试更新正在运行的工具时的常见问题。",
+        )
+        log_info_pair(
+            "Please try one of the following solutions:", "请尝试以下解决方案之一："
+        )
+        log_info_pair(
+            "1. Close all wl command windows and run 'wl self update' again",
+            "   关闭所有wl命令窗口，然后再次运行'wl self update'",
+        )
+        log_info_pair("2. Run the command as administrator", "   以管理员身份运行命令")
+        log_info_pair(
+            "3. Use 'uv tool install --editable .' directly",
+            "   直接使用'uv tool install --editable .'命令",
+        )
+        sys.exit(1)
+
+    def _run_delayed_update(self, uv_path: str, env: dict) -> None:
+        """
+        Run delayed update on Windows by creating a separate script that executes after the main process exits.
+        """
+        from wl_cli.utils.logging import log_info_pair
+
+        env_repr = repr(env)
+        uv_path_escaped = uv_path.replace("\\", "\\\\")
+
+        script_content = f"""
+import subprocess
+import time
+import sys
+import os
+
+print("Waiting for main process to exit...")
+print("等待主进程退出...")
+time.sleep(3)
+
+os.environ.update({env_repr})
+
+try:
+    print("Uninstalling existing wl_cli...")
+    print("正在卸载现有wl_cli...")
+    subprocess.run([\"{uv_path_escaped}\", \"tool\", \"uninstall\", \"wl_cli\"], check=False, capture_output=True, text=True, encoding="utf-8")
+
+    print("Installing wl_cli...")
+    print("正在安装wl_cli...")
+    primary_cmd = [\"{uv_path_escaped}\", \"tool\", \"install\", \"--editable\", \".\"]
+    subprocess.run(primary_cmd, check=True, capture_output=False, text=True, encoding="utf-8")
+
+    print("\\nWL command updated successfully!")
+    print("wl命令更新成功！")
+    print("You can close this window now.")
+    print("现在可以关闭此窗口。")
+except subprocess.CalledProcessError as e:
+    print("\\nError updating wl command: " + str(e))
+    print("更新wl命令失败: " + str(e))
+    try:
+        print("\\nTrying alternative installation method...")
+        print("尝试备选安装方法...")
+        alternative_cmd = [\"{uv_path_escaped}\", \"tool\", \"install\", \"--editable\", \".\", \"--python-preference\", \"only-system\"]
+        subprocess.run(alternative_cmd, check=True, capture_output=False, text=True, encoding="utf-8")
+        print("\\nWL command updated successfully with alternative method!")
+        print("使用备选方法成功更新wl命令！")
+    except subprocess.CalledProcessError as alt_e:
+        print("\\nAlternative installation also failed: " + str(alt_e))
+        print("备选安装方法也失败: " + str(alt_e))
+        print("Please try manual installation:")
+        print("请尝试手动安装：")
+        print("uv tool install --editable .")
+        print("Press Enter to exit...")
+        input()
+except Exception as e:
+    print("\\nUnexpected error: " + str(e))
+    print("意外错误: " + str(e))
+    print("Press Enter to exit...")
+    input()
+"""
+
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".py", delete=False, encoding="utf-8"
+        ) as f:
+            f.write(script_content)
+            temp_script_path = f.name
+
+        log_info_pair(
+            f"Running delayed update script: {temp_script_path}",
+            f"正在运行延迟更新脚本: {temp_script_path}",
+        )
+
+        try:
+            subprocess.Popen(
+                [sys.executable, temp_script_path],
+                shell=True,
+                creationflags=getattr(subprocess, "CREATE_NEW_CONSOLE", 0),
+            )
+            log_info_pair(
+                "Delayed update started. The update will continue in a new window.",
+                "延迟更新已启动。更新将在新窗口中继续进行。",
+            )
+            sys.exit(0)
+        except Exception as e:
+            log_info_pair(
+                f"Failed to start delayed update: {e}", f"启动延迟更新失败: {e}"
+            )
+            self._show_manual_instructions()
+
+    def _show_manual_instructions(self) -> None:
+        """
+        Show manual installation instructions to the user.
+        """
+        from wl_cli.utils.logging import log_info_pair
+
+        log_info_pair(
+            "Error updating wl command: Access denied. This is a common issue on Windows when trying to update a running tool.",
+            "错误：更新wl命令失败: 权限被拒绝。这是在Windows上尝试更新正在运行的工具时的常见问题。",
+        )
+        log_info_pair(
+            "Please try one of the following solutions:", "请尝试以下解决方案之一："
+        )
+        log_info_pair(
+            "1. Close all wl command windows and run 'wl self update' again",
+            "   关闭所有wl命令窗口，然后再次运行'wl self update'",
+        )
+        log_info_pair("2. Run the command as administrator", "   以管理员身份运行命令")
+        log_info_pair(
+            "3. Use 'uv tool install --editable .' directly",
+            "   直接使用'uv tool install --editable .'命令",
+        )
+        sys.exit(1)

wl_cli/commands/testcommands/__init__.py

@@ -0,0 +1,8 @@
+"""
+Test commands package initialization.
+"""
+
+# Import the test command to register it
+from .test_commands import TestCommand
+
+__all__ = ["TestCommand"]

wl_cli/commands/testcommands/base_dependency_analyzer.py

@@ -0,0 +1,198 @@
+"""Base dependency analyzer with shared AST-based dependency analysis logic."""
+
+import ast
+import os
+from pathlib import Path
+
+from .utils.project_root import project_root_for
+
+
+class BaseDependencyAnalyzer:
+    """Base class with shared dependency analysis logic using AST parsing.
+
+    Provides common dependency resolution methods that can be inherited by
+    classes that need dependency analysis functionality.
+    """
+
+    def __init__(
+        self, module_file_cache: dict[tuple[str, str], Path | None] | None = None
+    ):
+        """Initialize with optional module file cache.
+
+        Args:
+            module_file_cache: Optional cache for found module files
+                 Caches (module_name, src_dir_str) -> Path found result
+        """
+        self._dependency_cache: dict[str, tuple[list[Path], float]] = {}
+        self._module_file_cache: dict[tuple[str, str], Path | None] = (
+            module_file_cache or {}
+        )
+
+    def _get_test_dependencies(self, test_file: Path) -> list[Path]:
+        """Get test file dependencies by analyzing imports, including indirect dependencies."""
+        # Check dependency cache first
+        cache_key = str(test_file)
+        if cache_key in self._dependency_cache:
+            # Cache entry stores (dependencies, mtime) tuple
+            cached_deps, cached_mtime = self._dependency_cache[cache_key]
+            # Check if file has been modified since caching
+            try:
+                current_mtime = os.path.getmtime(test_file)
+                # If mtime hasn't changed, use cached result
+                if abs(current_mtime - cached_mtime) < 1e-6:
+                    return cached_deps
+            except OSError:
+                # If we can't stat the file, just use cached result
+                return cached_deps
+
+        dependencies: set[Path] = set()
+        # ADR 0006: 回退是调用方策略 —— 子系统策略helper 已显式兜底 CWD
+        project_root = project_root_for()
+        src_dir = Path(project_root) / "src"
+        test_dir = Path(project_root) / "tests"
+
+        # Analyze the test file itself
+        self._analyze_file_dependencies(test_file, dependencies, src_dir, test_dir)
+
+        # Cache the result with current mtime
+        try:
+            current_mtime = os.path.getmtime(test_file)
+        except OSError:
+            current_mtime = 0.0
+        self._dependency_cache[cache_key] = (list(dependencies), current_mtime)
+
+        # Simple LRU-style eviction: if cache exceeds 1000 entries, clear half
+        if len(self._dependency_cache) > 1000:
+            # Remove half the entries to keep cache size manageable
+            keys = list(self._dependency_cache.keys())
+            half = len(keys) // 2
+            for key in keys[:half]:
+                del self._dependency_cache[key]
+
+        return list(dependencies)
+
+    def _analyze_file_dependencies(
+        self, file_path: Path, dependencies: set[Path], src_dir: Path, test_dir: Path
+    ) -> None:
+        """Recursively analyze dependencies for a file."""
+        try:
+            # Read and parse file
+            content = file_path.read_text(encoding="utf-8")
+            tree = ast.parse(content)
+
+            # Analyze imports
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    self._analyze_import_node(node, dependencies, src_dir, test_dir)
+                elif isinstance(node, ast.ImportFrom):
+                    self._analyze_import_from_node(
+                        node, file_path, dependencies, src_dir, test_dir
+                    )
+
+        except (OSError, SyntaxError, TypeError):
+            pass
+
+    def _analyze_import_node(
+        self, node: ast.Import, dependencies: set[Path], src_dir: Path, test_dir: Path
+    ) -> None:
+        """Analyze an Import node and add dependencies."""
+        for alias in node.names:
+            module_name = alias.name
+            # First try to find in src directory
+            dep_file = self._find_module_file(module_name, src_dir)
+            # If not found, try in test directory
+            if not dep_file:
+                dep_file = self._find_module_file(module_name, test_dir)
+            if dep_file and dep_file not in dependencies:
+                dependencies.add(dep_file)
+                # Recursively analyze this dependency
+                self._analyze_file_dependencies(
+                    dep_file, dependencies, src_dir, test_dir
+                )
+
+    def _analyze_import_from_node(
+        self,
+        node: ast.ImportFrom,
+        file_path: Path,
+        dependencies: set[Path],
+        src_dir: Path,
+        test_dir: Path,
+    ) -> None:
+        """Analyze an ImportFrom node and add dependencies."""
+        if node.module:
+            module_name = node.module
+            # First try to find in src directory
+            dep_file = self._find_module_file(module_name, src_dir)
+            # If not found, try in test directory
+            if not dep_file:
+                dep_file = self._find_module_file(module_name, test_dir)
+            if dep_file and dep_file not in dependencies:
+                dependencies.add(dep_file)
+                # Recursively analyze this dependency
+                self._analyze_file_dependencies(
+                    dep_file, dependencies, src_dir, test_dir
+                )
+        elif node.level > 0:
+            # Handle relative imports
+            relative_path = Path(file_path.parent)
+            for _ in range(node.level - 1):
+                relative_path = relative_path.parent
+            for alias in node.names:
+                # Try to find the relative module
+                relative_module_path = relative_path / f"{alias.name}.py"
+                if relative_module_path.exists():
+                    if relative_module_path not in dependencies:
+                        dependencies.add(relative_module_path)
+                        self._analyze_file_dependencies(
+                            relative_module_path, dependencies, src_dir, test_dir
+                        )
+                # Try to find __init__.py in the relative directory
+                relative_dir_path = relative_path / alias.name
+                init_file = relative_dir_path / "__init__.py"
+                if init_file.exists():
+                    if init_file not in dependencies:
+                        dependencies.add(init_file)
+                        self._analyze_file_dependencies(
+                            init_file, dependencies, src_dir, test_dir
+                        )
+
+    def _find_module_file(self, module_name: str, src_dir: Path) -> Path | None:
+        """Find module file from module name."""
+        # Create cache key
+        cache_key = (module_name, str(src_dir))
+
+        # Check cache first
+        if cache_key in self._module_file_cache:
+            return self._module_file_cache[cache_key]
+
+        # Convert module name to path
+        module_path = Path(module_name.replace(".", "/"))
+
+        # Look for __init__.py in module directory
+        init_file = src_dir / module_path / "__init__.py"
+        if init_file.exists():
+            self._module_file_cache[cache_key] = init_file
+            return init_file
+
+        # Look for .py file with module name
+        py_file = src_dir / f"{module_path}.py"
+        if py_file.exists():
+            self._module_file_cache[cache_key] = py_file
+            return py_file
+
+        # Try looking in parent directories for the module
+        current_dir = src_dir
+        while current_dir.parent != current_dir:
+            # Check if module exists in current directory
+            test_init_file = current_dir / module_path / "__init__.py"
+            if test_init_file.exists():
+                self._module_file_cache[cache_key] = test_init_file
+                return test_init_file
+            test_py_file = current_dir / f"{module_path}.py"
+            if test_py_file.exists():
+                self._module_file_cache[cache_key] = test_py_file
+                return test_py_file
+            current_dir = current_dir.parent
+
+        self._module_file_cache[cache_key] = None
+        return None

wl_cli/commands/testcommands/batch_processor.py

@@ -0,0 +1,278 @@
+"""Batch processor for step-by-step test execution."""
+
+import concurrent.futures
+import os
+import sys
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from tqdm import tqdm
+
+from ...utils.output_context import is_concise_mode, should_show_progress_bars
+from .cache_manager import CacheManager
+
+
+class BatchProcessor:
+    """Processes test files in batches for step-by-step execution."""
+
+    def __init__(self, cache_manager: CacheManager):
+        """Initialize with cache manager dependency."""
+        self.cache_manager = cache_manager
+
+    def process_specified_files(
+        self,
+        quiet: bool,
+        verbose: bool,
+        test_files: list[Path],
+        python_executable: str,
+        project_root: str,
+        env: dict[str, str],
+        debug_mode: bool,
+        no_cache: bool,
+        execute_single: Callable[[Path], tuple[bool, str]],
+    ) -> None:
+        """Process specified test files in step-by-step mode, stopping at first error."""
+        show_progress = should_show_progress_bars(
+            override_quiet=quiet, override_verbose=verbose
+        )
+        concise = is_concise_mode(override_quiet=quiet, override_verbose=verbose)
+        self.cache_manager.start_run()
+
+        if not test_files:
+            print("No test files found.")
+            return
+
+        # Calculate processing parameters
+        cpu_count = os.cpu_count() or 4
+        max_workers = min(16, cpu_count * 2)
+        batch_size = min(50, max_workers * 5)
+
+        error_occurred, error_message = self._process_batches(
+            test_files,
+            max_workers,
+            batch_size,
+            show_progress,
+            concise,
+            execute_single,
+        )
+
+        if error_occurred:
+            if show_progress:
+                print("\033[K", end="\r")
+            print(f"{error_message}")
+            print("Stopping at first error as requested.")
+            sys.exit(1)
+
+        print("All tests passed successfully!")
+        self.cache_manager.report_summary(test_files)
+
+    def process_all_files(
+        self,
+        quiet: bool,
+        verbose: bool,
+        test_files: list[Path],
+        python_executable: str,
+        project_root: str,
+        env: dict[str, str],
+        debug_mode: bool,
+        no_cache: bool,
+        execute_single: Callable[[Path], tuple[bool, str]],
+    ) -> None:
+        """Process all test files in step-by-step mode."""
+        show_progress = should_show_progress_bars(
+            override_quiet=quiet, override_verbose=verbose
+        )
+        concise = is_concise_mode(override_quiet=quiet, override_verbose=verbose)
+        self.cache_manager.start_run()
+
+        # Calculate processing parameters
+        cpu_count = os.cpu_count() or 4
+        max_workers = min(16, cpu_count * 2)
+        batch_size = min(50, max_workers * 5)
+
+        error_occurred, error_message = self._process_batches(
+            test_files,
+            max_workers,
+            batch_size,
+            show_progress,
+            concise,
+            execute_single,
+        )
+
+        if error_occurred:
+            if show_progress:
+                print("\033[K", end="\r")
+            print(f"{error_message}")
+            print("Stopping at first error as requested.")
+            sys.exit(1)
+
+        print("All tests passed successfully!")
+        self.cache_manager.report_summary(test_files)
+
+    def _process_batches(
+        self,
+        test_files: list[Path],
+        max_workers: int,
+        batch_size: int,
+        show_progress: bool,
+        concise: bool,
+        execute_single: Callable[[Path], tuple[bool, str]],
+    ) -> tuple[bool, str]:
+        """Process all test batches and return error status."""
+        error_occurred = False
+        error_message = ""
+
+        if show_progress:
+            with tqdm(
+                total=len(test_files),
+                unit="file",
+                dynamic_ncols=True,
+                bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]",
+            ) as pbar:
+                error_occurred, error_message = self._process_batches_with_progress(
+                    test_files,
+                    max_workers,
+                    batch_size,
+                    pbar,
+                    concise,
+                    execute_single,
+                )
+
+        else:
+            error_occurred, error_message, _ = self._process_batches_without_progress(
+                test_files,
+                max_workers,
+                batch_size,
+                concise,
+                execute_single,
+            )
+
+        return error_occurred, error_message
+
+    def _process_batches_with_progress(
+        self,
+        test_files: list[Path],
+        max_workers: int,
+        batch_size: int,
+        pbar: tqdm,
+        _concise_mode: bool,
+        execute_single: Callable[[Path], tuple[bool, str]],
+    ) -> tuple[bool, str]:
+        """Process batches with progress bar."""
+        error_occurred = False
+        error_message = ""
+
+        for i in range(0, len(test_files), batch_size):
+            batch_files = test_files[i : i + batch_size]
+            error_occurred, error_message = self._process_single_batch(
+                batch_files,
+                max_workers,
+                pbar,
+                _concise_mode,
+                execute_single,
+            )
+            if error_occurred:
+                break
+
+        return error_occurred, error_message
+
+    def _process_batches_without_progress(
+        self,
+        test_files: list[Path],
+        max_workers: int,
+        batch_size: int,
+        concise: bool,
+        execute_single: Callable[[Path], tuple[bool, str]],
+    ) -> tuple[bool, str, int]:
+        """Process batches without progress bar."""
+        error_occurred = False
+        error_message = ""
+        processed = 0
+
+        for i in range(0, len(test_files), batch_size):
+            batch_files = test_files[i : i + batch_size]
+            error_occurred, error_message = self._process_single_batch(
+                batch_files,
+                max_workers,
+                None,
+                concise,
+                execute_single,
+            )
+            processed += len(batch_files)
+            if not concise:
+                print(f"[{processed}/{len(test_files)}]", end=" ", flush=True)
+            if error_occurred:
+                break
+
+        return error_occurred, error_message, processed
+
+    def _process_single_batch(
+        self,
+        batch_files: list[Path],
+        max_workers: int,
+        pbar: tqdm | None,
+        _concise_mode: bool,
+        execute_single: Callable[[Path], tuple[bool, str]],
+    ) -> tuple[bool, str]:
+        """Process a single batch of test files."""
+        error_occurred = False
+        error_message = ""
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_file = {
+                executor.submit(execute_single, test_file): test_file
+                for test_file in batch_files
+            }
+
+            for future in concurrent.futures.as_completed(future_to_file):
+                test_file = future_to_file[future]
+                test_success, error_msg = self._process_future_result(
+                    future, test_file, pbar
+                )
+                if not test_success:
+                    error_occurred = True
+                    error_message = f"Test failed for file: {test_file}\n{error_msg}"
+                    for f in future_to_file:
+                        if not f.done():
+                            f.cancel()
+                    break
+
+        return error_occurred, error_message
+
+    def _process_future_result(
+        self,
+        future: concurrent.futures.Future,
+        test_file: Path,
+        pbar: tqdm | None,
+    ) -> tuple[bool, str]:
+        """Process the result of a future."""
+        try:
+            test_success, error_msg = future.result()
+            if pbar:
+                truncated_name = self._truncate_filename(test_file.name)
+                self._update_test_progress(pbar, truncated_name, test_file)
+            return test_success, error_msg
+        except Exception as e:
+            error_message = f"Error running test for file {test_file}: {e}"
+            return False, error_message
+
+    def _truncate_filename(self, filename: str) -> str:
+        """Truncate filename to fit in progress bar."""
+        max_len = 28
+        if len(filename) > max_len:
+            return filename[: max_len - 3] + "..."
+        return filename
+
+    def _update_test_progress(
+        self,
+        pbar: tqdm,
+        truncated_name: str,
+        test_file: Path,
+    ) -> None:
+        """Update progress bar for test processing."""
+        if test_file in self.cache_manager.cache_hit_files:
+            pbar.set_description(f"Testing {truncated_name:<28} [cached]")
+        else:
+            pbar.set_description(f"Testing {truncated_name:<28}")
+        pbar.update(1)