Live feed: the route is Enter's job, not a lane's
Drop the via chain from the feed row. Whatever the fixed lanes left it was a handful of cells, so a route never actually arrived — it arrived elided to a stub that named one hop and hinted at the rest, which is the least useful form a route can take. A route is a shape rather than a lane, and the packet viewer already draws it properly one keypress away: a wrapped path line over the route graph, with the room to say the whole thing. So the feed says what arrived and how well it was heard; Enter says how it got here. What that buys is the whole row fitting a 72-column screen — 69 cells, class label included. The label was being dropped on exactly the screens where it mattered most, to make room for a route that never fitted either; now nothing competes for those cells and the class reads in words down to the width where it genuinely can't. ←→ stays: it just has less to do, firing only on a terminal too narrow for the lanes themselves, and its footer atom appears only there. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
1 parent
c2c10aef33
commit
db68a17e23
2 files changed
+74
-77
No files matched your search
@@ -3,12 +3,17 @@
|
||||
The interactive face of the ``livefeed`` tool — the dashboard's old feed panel,
|
||||
promoted to a first-class screen. One always-repainting list streams the latest
|
||||
packets, newest first: time, class (icon + label, icon alone on a narrow terminal),
|
||||
node, SNR/RSSI, and the trailing detail (a relayed frame's ``via`` chain, a message's
|
||||
conversation). Seeded from stored history so the screen opens full, then streamed
|
||||
node, SNR/RSSI, and a message's conversation. What a row deliberately does *not* carry
|
||||
is the relay path a frame rode in on: a route is a shape, not a lane, and squeezing one
|
||||
into the cells left at the right edge only ever produced a stub — so the route belongs
|
||||
to the packet viewer, which has the room to draw it as a wrapped path line over its
|
||||
graph. The feed's job is to say what arrived and how well it was heard; Enter says how
|
||||
it got here.
|
||||
|
||||
Seeded from stored history so the screen opens full, then streamed
|
||||
live off the event hub. ``↑``/``↓`` walk the rows, PgUp/PgDn/Home/End page and jump
|
||||
them, ``←``/``→`` scroll the highlighted row sideways when it runs past the right edge
|
||||
(a long relay path read to its end without opening anything), and Enter opens the
|
||||
highlighted packet in the shared
|
||||
them, ``←``/``→`` scroll the highlighted row sideways on a terminal too narrow to hold
|
||||
it whole, and Enter opens the highlighted packet in the shared
|
||||
:class:`~meshterm.ui.packet_viewer.PacketViewer` — which then pages through the feed
|
||||
itself with the same ``↑``/``↓``, and, for an overheard channel-text packet naming a
|
||||
channel we hold the key for, decrypts it.
|
||||
@@ -42,7 +47,6 @@ from .packet_viewer import (
|
||||
from .theme import name_style, snr_style
|
||||
from .tui.render import crop_cells, render_to_ansi
|
||||
from .tui.screen import ListWindow, Screen
|
||||
from .pathline import path_line
|
||||
from .widgets import NameKeyResolver, TypeOf
|
||||
|
||||
if TYPE_CHECKING:
|
||||
@@ -63,9 +67,11 @@ _FEED_NAME_WIDTH = 18
|
||||
#: packet under (``direct message``), so every label reads whole and the lanes hold.
|
||||
_FEED_CLASS_WIDTH = 14
|
||||
|
||||
#: Terminal width below which the feed drops the textual class label and keeps only
|
||||
#: the two-cell icon, buying the name and reception lanes room (≤72-col care).
|
||||
_FEED_LABEL_MIN_WIDTH = 80
|
||||
#: Terminal width below which the feed drops the textual class label and keeps only the
|
||||
#: two-cell icon. It is exactly the width the full row occupies — with no route to make
|
||||
#: room for, every lane fits a 72-column screen, so the label (the row's most informative
|
||||
#: field now that it names the real class) is only ever dropped when it truly can't fit.
|
||||
_FEED_LABEL_MIN_WIDTH = 69
|
||||
|
||||
#: Cells one ←/→ press shifts the highlighted row by — the app-wide select list's own
|
||||
#: step (:attr:`~meshterm.ui.tui.select.SelectScreen._HSCROLL_STEP`), so a row here
|
||||
@@ -344,16 +350,17 @@ class LiveFeedScreen(Screen):
|
||||
textual label beside it is dropped wholesale on a narrow terminal
|
||||
(``show_label``), keeping the lanes aligned either way. The node lane is then
|
||||
free to be about the node: its name in the app-wide palette hue (our own node
|
||||
white, a bare hash muted), and a dash where nobody identified themselves. Never
|
||||
wraps — the detail lane gets whatever width the fixed lanes leave (``width``).
|
||||
white, a bare hash muted), and a dash where nobody identified themselves. No
|
||||
relay path rides here — the whole row fits a 72-column screen precisely because
|
||||
it doesn't try to, and the route is drawn properly one keypress away, in the
|
||||
packet viewer.
|
||||
|
||||
A row that runs past the right edge is read by scrolling it, not by growing it.
|
||||
An unhighlighted row simply elides its relay path's middle hops, keeping both
|
||||
ends of the route in view; the *highlighted* row instead slides under ``←→``
|
||||
(:attr:`_hshift`), carrying its detail whole so it can be read to the end — the
|
||||
app-wide h-scroll convention, with the ``▸`` pointer lane pinned so the cursor
|
||||
never scrolls away from the row it marks. The shift bound is measured here,
|
||||
against the current width, so a resize can only clamp it back into range.
|
||||
A row that runs past the right edge — a terminal narrower than the lanes need —
|
||||
is read by scrolling it, not by growing it: the *highlighted* row slides under
|
||||
``←→`` (:attr:`_hshift`), the app-wide h-scroll convention, with the ``▸``
|
||||
pointer lane pinned so the cursor never scrolls away from the row it marks. The
|
||||
shift bound is measured here, against the current width, so a resize can only
|
||||
clamp it back into range.
|
||||
"""
|
||||
row = Text(no_wrap=True, overflow="ellipsis")
|
||||
row.append("▸ " if selected else " ", style="accent")
|
||||
@@ -382,9 +389,7 @@ class LiveFeedScreen(Screen):
|
||||
f" {entry.rssi:5.0f} dBm" if entry.rssi is not None else " " * 10,
|
||||
style="muted",
|
||||
)
|
||||
note = self._feed_note(
|
||||
entry, None if selected else max(1, avail - body.cell_len - 2)
|
||||
)
|
||||
note = self._feed_note(entry)
|
||||
if note is not None:
|
||||
body.append(" ")
|
||||
body.append_text(note)
|
||||
@@ -406,8 +411,8 @@ class LiveFeedScreen(Screen):
|
||||
class lane two columns left already says that, straight from
|
||||
:func:`~meshterm.ui.packet_viewer.class_marks`, and a row that spelled it twice
|
||||
was reading ``packet`` beside ``channel text`` as though they were two facts.
|
||||
A relayed flood names no origin, so its lane says so with a dash and lets the
|
||||
eye travel on to the ``via`` chain, which does name nodes.
|
||||
A relayed flood names no origin, so its lane says so with a dash — the route that
|
||||
would name nodes is the packet viewer's to draw, not a stub for this row to carry.
|
||||
"""
|
||||
if entry.kind == "message":
|
||||
sender = _channel_sender(entry.text)
|
||||
@@ -421,35 +426,22 @@ class LiveFeedScreen(Screen):
|
||||
return entry.where, "muted" # an ack's code, or any other stray context
|
||||
return "—", "muted"
|
||||
|
||||
def _feed_note(self, entry: PacketEntry, budget: Optional[int]) -> Optional[Text]:
|
||||
"""The row's trailing detail: a packet's relay path, a message's conversation.
|
||||
def _feed_note(self, entry: PacketEntry) -> Optional[Text]:
|
||||
"""The row's trailing detail — a message's conversation, and nothing else.
|
||||
|
||||
The path renders through THE path line. Given a ``budget`` — the cells the row's
|
||||
fixed lanes leave — a chain too long for the lane elides its *middle* hops behind
|
||||
``⋯``, so the origin and the last relay (the ends a right-edge cut would amputate)
|
||||
always survive. ``None`` asks for the chain whole instead: that is the highlighted
|
||||
row, which scrolls sideways rather than eliding, so nothing may be dropped before
|
||||
``←→`` has had the chance to reveal it.
|
||||
A relayed frame's route used to sit here, and it never fitted: whatever the fixed
|
||||
lanes left it was a handful of cells, so the chain arrived elided to a stub that
|
||||
named one hop and hinted at the rest. A route is a shape rather than a lane, and
|
||||
it is one keypress away — the packet viewer draws it as a wrapped path line over
|
||||
the route graph, with the room to say the whole thing. So the feed says what
|
||||
arrived; Enter says how it got here.
|
||||
|
||||
Args:
|
||||
entry: The packet the row describes.
|
||||
budget: Cells the detail may occupy, or ``None`` for the full-length line.
|
||||
|
||||
Returns:
|
||||
The detail to append, or ``None`` when the class carries none.
|
||||
"""
|
||||
if entry.kind == "packet" and entry.path is not None:
|
||||
note = Text("via ", style="muted")
|
||||
line = path_line(
|
||||
entry.path.split(","),
|
||||
self._resolve,
|
||||
prefix_bytes=self._prefix_bytes,
|
||||
self_name=self._self_name,
|
||||
)
|
||||
note.append_text(
|
||||
line.text() if budget is None else line.ellipsized(max(1, budget - 4))
|
||||
)
|
||||
return note
|
||||
if entry.kind == "message" and entry.where:
|
||||
return Text(entry.where, style="muted")
|
||||
return None
|
||||
|
||||
+38
-33
@@ -74,17 +74,22 @@ def test_livefeed_live_events_land_in_the_feed() -> None:
|
||||
assert body.index("ack") < body.index("message") < body.index("advert")
|
||||
|
||||
|
||||
def test_livefeed_packet_rows_show_their_relay_path() -> None:
|
||||
"""An RX-log packet reads as its relay path, resolved to names where known.
|
||||
def test_livefeed_rows_leave_the_relay_path_to_the_viewer() -> None:
|
||||
"""A row says what arrived and how well it was heard; the route is Enter's job.
|
||||
|
||||
The path renders through the shared compact path widget, so each name carries its
|
||||
own hue — assert on the stripped text, not the raw ANSI.
|
||||
Whatever the fixed lanes left a route was never enough to draw one in — it arrived
|
||||
elided to a stub — so the feed carries none, and the whole row fits a 72-column
|
||||
screen with its class label intact.
|
||||
"""
|
||||
screen = _screen()
|
||||
screen.on_event(
|
||||
MeshEvent.observation_event(_obs(kind="packet", path="3d63,a1b2", snr=1.0))
|
||||
)
|
||||
assert "via YUL → Alice" in "\n".join(_stripped(screen.render_body(100)))
|
||||
row = _stripped(screen.render_body(72))[1]
|
||||
assert "via" not in row and "YUL" not in row # no route, not even a stub of one
|
||||
assert "📦 packet" in row # the class still reads in words at 72
|
||||
assert "+1.0 dB" in row and "-90 dBm" in row # …as does the reception it was heard at
|
||||
assert len(row.rstrip()) <= 72
|
||||
|
||||
|
||||
def test_livefeed_class_lane_names_the_payload_class_once() -> None:
|
||||
@@ -150,60 +155,60 @@ def test_livefeed_windows_inside_the_fixed_screen() -> None:
|
||||
assert "↓" in body and "more" in body # hidden feed rows are counted below
|
||||
|
||||
|
||||
def _long_packet(**extra) -> Observation:
|
||||
"""A relayed packet whose ``via`` chain is far wider than any sane terminal."""
|
||||
return _obs(kind="packet", path=",".join(f"{i:02d}aa" for i in range(12)), **extra)
|
||||
#: A terminal too narrow to hold the feed's fixed lanes — the only thing that makes a
|
||||
#: row overflow now that no route rides in it (see ``_FEED_LABEL_MIN_WIDTH``).
|
||||
_CRAMPED = 44
|
||||
|
||||
|
||||
def test_livefeed_the_whole_row_fits_a_72_column_screen() -> None:
|
||||
"""No row overflows at 72 — which is why ←→ has nothing to advertise there."""
|
||||
screen = _screen(seed=[_obs(node="n0", kind="telemetry")])
|
||||
for line in _stripped(screen.render_body(72))[1:]:
|
||||
assert len(line.rstrip()) <= 72
|
||||
assert screen._hmax == 0
|
||||
assert "←→" not in screen.footer_hint
|
||||
|
||||
|
||||
def test_livefeed_highlighted_row_scrolls_sideways_to_its_tail() -> None:
|
||||
"""←→ slide the highlighted row so a long relay path reads to its last hop."""
|
||||
screen = _screen(seed=[_long_packet()])
|
||||
opening = _stripped(screen.render_body(100))[1]
|
||||
"""On a terminal too narrow for the lanes, ←→ slide the highlighted row to its end."""
|
||||
screen = _screen(seed=[_obs()])
|
||||
opening = _stripped(screen.render_body(_CRAMPED))[1]
|
||||
assert screen._hmax > 0 # the row does run past the right edge
|
||||
assert "00aa" in opening and "11aa" not in opening # …so its tail is off-screen
|
||||
assert not opening.rstrip().endswith("dBm") # …so its reception tail is off-screen
|
||||
|
||||
for _ in range(40): # → saturates at the row's own end, never past it
|
||||
screen.handle("right")
|
||||
scrolled = _stripped(screen.render_body(100))[1]
|
||||
scrolled = _stripped(screen.render_body(_CRAMPED))[1]
|
||||
assert screen._hshift == screen._hmax
|
||||
assert scrolled.startswith("▸ ") # the pointer lane stays pinned while the row slides
|
||||
assert scrolled.rstrip().endswith("11aa") # the last hop is now readable
|
||||
assert "Alice" not in scrolled # …at the cost of the lanes that slid off the left
|
||||
assert scrolled.rstrip().endswith("-90 dBm") # the tail is now readable
|
||||
assert opening[2:10] not in scrolled # …at the cost of the time lane, slid off left
|
||||
|
||||
for _ in range(40):
|
||||
screen.handle("left")
|
||||
assert screen._hshift == 0
|
||||
assert _stripped(screen.render_body(100))[1] == opening # back where it started
|
||||
assert _stripped(screen.render_body(_CRAMPED))[1] == opening # back where it started
|
||||
|
||||
|
||||
def test_livefeed_moving_the_selection_abandons_the_rows_scroll() -> None:
|
||||
"""Each row scrolls on its own: landing on another packet starts it at its beginning."""
|
||||
screen = _screen(seed=[_long_packet(age_s=1), _long_packet(age_s=0)])
|
||||
screen.render_body(100)
|
||||
screen = _screen(seed=[_obs(node="n0", age_s=1), _obs(node="n1", age_s=0)])
|
||||
screen.render_body(_CRAMPED)
|
||||
screen.handle("right")
|
||||
assert screen._hshift > 0
|
||||
screen.handle("down")
|
||||
assert screen._hshift == 0
|
||||
|
||||
|
||||
def test_livefeed_only_the_highlighted_row_carries_its_path_whole() -> None:
|
||||
"""An unhighlighted row elides its middle hops; the one you can scroll keeps them."""
|
||||
screen = _screen(seed=[_long_packet(age_s=1), _long_packet(age_s=0)])
|
||||
rows = _stripped(screen.render_body(100))[1:3]
|
||||
assert "⋯" not in rows[0] # the highlighted row: whole, cropped at the edge
|
||||
assert "⋯" in rows[1] # the rest: middle elided so both ends survive
|
||||
|
||||
|
||||
def test_livefeed_advertises_line_scroll_only_where_it_acts() -> None:
|
||||
"""←→ earns its footer atom exactly while the highlighted row overflows."""
|
||||
short = _screen(seed=[_obs()])
|
||||
short.render_body(100)
|
||||
assert "←→" not in short.footer_hint
|
||||
screen = _screen(seed=[_obs()])
|
||||
screen.render_body(100)
|
||||
assert "←→" not in screen.footer_hint # a row with room to spare scrolls nowhere
|
||||
|
||||
long_row = _screen(seed=[_long_packet()])
|
||||
long_row.render_body(100)
|
||||
assert "←→ scroll line" in long_row.footer_hint
|
||||
assert len(long_row.footer_hint) <= 72 # the screens-at-72 rule, fullest state
|
||||
screen.render_body(_CRAMPED)
|
||||
assert "←→ scroll line" in screen.footer_hint
|
||||
assert len(screen.footer_hint) <= 72 # the screens-at-72 rule, fullest state
|
||||
|
||||
|
||||
def test_livefeed_without_a_device_reads_as_waiting() -> None:
|
||||
|
||||
Reference in new issue
Block a user