shrinkray 0.0.0__py3-none-any.whl → 25.12.26.0__py3-none-any.whl

shrinkray/subprocess/client.py

@@ -0,0 +1,253 @@
+"""Client for communicating with the reducer subprocess."""
+
+import asyncio
+import sys
+import traceback
+import uuid
+from collections.abc import AsyncIterator
+from typing import Any
+
+from shrinkray.subprocess.protocol import (
+    ProgressUpdate,
+    Request,
+    Response,
+    deserialize,
+    serialize,
+)
+
+
+class SubprocessClient:
+    """Client for communicating with the reducer subprocess via JSON protocol."""
+
+    def __init__(self, debug_mode: bool = False):
+        self._process: asyncio.subprocess.Process | None = None
+        self._pending_responses: dict[str, asyncio.Future[Response]] = {}
+        self._progress_queue: asyncio.Queue[ProgressUpdate] = asyncio.Queue()
+        self._reader_task: asyncio.Task | None = None
+        self._completed = False
+        self._error_message: str | None = None
+        self._debug_mode = debug_mode
+
+    async def start(self) -> None:
+        """Launch the subprocess."""
+        # In debug mode, inherit stderr so interestingness test output
+        # goes directly to the parent process's stderr
+        self._process = await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-m",
+            "shrinkray.subprocess.worker",
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=sys.stderr,
+        )
+        self._reader_task = asyncio.create_task(self._read_output())
+
+    async def _read_output(self) -> None:
+        """Read and dispatch messages from subprocess stdout."""
+        if self._process is None or self._process.stdout is None:
+            return
+
+        buffer = b""
+        while True:
+            try:
+                chunk = await self._process.stdout.read(4096)
+                if not chunk:
+                    break
+                buffer += chunk
+                while b"\n" in buffer:
+                    line, buffer = buffer.split(b"\n", 1)
+                    if line:
+                        await self._handle_message(line.decode("utf-8"))
+            except Exception:
+                traceback.print_exc()
+                break
+
+    async def _handle_message(self, line: str) -> None:
+        """Handle a message from the subprocess."""
+        try:
+            msg = deserialize(line)
+        except Exception:
+            traceback.print_exc()
+            return
+
+        if isinstance(msg, ProgressUpdate):
+            await self._progress_queue.put(msg)
+        elif isinstance(msg, Response):
+            # Check for completion or error signal (unsolicited responses with empty id)
+            if msg.id == "":
+                if msg.result and msg.result.get("status") == "completed":
+                    self._completed = True
+                    # Wake up any pending futures
+                    for future in self._pending_responses.values():
+                        if not future.done():
+                            future.set_exception(Exception("Subprocess completed"))
+                elif msg.error:
+                    self._completed = True
+                    self._error_message = msg.error
+                    # Wake up any pending futures with the error
+                    for future in self._pending_responses.values():
+                        if not future.done():
+                            future.set_exception(Exception(msg.error))
+                return
+
+            # Match response to pending request
+            if msg.id in self._pending_responses:
+                future = self._pending_responses.pop(msg.id)
+                if not future.done():
+                    future.set_result(msg)
+
+    async def send_command(
+        self, command: str, params: dict[str, Any] | None = None
+    ) -> Response:
+        """Send a command to the subprocess and wait for response."""
+        if self._process is None or self._process.stdin is None:
+            raise RuntimeError("Subprocess not started")
+
+        request_id = str(uuid.uuid4())
+        request = Request(id=request_id, command=command, params=params or {})
+
+        # Create future for response
+        future: asyncio.Future[Response] = asyncio.get_event_loop().create_future()
+        self._pending_responses[request_id] = future
+
+        # Send request
+        line = serialize(request) + "\n"
+        self._process.stdin.write(line.encode("utf-8"))
+        await self._process.stdin.drain()
+
+        # Wait for response
+        try:
+            return await future
+        except Exception:
+            self._pending_responses.pop(request_id, None)
+            raise
+
+    async def start_reduction(
+        self,
+        file_path: str,
+        test: list[str],
+        parallelism: int | None = None,
+        timeout: float = 1.0,
+        seed: int = 0,
+        input_type: str = "all",
+        in_place: bool = False,
+        formatter: str = "default",
+        volume: str = "normal",
+        no_clang_delta: bool = False,
+        clang_delta: str = "",
+        trivial_is_error: bool = True,
+    ) -> Response:
+        """Start the reduction process."""
+        params = {
+            "file_path": file_path,
+            "test": test,
+            "timeout": timeout,
+            "seed": seed,
+            "input_type": input_type,
+            "in_place": in_place,
+            "formatter": formatter,
+            "volume": volume,
+            "no_clang_delta": no_clang_delta,
+            "clang_delta": clang_delta,
+            "trivial_is_error": trivial_is_error,
+        }
+        if parallelism is not None:
+            params["parallelism"] = parallelism
+        return await self.send_command("start", params)
+
+    async def get_status(self) -> Response:
+        """Get current reduction status."""
+        return await self.send_command("status")
+
+    async def cancel(self) -> Response:
+        """Cancel the reduction."""
+        if self._completed:
+            return Response(id="", result={"status": "already_completed"})
+        if self._process is None or self._process.returncode is not None:
+            return Response(id="", result={"status": "process_exited"})
+        try:
+            return await self.send_command("cancel")
+        except Exception:
+            return Response(id="", result={"status": "cancelled"})
+
+    async def disable_pass(self, pass_name: str) -> Response:
+        """Disable a reduction pass by name."""
+        if self._completed:
+            return Response(id="", result={"status": "already_completed"})
+        try:
+            return await self.send_command("disable_pass", {"pass_name": pass_name})
+        except Exception:
+            traceback.print_exc()
+            return Response(id="", error="Failed to disable pass")
+
+    async def enable_pass(self, pass_name: str) -> Response:
+        """Enable a previously disabled reduction pass."""
+        if self._completed:
+            return Response(id="", result={"status": "already_completed"})
+        try:
+            return await self.send_command("enable_pass", {"pass_name": pass_name})
+        except Exception:
+            traceback.print_exc()
+            return Response(id="", error="Failed to enable pass")
+
+    async def skip_current_pass(self) -> Response:
+        """Skip the currently running pass."""
+        if self._completed:
+            return Response(id="", result={"status": "already_completed"})
+        try:
+            return await self.send_command("skip_pass")
+        except Exception:
+            traceback.print_exc()
+            return Response(id="", error="Failed to skip pass")
+
+    async def get_progress_updates(self) -> AsyncIterator[ProgressUpdate]:
+        """Yield progress updates as they arrive."""
+        while not self._completed:
+            try:
+                update = await asyncio.wait_for(self._progress_queue.get(), timeout=0.5)
+                yield update
+            except TimeoutError:
+                continue
+
+    @property
+    def is_completed(self) -> bool:
+        """Check if the reduction has completed."""
+        return self._completed
+
+    @property
+    def error_message(self) -> str | None:
+        """Get the error message if the subprocess failed."""
+        return self._error_message
+
+    async def close(self) -> None:
+        """Close the subprocess."""
+        if self._reader_task is not None:
+            self._reader_task.cancel()
+            try:
+                await self._reader_task
+            except asyncio.CancelledError:
+                pass
+
+        if self._process is not None:
+            if self._process.stdin is not None:
+                try:
+                    self._process.stdin.close()
+                except Exception:
+                    traceback.print_exc()
+            # Only terminate if still running
+            if self._process.returncode is None:
+                try:
+                    self._process.terminate()
+                    await asyncio.wait_for(self._process.wait(), timeout=5.0)
+                except TimeoutError:
+                    self._process.kill()
+                    await self._process.wait()
+                except ProcessLookupError:
+                    pass  # Process already exited
+
+    async def __aenter__(self) -> "SubprocessClient":
+        await self.start()
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        await self.close()

