py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/format/format_coordinator.py

@@ -0,0 +1,191 @@
+"""Format coordinator module."""
+
+import os
+from pathlib import Path
+
+from ...utils.output_context import get_output_config
+from .format_outcome import FormatOutcome
+from .format_path_handler import FormatPathHandler
+from .format_reporter import FormatReporter
+from .python_formatter import RuffCheckVerdict
+
+
+class FormatCoordinator:
+    """Coordinator for format command."""
+
+    def __init__(self) -> None:
+        """Initialize the format coordinator.
+
+        The ``-> None`` keeps mypy checking this body: without it the two
+        collaborators stay ``Any`` and the typed aliases below would silently
+        return unchecked values (the same trap ``LintCommand.__init__`` notes).
+        """
+        self.path_handler = FormatPathHandler()
+        self.reporter = FormatReporter()
+
+    def execute(self, *args, **kwargs) -> int:
+        """Execute the format command; returns the process exit code."""
+        return self._execute_internal(**kwargs)
+
+    def run(self, *args, **kwargs) -> int:
+        """Run the format command (alias for execute to maintain compatibility)."""
+        return self._execute_internal(**kwargs)
+
+    def _execute_internal(self, **kwargs) -> int:
+        """Internal method to execute the format command.
+
+        Returns ``0`` when the run is green (or ``--report``/``wl lint`` own the
+        exit code) and ``1`` when a formatting failure must propagate (#164).
+        """
+        quiet = kwargs.get("quiet", False)
+        # Auto-detected concise mode (non-TTY / CI / Claude) must not hide a
+        # failure's diagnostics -- only an explicit ``-q/--quiet`` may (F1).
+        requested_quiet = bool(quiet)
+        verbose = kwargs.get("verbose", False)
+        unsafe = kwargs.get("unsafe", True)  # Default to True as per specifications
+        report = kwargs.get("report", False)
+        step_by_step = kwargs.get("step_by_step", False)
+        paths = kwargs.get("paths", [])
+        for_lint = kwargs.get("for_lint", False)
+        # The directory the scope means (#188). ``wl lint`` passes its root
+        # down, so a prefix started from a subdirectory (or from anywhere the
+        # CLI was invoked) formats ``root/src`` instead of resolving ``src``
+        # against the process cwd and printing "Path src does not exist".
+        # ``None`` keeps the historical cwd scope for plain ``wl format``.
+        project_root = kwargs.get("project_root")
+
+        # Auto-detect quiet mode from output context if not explicitly set
+        if not quiet:
+            # If not explicitly quiet, check if we're in concise mode
+            config = get_output_config(override_quiet=quiet, override_verbose=verbose)
+            if config.concise_mode:
+                quiet = True
+
+        # Handle --no-unsafe flag if present
+        if "no_unsafe" in kwargs:
+            unsafe = not kwargs["no_unsafe"]
+
+        env = os.environ.copy()
+        current_path = Path(project_root) if project_root is not None else Path.cwd()
+        # A caller that pinned the root gets its explicit paths anchored there
+        # (#188): the path handler probes ``Path(p).exists()``, so a bare
+        # ``src`` from a different cwd would still be dropped. Absolute paths
+        # mean the same directory to the handler and to every ruff process.
+        if project_root is not None and paths:
+            paths = [
+                p if Path(p).is_absolute() else str(current_path / p) for p in paths
+            ]
+
+        # Handle report generation
+        if report:
+            self.generate_format_report(quiet, unsafe, paths, env)
+            return 0
+
+        try:
+            outcome: FormatOutcome
+            if paths:
+                outcome = self.format_specified_paths(
+                    paths, env, quiet, unsafe, step_by_step, for_lint
+                )
+            else:
+                outcome = self.format_defaults(
+                    current_path, env, quiet, unsafe, for_lint, step_by_step
+                )
+            if outcome.ok:
+                if not quiet:
+                    print("Formatting completed.")
+                return outcome.exit_code
+            if for_lint:
+                return self._lint_prefix_exit_code(outcome, quiet, requested_quiet)
+            if not requested_quiet:
+                self._render_failures(outcome)
+            return outcome.exit_code
+        except Exception as e:
+            if not quiet:
+                print(f"Warning: Error occurred during formatting: {e}")
+            return 1
+
+    def _lint_prefix_exit_code(
+        self, outcome: FormatOutcome, quiet: bool, requested_quiet: bool
+    ) -> int:
+        """Map a ``for_lint`` outcome to the prefix's exit code (#166).
+
+        ``wl lint`` runs format as a prefix. A ``ruff``/``tool_missing``
+        failure means the files could not be formatted, so it stops lint
+        before ruff re-runs and renders its diagnostics.
+
+        Two verdicts stay non-fatal, because lint itself owns the authoritative
+        run for each:
+
+        * a ``pre_commit``-only verdict (#149/D3). Since #180 the prefix does
+          not run pre-commit at all for lint, so this branch now only guards a
+          ``pre_commit`` failure such as one forwarded by a caller that still
+          produces it -- the exit contract is unchanged.
+        * a :class:`RuffCheckVerdict`-only outcome (#188): ``ruff check --fix``
+          exiting ``1`` means *some violations were not auto-fixable*, which is
+          the very thing lint's own ruff run reports. Aborting here is what
+          used to skip ruff's structured run, mypy, pre-commit and the report
+          whenever the report was most needed.
+        """
+        fatal = tuple(
+            failure
+            for failure in outcome.failures
+            if failure.kind != "pre_commit"
+            and not isinstance(failure, RuffCheckVerdict)
+        )
+        if fatal:
+            if not requested_quiet:
+                self._render_failures(outcome)
+            return outcome.exit_code
+        if not quiet:
+            print("Formatting completed.")
+        return 0
+
+    def _render_failures(self, outcome: FormatOutcome) -> None:
+        """Print the failures that made the run red (F1).
+
+        ``format_python_file`` captures ruff's output (its quiet flag is
+        forced), so without this the user saw ``Formatting code...`` followed
+        by exit 1 and nothing else. Directory runs may already have streamed
+        the tool output; their message then falls back to a one-line
+        ``<step> failed with return code N``, so nothing is duplicated.
+
+        ``pre_commit`` details are the exception (#172): the path handler
+        already printed every failing block, from the same ``failed_blocks``
+        the verdict was computed from, at the moment it read the run. Printing
+        them again here was the duplicate the ticket is about; the failure
+        line and message below still say which run went red.
+        """
+        for failure in outcome.failures:
+            print(f"Formatting failed ({failure.kind}): {failure.path}")
+            if failure.message:
+                print(failure.message)
+            if failure.kind == "pre_commit":
+                continue
+            for detail in failure.details:
+                print(detail)
+
+    # 添加别名方法以匹配测试期望的接口
+    def format_specified_paths(
+        self, paths, env, quiet, unsafe=False, step_by_step=False, for_lint=False
+    ) -> FormatOutcome:
+        """Alias for path_handler.format_specified_paths.
+
+        ``for_lint`` reaches the handler so the ``wl lint`` prefix skips
+        pre-commit for explicit paths too (#180), not only for the defaults.
+        """
+        return self.path_handler.format_specified_paths(
+            paths, env, quiet, unsafe, step_by_step, for_lint
+        )
+
+    def format_defaults(
+        self, current_path, env, quiet, unsafe, for_lint, step_by_step=False
+    ) -> FormatOutcome:
+        """Alias for path_handler.format_defaults."""
+        return self.path_handler.format_defaults(
+            current_path, env, quiet, unsafe, for_lint, step_by_step
+        )
+
+    def generate_format_report(self, quiet, unsafe, paths, env):
+        """Alias for reporter.generate_format_report."""
+        self.reporter.generate_format_report(quiet, unsafe, paths, env)

