feat(telemetry-separation): dedicated /telemetry tab split from /events by adapter data_class (v0.7.4)

PR #5 of the v0.7.x GUI rework arc. Production code; central-gui restart only
(supervisor untouched -- data_class is read only by central-gui per request).

- SourceAdapter gains a `data_class` class attr (Literal["event","telemetry"],
  default "event"). NWIS opts in as "telemetry" (continuous high-volume water
  gauges); every other adapter stays "event". The /events vs /telemetry split is
  thus registry-derived from class attrs -- no hardcoded adapter-name lists.
- routes.py refactor: `_class_adapter_names(data_class)` and a `data_class` arg
  on `_adapter_filter_options` scope the flat + domain-grouped chip/legend lists
  to a class (colors stay keyed to the FULL registry, so an adapter keeps one
  color across tabs). `_fetch_events` accepts `class_adapters` and adds an
  `adapter = ANY(...)` condition. Shared `_events_query`, `_events_page(data_class,
  base_path)` and `_events_rows_fragment(...)` back both tabs; `/events`,
  `/events/rows`, `/telemetry`, `/telemetry/rows` are thin wrappers.
- Templates parameterized with a `base_path` context var (form action, hx-get,
  hx-push-url header, clear-all redirect, JS BASE_PATH const); the `_events_rows`
  paginator macro takes `base`. Same templates serve both tabs; nav gains a
  Telemetry link.
- /events.json UNCHANGED -- the cursor path sets no `class_adapters`, so the
  subject + pagination contract is intact (TestEventsJsonSubject still passes).

Adds TestTelemetrySeparation (data_class defaults, registry split 11 event / 1
telemetry, class-scoped filter options, color stability, and the `adapter =
ANY(...)` SQL shape incl. the no-class events.json path). Updates the events
frontend tests for the base_path-parameterized templates.

Full suite: 682 passed, 1 skipped (central and unprivileged zvx, 3x each).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/test_events_feed_frontend.py

@@ -710,6 +710,7 @@ def _events_context(events):
     return {
         "events": events,
         "next_cursor": None,
+        "base_path": "/events",
         "query_string": "",
         "pagination": {
             "total": n, "offset": 0, "limit": 50, "page": 1, "total_pages": 1,
@@ -781,13 +782,17 @@ class TestRegistryDrivenAdapterFilter:
 
         context = mock_templates.TemplateResponse.call_args.kwargs.get("context")
 
-        # The list is exactly the registry, sorted by name (stable), no extras.
-        assert [a["name"] for a in context["adapters"]] == sorted(registry.keys())
+        # v0.7.4: /events shows event-class adapters only (telemetry-class, e.g.
+        # nwis, moved to /telemetry). Registry-derived, sorted, no extras.
+        event_names = sorted(n for n, c in registry.items()
+                             if getattr(c, "data_class", "event") == "event")
+        assert [a["name"] for a in context["adapters"]] == event_names
         # Each entry carries name + display_name (v0.7.1 adds a positional color).
         by_name = {a["name"]: a for a in context["adapters"]}
-        for cls in registry.values():
-            assert by_name[cls.name]["display_name"] == cls.display_name
-            assert by_name[cls.name]["color"].startswith("#")
+        for name in event_names:
+            cls = registry[name]
+            assert by_name[name]["display_name"] == cls.display_name
+            assert by_name[name]["color"].startswith("#")
 
 
 class TestPerAdapterRowPartials:

tests/test_telemetry_separation.py

@@ -0,0 +1,101 @@
+"""Tests for v0.7.4 telemetry/event separation: SourceAdapter.data_class,
+registry split, class-scoped filter options, and the data_class SQL filter.
+Registry-derived (no hardcoded adapter lists beyond the nwis pin). No live DB.
+"""
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from central.adapter import SourceAdapter
+from central.adapter_discovery import discover_adapters
+from central.gui import routes
+
+
+# --- data_class defaults / registry split -----------------------------------
+
+def test_base_default_is_event():
+    assert SourceAdapter.data_class == "event"
+
+
+def test_registry_split_11_event_1_telemetry():
+    reg = discover_adapters()
+    by_class = {}
+    for name, cls in reg.items():
+        by_class.setdefault(getattr(cls, "data_class", "event"), []).append(name)
+    assert by_class.get("telemetry") == ["nwis"]
+    # Everything else is event-class; the split must cover the whole registry.
+    assert sorted(by_class.get("event", [])) == sorted(n for n in reg if n != "nwis")
+    assert len(by_class.get("event", [])) == len(reg) - 1
+
+
+def test_class_adapter_names():
+    assert "nwis" not in routes._class_adapter_names("event")
+    assert routes._class_adapter_names("telemetry") == ["nwis"]
+    assert "usgs_quake" in routes._class_adapter_names("event")
+
+
+# --- class-scoped chip-picker / legend options -------------------------------
+
+def test_event_options_exclude_nwis():
+    flat, grouped = routes._adapter_filter_options("event")
+    names = {a["name"] for a in flat}
+    assert "nwis" not in names
+    assert len(flat) == len(discover_adapters()) - 1
+    grouped_values = {opt["value"] for _, items in grouped for opt in items}
+    assert "nwis" not in grouped_values
+
+
+def test_telemetry_options_only_nwis():
+    flat, grouped = routes._adapter_filter_options("telemetry")
+    assert [a["name"] for a in flat] == ["nwis"]
+    grouped_values = [opt["value"] for _, items in grouped for opt in items]
+    assert grouped_values == ["nwis"]
+
+
+def test_colors_stable_across_classes():
+    """A given adapter keeps the same color on /events and /telemetry (colors
+    are keyed to the full registry, not the per-tab subset)."""
+    full, _ = routes._adapter_filter_options()
+    full_color = {a["name"]: a["color"] for a in full}
+    ev, _ = routes._adapter_filter_options("event")
+    for a in ev:
+        assert a["color"] == full_color[a["name"]]
+
+
+# --- data_class SQL filter (captured SQL) ------------------------------------
+
+async def _capture(parsed):
+    captured = {}
+
+    async def fake_fetch(query, *args):
+        captured["query"] = query
+        captured["params"] = list(args)
+        return []
+
+    conn = MagicMock()
+    conn.fetch = fake_fetch
+    pool = MagicMock()
+    pool.acquire.return_value.__aenter__ = AsyncMock(return_value=conn)
+    pool.acquire.return_value.__aexit__ = AsyncMock(return_value=None)
+    with patch("central.gui.routes.get_pool", return_value=pool):
+        await routes._fetch_events(parsed)
+    return captured
+
+
+@pytest.mark.asyncio
+async def test_class_adapters_adds_adapter_any_condition():
+    parsed, _ = routes._parse_events_params({"time": "all"}, default_offset=0)
+    parsed["class_adapters"] = routes._class_adapter_names("event")
+    cap = await _capture(parsed)
+    assert "adapter = ANY($" in cap["query"]
+    assert routes._class_adapter_names("event") in cap["params"]
+
+
+@pytest.mark.asyncio
+async def test_no_class_adapters_no_class_condition():
+    """events.json path: no class_adapters -> no extra adapter filter (all classes)."""
+    parsed, _ = routes._parse_events_params({"time": "all"})  # cursor-mode, no class
+    assert parsed.get("class_adapters") is None
+    cap = await _capture(parsed)
+    # The only adapter=ANY would come from a user filter, which we didn't set.
+    assert "adapter = ANY($" not in cap["query"]