beans-picker 0.3.0__py3-none-any.whl

beans_picker/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

beans_picker/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from beans_picker.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

beans_picker/_aio.py

@@ -0,0 +1,32 @@
+"""Small asyncio helpers and the time seams (`Sleep`, `Clock`) that waiting code takes."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+
+type Sleep = Callable[[float], Awaitable[None]]
+type Clock = Callable[[], float]
+
+
+async def gather_settled[T](*aws: Awaitable[T]) -> list[T]:
+    """Wait for every awaitable, then return their results in order, or raise the first failure by position."""
+    tasks = [asyncio.ensure_future(a) for a in aws]
+    try:
+        if tasks:
+            await asyncio.wait(tasks)
+    except BaseException:
+        for t in tasks:
+            t.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+        raise
+    # Retrieve every exception first so none is reported as never retrieved.
+    failures = [None if t.cancelled() else t.exception() for t in tasks]
+    results: list[T] = []
+    for t, exc in zip(tasks, failures, strict=True):
+        if t.cancelled():
+            raise asyncio.CancelledError
+        if exc is not None:
+            raise exc
+        results.append(t.result())
+    return results

beans_picker/_json.py

@@ -0,0 +1,101 @@
+"""Compact JSON output and JSON string literals, written by hand so every byte is fixed."""
+
+from __future__ import annotations
+
+import math
+from typing import Final
+
+from beans_picker._numbers import number_text
+
+type JsonValue = str | int | float | bool | list[JsonValue] | dict[str, JsonValue] | None
+type JsonObject = dict[str, JsonValue]
+
+_SHORT_ESCAPES: Final[dict[str, str]] = {
+    '"': '\\"',
+    "\\": "\\\\",
+    "\b": "\\b",
+    "\f": "\\f",
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+}
+
+
+def _needs_work(s: str) -> bool:
+    for ch in s:
+        c = ord(ch)
+        if c < 0x20 or ch in ('"', "\\") or 0xD800 <= c <= 0xDFFF:
+            return True
+    return False
+
+
+def quote(s: str) -> str:
+    """`s` as a JSON string literal, quotes included."""
+    if not _needs_work(s):
+        return f'"{s}"'
+    out: list[str] = ['"']
+    i = 0
+    n = len(s)
+    while i < n:
+        ch = s[i]
+        c = ord(ch)
+        short = _SHORT_ESCAPES.get(ch)
+        if short is not None:
+            out.append(short)
+        elif c < 0x20:
+            out.append(f"\\u{c:04x}")
+        elif 0xD800 <= c <= 0xDBFF and i + 1 < n and 0xDC00 <= ord(s[i + 1]) <= 0xDFFF:
+            # A pair held as two code points is one character.
+            out.append(chr(0x10000 + ((c - 0xD800) << 10) + (ord(s[i + 1]) - 0xDC00)))
+            i += 1
+        elif 0xD800 <= c <= 0xDFFF:
+            out.append(f"\\u{c:04x}")
+        else:
+            out.append(ch)
+        i += 1
+    out.append('"')
+    return "".join(out)
+
+
+def dumps(obj: object) -> str:
+    """`obj` as compact JSON (no spaces)."""
+    parts: list[str] = []
+    _write(obj, parts)
+    return "".join(parts)
+
+
+def _write(obj: object, out: list[str]) -> None:
+    if obj is None:
+        out.append("null")
+    elif isinstance(obj, bool):
+        out.append("true" if obj else "false")
+    elif isinstance(obj, int):
+        text = number_text(obj)
+        # An integer too large for a float has no finite JSON number.
+        out.append("null" if text.endswith("Infinity") else text)
+    elif isinstance(obj, float):
+        out.append(number_text(obj) if math.isfinite(obj) else "null")
+    elif isinstance(obj, str):
+        out.append(quote(obj))
+    elif isinstance(obj, dict):
+        out.append("{")
+        first = True
+        for key, value in obj.items():
+            if not isinstance(key, str):
+                raise TypeError(f"JSON object keys must be str, not {type(key).__name__}")
+            if not first:
+                out.append(",")
+            first = False
+            out.append(quote(key))
+            out.append(":")
+            _write(value, out)
+        out.append("}")
+    elif isinstance(obj, list | tuple):
+        out.append("[")
+        for i, item in enumerate(obj):
+            if i:
+                out.append(",")
+            _write(item, out)
+        out.append("]")
+    else:
+        raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")

beans_picker/_numbers.py

@@ -0,0 +1,116 @@
+"""Number rounding, formatting and parsing with the exact rules the tool outputs use."""
+
+from __future__ import annotations
+
+import math
+import re
+from decimal import ROUND_HALF_UP, Decimal
+from typing import Final
+
+from beans_picker._text import trim
+
+
+def round_half_up(x: float) -> int:
+    """The integer nearest to `x`; a tie goes up (2.5 -> 3, -2.5 -> -2)."""
+    f = math.floor(x)
+    return f + 1 if x - f >= 0.5 else f
+
+
+def round3(p: float) -> float:
+    return round_half_up(p * 1000) / 1000
+
+
+def fixed(p: float, digits: int) -> str:
+    """`p` with exactly `digits` decimals, rounded half away from zero on its exact binary value."""
+    if not math.isfinite(p) or abs(p) >= 1e21:
+        return number_text(p)
+    if p == 0:
+        p = 0.0
+    q = Decimal(p).quantize(Decimal(10) ** -digits, rounding=ROUND_HALF_UP)
+    return f"{q:f}"
+
+
+_EXP_LIMIT_HIGH: Final = 21
+_EXP_LIMIT_LOW: Final = -6
+
+
+def number_text(x: float) -> str:
+    """`x` written as in JSON output."""
+    if isinstance(x, bool):
+        return "1" if x else "0"
+    if isinstance(x, int):
+        try:
+            x = float(x)
+        except OverflowError:
+            x = math.inf if x > 0 else -math.inf
+    if math.isnan(x):
+        return "NaN"
+    if math.isinf(x):
+        return "Infinity" if x > 0 else "-Infinity"
+    if x == 0:
+        return "0"
+    sign = "-" if x < 0 else ""
+    digits, n = _shortest_digits(abs(x))
+    k = len(digits)
+    if k <= n <= _EXP_LIMIT_HIGH:
+        body = digits + "0" * (n - k)
+    elif 0 < n <= _EXP_LIMIT_HIGH:
+        body = digits[:n] + "." + digits[n:]
+    elif _EXP_LIMIT_LOW < n <= 0:
+        body = "0." + "0" * (-n) + digits
+    else:
+        e = n - 1
+        exp = f"e+{e}" if e >= 0 else f"e-{-e}"
+        body = (digits[0] + "." + digits[1:] if k > 1 else digits) + exp
+    return sign + body
+
+
+def _shortest_digits(x: float) -> tuple[str, int]:
+    text = repr(x)
+    mantissa, _, exp_text = text.partition("e")
+    exp = int(exp_text) if exp_text else 0
+    int_part, _, frac_part = mantissa.partition(".")
+    all_digits = int_part + frac_part
+    point = len(int_part) + exp
+    stripped = all_digits.lstrip("0")
+    point -= len(all_digits) - len(stripped)
+    stripped = stripped.rstrip("0")
+    return stripped, point
+
+
+_DECIMAL_RE: Final = re.compile(r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?")
+_INFINITY_RE: Final = re.compile(r"[+-]?Infinity")
+_PREFIXED_RE: Final = re.compile(r"0(?:[xX][0-9a-fA-F]+|[oO][0-7]+|[bB][01]+)")
+
+
+def parse_number(text: str) -> float:
+    """The number a text denotes, or NaN."""
+    s = trim(text)
+    if s == "":
+        return 0.0
+    if _DECIMAL_RE.fullmatch(s):
+        return float(s)
+    if _INFINITY_RE.fullmatch(s):
+        return -math.inf if s[0] == "-" else math.inf
+    if _PREFIXED_RE.fullmatch(s):
+        base = {"x": 16, "o": 8, "b": 2}[s[1].lower()]
+        try:
+            return float(int(s[2:], base))
+        except OverflowError:
+            return math.inf
+    return math.nan
+
+
+def scalar_text(v: object) -> str:
+    """A received value as text: `null`, `true`/`false`, a number in its shortest form, a list joined by commas."""
+    if v is None:
+        return "null"
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, int | float):
+        return number_text(v)
+    if isinstance(v, str):
+        return v
+    if isinstance(v, list | tuple):
+        return ",".join("" if item is None else scalar_text(item) for item in v)
+    return "[object Object]"

beans_picker/_proc.py

@@ -0,0 +1,92 @@
+"""The one place subprocesses are started."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Final, Protocol
+
+from beans_picker.errors import ProcessError
+
+DEFAULT_MAX_BYTES: Final = 1 << 20
+_CHUNK: Final = 64 * 1024
+
+
+@dataclass(frozen=True, slots=True)
+class Completed:
+    stdout: str
+    returncode: int
+
+
+class Runner(Protocol):
+    async def __call__(
+        self,
+        argv: Sequence[str],
+        /,
+        *,
+        max_bytes: int = DEFAULT_MAX_BYTES,
+        check: bool = True,
+        cwd: Path | None = None,
+    ) -> Completed: ...
+
+
+async def run(
+    argv: Sequence[str],
+    /,
+    *,
+    max_bytes: int = DEFAULT_MAX_BYTES,
+    check: bool = True,
+    cwd: Path | None = None,
+) -> Completed:
+    """Run `argv` with stdin and stderr on the null device; return stdout and the exit code."""
+    if not argv:
+        raise ProcessError("empty command")
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *argv,
+            stdin=asyncio.subprocess.DEVNULL,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+            cwd=cwd,
+        )
+    except OSError as err:
+        raise ProcessError(f"{argv[0]}: could not start: {err}") from err
+    try:
+        stdout = await _read_limited(proc, max_bytes)
+        if stdout is not None:
+            returncode = await proc.wait()
+    except BaseException:
+        await _kill(proc)
+        raise
+    if stdout is None:
+        await _kill(proc)
+        raise ProcessError(f"{argv[0]}: output exceeded {max_bytes} bytes")
+    text = stdout.decode("utf-8", errors="replace")
+    if check and returncode != 0:
+        raise ProcessError(f"{argv[0]} exited with code {returncode}", returncode=returncode, stdout=text)
+    return Completed(stdout=text, returncode=returncode)
+
+
+async def _read_limited(proc: asyncio.subprocess.Process, max_bytes: int) -> bytes | None:
+    stream = proc.stdout
+    if stream is None:  # pragma: no cover - stdout is always a pipe here
+        return b""
+    buf = bytearray()
+    while True:
+        chunk = await stream.read(_CHUNK)
+        if not chunk:
+            return bytes(buf)
+        buf += chunk
+        if len(buf) > max_bytes:
+            return None
+
+
+async def _kill(proc: asyncio.subprocess.Process) -> None:
+    if proc.returncode is None:
+        with contextlib.suppress(ProcessLookupError):
+            proc.kill()
+    # Reap the child even when the caller is being cancelled.
+    await asyncio.shield(proc.wait())

