^N shows the places of the nodes on Node detail, the packet viewer, Live feed, and Trace

Each screen opens with node names and keeps its own choice. Node detail acts only on
the Routes tab (F1). The packet viewer changes its via line and its from/to chips (F1).
Live feed changes the endpoint chips of an addressed packet (F1). Trace changes its
route lane and its per-hop links (F1). Each hint and chip shows only where a line has
a named hop.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Jean-Pierre MartineauandClaude Sonnet 5.5 committed 2026-11-03 03:01:12 -05:00
1 parent 9626d06a3f
commit 7dd7cb5a62
5 files changed
+537 -63

No files matched your search

+58 -7
View File
@@ -96,6 +96,8 @@ from .packet_viewer import (
unnamed_scope,
)
from .pathline import SELF_GLYPH, PathHop, cut_to
from .placemode import ACTION as PLACES_ACTION
from .placemode import PlaceToggle, node_of, placed_hops, places_of_session
from .theme import name_style, snr_style
from .tui.render import crop_cells, render_to_ansi
from .tui.screen import ListWindow, Screen
@@ -288,6 +290,11 @@ class LiveFeedScreen(Screen):
floating = False
#: The hint sheds this atom first when it is too wide (refer to
#: :func:`~meshterm.ui.tui.frame.fit_hint`). The user can try the arrow keys on a row
#: that is too wide, but nothing else shows ^N.
spare_hint_atoms = ("←→ scroll line",)
@property
def picocalc_lyra_lane(self):
"""The shared lane, which stays dim until there are packets to move through.
@@ -302,10 +309,16 @@ class LiveFeedScreen(Screen):
An empty feed has no cursor and no place to move to. Thus all four chips are dim
until the first packet arrives.
"""
from .tui.fkeys import default_lane
return default_lane(nav=bool(self._feed))
F1 is the place mode of the route chips (^N). It has a chip only while the feed
holds a row that draws such a chip.
"""
from .tui.fkeys import FPair, default_lane
lane = list(default_lane(nav=bool(self._feed)))
if self._places_available():
lane[0] = FPair(self._places.chip, PLACES_ACTION)
return lane
def __init__(
self,
@@ -399,6 +412,8 @@ class LiveFeedScreen(Screen):
#: range.
self._hshift = 0
self._hmax = 0
#: ^N: the route chips of the subject lane show the node names, or the places.
self._places = PlaceToggle()
# --- live feed -----------------------------------------------------------------
@@ -457,10 +472,39 @@ class LiveFeedScreen(Screen):
This is the same rule ("advertise a key only where it acts") that the ``hscroll``
hint of the select list follows.
"""
base = "↑↓ PgUp/PgDn Home/End move · Enter open · Esc back"
atoms = ["↑↓ PgUp/PgDn Home/End move"]
if self._selected is not None and self._hmax > 0:
return "↑↓ PgUp/PgDn Home/End move · ←→ scroll line · Enter open · Esc back"
return base
atoms.append("←→ scroll line")
atoms.append("Enter open")
if self._places_available():
atoms.append(self._places.hint)
atoms.append("Esc back")
return " · ".join(atoms)
def _places_available(self) -> bool:
"""Whether ^N acts: a row of the feed draws its subject as a route chip pair."""
return any(self._has_endpoints(entry) for entry in self._feed)
def _has_endpoints(self, entry: PacketEntry) -> bool:
"""Whether the subject of the row is the two endpoints of an addressed packet.
The tests follow the order of :meth:`_feed_subject`. A packet that names a node, a
message, and a channel packet each have another subject. Also, one of the two
endpoints must have a name, because only a name is a chip that ^N can change.
"""
raw = entry.raw if isinstance(entry.raw, dict) else {}
if not raw.get("dest_hash") or not (raw.get("src_key") or raw.get("src_hash")):
return False
if entry.kind == "message" or raw.get("payload_typename") in CHANNEL_CLASSES:
return False
if node_label(entry, self._resolve, self._self_name)[0] != "?":
return False
ends = (raw.get("dest_hash"), raw.get("src_key") or raw.get("src_hash"))
names = (self._resolve(end) for end in ends)
return any(
name and name != end and name != self._self_name
for name, end in zip(names, ends, strict=True)
)
def handle(self, action: str, data: str = "") -> None:
"""Move the cursor, commit the row that it is on, scroll a row, or leave."""
@@ -487,6 +531,10 @@ class LiveFeedScreen(Screen):
self._select_stop(0)
elif action in ("end", "ctrl_end"):
self._select_stop(len(self._feed))
elif action == PLACES_ACTION:
if self._places_available():
self._places.flip()
self._session.invalidate()
elif action == "left":
self._scroll_line(-_HSCROLL_STEP)
elif action == "right":
@@ -921,7 +969,10 @@ class LiveFeedScreen(Screen):
if name and name == self._self_name:
return PathHop(SELF_GLYPH, you=True)
if name and name != value:
return PathHop(name, key=value)
hop = PathHop(name, key=value)
if self._places.on:
hop = placed_hops([hop], places_of_session(), node_of(self._resolve))[0]
return hop
return PathHop(short, key=value, lit_bytes=ENDPOINT_HASH_BYTES)
@staticmethod
+75 -11
View File
@@ -141,6 +141,8 @@ from .pathline import (
hops_atom,
with_action_mark,
)
from .placemode import ACTION as PLACES_ACTION
from .placemode import NodeOf, PlaceToggle, node_of, placed, places_of_session
from .theme import glyph as platform_glyph
from .theme import mark_rgb, name_style, snr_style
from .tui.render import crop_cells, render_hanging, render_lines, render_to_ansi
@@ -328,12 +330,15 @@ class _Route:
context: The line that hangs under ``path``: the hop count, then the bottleneck
SNR, the sample count, and a ``★ best`` or ``device route`` tag when the route
has them. The hop count is always there, so this line is never empty.
line: The same path line before it became text. With it, place mode (^N) can name
the hops by their places. ``None`` means that the route has no place mode.
"""
draw: tuple[str, ...]
spec: str
path: Text
context: Text
line: PathLine | None = None
@dataclass(slots=True)
@@ -382,6 +387,8 @@ class _RoutesView:
legend: Whether to draw the node-type legend below the graph (a relay with a known
type was shown).
note: The muted line shown instead of a graph when there is no evidence.
find: Gives the node id for the hash of a hop (:func:`~meshterm.ui.placemode.node_of`
of the resolver), for place mode. ``None`` when the resolver cannot tell.
"""
routes: list[_Route] = field(default_factory=list)
@@ -390,6 +397,7 @@ class _RoutesView:
label_rgb_of: LabelRgbOf | None = None
legend: bool = False
note: str = ""
find: NodeOf | None = None
@dataclass(slots=True)
@@ -446,10 +454,15 @@ class NodeDetailScreen(Screen):
The pager works only when the route list is really in a list window. On the Info tab,
and on a node whose routes all fit, the keys move nothing.
F1 is the place mode of the path lines (^N). It has a chip only while the Routes tab
shows a path line that place mode can change.
"""
from .tui.fkeys import FPair, default_lane
lane = list(default_lane(nav=self._list_hidden))
if self._places_available():
lane[0] = FPair(self._places.chip, PLACES_ACTION)
if len(self._tabs) >= 2:
nxt = self._tabs[(self._tab_index + 1) % len(self._tabs)]
lane[2] = FPair(nxt.name, "tab")
@@ -573,6 +586,8 @@ class NodeDetailScreen(Screen):
#: The last render width. With it, the footer hint can tell whether the path line of
#: the highlighted route really overflows (nothing overflows before the first paint).
self._last_width = 0
#: ^N: the path lines of the Routes tab show the node names, or the places.
self._places = PlaceToggle()
# --- input -----------------------------------------------------------------
@@ -600,9 +615,24 @@ class NodeDetailScreen(Screen):
parts.append("←→ scroll")
elif self._key_overflows():
parts.append("←→ scroll key")
if self._places_available():
parts.append(self._places.hint)
parts.append("Esc back")
return " · ".join(parts)
def _places_available(self) -> bool:
"""Whether ^N acts: the Routes tab is open and a route has a path line to change."""
tab = self._tabs[self._tab_index] if self._tabs else None
if tab is None or tab.kind != "routes" or self._routes is None:
return False
return any(route.line is not None for route in self._routes.routes)
def _route_path(self, route: _Route) -> Text:
"""The path line of a route as text: with its places while place mode is on."""
if self._places.on and route.line is not None and self._routes is not None:
return placed(route.line, places_of_session(), self._routes.find).text()
return route.path
def _selected_route_overflows(self) -> bool:
"""Whether the highlighted path line is too wide for the content lane of the list.
@@ -623,7 +653,7 @@ class NodeDetailScreen(Screen):
# The `…` at the end is chrome outside the lane (pathline.with_action_mark), so it
# is not part of what must fit. A route exactly as wide as its lane does not scroll,
# and the mark is the thing that is not shown.
return cell_len(routes[self._row_index].path.plain) > avail
return cell_len(self._route_path(routes[self._row_index]).plain) > avail
def _on_info_tab(self) -> bool:
"""Whether the Info tab fills the stage (thus its key lane is visible)."""
@@ -751,6 +781,9 @@ class NodeDetailScreen(Screen):
else:
assert isinstance(payload, _Action)
self.resolve(payload.key)
elif action == PLACES_ACTION:
if self._places_available():
self._places.flip()
elif action == "tab":
self._switch_tab(1)
elif action == "shift_tab":
@@ -1158,7 +1191,7 @@ class NodeDetailScreen(Screen):
indent = _ROUTE_INDENT
avail = max(1, width - indent)
pointer = Text("❯ " if selected else " ", style="cursor" if selected else "")
marked = route.path
marked = self._route_path(route)
if selected and self._hshift:
total = cell_len(marked.plain)
# A scrolled row gave one cell to its left mark, so its last visible part has
@@ -2520,6 +2553,27 @@ def _route_line(
each route has a length. Before, a row whose second line came and went with the
evidence made the list one row taller when the highlight moved.
"""
line = _route_path_line(
node_label,
name_key,
hops_out,
resolve=resolve,
node_known=node_known,
hash_bytes=hash_bytes,
)
return line.text(), _route_context(hops_out, tag, weakest, samples)
def _route_path_line(
node_label: str,
name_key: str,
hops_out: tuple[str, ...],
*,
resolve, # noqa: ANN001 - NodeResolver, with no strict type, like the graph callbacks
node_known: bool,
hash_bytes: int,
) -> PathLine:
"""The path line of one route, from the contact to our node (refer to :func:`_route_line`)."""
hash_bytes = max(hash_bytes, 1) # an unknown mode still must have a real width to slice
def hop_of(hop: str) -> PathHop:
@@ -2528,7 +2582,7 @@ def _route_line(
return PathHop(named, key=hop)
return PathHop(_hop_hash(hop, hop, hash_bytes)) # unknown: its hash, in the grey
path = PathLine(
return PathLine(
[
PathHop(node_label, key=name_key)
if node_known and name_key
@@ -2536,8 +2590,13 @@ def _route_line(
*(hop_of(hop) for hop in reversed(hops_out)),
PathHop(SELF_GLYPH, you=True),
]
).text()
)
def _route_context(
hops_out: tuple[str, ...], tag: str, weakest: float | None, samples: int
) -> Text:
"""The line of context under one route (refer to :func:`_route_line`)."""
atoms: list[Text] = [hops_atom(len(hops_out))]
if weakest is not None:
snr = Text("weakest ", style="muted")
@@ -2554,7 +2613,7 @@ def _route_line(
if i:
context.append(" · ", style="muted")
context.append_text(atom)
return path, context
return context
def _cluster_presentation(members: tuple[str, ...], type_of) -> _Cluster: # noqa: ANN001
@@ -2711,19 +2770,23 @@ def _routes_view(
routes: list[_Route] = []
for hops_out, tag, weakest, samples in entries:
spec = render_forced_spec(hops_out, target_hash, width_bytes) if target_hash else ""
path, context = _route_line(
line = _route_path_line(
node_label,
name_key,
hops_out,
tag,
weakest,
samples,
resolve=resolve,
node_known=node_known,
self_name=self_name,
hash_bytes=hash_bytes,
)
routes.append(_Route(draw=tuple(reversed(hops_out)), spec=spec, path=path, context=context))
routes.append(
_Route(
draw=tuple(reversed(hops_out)),
spec=spec,
path=line.text(),
context=_route_context(hops_out, tag, weakest, samples),
line=line,
)
)
# The legend explains the marks of the relays with a known type. Thus the real types of
# the members decide it, before the contraction folds the members of a dense cluster
@@ -2777,6 +2840,7 @@ def _routes_view(
label_of=label_of,
label_rgb_of=cluster_label_rgb_of,
legend=legend,
find=node_of(resolve),
)
+54 -5
View File
@@ -66,6 +66,8 @@ from .marks import SELF_MARK, UNKNOWN_MARK
from .menus import SEP_COMPACT, SEP_ROOMY
from .pathgraph import PathLayer, render_path_graph, revisited_hops
from .pathline import PathHop, PathLine, hops_atom, path_line
from .placemode import ACTION as PLACES_ACTION
from .placemode import PlaceToggle, node_of, placed, placed_hops, places_of_session
from .theme import glyph, name_style, snr_style
from .trace_screen import snr_bar
from .tui.render import render_lines, render_to_ansi
@@ -430,6 +432,10 @@ class PacketViewer(Screen):
grow_only = True
#: The hint sheds these atoms first (refer to :func:`~meshterm.ui.tui.frame.fit_hint`).
#: The user finds the paging keys without the hint, but nothing else shows ^N.
spare_hint_atoms = ("Home/End ends", "PgUp/PgDn scroll")
@property
def picocalc_lyra_lane(self):
"""The shared pager over the body, with the jumps named for their destinations.
@@ -445,10 +451,15 @@ class PacketViewer(Screen):
pin also when the list holds one packet (as the ``Top`` chip of the feed does, on
the screen under this dialog). When the dialog opens over a single packet of a
snapshot, all four chips are dim at the same time.
F1 is the place mode of the path lines (^N). It has a chip only while the shown
packet has a path line or a hop chip to change.
"""
from .tui.fkeys import FPair, default_lane
lane = list(default_lane(nav=self.content_overflows))
if self._places_available():
lane[0] = FPair(self._places.chip, PLACES_ACTION)
many = len(self._entries) > 1 or self._can_pin
lane[3] = FPair(
"Page ↓", "pagedown", "Oldest", "end", enabled=self.content_overflows, opp_enabled=many
@@ -540,6 +551,8 @@ class PacketViewer(Screen):
self._key_of = key_of
self._scope_of: ScopeOf = scope_of or unnamed_scope
self._message_scope = message_scope
#: ^N: the path line and the hop chips show the node names, or the places.
self._places = PlaceToggle()
#: Whether the viewer is on the pin: the stop above the newest packet, which
#: holds the top position instead of a packet. It means that ``_index == 0``. The
#: pin is a mode on the newest entry, so all the code that reads the viewer (the
@@ -578,9 +591,38 @@ class PacketViewer(Screen):
atoms = []
if len(self._entries) > 1 or self._can_pin:
atoms += ["PgUp/PgDn scroll", "Home/End ends"]
if self._places_available():
atoms.append(self._places.hint)
atoms.append("Esc close")
self.footer_hint = " · ".join(atoms)
def _places_available(self) -> bool:
"""Whether ^N acts: the shown packet has a path line or a named hop chip."""
if not self._entries:
return False
entry = self._entries[self._index]
raw = entry.raw if isinstance(entry.raw, dict) else {}
if entry.kind == "packet" and any((entry.path or "").split(",")):
return True
if (entry.node or entry.name) and node_label(entry, self._resolve, self._self_name)[
1
] not in (
"muted",
"you",
):
return True
for end in (raw.get("dest_hash"), raw.get("src_key") or raw.get("src_hash")):
named = self._resolve(end) if end else ""
if named and named != end and named != self._self_name:
return True
return False
def _place_hop(self, hop: PathHop) -> PathHop:
"""The hop with its place for a label, while place mode is on."""
if not self._places.on:
return hop
return placed_hops([hop], places_of_session(), node_of(self._resolve))[0]
@property
def _can_pin(self) -> bool:
"""Whether this viewer has a stream to follow, which is what a ``source`` is.
@@ -678,6 +720,10 @@ class PacketViewer(Screen):
self.scroll_pages(-1)
elif action in ("pagedown", "space"):
self.scroll_pages(1)
elif action == PLACES_ACTION:
if self._places_available():
self._places.flip()
self._update_footer()
elif action in ("escape", "enter"):
self.resolve(None)
@@ -761,9 +807,9 @@ class PacketViewer(Screen):
# moment before. The store caches the lookup, so a request at each paint costs a
# dict hit.
# The card is also a function of whether the frame is short, because a short
# frame removes the node-type legend.
# frame removes the node-type legend. It is also a function of place mode (^N).
short = short_frame(self._scroll_viewport)
key = (id(entry), width, age_minute, self._entry_scope(entry), short)
key = (id(entry), width, age_minute, self._entry_scope(entry), short, self._places.on)
cached = self._body_cache.get(key)
if cached is not None:
self._body_cache.move_to_end(key)
@@ -852,7 +898,7 @@ class PacketViewer(Screen):
# The node that sent the packet is the origin of its route. Thus it is a chip
# that closes on the point, and the ``via`` row continues that route.
hop = PathHop(label, you=True) if style == "you" else PathHop(label, key=entry.node)
who.append_text(hop_chip(hop, role=ORIGIN))
who.append_text(hop_chip(self._place_hop(hop), role=ORIGIN))
if entry.node and label != entry.node:
who.append(" ")
who.append_text(highlighted_hash(entry.node, self._prefix_bytes))
@@ -997,7 +1043,7 @@ class PacketViewer(Screen):
says that the route continues past the chip. A flat end claims that the first relay
was the origin.
"""
return path_line(
line = path_line(
(entry.path or "").split(","),
self._resolve,
prefix_bytes=self._prefix_bytes,
@@ -1006,6 +1052,9 @@ class PacketViewer(Screen):
from_origin=False,
to_destination=False,
)
if self._places.on:
line = placed(line, places_of_session(), node_of(self._resolve))
return line
@staticmethod
def _empty_via(entry: PacketEntry) -> str:
@@ -1212,7 +1261,7 @@ class PacketViewer(Screen):
if known:
ours = bool(self._self_name and named == self._self_name)
hop = PathHop(named, you=True) if ours else PathHop(named, key=value)
text.append_text(hop_chip(hop, role=role))
text.append_text(hop_chip(self._place_hop(hop), role=role))
text.append(" ")
text.append_text(highlighted_hash(value, self._prefix_bytes or 1, known=known))
return text
+106 -40
View File
@@ -127,6 +127,8 @@ from .pathline import (
hops_atom,
path_line,
)
from .placemode import ACTION as PLACES_ACTION
from .placemode import PlaceToggle, node_of, placed, places_of_session
from .theme import snr_style
from .tui.render import crop_cells, render_lines, render_to_ansi
from .tui.screen import Screen
@@ -264,6 +266,12 @@ def _slid(line: Text, shift: int, width: int) -> Text:
return out
def _is_hash(hop: PathHop) -> bool:
"""Whether a hop shows its hash and no name: place mode keeps such a hop as it is."""
key = (hop.key or "").lower().removeprefix("0x")
return hop.label.lower().removeprefix("0x") == key
def _note(text: str, indent: int, *, style: str = "faint") -> Text:
"""The trailing note of a lane (a source, a stamp, a count), on its own hanging line."""
return Text(" " * indent + text, style=style)
@@ -438,6 +446,25 @@ class TraceScreen(Screen):
floating = False
#: The hint sheds this atom first when it is too wide (refer to
#: :func:`~meshterm.ui.tui.frame.fit_hint`). The user finds the paging keys without
#: the hint, but nothing else shows ^N.
spare_hint_atoms = ("PgUp/PgDn scroll",)
@property
def picocalc_lyra_lane(self):
"""The shared lane, with the place mode of the route lines on F1.
F1 is the ^N chip. It has a chip only while a route line is on the page that has
a named hop (refer to :meth:`_places_available`).
"""
from .tui.fkeys import DEFAULT_LANE, FPair
lane = list(DEFAULT_LANE)
if self._places_available():
lane[0] = FPair(self._places.chip, PLACES_ACTION)
return lane
def __init__(
self,
target: str,
@@ -590,6 +617,8 @@ class TraceScreen(Screen):
#: the footer.
self._hshift = 0
self._hop_pan = 0
#: ^N: the route lines show the node names, or the places.
self._places = PlaceToggle()
# --- state -----------------------------------------------------------------
@@ -602,7 +631,29 @@ class TraceScreen(Screen):
return f"tracing {done}/{total}… · PgUp/PgDn scroll · Esc back"
return "tracing… · PgUp/PgDn scroll · Esc back"
slide = " · ←→ scroll" if self._hop_pan else ""
return f"↑↓ actions{slide} · Enter run · PgUp/PgDn scroll · Esc back"
places = f" · {self._places.hint}" if self._places_available() else ""
return f"↑↓ actions{slide} · Enter run · PgUp/PgDn scroll{places} · Esc back"
def _places_available(self) -> bool:
"""Whether ^N acts: the route lane shows a line with a named hop.
The hop lines of the results come from the walked route. Thus the route lane,
which draws the same hops, decides it for both.
"""
current = next((t for t in reversed(self._traces) if t.success), None)
shown = self._shown_route(current)
if shown is None:
return False
return any(
hop.key and hop.label and not hop.you and not hop.gap and not _is_hash(hop)
for hop in shown[0].hops
)
def _placed(self, line: PathLine) -> PathLine:
"""The path line with its places for the node names, while place mode is on."""
if self._places.on:
return placed(line, places_of_session(), node_of(self._resolve))
return line
def start_trace(self) -> None:
"""Start a trace run in the background (does nothing while a run is in progress)."""
@@ -776,6 +827,9 @@ class TraceScreen(Screen):
self._pin_cursor = False
step = _HSCROLL_STEP if action == "right" else -_HSCROLL_STEP
self._hshift = max(0, min(self._hop_pan, self._hshift + step))
elif action == PLACES_ACTION:
if self._places_available():
self._places.flip()
elif action == "enter":
self._commit_action()
elif action == "up":
@@ -966,7 +1020,7 @@ class TraceScreen(Screen):
it changes. A *running* trace does not use the cache at all, because its log row
has the live spinner glyph.
"""
key = (self._traces_rev, self._status, width, self._hshift)
key = (self._traces_rev, self._status, width, self._hshift, self._places.on)
if not self._running and self._tail_memo is not None and self._tail_memo[0] == key:
return self._tail_memo[1]
lines: list[str] = []
@@ -983,7 +1037,10 @@ class TraceScreen(Screen):
if not self._running:
# The key is the shift at which the rows were drawn, which _hop_lines can
# clamp. Thus the next paint finds it.
self._tail_memo = ((self._traces_rev, self._status, width, self._hshift), lines)
self._tail_memo = (
(self._traces_rev, self._status, width, self._hshift, self._places.on),
lines,
)
return lines
def cursor_line(self) -> int | None:
@@ -1060,39 +1117,46 @@ class TraceScreen(Screen):
continuations already have the indent of the lane.
"""
indent = len(_ROUTE_LANE)
if current is not None:
route = route_path(
current,
self._device_label,
self._resolve,
self._device_hash,
bare_self=True,
show_hash=False,
)
return route.wrapped(width, indent=indent)
planned = self._planned_route()
if planned is not None:
lines = planned.wrapped(width, indent=indent)
if self._effective_spec()[1] and self._auto_source:
lines.append(_note(f"(auto · {self._auto_source})", indent))
return lines
if self._previous is not None:
route = route_path(
self._previous,
self._device_label,
self._resolve,
self._device_hash,
bare_self=True,
show_hash=False,
)
lines = route.wrapped(width, indent=indent)
stamp = self._previous.timestamp.astimezone().strftime("%b %d %H:%M")
lines.append(_note(f"(previous · {stamp})", indent))
shown = self._shown_route(current)
if shown is not None:
route, note = shown
lines = self._placed(route).wrapped(width, indent=indent)
if note:
lines.append(_note(note, indent))
return lines
if self._mode == "path":
return [Text("none — compose a path to walk", style="muted")]
return [Text("unknown — press Enter to trace", style="muted")]
def _shown_route(self, current: TraceResult | None) -> tuple[PathLine, str] | None:
"""The path line of the route lane, and the note under it (``""`` for none).
The order is the order that :meth:`_route_value` explains: the live route, the
planned route, the previous route. The result is ``None`` when there is no route to
show. The line is not changed by place mode (refer to :meth:`_placed`).
"""
if current is not None:
return self._walked_route(current), ""
planned = self._planned_route()
if planned is not None:
auto = self._effective_spec()[1] and self._auto_source
return planned, f"(auto · {self._auto_source})" if auto else ""
if self._previous is not None:
stamp = self._previous.timestamp.astimezone().strftime("%b %d %H:%M")
return self._walked_route(self._previous), f"(previous · {stamp})"
return None
def _walked_route(self, result: TraceResult) -> PathLine:
"""The route that a trace walked, with bare ends and no hashes after the names."""
return route_path(
result,
self._device_label,
self._resolve,
self._device_hash,
bare_self=True,
show_hash=False,
)
def _effective_spec(self) -> tuple[str, bool]:
"""The wire spec that the next Trace walks, and whether automatic resolution gave it.
@@ -1361,15 +1425,17 @@ class TraceScreen(Screen):
None if not node or node == self._device_label else node
for node in (agg.origin, agg.destination)
]
return path_line(
ends,
self._resolve,
prefix_bytes=hash_bytes or 8,
self_name=self._device_label,
hash_bytes=hash_bytes,
bare_self=True,
from_origin=from_origin,
to_destination=to_destination,
return self._placed(
path_line(
ends,
self._resolve,
prefix_bytes=hash_bytes or 8,
self_name=self._device_label,
hash_bytes=hash_bytes,
bare_self=True,
from_origin=from_origin,
to_destination=to_destination,
)
).text()
def _trace_log(self) -> RenderableType:
+244
View File
@@ -0,0 +1,244 @@
# SPDX-License-Identifier: Apache-2.0
"""Place mode (^N) on the path screens: Node detail, the packet viewer, the live feed, and Trace.
Each screen opens with node names. ^N changes its path lines to the places of the nodes
(refer to :mod:`meshterm.ui.placemode`), and the hint and the lane chip say what the key
does now. The place service of the session is replaced by a small fake in each test.
"""
from __future__ import annotations
import pytest
from rich.text import Text
from meshterm.core.events import MeshEvent
from meshterm.core.models import Hop, Observation, TraceResult, utcnow
from meshterm.core.places import Place
from meshterm.ui import placemode
from meshterm.ui.livefeed_screen import LiveFeedScreen
from meshterm.ui.node_detail_screen import (
NodeDetailScreen,
_Route,
_RoutesView,
_Tab,
)
from meshterm.ui.packet_viewer import PacketEntry, PacketViewer
from meshterm.ui.pathline import PathHop, PathLine
from meshterm.ui.trace_screen import TraceScreen
from tests.conftest import plain as _plain
#: The node that has a place in these tests (12 hex digits, the id of a node).
_HUB = "3d63c6429436"
class _Places:
"""A fake place service: the hub is in Villeray, and no other node has a place."""
def get(self, node: str | None) -> Place | None:
return Place("Villeray", None, "tiles") if node == _HUB else None
@pytest.fixture
def places(monkeypatch: pytest.MonkeyPatch) -> _Places:
"""Make the fake service the place service of the session."""
service = _Places()
monkeypatch.setattr("meshterm.services.places._CURRENT", service)
return service
def _lane_places(screen) -> list: # noqa: ANN001
"""The slots of the lane that ^N drives."""
return [pair for pair in screen.picocalc_lyra_lane if pair and pair.action == placemode.ACTION]
# -- Node detail -------------------------------------------------------------------
def _detail(with_line: bool = True) -> NodeDetailScreen:
line = PathLine([PathHop("Hub", key=_HUB), PathHop("★", you=True)])
route = _Route(
draw=(_HUB,),
spec="3d,f2",
path=line.text(),
context=Text("1 hop"),
line=line if with_line else None,
)
routes = _RoutesView(
routes=[route],
glyph_of=lambda n: ("●", "#ffffff"),
label_of=lambda n: n[:2],
label_rgb_of=lambda n: (200, 200, 200),
)
screen = NodeDetailScreen(
title="Node — Hub",
header=Text("Hub"),
info_rows=[("heard", Text("5m ago"))],
tabs=[_Tab("Info", "info"), _Tab("Routes", "routes")],
routes=routes,
)
screen.note_viewport(30)
return screen
def test_node_detail_places_act_only_on_the_routes_tab(places: _Places) -> None:
"""^N shows on the Routes tab only, and it changes the route row (not the header)."""
screen = _detail()
assert "^N" not in screen.footer_hint # the Info tab has no path line
assert not _lane_places(screen)
screen.handle(placemode.ACTION)
assert not screen._places.on # the key does nothing there
screen.handle("tab")
assert "^N places" in screen.footer_hint
assert [p.label for p in _lane_places(screen)] == ["Places"]
assert "❯ Hub" in _plain(screen.render_body(72))
screen.handle(placemode.ACTION)
body = _plain(screen.render_body(72))
assert "❯ Villeray" in body and "❯ Hub" not in body
assert "^N names" in screen.footer_hint
assert [p.label for p in _lane_places(screen)] == ["Names"]
screen.handle(placemode.ACTION)
assert "❯ Hub" in _plain(screen.render_body(72))
def test_node_detail_without_a_path_line_hides_the_key() -> None:
"""A route with no path line to change gives no hint and no chip."""
screen = _detail(with_line=False)
screen.handle("tab")
assert "^N" not in screen.footer_hint and not _lane_places(screen)
# -- the packet viewer -----------------------------------------------------------------
def _resolver(names: dict[str, str]): # noqa: ANN202
"""A node resolver that also tells the node of a hash, as ``make_node_resolver`` does."""
def resolve(hop: str) -> str:
return names.get(hop, "")
resolve.node_of = lambda hop: _HUB if hop in names else None # type: ignore[attr-defined]
return resolve
def _row(body: str, label: str) -> str:
"""The line of a card that starts with ``label``."""
return next(line for line in body.splitlines() if line.startswith(label))
def test_packet_viewer_places_change_the_via_chain_and_the_sender(places: _Places) -> None:
"""The ``from`` chip and the ``via`` line change. The route graph keeps its labels."""
entry = PacketEntry(when=utcnow(), kind="packet", node=_HUB, path=_HUB, raw={})
viewer = PacketViewer([entry], 0, resolve=_resolver({_HUB: "Hub"}))
assert "^N places" in viewer.footer_hint
assert viewer.footer_hint.endswith("Esc close")
assert [p.label for p in _lane_places(viewer)] == ["Places"]
body = _plain(viewer.render_body(80))
assert "Hub" in _row(body, "from") and "Hub" in _row(body, "via")
viewer.handle(placemode.ACTION)
body = _plain(viewer.render_body(80))
assert "Villeray" in _row(body, "from") and "Villeray" in _row(body, "via")
assert "Hub" not in _row(body, "from") + _row(body, "via")
assert "^N names" in viewer.footer_hint
assert [p.label for p in _lane_places(viewer)] == ["Names"]
def test_packet_viewer_hides_the_key_when_no_hop_is_drawn() -> None:
"""An ack has no path line and no hop chip, so ^N has no hint, no chip, and no effect."""
entry = PacketEntry(when=utcnow(), kind="ack", where="abcd")
viewer = PacketViewer([entry], 0, resolve=lambda h: "")
assert "^N" not in viewer.footer_hint and not _lane_places(viewer)
viewer.handle(placemode.ACTION)
assert not viewer._places.on
# -- the live feed -----------------------------------------------------------------------
class _FeedSession:
def invalidate(self) -> None:
pass
def test_livefeed_places_change_the_route_chips(places: _Places) -> None:
"""The two endpoints of an addressed packet change with ^N. An empty feed has no key."""
resolve = _resolver({_HUB: "Hub", "a1": "Alice"})
screen = LiveFeedScreen(session=_FeedSession(), resolve=resolve, seed=[])
screen.note_viewport(48)
assert "^N" not in screen.footer_hint and not _lane_places(screen) # no row yet
raw = {"payload_typename": "TEXT_MSG", "dest_hash": _HUB, "src_hash": "a1"}
obs = Observation(
node="", name="", kind="packet", snr=5.0, rssi=-90.0, observed_at=utcnow(), raw=raw
)
screen.on_event(MeshEvent.observation_event(obs))
assert "^N places" in screen.footer_hint
assert [p.label for p in _lane_places(screen)] == ["Places"]
body = _plain(screen.render_body(100))
assert "Hub" in body
screen.handle(placemode.ACTION)
body = _plain(screen.render_body(100))
assert "Villeray" in body and "Hub" not in body
assert "^N names" in screen.footer_hint
assert [p.label for p in _lane_places(screen)] == ["Names"]
# -- Trace -------------------------------------------------------------------------------
class _TraceSession:
def invalidate(self) -> None:
pass
def _trace_screen(auto_spec: str) -> TraceScreen:
async def flow(current): # noqa: ANN001, ANN202
return current
async def trace(path_spec, on_trace): # noqa: ANN001, ANN202
on_trace(TraceResult(target="Hub", success=True, hops=[Hop(index=0, node=_HUB, snr=5.0)]))
screen = TraceScreen(
"Hub",
device_label="Us",
device_hash="aabb" + "00" * 30,
resolve=_resolver({_HUB: "Hub"}),
session=_TraceSession(),
trace=trace,
compose_path=flow,
explore=flow,
pick_width=flow,
pick_samples=flow,
width_bytes=lambda: 6,
sample_count=lambda: 1,
pace_s=0.0,
auto_spec=lambda: auto_spec,
)
screen.note_viewport(40)
return screen
def test_trace_places_change_the_route_lane(places: _Places) -> None:
"""The planned route changes with ^N, and the hint and the chip say what the key does."""
screen = _trace_screen(_HUB)
assert "^N places" in screen.footer_hint
assert [p.label for p in _lane_places(screen)] == ["Places"]
assert "Hub" in _plain(screen.render_body(100))
screen.handle(placemode.ACTION)
body = _plain(screen.render_body(100))
assert "Villeray" in body
assert "^N names" in screen.footer_hint
assert [p.label for p in _lane_places(screen)] == ["Names"]
def test_trace_hides_the_key_when_there_is_no_route() -> None:
"""With no route on the page, ^N has no hint, no chip, and no effect."""
screen = _trace_screen("")
assert "^N" not in screen.footer_hint and not _lane_places(screen)
screen.handle(placemode.ACTION)
assert not screen._places.on