Performance sweep: cache the render funnel, the queries, the graphs
Every repaint re-rasterized every row and re-ran every layout; every screen open re-scanned the whole history. Now work is done once per change instead of once per frame: Render pipeline — a content-keyed ANSI cache in render_to_ansi (every Text/str row app-wide), memoized corner glow, and panel-wrap memos for the base frame and stacked dialogs, all dropped on a platform switch or emoji recalibration. Idle-frame compose falls 5-100x per screen (contacts 5.6->0.1 ms, record card 8.5->0.07 ms, trace 7.6->0.6 ms). Repository — an observed_at index turns every since-window query into a range walk (recent_observations 7.5->1 ms); heard_nodes and first_seen aggregate in one streaming pass by ISO-string comparison instead of hydrating dataclasses and sorting; node_names groups in SQL (NOT INDEXED past a slow planner choice). Per packet — livefeed no longer repaints on events that drew nothing, the channel list's stats TTL rises above the tick so the repository is not queried per frame, watch-store alerts batch through the throttled flush instead of a full-state disk write per new node, and the header's 360-bucket histogram/flags tuples are memoized per minute and packet. Per open — the resolvers, topology canonical()/display_name(), and Yen's route search memoize over their frozen inputs; timemachine, chat, and livefeed drop duplicate queries; the config editor, device actions, info, advert, and tx-optimize reuse the devstate session cache instead of re-asking the radio. Per frame, per screen — dashboard folds five window scans into one digest; walk caches everything derived from its frozen graph (the onward-count quadratic included); packet viewer, record dialog, trophy rows, trace stats/log, and the node-detail route fan memoize on their frozen inputs, invalidated by revision counters where the input can move. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
1 parent
6b13808ec6
commit
f69d1785b7
25 files changed
+704
-185
No files matched your search
@@ -183,7 +183,12 @@ def format_value(spec: SettingSpec, value: Any) -> str:
|
||||
# --- snapshot ----------------------------------------------------------------
|
||||
|
||||
|
||||
async def build_snapshot(device: Device) -> dict:
|
||||
async def build_snapshot(
|
||||
device: Device,
|
||||
*,
|
||||
self_info: Optional[dict] = None,
|
||||
path_hash_mode: Optional[int] = None,
|
||||
) -> dict:
|
||||
"""Read a device's full current configuration into one dict.
|
||||
|
||||
Merges ``SELF_INFO`` with the separately-read tuning parameters and path-hash mode.
|
||||
@@ -192,20 +197,28 @@ async def build_snapshot(device: Device) -> dict:
|
||||
|
||||
Args:
|
||||
device: A connected device.
|
||||
self_info: An already-read ``SELF_INFO`` dict to reuse instead of asking the
|
||||
radio again — a menu caller passes the devstate session cache here, saving
|
||||
a round-trip on every screen open. Omit to read live (a refresh after a
|
||||
restore or reset must not trust any cache).
|
||||
path_hash_mode: An already-read path-hash mode to reuse, on the same terms.
|
||||
|
||||
Returns:
|
||||
A dict keyed like ``SELF_INFO`` plus ``rx_delay``, ``airtime_factor``,
|
||||
``path_hash_mode``, ``autoadd_config`` and ``flood_scope``.
|
||||
"""
|
||||
snapshot = dict(await device.get_self_info())
|
||||
snapshot = dict(self_info if self_info is not None else await device.get_self_info())
|
||||
try:
|
||||
snapshot.update(await device.get_tuning())
|
||||
except Exception: # noqa: BLE001 - optional read; absence is acceptable
|
||||
pass
|
||||
try:
|
||||
snapshot["path_hash_mode"] = await device.get_path_hash_mode()
|
||||
except Exception: # noqa: BLE001 - optional read; absence is acceptable
|
||||
pass
|
||||
if path_hash_mode is not None:
|
||||
snapshot["path_hash_mode"] = path_hash_mode
|
||||
else:
|
||||
try:
|
||||
snapshot["path_hash_mode"] = await device.get_path_hash_mode()
|
||||
except Exception: # noqa: BLE001 - optional read; absence is acceptable
|
||||
pass
|
||||
try:
|
||||
snapshot["autoadd_config"] = await device.get_autoadd_config()
|
||||
except Exception: # noqa: BLE001 - optional read; absence is acceptable
|
||||
|
||||
@@ -248,18 +248,29 @@ class WatchStore:
|
||||
self.flush(only_if_due=True)
|
||||
|
||||
def mark_silent(self, key: str, when: Optional[datetime] = None) -> None:
|
||||
"""Latch a node's active silence alarm so it fires once per quiet spell."""
|
||||
"""Latch a node's active silence alarm so it fires once per quiet spell.
|
||||
|
||||
Packet/sweep-driven (like :meth:`note_heard`), so the write is throttled — the
|
||||
full-state save is synchronous on the event loop, and the sentinel flushes any
|
||||
pending change on stop.
|
||||
"""
|
||||
entry = self.state.watched.get(key)
|
||||
if entry is not None:
|
||||
entry.silent_since = when or utcnow()
|
||||
self._save()
|
||||
self._dirty = True
|
||||
self.flush(only_if_due=True)
|
||||
|
||||
def clear_silent(self, key: str) -> None:
|
||||
"""Re-arm a node's silence alarm after it has been heard again."""
|
||||
"""Re-arm a node's silence alarm after it has been heard again.
|
||||
|
||||
Packet-driven, so throttled like :meth:`mark_silent` — a recovery burst after an
|
||||
outage must not land one full-state disk write per packet.
|
||||
"""
|
||||
entry = self.state.watched.get(key)
|
||||
if entry is not None and entry.silent_since is not None:
|
||||
entry.silent_since = None
|
||||
self._save()
|
||||
self._dirty = True
|
||||
self.flush(only_if_due=True)
|
||||
|
||||
# --- the new-node baseline ---------------------------------------------------------
|
||||
|
||||
@@ -289,7 +300,13 @@ class WatchStore:
|
||||
def add_alert(
|
||||
self, kind: str, label: str, message: str, *, when: Optional[datetime] = None
|
||||
) -> Alert:
|
||||
"""Append an alert to the log (capped) and persist immediately.
|
||||
"""Append an alert to the log (capped) and persist, throttled.
|
||||
|
||||
Alerts fire from the packet path (a new mesh region can announce a never-seen
|
||||
node per packet for a while), and the save serializes the whole state
|
||||
synchronously on the event loop — so this batches through the same throttled
|
||||
flush as :meth:`note_heard`. The in-memory log (and the header badge it feeds)
|
||||
updates immediately either way; the sentinel flushes any pending write on stop.
|
||||
|
||||
Args:
|
||||
kind: The rule that tripped (``silence``/``recovered``/``snr``/``new-node``).
|
||||
@@ -309,7 +326,8 @@ class WatchStore:
|
||||
state.alerts.append(alert)
|
||||
if len(state.alerts) > ALERT_CAP:
|
||||
del state.alerts[: len(state.alerts) - ALERT_CAP]
|
||||
self._save()
|
||||
self._dirty = True
|
||||
self.flush(only_if_due=True)
|
||||
return alert
|
||||
|
||||
def alerts(self) -> list[Alert]:
|
||||
|
||||
@@ -164,6 +164,11 @@ CREATE INDEX IF NOT EXISTS idx_neighbour_reports_pair ON neighbour_reports(repea
|
||||
CREATE INDEX IF NOT EXISTS idx_discovered_paths_cat ON discovered_paths(category, width_bytes);
|
||||
CREATE INDEX IF NOT EXISTS idx_observations_run ON observations(run_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_observations_node ON observations(node);
|
||||
-- The reception history is queried by time window from every direction — the monitor's
|
||||
-- session seed, the dashboard's recent slice, the Time Machine's hour range, every
|
||||
-- ``since=`` filter — and observed_at stores UTC ISO-8601, which orders lexically, so a
|
||||
-- plain index turns each of those from a full-table scan into a range walk.
|
||||
CREATE INDEX IF NOT EXISTS idx_observations_observed_at ON observations(observed_at);
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_peer ON messages(peer);
|
||||
"""
|
||||
|
||||
|
||||
@@ -8,6 +8,7 @@ from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import statistics
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta
|
||||
from pathlib import Path
|
||||
@@ -1397,9 +1398,9 @@ class Repository:
|
||||
) -> list[tuple[str, Optional[str], datetime]]:
|
||||
"""When each node first ever appeared in the history, newest arrivals first.
|
||||
|
||||
The Time Machine's "new arrivals" feed: a single ordered scan folds out each
|
||||
node's earliest observation and its most recent advertised name (``packet``
|
||||
rows excluded — no reliable identity).
|
||||
The Time Machine's "new arrivals" feed: one grouped scan yields each node's
|
||||
earliest observation, labelled by its most recent advertised name (via
|
||||
:meth:`node_names`; ``packet`` rows excluded — no reliable identity).
|
||||
|
||||
Args:
|
||||
since: Only nodes whose *first* appearance is at or after this time.
|
||||
@@ -1407,26 +1408,34 @@ class Repository:
|
||||
Returns:
|
||||
``(node, latest_name, first_heard)`` triples, most recent arrival first.
|
||||
"""
|
||||
rows = self._conn.execute(
|
||||
# One streaming pass, unsorted: ``observed_at`` is UTC ISO-8601 and compares
|
||||
# correctly as a string, so each node's earliest stamp and latest name are
|
||||
# tracked by string comparison, and only the ~one winning stamp per node is
|
||||
# parsed — instead of ordering the whole history and walking it row-object by
|
||||
# row-object as this used to.
|
||||
firsts: dict[str, str] = {}
|
||||
names: dict[str, tuple[str, str]] = {}
|
||||
for row in self._conn.execute(
|
||||
"SELECT node, name, observed_at FROM observations "
|
||||
"WHERE node IS NOT NULL AND kind != 'packet' ORDER BY observed_at"
|
||||
).fetchall()
|
||||
firsts: dict[str, datetime] = {}
|
||||
names: dict[str, str] = {}
|
||||
for row in rows:
|
||||
node = row["node"]
|
||||
if node not in firsts:
|
||||
try:
|
||||
firsts[node] = datetime.fromisoformat(row["observed_at"])
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
"WHERE node IS NOT NULL AND kind != 'packet'"
|
||||
):
|
||||
node, iso = row["node"], row["observed_at"]
|
||||
earliest = firsts.get(node)
|
||||
if earliest is None or iso < earliest:
|
||||
firsts[node] = iso
|
||||
if row["name"]:
|
||||
names[node] = row["name"]
|
||||
arrivals = [
|
||||
(node, names.get(node), first)
|
||||
for node, first in firsts.items()
|
||||
if since is None or first >= since
|
||||
]
|
||||
named = names.get(node)
|
||||
if named is None or iso >= named[0]:
|
||||
names[node] = (iso, row["name"])
|
||||
arrivals: list[tuple[str, Optional[str], datetime]] = []
|
||||
for node, iso in firsts.items():
|
||||
try:
|
||||
first = datetime.fromisoformat(iso)
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
if since is None or first >= since:
|
||||
named = names.get(node)
|
||||
arrivals.append((node, named[1] if named else None, first))
|
||||
arrivals.sort(key=lambda t: t[2], reverse=True)
|
||||
return arrivals
|
||||
|
||||
@@ -1491,10 +1500,15 @@ class Repository:
|
||||
Returns:
|
||||
Latest non-empty name keyed by stored node id (the 12-hex key prefix).
|
||||
"""
|
||||
# SQLite's bare-column-with-MAX guarantee: grouped with ``MAX(observed_at)``, the
|
||||
# ungrouped ``name`` is taken from the row that supplied the maximum — the latest
|
||||
# name per node in one aggregate scan, no Python walk over the whole history.
|
||||
# ``NOT INDEXED``, because the planner otherwise walks ``idx_observations_node``
|
||||
# row by row (a random-access fetch per entry — measurably slower than the scan).
|
||||
rows = self._conn.execute(
|
||||
"SELECT node, name FROM observations "
|
||||
"SELECT node, name, MAX(observed_at) FROM observations NOT INDEXED "
|
||||
"WHERE node IS NOT NULL AND name IS NOT NULL AND name != '' "
|
||||
"AND kind != 'packet' ORDER BY observed_at"
|
||||
"AND kind != 'packet' GROUP BY node"
|
||||
).fetchall()
|
||||
return {row["node"]: row["name"] for row in rows}
|
||||
|
||||
@@ -1522,24 +1536,55 @@ class Repository:
|
||||
if since is not None:
|
||||
sql += " AND observed_at >= ?"
|
||||
params.append(since.isoformat())
|
||||
rows = self._conn.execute(sql, params).fetchall()
|
||||
|
||||
grouped: dict[Optional[str], list[Observation]] = {}
|
||||
for row in rows:
|
||||
obs = Observation(
|
||||
node=row["node"],
|
||||
public_key=row["public_key"],
|
||||
name=row["name"],
|
||||
node_type=row["node_type"],
|
||||
snr=row["snr"],
|
||||
rssi=row["rssi"],
|
||||
lat=row["lat"],
|
||||
lon=row["lon"],
|
||||
observed_at=datetime.fromisoformat(row["observed_at"]),
|
||||
# One streaming pass, aggregating in place. This is a whole-history scan on the
|
||||
# open path of half the screens (Contacts, the map, a trace's target list), so it
|
||||
# never materializes per-row Observation objects or parses per-row timestamps —
|
||||
# ``observed_at`` is UTC ISO-8601, which compares correctly as a *string*, so each
|
||||
# "most recent X" is tracked by string comparison and only the one winning stamp
|
||||
# per node is parsed at the end. ``>=`` on every comparison keeps the old
|
||||
# sort-then-walk-backwards tie behaviour: among equal stamps, the later row wins.
|
||||
stats: dict[Optional[str], list] = {}
|
||||
for row in self._conn.execute(sql, params):
|
||||
iso = row["observed_at"]
|
||||
snr = row["snr"]
|
||||
s = stats.get(row["node"])
|
||||
if s is None:
|
||||
# [count, snrs, last_iso, last_rssi, name, name_iso, type, type_iso,
|
||||
# key, key_iso, lat, lon, loc_iso]
|
||||
stats[row["node"]] = s = [
|
||||
0, [], "", None, None, "", None, "", None, "", None, None, ""
|
||||
]
|
||||
s[0] += 1
|
||||
if snr is not None:
|
||||
s[1].append(snr)
|
||||
if iso >= s[2]:
|
||||
s[2], s[3] = iso, row["rssi"]
|
||||
if row["name"] and iso >= s[5]:
|
||||
s[4], s[5] = row["name"], iso
|
||||
if row["node_type"] is not None and iso >= s[7]:
|
||||
s[6], s[7] = row["node_type"], iso
|
||||
if row["public_key"] and iso >= s[9]:
|
||||
s[8], s[9] = row["public_key"], iso
|
||||
if row["lat"] is not None and row["lon"] is not None and iso >= s[12]:
|
||||
s[10], s[11], s[12] = row["lat"], row["lon"], iso
|
||||
|
||||
nodes = [
|
||||
HeardNode(
|
||||
node=node,
|
||||
name=s[4],
|
||||
count=s[0],
|
||||
median_snr=statistics.median(s[1]) if s[1] else None,
|
||||
best_snr=max(s[1]) if s[1] else None,
|
||||
last_rssi=s[3],
|
||||
last_seen=datetime.fromisoformat(s[2]),
|
||||
lat=s[10],
|
||||
lon=s[11],
|
||||
node_type=s[6],
|
||||
public_key=s[8],
|
||||
)
|
||||
grouped.setdefault(row["node"], []).append(obs)
|
||||
|
||||
nodes = [HeardNode.from_observations(node, obs) for node, obs in grouped.items()]
|
||||
for node, s in stats.items()
|
||||
]
|
||||
for heard in nodes: # backfill the type registry from history (PicoCalc colour)
|
||||
register_node_type(heard.public_key or heard.node, heard.node_type)
|
||||
return sorted(nodes, key=lambda n: n.last_seen, reverse=True)
|
||||
|
||||
@@ -69,6 +69,13 @@ class MonitorService:
|
||||
# indicator answers "is the mesh alive?", not "any mail?". Pruned as it rolls,
|
||||
# so it never holds more than the six-hour window plus one closing bucket.
|
||||
self._activity: dict[int, int] = {}
|
||||
# The last histogram/flags tuples, keyed by what they derive from — the current
|
||||
# minute bucket and (for the histogram) the packet-arrival stamp below. The header
|
||||
# rebuilds both on every repaint of every screen; between packets and minute
|
||||
# rolls that was 720 dict lookups a frame for identical tuples.
|
||||
self._activity_stamp = 0
|
||||
self._histogram_cache: tuple[int, int, tuple[int, ...]] = (-1, -1, ())
|
||||
self._flags_cache: tuple[int, tuple[bool, ...]] = (-1, ())
|
||||
# Tallies by packet class (advert/telemetry/packet/message/ack): seeded from
|
||||
# stored history below, then fed live by the kind-unfiltered subscription —
|
||||
# the dashboard's traffic panel, persistent across sessions.
|
||||
@@ -139,7 +146,14 @@ class MonitorService:
|
||||
:data:`ACTIVITY_BUCKETS` bucket counts.
|
||||
"""
|
||||
bucket = int(time.time() // ACTIVITY_BUCKET_S)
|
||||
return tuple(self._activity.get(bucket - i, 0) for i in range(ACTIVITY_BUCKETS))
|
||||
stamp = self._activity_stamp
|
||||
cached_bucket, cached_stamp, histogram = self._histogram_cache
|
||||
if bucket != cached_bucket or stamp != cached_stamp:
|
||||
histogram = tuple(
|
||||
self._activity.get(bucket - i, 0) for i in range(ACTIVITY_BUCKETS)
|
||||
)
|
||||
self._histogram_cache = (bucket, stamp, histogram)
|
||||
return histogram
|
||||
|
||||
def activity_session_flags(self) -> tuple[bool, ...]:
|
||||
"""Whether each histogram bucket holds this session's own traffic.
|
||||
@@ -153,7 +167,11 @@ class MonitorService:
|
||||
:data:`ACTIVITY_BUCKETS` flags, newest first.
|
||||
"""
|
||||
bucket = int(time.time() // ACTIVITY_BUCKET_S)
|
||||
return tuple(bucket - i >= self._start_bucket for i in range(ACTIVITY_BUCKETS))
|
||||
cached_bucket, flags = self._flags_cache
|
||||
if bucket != cached_bucket:
|
||||
flags = tuple(bucket - i >= self._start_bucket for i in range(ACTIVITY_BUCKETS))
|
||||
self._flags_cache = (bucket, flags)
|
||||
return flags
|
||||
|
||||
def kind_counts(self) -> dict[str, int]:
|
||||
"""Tallies by packet class: advert/telemetry/packet buckets, message, ack.
|
||||
@@ -172,6 +190,7 @@ class MonitorService:
|
||||
"""Land one packet in the current activity bucket (and prune scrolled-off ones)."""
|
||||
bucket = int(time.time() // ACTIVITY_BUCKET_S)
|
||||
self._activity[bucket] = self._activity.get(bucket, 0) + 1
|
||||
self._activity_stamp += 1 # invalidates the memoized histogram tuple
|
||||
obs = event.observation
|
||||
kind = obs.kind if obs is not None else event.kind.value
|
||||
if obs is not None and kind == "packet":
|
||||
|
||||
@@ -74,6 +74,9 @@ _CORROBORATION_MARGIN = 3
|
||||
|
||||
_HEX_DIGITS = frozenset("0123456789abcdef")
|
||||
|
||||
#: Distinguishes "memoized as None" from "not memoized" in the identity caches.
|
||||
_MISS = object()
|
||||
|
||||
|
||||
def _is_hex(value: str) -> bool:
|
||||
"""Whether ``value`` is non-empty, even-length hex (a plausible path hash)."""
|
||||
@@ -292,6 +295,18 @@ class MeshTopology:
|
||||
key = (c.public_key or c.key_prefix or "").lower().removeprefix("0x")
|
||||
if key:
|
||||
self._known.append((key, key[:12], c.name))
|
||||
# ``_known`` never changes after construction, and a build feeds the same few
|
||||
# dozen distinct hashes through canonical() thousands of times (every hop of
|
||||
# every stored packet path), so both identity lookups memoize per instance.
|
||||
self._canonical_memo: dict[str, Optional[str]] = {}
|
||||
self._name_memo: dict[str, Optional[str]] = {}
|
||||
# Route search results per (target, k), valid for one graph shape: every link
|
||||
# mutation bumps the version, so a memoized Yen's run can never outlive the
|
||||
# evidence it ranked. Callers ask for the same target twice per screen open
|
||||
# (suggested() and scenarios() both run the search), and the search is the
|
||||
# single priciest part of a topology-backed open.
|
||||
self._graph_version = 0
|
||||
self._routes_memo: dict[tuple[str, int, int], list[tuple[str, ...]]] = {}
|
||||
|
||||
# --- identity ----------------------------------------------------------------
|
||||
|
||||
@@ -313,24 +328,32 @@ class MeshTopology:
|
||||
"""
|
||||
if not hop:
|
||||
return None
|
||||
cached = self._canonical_memo.get(hop, _MISS)
|
||||
if cached is not _MISS:
|
||||
return cached
|
||||
needle = hop.lower().removeprefix("0x")
|
||||
if not _is_hex(needle):
|
||||
return None
|
||||
matches = {
|
||||
canonical
|
||||
for key, canonical, _name in self._known
|
||||
if key.startswith(needle) or needle.startswith(key[:12])
|
||||
}
|
||||
if len(matches) == 1:
|
||||
return next(iter(matches))
|
||||
return needle[:12]
|
||||
result: Optional[str] = None
|
||||
else:
|
||||
matches = {
|
||||
canonical
|
||||
for key, canonical, _name in self._known
|
||||
if key.startswith(needle) or needle.startswith(key[:12])
|
||||
}
|
||||
result = next(iter(matches)) if len(matches) == 1 else needle[:12]
|
||||
self._canonical_memo[hop] = result
|
||||
return result
|
||||
|
||||
def display_name(self, node: str) -> Optional[str]:
|
||||
"""The contact name for a canonical id, or ``None`` when unknown."""
|
||||
for key, canonical, name in self._known:
|
||||
if canonical == node:
|
||||
return name
|
||||
return None
|
||||
cached = self._name_memo.get(node, _MISS)
|
||||
if cached is not _MISS:
|
||||
return cached
|
||||
result = next(
|
||||
(name for _key, canonical, name in self._known if canonical == node), None
|
||||
)
|
||||
self._name_memo[node] = result
|
||||
return result
|
||||
|
||||
# --- construction ------------------------------------------------------------
|
||||
|
||||
@@ -357,6 +380,7 @@ class MeshTopology:
|
||||
source: Evidence class tag (``trace`` / ``route`` / ``packet`` /
|
||||
``neighbour``).
|
||||
"""
|
||||
self._graph_version += 1 # link evidence moved; memoized route searches expire
|
||||
for i in range(len(nodes) - 1):
|
||||
a, b = nodes[i], nodes[i + 1]
|
||||
if not a or not b or a == b:
|
||||
@@ -543,6 +567,7 @@ class MeshTopology:
|
||||
|
||||
def _merge_node(self, src: str, dst: str) -> None:
|
||||
"""Relabel every link touching ``src`` onto ``dst``, folding shared links together."""
|
||||
self._graph_version += 1 # the graph is being reshaped; memoized searches expire
|
||||
for key in list(self._links):
|
||||
if src not in key:
|
||||
continue
|
||||
@@ -759,8 +784,14 @@ class MeshTopology:
|
||||
|
||||
Returns:
|
||||
The intermediate-hop tuples of the found routes (endpoints stripped),
|
||||
cheapest total-cost first.
|
||||
cheapest total-cost first. Memoized per graph version (see
|
||||
``_routes_memo``) — callers treat the list as read-only, which they do
|
||||
(both consumers only iterate it).
|
||||
"""
|
||||
memo_key = (target, k, self._graph_version)
|
||||
memoized = self._routes_memo.get(memo_key)
|
||||
if memoized is not None:
|
||||
return memoized
|
||||
neighbors: dict[str, list[tuple[str, float]]] = {}
|
||||
for (a, b), link in self._links.items():
|
||||
cost = 1.0 / max(link.strength(self._now), 1e-6) + _HOP_PENALTY
|
||||
@@ -806,6 +837,7 @@ class MeshTopology:
|
||||
|
||||
first = shortest(self.self_id, set(), set())
|
||||
if first is None or len(first[1]) - 2 > _MAX_SCENARIO_HOPS:
|
||||
self._routes_memo[memo_key] = []
|
||||
return []
|
||||
accepted: list[list[str]] = [first[1]]
|
||||
# Spur candidates, a min-heap by total cost (counter tiebreaker so equal-cost
|
||||
@@ -843,7 +875,9 @@ class MeshTopology:
|
||||
break
|
||||
_, _, best_path = heapq.heappop(candidates)
|
||||
accepted.append(best_path)
|
||||
return [tuple(path[1:-1]) for path in accepted]
|
||||
routes = [tuple(path[1:-1]) for path in accepted]
|
||||
self._routes_memo[memo_key] = routes
|
||||
return routes
|
||||
|
||||
|
||||
def build_topology(
|
||||
|
||||
@@ -61,18 +61,29 @@ def make_node_resolver(
|
||||
if name and ident:
|
||||
entries.append((name, "", ident))
|
||||
|
||||
# Memoized per label: the render paths ask for the same few hop hashes on every
|
||||
# repaint (per hop, per row, per frame), and ``entries`` is immutable for this
|
||||
# closure's lifetime, so each distinct label is scanned exactly once.
|
||||
memo: dict[str, Optional[str]] = {}
|
||||
|
||||
def resolve(label: Optional[str]) -> Optional[str]:
|
||||
if not label:
|
||||
return label
|
||||
if label in memo:
|
||||
return memo[label]
|
||||
needle = label.lower().removeprefix("0x")
|
||||
result = label
|
||||
for name, pub, prefix in entries:
|
||||
# The hash is a prefix of the node's key; match either against the full
|
||||
# public key or the (possibly shorter) stored prefix, in either direction.
|
||||
if pub and pub.startswith(needle):
|
||||
return name
|
||||
result = name
|
||||
break
|
||||
if prefix and (prefix.startswith(needle) or needle.startswith(prefix)):
|
||||
return name
|
||||
return label
|
||||
result = name
|
||||
break
|
||||
memo[label] = result
|
||||
return result
|
||||
|
||||
return resolve
|
||||
|
||||
@@ -100,14 +111,21 @@ def make_node_type_resolver(
|
||||
if ident and c.node_type is not None:
|
||||
entries.append((ident, c.node_type))
|
||||
|
||||
memo: dict[str, Optional[int]] = {} # per label, as in make_node_resolver
|
||||
|
||||
def type_of(label: Optional[str]) -> Optional[int]:
|
||||
if not label:
|
||||
return None
|
||||
if label in memo:
|
||||
return memo[label]
|
||||
needle = label.lower().removeprefix("0x")
|
||||
result = None
|
||||
for ident, node_type in entries:
|
||||
if ident.startswith(needle) or needle.startswith(ident):
|
||||
return node_type
|
||||
return None
|
||||
result = node_type
|
||||
break
|
||||
memo[label] = result
|
||||
return result
|
||||
|
||||
return type_of
|
||||
|
||||
@@ -134,14 +152,17 @@ def make_key_resolver(contacts: Optional[list[Contact]]) -> NodeResolver:
|
||||
if (pub := (c.public_key or "").lower().removeprefix("0x"))
|
||||
]
|
||||
|
||||
memo: dict[str, str] = {} # per label, as in make_node_resolver
|
||||
|
||||
def resolve(label: Optional[str]) -> Optional[str]:
|
||||
if not label:
|
||||
return label
|
||||
if label in memo:
|
||||
return memo[label]
|
||||
needle = label.lower().removeprefix("0x")
|
||||
for pub in keys:
|
||||
if pub.startswith(needle):
|
||||
return pub
|
||||
return label
|
||||
result = next((pub for pub in keys if pub.startswith(needle)), label)
|
||||
memo[label] = result
|
||||
return result
|
||||
|
||||
return resolve
|
||||
|
||||
|
||||
@@ -41,11 +41,10 @@ class InfoTool(Tool):
|
||||
Returns:
|
||||
A :class:`ToolResult` summarizing the device name.
|
||||
"""
|
||||
from ..core.device_config import build_snapshot
|
||||
from ..ui.config_editor import config_table
|
||||
from ..ui.config_editor import cached_snapshot, config_table
|
||||
|
||||
device = await ctx.device()
|
||||
snapshot = await build_snapshot(device)
|
||||
snapshot = await cached_snapshot(ctx, device)
|
||||
custom = await device.get_custom_vars()
|
||||
|
||||
# A live status panel (role, firmware, battery, clock, radio/packet statistics)
|
||||
|
||||
@@ -128,7 +128,7 @@ class TxOptimizeTool(Tool):
|
||||
from ..ui.tx_screen import open_tx_optimize
|
||||
|
||||
device = await ctx.device()
|
||||
contacts = await device.get_contacts()
|
||||
contacts = await ctx.devstate.contacts() # the session cache; no re-read
|
||||
admin_node = next(
|
||||
(c for c in contacts if c.name == str(params["admin"])), None
|
||||
)
|
||||
|
||||
@@ -37,6 +37,7 @@ from __future__ import annotations
|
||||
import asyncio
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
from functools import lru_cache
|
||||
from typing import TYPE_CHECKING, Awaitable, Callable, Optional
|
||||
|
||||
from rich.console import Group
|
||||
@@ -408,9 +409,11 @@ class _LiveStats:
|
||||
the manager sits open updates that channel's counts, age, and sparkline in place —
|
||||
but the repository is re-queried at most once per ``ttl`` seconds rather than once per
|
||||
row per repaint, so a full slot table stays cheap at the session's ~1 Hz repaint.
|
||||
The TTL sits *above* that repaint period on purpose: at exactly the tick rate every
|
||||
idle frame would still land one repository query — the throttle would gate nothing.
|
||||
"""
|
||||
|
||||
def __init__(self, ctx: "AppContext", *, ttl: float = 1.0) -> None:
|
||||
def __init__(self, ctx: "AppContext", *, ttl: float = 3.0) -> None:
|
||||
"""Bind to a context; the first read populates the cache."""
|
||||
self._ctx = ctx
|
||||
self._ttl = ttl
|
||||
@@ -465,6 +468,7 @@ _BADGE_WIDTH = 5
|
||||
_COUNT_WIDTH = 5
|
||||
#: Width of the right-aligned last-message-age lane (fits ``never``-length ages).
|
||||
_AGE_WIDTH = 5
|
||||
@lru_cache(maxsize=32)
|
||||
def _activity_sparkline(histogram: "tuple[int, ...]", peak: float) -> Text:
|
||||
"""The channel's braille activity sparkline over the trailing two hours, now at the right.
|
||||
|
||||
@@ -474,6 +478,10 @@ def _activity_sparkline(histogram: "tuple[int, ...]", peak: float) -> Text:
|
||||
:meth:`_LiveStats.peak`) — so the whole activity column shares one scale and the
|
||||
rows' bars are comparable at a glance. The histogram runs deeper than is drawn; the
|
||||
tail past the drawn buckets shapes ``peak`` but isn't charted.
|
||||
|
||||
Memoized on its (hashable) inputs: the row callables rebuild every repaint, but the
|
||||
histogram snapshot only moves once per :class:`_LiveStats` TTL, so between refreshes
|
||||
every slot's sparkline is a cache hit. Callers treat the returned Text as read-only.
|
||||
"""
|
||||
return activity_sparkline(histogram, ACTIVITY_DRAWN_BUCKETS, peak=peak)
|
||||
|
||||
|
||||
+3
-2
@@ -1021,9 +1021,10 @@ async def _make_paths_presenter(
|
||||
|
||||
session = ctx.ui.session
|
||||
contacts = await ctx.devstate.contacts()
|
||||
resolve = trace_runner.make_node_resolver(contacts, ctx.repo.node_names())
|
||||
stored_names = ctx.repo.node_names()
|
||||
resolve = trace_runner.make_node_resolver(contacts, stored_names)
|
||||
type_of = trace_runner.make_node_type_resolver(contacts)
|
||||
key_of = trace_runner.make_name_key_resolver(contacts, ctx.repo.node_names())
|
||||
key_of = trace_runner.make_name_key_resolver(contacts, stored_names)
|
||||
prefix_bytes = await _routing_prefix_bytes(ctx)
|
||||
self_name: Optional[str] = None
|
||||
try:
|
||||
|
||||
@@ -99,6 +99,28 @@ _REBOOT_DROP_TIMEOUT_S = 10.0
|
||||
_REBOOT_DROP_POLL_S = 0.25
|
||||
|
||||
|
||||
async def cached_snapshot(ctx: "AppContext", device: "Device") -> dict:
|
||||
"""A config snapshot for a *screen open*, reusing the devstate session cache.
|
||||
|
||||
The two facts devstate already holds — ``SELF_INFO`` and the path-hash mode — are
|
||||
the slowest part of :func:`~meshterm.core.device_config.build_snapshot` to re-ask
|
||||
the radio for, and every config apply invalidates them (see
|
||||
``tools/config.py``), so an open can trust the cache. The refresh after a restore,
|
||||
key change, or factory reset keeps calling ``build_snapshot(device)`` raw: the
|
||||
device state genuinely changed under us there.
|
||||
"""
|
||||
self_info: Optional[dict] = None
|
||||
path_hash_mode: Optional[int] = None
|
||||
try:
|
||||
self_info = await ctx.devstate.self_info()
|
||||
path_hash_mode = await ctx.devstate.path_hash_mode()
|
||||
except Exception: # noqa: BLE001 - fall back to the raw reads below
|
||||
pass
|
||||
return await build_snapshot(
|
||||
device, self_info=self_info, path_hash_mode=path_hash_mode
|
||||
)
|
||||
|
||||
|
||||
async def edit_config(ctx: "AppContext") -> Optional[list[tuple]]:
|
||||
"""Run the interactive editor and return the staged operations to perform.
|
||||
|
||||
@@ -112,7 +134,7 @@ async def edit_config(ctx: "AppContext") -> Optional[list[tuple]]:
|
||||
from .tui import CANCEL, SelectScreen
|
||||
|
||||
device = await ctx.device()
|
||||
snapshot = await build_snapshot(device)
|
||||
snapshot = await cached_snapshot(ctx, device)
|
||||
custom = await device.get_custom_vars()
|
||||
# The background-advert cadences are app-side settings (MeshTerm sends the adverts,
|
||||
# not the firmware), but they're staged and applied exactly like device values so
|
||||
@@ -652,7 +674,7 @@ async def device_actions(ctx: "AppContext") -> None:
|
||||
from .tui import CANCEL, SelectScreen
|
||||
|
||||
device = await ctx.device()
|
||||
snapshot = await build_snapshot(device)
|
||||
snapshot = await cached_snapshot(ctx, device)
|
||||
|
||||
# Same persistent-backdrop pattern as the editor: the menu stays pushed while each
|
||||
# action's prompts float over it as modal popups (see edit_config).
|
||||
@@ -749,7 +771,7 @@ async def send_advert(ctx: "AppContext") -> None:
|
||||
ctx: Shared application context (provides the connected device and UI surface).
|
||||
"""
|
||||
device = await ctx.device()
|
||||
snapshot = dict(await device.get_self_info())
|
||||
snapshot = dict(await ctx.devstate.self_info()) # the session cache; no re-read
|
||||
# No emoji in this floating dialog's title: a terminal that paints an emoji a cell
|
||||
# narrower than Rich measures it leaves the content-sized popup's title border short,
|
||||
# bleeding the backdrop through the frame. The menu row keeps its 📡 icon (drawn in the
|
||||
|
||||
@@ -171,6 +171,12 @@ class DashboardScreen(Screen):
|
||||
#: dynamic rows): ``stats`` from get_stats, ``battery`` from get_battery.
|
||||
self.stats: dict = {}
|
||||
self.battery: dict = {}
|
||||
# The one-pass window aggregates (see _digest_window), refreshed per repaint.
|
||||
self._win_nodes: set[str] = set()
|
||||
self._win_repeaters: set[str] = set()
|
||||
self._win_counts: Counter = Counter()
|
||||
self._win_snrs: list[float] = []
|
||||
self._win_rssis: list[float] = []
|
||||
|
||||
# --- live window -----------------------------------------------------------------
|
||||
|
||||
@@ -212,6 +218,7 @@ class DashboardScreen(Screen):
|
||||
def render_body(self, width: int) -> list[str]:
|
||||
"""Render the overview sections as one scrolling body."""
|
||||
self._prune()
|
||||
self._digest_window()
|
||||
body: list[RenderableType] = [
|
||||
*self._activity_section(width),
|
||||
Text(),
|
||||
@@ -223,6 +230,37 @@ class DashboardScreen(Screen):
|
||||
self._scroll_total = max(1, len(lines))
|
||||
return lines
|
||||
|
||||
def _digest_window(self) -> None:
|
||||
"""Fold the observation window into the per-frame aggregates, in one pass.
|
||||
|
||||
The pulse line, the busiest-transmitter row, and the RF section each need a
|
||||
different slice of the same window; scanning the (up to 4000-entry) deque once
|
||||
per consumer added up to five full passes on every repaint of a busy mesh.
|
||||
One pass here fills them all; the section builders read the results.
|
||||
"""
|
||||
nodes: set[str] = set()
|
||||
repeaters: set[str] = set()
|
||||
counts: Counter = Counter()
|
||||
snrs: list[float] = []
|
||||
rssis: list[float] = []
|
||||
for o in self._window:
|
||||
if o.node and o.node_type == NODE_TYPE_REPEATER:
|
||||
repeaters.add(o.node)
|
||||
if o.kind == "packet":
|
||||
continue
|
||||
if o.node:
|
||||
nodes.add(o.node)
|
||||
counts[o.node] += 1
|
||||
if o.snr is not None:
|
||||
snrs.append(o.snr)
|
||||
if o.rssi is not None:
|
||||
rssis.append(o.rssi)
|
||||
self._win_nodes = nodes
|
||||
self._win_repeaters = repeaters
|
||||
self._win_counts = counts
|
||||
self._win_snrs = snrs
|
||||
self._win_rssis = rssis
|
||||
|
||||
# -- activity --
|
||||
|
||||
def _activity_section(self, width: int) -> list[RenderableType]:
|
||||
@@ -296,12 +334,8 @@ class DashboardScreen(Screen):
|
||||
recent = sum(shown[:15]) / max(1, min(15, len(shown)))
|
||||
overall = sum(shown) / max(1, len(shown))
|
||||
span = _span_label(len(shown))
|
||||
nodes = {o.node for o in self._window if o.node and o.kind != "packet"}
|
||||
repeaters = {
|
||||
o.node
|
||||
for o in self._window
|
||||
if o.node and o.node_type == NODE_TYPE_REPEATER
|
||||
}
|
||||
nodes = self._win_nodes # the one-pass window digest (see _digest_window)
|
||||
repeaters = self._win_repeaters
|
||||
|
||||
def compose(heard: bool) -> Text:
|
||||
line = Text()
|
||||
@@ -335,9 +369,7 @@ class DashboardScreen(Screen):
|
||||
|
||||
def _busiest(self) -> Optional[tuple[str, int]]:
|
||||
"""The window's most-heard attributable node, or ``None`` in silence."""
|
||||
counts = Counter(
|
||||
o.node for o in self._window if o.node and o.kind != "packet"
|
||||
)
|
||||
counts = self._win_counts # the one-pass window digest (see _digest_window)
|
||||
if not counts:
|
||||
return None
|
||||
node, count = counts.most_common(1)[0]
|
||||
@@ -387,8 +419,8 @@ class DashboardScreen(Screen):
|
||||
heading.append(" · reception over 2 h · radio live", style="muted")
|
||||
rows: list[tuple[str, Text]] = []
|
||||
|
||||
snrs = [o.snr for o in self._window if o.snr is not None and o.kind != "packet"]
|
||||
rssis = [o.rssi for o in self._window if o.rssi is not None and o.kind != "packet"]
|
||||
snrs = self._win_snrs # the one-pass window digest (see _digest_window)
|
||||
rssis = self._win_rssis
|
||||
if snrs:
|
||||
med = median(snrs)
|
||||
line = Text(f"{med:+.1f} dB median ", style=snr_style(med))
|
||||
|
||||
@@ -232,11 +232,12 @@ class LiveFeedScreen(Screen):
|
||||
when=utcnow(), kind="ack",
|
||||
where=event.ack.code or "delivery confirmed",
|
||||
)
|
||||
if entry is not None:
|
||||
self._feed.appendleft(entry)
|
||||
# Keep the highlight on the same packet as new rows push it down.
|
||||
if self._selected is not None:
|
||||
self._selected = min(self._selected + 1, len(self._feed) - 1)
|
||||
if entry is None:
|
||||
return # nothing new on screen — don't buy a full repaint for it
|
||||
self._feed.appendleft(entry)
|
||||
# Keep the highlight on the same packet as new rows push it down.
|
||||
if self._selected is not None:
|
||||
self._selected = min(self._selected + 1, len(self._feed) - 1)
|
||||
self._session.invalidate()
|
||||
|
||||
# --- input -----------------------------------------------------------------------
|
||||
@@ -739,12 +740,17 @@ async def open_livefeed(ctx: "AppContext") -> None:
|
||||
contacts = []
|
||||
# Contacts first, every name the recorder ever overheard as the fallback — the
|
||||
# app-wide rule that a node we can name never renders as a bare hash.
|
||||
resolve = trace_runner.make_node_resolver(contacts, ctx.repo.node_names())
|
||||
stored_names = ctx.repo.node_names()
|
||||
resolve = trace_runner.make_node_resolver(contacts, stored_names)
|
||||
type_of = trace_runner.make_node_type_resolver(contacts)
|
||||
key_of = trace_runner.make_name_key_resolver(contacts, ctx.repo.node_names())
|
||||
key_of = trace_runner.make_name_key_resolver(contacts, stored_names)
|
||||
prefix_bytes = await _routing_prefix_bytes(ctx)
|
||||
|
||||
seed = ctx.repo.recent_observations(since=utcnow() - OBSERVATION_WINDOW)
|
||||
# Only the newest screenful is kept (the deque caps at _FEED_CAP), so only that
|
||||
# many are worth hydrating.
|
||||
seed = ctx.repo.recent_observations(
|
||||
since=utcnow() - OBSERVATION_WINDOW, limit=_FEED_CAP
|
||||
)
|
||||
screen = LiveFeedScreen(
|
||||
session=session,
|
||||
resolve=resolve,
|
||||
|
||||
@@ -359,6 +359,8 @@ class NodeDetailScreen(Screen):
|
||||
#: it moves onto a route row and holds while it rests on an action row, so the graph
|
||||
#: keeps showing the last pick.
|
||||
self._route_sel = 0
|
||||
#: The composed route fan for one (width, rows, selection) — see _routes_stage.
|
||||
self._stage_memo: Optional[tuple[tuple, list[str]]] = None
|
||||
self._cursor: Optional[int] = None
|
||||
#: The route list's window state: the first visible row, the rows the last fit
|
||||
#: carried (the PgUp/PgDn stride), and whether any rows are hidden (gates the
|
||||
@@ -712,6 +714,16 @@ class NodeDetailScreen(Screen):
|
||||
if not rv.routes or rv.glyph_of is None:
|
||||
return render_lines(Text(rv.note or "no route observed yet", style="muted"), width)
|
||||
sel = self._route_sel if 0 <= self._route_sel < len(rv.routes) else 0
|
||||
# The routes view is a snapshot (the opener built it once), so the whole fan —
|
||||
# a multi-pass graph layout — is a pure function of the width, the row budget,
|
||||
# and which route is emphasized. One slot suffices: the key only moves on a
|
||||
# selection change or a resize, and then the previous layout is dead anyway.
|
||||
caption_lines = 1 + (1 if rv.legend else 0)
|
||||
list_need = min(sum(len(block) for block in route_blocks), _LIST_MIN_LINES)
|
||||
max_rows = max(_GRAPH_MIN_ROWS, min(_PATH_MAX_ROWS, budget - caption_lines - list_need))
|
||||
stage_key = (width, max_rows, sel)
|
||||
if self._stage_memo is not None and self._stage_memo[0] == stage_key:
|
||||
return self._stage_memo[1]
|
||||
# Priority is fixed by evidence order (route 0, the best-evidence route, is always the
|
||||
# spine) so the fan's geometry never moves as the selection changes — only emphasis
|
||||
# (which route is drawn white and on top) and the label muting below follow the pick.
|
||||
@@ -738,9 +750,6 @@ class NodeDetailScreen(Screen):
|
||||
def label_rgb_of(node: str):
|
||||
return base_rgb(node) if node in on_route else _GREY
|
||||
|
||||
caption_lines = 1 + (1 if rv.legend else 0)
|
||||
list_need = min(sum(len(block) for block in route_blocks), _LIST_MIN_LINES)
|
||||
max_rows = max(_GRAPH_MIN_ROWS, min(_PATH_MAX_ROWS, budget - caption_lines - list_need))
|
||||
lines = list(
|
||||
render_path_graph(
|
||||
layers,
|
||||
@@ -755,6 +764,7 @@ class NodeDetailScreen(Screen):
|
||||
lines.extend(render_lines(caption, width, no_wrap=True))
|
||||
if rv.legend:
|
||||
lines.extend(render_lines(node_type_legend(), width, no_wrap=True))
|
||||
self._stage_memo = (stage_key, lines)
|
||||
return lines
|
||||
|
||||
def _route_row_lines(self, route: _Route, selected: bool, width: int) -> list[str]:
|
||||
|
||||
@@ -30,6 +30,7 @@ dialog, matching what they do on every other screen; Esc closes it.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections import OrderedDict
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime
|
||||
from typing import Callable, Optional, Sequence
|
||||
@@ -39,9 +40,12 @@ from rich.table import Table
|
||||
from rich.text import Text
|
||||
|
||||
from ..core.channels import decrypt_channel_text, identify_channel
|
||||
from ..core.models import NODE_TYPE_LABELS, Observation
|
||||
from ..core.models import NODE_TYPE_LABELS, Observation, utcnow
|
||||
from ..services.trace_runner import NodeResolver
|
||||
from .map_render import _SELF, _UNKNOWN
|
||||
|
||||
#: Composed packet cards the viewer memoizes (a few pages either side of the view).
|
||||
_BODY_CACHE_MAX = 8
|
||||
from .pathgraph import PathLayer, render_path_graph, revisited_hops
|
||||
from .pathline import PathLine, path_line
|
||||
from .theme import glyph, name_style, snr_style
|
||||
@@ -354,6 +358,8 @@ class PacketViewer(Screen):
|
||||
super().__init__()
|
||||
self._entries = list(entries)
|
||||
self._index = max(0, min(index, len(self._entries) - 1))
|
||||
# Composed cards per (entry, width, age-minute) — see render_body.
|
||||
self._body_cache: "OrderedDict[tuple, list[str]]" = OrderedDict()
|
||||
self._resolve = resolve
|
||||
self._prefix_bytes = prefix_bytes
|
||||
self._self_name = self_name
|
||||
@@ -464,6 +470,18 @@ class PacketViewer(Screen):
|
||||
# same packet, so the title's ``n/total`` and the reachable range stay current.
|
||||
self._sync()
|
||||
entry = self._entries[self._index]
|
||||
# An entry is immutable once captured, so its whole card — rows, decrypted
|
||||
# payload, route-graph layout — is a pure function of the entry, the width,
|
||||
# and the minute its "heard" age reads (the one row that rolls with time).
|
||||
# Memoize on exactly that: the repaint tick re-lays the graph only when a
|
||||
# minute boundary actually moves the visible text.
|
||||
age_minute = int(max(0.0, (utcnow() - entry.when).total_seconds()) // 60)
|
||||
key = (id(entry), width, age_minute)
|
||||
cached = self._body_cache.get(key)
|
||||
if cached is not None:
|
||||
self._body_cache.move_to_end(key)
|
||||
self._scroll_total = max(1, len(cached))
|
||||
return cached
|
||||
head, tail = self._head_rows(entry), self._tail_rows(entry)
|
||||
label_w = self._label_width(head + tail, width)
|
||||
|
||||
@@ -479,6 +497,9 @@ class PacketViewer(Screen):
|
||||
lines.append("")
|
||||
lines.extend(self._grid_lines(tail, width, label_w))
|
||||
self._scroll_total = max(1, len(lines))
|
||||
self._body_cache[key] = lines
|
||||
if len(self._body_cache) > _BODY_CACHE_MAX:
|
||||
self._body_cache.popitem(last=False)
|
||||
return lines
|
||||
|
||||
@staticmethod
|
||||
|
||||
@@ -210,6 +210,8 @@ class RecordDialog(Screen):
|
||||
self._actions = ("trace", "delete", "back")
|
||||
self._index = 0
|
||||
self._cursor: Optional[int] = None
|
||||
# The composed card above the action rows, per width (see render_body).
|
||||
self._upper_cache: Optional[tuple[int, list[str]]] = None
|
||||
# The card opens at the top, reading down; the arrows drive (and follow) the action
|
||||
# cursor, while PgUp/PgDn/Home/End scroll the body free of it (see cursor_line).
|
||||
self._follow = False
|
||||
@@ -430,6 +432,43 @@ class RecordDialog(Screen):
|
||||
|
||||
def render_body(self, width: int) -> list[str]:
|
||||
"""Stats lanes, the route graph, the full route, provenance, then the actions."""
|
||||
# Everything above the action rows — the stat lanes, the area drawing, the
|
||||
# route graph and the provenance — is a pure function of the frozen record
|
||||
# and the width, so it is composed once per width; only the cursor-bearing
|
||||
# action rows below re-render per repaint.
|
||||
cached = self._upper_cache
|
||||
if cached is not None and cached[0] == width:
|
||||
lines = list(cached[1])
|
||||
else:
|
||||
lines = self._upper_lines(width)
|
||||
self._upper_cache = (width, list(lines))
|
||||
|
||||
lines.append("")
|
||||
self._cursor = None
|
||||
for i, key in enumerate(self._actions):
|
||||
if key == "back":
|
||||
lines.append("")
|
||||
selected = i == self._index
|
||||
row = Text("❯ " if selected else " ", style="brand" if selected else "")
|
||||
if key == "trace":
|
||||
row.append("👣 ", style="accent")
|
||||
row.append("Trace this path — reopen in Trace path")
|
||||
elif key == "delete":
|
||||
row.append("🗑 ", style="err")
|
||||
row.append("Delete record…")
|
||||
else:
|
||||
row.append("Back")
|
||||
if selected:
|
||||
row.style = "brand"
|
||||
self._cursor = len(lines)
|
||||
row.no_wrap = True
|
||||
row.truncate(width, overflow="ellipsis")
|
||||
lines.append(render_to_ansi(row, width))
|
||||
self._scroll_total = max(1, len(lines))
|
||||
return lines
|
||||
|
||||
def _upper_lines(self, width: int) -> list[str]:
|
||||
"""Compose the record card above the action rows (memoized per width)."""
|
||||
record = self._record
|
||||
lines: list[str] = []
|
||||
|
||||
@@ -472,29 +511,6 @@ class RecordDialog(Screen):
|
||||
when = Text(stamp)
|
||||
when.append(f" · MeshTerm {record.app_version}", style="muted")
|
||||
lines.append(render_to_ansi(self._lane("recorded", when), width, no_wrap=True))
|
||||
|
||||
lines.append("")
|
||||
self._cursor = None
|
||||
for i, key in enumerate(self._actions):
|
||||
if key == "back":
|
||||
lines.append("")
|
||||
selected = i == self._index
|
||||
row = Text("❯ " if selected else " ", style="brand" if selected else "")
|
||||
if key == "trace":
|
||||
row.append("👣 ", style="accent")
|
||||
row.append("Trace this path — reopen in Trace path")
|
||||
elif key == "delete":
|
||||
row.append("🗑 ", style="err")
|
||||
row.append("Delete record…")
|
||||
else:
|
||||
row.append("Back")
|
||||
if selected:
|
||||
row.style = "brand"
|
||||
self._cursor = len(lines)
|
||||
row.no_wrap = True
|
||||
row.truncate(width, overflow="ellipsis")
|
||||
lines.append(render_to_ansi(row, width))
|
||||
self._scroll_total = max(1, len(lines))
|
||||
return lines
|
||||
|
||||
|
||||
@@ -561,8 +577,16 @@ async def open_records(ctx: "AppContext") -> dict:
|
||||
) else None
|
||||
node_entries.append((ident, pos, contact.node_type))
|
||||
|
||||
# Memoized: the boards ask for the same route nodes over and over (every hop of
|
||||
# every record, records sharing hops), and the entry list is fixed for this open —
|
||||
# so each distinct id pays the prefix scan once.
|
||||
geo_memo: dict[str, tuple[Optional[tuple[float, float]], Optional[int]]] = {}
|
||||
|
||||
def node_geo(node_id: str) -> tuple[Optional[tuple[float, float]], Optional[int]]:
|
||||
"""A route node's best-known position and type across the heard/contact entries."""
|
||||
cached = geo_memo.get(node_id)
|
||||
if cached is not None:
|
||||
return cached
|
||||
needle = node_id.lower().removeprefix("0x")
|
||||
pos: Optional[tuple[float, float]] = None
|
||||
ntype: Optional[int] = None
|
||||
@@ -575,6 +599,7 @@ async def open_records(ctx: "AppContext") -> dict:
|
||||
ntype = etype
|
||||
if pos is not None and ntype is not None:
|
||||
break
|
||||
geo_memo[node_id] = (pos, ntype)
|
||||
return pos, ntype
|
||||
|
||||
def walk_drawing(
|
||||
@@ -743,6 +768,26 @@ async def open_records(ctx: "AppContext") -> dict:
|
||||
):
|
||||
ctx.repo.delete_discoveries(category.id)
|
||||
|
||||
def record_row_title(
|
||||
rank: int, category: Category, record: DiscoveredPath,
|
||||
show_width: bool, score_w: int,
|
||||
):
|
||||
"""A width-aware row title, memoized per width — the record is frozen, so the
|
||||
path-widget assembly and middle-elide only ever run once per render width
|
||||
instead of once per record per repaint."""
|
||||
memo: dict[int, Text] = {}
|
||||
|
||||
def title(width: int) -> Text:
|
||||
cached = memo.get(width)
|
||||
if cached is None:
|
||||
cached = memo[width] = browser_row(
|
||||
rank, category, record,
|
||||
show_width=show_width, score_w=score_w, width=width,
|
||||
)
|
||||
return cached
|
||||
|
||||
return title
|
||||
|
||||
while True:
|
||||
items: list = []
|
||||
for category in CATEGORIES:
|
||||
@@ -759,12 +804,9 @@ async def open_records(ctx: "AppContext") -> dict:
|
||||
items.append(Choice(
|
||||
# Width-aware (see Choice.title): the row re-fits its walk to each
|
||||
# render width, middle-eliding rather than dying at the right edge.
|
||||
title=(
|
||||
lambda width, rank=rank, category=category, record=record,
|
||||
show_width=show_width, score_w=score_w: browser_row(
|
||||
rank, category, record,
|
||||
show_width=show_width, score_w=score_w, width=width,
|
||||
)
|
||||
title=record_row_title(
|
||||
rank, category, record,
|
||||
show_width=show_width, score_w=score_w,
|
||||
),
|
||||
value=("open", category, rank, record),
|
||||
))
|
||||
|
||||
@@ -829,10 +829,14 @@ def _mesh_sections(
|
||||
# every wider window keeps the calendar-day columns. Both feed the same bar and
|
||||
# tick machinery — only the bucket resolution and the axis labels differ.
|
||||
hourly = since is not None and window is not None and window <= timedelta(days=1)
|
||||
# The all-days series feeds the ledger at the bottom too — fetched once here (it is
|
||||
# one of the costlier scans), and only on demand in the hourly case.
|
||||
all_days: Optional[list[tuple[str, int, int]]] = None
|
||||
if hourly:
|
||||
series = _fill_hours(ctx.repo.hourly_series(since), since, now)
|
||||
else:
|
||||
series = _fill_days(ctx.repo.daily_activity(), since, now)
|
||||
all_days = ctx.repo.daily_activity()
|
||||
series = _fill_days(all_days, since, now)
|
||||
if not series:
|
||||
return [
|
||||
Text(),
|
||||
@@ -895,6 +899,9 @@ def _mesh_sections(
|
||||
)
|
||||
|
||||
arrivals = ctx.repo.first_seen(since=since)
|
||||
# One aggregation serves both the arrivals' key lane and the ledger's node count
|
||||
# below (every heard node *is* a first-seen node, so the counts agree).
|
||||
heard = ctx.repo.heard_nodes()
|
||||
out.append(Text())
|
||||
out.append(_heading("Arrivals", "nodes heard for the first time ever"))
|
||||
if not arrivals:
|
||||
@@ -909,7 +916,7 @@ def _mesh_sections(
|
||||
# and each key expands to its fullest known form the way the picker's lane
|
||||
# does: the key captured with an observation (shows offline), else the
|
||||
# device's contact list, else the stored 12-hex prefix.
|
||||
stored_keys = {n.node: n.public_key for n in ctx.repo.heard_nodes() if n.node}
|
||||
stored_keys = {n.node: n.public_key for n in heard if n.node}
|
||||
listed = [
|
||||
(
|
||||
stored_keys.get(node) or resolve_key(node) or node,
|
||||
@@ -949,8 +956,9 @@ def _mesh_sections(
|
||||
line.append(f" ({format_ago(secs)})", style=_recency_style(secs))
|
||||
out.append(line)
|
||||
|
||||
all_days = ctx.repo.daily_activity()
|
||||
total_nodes = len(ctx.repo.first_seen())
|
||||
if all_days is None:
|
||||
all_days = ctx.repo.daily_activity()
|
||||
total_nodes = sum(1 for n in heard if n.node)
|
||||
busiest = max(all_days, key=lambda d: d[1])
|
||||
out.append(Text())
|
||||
out.append(_heading("Ledger", "everything ever recorded"))
|
||||
|
||||
@@ -419,6 +419,14 @@ class TraceScreen(Screen):
|
||||
#: Traces aggregated on screen — the current route's run. Adopting a
|
||||
#: different path clears it (old numbers describe the old route).
|
||||
self._traces: list[TraceResult] = []
|
||||
#: Bumped on every mutation of ``_traces`` — the key the per-frame memos
|
||||
#: below expire on (a bare ``len`` would miss a clear-then-refill).
|
||||
self._traces_rev = 0
|
||||
# The aggregate stats and the windowed results block, each valid for one
|
||||
# traces revision (see render_body / _tail_lines): a repaint that changed
|
||||
# nothing re-reads them instead of re-aggregating every stored trace.
|
||||
self._stats_memo: Optional[tuple[int, TraceStats]] = None
|
||||
self._tail_memo: Optional[tuple[tuple, list[str]]] = None
|
||||
#: Every trace this screen ever ran, across path changes — the session
|
||||
#: count the owner reports, immune to the per-route clears above.
|
||||
self._total_traces = 0
|
||||
@@ -538,6 +546,7 @@ class TraceScreen(Screen):
|
||||
earlier label on the same board.
|
||||
"""
|
||||
self._traces.append(result)
|
||||
self._traces_rev += 1
|
||||
self._total_traces += 1
|
||||
for label in placed:
|
||||
self._run_placed[label.split(" — ")[0]] = label
|
||||
@@ -692,6 +701,7 @@ class TraceScreen(Screen):
|
||||
# session restarts as clean as a fresh screen.
|
||||
self._path_spec = spec.strip()
|
||||
self._traces.clear()
|
||||
self._traces_rev += 1
|
||||
self._status = ""
|
||||
finally:
|
||||
self._dialog_open = False
|
||||
@@ -725,6 +735,7 @@ class TraceScreen(Screen):
|
||||
return
|
||||
self._path_spec = reversed_spec
|
||||
self._traces.clear()
|
||||
self._traces_rev += 1
|
||||
self._status = ""
|
||||
self._session.invalidate()
|
||||
|
||||
@@ -737,7 +748,11 @@ class TraceScreen(Screen):
|
||||
highlighted row's body line is known exactly — that is what :meth:`cursor_line`
|
||||
pins while the user is navigating.
|
||||
"""
|
||||
stats = TraceStats.from_traces(self._target, self._traces)
|
||||
if self._stats_memo is not None and self._stats_memo[0] == self._traces_rev:
|
||||
stats = self._stats_memo[1]
|
||||
else:
|
||||
stats = TraceStats.from_traces(self._target, self._traces)
|
||||
self._stats_memo = (self._traces_rev, stats)
|
||||
current = next((t for t in reversed(self._traces) if t.success), None)
|
||||
# Both path lanes break at hop boundaries under their own value column (the
|
||||
# app-wide labelled-row rule): a long walk never folds back to column zero,
|
||||
@@ -781,7 +796,19 @@ class TraceScreen(Screen):
|
||||
def _tail_lines(
|
||||
self, stats: TraceStats, current: Optional[TraceResult], width: int
|
||||
) -> list[str]:
|
||||
"""The windowed results block: per-hop medians, then the trace log."""
|
||||
"""The windowed results block: per-hop medians, then the trace log.
|
||||
|
||||
Memoized per traces revision while idle — the block re-renders every stored
|
||||
trace, and between completions nothing in it moves. A *running* trace skips
|
||||
the memo outright: its log row carries the live spinner glyph.
|
||||
"""
|
||||
key = (self._traces_rev, self._status, width)
|
||||
if (
|
||||
not self._running
|
||||
and self._tail_memo is not None
|
||||
and self._tail_memo[0] == key
|
||||
):
|
||||
return self._tail_memo[1]
|
||||
tail: list[RenderableType] = []
|
||||
if stats.hop_snrs:
|
||||
hash_bytes = current.path_hash_bytes if current is not None else None
|
||||
@@ -790,9 +817,10 @@ class TraceScreen(Screen):
|
||||
if self._running or self._status or self._traces:
|
||||
tail += [Text(), Text("Traces", style="accent")]
|
||||
tail.append(self._trace_log())
|
||||
if not tail:
|
||||
return []
|
||||
return render_lines(Group(*tail), width)
|
||||
lines = render_lines(Group(*tail), width) if tail else []
|
||||
if not self._running:
|
||||
self._tail_memo = (key, lines)
|
||||
return lines
|
||||
|
||||
def cursor_line(self) -> Optional[int]:
|
||||
"""The highlighted action row while ↑/↓ are in use; free scrolling otherwise.
|
||||
@@ -1429,8 +1457,12 @@ async def _open_session(
|
||||
# destination — a direct attempt, honest about being one.
|
||||
device_route: Optional[tuple[str, ...]] = None
|
||||
if target_contact is not None and target_contact.route_hops is not None:
|
||||
topo0 = fresh_topology()
|
||||
device_route = tuple(topo0.canonical(h) or h for h in target_contact.route_hops)
|
||||
# Canonicalizing hop hashes needs only the contact index, so an *empty*
|
||||
# graph does it — not the full evidence build (stored traces, packet paths,
|
||||
# neighbour tables) fresh_topology() runs, which this branch would then
|
||||
# discard unread.
|
||||
ident = MeshTopology(device_hash or "local", contacts)
|
||||
device_route = tuple(ident.canonical(h) or h for h in target_contact.route_hops)
|
||||
auto_hops: Optional[tuple[str, ...]] = None
|
||||
auto_source = ""
|
||||
if target_hash is not None:
|
||||
|
||||
@@ -416,9 +416,14 @@ def _install_terminal_widths(narrow: frozenset[str], wide: frozenset[str]) -> No
|
||||
import prompt_toolkit.utils as ptu
|
||||
import rich.cells as cells
|
||||
|
||||
from .render import _ANSI_CACHE
|
||||
|
||||
cells.cached_cell_len.cache_clear()
|
||||
cells._cell_len = _make_cell_len(narrow, wide)
|
||||
ptu._CHAR_SIZES_CACHE = _make_pt_cache(narrow, wide)
|
||||
# The measurement just changed under every renderable, so anything rasterized before
|
||||
# calibration (nothing, in the normal boot order — but never trust that) is stale.
|
||||
_ANSI_CACHE.clear()
|
||||
|
||||
|
||||
__all__ = ["calibrate"]
|
||||
+80
-21
@@ -7,14 +7,15 @@ header and footer so the whole view fits the terminal exactly (never overflowing
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Sequence
|
||||
from collections import OrderedDict
|
||||
from typing import Optional, Sequence
|
||||
|
||||
from rich.cells import cell_len
|
||||
from rich.console import Group, RenderableType
|
||||
from rich.panel import Panel
|
||||
from rich.text import Text
|
||||
|
||||
from ...platforms import get_platform
|
||||
from ...platforms import Platform, get_platform, on_platform
|
||||
from ..theme import hint_style, title_style
|
||||
from .glow import apply_corner_glow
|
||||
from .render import render_lines
|
||||
@@ -131,39 +132,44 @@ def _breathing_room(body_len: int, budget: int) -> int:
|
||||
return 1 if body_len + 2 <= budget else 0
|
||||
|
||||
|
||||
def _panel(screen: Screen, inner_w: int, viewport: int, active: bool) -> Panel:
|
||||
"""Render a screen's body into a titled, scroll-aware panel.
|
||||
def _panel_box(
|
||||
title: str, visible: list[str], more_above: bool, more_below: bool, border: str
|
||||
) -> Panel:
|
||||
"""Wrap already-sliced body lines in a titled, scroll-aware panel.
|
||||
|
||||
Args:
|
||||
screen: The screen to frame.
|
||||
inner_w: Inner content width in columns.
|
||||
viewport: Visible body height in rows.
|
||||
active: Whether this is the focused (top) screen, brightening its border.
|
||||
title: The screen's heading (empty for none).
|
||||
visible: The viewport's ANSI lines, already sliced and padded to height.
|
||||
more_above: Whether content continues above the slice.
|
||||
more_below: Whether content continues below the slice.
|
||||
border: Border style name (``"accent"`` for the focused screen).
|
||||
|
||||
Returns:
|
||||
A Rich :class:`Panel` of exactly ``viewport + 2`` rows.
|
||||
A Rich :class:`Panel` of exactly ``len(visible) + 2`` rows.
|
||||
"""
|
||||
# Record the viewport *before* the body renders, so a screen that windows a
|
||||
# list inside itself (see :class:`~meshterm.ui.tui.screen.ListWindow`) can size
|
||||
# its chrome to the frame it is about to be sliced into.
|
||||
screen.note_viewport(viewport)
|
||||
body_lines = screen.render_body(inner_w)
|
||||
visible, more_above, more_below = _visible_slice(screen, body_lines, viewport)
|
||||
body = Text.from_ansi("\n".join(visible))
|
||||
border = "accent" if active else "muted"
|
||||
subtitle = None
|
||||
if more_above or more_below:
|
||||
arrow = ("↑" if more_above else " ") + ("↓" if more_below else " ")
|
||||
subtitle = f"[{hint_style(border)}]{arrow} more[/]"
|
||||
return Panel(
|
||||
body,
|
||||
title=f"[{title_style(border)}]{screen.title}[/]" if screen.title else None,
|
||||
title=f"[{title_style(border)}]{title}[/]" if title else None,
|
||||
subtitle=subtitle,
|
||||
border_style=border,
|
||||
padding=(0, 1),
|
||||
)
|
||||
|
||||
|
||||
#: The last framed base composition: ``(content key, rendered lines)``. Re-parsing the
|
||||
#: sliced body (``Text.from_ansi``) and re-rendering it through the Panel is the priciest
|
||||
#: part of a repaint (~8 ms on a full frame), and the idle tick recomposes an unchanged
|
||||
#: screen every second — only the header above it moves. One slot suffices: there is only
|
||||
#: ever one base screen per paint, and any content change (a keystroke, a scroll, new
|
||||
#: rows) simply misses and re-renders.
|
||||
_BASE_BOX_CACHE: Optional[tuple[tuple, list[str]]] = None
|
||||
|
||||
|
||||
def _title_bar(screen: Screen, cols: int, more_above: bool, more_below: bool) -> Text:
|
||||
"""The borderless frame's one-row title bar: a centered title on a bold rule, clip arrows.
|
||||
|
||||
@@ -231,6 +237,7 @@ def compose_base(
|
||||
Returns:
|
||||
An ANSI string of exactly ``rows`` lines, each within ``cols`` columns.
|
||||
"""
|
||||
global _BASE_BOX_CACHE
|
||||
platform = get_platform()
|
||||
# The header is a single status line: crop it to one row so a narrow terminal never
|
||||
# wraps it onto a second line (which would push the panel down and misreport its height).
|
||||
@@ -241,8 +248,26 @@ def compose_base(
|
||||
)
|
||||
if platform.frame_border:
|
||||
viewport = max(1, rows - header_h - 1 - 2) # minus footer(1) and panel border(2)
|
||||
panel: RenderableType = _panel(base, cols - 4, viewport, active=True)
|
||||
body = render_lines(Group(panel, footer), cols)
|
||||
# Record the viewport *before* the body renders, so a screen that windows a
|
||||
# list inside itself (see :class:`~meshterm.ui.tui.screen.ListWindow`) can size
|
||||
# its chrome to the frame it is about to be sliced into.
|
||||
base.note_viewport(viewport)
|
||||
body_lines = base.render_body(cols - 4)
|
||||
visible, more_above, more_below = _visible_slice(base, body_lines, viewport)
|
||||
# The panel wrap is a pure function of what's between its borders: memoize it so
|
||||
# the repaints that change nothing below the header (the 1 Hz tick) skip the
|
||||
# ANSI re-parse and Panel re-render. A dynamic footer (the F-key lane, which can
|
||||
# flip with the physical Shift key alone) has no place in the key, so it renders
|
||||
# uncached — that combination doesn't arise: the lane belongs to the borderless
|
||||
# platform below.
|
||||
key = (cols, rows, base.title, footer_hint, more_above, more_below, *visible)
|
||||
if footer_lane is None and _BASE_BOX_CACHE is not None and _BASE_BOX_CACHE[0] == key:
|
||||
body = _BASE_BOX_CACHE[1]
|
||||
else:
|
||||
panel = _panel_box(base.title, visible, more_above, more_below, "accent")
|
||||
body = render_lines(Group(panel, footer), cols)
|
||||
if footer_lane is None:
|
||||
_BASE_BOX_CACHE = (key, body)
|
||||
else:
|
||||
# Borderless chrome: a one-row title bar instead of the Panel's border and
|
||||
# padding — the body wins the full terminal width and one extra row.
|
||||
@@ -412,6 +437,16 @@ def _dialog_layout(screen: Screen, cols: int, rows: int) -> tuple[int, int, int,
|
||||
return max_w, vpad, viewport, body_lines
|
||||
|
||||
|
||||
#: Memoized dialog compositions, keyed by everything the box is a function of. Dialogs
|
||||
#: stack (a confirm over a picker over a menu), and each layer recomposes on every
|
||||
#: repaint of the frame beneath it, so a single slot would thrash — a handful covers the
|
||||
#: deepest realistic stack, LRU-evicted as dialogs change.
|
||||
_DIALOG_CACHE: "OrderedDict[tuple, str]" = OrderedDict()
|
||||
|
||||
#: Dialog compositions the memo keeps.
|
||||
_DIALOG_CACHE_MAX = 12
|
||||
|
||||
|
||||
def compose_dialog(screen: Screen, cols: int, rows: int) -> str:
|
||||
"""Compose a centered dialog panel for a floating screen, bounded to the terminal.
|
||||
|
||||
@@ -425,8 +460,16 @@ def compose_dialog(screen: Screen, cols: int, rows: int) -> str:
|
||||
"""
|
||||
max_w, vpad, viewport, body_lines = _dialog_layout(screen, cols, rows)
|
||||
visible, more_above, more_below = _visible_slice(screen, body_lines, viewport)
|
||||
body = Text.from_ansi("\n".join(visible))
|
||||
border = getattr(screen, "border_style", "accent")
|
||||
key = (
|
||||
max_w, vpad, screen.title, screen.footer_hint, border,
|
||||
more_above, more_below, *visible,
|
||||
)
|
||||
cached = _DIALOG_CACHE.get(key)
|
||||
if cached is not None:
|
||||
_DIALOG_CACHE.move_to_end(key)
|
||||
return cached
|
||||
body = Text.from_ansi("\n".join(visible))
|
||||
hint = hint_style(border)
|
||||
subtitle = f"[{hint}]{screen.footer_hint}[/]"
|
||||
if more_above or more_below:
|
||||
@@ -440,4 +483,20 @@ def compose_dialog(screen: Screen, cols: int, rows: int) -> str:
|
||||
padding=(vpad, 1),
|
||||
width=max_w,
|
||||
)
|
||||
return "\n".join(apply_corner_glow(render_lines(panel, max_w)))
|
||||
out = "\n".join(apply_corner_glow(render_lines(panel, max_w)))
|
||||
_DIALOG_CACHE[key] = out
|
||||
if len(_DIALOG_CACHE) > _DIALOG_CACHE_MAX:
|
||||
_DIALOG_CACHE.popitem(last=False)
|
||||
return out
|
||||
|
||||
|
||||
@on_platform
|
||||
def _bind(platform: Platform) -> None:
|
||||
"""Drop the composition memos on a platform switch — their output bakes the theme in.
|
||||
|
||||
Registered at module bottom so the immediate first run (see
|
||||
:func:`~meshterm.platforms.on_platform`) finds both caches already defined.
|
||||
"""
|
||||
global _BASE_BOX_CACHE
|
||||
_BASE_BOX_CACHE = None
|
||||
_DIALOG_CACHE.clear()
|
||||
+25
-2
@@ -29,6 +29,7 @@ box-drawing glyphs are recoloured).
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from collections import OrderedDict
|
||||
from itertools import accumulate
|
||||
|
||||
from rich.cells import cell_len
|
||||
@@ -291,6 +292,17 @@ class _Glower:
|
||||
self.targets.setdefault(row, []).append((idx, weight))
|
||||
|
||||
|
||||
#: Memoized glow output per input block. The pass is pure — the highlight is derived from
|
||||
#: the lines alone — and the compositors call it with byte-identical input on every idle
|
||||
#: repaint (the 1 Hz header tick recomposes an unchanged screen), so remembering a handful
|
||||
#: of recent blocks turns the ~3 ms scan-and-splice into a dict hit. A few entries cover
|
||||
#: the layers alive in one frame (the base panel and each stacked dialog).
|
||||
_GLOW_CACHE: "OrderedDict[tuple[str, ...], list[str]]" = OrderedDict()
|
||||
|
||||
#: Blocks the memo keeps: the base frame plus the deepest realistic dialog stack.
|
||||
_GLOW_CACHE_MAX = 12
|
||||
|
||||
|
||||
def apply_corner_glow(lines: list[str]) -> list[str]:
|
||||
"""Light every frame in ``lines`` from its top-left corner.
|
||||
|
||||
@@ -303,6 +315,17 @@ def apply_corner_glow(lines: list[str]) -> list[str]:
|
||||
lines: Composed ANSI lines (one per terminal row, no newlines).
|
||||
|
||||
Returns:
|
||||
The lines with the corner highlight applied.
|
||||
The lines with the corner highlight applied. The result is memoized per input
|
||||
block (see :data:`_GLOW_CACHE`) — callers treat it as read-only, which they all
|
||||
do (every compositor only joins or concatenates it onward).
|
||||
"""
|
||||
return _Glower(lines).apply()
|
||||
key = tuple(lines)
|
||||
cached = _GLOW_CACHE.get(key)
|
||||
if cached is not None:
|
||||
_GLOW_CACHE.move_to_end(key)
|
||||
return cached
|
||||
out = _Glower(lines).apply()
|
||||
_GLOW_CACHE[key] = out
|
||||
if len(_GLOW_CACHE) > _GLOW_CACHE_MAX:
|
||||
_GLOW_CACHE.popitem(last=False)
|
||||
return out
|
||||
@@ -11,7 +11,9 @@ automatically when the terminal is resized.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections import OrderedDict
|
||||
from io import StringIO
|
||||
from typing import Optional
|
||||
|
||||
from rich.cells import cell_len
|
||||
from rich.console import Console, RenderableType
|
||||
@@ -34,12 +36,62 @@ _CONSOLES: dict[int, Console] = {}
|
||||
_COLOR_SYSTEM = "truecolor"
|
||||
|
||||
|
||||
#: Memoized ANSI per (content, width) for the *describable* renderables — a ``str`` or a
|
||||
#: :class:`Text`, whose rendering is a pure function of their plain text, spans, and flags.
|
||||
#: The TUI recomposes the whole frame on every keystroke and on the idle tick, and the
|
||||
#: list-family screens rasterize row by row through :func:`render_to_ansi`; between two
|
||||
#: paints almost every row is byte-identical, so this cache turns the per-row console
|
||||
#: render (~0.15 ms each) into a dict hit. Tables, panels and groups have no cheap content
|
||||
#: key and skip the cache (their callers memoize at their own level where it matters).
|
||||
_ANSI_CACHE: "OrderedDict[tuple, str]" = OrderedDict()
|
||||
|
||||
#: Entries the ANSI cache holds before evicting least-recently-used ones. Sized for a few
|
||||
#: screenfuls of distinct rows (a busy list, its filtered variants, a dialog over it) at
|
||||
#: well under ~2 MB; small enough that even the PicoCalc carries it without noticing.
|
||||
_ANSI_CACHE_MAX = 4096
|
||||
|
||||
#: Generation stamp folded into every cache key. A platform switch swaps the theme and
|
||||
#: colour system baked into the render consoles, so it bumps the generation instead of
|
||||
#: trusting eviction — a stale entry can then never be *read*, even mid-eviction.
|
||||
_CACHE_GEN = 0
|
||||
|
||||
|
||||
@on_platform
|
||||
def _bind(platform: Platform) -> None:
|
||||
"""Re-bind the rasterizer's colour depth and drop stale consoles on a switch."""
|
||||
global _COLOR_SYSTEM
|
||||
global _COLOR_SYSTEM, _CACHE_GEN
|
||||
_COLOR_SYSTEM = "truecolor" if platform.truecolor else "standard"
|
||||
_CONSOLES.clear()
|
||||
_ANSI_CACHE.clear()
|
||||
_CACHE_GEN += 1
|
||||
|
||||
|
||||
def _cache_key(renderable: RenderableType, width: int, no_wrap: bool) -> Optional[tuple]:
|
||||
"""A content key for a cacheable renderable, or ``None`` when it has no cheap one.
|
||||
|
||||
A ``str`` *is* its own content (markup included). A :class:`Text` renders as a pure
|
||||
function of its plain text, span list, base style, and wrap flags — everything the
|
||||
key captures (span styles via ``str``, which :class:`~rich.style.Style` memoizes).
|
||||
Anything else — a table, a group, a panel — would need a deep walk to describe, so it
|
||||
reports ``None`` and renders uncached.
|
||||
"""
|
||||
if isinstance(renderable, str):
|
||||
return ("s", renderable, width, no_wrap, _CACHE_GEN)
|
||||
if isinstance(renderable, Text):
|
||||
return (
|
||||
"t",
|
||||
renderable.plain,
|
||||
tuple((s.start, s.end, str(s.style)) for s in renderable.spans),
|
||||
str(renderable.style),
|
||||
renderable.no_wrap,
|
||||
renderable.overflow,
|
||||
renderable.justify,
|
||||
renderable.tab_size,
|
||||
width,
|
||||
no_wrap,
|
||||
_CACHE_GEN,
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
def _console(width: int) -> Console:
|
||||
@@ -85,6 +137,12 @@ def render_to_ansi(renderable: RenderableType, width: int, *, no_wrap: bool = Fa
|
||||
The rendered output as an ANSI-escaped string, without a trailing newline.
|
||||
"""
|
||||
width = max(1, width)
|
||||
key = _cache_key(renderable, width, no_wrap)
|
||||
if key is not None:
|
||||
cached = _ANSI_CACHE.get(key)
|
||||
if cached is not None:
|
||||
_ANSI_CACHE.move_to_end(key)
|
||||
return cached
|
||||
console = _console(width)
|
||||
with console.capture() as capture:
|
||||
if no_wrap:
|
||||
@@ -95,7 +153,12 @@ def render_to_ansi(renderable: RenderableType, width: int, *, no_wrap: bool = Fa
|
||||
# one call is what makes the PicoCalc glyph contract hold app-wide (identity on the
|
||||
# regular platform). Widths were measured on the pre-fold text; the fold preserves
|
||||
# cell counts (wide emoji become glyph + pad), so the layout above survives it.
|
||||
return fold_text(capture.get())
|
||||
out = fold_text(capture.get())
|
||||
if key is not None:
|
||||
_ANSI_CACHE[key] = out
|
||||
if len(_ANSI_CACHE) > _ANSI_CACHE_MAX:
|
||||
_ANSI_CACHE.popitem(last=False)
|
||||
return out
|
||||
|
||||
|
||||
def render_lines(renderable: RenderableType, width: int, *, no_wrap: bool = False) -> list[str]:
|
||||
|
||||
+42
-10
@@ -245,6 +245,15 @@ class WalkScreen(Screen):
|
||||
#: The link list's window (the list scrolls, the screen doesn't); its
|
||||
#: settled capacity is the stride a PgUp/PgDn moves the highlight by.
|
||||
self._list = ListWindow()
|
||||
# Graph-derived memos. The topology is snapshotted once when the screen opens
|
||||
# (fresh evidence means reopening), so everything derived purely from it —
|
||||
# neighbour lists, the node set, BFS depths, onward-link counts — is computed
|
||||
# once per key instead of once per repaint. Nothing ever invalidates these:
|
||||
# they live exactly as long as the frozen graph they describe.
|
||||
self._links_of_memo: dict[str, list[tuple[str, Link]]] = {}
|
||||
self._all_nodes_memo: Optional[set[str]] = None
|
||||
self._hops_out_memo: Optional[dict[str, int]] = None
|
||||
self._onward_memo: dict[str, dict[str, int]] = {}
|
||||
|
||||
# --- state -------------------------------------------------------------------
|
||||
|
||||
@@ -259,7 +268,14 @@ class WalkScreen(Screen):
|
||||
return self._trail[-2] if len(self._trail) > 1 else None
|
||||
|
||||
def _links_of(self, node: str) -> list[tuple[str, Link]]:
|
||||
"""``(other, link)`` for every link off ``node``, strongest evidence first."""
|
||||
"""``(other, link)`` for every link off ``node``, strongest evidence first.
|
||||
|
||||
Memoized per node over the frozen graph (the sort order is pinned at first
|
||||
ask — strength decays over hours, far slower than a screen stays open).
|
||||
"""
|
||||
memoized = self._links_of_memo.get(node)
|
||||
if memoized is not None:
|
||||
return memoized
|
||||
now = utcnow()
|
||||
pairs = [
|
||||
(link.b if link.a == node else link.a, link)
|
||||
@@ -267,15 +283,18 @@ class WalkScreen(Screen):
|
||||
if node in (link.a, link.b)
|
||||
]
|
||||
pairs.sort(key=lambda pair: -pair[1].strength(now))
|
||||
self._links_of_memo[node] = pairs
|
||||
return pairs
|
||||
|
||||
def _all_nodes(self) -> set[str]:
|
||||
"""Every node the graph mentions, plus us (walkable even when alone)."""
|
||||
nodes = {self._topo.self_id}
|
||||
for link in self._topo.links():
|
||||
nodes.add(link.a)
|
||||
nodes.add(link.b)
|
||||
return nodes
|
||||
if self._all_nodes_memo is None:
|
||||
nodes = {self._topo.self_id}
|
||||
for link in self._topo.links():
|
||||
nodes.add(link.a)
|
||||
nodes.add(link.b)
|
||||
self._all_nodes_memo = nodes
|
||||
return self._all_nodes_memo
|
||||
|
||||
def _hops_out(self) -> dict[str, int]:
|
||||
"""BFS hop distance from our own node over the evidence links.
|
||||
@@ -283,6 +302,8 @@ class WalkScreen(Screen):
|
||||
Nodes with no path to us are absent — they are the islands, flagged as such
|
||||
wherever a distance would otherwise show.
|
||||
"""
|
||||
if self._hops_out_memo is not None:
|
||||
return self._hops_out_memo
|
||||
adjacency: dict[str, set[str]] = {}
|
||||
for link in self._topo.links():
|
||||
adjacency.setdefault(link.a, set()).add(link.b)
|
||||
@@ -295,6 +316,7 @@ class WalkScreen(Screen):
|
||||
if neighbour not in depths:
|
||||
depths[neighbour] = depths[node] + 1
|
||||
queue.append(neighbour)
|
||||
self._hops_out_memo = depths
|
||||
return depths
|
||||
|
||||
def _matches(self) -> list[str]:
|
||||
@@ -918,14 +940,24 @@ class WalkScreen(Screen):
|
||||
return name_w, key_w
|
||||
|
||||
def _onward_counts(self, pairs: list[tuple[str, Link]]) -> dict[str, int]:
|
||||
"""How many links continue from each neighbour, the one back here excluded."""
|
||||
"""How many links continue from each neighbour, the one back here excluded.
|
||||
|
||||
Memoized per focus (the counts depend only on the frozen graph and whose
|
||||
neighbours are being listed) — this was quadratic per repaint: every
|
||||
neighbour re-walked a fresh copy of the whole link table.
|
||||
"""
|
||||
focus = self._focus
|
||||
memoized = self._onward_memo.get(focus)
|
||||
if memoized is not None:
|
||||
return memoized
|
||||
counts: dict[str, int] = {}
|
||||
for other, _link in pairs:
|
||||
# A link off the neighbour "continues onward" unless its far end is here:
|
||||
# one endpoint is the neighbour itself, so only the far endpoint can be us.
|
||||
counts[other] = sum(
|
||||
1
|
||||
for link in self._topo.links()
|
||||
if other in (link.a, link.b) and self._focus not in (link.a, link.b)
|
||||
1 for far, _l in self._links_of(other) if far != focus
|
||||
)
|
||||
self._onward_memo[focus] = counts
|
||||
return counts
|
||||
|
||||
def _link_row(
|
||||
|
||||
@@ -217,6 +217,7 @@ def test_monitor_tallies_live_packets_by_payload_class(tmp_path: Path) -> None:
|
||||
|
||||
monitor = MonitorService.__new__(MonitorService)
|
||||
monitor._activity = {}
|
||||
monitor._activity_stamp = 0
|
||||
monitor._kind_counts = {}
|
||||
monitor._count_packet(
|
||||
MeshEvent.observation_event(
|
||||
|
||||
Reference in new issue
Block a user