beans_picker/_stdin.py

@@ -0,0 +1,66 @@
+"""Standard input for the MCP transport, read so that a signal can end serving at once."""
+
+from __future__ import annotations
+
+import asyncio
+import fcntl
+import os
+import threading
+from typing import Final
+
+import anyio
+
+_CHUNK: Final = 65536
+
+
+class StdinLines(anyio.AsyncFile[str]):
+    """Lines of a descriptor as UTF-8 text; an empty string at end of input, as from a file."""
+
+    def __init__(self, fd: int = 0) -> None:
+        own = fcntl.fcntl(fd, fcntl.F_DUPFD_CLOEXEC, 3)
+        # The wrapped file is only there for the `AsyncFile` interface; lines come from the thread.
+        super().__init__(os.fdopen(own, "r", encoding="utf-8", errors="replace", closefd=False))
+        self._fd = own
+        self._lines: asyncio.Queue[str] | None = None
+
+    async def readline(self) -> str:
+        if self._lines is None:
+            self._lines = asyncio.Queue()
+            pump = threading.Thread(
+                target=_pump,
+                args=(self._fd, asyncio.get_running_loop(), self._lines),
+                name="beans-picker stdin",
+                daemon=True,
+            )
+            pump.start()
+        line = await self._lines.get()
+        if not line:
+            self._lines.put_nowait(line)
+        return line
+
+
+def _pump(fd: int, loop: asyncio.AbstractEventLoop, lines: asyncio.Queue[str]) -> None:
+    pending = bytearray()
+    try:
+        while chunk := os.read(fd, _CHUNK):
+            pending += chunk
+            while (end := pending.find(b"\n")) >= 0:
+                line = bytes(pending[: end + 1])
+                del pending[: end + 1]
+                if not _deliver(loop, lines, line.decode("utf-8", "replace")):
+                    return
+        if pending:
+            _deliver(loop, lines, pending.decode("utf-8", "replace"))
+    except OSError:
+        pass  # the descriptor failed: treat it as the end of input
+    finally:
+        _deliver(loop, lines, "")
+        os.close(fd)
+
+
+def _deliver(loop: asyncio.AbstractEventLoop, lines: asyncio.Queue[str], line: str) -> bool:
+    try:
+        loop.call_soon_threadsafe(lines.put_nowait, line)
+    except RuntimeError:
+        return False
+    return True