shrinkray/subprocess/protocol.py

@@ -0,0 +1,190 @@
+"""Line-oriented JSON protocol for subprocess communication."""
+
+import base64
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Request:
+    """A command request from the UI to the worker subprocess."""
+
+    id: str
+    command: str
+    params: dict = field(default_factory=dict)
+
+
+@dataclass
+class Response:
+    """A response from the worker subprocess to the UI."""
+
+    id: str
+    result: Any = None
+    error: str | None = None
+
+
+@dataclass
+class ProgressUpdate:
+    """An unsolicited progress update from the worker subprocess."""
+
+    # Current reducer pass/pump status
+    status: str
+    # Size information
+    size: int
+    original_size: int
+    # Call statistics
+    calls: int
+    reductions: int
+    interesting_calls: int = 0
+    wasted_calls: int = 0
+    # Runtime in seconds
+    runtime: float = 0.0
+    # Parallelism stats
+    parallel_workers: int = 0
+    average_parallelism: float = 0.0
+    effective_parallelism: float = 0.0
+    # Time since last reduction
+    time_since_last_reduction: float = 0.0
+    # Content preview (truncated for large files)
+    content_preview: str = ""
+    # Whether content is hex mode
+    hex_mode: bool = False
+    # Pass statistics (only passes with test evaluations)
+    pass_stats: list["PassStatsData"] = field(default_factory=list)
+    # Currently running pass name (for highlighting)
+    current_pass_name: str = ""
+    # List of disabled pass names
+    disabled_passes: list[str] = field(default_factory=list)
+
+
+@dataclass
+class PassStatsData:
+    """Statistics for a single pass (serializable)."""
+
+    pass_name: str
+    bytes_deleted: int
+    run_count: int
+    test_evaluations: int
+    successful_reductions: int
+    success_rate: float
+
+
+def serialize(msg: Request | Response | ProgressUpdate) -> str:
+    """Serialize a message to a JSON line (without newline)."""
+    if isinstance(msg, Request):
+        data = {
+            "id": msg.id,
+            "command": msg.command,
+            "params": msg.params,
+        }
+    elif isinstance(msg, Response):
+        data = {
+            "id": msg.id,
+            "result": msg.result,
+            "error": msg.error,
+        }
+    elif isinstance(msg, ProgressUpdate):
+        data = {
+            "type": "progress",
+            "data": {
+                "status": msg.status,
+                "size": msg.size,
+                "original_size": msg.original_size,
+                "calls": msg.calls,
+                "reductions": msg.reductions,
+                "interesting_calls": msg.interesting_calls,
+                "wasted_calls": msg.wasted_calls,
+                "runtime": msg.runtime,
+                "parallel_workers": msg.parallel_workers,
+                "average_parallelism": msg.average_parallelism,
+                "effective_parallelism": msg.effective_parallelism,
+                "time_since_last_reduction": msg.time_since_last_reduction,
+                "content_preview": msg.content_preview,
+                "hex_mode": msg.hex_mode,
+                "pass_stats": [
+                    {
+                        "pass_name": ps.pass_name,
+                        "bytes_deleted": ps.bytes_deleted,
+                        "run_count": ps.run_count,
+                        "test_evaluations": ps.test_evaluations,
+                        "successful_reductions": ps.successful_reductions,
+                        "success_rate": ps.success_rate,
+                    }
+                    for ps in msg.pass_stats
+                ],
+                "current_pass_name": msg.current_pass_name,
+                "disabled_passes": msg.disabled_passes,
+            },
+        }
+    else:
+        raise TypeError(f"Cannot serialize {msg!r}")
+    return json.dumps(data, separators=(",", ":"))
+
+
+def deserialize(line: str) -> Request | Response | ProgressUpdate:
+    """Deserialize a JSON line to a message object."""
+    data = json.loads(line)
+
+    # Check for progress update (has "type" field)
+    if data.get("type") == "progress":
+        d = data["data"]
+
+        # Parse pass stats
+        pass_stats_data = []
+        for ps_dict in d.get("pass_stats", []):
+            pass_stats_data.append(
+                PassStatsData(
+                    pass_name=ps_dict["pass_name"],
+                    bytes_deleted=ps_dict["bytes_deleted"],
+                    run_count=ps_dict["run_count"],
+                    test_evaluations=ps_dict["test_evaluations"],
+                    successful_reductions=ps_dict["successful_reductions"],
+                    success_rate=ps_dict["success_rate"],
+                )
+            )
+
+        return ProgressUpdate(
+            status=d["status"],
+            size=d["size"],
+            original_size=d["original_size"],
+            calls=d["calls"],
+            reductions=d["reductions"],
+            interesting_calls=d.get("interesting_calls", 0),
+            wasted_calls=d.get("wasted_calls", 0),
+            runtime=d.get("runtime", 0.0),
+            parallel_workers=d.get("parallel_workers", 0),
+            average_parallelism=d.get("average_parallelism", 0.0),
+            effective_parallelism=d.get("effective_parallelism", 0.0),
+            time_since_last_reduction=d.get("time_since_last_reduction", 0.0),
+            content_preview=d.get("content_preview", ""),
+            hex_mode=d.get("hex_mode", False),
+            pass_stats=pass_stats_data,
+            current_pass_name=d.get("current_pass_name", ""),
+            disabled_passes=d.get("disabled_passes", []),
+        )
+
+    # Check for response (has "result" or "error" field)
+    if "result" in data or "error" in data:
+        return Response(
+            id=data["id"],
+            result=data.get("result"),
+            error=data.get("error"),
+        )
+
+    # Otherwise it's a request
+    return Request(
+        id=data["id"],
+        command=data["command"],
+        params=data.get("params", {}),
+    )
+
+
+def encode_bytes(data: bytes) -> str:
+    """Encode bytes to base64 string for JSON transport."""
+    return base64.b64encode(data).decode("ascii")
+
+
+def decode_bytes(data: str) -> bytes:
+    """Decode base64 string back to bytes."""
+    return base64.b64decode(data.encode("ascii"))