pcode 0.1.0__py3-none-any.whl

pcode/syntax_colors.py

@@ -0,0 +1,206 @@
+"""Derive prompt-chrome colors from the selected Pygments style.
+
+A Pygments style is written for code sitting on its own background, not for
+UI chrome, so nothing in it can be trusted as-is:
+
+- Token colors are optional. `gruvbox-light` leaves `Token.Text` uncolored.
+- `highlight_color` is only loosely related to the background. `gruvbox-dark`
+  pairs a near-white highlight (#ebdbb2) with near-white text (#dddddd), so
+  using it as the selected-row background would hide the row.
+- Nothing forces the style saved for the dark palette to actually be dark:
+  `/syntax solarized-light` is accepted while `/theme` is dark.
+
+Every derived color is therefore checked against the surface it will be
+painted on, and falls back to the palette's own value (then to a blend) when
+the contrast is too low. Brightness uses the same weighting as
+`theme.background_theme`, so "is this light or dark" means one thing here.
+"""
+
+import re
+from collections.abc import Iterable, Mapping
+
+from pygments.styles import get_style_by_name
+from pygments.token import Token
+from pygments.util import ClassNotFound
+
+# The fields a Palette is built from; every one of them is produced below.
+FIELDS = (
+    "accent",
+    "muted",
+    "surface",
+    "foreground",
+    "selected",
+    "task_heading",
+    "success",
+    "agents",
+)
+# Where each sub-agent hue comes from, in ring order. Kinds of token a style
+# tends to colour apart from functions (the accent) and strings (success).
+_AGENT_TOKENS = (
+    (Token.Keyword, Token.Name.Class),
+    (Token.Literal.Number, Token.Name.Builtin),
+    (Token.Name.Tag, Token.Name.Decorator),
+)
+
+_HEX = re.compile(r"^#?(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$")
+_WEIGHTS = (0.299, 0.587, 0.114)
+
+# Minimum brightness gap between a color and the surface behind it. Text has
+# to be read, so it demands more than a background band that only has to be
+# seen. Both are deliberately loose: the aim is to catch invisible pairings,
+# not to impose a contrast standard on a style the user chose on purpose.
+_TEXT_GAP = 0.3
+_ACCENT_GAP = 0.18
+_BAND_GAP = 0.04
+
+
+def _normalize(color: str | None) -> str | None:
+    """Return `#rrggbb`, or None when the style left the value unusable."""
+    if not color or not _HEX.match(color):
+        return None
+    digits = color.lstrip("#")
+    if len(digits) == 3:
+        digits = "".join(digit * 2 for digit in digits)
+    return f"#{digits.lower()}"
+
+
+def _rgb(color: str) -> tuple[float, ...]:
+    digits = color.lstrip("#")
+    return tuple(int(digits[index : index + 2], 16) / 255 for index in (0, 2, 4))
+
+
+def _brightness(color: str) -> float:
+    return sum(value * weight for value, weight in zip(_rgb(color), _WEIGHTS))
+
+
+def _mix(color: str, other: str, weight: float) -> str:
+    blended = (
+        round((left * (1 - weight) + right * weight) * 255)
+        for left, right in zip(_rgb(color), _rgb(other))
+    )
+    return "#" + "".join(f"{value:02x}" for value in blended)
+
+
+def _pick(
+    candidates: Iterable[str | None],
+    requirements: Iterable[tuple[str, float]],
+    default: str,
+) -> str:
+    """First candidate keeping the required brightness gap from every backdrop."""
+    requirements = tuple(requirements)
+    for candidate in candidates:
+        color = _normalize(candidate)
+        if color and all(
+            abs(_brightness(color) - _brightness(backdrop)) >= gap for backdrop, gap in requirements
+        ):
+            return color
+    return default
+
+
+def _token(style, token) -> str | None:
+    return dict(style).get(token, {}).get("color")
+
+
+def derive_colors(style_name: str, fallback: Mapping, backdrop: str | None = None) -> dict:
+    """Palette field values for `style_name`, backed by `fallback`'s values.
+
+    Without a `backdrop` the colors are meant for the popup, which paints the
+    style's own background behind them. Prompt chrome has no such background:
+    it sits on whatever the terminal paints, and a style chosen for the other
+    appearance would vanish there (`bw` hands out near-black on a dark
+    terminal). Pass the background it will actually land on, and the accents
+    are checked against that instead, falling back to the palette's own.
+
+    An unknown style name yields the fallback unchanged: a saved preference
+    can outlive the Pygments plugin that provided the style.
+    """
+    try:
+        style = get_style_by_name(style_name)
+    except ClassNotFound:
+        return {field: fallback[field] for field in FIELDS}
+
+    surface = _normalize(style.background_color) or fallback["surface"]
+    foreground = _pick(
+        (_token(style, Token.Text), fallback["foreground"]),
+        ((surface, _TEXT_GAP),),
+        "#ffffff" if _brightness(surface) < 0.5 else "#1c1c1c",
+    )
+    # The selected row is a background: it only has to separate from the
+    # surface, but whatever is written on it still has to stay readable. The
+    # palette's own `selected` is not a candidate -- it belongs to a different
+    # background, so a blend off this style's surface stays more coherent.
+    selected = _pick(
+        (style.highlight_color, getattr(style, "line_number_background_color", None)),
+        ((surface, _BAND_GAP), (foreground, _TEXT_GAP)),
+        _mix(surface, foreground, 0.25),
+    )
+    # An accent is written on the surface and on the selected row both, unless
+    # the caller named the one background that really is behind it.
+    if backdrop is None:
+        on_surface = ((surface, _ACCENT_GAP),)
+        on_selection = ((surface, _ACCENT_GAP), (selected, _ACCENT_GAP))
+        last_resort = {field: foreground for field in ("accent", "task_heading", "success")}
+        last_resort["muted"] = _mix(foreground, surface, 0.45)
+        last_resort["agents"] = (foreground,) * len(_AGENT_TOKENS)
+    else:
+        on_surface = on_selection = ((backdrop, _ACCENT_GAP),)
+        last_resort = {
+            field: fallback[field] for field in ("accent", "muted", "task_heading", "success")
+        }
+        last_resort["agents"] = fallback["agents"]
+    accent = _pick(
+        (
+            _token(style, Token.Name.Function),
+            _token(style, Token.Keyword),
+            fallback["accent"],
+        ),
+        on_selection,
+        last_resort["accent"],
+    )
+    # The tick and each hue must differ from the accent and from each other,
+    # or a sub-agent would merge with the active task (or another sub-agent).
+    # Monochrome styles (`algol`) colour everything alike, so the palette's
+    # own value is the usual answer there.
+    taken = {accent}
+
+    def distinct(candidates, resort):
+        color = _pick((c for c in candidates if _normalize(c) not in taken), on_surface, resort)
+        taken.add(color)
+        return color
+
+    success = distinct(
+        (_token(style, Token.Literal.String), fallback["success"]), last_resort["success"]
+    )
+    agents = [
+        distinct([*(_token(style, token) for token in tokens), default], resort)
+        for tokens, default, resort in zip(_AGENT_TOKENS, fallback["agents"], last_resort["agents"])
+    ]
+    return {
+        "surface": surface,
+        "foreground": foreground,
+        "selected": selected,
+        "success": success,
+        "agents": tuple(agents),
+        "accent": accent,
+        "muted": _pick(
+            (_token(style, Token.Comment), fallback["muted"]),
+            on_surface,
+            last_resort["muted"],
+        ),
+        # Apart from the accent, since the status row's detail and the session
+        # name wear it beside the accented phase. Not added to `taken`: the
+        # first sub-agent hue shares the Keyword colour on purpose.
+        "task_heading": _pick(
+            (
+                color
+                for color in (
+                    _token(style, Token.Keyword),
+                    _token(style, Token.Name.Class),
+                    fallback["task_heading"],
+                )
+                if _normalize(color) != accent
+            ),
+            on_surface,
+            last_resort["task_heading"],
+        ),
+    }

pcode/task_prompt.py

@@ -0,0 +1,28 @@
+"""Literal, quote-styled submitted prompts."""
+
+from dataclasses import dataclass
+
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.segment import Segment
+from rich.text import Text
+
+
+@dataclass(frozen=True)
+class TaskPrompt:
+    text: str
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        # Popups render prompts on a console that may carry no pcode theme.
+        style = console.get_style("pcode.accent", default="none")
+        # Leave room for a quote rail on every physical line, including wraps.
+        # On one-column terminals prioritize the text rather than the decoration.
+        prefix = "▌ " if options.max_width > 2 else ""
+        lines = console.render_lines(
+            Text(self.text, style=style),
+            options.update(width=max(1, options.max_width - len(prefix))),
+            pad=False,
+        )
+        for line in lines:
+            yield Segment(prefix, style)
+            yield from line
+            yield Segment.line()