beans_picker/_text.py

@@ -0,0 +1,97 @@
+"""Text primitives shared by every layer: UTF-16 lengths, the whitespace set and regex classes."""
+
+from __future__ import annotations
+
+from typing import Final
+
+# Candidate keys and state signatures depend on this exact set; changing it changes every key.
+# U+0085 and U+200E are deliberately not in it.
+WS_CODE_POINTS: Final[tuple[int, ...]] = (
+    0x0009,
+    0x000A,
+    0x000B,
+    0x000C,
+    0x000D,
+    0x0020,
+    0x00A0,
+    0x1680,
+    *range(0x2000, 0x200B),
+    0x2028,
+    0x2029,
+    0x202F,
+    0x205F,
+    0x3000,
+    0xFEFF,
+)
+
+WS_CHARS: Final[frozenset[str]] = frozenset(chr(c) for c in WS_CODE_POINTS)
+
+_WS_STR: Final[str] = "".join(chr(c) for c in WS_CODE_POINTS)
+
+
+def _escape_class(code_points: tuple[int, ...]) -> str:
+    return "".join(f"\\u{c:04x}" for c in code_points)
+
+
+WS_CLASS_BODY: Final[str] = _escape_class(WS_CODE_POINTS)
+WS: Final[str] = f"[{WS_CLASS_BODY}]"
+NOT_WS: Final[str] = f"[^{WS_CLASS_BODY}]"
+WORD_CLASS_BODY: Final[str] = "A-Za-z0-9_"
+WORD: Final[str] = f"[{WORD_CLASS_BODY}]"
+NOT_WORD: Final[str] = f"[^{WORD_CLASS_BODY}]"
+DIGIT: Final[str] = "[0-9]"
+# Never use inside a pattern compiled with re.ASCII.
+LETTER_OR_NUMBER: Final[str] = "[^\\W_]"
+NOT_LETTER_OR_NUMBER: Final[str] = "[\\W_]"
+NOT_LINE_END: Final[str] = "[^\\n\\r\\u2028\\u2029]"
+
+
+def utf16_units(s: str) -> bytes:
+    return s.encode("utf-16-le", "surrogatepass")
+
+
+def utf16_len(s: str) -> int:
+    """The length of `s` in UTF-16 code units (an astral character counts 2)."""
+    return len(utf16_units(s)) // 2
+
+
+def _from_units(units: bytes) -> str:
+    return units.decode("utf-16-le", "surrogatepass")
+
+
+def utf16_slice(s: str, stop: int, *, start: int = 0) -> str:
+    """`s` cut to the UTF-16 unit range [start, stop)."""
+    units = utf16_units(s)
+    n = len(units) // 2
+    lo = _clamp(start, n)
+    hi = _clamp(stop, n)
+    if hi <= lo:
+        return ""
+    return _from_units(units[2 * lo : 2 * hi])
+
+
+def _clamp(i: int, n: int) -> int:
+    if i < 0:
+        return max(n + i, 0)
+    return min(i, n)
+
+
+def hash_bytes(s: str) -> bytes:
+    """The bytes that are hashed for `s`: UTF-8, with every lone surrogate replaced by U+FFFD."""
+    return s.encode("utf-16-le", "surrogatepass").decode("utf-16-le", "replace").encode("utf-8")
+
+
+def trim(s: str) -> str:
+    return s.strip(_WS_STR)
+
+
+def lstrip_ws(s: str) -> str:
+    return s.lstrip(_WS_STR)
+
+
+def rstrip_ws(s: str) -> str:
+    return s.rstrip(_WS_STR)
+
+
+def is_ws(ch: str) -> bool:
+    return ch in WS_CHARS