queue-watch 0.3.0__tar.gz → 0.4.0__tar.gz

{queue_watch-0.3.0 → queue_watch-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: queue-watch
-Version: 0.3.0
+Version: 0.4.0
 Summary: Read-only terminal dashboard for CI runs and merge queues, with mouse support
 Project-URL: Homepage, https://github.com/wolfiesch/queue-watch
 Project-URL: Issues, https://github.com/wolfiesch/queue-watch/issues
@@ -62,6 +62,7 @@ queue-watch profile add work --repo acme/api --repo acme/web
 queue-watch --config sources.toml        # any combination of sources
 queue-watch --repo owner/repo --once     # one JSON snapshot, no TUI
 queue-watch --demo                       # a simulated repository
+queue-watch --demo 2                     # two simulated repositories, as in a profile
 queue-watch --theme nord --ascii         # another Textual theme; ASCII glyphs only
 queue-watch --density comfortable        # title, owner and PR on a second line
 ```
@@ -91,6 +92,8 @@ queue-watch profile add default --repo acme/api                # opens outside a
 
 `profile add` writes Actions for each repository, plus its merge queue when the default branch has one, with the repository's name in each label. Repositories already in the profile are left alone, and anything written by hand stays. A profile is ordinary [source config](#sources), so you can add `command` and `flock-queue` sources too. When a dashboard spans several repositories, a branch name such as `main` in two of them is two rows, each labelled with its repository.
 
+![queue-watch --demo 2: two simulated repositories in one dashboard, each with its own merge queue strip, and rows that keep main and other shared branch names apart by repository](https://raw.githubusercontent.com/wolfiesch/queue-watch/main/docs/demo-profile.gif)
+
 ### Repository configs need trust
 
 A config can run commands and open SSH connections, so a `.queue-watch.toml` that arrives with a clone does nothing until you review it and run:
@@ -165,7 +168,7 @@ uv run pytest -q                        # includes SVG snapshot tests
 uv run pytest -q --snapshot-update      # after an intended layout change
 ```
 
-`docs/screenshot.png` is the wide layout snapshot rendered in a browser; `uv run python docs/record_demo.py` re-records `docs/demo.gif` (needs Chrome and ffmpeg). To release, bump `__version__` in `src/queue_watch/__init__.py`, merge, and push a matching `vX.Y.Z` tag; the release workflow tests, builds, publishes to PyPI with trusted publishing, and creates the GitHub release.
+`docs/screenshot.png` is the wide layout snapshot rendered in a browser; `uv run python docs/record_demo.py` re-records `docs/demo.gif`, and `--repos 2` records `docs/demo-profile.gif` (both need Chrome and ffmpeg). To release, bump `__version__` in `src/queue_watch/__init__.py`, merge, and push a matching `vX.Y.Z` tag; the release workflow tests, builds, publishes to PyPI with trusted publishing, and creates the GitHub release.
 
 ## License
 

{queue_watch-0.3.0 → queue_watch-0.4.0}/README.md

@@ -35,6 +35,7 @@ queue-watch profile add work --repo acme/api --repo acme/web
 queue-watch --config sources.toml        # any combination of sources
 queue-watch --repo owner/repo --once     # one JSON snapshot, no TUI
 queue-watch --demo                       # a simulated repository
+queue-watch --demo 2                     # two simulated repositories, as in a profile
 queue-watch --theme nord --ascii         # another Textual theme; ASCII glyphs only
 queue-watch --density comfortable        # title, owner and PR on a second line
 ```
@@ -64,6 +65,8 @@ queue-watch profile add default --repo acme/api                # opens outside a
 
 `profile add` writes Actions for each repository, plus its merge queue when the default branch has one, with the repository's name in each label. Repositories already in the profile are left alone, and anything written by hand stays. A profile is ordinary [source config](#sources), so you can add `command` and `flock-queue` sources too. When a dashboard spans several repositories, a branch name such as `main` in two of them is two rows, each labelled with its repository.
 
+![queue-watch --demo 2: two simulated repositories in one dashboard, each with its own merge queue strip, and rows that keep main and other shared branch names apart by repository](https://raw.githubusercontent.com/wolfiesch/queue-watch/main/docs/demo-profile.gif)
+
 ### Repository configs need trust
 
 A config can run commands and open SSH connections, so a `.queue-watch.toml` that arrives with a clone does nothing until you review it and run:
@@ -138,7 +141,7 @@ uv run pytest -q                        # includes SVG snapshot tests
 uv run pytest -q --snapshot-update      # after an intended layout change
 ```
 
-`docs/screenshot.png` is the wide layout snapshot rendered in a browser; `uv run python docs/record_demo.py` re-records `docs/demo.gif` (needs Chrome and ffmpeg). To release, bump `__version__` in `src/queue_watch/__init__.py`, merge, and push a matching `vX.Y.Z` tag; the release workflow tests, builds, publishes to PyPI with trusted publishing, and creates the GitHub release.
+`docs/screenshot.png` is the wide layout snapshot rendered in a browser; `uv run python docs/record_demo.py` re-records `docs/demo.gif`, and `--repos 2` records `docs/demo-profile.gif` (both need Chrome and ffmpeg). To release, bump `__version__` in `src/queue_watch/__init__.py`, merge, and push a matching `vX.Y.Z` tag; the release workflow tests, builds, publishes to PyPI with trusted publishing, and creates the GitHub release.
 
 ## License
 

{queue_watch-0.3.0 → queue_watch-0.4.0}/src/queue_watch/__init__.py

@@ -1,3 +1,3 @@
 """Read-only terminal dashboard for CI runs and merge queues."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{queue_watch-0.3.0 → queue_watch-0.4.0}/src/queue_watch/adapters/github_actions.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import re
 from datetime import UTC, datetime
 
@@ -28,6 +29,7 @@ STATES = {
     "stale": "neutral",
 }
 PAGE = 100
+ETAGS = 200  # cached responses kept for revalidation: the run lists plus recent job lists
 
 
 def state_of(item: dict) -> tuple[str, str]:
@@ -44,6 +46,41 @@ class GitHubActions(Adapter):
         if not re.fullmatch(r"[\w.-]+/[\w.-]+", repo):
             raise ValueError(f"repo must be owner/repo, got {repo!r}")
         self.repo = repo
+        self.etags: dict[str, tuple[str, object, bool]] = {}
+
+    async def get(self, endpoint: str) -> tuple[object, bool]:
+        """GET one page, sending back the last ETag; returns ``(body, more_pages)``.
+
+        GitHub does not count a 304 against the rate limit, so a page that has not
+        changed since the last poll costs nothing. The cache is per page: a 304 says
+        nothing about later pages, so callers that need them still fetch them.
+        """
+        argv = ["gh", "api", "--include", endpoint]
+        cached = self.etags.get(endpoint)
+        if cached:
+            argv += ["--header", f"If-None-Match: {cached[0]}"]
+        returncode, stdout, stderr = await process.capture(argv)
+        head, _, body = stdout.decode(errors="replace").replace("\r\n", "\n").partition("\n\n")
+        status, *lines = head.split("\n")
+        if cached and status.split()[1:2] == ["304"]:
+            if endpoint in self.etags:  # evictions can run while this request was out
+                self.etags[endpoint] = self.etags.pop(endpoint)  # most recently used last
+            return cached[1], cached[2]
+        if returncode:
+            raise process.failure(argv, returncode, stderr)
+        headers = {}
+        for line in lines:
+            name, sep, value = line.partition(":")
+            if sep:
+                headers[name.strip().lower()] = value.strip()
+        data = json.loads(body)
+        more = 'rel="next"' in headers.get("link", "")
+        self.etags.pop(endpoint, None)
+        if headers.get("etag"):
+            self.etags[endpoint] = (headers["etag"], data, more)
+            while len(self.etags) > ETAGS:
+                self.etags.pop(next(iter(self.etags)))
+        return data, more
 
     async def snapshot(self) -> dict:
         # Fetch each active state separately: an old queued run must not disappear
@@ -52,7 +89,8 @@ class GitHubActions(Adapter):
             endpoint = f"repos/{self.repo}/actions/runs?per_page={PAGE}"
             if status:
                 endpoint += "&status=" + status
-            return await process.run_json(["gh", "api", endpoint])
+            page, _ = await self.get(endpoint)
+            return page
 
         statuses = (*ACTIVE_STATUSES, None)
         pages = await asyncio.gather(*(fetch(status) for status in statuses))
@@ -113,16 +151,12 @@ class GitHubActions(Adapter):
         }
 
     async def children(self, record: dict) -> list[dict]:
-        # Paginate so large platform matrices are not silently truncated.
-        pages = await process.run_json(
-            [
-                "gh",
-                "api",
-                "--paginate",
-                "--slurp",
-                f"repos/{self.repo}/actions/runs/{int(record['id'])}/jobs?per_page={PAGE}",
-            ]
-        )
+        endpoint = f"repos/{self.repo}/actions/runs/{int(record['id'])}/jobs?per_page={PAGE}"
+        first, more = await self.get(endpoint)
+        pages = [first]
+        if more:
+            # Paginate so large platform matrices are not silently truncated.
+            pages = await process.run_json(["gh", "api", "--paginate", "--slurp", endpoint])
         jobs = []
         for job in (job for page in pages for job in page["jobs"]):
             state, raw = state_of(job)

{queue_watch-0.3.0 → queue_watch-0.4.0}/src/queue_watch/app.py

@@ -132,6 +132,7 @@ Screen { background: $surface; }
 .queue-head .took-stats { width: auto; }
 .queue-head .depth, .queue-head .took { display: none; }
 .queue.-depth .queue-head .depth, .queue.-took .queue-head .took { display: block; }
+.queue.-took.-took-flat .queue-head .took.spark { display: none; }
 .-narrow .queue .queue-head .spark, .-narrow .queue .queue-head .depth { display: none; }
 Sparkline > .sparkline--max-color { color: $error; }
 Sparkline > .sparkline--min-color { color: $success; }
@@ -473,7 +474,8 @@ class QueueWatch(App):
         self.query_one(ChangeTable).show(visible, queue, self.selected, empty)
         tabs = self.query_one("#tabs", TabbedContent)
         tabs.get_tab(CHANGES).label = f"Changes {len(visible)}"
-        for source_id, strip in self.strips.items():
+        # Snapshot: awaiting show() lets a concurrent fetch mount a new strip.
+        for source_id, strip in list(self.strips.items()):
             records = snapshots.get(source_id, {}).get("records", [])
             mine = {
                 rid: change for (sid, rid), change in self.by_record.items() if sid == source_id
@@ -842,7 +844,10 @@ class QueueWatch(App):
 
     @on(DataTable.RowHighlighted)
     async def row_highlighted(self, event: DataTable.RowHighlighted) -> None:
-        if not self.rendering and event.data_table.id == self.active_pane():
+        # Highlights still arrive while the app shuts down and its widgets go away.
+        if not self.is_running or self.rendering:
+            return
+        if event.data_table.id == self.active_pane():
             await self.show_selection()
 
     @on(TabbedContent.TabActivated)

{queue_watch-0.3.0 → queue_watch-0.4.0}/src/queue_watch/cli.py

@@ -18,6 +18,7 @@ Examples:
   queue-watch --config sources.toml --once
   queue-watch trust                         # after reviewing .queue-watch.toml
   queue-watch --demo                        # simulated repository, no login needed
+  queue-watch --demo 2                      # two simulated repositories, like a profile
   queue-watch profile add work --repo acme/api --repo acme/web
   queue-watch profile list
 """
@@ -144,7 +145,13 @@ def main(argv: list[str] | None = None) -> int:
     group.add_argument("--config", type=Path, help="TOML file with [[source]] tables")
     group.add_argument("--profile", help="NAME for ~/.config/queue-watch/NAME.toml")
     group.add_argument(
-        "--demo", action="store_true", help="simulated repository; no network or login"
+        "--demo",
+        nargs="?",
+        const=1,
+        type=int,
+        choices=(1, 2),
+        metavar="REPOS",
+        help="simulated repository, or 2 for two watched like a profile; no network or login",
     )
     parser.add_argument("--once", action="store_true", help="print JSON once; no TUI")
     parser.add_argument(
@@ -165,7 +172,7 @@ def main(argv: list[str] | None = None) -> int:
 
             clock = demo.Clock()
             widgets.now = clock.now  # ages and estimates follow the simulated clock
-            sources = demo.sources(clock)
+            sources = demo.sources(clock, args.demo)
         elif args.config:
             sources = load(args.config.expanduser())
         elif args.profile:

{queue_watch-0.3.0 → queue_watch-0.4.0}/src/queue_watch/demo.py

@@ -1,4 +1,4 @@
-"""``--demo``: a made-up repository whose CI and merge queue move on their own.
+"""``--demo``: made-up repositories whose CI and merge queues move on their own.
 
 Nothing touches the network. Simulated time runs at ``SPEED`` times the wall clock
 so a minute of watching shows several merges, a failed check and its fix. Events
@@ -19,20 +19,59 @@ from .model import SCHEMA
 SPEED = 15  # simulated seconds per wall-clock second
 STEP = 30  # simulated seconds per tick
 WARMUP = 40  # ticks simulated before the first frame, so history exists
-REPO = "https://github.com/acme/widgets"
-NOTE = "Demo data: a simulated repository. Nothing here is real."
-
-PULLS = (
-    ("Stream large uploads", "feat/stream-upload", "dana"),
-    ("Cache parsed headers", "feat/parser-cache", "lee"),
-    ("Document merge queue", "docs/merge-queue", "sam"),
-    ("Fix font fallback on Windows", "fix/font-fallback", "ari"),
-    ("Faster diff rendering", "feat/diff-speed", "noor"),
-    ("Retry flaky socket reads", "fix/socket-retry", "kai"),
-    ("Bump lockfile", "chore/lockfile", "lee"),
-    ("Add CSV exporter", "feat/csv-export", "dana"),
-    ("Tidy error messages", "fix/errors", "sam"),
-    ("Theme tokens for dark mode", "feat/theme", "noor"),
+
+
+@dataclass(frozen=True)
+class Repo:
+    """One simulated repository: its pull requests and where its numbering starts."""
+
+    name: str
+    pulls: tuple[tuple[str, str, str], ...]  # title, branch, owner
+    first_pull: int
+    first_run: int
+    release: str | None  # a release run left waiting for approval on main
+    offset: int  # phase into the event patterns, so repositories move out of step
+
+    @property
+    def url(self) -> str:
+        return f"https://github.com/{self.name}"
+
+
+WIDGETS = Repo(
+    "acme/widgets",
+    (
+        ("Stream large uploads", "feat/stream-upload", "dana"),
+        ("Cache parsed headers", "feat/parser-cache", "lee"),
+        ("Document merge queue", "docs/merge-queue", "sam"),
+        ("Fix font fallback on Windows", "fix/font-fallback", "ari"),
+        ("Faster diff rendering", "feat/diff-speed", "noor"),
+        ("Retry flaky socket reads", "fix/socket-retry", "kai"),
+        ("Bump lockfile", "chore/lockfile", "lee"),
+        ("Add CSV exporter", "feat/csv-export", "dana"),
+        ("Tidy error messages", "fix/errors", "sam"),
+        ("Theme tokens for dark mode", "feat/theme", "noor"),
+    ),
+    first_pull=482,
+    first_run=9100,
+    release="v2.4.0",
+    offset=0,
+)
+# Shares branch names (main, chore/lockfile, fix/errors) with WIDGETS: a profile
+# watching both must keep them apart.
+GADGETS = Repo(
+    "acme/gadgets",
+    (
+        ("Pair over Bluetooth LE", "feat/ble-pairing", "mika"),
+        ("Bump lockfile", "chore/lockfile", "kai"),
+        ("Fix battery drain in sleep", "fix/sleep-drain", "ari"),
+        ("Firmware update screen", "feat/fw-update", "noor"),
+        ("Tidy error messages", "fix/errors", "lee"),
+        ("Calibrate the gyro at boot", "feat/gyro-cal", "dana"),
+    ),
+    first_pull=1201,
+    first_run=5300,
+    release=None,
+    offset=3,
 )
 ARRIVAL_GAPS = (2, 1, 3, 6, 7, 2, 3, 8)  # ticks between arrivals: bursts, then lulls
 CHECK_TICKS = (3, 5, 4, 6, 3)  # how long CI takes on a pull request
@@ -96,6 +135,7 @@ class Entry:
 @dataclass
 class Simulation:
     clock: Clock
+    repo: Repo = WIDGETS
     epoch: float = 0.0  # simulated time of tick 0
     tick: int = 0
     pulls: int = 0
@@ -108,7 +148,9 @@ class Simulation:
 
     def __post_init__(self) -> None:
         self.epoch = self.clock.now() - WARMUP * STEP
-        self.release = self.start_run("Release", "v2.4.0", "main", 2, 0, "blocked")
+        self.release = None
+        if self.repo.release:
+            self.release = self.start_run("Release", self.repo.release, "main", 2, 0, "blocked")
         self.advance()
 
     def at(self, tick: int) -> float:
@@ -122,8 +164,8 @@ class Simulation:
 
     def start_run(self, workflow: str, title: str, ref: str, ticks: int, salt: int, outcome: str):
         run = Run(
-            9100 + self.started, workflow, title, ref, sha(ref, salt), self.tick,
-            self.tick + ticks, outcome,
+            self.repo.first_run + self.started, workflow, title, ref, sha(self.repo.name, ref, salt),
+            self.tick, self.tick + ticks, outcome,
         )  # fmt: skip
         self.started += 1
         self.runs.append(run)
@@ -152,6 +194,7 @@ class Simulation:
                 {
                     "id": f"attempt-{self.merges}",
                     "kind": "attempt",
+                    "repo": self.repo.name,
                     "state": "failure" if failed else "success",
                     "raw_state": "failed" if failed else "merged",
                     "title": f"#{head.number} {head.title}",
@@ -160,7 +203,7 @@ class Simulation:
                     "owner": head.owner,
                     "started_at": iso(self.at(head.since)),
                     "finished_at": iso(self.at(tick)),
-                    "url": f"{REPO}/pull/{head.number}",
+                    "url": f"{self.repo.url}/pull/{head.number}",
                     "fields": {"pull_request": head.number},
                 }
             )
@@ -175,17 +218,18 @@ class Simulation:
                 first.state, first.since = "merging", tick
         del self.runs[: max(0, len(self.runs) - 14)]
         del self.attempts[: max(0, len(self.attempts) - 40)]  # about an hour of merges
-        if self.release not in self.runs:
+        if self.release and self.release not in self.runs:
             self.runs.insert(0, self.release)
 
     def arrive(self) -> None:
-        title, ref, owner = PULLS[self.pulls % len(PULLS)]
-        number = 482 + self.pulls
-        fails = self.pulls % FAILS_EVERY == FAILS_EVERY - 1
-        ticks = CHECK_TICKS[self.pulls % len(CHECK_TICKS)]
+        pulls, phase = self.repo.pulls, self.pulls + self.repo.offset
+        title, ref, owner = pulls[self.pulls % len(pulls)]
+        number = self.repo.first_pull + self.pulls
+        fails = phase % FAILS_EVERY == FAILS_EVERY - 1
+        ticks = CHECK_TICKS[phase % len(CHECK_TICKS)]
         run = self.start_run("CI", title, ref, ticks, self.tick, "failure" if fails else "success")
         self.queue.append(Entry(number, title, ref, owner, self.tick, run, fails, since=self.tick))
-        self.next_arrival = self.tick + ARRIVAL_GAPS[self.pulls % len(ARRIVAL_GAPS)]
+        self.next_arrival = self.tick + ARRIVAL_GAPS[phase % len(ARRIVAL_GAPS)]
         self.pulls += 1
 
     def run_record(self, run: Run) -> dict:
@@ -214,6 +258,7 @@ class Simulation:
         return {
             "id": str(run.id),
             "kind": "run",
+            "repo": self.repo.name,
             "state": state,
             "raw_state": {"running": "in_progress", "blocked": "waiting"}.get(state, state),
             "title": run.workflow,
@@ -222,7 +267,7 @@ class Simulation:
             "sha": run.sha,
             "created_at": iso(self.at(run.start)),
             "updated_at": iso(self.at(min(self.tick, run.end))),
-            "url": f"{REPO}/actions/runs/{run.id}",
+            "url": f"{self.repo.url}/actions/runs/{run.id}",
             "fields": {"run_id": run.id, "attempt": 1},
             "children": jobs,
         }
@@ -240,6 +285,7 @@ class Simulation:
         return {
             "id": f"entry-{entry.number}",
             "kind": "queue_entry",
+            "repo": self.repo.name,
             "state": state,
             "raw_state": raw,
             "title": f"#{entry.number} {entry.title}",
@@ -248,7 +294,7 @@ class Simulation:
             "owner": entry.owner,
             "position": position,
             "created_at": iso(self.at(entry.joined)),
-            "url": f"{REPO}/pull/{entry.number}",
+            "url": f"{self.repo.url}/pull/{entry.number}",
             "fields": fields,
         }
 
@@ -275,7 +321,7 @@ class Simulation:
             "schema": SCHEMA,
             "observed_at": iso(now),
             "records": records + self.attempts[::-1],
-            "note": NOTE,
+            "note": f"Demo data: {self.repo.name} is a simulated repository. Nothing here is real.",
         }
 
 
@@ -298,9 +344,20 @@ class DemoMergeQueue(DemoCI):
         return self.simulation.merge_queue()
 
 
-def sources(clock: Clock) -> list[Source]:
-    simulation = Simulation(clock)
-    return [
-        Source("ci", DemoCI.label, 2, DemoCI(simulation)),
-        Source("merge-queue", DemoMergeQueue.label, 2, DemoMergeQueue(simulation)),
-    ]
+def sources(clock: Clock, repos: int = 1) -> list[Source]:
+    """One simulated repository, or two watched together the way a profile would."""
+    if repos == 1:
+        simulation = Simulation(clock)
+        return [
+            Source("ci", DemoCI.label, 2, DemoCI(simulation)),
+            Source("merge-queue", DemoMergeQueue.label, 2, DemoMergeQueue(simulation)),
+        ]
+    result = []
+    for repo in (WIDGETS, GADGETS)[:repos]:
+        simulation = Simulation(clock, repo)
+        prefix, name = repo.name.replace("/", "-"), repo.name.split("/")[1]
+        result += [
+            Source(f"{prefix}-ci", f"{name} CI", 2, DemoCI(simulation)),
+            Source(f"{prefix}-merge-queue", f"{name} merge queue", 2, DemoMergeQueue(simulation)),
+        ]
+    return result

{queue_watch-0.3.0 → queue_watch-0.4.0}/src/queue_watch/process.py

@@ -29,10 +29,10 @@ def over_ssh(host: str, argv: list[str], cwd: str | None = None) -> list[str]:
     return ["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=8", host, "--", command]
 
 
-async def run_json(
+async def capture(
     argv: list[str], *, stdin: str | None = None, timeout: float = 25, cwd: str | None = None
-) -> Any:
-    """Run ``argv`` and parse stdout as JSON; a nonzero exit raises RuntimeError.
+) -> tuple[int, bytes, bytes]:
+    """Run ``argv`` and return ``(returncode, stdout, stderr)``.
 
     The command gets its own process group so a timeout also stops children that
     inherited its output pipes; otherwise they would hold the read open.
@@ -56,9 +56,21 @@ async def run_json(
         with contextlib.suppress(TimeoutError):
             await asyncio.wait_for(process.communicate(), 2)
         raise
-    if process.returncode:
-        message = stderr.decode(errors="replace").strip()[-1200:]
-        raise RuntimeError(message or f"{argv[0]} exited {process.returncode}")
+    return process.returncode, stdout, stderr
+
+
+def failure(argv: list[str], returncode: int, stderr: bytes) -> RuntimeError:
+    message = stderr.decode(errors="replace").strip()[-1200:]
+    return RuntimeError(message or f"{argv[0]} exited {returncode}")
+
+
+async def run_json(
+    argv: list[str], *, stdin: str | None = None, timeout: float = 25, cwd: str | None = None
+) -> Any:
+    """Run ``argv`` and parse stdout as JSON; a nonzero exit raises RuntimeError."""
+    returncode, stdout, stderr = await capture(argv, stdin=stdin, timeout=timeout, cwd=cwd)
+    if returncode:
+        raise failure(argv, returncode, stderr)
     return json.loads(stdout)
 
 

{queue_watch-0.3.0 → queue_watch-0.4.0}/src/queue_watch/widgets.py

@@ -12,6 +12,7 @@ import time
 from collections import deque
 from dataclasses import dataclass
 from datetime import datetime
+from itertools import pairwise
 from typing import Any
 from zoneinfo import ZoneInfo
 
@@ -391,6 +392,7 @@ class QueueChip(Static):
 
 DEPTH_SAMPLES = 120  # one per fetch: half an hour at the default 15 s interval
 SPARK_CELLS = 20
+SPARK_MIN = 4  # narrower than this a sparkline shows no trend: drop it instead
 
 
 class QueueStrip(Vertical):
@@ -408,6 +410,8 @@ class QueueStrip(Vertical):
         self.built: tuple | None = None
         # Queue length after each fetch this session; sources keep no history of it.
         self.depth: deque[int] = deque(maxlen=DEPTH_SAMPLES)
+        # Cell widths of the head row's text, for fit(): title, eta, rate, stats.
+        self.text_cells = (0, 0, 0, 0)
 
     def compose(self) -> ComposeResult:
         with Horizontal(classes="queue-head"):
@@ -447,40 +451,87 @@ class QueueStrip(Vertical):
             if self.merges:
                 last = short_age(now() - max(self.merges))
                 status += f" {SYMBOLS.dot} last merge {last} ago"
-        self.query_one(".queue-title", Static).update(Content.assemble((status, "b")))
+        title = Content.assemble((status, "b"))
+        self.query_one(".queue-title", Static).update(title)
         clears = max((eta_of(e) or 0 for e in self.entries), default=0)
-        self.query_one(".queue-eta", Static).update(
-            Content.assemble(muted("clears in "), (eta_text(clears), "b")) if clears else ""
+        eta = (
+            Content.assemble(muted("clears in "), (eta_text(clears), "b")) if clears else Content()
         )
-        # Visibility is by class so that the narrow layout's CSS can still hide sparklines.
-        self.set_class(len(self.depth) > 1, "-depth")
+        self.query_one(".queue-eta", Static).update(eta)
         if len(self.depth) > 1:
-            depth = self.query_one(".depth.spark", Sparkline)
-            depth.data = list(self.depth)
-            depth.styles.width = min(len(self.depth), SPARK_CELLS)
+            self.query_one(".depth.spark", Sparkline).data = list(self.depth)
         merged = sum(now() - finished <= 3600 for finished in self.merges)
-        self.query_one(".rate", Static).update(
+        rate = (
             Content.assemble(glyph("success"), muted(f" {merged} merged/hr"))
             if self.history
-            else ""
+            else Content()
         )
+        self.query_one(".rate", Static).update(rate)
         took = [elapsed(a) for a in self.attempts[-30:]]
         failed = sum(a["state"] == "failure" for a in self.attempts[-30:])
-        self.set_class(len(took) > 1, "-took")
+        stats = Content()
         if len(took) > 1:
-            trend = self.query_one(".took.spark", Sparkline)
-            trend.data = took
-            trend.styles.width = min(len(took), SPARK_CELLS)
-            self.query_one(".took-stats", Static).update(
-                Content.assemble(
-                    muted(
-                        f" median {human_seconds(statistics.median(took))} {SYMBOLS.dot} "
-                        f"max {human_seconds(max(took))} {SYMBOLS.dot} "
-                    ),
-                    glyph("failure"),
-                    muted(f" {failed}/{len(took)}"),
-                )
+            self.query_one(".took.spark", Sparkline).data = took
+            stats = Content.assemble(
+                muted(
+                    f" median {human_seconds(statistics.median(took))} {SYMBOLS.dot} "
+                    f"max {human_seconds(max(took))} {SYMBOLS.dot} "
+                ),
+                glyph("failure"),
+                muted(f" {failed}/{len(took)}"),
             )
+            self.query_one(".took-stats", Static).update(stats)
+        self.text_cells = tuple(c.cell_length for c in (title, eta, rate, stats))
+        self.fit()
+
+    def head_width(self, depth: int | None, took: int | None, stats: bool) -> int:
+        """Cells the head row needs with sparklines of these widths (None: hidden).
+
+        Mirrors the ``.queue-head`` rules in the app CSS: widths, margins (adjacent
+        margins collapse to the larger) and the ETA's ``min-width``."""
+        title, eta, rate, stats_cells = self.text_cells
+        boxes = [(title, 0, 0), (max(18, eta + 2), 0, 0)]  # (width, margin-left, margin-right)
+        if depth is not None:
+            boxes += [(5, 2, 0), (depth, 1, 1)]  # "depth" label, sparkline
+        boxes.append((rate, 2, 0))
+        if stats:
+            boxes.append((4, 2, 0))  # "took" label
+            if took is not None:
+                boxes.append((took, 1, 1))
+            boxes.append((stats_cells, 0, 0))
+        gaps = sum(max(left[2], right[1]) for left, right in pairwise(boxes))
+        return sum(box[0] for box in boxes) + boxes[0][1] + boxes[-1][2] + gaps
+
+    def fit(self) -> None:
+        """Size the sparklines to the room the head row's text leaves, so the counts
+        never clip: shrink both, then drop the depth trend, then the took trend."""
+        room = self.query_one(".queue-head").size.width or self.app.size.width - 4
+        stats = len(self.attempts[-30:]) > 1
+        want_depth = min(len(self.depth), SPARK_CELLS) if len(self.depth) > 1 else None
+        want_took = min(len(self.attempts), SPARK_CELLS) if stats else None
+        for depth, took in ((want_depth, want_took), (None, want_took), (None, None)):
+            spare = room - self.head_width(
+                None if depth is None else 0, None if took is None else 0, stats
+            )
+            if depth is not None and took is not None:
+                depth = min(depth, max(spare // 2, spare - took))
+                took = min(took, spare - depth)
+            elif depth is not None:
+                depth = min(depth, spare)
+            elif took is not None:
+                took = min(took, spare)
+            # A short history keeps its full length; only a shrunk trend has a floor.
+            fits = ((depth, want_depth), (took, want_took))
+            if all(cells is None or cells >= min(want, SPARK_MIN) for cells, want in fits):
+                break
+        # Visibility is by class so that the narrow layout's CSS can still hide sparklines.
+        self.set_class(depth is not None, "-depth")
+        if depth is not None:
+            self.query_one(".depth.spark").styles.width = depth
+        self.set_class(stats, "-took")
+        self.set_class(stats and took is None, "-took-flat")
+        if took is not None:
+            self.query_one(".took.spark").styles.width = took
 
     async def chain(self) -> None:
         chain = self.query_one(".chain", Horizontal)
@@ -513,6 +564,7 @@ class QueueStrip(Vertical):
         chain.display = bool(widgets)
 
     async def on_resize(self) -> None:
+        self.fit()
         if self.built is not None and self.built[0] != self.query_one(".chain").size.width:
             await self.chain()
 

{queue_watch-0.3.0 → queue_watch-0.4.0}/tests/test_app.py

@@ -367,3 +367,42 @@ def test_markup_in_adapter_strings_is_shown_literally() -> None:
             assert "[/oops]" in str(app.query_one("#tabs").get_tab("pane0-tab").label)
 
     asyncio.run(run())
+
+
+def test_queue_head_sizes_sparklines_so_counts_never_clip() -> None:
+    attempts = [
+        {
+            "id": f"a{i}",
+            "kind": "attempt",
+            "state": "failure" if i % 3 == 0 else "success",
+            "title": f"#{i} Change",
+            "ref": f"change-{i}",
+            "started_at": iso(60 - i),
+            "finished_at": iso(59.5 - i - (i % 4) / 4),  # 30 to 75 seconds
+        }
+        for i in range(30)
+    ]
+    queue_view = {"kind": "queue_entry", "label": "Queue", "columns": [{"key": "title"}]}
+
+    async def run(records: list[dict], width: int) -> list[int]:
+        app = QueueWatch([Source("mq", "MQ", 60, Fake(records, [queue_view]))])
+        async with app.run_test(size=(width, 40)) as pilot:
+            await loaded(pilot)
+            strip = app.strips["mq"]
+            strip.depth.extend([3, 5, 2, 8] * 30)  # a long session's depth history
+            strip.head()
+            await pilot.pause()
+            head = strip.query_one(".queue-head")
+            stats = strip.query_one(".took-stats", Static)
+            text = stats.render()
+            assert str(text).endswith("✗ 10/30")
+            assert stats.region.width == text.cell_length
+            assert stats.region.right <= head.region.right
+            sparks = [s.region.width for s in head.query(".spark") if s.display]
+            assert all(4 <= cells <= 20 for cells in sparks)
+            return sparks
+
+    # Queued and empty queues: the empty one's longer title leaves less room.
+    for records in (QUEUE + attempts, attempts):
+        assert asyncio.run(run(records, 120))  # at least one trend still fits
+        assert asyncio.run(run(records, 200)) == [20, 20]

queue_watch-0.4.0/tests/test_demo.py

@@ -0,0 +1,62 @@
+import asyncio
+
+import pytest
+
+from queue_watch import demo, widgets
+from queue_watch.app import QueueWatch
+from queue_watch.changes import correlate
+from queue_watch.model import validate_snapshot
+
+
+class Clock:
+    now_value = 1_800_000_000.0
+
+    def now(self) -> float:
+        return self.now_value
+
+
+@pytest.mark.parametrize("repo", [demo.WIDGETS, demo.GADGETS], ids=lambda r: r.name)
+def test_demo_queue_keeps_moving_with_valid_snapshots(repo: demo.Repo) -> None:
+    clock = Clock()
+    simulation = demo.Simulation(clock, repo)
+    lengths, merged = [], set()
+    for _ in range(400):  # 400 ticks: well past every pattern's period
+        clock.now_value += demo.STEP
+        queue = validate_snapshot(simulation.merge_queue())
+        validate_snapshot(simulation.ci())
+        entries = [r for r in queue["records"] if r["kind"] == "queue_entry"]
+        assert [e["position"] for e in entries] == list(range(1, len(entries) + 1))
+        assert sum(e["raw_state"] == "merging" for e in entries) <= 1
+        lengths.append(len(entries))
+        merged |= {r["id"] for r in queue["records"] if r["kind"] == "attempt"}
+    assert len(merged) > 100
+    assert max(lengths) <= 8  # arrivals and merges balance; the queue never runs away
+
+
+def test_two_repo_demo_keeps_shared_branches_apart() -> None:
+    clock = Clock()
+    clock.now_value += 400 * demo.STEP  # both repositories have run every pull request
+    sources = demo.sources(clock, 2)
+    assert len({s.id for s in sources}) == 4
+    snapshots = {s.id: validate_snapshot(asyncio.run(s.adapter.snapshot())) for s in sources}
+    repos = {(c.repo, c.ref) for c in correlate(snapshots)}
+    for ref in ("main", "chore/lockfile", "fix/errors"):
+        assert {("acme/widgets", ref), ("acme/gadgets", ref)} <= repos
+
+
+def test_two_repo_demo_loads_every_queue(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Four sources answer together; strips mounted mid-rebuild once crashed the app.
+    clock = demo.Clock()
+    monkeypatch.setattr(widgets, "now", clock.now)
+
+    async def run() -> None:
+        app = QueueWatch(demo.sources(clock, 2))
+        async with app.run_test(size=(112, 40)) as pilot:
+            for _ in range(100):
+                await pilot.pause(0.02)
+                if len(app.updated) == len(app.sources):
+                    break
+            await app.workers.wait_for_complete()
+            assert set(app.strips) == {"acme-widgets-merge-queue", "acme-gadgets-merge-queue"}
+
+    asyncio.run(run())

{queue_watch-0.3.0 → queue_watch-0.4.0}/tests/test_github_actions.py

@@ -1,4 +1,4 @@
-"""GitHub Actions paging, precedence and state normalization; subprocess limits."""
+"""GitHub Actions paging, precedence, revalidation and state normalization; subprocess limits."""
 
 from __future__ import annotations
 
@@ -15,9 +15,26 @@ from queue_watch.adapters.github_actions import GitHubActions
 from queue_watch.model import validate_snapshot
 
 
+def http(body, *, etag=None, link=None) -> tuple[int, bytes, bytes]:
+    """What ``gh api --include`` prints for a 200."""
+    head = ["HTTP/2.0 200 OK"] + [f"Etag: {etag}"] * bool(etag) + [f"Link: {link}"] * bool(link)
+    return 0, ("\r\n".join(head) + "\r\n\r\n" + json.dumps(body)).encode(), b""
+
+
+def not_modified(etag) -> tuple[int, bytes, bytes]:
+    """``gh api --include`` on a 304: headers only, and a nonzero exit."""
+    return 1, f"HTTP/2.0 304 Not Modified\r\nEtag: {etag}\r\n\r\n".encode(), b"gh: HTTP 304\n"
+
+
+def endpoint_of(argv) -> str:
+    return next(arg for arg in argv if arg.startswith("repos/"))
+
+
 def test_old_active_runs_survive_recent_page_and_newer_state_wins(monkeypatch):
     async def response(argv):
-        endpoint = argv[-1]
+        return http(body(endpoint_of(argv)))
+
+    def body(endpoint):
         if "status=queued" in endpoint:
             return {
                 "total_count": 101,
@@ -52,7 +69,7 @@ def test_old_active_runs_survive_recent_page_and_newer_state_wins(monkeypatch):
             ],
         }
 
-    monkeypatch.setattr(github_actions.process, "run_json", response)
+    monkeypatch.setattr(github_actions.process, "capture", response)
     snapshot = validate_snapshot(asyncio.run(GitHubActions(repo="owner/repo").snapshot()))
     assert [(r["id"], r["state"], r["raw_state"]) for r in snapshot["records"]] == [
         ("5", "blocked", "waiting"),
@@ -62,9 +79,15 @@ def test_old_active_runs_survive_recent_page_and_newer_state_wins(monkeypatch):
     assert snapshot["warnings"] == ["queued: showing first 100 of 101 runs"]
 
 
-def test_jobs_become_child_records_with_steps(monkeypatch):
+def test_jobs_become_child_records_with_steps_across_pages(monkeypatch):
+    async def first_page(argv):
+        if 'If-None-Match: W/"j"' in argv:
+            return not_modified('W/"j"')
+        return http(
+            {"jobs": []}, etag='W/"j"', link='<https://api.github.com/x?page=2>; rel="next"'
+        )
+
     async def response(argv):
-        assert "--paginate" in argv
         return [
             {
                 "jobs": [
@@ -88,15 +111,61 @@ def test_jobs_become_child_records_with_steps(monkeypatch):
             {"jobs": [{"id": 8, "name": "lint", "status": "completed", "conclusion": "skipped"}]},
         ]
 
+    monkeypatch.setattr(github_actions.process, "capture", first_page)
     monkeypatch.setattr(github_actions.process, "run_json", response)
-    jobs = asyncio.run(GitHubActions(repo="owner/repo").children({"id": "3"}))
-    assert [(j["title"], j["state"], j["fields"]["runner"]) for j in jobs] == [
-        ("test", "running", "linux-1"),
-        ("lint", "neutral", None),
-    ]
+    adapter = GitHubActions(repo="owner/repo")
+    for _ in range(2):  # the second first-page request answers 304
+        jobs = asyncio.run(adapter.children({"id": "3"}))
+        # A 304 says nothing about later pages, so every page is still fetched.
+        assert [(j["title"], j["state"], j["fields"]["runner"]) for j in jobs] == [
+            ("test", "running", "linux-1"),
+            ("lint", "neutral", None),
+        ]
     assert [(s["title"], s["state"]) for s in jobs[0]["children"]] == [("Run", "failure")]
 
 
+def test_unchanged_lists_are_revalidated_and_reuse_the_cached_body(monkeypatch):
+    etags = {}
+    queued = [{"id": 1, "status": "queued", "updated_at": "2026-10-20T03:00:00Z"}]
+    sent = []
+
+    async def response(argv):
+        endpoint = endpoint_of(argv)
+        header = next((arg for arg in argv if arg.startswith("If-None-Match: ")), None)
+        sent.append(header)
+        etag = etags.setdefault(endpoint, 'W/"1"')
+        if header == f"If-None-Match: {etag}":
+            return not_modified(etag)
+        runs = queued if endpoint.endswith("status=queued") else []
+        # The unfiltered list always has older pages; only its first page is read.
+        link = None if "status=" in endpoint else '<https://api.github.com/x?page=2>; rel="next"'
+        return http({"total_count": len(runs), "workflow_runs": runs}, etag=etag, link=link)
+
+    monkeypatch.setattr(github_actions.process, "capture", response)
+    adapter = GitHubActions(repo="owner/repo")
+
+    def ids():
+        return [r["id"] for r in asyncio.run(adapter.snapshot())["records"]]
+
+    assert ids() == ["1"]
+    assert sent == [None] * 6
+    sent.clear()
+    assert ids() == ["1"]  # every list answered 304
+    assert all(header and header.startswith("If-None-Match: ") for header in sent)
+    etags["repos/owner/repo/actions/runs?per_page=100&status=queued"] = 'W/"2"'
+    queued.append({"id": 2, "status": "queued", "updated_at": "2026-10-20T03:01:00Z"})
+    assert ids() == ["2", "1"]  # the changed list replaces its cached body
+
+
+def test_failed_request_raises_gh_message(monkeypatch):
+    async def response(argv):
+        return 1, b"HTTP/2.0 404 Not Found\r\n\r\n{}", b"gh: Not Found (HTTP 404)\n"
+
+    monkeypatch.setattr(github_actions.process, "capture", response)
+    with pytest.raises(RuntimeError, match="Not Found"):
+        asyncio.run(GitHubActions(repo="owner/repo").snapshot())
+
+
 def test_repo_must_be_owner_slash_name():
     with pytest.raises(ValueError, match="owner/repo"):
         GitHubActions(repo="owner/repo; rm -rf /")

queue_watch-0.3.0/tests/test_demo.py

@@ -1,26 +0,0 @@
-from queue_watch import demo
-from queue_watch.model import validate_snapshot
-
-
-class Clock:
-    now_value = 1_800_000_000.0
-
-    def now(self) -> float:
-        return self.now_value
-
-
-def test_demo_queue_keeps_moving_with_valid_snapshots() -> None:
-    clock = Clock()
-    simulation = demo.Simulation(clock)
-    lengths, merged = [], set()
-    for _ in range(400):  # 400 ticks: well past every pattern's period
-        clock.now_value += demo.STEP
-        queue = validate_snapshot(simulation.merge_queue())
-        validate_snapshot(simulation.ci())
-        entries = [r for r in queue["records"] if r["kind"] == "queue_entry"]
-        assert [e["position"] for e in entries] == list(range(1, len(entries) + 1))
-        assert sum(e["raw_state"] == "merging" for e in entries) <= 1
-        lengths.append(len(entries))
-        merged |= {r["id"] for r in queue["records"] if r["kind"] == "attempt"}
-    assert len(merged) > 100
-    assert max(lengths) <= 8  # arrivals and merges balance; the queue never runs away