codetool-shell 0.1.1__py3-none-win_amd64.whl

codetool_shell/filters/traceback/reducer.py

@@ -0,0 +1,141 @@
+"""Reducer for standalone Python traceback output."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..text import join_preserving_final_newline, score, split_preserving_final_newline
+from .detector import TracebackBlock, TracebackEvent, TracebackFrame, parse_python_traceback
+from .summary import exception_type, is_repo_looking_path
+
+
+@dataclass(frozen=True)
+class FrameGroup:
+    """Consecutive identical frames collapsed into one group."""
+
+    frame: TracebackFrame
+    repeat_count: int = 1
+
+
+def compress_traceback_output(text: str) -> str:
+    """Compress clear standalone Python tracebacks."""
+
+    lines, final_newline = split_preserving_final_newline(text)
+    parsed = parse_python_traceback(lines)
+    if parsed is None:
+        return text
+
+    candidate_lines = _reduce_lines(lines, parsed.events)
+    if len(candidate_lines) < 4:
+        return text
+
+    candidate = join_preserving_final_newline(candidate_lines, final_newline)
+    if score(candidate) < score(text):
+        return candidate
+    return text
+
+
+def _reduce_lines(lines: list[str], events: tuple[TracebackEvent, ...]) -> list[str]:
+    blocks = [event for event in events if isinstance(event, TracebackBlock)]
+    last_exception = blocks[-1].exception
+    selected = [f"python traceback: {exception_type(last_exception)}"]
+    cursor = 0
+
+    for event in events:
+        selected.extend(_reduce_noise(lines[cursor : event.start], "pre-traceback"))
+        if isinstance(event, TracebackBlock):
+            selected.extend(_reduce_block(event))
+        else:
+            selected.append(event.line)
+        cursor = event.end
+
+    selected.extend(_reduce_noise(lines[cursor:], "post-traceback"))
+    return _drop_blank_and_adjacent_duplicates(selected)
+
+
+def _reduce_block(block: TracebackBlock) -> list[str]:
+    selected = ["Traceback (most recent call last):"]
+    groups = _collapse_repeated_frames(block.frames)
+    selected_indices = set(_select_group_indices(groups))
+    omitted = 0
+
+    def flush_omitted() -> None:
+        nonlocal omitted
+        if omitted:
+            plural = "" if omitted == 1 else "s"
+            selected.append(f"… {omitted} stack frame{plural} omitted")
+            omitted = 0
+
+    for index, group in enumerate(groups):
+        if index not in selected_indices:
+            omitted += group.repeat_count
+            continue
+
+        flush_omitted()
+        selected.append(group.frame.line)
+        if group.repeat_count > 1:
+            repeated = group.repeat_count - 1
+            plural = "" if repeated == 1 else "s"
+            selected.append(f"… {repeated} repeated stack frame{plural} omitted")
+        if _should_keep_context(index, selected_indices, group.frame):
+            selected.extend(group.frame.context)
+
+    flush_omitted()
+    selected.append(block.exception)
+    return selected
+
+
+def _collapse_repeated_frames(frames: tuple[TracebackFrame, ...]) -> list[FrameGroup]:
+    groups: list[FrameGroup] = []
+    for frame in frames:
+        if groups and _frame_key(groups[-1].frame) == _frame_key(frame):
+            previous = groups[-1]
+            groups[-1] = FrameGroup(previous.frame, previous.repeat_count + 1)
+            continue
+        groups.append(FrameGroup(frame))
+    return groups
+
+
+def _select_group_indices(groups: list[FrameGroup]) -> list[int]:
+    if len(groups) <= 8:
+        return list(range(len(groups)))
+
+    selected = {0, 1}
+    selected.update(range(max(0, len(groups) - 3), len(groups)))
+    for index, group in enumerate(groups):
+        if is_repo_looking_path(group.frame.path):
+            selected.add(index)
+    return sorted(selected)
+
+
+def _should_keep_context(
+    index: int,
+    selected_indices: set[int],
+    frame: TracebackFrame,
+) -> bool:
+    if not frame.context:
+        return False
+    return index == max(selected_indices) or any("^" in line for line in frame.context)
+
+
+def _reduce_noise(lines: list[str], label: str) -> list[str]:
+    cleaned = [line.strip() for line in lines if line.strip()]
+    if len(cleaned) <= 3:
+        return cleaned
+    omitted = len(cleaned) - 2
+    return [cleaned[0], f"… {omitted} {label} lines omitted", cleaned[-1]]
+
+
+def _frame_key(frame: TracebackFrame) -> tuple[str, tuple[str, ...]]:
+    return (frame.line, frame.context)
+
+
+def _drop_blank_and_adjacent_duplicates(lines: list[str]) -> list[str]:
+    output: list[str] = []
+    for line in lines:
+        if not line:
+            continue
+        if output and output[-1] == line:
+            continue
+        output.append(line)
+    return output

codetool_shell/filters/traceback/summary.py

@@ -0,0 +1,122 @@
+"""Line classifiers for standalone Python tracebacks."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class FrameLine:
+    """A parsed Python traceback frame line."""
+
+    line: str
+    path: str
+
+
+_FRAME_RE = re.compile(r'^\s*File "([^"]+)", line ([1-9]\d*)(?:, in (.+))?$')
+_EXCEPTION_RE = re.compile(
+    r"^(?:[A-Za-z_][\w]*\.)*[A-Za-z_][\w]*"
+    r"(?:Error|Exception|Warning|Interrupt|Exit|Iteration|Timeout|Cancelled|Abort|Failure|Failed)"
+    r"(?:[:(].*)?$"
+)
+
+
+def is_traceback_header(line: str) -> bool:
+    """Return true for the canonical Python traceback header."""
+
+    return line.strip() == "Traceback (most recent call last):"
+
+
+def is_chain_separator(line: str) -> bool:
+    """Return true for Python chained-exception separator text."""
+
+    stripped = line.strip()
+    return stripped in {
+        "During handling of the above exception, another exception occurred:",
+        "The above exception was the direct cause of the following exception:",
+        "The above exception was the context of the following exception:",
+    }
+
+
+def parse_frame_line(line: str) -> FrameLine | None:
+    """Parse a Python traceback frame line."""
+
+    match = _FRAME_RE.match(line)
+    if match is None:
+        return None
+    return FrameLine(line=line.strip(), path=match.group(1))
+
+
+def is_unindented_exception_summary(line: str) -> bool:
+    """Return true for an exception summary line outside source indentation."""
+
+    if line[:1].isspace():
+        return False
+    return _EXCEPTION_RE.match(line.strip()) is not None
+
+
+def exception_type(exception_line: str) -> str:
+    """Return the exception class/type prefix from a summary line."""
+
+    return exception_line.split(":", 1)[0].split("(", 1)[0].strip()
+
+
+def is_context_line(line: str) -> bool:
+    """Return true for source/caret/context lines following a frame."""
+
+    stripped = line.strip()
+    return bool(line[:1].isspace() or is_previous_line_repeated(stripped))
+
+
+def is_previous_line_repeated(line: str) -> bool:
+    """Return true for CPython repeated-frame summary lines."""
+
+    stripped = line.strip()
+    return stripped.startswith("[Previous line repeated ") and stripped.endswith("]")
+
+
+def normalize_context_line(line: str) -> str:
+    """Trim traceback indentation while preserving source/caret alignment."""
+
+    if line.startswith("    "):
+        return line[4:]
+    return line.strip()
+
+
+def normalize_selected_line(line: str) -> str:
+    """Normalize a selected non-source diagnostic line."""
+
+    return line.strip()
+
+
+def is_repo_looking_path(path: str) -> bool:
+    """Return true when a frame path looks user/repo-owned rather than runtime."""
+
+    normalized = path.replace("\\", "/")
+    lower = normalized.lower()
+    if normalized.startswith("<"):
+        return True
+    if any(
+        marker in lower
+        for marker in (
+            "/site-packages/",
+            "/dist-packages/",
+            "/lib/python",
+            "/lib64/python",
+            "/python3.",
+            "/importlib/",
+        )
+    ):
+        return False
+    if lower.startswith(("/usr/lib/", "/usr/local/lib/", "/opt/hostedtoolcache/")):
+        return False
+    return (
+        not normalized.startswith("/")
+        or normalized.startswith(("./", "../", "~/"))
+        or "/workspace/" in lower
+        or "/workspaces/" in lower
+        or "/src/" in lower
+        or "/tests/" in lower
+        or lower.startswith(("/home/", "/users/"))
+    )

