perf: memoise table rows so a repaint costs only what changed

[hellices]

Fixes #208

Problem

Every watch event triggered a full-table repaint whose cost was proportional to
the total row count, not to the number of objects that changed — and it ran
synchronously on the asyncio event loop, so keypresses queued behind it.

Measured before this change (pods view, all-namespaces, M-series Mac, 3.12):

rows	one "1 pod changed" repaint
1,000	11.4 ms
10,000	170 ms
50,000	1,102 ms

At 10,000 objects, 10 events/second was already enough to push cursor movement
past 2.5 seconds.

cProfile at 50,000 pods showed where it went:

• rich.Text.__init__ — 400,000 allocations per repaint (~8 per row), ~52% of
  render time, each running strip_control_codes/str.translate
• format_age — a datetime.now(UTC) and an RFC 3339 reparse per row, per
  repaint
• _apply_in_place — one DataTable.get_row() per row, each re-deriving
  ordered_columns (50,002 calls), then a 14-cell value comparison — ~300 ms
  even when nothing had changed

Approach

Watch summaries are frozen dataclasses replaced wholesale by apply_event, so
a row whose summary object is unchanged provably renders identical cells. That
makes object identity a sound cache key.

1. ResourceTable._row_memo keyed by summary identity plus a stamp
   covering the inputs not carried by the summary — the age string, and the
   live metrics sample on the pods view. A hit re-emits the memoised row
   untouched. Invalidated when the cell-set shape changes (kind,
   all-namespaces, custom view); not on sort, which reorders rows and
   decorates headers without changing any cell. Pruned amortised so churning
   pod names cannot grow it without bound.
2. The in-place diff compares against _emitted — the cells this widget
   last put into the table — instead of DataTable.get_row(). A memo hit is
   the same list object, so it is settled by one identity check and never
   touches ordered_columns, get_row, or _cells_equal. get_row remains
   the fallback whenever _emitted has no record of a row, so the diff stays
   correct even if the bookkeeping ever drifted.
3. One datetime.now(UTC) per repaint, threaded into every age() call.
   Also fixes a latent inconsistency: rows in a single repaint could previously
   straddle a second boundary and report different ages for the same instant.

Results

Same fixtures, after:

rows	repaint before	repaint after	cell build before	after
1,000	11.40 ms	1.04 ms	6.34 ms	0.63 ms
10,000	170.05 ms	11.46 ms	139.17 ms	7.05 ms
50,000	1,102.36 ms	80.12 ms	780.61 ms	42.82 ms

Keypress latency under churn (30 samples, cursor-down, 10 events/s):

rows	before	after
10,000	2,551 ms	100 ms
50,000	3,364 ms	2,178 ms

Cold first build is unchanged by design (there is no memo to hit) and is now
the dominant cost at 50,000 rows — a separate bootstrap problem, not folded in
here.

Tests

tests/ui/test_table_row_memo.py, all behavioural, no wall-clock assertions:

• test_repaint_rebuilds_only_the_changed_row — one MODIFIED pod rebuilds
  exactly one row
• test_unchanged_repaint_rebuilds_nothing — an identical repaint rebuilds none
• test_unchanged_rows_are_not_read_back_from_the_datatable — the diff makes
  zero get_row lookups (Textual's own paint-time RowKey lookups filtered out)
• test_changed_metrics_rebuild_the_row_without_a_new_summary — guards against
  over-caching: a new metrics sample re-renders the row even though the summary
  object is identical
• test_view_signature_change_discards_the_memo — switching to the
  all-namespaces column set rebuilds every row
• test_age_uses_one_clock_reading_per_repaint — a single now feeds every row

The first three and the last failed RED against main; the two guard tests pass
either way by design (they exist to catch over-caching).

Verification

• make check — ruff, mypy --strict, 4072 passed / 21 skipped, tach all green

[Copilot]

Pull request overview

Optimizes resource-table repaints by reusing unchanged rows and avoiding costly DataTable reads.

Changes:

• Memoizes rendered rows using summary identity and volatile inputs.
• Tracks emitted cells for efficient in-place updates.
• Adds behavioral regression tests for memoization, metrics, and clock consistency.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 1 comment.

File	Description
src/korvid/ui/widgets/resource_table.py	Implements row memoization and optimized diffing.
tests/ui/test_table_row_memo.py	Tests row reuse and invalidation behavior.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

Suppressed comments (1)

tests/ui/test_table_row_memo.py:157

• The clock test deliberately uses fresh summary objects, so it bypasses the memo and would still pass if AGE were removed from the stamp. That regression would freeze AGE cells indefinitely for unchanged resources. Please also keep the same summary identity across two renders, advance the clock across an age boundary, and assert that the AGE cell is updated.

            # Fresh summary objects: identity differs, so every row rebuilds.
            fresh: list[Summary] = [_pod("alpha"), _pod("beta"), _pod("gamma")]
            table.show("pods", fresh, all_namespaces=False, pattern="")