# Motion-Driven Axis Labeling Implementation Plan > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. **Goal:** Replace static ideology-CSV axis labeling with motion-projection-based labeling, add axis swap when Y ends up as "Links–Rechts", and expose top motions per axis to the user. **Architecture:** `political_axis.py` exposes `global_mean` in the `axes` dict; `axis_classifier.py` gains motion-loading helpers and a keyword classifier as the primary label source (falling back to existing Pearson-r); `explorer.py` swaps axes when needed and renders a new expander showing the top motions. **Tech Stack:** Python, NumPy, DuckDB (stdlib only — no new deps), Streamlit, pytest --- ## File Map | File | Change | |---|---| | `analysis/political_axis.py` | Add `axes["global_mean"] = global_mean` (one line) | | `analysis/axis_classifier.py` | Add `_KEYWORDS`, motion helpers, restructure `classify_axes` | | `explorer.py` | Add `_swap_axes`, `_should_swap_axes`, wire swap, add motion expander | | `tests/test_political_compass.py` | Add 5 new unit tests | --- ## Task 1: Expose `global_mean` from `compute_2d_axes` **Files:** - Modify: `analysis/political_axis.py` (line 362) - [ ] **Step 1: Write the failing test** Add this test at the bottom of `tests/test_political_compass.py`: ```python def test_compute_2d_axes_exposes_global_mean(monkeypatch): """axes dict returned by compute_2d_axes must contain 'global_mean'.""" fake_traj = types.SimpleNamespace() fake_traj._load_window_ids = lambda db: ["w1"] aligned = { "w1": { "Alice": np.array([1.0, 0.0, 0.0]), "Bob": np.array([-1.0, 0.5, 0.0]), } } fake_traj._load_mp_vectors_for_window = lambda db, w: aligned.get(w, {}) fake_traj._procrustes_align_windows = lambda x: aligned monkeypatch.setitem(sys.modules, "analysis.trajectory", fake_traj) from analysis.political_axis import compute_2d_axes _, axis_def = compute_2d_axes(db_path="dummy", window_ids=["w1"], method="pca") assert "global_mean" in axis_def assert isinstance(axis_def["global_mean"], np.ndarray) ``` - [ ] **Step 2: Run test to verify it fails** ```bash pytest tests/test_political_compass.py::test_compute_2d_axes_exposes_global_mean -v ``` Expected: FAIL — `AssertionError: assert 'global_mean' in {…}` (key not yet present) - [ ] **Step 3: Add `global_mean` to axes dict in `political_axis.py`** In `analysis/political_axis.py`, the line at ~362 reads: ```python global_mean = M.mean(axis=0) positions_by_window: Dict[str, Dict[str, Tuple[float, float]]] = { ``` Add `axes["global_mean"] = global_mean` immediately after that assignment: ```python global_mean = M.mean(axis=0) axes["global_mean"] = global_mean positions_by_window: Dict[str, Dict[str, Tuple[float, float]]] = { ``` - [ ] **Step 4: Run test to verify it passes** ```bash pytest tests/test_political_compass.py::test_compute_2d_axes_exposes_global_mean -v ``` Expected: PASS - [ ] **Step 5: Run full test suite to confirm no regressions** ```bash pytest tests/test_political_compass.py -v ``` Expected: all previously passing tests still pass + new test passes. - [ ] **Step 6: Commit** ```bash git add analysis/political_axis.py tests/test_political_compass.py git commit -m "feat: expose global_mean in compute_2d_axes axes dict" ``` --- ## Task 2: Add keyword classifier helper `_classify_from_titles` **Files:** - Modify: `analysis/axis_classifier.py` - Test: `tests/test_political_compass.py` - [ ] **Step 1: Write the three failing tests** Add to `tests/test_political_compass.py`: ```python def test_classify_from_titles_left_right(): """Titles dominated by left-right keywords → 'Links–Rechts'.""" from analysis.axis_classifier import _classify_from_titles titles = [ "Motie over asielbeleid", "Motie over minimumloon verhoging", "Motie over vluchtelingen opvang", "Motie over belastingverlaging", "Motie over bijstandsuitkering", ] label, confidence = _classify_from_titles(titles) assert label == "Links\u2013Rechts" assert confidence >= 0.4 def test_classify_from_titles_progressive(): """Titles dominated by progressive/conservative keywords → 'Progressief–Conservatief'.""" from analysis.axis_classifier import _classify_from_titles titles = [ "Motie over klimaatdoelstellingen", "Motie over stikstofbeleid", "Motie over duurzame energie", "Motie over co2 uitstoot", "Motie over energietransitie", ] label, confidence = _classify_from_titles(titles) assert label == "Progressief\u2013Conservatief" assert confidence >= 0.4 def test_classify_from_titles_low_confidence(): """Mixed/irrelevant titles → None (fallback triggered).""" from analysis.axis_classifier import _classify_from_titles titles = [ "Motie over sportsubsidie", "Motie over bibliotheekregeling", "Motie over verkeersveiligheid", ] label, confidence = _classify_from_titles(titles) assert label is None assert confidence < 0.4 ``` - [ ] **Step 2: Run tests to verify they fail** ```bash pytest tests/test_political_compass.py::test_classify_from_titles_left_right tests/test_political_compass.py::test_classify_from_titles_progressive tests/test_political_compass.py::test_classify_from_titles_low_confidence -v ``` Expected: FAIL — `ImportError: cannot import name '_classify_from_titles'` - [ ] **Step 3: Add `_KEYWORDS` constant and `_classify_from_titles` to `axis_classifier.py`** Add after the `_INTERPRETATION_TEMPLATES` block (after line 42) and before `_load_ideology`: ```python _KEYWORD_THRESHOLD = 0.4 _KEYWORDS: Dict[str, List[str]] = { "Links\u2013Rechts": [ # economic "belasting", "uitkering", "bijstand", "minimumloon", "cao", "vakbond", "bezuiniging", "privatisering", "subsidie", "pensioen", "aow", "zorg", # immigration "asiel", "asielaanvraag", "migratie", "vreemdeling", "vluchtelingen", "terugkeer", "grenzen", "opvang", "statushouder", ], "Progressief\u2013Conservatief": [ # environment "klimaat", "stikstof", "duurzaam", "duurzaamheid", "co2", "energietransitie", "biodiversiteit", # social "euthanasie", "abortus", "lgbtq", "transgender", "diversiteit", "traditi", "gezin", "religie", "geloof", ], "Nationaal\u2013Internationaal": [ "navo", "nato", "europees", "europese", " eu ", "verdrag", " vn ", "internationaal", ], } def _classify_from_titles(titles: List[str]) -> Tuple[Optional[str], float]: """Classify a list of motion titles into an axis category using keyword matching. Returns (category_label, confidence) where confidence = fraction of titles containing at least one keyword from the winning category. Returns (None, 0.0) if confidence is below _KEYWORD_THRESHOLD. """ if not titles: return None, 0.0 counts: Dict[str, int] = {cat: 0 for cat in _KEYWORDS} for title in titles: lower = title.lower() for cat, keywords in _KEYWORDS.items(): if any(kw in lower for kw in keywords): counts[cat] += 1 best_cat = max(counts, key=lambda c: counts[c]) best_count = counts[best_cat] confidence = best_count / len(titles) if confidence < _KEYWORD_THRESHOLD: return None, confidence return best_cat, confidence ``` - [ ] **Step 4: Run the three tests to verify they pass** ```bash pytest tests/test_political_compass.py::test_classify_from_titles_left_right tests/test_political_compass.py::test_classify_from_titles_progressive tests/test_political_compass.py::test_classify_from_titles_low_confidence -v ``` Expected: all 3 PASS - [ ] **Step 5: Run full suite to confirm no regressions** ```bash pytest tests/test_political_compass.py -v ``` - [ ] **Step 6: Commit** ```bash git add analysis/axis_classifier.py tests/test_political_compass.py git commit -m "feat: add _classify_from_titles keyword classifier to axis_classifier" ``` --- ## Task 3: Add motion-loading helpers to `axis_classifier.py` **Files:** - Modify: `analysis/axis_classifier.py` These helpers have DB dependencies so they don't get new unit tests here — they are exercised indirectly once `classify_axes` is wired up. Error handling is the main concern. - [ ] **Step 1: Add `import json` at top of `axis_classifier.py`** After `import numpy as np` (line 12), add: ```python import json ``` - [ ] **Step 2: Add the four motion helpers after `_classify_from_titles`** ```python def _load_motion_vectors(db_path: str, window_id: str) -> Dict[int, np.ndarray]: """Load SVD motion vectors for a given window from DuckDB. Returns {motion_id: vector_array}. Returns {} on any error. """ try: import duckdb conn = duckdb.connect(db_path, read_only=True) rows = conn.execute( "SELECT entity_id, vector FROM svd_vectors " "WHERE entity_type = 'motion' AND window_id = ?", [window_id], ).fetchall() conn.close() result = {} for entity_id, vector_raw in rows: try: mid = int(entity_id) vec = np.array(json.loads(vector_raw), dtype=float) result[mid] = vec except Exception: continue return result except Exception as exc: _logger.debug("Failed to load motion vectors for window %s: %s", window_id, exc) return {} def _project_motions( motion_vecs: Dict[int, np.ndarray], x_axis: np.ndarray, y_axis: np.ndarray, global_mean: np.ndarray, ) -> Dict[int, Tuple[float, float]]: """Project motion vectors onto the PCA axes after centering by global_mean. Returns {motion_id: (x_score, y_score)}. """ projections: Dict[int, Tuple[float, float]] = {} for mid, vec in motion_vecs.items(): try: centered = vec - global_mean x_score = float(np.dot(centered, x_axis)) y_score = float(np.dot(centered, y_axis)) projections[mid] = (x_score, y_score) except Exception: continue return projections def _top_motion_ids( projections: Dict[int, Tuple[float, float]], axis: str, n: int = 5, ) -> Dict[str, List[int]]: """Return the top-n motion IDs at each pole of the given axis. axis: 'x' or 'y' Returns {'+': [motion_ids], '-': [motion_ids]} (highest positive first, most negative first in the '-' list). """ idx = 0 if axis == "x" else 1 sorted_ids = sorted(projections, key=lambda mid: projections[mid][idx]) neg_ids = sorted_ids[:n] # most negative pos_ids = sorted_ids[-n:][::-1] # most positive return {"+": pos_ids, "-": neg_ids} def _fetch_motion_titles( db_path: str, motion_ids: List[int], ) -> Dict[int, Tuple[str, str]]: """Fetch (title, date) for a list of motion IDs from DuckDB. Returns {motion_id: (title, date_str)}. Missing IDs are omitted. Returns {} on any DB error. """ if not motion_ids: return {} try: import duckdb placeholders = ", ".join("?" * len(motion_ids)) conn = duckdb.connect(db_path, read_only=True) rows = conn.execute( f"SELECT id, title, date FROM motions WHERE id IN ({placeholders})", motion_ids, ).fetchall() conn.close() return {int(row[0]): (str(row[1]), str(row[2])) for row in rows} except Exception as exc: _logger.debug("Failed to fetch motion titles: %s", exc) return {} ``` - [ ] **Step 3: Run full test suite to confirm nothing broke** ```bash pytest tests/test_political_compass.py -v ``` Expected: all previously passing tests still pass. - [ ] **Step 4: Commit** ```bash git add analysis/axis_classifier.py git commit -m "feat: add motion-loading helpers to axis_classifier" ``` --- ## Task 4: Restructure `classify_axes` to use motion projection as primary **Files:** - Modify: `analysis/axis_classifier.py` - [ ] **Step 1: Replace the body of `classify_axes`** Replace the entire function (lines 180–269 in the current file) with the version below. Key changes from the old version: - Remove the `if not ideology: return axes` early return (motion path doesn't need ideology). - New early return only if BOTH motion path AND ideology path are unavailable. - Motion classification runs first per window; keyword result overrides Pearson-r if confident. - New accumulators: `x_top_motions`, `y_top_motions`, `x_label_confidence`, `y_label_confidence`. ```python def classify_axes( positions_by_window: Dict[str, Dict[str, Tuple[float, float]]], axes: dict, db_path: str, ) -> dict: """Classify compass axes using motion projection (primary) and ideology CSV (fallback). Motion projection path: - Requires axes["global_mean"], axes["x_axis"], axes["y_axis"]. - Loads motion SVD vectors per window, projects onto PCA axes, ranks top 5+5 motions, applies keyword classifier → label. Fallback path (unchanged): - Pearson-r against party_ideologies.csv (left_right, progressive). - Pearson-r against coalition_membership.csv dummy. Enriches axes with: x_label, y_label — global modal label across annual windows x_quality, y_quality — {window_id: float} max |r| x_interpretation — {window_id: str} y_interpretation — {window_id: str} x_top_motions, y_top_motions — {window_id: {'+': [(title, date), ...], '-': [...]}} x_label_confidence — {window_id: float} y_label_confidence — {window_id: float} """ data_dir = Path(db_path).parent ideology = _load_ideology(data_dir / "party_ideologies.csv") coalition = _load_coalition(data_dir / "coalition_membership.csv") # Determine whether motion projection is possible. global_mean = axes.get("global_mean") x_axis_arr = np.array(axes.get("x_axis", [])) y_axis_arr = np.array(axes.get("y_axis", [])) motion_path_available = ( global_mean is not None and x_axis_arr.ndim == 1 and x_axis_arr.size > 0 and y_axis_arr.size > 0 ) if not ideology and not motion_path_available: return axes # nothing to classify with x_quality: Dict[str, float] = {} y_quality: Dict[str, float] = {} x_interpretation: Dict[str, str] = {} y_interpretation: Dict[str, str] = {} x_top_motions: Dict[str, Dict] = {} y_top_motions: Dict[str, Dict] = {} x_label_confidence: Dict[str, float] = {} y_label_confidence: Dict[str, float] = {} annual_x_labels: List[str] = [] annual_y_labels: List[str] = [] for wid, pos_dict in positions_by_window.items(): year = _window_year(wid) is_annual = wid != "current_parliament" and "-" not in wid # ── Ideology / coalition Pearson-r (unchanged logic) ────────────────── x_lbl_fallback: Optional[str] = None y_lbl_fallback: Optional[str] = None x_q = 0.0 y_q = 0.0 x_int = "" y_int = "" if ideology: parties = [p for p in pos_dict if p in ideology] if len(parties) >= 5: party_x = [pos_dict[p][0] for p in parties] party_y = [pos_dict[p][1] for p in parties] ref_lr = [ideology[p]["left_right"] for p in parties] ref_pc = [ideology[p]["progressive"] for p in parties] if year and coalition and year in coalition: gov_set = coalition[year] ref_co = [1.0 if p in gov_set else -1.0 for p in parties] else: ref_co = [0.0] * len(parties) r_lr_x = _pearsonr(party_x, ref_lr) r_co_x = _pearsonr(party_x, ref_co) r_pc_x = _pearsonr(party_x, ref_pc) x_lbl_fallback, x_int, x_q = _assign_label(r_lr_x, r_co_x, r_pc_x, "x") r_lr_y = _pearsonr(party_y, ref_lr) r_co_y = _pearsonr(party_y, ref_co) r_pc_y = _pearsonr(party_y, ref_pc) y_lbl_fallback, y_int, y_q = _assign_label(r_lr_y, r_co_y, r_pc_y, "y") # ── Motion projection (primary) ──────────────────────────────────────── x_lbl = x_lbl_fallback y_lbl = y_lbl_fallback x_conf = 0.0 y_conf = 0.0 x_tops: Dict[str, List] = {"+": [], "-": []} y_tops: Dict[str, List] = {"+": [], "-": []} if motion_path_available: motion_vecs = _load_motion_vectors(db_path, wid) if motion_vecs: projections = _project_motions(motion_vecs, x_axis_arr, y_axis_arr, global_mean) x_ids = _top_motion_ids(projections, "x", n=5) y_ids = _top_motion_ids(projections, "y", n=5) all_x_ids = x_ids["+"] + x_ids["-"] all_y_ids = y_ids["+"] + y_ids["-"] titles_map = _fetch_motion_titles(db_path, list(set(all_x_ids + all_y_ids))) x_title_list = [ titles_map[mid][0] for mid in all_x_ids if mid in titles_map ] y_title_list = [ titles_map[mid][0] for mid in all_y_ids if mid in titles_map ] x_kw_lbl, x_conf = _classify_from_titles(x_title_list) y_kw_lbl, y_conf = _classify_from_titles(y_title_list) if x_kw_lbl is not None: x_lbl = x_kw_lbl if y_kw_lbl is not None: y_lbl = y_kw_lbl # Build display lists: [(title, date), ...] for pole, ids in x_ids.items(): x_tops[pole] = [ titles_map[mid] for mid in ids if mid in titles_map ] for pole, ids in y_ids.items(): y_tops[pole] = [ titles_map[mid] for mid in ids if mid in titles_map ] # ── Final label resolution ──────────────────────────────────────────── # If both motion and ideology paths produced nothing, use generic fallback. if x_lbl is None: x_lbl = _LABELS["fallback_x"] x_int = _INTERPRETATION_TEMPLATES["fallback"].format(orientation="horizontale") if y_lbl is None: y_lbl = _LABELS["fallback_y"] y_int = _INTERPRETATION_TEMPLATES["fallback"].format(orientation="verticale") x_quality[wid] = x_q y_quality[wid] = y_q x_interpretation[wid] = x_int y_interpretation[wid] = y_int x_top_motions[wid] = x_tops y_top_motions[wid] = y_tops x_label_confidence[wid] = x_conf y_label_confidence[wid] = y_conf if is_annual: annual_x_labels.append(x_lbl) annual_y_labels.append(y_lbl) def _modal(labels: List[str], fallback: str) -> str: if not labels: return fallback return Counter(labels).most_common(1)[0][0] enriched = dict(axes) enriched["x_label"] = _modal(annual_x_labels, "Links\u2013Rechts") enriched["y_label"] = _modal(annual_y_labels, "Progressief\u2013Conservatief") enriched["x_quality"] = x_quality enriched["y_quality"] = y_quality enriched["x_interpretation"] = x_interpretation enriched["y_interpretation"] = y_interpretation enriched["x_top_motions"] = x_top_motions enriched["y_top_motions"] = y_top_motions enriched["x_label_confidence"] = x_label_confidence enriched["y_label_confidence"] = y_label_confidence return enriched ``` - [ ] **Step 2: Run full test suite** ```bash pytest tests/test_political_compass.py -v ``` Expected: all existing tests + all 4 tasks' new tests pass. Particularly verify the 3 classifier tests from Task 2 and the `test_compute_2d_axes_exposes_global_mean` from Task 1 still pass. - [ ] **Step 3: Commit** ```bash git add analysis/axis_classifier.py git commit -m "feat: restructure classify_axes — motion projection as primary label source" ``` --- ## Task 5: Add axis-swap logic and tests in `explorer.py` **Files:** - Modify: `explorer.py` - Test: `tests/test_political_compass.py` - [ ] **Step 1: Write the two failing tests** Add to `tests/test_political_compass.py`: ```python def test_axis_swap_when_y_is_left_right(): """When y_label is 'Links–Rechts' and x_label is not, positions must be swapped.""" from explorer import _swap_axes positions_by_window = { "2023": { "VVD": (0.5, 0.8), "PvdA": (-0.3, -0.6), } } axis_def = { "x_label": "Progressief\u2013Conservatief", "y_label": "Links\u2013Rechts", "x_quality": {"2023": 0.7}, "y_quality": {"2023": 0.8}, "x_interpretation": {"2023": "prog interpretation"}, "y_interpretation": {"2023": "lr interpretation"}, "x_top_motions": {"2023": {"+": [], "-": []}}, "y_top_motions": {"2023": {"+": [], "-": []}}, "x_label_confidence": {"2023": 0.5}, "y_label_confidence": {"2023": 0.7}, } new_pos, new_ax = _swap_axes(positions_by_window, axis_def) # Positions swapped: (x, y) → (y, x) assert new_pos["2023"]["VVD"] == (0.8, 0.5) assert new_pos["2023"]["PvdA"] == (-0.6, -0.3) # Labels swapped assert new_ax["x_label"] == "Links\u2013Rechts" assert new_ax["y_label"] == "Progressief\u2013Conservatief" # Quality swapped assert new_ax["x_quality"] == {"2023": 0.8} assert new_ax["y_quality"] == {"2023": 0.7} def test_axis_swap_not_applied_when_x_is_left_right(): """When x_label is already 'Links–Rechts', no swap should occur.""" from explorer import _should_swap_axes axis_def = { "x_label": "Links\u2013Rechts", "y_label": "Progressief\u2013Conservatief", } assert _should_swap_axes(axis_def) is False axis_def2 = { "x_label": "Links\u2013Rechts", "y_label": "Links\u2013Rechts", # both LR — no swap } assert _should_swap_axes(axis_def2) is False ``` - [ ] **Step 2: Run tests to verify they fail** ```bash pytest tests/test_political_compass.py::test_axis_swap_when_y_is_left_right tests/test_political_compass.py::test_axis_swap_not_applied_when_x_is_left_right -v ``` Expected: FAIL — `ImportError: cannot import name '_swap_axes'` / `'_should_swap_axes'` - [ ] **Step 3: Add `_swap_axes` and `_should_swap_axes` to `explorer.py`** Add these two functions near the top of `explorer.py`, just before `load_positions` (i.e. before the function that starts around line 184). A good place is after any existing module-level helpers. ```python def _should_swap_axes(axis_def: dict) -> bool: """Return True if the Y axis is 'Links–Rechts' and the X axis is not. When true, caller should swap x/y positions and metadata so left-right is conventionally on the horizontal axis. """ lr = "Links\u2013Rechts" return axis_def.get("y_label") == lr and axis_def.get("x_label") != lr def _swap_axes( positions_by_window: dict, axis_def: dict, ) -> tuple: """Swap x and y in all positions and axis metadata. Pure function — returns (new_positions_by_window, new_axis_def). """ new_positions: dict = {} for wid, pos_dict in positions_by_window.items(): new_positions[wid] = {ent: (y, x) for ent, (x, y) in pos_dict.items()} new_ax = dict(axis_def) # Swap paired scalar keys new_ax["x_label"] = axis_def.get("y_label") new_ax["y_label"] = axis_def.get("x_label") # Swap paired dict keys for x_key, y_key in [ ("x_quality", "y_quality"), ("x_interpretation", "y_interpretation"), ("x_top_motions", "y_top_motions"), ("x_label_confidence", "y_label_confidence"), ]: new_ax[x_key] = axis_def.get(y_key) new_ax[y_key] = axis_def.get(x_key) return new_positions, new_ax ``` - [ ] **Step 4: Wire the swap in `load_positions`** In `explorer.py`, after the `classify_axes` try/except block (currently lines 202–211, ending at `axis_def = classify_axes(...)`), add: ```python if _should_swap_axes(axis_def): positions_by_window, axis_def = _swap_axes(positions_by_window, axis_def) ``` Place this immediately before the `# Filter displayed windows by window_size` comment (currently ~line 213). - [ ] **Step 5: Run tests to verify they pass** ```bash pytest tests/test_political_compass.py::test_axis_swap_when_y_is_left_right tests/test_political_compass.py::test_axis_swap_not_applied_when_x_is_left_right -v ``` Expected: both PASS - [ ] **Step 6: Run full suite** ```bash pytest tests/test_political_compass.py -v ``` Expected: all tests pass. - [ ] **Step 7: Commit** ```bash git add explorer.py tests/test_political_compass.py git commit -m "feat: add axis swap — left-right goes on horizontal axis when detected" ``` --- ## Task 6: Add motion expander UI in `build_compass_tab` **Files:** - Modify: `explorer.py` No new unit tests for this task — it's pure Streamlit rendering and cannot be unit-tested without a browser. Verify visually after implementation. - [ ] **Step 1: Add the expander block after `st.plotly_chart`** In `explorer.py`, find the `st.plotly_chart` call (line ~974) inside `with col1:`. After the two `st.caption` calls (lines ~981–986), add: ```python # Motion expander — show which motions define each axis for this window x_top = axis_def.get("x_top_motions", {}).get(window_idx, {}) y_top = axis_def.get("y_top_motions", {}).get(window_idx, {}) x_conf = axis_def.get("x_label_confidence", {}).get(window_idx) y_conf = axis_def.get("y_label_confidence", {}).get(window_idx) evr = axis_def.get("explained_variance_ratio", [None, None]) evr0 = evr[0] if evr else None _has_motion_data = bool( x_top.get("+") or x_top.get("-") or y_top.get("+") or y_top.get("-") ) if _has_motion_data: with st.expander("\U0001f50d Wat bepaalt deze assen?"): x_conf_pct = f" (vertrouwen: {x_conf:.0%})" if x_conf is not None else "" y_conf_pct = f" (vertrouwen: {y_conf:.0%})" if y_conf is not None else "" st.markdown(f"**Horizontale as: {_x_label}**{x_conf_pct}") x_pos_titles = x_top.get("+", []) x_neg_titles = x_top.get("-", []) if x_pos_titles: labels_pos = " · ".join( f"{t} ({d})" for t, d in x_pos_titles[:3] ) st.markdown(f"  ➕ {labels_pos}") if x_neg_titles: labels_neg = " · ".join( f"{t} ({d})" for t, d in x_neg_titles[:3] ) st.markdown(f"  ➖ {labels_neg}") st.markdown(f"**Verticale as: {_y_label}**{y_conf_pct}") y_pos_titles = y_top.get("+", []) y_neg_titles = y_top.get("-", []) if y_pos_titles: labels_pos = " · ".join( f"{t} ({d})" for t, d in y_pos_titles[:3] ) st.markdown(f"  ➕ {labels_pos}") if y_neg_titles: labels_neg = " · ".join( f"{t} ({d})" for t, d in y_neg_titles[:3] ) st.markdown(f"  ➖ {labels_neg}") if evr0 is not None: st.caption( f"As 1 verklaart {evr0:.1%} van de variantie in stemgedrag." ) ``` Note: `_x_label` and `_y_label` are already defined earlier in `build_compass_tab` from `axis_def.get("x_label", …)`. `window_idx` is the currently selected window string. Confirm those variable names match the existing code before inserting. - [ ] **Step 2: Check that `explained_variance_ratio` is stored in `axis_def`** Search `analysis/political_axis.py` for where `axes["explained_variance_ratio"]` is set. If it isn't stored, add it: In `compute_2d_axes`, after `axes["global_mean"] = global_mean` (Task 1), find where `evr` is computed (it's the `explained_variance_ratio_` from sklearn PCA or numpy SVD). Add: ```python axes["explained_variance_ratio"] = list(axes.get("explained_variance_ratio", [evr1, evr2])) ``` If it's already stored under a different key, use that key in the expander code instead. - [ ] **Step 3: Run full test suite (sanity check)** ```bash pytest tests/test_political_compass.py -v ``` Expected: all tests pass (expander is UI-only, no test required). - [ ] **Step 4: Commit** ```bash git add explorer.py git commit -m "feat: add motion expander to compass tab — shows top motions per axis" ``` --- ## Final Verification - [ ] **Run all tests one last time** ```bash pytest tests/test_political_compass.py -v ``` Expected output summary: 13+ tests passing (8 existing + 5 new), 0 failing. - [ ] **Smoke-test the app** (if DB is available) ```bash streamlit run explorer.py ``` Navigate to the compass tab, select a window, verify: 1. Axis labels show e.g. "Links–Rechts" on X and "Progressief–Conservatief" on Y 2. The "🔍 Wat bepaalt deze assen?" expander appears and shows motions 3. No Python exceptions in the terminal - [ ] **Final commit (if any cleanup needed)** ```bash git add -u git commit -m "fix: address any issues found during smoke test" ```