codetool_shell/filters/tree.py

@@ -0,0 +1,59 @@
+"""Compact path-tree rendering for filters that repeat paths."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class TreeRow:
+    path: str
+    suffix: str = ""
+    children: tuple[str, ...] = ()
+
+
+@dataclass
+class _TreeNode:
+    children: dict[str, "_TreeNode"] = field(default_factory=dict)
+    rows: list[TreeRow] = field(default_factory=list)
+
+
+def format_tree(rows: list[TreeRow]) -> str:
+    root = _TreeNode()
+    for row in rows:
+        node = root
+        for part in _path_parts(row.path):
+            node = node.children.setdefault(part, _TreeNode())
+        node.rows.append(row)
+
+    lines: list[str] = []
+    _render_tree(root, lines, depth=0)
+    return "\n".join(lines)
+
+
+def _path_parts(path: str) -> list[str]:
+    clean = _clean_path(path)
+    parts = [part for part in clean.split("/") if part]
+    if clean.startswith("/") and parts:
+        parts[0] = "/" + parts[0]
+    return parts or ["."]
+
+
+def _clean_path(path: str) -> str:
+    clean = path.replace("\\", "/")
+    while clean.startswith("./"):
+        clean = clean[2:]
+    return clean or "."
+
+
+def _render_tree(node: _TreeNode, lines: list[str], *, depth: int) -> None:
+    indent = " " * depth
+    for name, child in node.children.items():
+        if child.rows and not child.children:
+            for row in child.rows:
+                lines.append(f"{indent}{name}{row.suffix}")
+                for entry in row.children:
+                    lines.append(f"{indent} {entry}")
+        else:
+            lines.append(f"{indent}{name}/")
+            _render_tree(child, lines, depth=depth + 1)

codetool_shell/python_backend.py

@@ -0,0 +1,38 @@
+"""Pure-Python text compression backend."""
+
+from __future__ import annotations
+
+from .filters import apply_filter_pipeline
+
+
+def compress_text_python(text: str, *, max_blank_lines: int = 1) -> str:
+    """Compress text using whitespace normalization and dedicated filters."""
+
+    normalized = _normalize_and_trim_trailing_whitespace(text)
+    filtered = apply_filter_pipeline(normalized)
+    return _collapse_blank_lines(filtered, max_blank_lines=max_blank_lines)
+
+
+def _normalize_and_trim_trailing_whitespace(text: str) -> str:
+    normalized = text.replace("\r\n", "\n").replace("\r", "\n")
+    return "\n".join(line.rstrip() for line in normalized.split("\n"))
+
+
+def _collapse_blank_lines(text: str, *, max_blank_lines: int) -> str:
+    output_lines: list[str] = []
+    blank_run = 0
+
+    for line in text.splitlines():
+        if line == "":
+            blank_run += 1
+            if blank_run <= max_blank_lines:
+                output_lines.append("")
+        else:
+            blank_run = 0
+            output_lines.append(line)
+
+    output = "\n".join(output_lines)
+    if text.endswith("\n") and output_lines and not output.endswith("\n"):
+        output += "\n"
+
+    return output

codetool_shell/rust_backend.py

@@ -0,0 +1,254 @@
+"""Wrapper for the optional Rust text-compression backend."""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+ENV_BINARY = "CODETOOL_SHELL_RUST_BINARY"
+ENV_TARGET_RUNTIME = "CODETOOL_SHELL_TARGET_RUNTIME"
+ENV_TARGET_WHEEL_TAG = "CODETOOL_SHELL_TARGET_WHEEL_TAG"
+ENV_GENERIC_TARGET_RUNTIME = "CODETOOL_TARGET_RUNTIME"
+ENV_GENERIC_TARGET_WHEEL_TAG = "CODETOOL_TARGET_WHEEL_TAG"
+ENV_BINARY_NAMES = (ENV_BINARY, "CODETOOL_OUTPUT_COMPRESS_RUST_BINARY")
+ENV_TARGET_RUNTIME_NAMES = (
+    ENV_TARGET_RUNTIME,
+    "CODETOOL_OUTPUT_COMPRESS_TARGET_RUNTIME",
+    ENV_GENERIC_TARGET_RUNTIME,
+)
+RUST_BINARY_NAME = "codetool-shell-rust"
+
+SUPPORTED_RUNTIME_KEYS = (
+    "linux-x86_64",
+    "linux-aarch64",
+    "macos-x86_64",
+    "macos-arm64",
+    "windows-x86_64",
+    "windows-arm64",
+)
+
+RUNTIME_ALIASES = {
+    "darwin-x86_64": "macos-x86_64",
+    "darwin-amd64": "macos-x86_64",
+    "darwin-arm64": "macos-arm64",
+    "darwin-aarch64": "macos-arm64",
+    "macos-aarch64": "macos-arm64",
+    "macosx-x86_64": "macos-x86_64",
+    "macosx-arm64": "macos-arm64",
+    "linux-amd64": "linux-x86_64",
+    "linux-x64": "linux-x86_64",
+    "linux-arm64": "linux-aarch64",
+    "windows-amd64": "windows-x86_64",
+    "windows-x64": "windows-x86_64",
+    "windows-aarch64": "windows-arm64",
+    "win-x86_64": "windows-x86_64",
+    "win-amd64": "windows-x86_64",
+    "win-arm64": "windows-arm64",
+    "linux_x86_64": "linux-x86_64",
+    "linux_aarch64": "linux-aarch64",
+    "macos_x86_64": "macos-x86_64",
+    "macos_arm64": "macos-arm64",
+    "windows_x86_64": "windows-x86_64",
+    "windows_arm64": "windows-arm64",
+}
+
+
+class RustBackendUnavailable(RuntimeError):
+    """Raised when the Rust backend was requested but cannot be found."""
+
+
+class RustBackendError(RuntimeError):
+    """Raised when the Rust backend fails before returning compressed text."""
+
+
+def compress_text_rust(text: str, *, max_blank_lines: int = 1) -> str:
+    """Compress ``text`` through the Rust CLI backend."""
+
+    binary = find_rust_binary()
+    if binary is None:
+        raise RustBackendUnavailable(
+            "Rust backend binary not found. Set "
+            f"{ENV_BINARY} or build/stage rust/{RUST_BINARY_NAME}."
+        )
+
+    args = [
+        binary,
+        "compress",
+        "--max-blank-lines",
+        str(max_blank_lines),
+    ]
+
+    try:
+        completed = subprocess.run(
+            args,
+            input=text,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=30,
+            check=False,
+        )
+    except FileNotFoundError as exc:
+        raise RustBackendUnavailable(str(exc)) from exc
+    except subprocess.TimeoutExpired as exc:
+        raise RustBackendError("Rust backend process exceeded wrapper timeout") from exc
+    except OSError as exc:
+        raise RustBackendError(str(exc)) from exc
+
+    if completed.returncode != 0:
+        message = f"Rust backend failed with exit status {completed.returncode}"
+        if completed.stderr:
+            message += f": {completed.stderr.strip()}"
+        raise RustBackendError(message)
+
+    return completed.stdout
+
+
+def is_rust_available() -> bool:
+    """Return ``True`` if a Rust backend binary can be discovered."""
+
+    return find_rust_binary() is not None
+
+
+def find_rust_binary() -> Optional[str]:
+    """Find the Rust backend via env var, packaged/dev binary, or ``PATH``."""
+
+    env_binary = _first_env(ENV_BINARY_NAMES)
+    if env_binary:
+        found = _resolve_candidate(env_binary)
+        if found is not None:
+            return found
+
+    for candidate in _packaged_and_dev_candidates():
+        found = _resolve_candidate(str(candidate))
+        if found is not None:
+            return found
+
+    return shutil.which(_platform_binary_name())
+
+
+def _packaged_and_dev_candidates() -> list[Path]:
+    binary_name = _platform_binary_name()
+    package_dir = Path(__file__).resolve().parent
+    runtime_key = _target_runtime_key()
+    candidates: list[Path] = []
+
+    for key in _runtime_key_candidates(runtime_key):
+        candidates.append(package_dir / "bin" / key / binary_name)
+
+    candidates.extend(
+        [
+            package_dir / "bin" / binary_name,
+            package_dir / binary_name,
+        ]
+    )
+
+    for parent in package_dir.parents:
+        candidates.extend(
+            [
+                parent / "rust" / "target" / "release" / binary_name,
+                parent / "rust" / "target" / "debug" / binary_name,
+            ]
+        )
+
+    return candidates
+
+
+def _runtime_key_candidates(runtime_key: str) -> list[str]:
+    canonical = canonical_runtime_key(runtime_key)
+    candidates = [canonical]
+    for alias, target in RUNTIME_ALIASES.items():
+        if target == canonical and alias not in candidates:
+            candidates.append(alias)
+    return candidates
+
+
+def _resolve_candidate(candidate: str) -> Optional[str]:
+    path = Path(candidate).expanduser()
+
+    if path.parent != Path("."):
+        return str(path) if _is_executable(path) else None
+
+    if path.name != candidate:
+        return str(path) if _is_executable(path) else None
+
+    return shutil.which(candidate)
+
+
+def _is_executable(path: Path) -> bool:
+    return path.is_file() and os.access(path, os.X_OK)
+
+
+def _platform_binary_name(runtime_key: str | None = None) -> str:
+    key = canonical_runtime_key(runtime_key or _target_runtime_key())
+    if key.startswith("windows-"):
+        return f"{RUST_BINARY_NAME}.exe"
+    return RUST_BINARY_NAME
+
+
+def _target_runtime_key() -> str:
+    override = _first_env(ENV_TARGET_RUNTIME_NAMES)
+    if override:
+        return canonical_runtime_key(override)
+    return _runtime_key_for_system(platform.system(), platform.machine())
+
+
+def _platform_tag() -> str:
+    """Compatibility helper for tests/consumers of the runtime directory key."""
+
+    return _target_runtime_key()
+
+
+def canonical_runtime_key(key: str) -> str:
+    normalized = key.strip().lower().replace("_", "-")
+    normalized = normalized.replace("linux-x86-64", "linux-x86_64")
+    normalized = normalized.replace("macos-x86-64", "macos-x86_64")
+    normalized = normalized.replace("windows-x86-64", "windows-x86_64")
+    normalized = normalized.replace("darwin-x86-64", "darwin-x86_64")
+    normalized = RUNTIME_ALIASES.get(normalized, normalized)
+    if normalized not in SUPPORTED_RUNTIME_KEYS:
+        raise ValueError(
+            "unsupported shell runtime key "
+            f"{key!r}; expected one of: {', '.join(SUPPORTED_RUNTIME_KEYS)}"
+        )
+    return normalized
+
+
+def _first_env(names: tuple[str, ...]) -> str | None:
+    for name in names:
+        value = os.environ.get(name)
+        if value:
+            return value
+    return None
+
+
+def _runtime_key_for_system(system: str, machine: str) -> str:
+    normalized_system = (system or "").strip().lower()
+    normalized_machine = (machine or "").strip().lower().replace("_", "-")
+
+    os_key = {
+        "linux": "linux",
+        "darwin": "macos",
+        "macos": "macos",
+        "windows": "windows",
+        "mingw": "windows",
+        "msys": "windows",
+        "cygwin": "windows",
+    }.get(normalized_system, normalized_system)
+
+    arch_key = {
+        "amd64": "x86_64",
+        "x64": "x86_64",
+        "x86-64": "x86_64",
+        "x86_64": "x86_64",
+        "arm64": "arm64",
+        "aarch64": "aarch64" if os_key == "linux" else "arm64",
+    }.get(normalized_machine, normalized_machine)
+
+    return canonical_runtime_key(f"{os_key}-{arch_key}")