wl_cli/commands/format/format_executor.py

@@ -0,0 +1,470 @@
+"""Format executor module."""
+
+import concurrent.futures
+import os
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from .format_cache_adapter import FormatCacheAdapter
+from .format_outcome import FormatFailure
+from .format_progress import FormatProgress
+from .python_formatter import (
+    FormatCommandResult,
+    RuffCheckVerdict,
+    _run_format_command,
+)
+
+
+class FormatExecutor:
+    """Executor for format operations."""
+
+    def __init__(self):
+        self.cache = FormatCacheAdapter()
+        self.progress = FormatProgress()
+        self._has_psutil = False
+        try:
+            import psutil
+
+            self._has_psutil = True
+            self._psutil = psutil
+        except ImportError:
+            pass
+
+    def get_optimal_workers(self) -> int:
+        """Get optimal number of workers based on system resources."""
+        # Get CPU core count
+        cpu_count = os.cpu_count()
+
+        # Handle case where cpu_count is None
+        if cpu_count is None:
+            return 4
+
+        # Calculate base workers based on CPU cores
+        base_workers = min(32, cpu_count * 2)
+
+        # Adjust based on available memory if psutil is available
+        if self._has_psutil:
+            try:
+                # Get available memory in GB
+                available_memory = self._psutil.virtual_memory().available / (1024**3)
+
+                # Adjust based on available memory
+                if available_memory < 2:
+                    # Low memory, reduce workers
+                    return max(1, base_workers // 2)
+                elif available_memory < 4:
+                    # Moderate memory, use base workers
+                    return base_workers
+                else:
+                    # Sufficient memory, can increase workers slightly
+                    return min(32, base_workers * 2)
+            except Exception:
+                # If psutil call fails, fall back to base workers
+                pass
+
+        # Fall back to CPU-based calculation
+        return base_workers
+
+    def get_optimal_batch_size(self, workers: int) -> int:
+        """Get optimal batch size based on number of workers."""
+        # Calculate base batch size
+        base_batch_size = workers * 10
+
+        # Cap at 100 to avoid excessive memory usage
+        return min(100, base_batch_size)
+
+    def calculate_resource_based_settings(self) -> tuple[int, int]:
+        """Calculate resource-based settings for parallel processing."""
+        workers = self.get_optimal_workers()
+        batch_size = self.get_optimal_batch_size(workers)
+        return workers, batch_size
+
+    @staticmethod
+    def _ruff_failure(
+        path_obj: Path, result: FormatCommandResult, step: str
+    ) -> FormatFailure:
+        """Classify one failed ruff command into the failure vocabulary."""
+        if result.tool_missing or result.launcher_failure is not None:
+            # #200 NIT-2: name the actual startup failure. ``tool_missing`` is
+            # the closed vocabulary's only "never ran" slot, but saying "ruff
+            # could not be launched" for a uv failure reads as "install ruff";
+            # a uv launcher failure gets its own wording, and a missing
+            # executable keeps the launch error it actually raised (F6: no
+            # over-attribution).
+            if result.launcher_failure is not None:
+                message = (
+                    f"the uv launcher failed before ruff ran ({step}): "
+                    f"{result.launcher_failure}"
+                )
+            else:
+                reason = result.launch_error or f"exit code {result.returncode}"
+                message = f"ruff could not be started ({step}): {reason}"
+            return FormatFailure(
+                path=path_obj,
+                kind="tool_missing",
+                message=message,
+            )
+        message = result.output.strip() or (
+            f"{step} failed with return code {result.returncode}"
+        )
+        return FormatFailure(path=path_obj, kind="ruff", message=message)
+
+    @staticmethod
+    def _ruff_check_failure(
+        path_obj: Path, result: FormatCommandResult
+    ) -> FormatFailure:
+        """Classify a failed ``ruff check`` run on one explicit file (#196).
+
+        The explicit single-file entry used to package *every* non-zero
+        ``ruff check`` as a plain formatter failure, so ``wl lint foo.py``
+        stopped at its format prefix and never reached its own ruff run,
+        mypy, pre-commit or the report -- the same early exit #188 fixed for
+        directory and default scopes.
+
+        Exit ``1`` from a ruff that *did* run means "violations remain after
+        the fixes": that is a lint verdict, carried as
+        :class:`RuffCheckVerdict`, which the coordinator lets the lint run
+        judge. This deliberately includes a file ruff cannot parse -- it
+        reports ``invalid-syntax`` on stdout with rc1, so the syntax error is a
+        check verdict here and ``ruff format`` never runs for it (#200).
+
+        Anything else -- a launcher that never ran, ``uv`` itself failing with
+        rc1 (:attr:`FormatCommandResult.launcher_failure`, #200), or exit
+        ``>= 2`` (ruff refused the config/arguments) -- is still a genuine
+        formatter failure and still stops the lint prefix.
+        """
+        if (
+            not result.tool_missing
+            and result.launcher_failure is None
+            and result.returncode == 1
+        ):
+            message = result.output.strip() or "ruff check left unfixed violations"
+            return RuffCheckVerdict(path=path_obj, kind="ruff", message=message)
+        return FormatExecutor._ruff_failure(path_obj, result, "ruff check")
+
+    def format_python_file(
+        self, path_obj: Path, original_path: str, env: dict, quiet: bool, unsafe: bool
+    ) -> FormatFailure | None:
+        """Format a single Python file; ``None`` means it succeeded (#164)."""
+        try:
+            # In step-by-step mode, we want to suppress all output except errors
+            # But we still need to capture error output to display it later
+            step_by_step_quiet = quiet or True  # Always quiet in step-by-step mode
+
+            # Format with ruff check
+            ruff_check_cmd = ["uv", "run", "ruff", "check", "--fix"]
+            if unsafe:
+                ruff_check_cmd.append("--unsafe-fixes")
+            ruff_check_cmd.append(str(path_obj))
+
+            check_result = _run_format_command(
+                ruff_check_cmd, env, step_by_step_quiet, passthrough=False
+            )
+            if not check_result.ok:
+                # In step-by-step mode, we return the error output
+                # It will be displayed by the caller. A check run that left
+                # unfixable violations is a lint verdict, not a format
+                # failure (#196): ``wl lint``'s own ruff run owns it.
+                return self._ruff_check_failure(path_obj, check_result)
+
+            # Format with ruff format
+            format_result = _run_format_command(
+                [
+                    "uv",
+                    "run",
+                    "ruff",
+                    "format",
+                    str(path_obj),
+                ],
+                env,
+                step_by_step_quiet,
+                passthrough=False,
+            )
+            if not format_result.ok:
+                # In step-by-step mode, we return the error output
+                # It will be displayed by the caller
+                return self._ruff_failure(path_obj, format_result, "ruff format")
+
+            return None
+        except Exception as e:
+            # In step-by-step mode, we return the error message
+            # It will be displayed by the caller
+            return FormatFailure(
+                path=path_obj,
+                kind="ruff",
+                message=f"Warning: Failed to format {original_path}: {e}",
+            )
+
+    @staticmethod
+    def _as_failure(result: object, file_path: Path) -> FormatFailure | None:
+        """Normalise ``format_python_file``'s answer to ``failure | None``.
+
+        ``None`` is success under the #164 contract. The tuple/bool branches
+        keep older test doubles (which still answer ``(bool, message)``) usable;
+        production only ever takes the ``FormatFailure | None`` path.
+        """
+        if result is None or isinstance(result, FormatFailure):
+            return result
+        if isinstance(result, tuple):
+            success, message = result
+            return None if success else FormatFailure(file_path, "ruff", message)
+        if isinstance(result, bool):
+            return None if result else FormatFailure(file_path, "ruff", "")
+        # F2: fail *closed*. An unrecognised return type is a contract breach,
+        # not evidence of success -- silently treating it as green is a
+        # fail-open channel into the exit code.
+        raise TypeError(
+            "format_python_file returned "
+            f"{type(result).__name__}; expected FormatFailure | None"
+        )
+
+    def process_single_file(
+        self,
+        file_path: Path,
+        env: dict,
+        quiet: bool,
+        unsafe: bool,
+        cache: dict[str, bool],
+        cache_hits: list[int],
+    ) -> tuple[FormatFailure | None, Path, str, str]:
+        """Process a single file with caching; first item is the failure.
+
+        ``cache`` is only a per-run memo of the keys recorded during this run --
+        the durable cache is the ledger, so a hit survives across processes.
+        """
+        try:
+            # Check if we're in test environment
+            is_test = "PYTEST_CURRENT_TEST" in os.environ
+
+            # Skip caching in test environment to speed up tests
+            if not is_test:
+                # Read file content for cache key generation with UTF-8 encoding
+                content = file_path.read_text(encoding="utf-8")
+                cache_key, cached_hit = self.cache.lookup(file_path, content)
+
+                # Check if result is in the ledger or in this run's memo
+                if cached_hit or cache_key in cache:
+                    cache_hits[0] += 1
+                    return None, file_path, "cache", ""
+            else:
+                cache_key = None
+
+            # Format the file
+            failure = self._as_failure(
+                self.format_python_file(file_path, str(file_path), env, quiet, unsafe),
+                file_path,
+            )
+
+            # Record the result if successful and not in test environment
+            if failure is None and cache_key and not is_test:
+                cache[cache_key] = True
+                self.cache.record(cache_key)
+
+            return (
+                failure,
+                file_path,
+                "processed" if failure is None else "failed",
+                failure.message if failure is not None else "",
+            )
+        except Exception as e:
+            error_message = f"Error processing {file_path}: {e}"
+            if not quiet:
+                print(error_message)
+            return (
+                FormatFailure(file_path, "ruff", error_message),
+                file_path,
+                "error",
+                error_message,
+            )
+
+    def process_files_parallel_quiet(
+        self,
+        files: list[Path],
+        env: dict,
+        quiet: bool,
+        unsafe: bool,
+        cache: dict[str, bool],
+        cache_hits: list[int],
+    ) -> tuple[FormatFailure, ...]:
+        """Process files in parallel without progress bar.
+
+        Aggregates **every** failure in input order; the step-by-step layer
+        decides where to truncate (#164, audit patch 2 / review F3).
+        """
+        max_workers, batch_size = self.calculate_resource_based_settings()
+        total_files = len(files)
+        failures: list[tuple[int, FormatFailure]] = []
+
+        # Process files in batches
+        for i in range(0, total_files, batch_size):
+            batch_files = files[i : i + batch_size]
+
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                # Submit tasks for current batch
+                future_to_index = {
+                    executor.submit(
+                        self.process_single_file,
+                        file_path,
+                        env,
+                        quiet,
+                        unsafe,
+                        cache,
+                        cache_hits,
+                    ): i + offset
+                    for offset, file_path in enumerate(batch_files)
+                }
+
+                # Process results as they complete
+                for future in concurrent.futures.as_completed(future_to_index):
+                    index = future_to_index[future]
+                    try:
+                        failure, _, _, _ = future.result()
+                        if failure is not None:
+                            failures.append((index, failure))
+                    except Exception as e:
+                        failures.append(
+                            (
+                                index,
+                                FormatFailure(
+                                    files[index],
+                                    "ruff",
+                                    f"Error processing {files[index]}: {e}",
+                                ),
+                            )
+                        )
+
+        failures.sort(key=lambda item: item[0])
+        return tuple(failure for _, failure in failures)
+
+    def process_files_parallel_with_progress(
+        self,
+        files: list[Path],
+        env: dict,
+        quiet: bool,
+        unsafe: bool,
+        cache: dict[str, bool],
+        cache_hits: list[int],
+    ) -> tuple[tuple[FormatFailure, ...], int, bool]:
+        """Process files in parallel with progress bar.
+
+        First tuple item holds every failure in input order (#164).
+        """
+        total_files = len(files)
+        processed_files = 0
+        error_occurred = False
+        failures: list[tuple[int, FormatFailure]] = []
+        max_workers, batch_size = self.calculate_resource_based_settings()
+
+        # Create progress bar with optimized settings
+        pbar = self.progress.create_progress_bar(total_files)
+
+        try:
+            # Process files in batches
+            for i in range(0, total_files, batch_size):
+                batch_files = files[i : i + batch_size]
+
+                with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                    # Submit tasks for current batch
+                    future_to_index = {
+                        executor.submit(
+                            self.process_single_file,
+                            file_path,
+                            env,
+                            quiet,
+                            unsafe,
+                            cache,
+                            cache_hits,
+                        ): i + offset
+                        for offset, file_path in enumerate(batch_files)
+                    }
+
+                    # Process results as they complete
+                    for future in concurrent.futures.as_completed(future_to_index):
+                        index = future_to_index[future]
+                        file_path = files[index]
+                        try:
+                            failure, _, status, error_message = future.result()
+                            processed_files += 1
+
+                            # Update progress bar
+                            truncated_name = self.progress.truncate_filename(
+                                file_path.name
+                            )
+                            self.progress.update_progress_bar(
+                                pbar,
+                                truncated_name,
+                                status,
+                            )
+
+                            if failure is not None:
+                                error_occurred = True
+                                self.progress.print_format_error(
+                                    file_path, error_message
+                                )
+                                failures.append((index, failure))
+                        except Exception as e:
+                            error_occurred = True
+                            self.progress.print_processing_error(file_path, e)
+                            failures.append(
+                                (
+                                    index,
+                                    FormatFailure(
+                                        file_path,
+                                        "ruff",
+                                        f"Error processing {file_path}: {e}",
+                                    ),
+                                )
+                            )
+        finally:
+            # Ensure progress bar shows 100% before closing
+            self.progress.close_progress_bar(pbar, total_files)
+
+        failures.sort(key=lambda item: item[0])
+        return (
+            tuple(failure for _, failure in failures),
+            processed_files,
+            error_occurred,
+        )
+
+    def run_format_parallel(
+        self, files: list[Path], env: dict, quiet: bool, unsafe: bool
+    ) -> tuple[FormatFailure, ...]:
+        """Run format commands in parallel with caching.
+
+        Returns every failure in input order; an empty tuple means every file
+        succeeded. Truncation for step-by-step mode happens in the path
+        handler, not here (#164, review F3).
+        """
+        # Check if we're in test environment
+        is_test = "PYTEST_CURRENT_TEST" in os.environ
+
+        # Skip caching in test environment to speed up tests. Nothing is loaded
+        # up front: the ledger answers each file's hit, and the entries are
+        # written per file as they succeed (the cache is per-entry files, not
+        # one document rewritten at the end).
+        cache: dict[str, bool] = {}
+        cache_hits = [0]  # Use list to allow modification in nested function
+        total_files = len(files)
+        failures: tuple[FormatFailure, ...] = ()
+        error_occurred = False
+        processed_files = 0
+
+        if files:
+            if quiet:
+                # Process files in parallel without progress bar
+                failures = self.process_files_parallel_quiet(
+                    files, env, quiet, unsafe, cache, cache_hits
+                )
+            else:
+                # Process files in parallel with progress bar
+                failures, processed_files, error_occurred = (
+                    self.process_files_parallel_with_progress(
+                        files, env, quiet, unsafe, cache, cache_hits
+                    )
+                )
+
+        # Print cache statistics only if not in test environment
+        if not quiet and total_files > 0 and not is_test:
+            self.cache.print_statistics(cache_hits[0], total_files, error_occurred)
+
+        return failures