|
|
import numpy as np
|
|
|
import types
|
|
|
import sys
|
|
|
import types as _types
|
|
|
|
|
|
# Provide a minimal duckdb stub when the real package is not available in the test env
|
|
|
try:
|
|
|
import duckdb as _duckdb
|
|
|
except Exception:
|
|
|
import pandas as _pd
|
|
|
|
|
|
class FakeDuckDBConnection:
|
|
|
def __init__(self):
|
|
|
# storage for mp_votes rows: list of tuples matching _make_mp_votes_db
|
|
|
self._mp_votes = []
|
|
|
|
|
|
def execute(self, sql, params=None):
|
|
|
s = sql.strip().lower()
|
|
|
# simple create/select handling: return empty results for schema queries
|
|
|
if s.startswith("create table") or s.startswith(
|
|
|
"select distinct window_id"
|
|
|
):
|
|
|
return _types.SimpleNamespace(fetchall=lambda: [])
|
|
|
|
|
|
# compute_party_discipline query detection
|
|
|
if (
|
|
|
"from rice_per_motion" in s
|
|
|
or "select\n party,\n count(distinct motion_id) as n_motions"
|
|
|
in sql
|
|
|
):
|
|
|
# params: [start_date, end_date]
|
|
|
start_date, end_date = params or [None, None]
|
|
|
# filter rows by mp_name like '%,%' and date range and vote in ('voor','tegen')
|
|
|
rows = [r for r in self._mp_votes if ("," in (r[2] or ""))]
|
|
|
if start_date:
|
|
|
rows = [r for r in rows if r[5] >= start_date and r[5] <= end_date]
|
|
|
rows = [r for r in rows if (r[4] in ("voor", "tegen"))]
|
|
|
|
|
|
# build counts per motion_id, party, vote
|
|
|
from collections import defaultdict
|
|
|
|
|
|
counts = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))
|
|
|
motions = set()
|
|
|
for _id, motion_id, mp_name, party, vote, date, created_at in rows:
|
|
|
counts[motion_id][party][vote] += 1
|
|
|
motions.add((motion_id, party))
|
|
|
|
|
|
# compute rice per (motion, party)
|
|
|
rice_vals = defaultdict(list) # party -> list of rice per motion
|
|
|
motion_part_set = set()
|
|
|
for motion_id, party_counts in counts.items():
|
|
|
for party, vc in party_counts.items():
|
|
|
total = sum(vc.values())
|
|
|
if total == 0:
|
|
|
continue
|
|
|
# majority vote: vote with max count, tie-breaker by vote asc
|
|
|
maj_vote = sorted(vc.items(), key=lambda kv: (-kv[1], kv[0]))[
|
|
|
0
|
|
|
][0]
|
|
|
same = vc.get(maj_vote, 0)
|
|
|
rice = same / float(total)
|
|
|
rice_vals[party].append((motion_id, rice))
|
|
|
motion_part_set.add((motion_id, party))
|
|
|
|
|
|
# aggregate per party
|
|
|
import pandas as pd
|
|
|
|
|
|
rows_out = []
|
|
|
for party, lst in rice_vals.items():
|
|
|
n_motions = len({m for m, _ in lst})
|
|
|
avg_rice = sum(r for _, r in lst) / n_motions if n_motions else 0.0
|
|
|
rows_out.append(
|
|
|
{"party": party, "n_motions": n_motions, "discipline": avg_rice}
|
|
|
)
|
|
|
|
|
|
df = pd.DataFrame(rows_out)
|
|
|
return _types.SimpleNamespace(fetchdf=lambda: df)
|
|
|
|
|
|
# default fallback
|
|
|
return _types.SimpleNamespace(fetchall=lambda: [])
|
|
|
|
|
|
def executemany(self, sql, rows):
|
|
|
s = sql.strip().lower()
|
|
|
if s.startswith("insert into mp_votes"):
|
|
|
for r in rows:
|
|
|
self._mp_votes.append(r)
|
|
|
|
|
|
def close(self):
|
|
|
return None
|
|
|
|
|
|
_fake_duckdb = _types.ModuleType("duckdb")
|
|
|
_fake_duckdb.connect = lambda *a, **kw: FakeDuckDBConnection()
|
|
|
sys.modules["duckdb"] = _fake_duckdb
|
|
|
_duckdb = _fake_duckdb
|
|
|
|
|
|
# Provide a minimal plotly.express stub so explorer imports in tests without requiring plotly
|
|
|
try:
|
|
|
import plotly.express as px # type: ignore
|
|
|
except Exception:
|
|
|
_px = types.ModuleType("plotly.express")
|
|
|
_px.scatter = lambda *a, **kw: None
|
|
|
_px.line = lambda *a, **kw: None
|
|
|
# Ensure top-level 'plotly' package exists and exposes express
|
|
|
_plotly_pkg = types.ModuleType("plotly")
|
|
|
_plotly_pkg.express = _px
|
|
|
sys.modules["plotly"] = _plotly_pkg
|
|
|
sys.modules["plotly.express"] = _px
|
|
|
px = _px
|
|
|
# stub plotly.graph_objects too
|
|
|
_go = types.ModuleType("plotly.graph_objects")
|
|
|
_go.Figure = lambda *a, **kw: None
|
|
|
sys.modules["plotly.graph_objects"] = _go
|
|
|
|
|
|
# Provide a minimal streamlit stub so explorer imports succeed in the test env
|
|
|
try:
|
|
|
import streamlit as _st # noqa: F401
|
|
|
except Exception:
|
|
|
_st_stub = types.ModuleType("streamlit")
|
|
|
_st_stub.cache_data = lambda **kw: lambda f: f
|
|
|
_st_stub.plotly_chart = lambda *a, **kw: None
|
|
|
_st_stub.markdown = lambda *a, **kw: None
|
|
|
_st_stub.caption = lambda *a, **kw: None
|
|
|
_st_stub.error = lambda *a, **kw: None
|
|
|
_st_stub.warning = lambda *a, **kw: None
|
|
|
_st_stub.info = lambda *a, **kw: None
|
|
|
_st_stub.write = lambda *a, **kw: None
|
|
|
sys.modules["streamlit"] = _st_stub
|
|
|
|
|
|
import pytest
|
|
|
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
|
# Helpers shared by orientation tests
|
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
def _make_fake_traj(aligned):
|
|
|
fake = types.SimpleNamespace()
|
|
|
fake._load_window_ids = lambda db: list(aligned.keys())
|
|
|
fake._load_mp_vectors_for_window = lambda db, w: aligned.get(w, {})
|
|
|
fake._procrustes_align_windows = lambda x: aligned
|
|
|
return fake
|
|
|
|
|
|
|
|
|
def test_compute_2d_axes_pca_synthetic(monkeypatch):
|
|
|
"""Synthetic test for compute_2d_axes using patched alignment helper."""
|
|
|
|
|
|
# Create a fake trajectory module with required helpers
|
|
|
fake_traj = types.SimpleNamespace()
|
|
|
|
|
|
# _load_window_ids should return ordered windows
|
|
|
fake_traj._load_window_ids = lambda db: ["w1", "w2"]
|
|
|
|
|
|
# Provide aligned vectors directly
|
|
|
aligned = {
|
|
|
"w1": {"Alice": np.array([1.0, 0.0, 0.0]), "Bob": np.array([0.0, 1.0, 0.0])},
|
|
|
"w2": {"Alice": np.array([0.8, 0.2, 0.0]), "Bob": np.array([0.1, 0.9, 0.0])},
|
|
|
}
|
|
|
|
|
|
# _load_mp_vectors_for_window returns the pre-aligned vectors (needed for padding step)
|
|
|
fake_traj._load_mp_vectors_for_window = lambda db, w: aligned.get(w, {})
|
|
|
|
|
|
fake_traj._procrustes_align_windows = lambda x: aligned
|
|
|
|
|
|
# Insert fake module into sys.modules for import by analysis.political_axis
|
|
|
monkeypatch.setitem(sys.modules, "analysis.trajectory", fake_traj)
|
|
|
|
|
|
# Now import the function under test
|
|
|
from analysis.political_axis import compute_2d_axes
|
|
|
|
|
|
positions_by_window, axis_def = compute_2d_axes(
|
|
|
db_path="dummy", window_ids=["w1", "w2"], method="pca"
|
|
|
)
|
|
|
|
|
|
assert "w1" in positions_by_window and "w2" in positions_by_window
|
|
|
for wid in ("w1", "w2"):
|
|
|
for name, coord in positions_by_window[wid].items():
|
|
|
assert len(coord) == 2
|
|
|
assert np.isfinite(coord[0]) and np.isfinite(coord[1])
|
|
|
|
|
|
assert axis_def.get("method") == "pca"
|
|
|
|
|
|
|
|
|
def test_per_window_y_orientation(monkeypatch):
|
|
|
"""Per-window Y correction must ensure prog_avg_y > cons_avg_y in every window.
|
|
|
|
|
|
We construct two windows:
|
|
|
- w_good: progressive MPs at +Y, conservative MPs at -Y (already correct)
|
|
|
- w_bad: conservative MPs at +Y, progressive MPs at -Y (inverted)
|
|
|
|
|
|
We weight w_good with many more MPs so the GLOBAL centroid check passes
|
|
|
without noticing the per-window inversion. The per-window correction must
|
|
|
then flip w_bad so both windows end up with prog_avg_y > cons_avg_y.
|
|
|
"""
|
|
|
|
|
|
# Helpers to make slightly varied vectors
|
|
|
def pv(base):
|
|
|
return np.array(base, dtype=float)
|
|
|
|
|
|
# w_good: large left/right spread on dim-0, prog up (+Y), cons down (-Y)
|
|
|
w_good = {
|
|
|
# right / conservative
|
|
|
"Wilders, G.": pv([-3.0, -1.0, 0.0]),
|
|
|
"Rutte, M.": pv([-3.0, -0.9, 0.0]),
|
|
|
"van der Staaij, K.": pv([-2.9, -0.95, 0.0]),
|
|
|
"Omtzigt, P.": pv([-2.8, -0.85, 0.0]),
|
|
|
# left / progressive
|
|
|
"Marijnissen, L.": pv([3.0, 1.0, 0.0]),
|
|
|
"Klever, A.": pv([3.0, 0.9, 0.0]),
|
|
|
"Bromet, L.": pv([2.9, 0.95, 0.0]),
|
|
|
"Nijboer, H.": pv([2.8, 0.85, 0.0]),
|
|
|
}
|
|
|
|
|
|
# w_bad: same left/right structure but Y is inverted relative to w_good
|
|
|
# (conservative at +Y, progressive at -Y)
|
|
|
w_bad = {
|
|
|
"Wilders, G.": pv([-3.0, 1.0, 0.0]), # cons at +Y
|
|
|
"Rutte, M.": pv([-3.0, 0.9, 0.0]),
|
|
|
"van der Staaij, K.": pv([-2.9, 0.95, 0.0]),
|
|
|
"Omtzigt, P.": pv([-2.8, 0.85, 0.0]),
|
|
|
"Marijnissen, L.": pv([3.0, -1.0, 0.0]), # prog at -Y
|
|
|
"Klever, A.": pv([3.0, -0.9, 0.0]),
|
|
|
"Bromet, L.": pv([2.9, -0.95, 0.0]),
|
|
|
"Nijboer, H.": pv([2.8, -0.85, 0.0]),
|
|
|
}
|
|
|
|
|
|
aligned = {"w_good": w_good, "w_bad": w_bad}
|
|
|
|
|
|
mp_metadata = [
|
|
|
("Wilders, G.", "PVV"),
|
|
|
("Rutte, M.", "VVD"),
|
|
|
("van der Staaij, K.", "SGP"),
|
|
|
("Omtzigt, P.", "Nieuw Sociaal Contract"),
|
|
|
("Marijnissen, L.", "SP"),
|
|
|
("Klever, A.", "GroenLinks-PvdA"),
|
|
|
("Bromet, L.", "GroenLinks-PvdA"),
|
|
|
("Nijboer, H.", "SP"),
|
|
|
]
|
|
|
|
|
|
fake_traj = _make_fake_traj(aligned)
|
|
|
monkeypatch.setitem(sys.modules, "analysis.trajectory", fake_traj)
|
|
|
|
|
|
import types as _types
|
|
|
|
|
|
fake_conn = _types.SimpleNamespace(
|
|
|
execute=lambda q: _types.SimpleNamespace(fetchall=lambda: mp_metadata),
|
|
|
close=lambda: None,
|
|
|
)
|
|
|
import duckdb as _duckdb
|
|
|
|
|
|
monkeypatch.setattr(_duckdb, "connect", lambda db_path, **kw: fake_conn)
|
|
|
|
|
|
import importlib, analysis.political_axis as _ax
|
|
|
|
|
|
importlib.reload(_ax)
|
|
|
from analysis.political_axis import compute_2d_axes
|
|
|
|
|
|
positions_by_window, axis_def = compute_2d_axes(
|
|
|
db_path="dummy", window_ids=["w_good", "w_bad"], method="pca"
|
|
|
)
|
|
|
|
|
|
prog_mps = {"Marijnissen, L.", "Klever, A.", "Bromet, L.", "Nijboer, H."}
|
|
|
cons_mps = {"Wilders, G.", "Rutte, M.", "van der Staaij, K.", "Omtzigt, P."}
|
|
|
|
|
|
for wid in ("w_good", "w_bad"):
|
|
|
pos = positions_by_window[wid]
|
|
|
prog_y = np.mean([pos[mp][1] for mp in prog_mps if mp in pos])
|
|
|
cons_y = np.mean([pos[mp][1] for mp in cons_mps if mp in pos])
|
|
|
assert prog_y > cons_y, (
|
|
|
f"Window '{wid}': expected prog_avg_y ({prog_y:.3f}) > cons_avg_y ({cons_y:.3f})"
|
|
|
)
|
|
|
|
|
|
|
|
|
def test_pca_axis_orientation(monkeypatch):
|
|
|
"""PCA axes must be oriented so right parties score higher on X and
|
|
|
progressive parties score higher on Y than their respective opposites.
|
|
|
|
|
|
We construct a minimal vote-matrix world where:
|
|
|
- Right MPs (PVV, VVD members) cluster in one direction on dim-0.
|
|
|
- Left MPs (SP, GroenLinks-PvdA members) cluster in the opposite direction.
|
|
|
- Progressive MPs cluster on dim-1; conservative MPs on the opposite side.
|
|
|
|
|
|
The orientation logic in compute_2d_axes should flip axis signs so that
|
|
|
right_x > left_x and prog_y > cons_y regardless of the raw SVD sign.
|
|
|
"""
|
|
|
# Build vectors so that right parties are at +1 on dim-0 and
|
|
|
# progressive parties are at +1 on dim-1.
|
|
|
# We deliberately negate them to test that auto-orient flips them back.
|
|
|
# Right/left use magnitude 3, prog/cons use magnitude 1 so that dim-0
|
|
|
# dominates PCA variance — ensuring PC1 = left-right axis, PC2 = prog-cons.
|
|
|
right_vec = np.array([-3.0, 0.0, 0.0]) # intentionally negative on dim-0
|
|
|
left_vec = np.array([3.0, 0.0, 0.0]) # intentionally positive on dim-0
|
|
|
prog_vec = np.array([0.0, -1.0, 0.0]) # intentionally negative on dim-1
|
|
|
cons_vec = np.array([0.0, 1.0, 0.0]) # intentionally positive on dim-1
|
|
|
|
|
|
aligned = {
|
|
|
"w1": {
|
|
|
# Right-leaning MPs
|
|
|
"Wilders, G.": right_vec,
|
|
|
"Rutte, M.": right_vec + np.array([0.0, 0.0, 0.05]),
|
|
|
# Left-leaning MPs
|
|
|
"Marijnissen, L.": left_vec,
|
|
|
"Klever, A.": left_vec + np.array([0.0, 0.0, 0.05]),
|
|
|
# Progressive MPs
|
|
|
"Bromet, L.": prog_vec,
|
|
|
"Nijboer, H.": prog_vec + np.array([0.0, 0.0, -0.05]),
|
|
|
# Conservative MPs
|
|
|
"Segers, G.": cons_vec,
|
|
|
"Omtzigt, P.": cons_vec + np.array([0.0, 0.0, -0.05]),
|
|
|
}
|
|
|
}
|
|
|
|
|
|
# mp_metadata rows used by the orientation code (party affiliation)
|
|
|
mp_metadata = [
|
|
|
("Wilders, G.", "PVV"),
|
|
|
("Rutte, M.", "VVD"),
|
|
|
("Marijnissen, L.", "SP"),
|
|
|
("Klever, A.", "GroenLinks-PvdA"),
|
|
|
("Bromet, L.", "GroenLinks-PvdA"),
|
|
|
("Nijboer, H.", "SP"),
|
|
|
("Segers, G.", "CDA"),
|
|
|
("Omtzigt, P.", "Nieuw Sociaal Contract"),
|
|
|
]
|
|
|
|
|
|
fake_traj = _make_fake_traj(aligned)
|
|
|
monkeypatch.setitem(sys.modules, "analysis.trajectory", fake_traj)
|
|
|
|
|
|
# Patch duckdb so the orientation helper can fetch mp_metadata
|
|
|
import types as _types
|
|
|
|
|
|
fake_conn = _types.SimpleNamespace(
|
|
|
execute=lambda q: _types.SimpleNamespace(fetchall=lambda: mp_metadata),
|
|
|
close=lambda: None,
|
|
|
)
|
|
|
import duckdb as _duckdb
|
|
|
|
|
|
monkeypatch.setattr(_duckdb, "connect", lambda db_path, **kw: fake_conn)
|
|
|
|
|
|
# Need to reload the module so monkeypatched sys.modules takes effect
|
|
|
import importlib, analysis.political_axis as _ax
|
|
|
|
|
|
importlib.reload(_ax)
|
|
|
from analysis.political_axis import compute_2d_axes
|
|
|
|
|
|
positions_by_window, axis_def = compute_2d_axes(
|
|
|
db_path="dummy", window_ids=["w1"], method="pca"
|
|
|
)
|
|
|
|
|
|
pos = positions_by_window["w1"]
|
|
|
|
|
|
# X-axis: right parties should score higher than left parties
|
|
|
right_x = np.mean([pos["Wilders, G."][0], pos["Rutte, M."][0]])
|
|
|
left_x = np.mean([pos["Marijnissen, L."][0], pos["Klever, A."][0]])
|
|
|
assert right_x > left_x, (
|
|
|
f"Expected right parties (x={right_x:.3f}) > left parties (x={left_x:.3f}) on X-axis"
|
|
|
)
|
|
|
|
|
|
# Y-axis: progressive parties should score higher than conservative parties
|
|
|
prog_y = np.mean([pos["Bromet, L."][1], pos["Nijboer, H."][1]])
|
|
|
cons_y = np.mean([pos["Segers, G."][1], pos["Omtzigt, P."][1]])
|
|
|
assert prog_y > cons_y, (
|
|
|
f"Expected progressive parties (y={prog_y:.3f}) > conservative parties (y={cons_y:.3f}) on Y-axis"
|
|
|
)
|
|
|
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
|
# Tests for compute_party_discipline
|
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
def _make_mp_votes_db():
|
|
|
"""Create an in-memory DuckDB with mp_votes fixture data.
|
|
|
|
|
|
6 motions, 2 parties (SP, VVD), each with 4 MPs.
|
|
|
SP is perfectly disciplined (all 4 vote the same each time).
|
|
|
VVD has 1 dissident on 2 of 6 motions → Rice index = (4+4+4+4+3+3)/6/4 ≈ 0.917.
|
|
|
Dates span 2023-01-01 to 2023-12-31.
|
|
|
"""
|
|
|
import duckdb
|
|
|
|
|
|
conn = duckdb.connect(":memory:")
|
|
|
conn.execute("""
|
|
|
CREATE TABLE mp_votes (
|
|
|
id INTEGER,
|
|
|
motion_id VARCHAR,
|
|
|
mp_name VARCHAR,
|
|
|
party VARCHAR,
|
|
|
vote VARCHAR,
|
|
|
date DATE,
|
|
|
created_at TIMESTAMP
|
|
|
)
|
|
|
""")
|
|
|
rows = []
|
|
|
dates = [
|
|
|
"2023-01-10",
|
|
|
"2023-03-15",
|
|
|
"2023-05-20",
|
|
|
"2023-07-25",
|
|
|
"2023-09-30",
|
|
|
"2023-11-05",
|
|
|
]
|
|
|
sp_mps = ["Janssen, A.", "Pietersen, B.", "Willemsen, C.", "Hendriksen, D."]
|
|
|
vvd_mps = ["Adams, E.", "Bakker, F.", "Claassen, G.", "Dekker, H."]
|
|
|
for i, date in enumerate(dates, start=1):
|
|
|
m_id = f"M{i:03d}"
|
|
|
for mp in sp_mps:
|
|
|
rows.append((i * 10 + 1, m_id, mp, "SP", "voor", date, "2023-01-01"))
|
|
|
if i <= 4:
|
|
|
for mp in vvd_mps:
|
|
|
rows.append((i * 10 + 2, m_id, mp, "VVD", "voor", date, "2023-01-01"))
|
|
|
else:
|
|
|
for mp in vvd_mps[:3]:
|
|
|
rows.append((i * 10 + 2, m_id, mp, "VVD", "voor", date, "2023-01-01"))
|
|
|
rows.append(
|
|
|
(i * 10 + 3, m_id, vvd_mps[3], "VVD", "tegen", date, "2023-01-01")
|
|
|
)
|
|
|
conn.executemany("INSERT INTO mp_votes VALUES (?, ?, ?, ?, ?, ?, ?)", rows)
|
|
|
return conn
|
|
|
|
|
|
|
|
|
def test_compute_party_discipline_basic(monkeypatch):
|
|
|
"""compute_party_discipline returns correct Rice index for fixture data."""
|
|
|
import duckdb as _duckdb
|
|
|
|
|
|
fixture_conn = _make_mp_votes_db()
|
|
|
|
|
|
monkeypatch.setattr(_duckdb, "connect", lambda path, **kw: fixture_conn)
|
|
|
|
|
|
import importlib
|
|
|
import sys
|
|
|
|
|
|
if "streamlit" not in sys.modules:
|
|
|
import types
|
|
|
|
|
|
st_stub = types.ModuleType("streamlit")
|
|
|
st_stub.cache_data = lambda **kw: lambda f: f
|
|
|
sys.modules["streamlit"] = st_stub
|
|
|
|
|
|
import explorer as _explorer
|
|
|
|
|
|
importlib.reload(_explorer)
|
|
|
|
|
|
df = _explorer.compute_party_discipline(
|
|
|
db_path="dummy",
|
|
|
start_date="2023-01-01",
|
|
|
end_date="2023-12-31",
|
|
|
)
|
|
|
|
|
|
assert not df.empty
|
|
|
assert set(df.columns) >= {"party", "n_motions", "discipline"}
|
|
|
|
|
|
sp_row = df[df["party"] == "SP"].iloc[0]
|
|
|
vvd_row = df[df["party"] == "VVD"].iloc[0]
|
|
|
|
|
|
assert sp_row["n_motions"] == 6
|
|
|
assert sp_row["discipline"] == pytest.approx(1.0, abs=1e-6)
|
|
|
|
|
|
assert vvd_row["n_motions"] == 6
|
|
|
expected_vvd = (4 * 1.0 + 2 * 0.75) / 6
|
|
|
assert vvd_row["discipline"] == pytest.approx(expected_vvd, abs=1e-4)
|
|
|
|
|
|
assert (df["discipline"] >= 0).all() and (df["discipline"] <= 1).all()
|
|
|
|
|
|
|
|
|
def test_compute_party_discipline_empty_range(monkeypatch):
|
|
|
"""Returns empty DataFrame when no motions fall in the date range."""
|
|
|
import duckdb as _duckdb
|
|
|
|
|
|
fixture_conn = _make_mp_votes_db()
|
|
|
monkeypatch.setattr(_duckdb, "connect", lambda path, **kw: fixture_conn)
|
|
|
|
|
|
import importlib, sys
|
|
|
|
|
|
if "streamlit" not in sys.modules:
|
|
|
import types
|
|
|
|
|
|
st_stub = types.ModuleType("streamlit")
|
|
|
st_stub.cache_data = lambda **kw: lambda f: f
|
|
|
sys.modules["streamlit"] = st_stub
|
|
|
|
|
|
import explorer as _explorer
|
|
|
|
|
|
importlib.reload(_explorer)
|
|
|
|
|
|
df = _explorer.compute_party_discipline(
|
|
|
db_path="dummy",
|
|
|
start_date="2000-01-01",
|
|
|
end_date="2000-12-31",
|
|
|
)
|
|
|
|
|
|
assert df.empty
|
|
|
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
|
# Tests for analysis.axis_classifier
|
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
import importlib
|
|
|
|
|
|
|
|
|
def _fresh_classifier(monkeypatch):
|
|
|
"""Import axis_classifier with cleared module-level caches."""
|
|
|
import analysis.axis_classifier as _cls
|
|
|
|
|
|
monkeypatch.setattr(_cls, "_ideology_cache", None)
|
|
|
monkeypatch.setattr(_cls, "_coalition_cache", None)
|
|
|
return _cls
|
|
|
|
|
|
|
|
|
def test_axis_label_left_right(tmp_path, monkeypatch):
|
|
|
"""Positions that closely correlate with left_right scores → label 'Verzorgingsstaat–Marktwerking'."""
|
|
|
_cls = _fresh_classifier(monkeypatch)
|
|
|
|
|
|
(tmp_path / "party_ideologies.csv").write_text(
|
|
|
"party,left_right,progressive\n"
|
|
|
"VVD,0.65,0.10\n"
|
|
|
"PvdA,-0.70,0.75\n"
|
|
|
"SP,-0.90,0.50\n"
|
|
|
"PVV,0.90,-0.50\n"
|
|
|
"D66,-0.10,0.85\n"
|
|
|
"CDA,0.25,-0.45\n"
|
|
|
)
|
|
|
(tmp_path / "coalition_membership.csv").write_text("window_id,party\n")
|
|
|
|
|
|
# X values are the party's left_right scores — perfect correlation
|
|
|
positions_by_window = {
|
|
|
"2022": {
|
|
|
"VVD": (0.65, 0.10),
|
|
|
"PvdA": (-0.70, 0.20),
|
|
|
"SP": (-0.90, 0.30),
|
|
|
"PVV": (0.90, -0.10),
|
|
|
"D66": (-0.10, 0.40),
|
|
|
"CDA": (0.25, -0.20),
|
|
|
}
|
|
|
}
|
|
|
axes = {"x_axis": None, "y_axis": None, "method": "pca"}
|
|
|
|
|
|
result = _cls.classify_axes(positions_by_window, axes, str(tmp_path / "motions.db"))
|
|
|
|
|
|
assert result["x_label"] == "Verzorgingsstaat–Marktwerking"
|
|
|
assert result["x_quality"]["2022"] >= 0.65
|
|
|
|
|
|
|
|
|
def test_axis_label_coalition_dominant(tmp_path, monkeypatch):
|
|
|
"""Positions that match coalition pattern but NOT left-right → 'Coalitie–Oppositie'."""
|
|
|
_cls = _fresh_classifier(monkeypatch)
|
|
|
|
|
|
(tmp_path / "party_ideologies.csv").write_text(
|
|
|
"party,left_right,progressive\n"
|
|
|
"VVD,0.65,0.10\n"
|
|
|
"PvdA,-0.70,0.75\n"
|
|
|
"SP,-0.90,0.50\n"
|
|
|
"PVV,0.90,-0.50\n"
|
|
|
"D66,-0.10,0.85\n"
|
|
|
"CDA,0.25,-0.45\n"
|
|
|
)
|
|
|
# 2016: Rutte II coalition = VVD + PvdA
|
|
|
(tmp_path / "coalition_membership.csv").write_text(
|
|
|
"window_id,party\n2016,VVD\n2016,PvdA\n"
|
|
|
)
|
|
|
|
|
|
# Coalition parties (VVD + PvdA) at x ≈ +1, opposition at x ≈ -1.
|
|
|
# VVD (right) and PvdA (left) are both near +1 → low left_right correlation
|
|
|
# but high coalition correlation.
|
|
|
positions_by_window = {
|
|
|
"2016": {
|
|
|
"VVD": (0.95, 0.10),
|
|
|
"PvdA": (0.90, 0.20),
|
|
|
"SP": (-0.85, 0.30),
|
|
|
"PVV": (-0.95, -0.10),
|
|
|
"D66": (-0.80, 0.40),
|
|
|
"CDA": (-0.75, -0.20),
|
|
|
}
|
|
|
}
|
|
|
axes = {"x_axis": None, "y_axis": None, "method": "pca"}
|
|
|
|
|
|
result = _cls.classify_axes(positions_by_window, axes, str(tmp_path / "motions.db"))
|
|
|
|
|
|
assert result["x_label"] == "Coalitie\u2013Oppositie"
|
|
|
assert "coalitie" in result["x_interpretation"]["2016"].lower()
|
|
|
|
|
|
|
|
|
def test_axis_classifier_missing_csv(tmp_path, monkeypatch):
|
|
|
"""Missing party_ideologies.csv → returns axes dict unchanged, no exception."""
|
|
|
_cls = _fresh_classifier(monkeypatch)
|
|
|
|
|
|
# No CSVs written — directory exists but files do not
|
|
|
positions_by_window = {"2022": {"VVD": (1.0, 0.5), "PvdA": (-1.0, 0.3)}}
|
|
|
axes = {"x_axis": None, "y_axis": None, "method": "pca"}
|
|
|
|
|
|
result = _cls.classify_axes(positions_by_window, axes, str(tmp_path / "motions.db"))
|
|
|
|
|
|
# Must not crash and must return the original axes dict unchanged
|
|
|
assert result is axes
|
|
|
assert "x_label" not in result
|
|
|
|
|
|
|
|
|
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)
|
|
|
# Provide a minimal duckdb stub so importing analysis.political_axis succeeds
|
|
|
import types as _types
|
|
|
|
|
|
fake_conn = _types.SimpleNamespace(
|
|
|
execute=lambda q: _types.SimpleNamespace(fetchall=lambda: []),
|
|
|
close=lambda: None,
|
|
|
)
|
|
|
fake_duckdb = _types.SimpleNamespace(connect=lambda db_path, **kw: fake_conn)
|
|
|
monkeypatch.setitem(sys.modules, "duckdb", fake_duckdb)
|
|
|
|
|
|
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)
|
|
|
|
|
|
|
|
|
def test_classify_from_titles_left_right():
|
|
|
"""Titles dominated by left-right keywords -> 'Verzorgingsstaat–Marktwerking'."""
|
|
|
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 == "Verzorgingsstaat–Marktwerking"
|
|
|
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
|
|
|
|
|
|
|
|
|
def test_axis_swap_when_y_is_left_right():
|
|
|
"""When y_label is economic left-right 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": "Verzorgingsstaat–Marktwerking",
|
|
|
"x_quality": {"2023": 0.7},
|
|
|
"y_quality": {"2023": 0.8},
|
|
|
"x_interpretation": {"2023": "prog interpretation"},
|
|
|
"y_interpretation": {"2023": "economic 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"] == "Verzorgingsstaat–Marktwerking"
|
|
|
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 economic left-right, no swap should occur."""
|
|
|
from explorer import _should_swap_axes
|
|
|
|
|
|
axis_def = {
|
|
|
"x_label": "Verzorgingsstaat–Marktwerking",
|
|
|
"y_label": "Progressief\u2013Conservatief",
|
|
|
}
|
|
|
assert _should_swap_axes(axis_def) is False
|
|
|
|
|
|
axis_def2 = {
|
|
|
"x_label": "Verzorgingsstaat–Marktwerking",
|
|
|
"y_label": "Verzorgingsstaat–Marktwerking", # both economic — no swap
|
|
|
}
|
|
|
assert _should_swap_axes(axis_def2) is False
|
|
|
|
|
|
|
|
|
def test_axis_swap_not_applied_when_neither_axis_is_left_right():
|
|
|
from explorer import _should_swap_axes
|
|
|
|
|
|
assert _should_swap_axes({"x_label": "Foo", "y_label": "Bar"}) is False
|
|
|
assert _should_swap_axes({"x_label": None, "y_label": None}) is False
|
|
|
|
