|
|
"""Rendering helpers for explorer tabs.
|
|
|
|
|
|
This module contains all Plotly/Streamlit rendering functions extracted from
|
|
|
explorer.py. It is import-safe: plotly and streamlit are optional.
|
|
|
"""
|
|
|
|
|
|
from __future__ import annotations
|
|
|
|
|
|
import json
|
|
|
import logging
|
|
|
from typing import Dict, List, Optional, Tuple
|
|
|
|
|
|
try:
|
|
|
import plotly.express as px
|
|
|
import plotly.graph_objects as go
|
|
|
except Exception:
|
|
|
px = None
|
|
|
import types
|
|
|
|
|
|
class _DummyTrace:
|
|
|
def __init__(self, **kwargs):
|
|
|
self.name = kwargs.get("name")
|
|
|
self.x = kwargs.get("x")
|
|
|
self.y = kwargs.get("y")
|
|
|
self.text = kwargs.get("text")
|
|
|
self.customdata = kwargs.get("customdata")
|
|
|
|
|
|
class _DummyFigure:
|
|
|
def __init__(self):
|
|
|
self.data = []
|
|
|
|
|
|
def add_trace(self, trace):
|
|
|
if isinstance(trace, _DummyTrace):
|
|
|
self.data.append(trace)
|
|
|
else:
|
|
|
try:
|
|
|
name = getattr(trace, "name", None)
|
|
|
x = getattr(trace, "x", None)
|
|
|
y = getattr(trace, "y", None)
|
|
|
text = getattr(trace, "text", None)
|
|
|
customdata = getattr(trace, "customdata", None)
|
|
|
except Exception:
|
|
|
name = trace.get("name") if hasattr(trace, "get") else None
|
|
|
x = trace.get("x") if hasattr(trace, "get") else None
|
|
|
y = trace.get("y") if hasattr(trace, "get") else None
|
|
|
text = trace.get("text") if hasattr(trace, "get") else None
|
|
|
customdata = (
|
|
|
trace.get("customdata") if hasattr(trace, "get") else None
|
|
|
)
|
|
|
self.data.append(
|
|
|
_DummyTrace(name=name, x=x, y=y, text=text, customdata=customdata)
|
|
|
)
|
|
|
|
|
|
def add_annotation(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def update_layout(self, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def update_traces(self, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def add_hline(self, **kwargs):
|
|
|
return None
|
|
|
|
|
|
go = types.SimpleNamespace(
|
|
|
Figure=_DummyFigure,
|
|
|
Scatter=lambda **kwargs: _DummyTrace(**kwargs),
|
|
|
Bar=lambda **kwargs: _DummyTrace(**kwargs),
|
|
|
)
|
|
|
|
|
|
try:
|
|
|
import streamlit as st
|
|
|
except Exception:
|
|
|
|
|
|
class _DummySt:
|
|
|
def cache_data(self, *args, **kwargs):
|
|
|
def _decorator(func):
|
|
|
return func
|
|
|
|
|
|
return _decorator
|
|
|
|
|
|
def markdown(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def subheader(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def plotly_chart(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def caption(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def text_area(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def json(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def checkbox(self, *args, **kwargs):
|
|
|
return kwargs.get("value", False)
|
|
|
|
|
|
def warning(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def info(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def error(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def success(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def selectbox(self, *args, **kwargs):
|
|
|
opts = (
|
|
|
kwargs.get("options")
|
|
|
if kwargs.get("options") is not None
|
|
|
else (args[1] if len(args) > 1 else [])
|
|
|
)
|
|
|
return opts[0] if opts else None
|
|
|
|
|
|
def multiselect(self, *args, **kwargs):
|
|
|
opts = (
|
|
|
kwargs.get("options")
|
|
|
if kwargs.get("options") is not None
|
|
|
else (args[1] if len(args) > 1 else [])
|
|
|
)
|
|
|
default = kwargs.get("default")
|
|
|
if default is not None:
|
|
|
return default
|
|
|
return opts[:6] if opts else []
|
|
|
|
|
|
def number_input(self, *args, **kwargs):
|
|
|
return kwargs.get("value") if "value" in kwargs else 1
|
|
|
|
|
|
def slider(self, *args, **kwargs):
|
|
|
return kwargs.get("value") if "value" in kwargs else 0.35
|
|
|
|
|
|
def select_slider(self, *args, **kwargs):
|
|
|
return kwargs.get("value") if "value" in kwargs else (None, None)
|
|
|
|
|
|
def expander(self, *args, **kwargs):
|
|
|
class _Ctx:
|
|
|
def __enter__(self_inner):
|
|
|
return self_inner
|
|
|
|
|
|
def __exit__(self_inner, exc_type, exc, tb):
|
|
|
return False
|
|
|
|
|
|
return _Ctx()
|
|
|
|
|
|
def columns(self, *args, **kwargs):
|
|
|
class _Col:
|
|
|
def markdown(self, *a, **k):
|
|
|
return None
|
|
|
|
|
|
def metric(self, *a, **k):
|
|
|
return None
|
|
|
|
|
|
def dataframe(self, *a, **k):
|
|
|
return None
|
|
|
|
|
|
def write(self, *a, **k):
|
|
|
return None
|
|
|
|
|
|
def text_input(self, *a, **k):
|
|
|
return None
|
|
|
|
|
|
n = len(args[0]) if args else 1
|
|
|
return tuple(_Col() for _ in range(n))
|
|
|
|
|
|
def form(self, *args, **kwargs):
|
|
|
class _Ctx:
|
|
|
def __enter__(self_inner):
|
|
|
return self_inner
|
|
|
|
|
|
def __exit__(self_inner, exc_type, exc, tb):
|
|
|
return False
|
|
|
|
|
|
return _Ctx()
|
|
|
|
|
|
def form_submit_button(self, *args, **kwargs):
|
|
|
return False
|
|
|
|
|
|
def button(self, *args, **kwargs):
|
|
|
return False
|
|
|
|
|
|
def rerun(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def divider(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def spinner(self, *args, **kwargs):
|
|
|
class _Ctx:
|
|
|
def __enter__(self_inner):
|
|
|
return self_inner
|
|
|
|
|
|
def __exit__(self_inner, exc_type, exc, tb):
|
|
|
return False
|
|
|
|
|
|
return _Ctx()
|
|
|
|
|
|
def write(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def dataframe(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def set_page_config(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def title(self, *args, **kwargs):
|
|
|
return None
|
|
|
|
|
|
def sidebar(self, *args, **kwargs):
|
|
|
return self
|
|
|
|
|
|
def radio(self, *args, **kwargs):
|
|
|
return kwargs.get("value") if "value" in kwargs else None
|
|
|
|
|
|
def text_input(self, *args, **kwargs):
|
|
|
return kwargs.get("value", "")
|
|
|
|
|
|
def tabs(self, *args, **kwargs):
|
|
|
n = len(args[0]) if args else 1
|
|
|
return [self for _ in range(n)]
|
|
|
|
|
|
@property
|
|
|
def session_state(self):
|
|
|
if not hasattr(self, "_session_state"):
|
|
|
self._session_state = {}
|
|
|
return self._session_state
|
|
|
|
|
|
st = _DummySt()
|
|
|
|
|
|
from analysis.config import PARTY_COLOURS
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
def _render_scree_plot(importances: List[float], n_show: int = 15) -> None:
|
|
|
"""Render a scree plot showing relative SVD component importance.
|
|
|
|
|
|
Highlighted bars for the top-2 components (used in the compass); muted bars
|
|
|
for the rest. A cumulative-variance dashed line on the same y-axis helps
|
|
|
spot the elbow. A 50 % cumulative threshold line is drawn for reference.
|
|
|
|
|
|
Args:
|
|
|
importances: List of importance values sorted descending (from load_scree_data).
|
|
|
n_show: How many components to display (default: first 15).
|
|
|
"""
|
|
|
if not importances:
|
|
|
return
|
|
|
data = list(importances[:n_show])
|
|
|
ranks = list(range(1, len(data) + 1))
|
|
|
|
|
|
cumsum = []
|
|
|
running = 0.0
|
|
|
for v in data:
|
|
|
running += v
|
|
|
cumsum.append(running)
|
|
|
|
|
|
n_highlight = 2
|
|
|
bar_colours = [
|
|
|
"#1565C0" if i < n_highlight else "#90CAF9" for i in range(len(data))
|
|
|
]
|
|
|
|
|
|
fig = go.Figure()
|
|
|
|
|
|
fig.add_trace(
|
|
|
go.Bar(
|
|
|
x=ranks,
|
|
|
y=data,
|
|
|
marker_color=bar_colours,
|
|
|
hovertemplate="As %{x}<br><b>%{y:.1f}%</b> verklaarde variantie<extra></extra>",
|
|
|
showlegend=False,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
fig.add_trace(
|
|
|
go.Scatter(
|
|
|
x=ranks,
|
|
|
y=cumsum,
|
|
|
mode="lines+markers",
|
|
|
line={"color": "#F57C00", "width": 2, "dash": "dot"},
|
|
|
marker={"size": 5, "color": "#F57C00"},
|
|
|
hovertemplate="As %{x}<br>Cumulatief: <b>%{y:.1f}%</b><extra></extra>",
|
|
|
name="Cumulatief",
|
|
|
showlegend=True,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
fig.add_hline(
|
|
|
y=50,
|
|
|
line_dash="dash",
|
|
|
line_color="#BDBDBD",
|
|
|
line_width=1,
|
|
|
annotation_text="50%",
|
|
|
annotation_position="right",
|
|
|
annotation_font_color="#9E9E9E",
|
|
|
annotation_font_size=11,
|
|
|
)
|
|
|
|
|
|
for i in range(min(n_highlight, len(data))):
|
|
|
fig.add_annotation(
|
|
|
x=ranks[i],
|
|
|
y=data[i] + 0.3,
|
|
|
text=f"{data[i]:.1f}%",
|
|
|
showarrow=False,
|
|
|
font={"size": 11, "color": "#1565C0"},
|
|
|
yanchor="bottom",
|
|
|
)
|
|
|
|
|
|
fig.update_layout(
|
|
|
height=280,
|
|
|
margin={"l": 10, "r": 50, "t": 30, "b": 40},
|
|
|
title={
|
|
|
"text": "Belang per SVD-as",
|
|
|
"font": {"size": 13, "color": "#555555"},
|
|
|
"x": 0.02,
|
|
|
"xanchor": "left",
|
|
|
},
|
|
|
legend={
|
|
|
"orientation": "h",
|
|
|
"x": 0.5,
|
|
|
"xanchor": "center",
|
|
|
"y": 1.08,
|
|
|
"font": {"size": 11},
|
|
|
},
|
|
|
xaxis={
|
|
|
"title": {"text": "As (rang)", "font": {"size": 11}},
|
|
|
"tickmode": "linear",
|
|
|
"tick0": 1,
|
|
|
"dtick": 1,
|
|
|
"showline": False,
|
|
|
"showgrid": False,
|
|
|
},
|
|
|
yaxis={
|
|
|
"title": {"text": "% van totale variantie", "font": {"size": 11}},
|
|
|
"showline": False,
|
|
|
"showgrid": True,
|
|
|
"gridcolor": "#eeeeee",
|
|
|
"ticksuffix": "%",
|
|
|
"range": [0, max(cumsum) * 1.08],
|
|
|
},
|
|
|
plot_bgcolor="rgba(0,0,0,0)",
|
|
|
paper_bgcolor="rgba(0,0,0,0)",
|
|
|
bargap=0.25,
|
|
|
)
|
|
|
st.plotly_chart(fig, use_container_width=True)
|
|
|
|
|
|
|
|
|
def _build_party_axis_figure(
|
|
|
party_coords: Dict[str, Tuple[float, float]],
|
|
|
comp_sel: int,
|
|
|
theme: dict,
|
|
|
bootstrap_data: Optional[Dict[str, Dict]] = None,
|
|
|
) -> Optional[go.Figure]:
|
|
|
"""Build a 1D horizontal Plotly scatter of party positions on SVD axis `comp_sel`.
|
|
|
|
|
|
Accepts explicit per-party 2D coordinates (x,y) and uses the component selection to
|
|
|
pick the value (comp_sel==1 -> x, comp_sel==2 -> y). This makes the API explicit and
|
|
|
avoids indexing into long SVD vectors.
|
|
|
|
|
|
Returns go.Figure or None if no data available.
|
|
|
"""
|
|
|
if not party_coords:
|
|
|
return None
|
|
|
|
|
|
if comp_sel not in (1, 2):
|
|
|
raise ValueError(
|
|
|
"_build_party_axis_figure only supports comp_sel 1 or 2 when using explicit coords"
|
|
|
)
|
|
|
|
|
|
axis_idx = comp_sel - 1
|
|
|
flip = theme.get("flip", False)
|
|
|
|
|
|
parties = []
|
|
|
scores = []
|
|
|
colours = []
|
|
|
|
|
|
for party, val in party_coords.items():
|
|
|
try:
|
|
|
if hasattr(val, "__len__") and len(val) == 2:
|
|
|
x, y = val
|
|
|
score = float(x if axis_idx == 0 else y)
|
|
|
else:
|
|
|
score = float(val[axis_idx])
|
|
|
|
|
|
if flip:
|
|
|
score = -score
|
|
|
except Exception:
|
|
|
continue
|
|
|
|
|
|
parties.append(party)
|
|
|
scores.append(score)
|
|
|
colours.append(PARTY_COLOURS.get(party, "#9E9E9E"))
|
|
|
|
|
|
if not scores:
|
|
|
return None
|
|
|
|
|
|
hover = []
|
|
|
symbols = []
|
|
|
if bootstrap_data:
|
|
|
for p, s in zip(parties, scores):
|
|
|
bd = bootstrap_data.get(p)
|
|
|
if bd:
|
|
|
n_mps = bd.get("n_mps", "?")
|
|
|
ci_low = None
|
|
|
ci_high = None
|
|
|
try:
|
|
|
ci_low = float(bd["ci_lower"][axis_idx])
|
|
|
ci_high = float(bd["ci_upper"][axis_idx])
|
|
|
except Exception:
|
|
|
pass
|
|
|
if ci_low is not None and ci_high is not None:
|
|
|
hover.append(
|
|
|
f"{p}: {s:.3f} (N={n_mps}, 95%-BI: [{ci_low:.3f}, {ci_high:.3f}])"
|
|
|
)
|
|
|
else:
|
|
|
hover.append(f"{p}: {s:.3f} (N={n_mps})")
|
|
|
symbols.append("diamond" if n_mps == 1 else "circle")
|
|
|
else:
|
|
|
hover.append(f"{p}: {s:.3f}")
|
|
|
symbols.append("circle")
|
|
|
marker_kwargs = {"size": 14, "color": colours, "symbol": symbols}
|
|
|
else:
|
|
|
hover = [f"{p}: {s:.3f}" for p, s in zip(parties, scores)]
|
|
|
marker_kwargs = {"size": 14, "color": colours}
|
|
|
|
|
|
fig = go.Figure()
|
|
|
x_min, x_max = min(scores) * 1.15, max(scores) * 1.15
|
|
|
if x_min == x_max:
|
|
|
x_min, x_max = x_min - 1, x_max + 1
|
|
|
fig.add_trace(
|
|
|
go.Scatter(
|
|
|
x=[x_min, x_max],
|
|
|
y=[0, 0],
|
|
|
mode="lines",
|
|
|
line={"color": "#cccccc", "width": 1},
|
|
|
hoverinfo="skip",
|
|
|
showlegend=False,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
scatter_kwargs = {
|
|
|
"x": scores,
|
|
|
"y": [0] * len(scores),
|
|
|
"mode": "markers+text",
|
|
|
"text": parties,
|
|
|
"textposition": "top center",
|
|
|
"marker": marker_kwargs,
|
|
|
"hovertext": hover,
|
|
|
"hoverinfo": "text",
|
|
|
"showlegend": False,
|
|
|
}
|
|
|
fig.add_trace(go.Scatter(**scatter_kwargs))
|
|
|
|
|
|
pos_pole = theme.get("positive_pole", "")
|
|
|
neg_pole = theme.get("negative_pole", "")
|
|
|
left_label = neg_pole
|
|
|
right_label = pos_pole
|
|
|
|
|
|
fig.update_layout(
|
|
|
height=160,
|
|
|
margin={"l": 10, "r": 10, "t": 10, "b": 30},
|
|
|
xaxis={
|
|
|
"title": f"← {left_label} | {right_label} →",
|
|
|
"showticklabels": False,
|
|
|
"showline": False,
|
|
|
"showgrid": False,
|
|
|
"zeroline": False,
|
|
|
},
|
|
|
yaxis={"visible": False, "range": [-1, 2]},
|
|
|
plot_bgcolor="rgba(0,0,0,0)",
|
|
|
paper_bgcolor="rgba(0,0,0,0)",
|
|
|
)
|
|
|
return fig
|
|
|
|
|
|
|
|
|
def _render_party_axis_chart(
|
|
|
party_coords: Dict[str, Tuple[float, float]],
|
|
|
comp_sel: int,
|
|
|
theme: dict,
|
|
|
bootstrap_data: Optional[Dict[str, Dict]] = None,
|
|
|
) -> None:
|
|
|
"""Render a 1D horizontal Plotly scatter of party positions on SVD axis `comp_sel`.
|
|
|
|
|
|
Expects explicit per-party coords mapping (party -> (x,y)) for components 1 & 2.
|
|
|
"""
|
|
|
fig = _build_party_axis_figure(party_coords, comp_sel, theme, bootstrap_data)
|
|
|
if fig is None:
|
|
|
st.caption("_Partijdata niet beschikbaar voor deze as._")
|
|
|
return
|
|
|
st.plotly_chart(fig, use_container_width=True)
|
|
|
|
|
|
|
|
|
def _render_party_axis_chart_1d(
|
|
|
party_coords: Dict[str, Tuple[float, ...]],
|
|
|
comp_sel: int,
|
|
|
theme: dict,
|
|
|
) -> None:
|
|
|
"""Render a 1D horizontal scatter of party positions on SVD component `comp_sel`.
|
|
|
|
|
|
Uses the same format as components 1-2: parties as markers on a horizontal line
|
|
|
with axis title showing poles with arrows.
|
|
|
|
|
|
Args:
|
|
|
party_coords: Dict mapping party name to tuple of scores (score_for_comp,)
|
|
|
comp_sel: SVD component number (1-indexed)
|
|
|
theme: Dict with label, positive_pole, negative_pole, flip
|
|
|
"""
|
|
|
if not party_coords:
|
|
|
st.caption("_Partijdata niet beschikbaar voor deze as._")
|
|
|
return
|
|
|
|
|
|
parties = []
|
|
|
scores = []
|
|
|
colours = []
|
|
|
|
|
|
for party, coords in party_coords.items():
|
|
|
try:
|
|
|
score = float(coords[0])
|
|
|
parties.append(party)
|
|
|
scores.append(score)
|
|
|
colours.append(PARTY_COLOURS.get(party, "#9E9E9E"))
|
|
|
except Exception:
|
|
|
continue
|
|
|
|
|
|
if not scores:
|
|
|
st.caption("_Partijdata niet beschikbaar voor deze as._")
|
|
|
return
|
|
|
|
|
|
flip = theme.get("flip", False)
|
|
|
if flip:
|
|
|
scores = [-s for s in scores]
|
|
|
|
|
|
hover = [f"{p}: {s:.3f}" for p, s in zip(parties, scores)]
|
|
|
|
|
|
fig = go.Figure()
|
|
|
x_min, x_max = min(scores) * 1.15, max(scores) * 1.15
|
|
|
if x_min == x_max:
|
|
|
x_min, x_max = x_min - 1, x_max + 1
|
|
|
|
|
|
fig.add_trace(
|
|
|
go.Scatter(
|
|
|
x=[x_min, x_max],
|
|
|
y=[0, 0],
|
|
|
mode="lines",
|
|
|
line={"color": "#cccccc", "width": 1},
|
|
|
hoverinfo="skip",
|
|
|
showlegend=False,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
fig.add_trace(
|
|
|
go.Scatter(
|
|
|
x=scores,
|
|
|
y=[0] * len(scores),
|
|
|
mode="markers+text",
|
|
|
text=parties,
|
|
|
textposition="top center",
|
|
|
marker={"size": 14, "color": colours},
|
|
|
hovertext=hover,
|
|
|
hoverinfo="text",
|
|
|
showlegend=False,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
pos_pole = theme.get("positive_pole", "")
|
|
|
neg_pole = theme.get("negative_pole", "")
|
|
|
left_label = neg_pole
|
|
|
right_label = pos_pole
|
|
|
|
|
|
fig.update_layout(
|
|
|
height=160,
|
|
|
margin={"l": 10, "r": 10, "t": 10, "b": 30},
|
|
|
xaxis={
|
|
|
"title": f"← {left_label} | {right_label} →",
|
|
|
"showticklabels": False,
|
|
|
"showline": False,
|
|
|
"showgrid": False,
|
|
|
"zeroline": False,
|
|
|
},
|
|
|
yaxis={"visible": False, "range": [-1, 2]},
|
|
|
plot_bgcolor="rgba(0,0,0,0)",
|
|
|
paper_bgcolor="rgba(0,0,0,0)",
|
|
|
)
|
|
|
|
|
|
st.plotly_chart(fig, use_container_width=True)
|
|
|
|
|
|
|
|
|
def _render_svd_time_trajectory(
|
|
|
party_scores_by_window: Dict[str, Dict[str, List[float]]],
|
|
|
comp_sel: int,
|
|
|
theme: dict,
|
|
|
selected_parties: List[str],
|
|
|
) -> None:
|
|
|
"""Render a time trajectory plot showing party positions over time on an SVD component.
|
|
|
|
|
|
Args:
|
|
|
party_scores_by_window: {window_id: {party_name: [scores]}}
|
|
|
comp_sel: SVD component number (1-indexed)
|
|
|
theme: Theme dict with label, positive_pole, negative_pole, flip
|
|
|
selected_parties: List of party names to display
|
|
|
"""
|
|
|
if not party_scores_by_window or not selected_parties:
|
|
|
st.caption("_Geen data beschikbaar voor tijdtraject._")
|
|
|
return
|
|
|
|
|
|
idx = comp_sel - 1
|
|
|
|
|
|
party_trajectories: Dict[str, List[Tuple[str, float]]] = {}
|
|
|
|
|
|
all_windows = list(party_scores_by_window.keys())
|
|
|
sorted_windows = []
|
|
|
if "current_parliament" in all_windows:
|
|
|
sorted_windows.append("current_parliament")
|
|
|
other_windows = sorted(
|
|
|
[w for w in all_windows if w != "current_parliament"], reverse=True
|
|
|
)
|
|
|
sorted_windows.extend(other_windows)
|
|
|
|
|
|
for window in sorted_windows:
|
|
|
scores_by_party = party_scores_by_window.get(window, {})
|
|
|
for party in selected_parties:
|
|
|
scores = scores_by_party.get(party, [])
|
|
|
if scores and len(scores) > idx:
|
|
|
try:
|
|
|
score = float(scores[idx])
|
|
|
party_trajectories.setdefault(party, []).append((window, score))
|
|
|
except (ValueError, TypeError):
|
|
|
continue
|
|
|
|
|
|
if not party_trajectories:
|
|
|
st.caption("_Geen data beschikbaar voor geselecteerde partijen._")
|
|
|
return
|
|
|
|
|
|
fig = go.Figure()
|
|
|
|
|
|
all_scores = []
|
|
|
for traj in party_trajectories.values():
|
|
|
all_scores.extend([s for _, s in traj])
|
|
|
|
|
|
if not all_scores:
|
|
|
st.caption("_Geen scores beschikbaar._")
|
|
|
return
|
|
|
|
|
|
x_min, x_max = min(all_scores) * 1.15, max(all_scores) * 1.15
|
|
|
if x_min == x_max:
|
|
|
x_min, x_max = x_min - 1, x_max + 1
|
|
|
|
|
|
window_to_y = {w: i for i, w in enumerate(sorted_windows)}
|
|
|
|
|
|
for window in sorted_windows:
|
|
|
y_pos = window_to_y[window]
|
|
|
fig.add_trace(
|
|
|
go.Scatter(
|
|
|
x=[x_min, x_max],
|
|
|
y=[y_pos, y_pos],
|
|
|
mode="lines",
|
|
|
line={"color": "#cccccc", "width": 1},
|
|
|
hoverinfo="skip",
|
|
|
showlegend=False,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
for party in selected_parties:
|
|
|
if party not in party_trajectories:
|
|
|
continue
|
|
|
|
|
|
traj = party_trajectories[party]
|
|
|
if len(traj) < 1:
|
|
|
continue
|
|
|
|
|
|
x_vals = [score for _, score in traj]
|
|
|
y_vals = [window_to_y[window] for window, _ in traj]
|
|
|
color = PARTY_COLOURS.get(party, "#9E9E9E")
|
|
|
|
|
|
fig.add_trace(
|
|
|
go.Scatter(
|
|
|
x=x_vals,
|
|
|
y=y_vals,
|
|
|
mode="lines",
|
|
|
line={"color": color, "width": 2},
|
|
|
hoverinfo="skip",
|
|
|
showlegend=False,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
hover_texts = [f"{party}<br>{window}: {score:.3f}" for window, score in traj]
|
|
|
fig.add_trace(
|
|
|
go.Scatter(
|
|
|
x=x_vals,
|
|
|
y=y_vals,
|
|
|
mode="markers+text",
|
|
|
text=[party] * len(traj),
|
|
|
textposition="top center",
|
|
|
marker={"size": 12, "color": color},
|
|
|
hovertext=hover_texts,
|
|
|
hoverinfo="text",
|
|
|
showlegend=False,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
pos_pole = theme.get("positive_pole", "")
|
|
|
neg_pole = theme.get("negative_pole", "")
|
|
|
left_label = neg_pole
|
|
|
right_label = pos_pole
|
|
|
|
|
|
y_labels = {}
|
|
|
for window in sorted_windows:
|
|
|
if window == "current_parliament":
|
|
|
y_labels[window_to_y[window]] = "Huidig"
|
|
|
else:
|
|
|
y_labels[window_to_y[window]] = window
|
|
|
|
|
|
fig.update_layout(
|
|
|
height=max(400, len(sorted_windows) * 60 + 100),
|
|
|
margin={"l": 80, "r": 10, "t": 10, "b": 30},
|
|
|
xaxis={
|
|
|
"title": f"← {left_label} | {right_label} →",
|
|
|
"range": [x_min, x_max],
|
|
|
"showticklabels": False,
|
|
|
"showline": False,
|
|
|
"showgrid": True,
|
|
|
"gridcolor": "rgba(0,0,0,0.1)",
|
|
|
"zeroline": True,
|
|
|
"zerolinecolor": "rgba(0,0,0,0.2)",
|
|
|
},
|
|
|
yaxis={
|
|
|
"tickvals": list(y_labels.keys()),
|
|
|
"ticktext": list(y_labels.values()),
|
|
|
"tickmode": "array",
|
|
|
"autorange": "reversed",
|
|
|
"showgrid": False,
|
|
|
},
|
|
|
plot_bgcolor="rgba(0,0,0,0)",
|
|
|
paper_bgcolor="rgba(0,0,0,0)",
|
|
|
)
|
|
|
|
|
|
st.plotly_chart(fig, use_container_width=True)
|
|
|
|
|
|
|
|
|
def _render_voting_results(voting_results_json) -> None:
|
|
|
"""Render a voting_results JSON blob as a grouped voor/tegen/onthouden table.
|
|
|
|
|
|
The JSON is stored as {party_or_mp: vote} where vote is one of
|
|
|
'voor', 'tegen', 'onthouden', 'afwezig'. We group by vote for readability.
|
|
|
"""
|
|
|
if not voting_results_json:
|
|
|
return
|
|
|
try:
|
|
|
vdata = (
|
|
|
json.loads(voting_results_json)
|
|
|
if isinstance(voting_results_json, str)
|
|
|
else voting_results_json
|
|
|
)
|
|
|
if not isinstance(vdata, dict) or not vdata:
|
|
|
return
|
|
|
by_vote: Dict[str, List[str]] = {}
|
|
|
for actor, vote in vdata.items():
|
|
|
vote_str = str(vote).lower().strip()
|
|
|
by_vote.setdefault(vote_str, []).append(str(actor))
|
|
|
vote_order = ["voor", "tegen", "onthouden", "afwezig"]
|
|
|
vote_emoji = {"voor": "✅", "tegen": "❌", "onthouden": "🟡", "afwezig": "⬜"}
|
|
|
rows_shown = False
|
|
|
for v in vote_order + [k for k in by_vote if k not in vote_order]:
|
|
|
actors = by_vote.get(v)
|
|
|
if not actors:
|
|
|
continue
|
|
|
emoji = vote_emoji.get(v, "▪️")
|
|
|
st.markdown(
|
|
|
f"**{emoji} {v.capitalize()}** ({len(actors)}): {', '.join(sorted(actors))}"
|
|
|
)
|
|
|
rows_shown = True
|
|
|
if not rows_shown:
|
|
|
st.caption("_Geen stemuitslag beschikbaar_")
|
|
|
except Exception:
|
|
|
pass
|
|
|
|
|
|
|
|
|
def _add_y_direction_annotations(fig: go.Figure) -> None:
|
|
|
"""Add ▲ Progressief / ▼ Conservatief labels above and below the Y axis."""
|
|
|
common = dict(
|
|
|
xref="paper",
|
|
|
yref="paper",
|
|
|
x=-0.07,
|
|
|
showarrow=False,
|
|
|
font=dict(size=11, color="#666666"),
|
|
|
)
|
|
|
fig.add_annotation(**common, y=1.02, text="▲ Progressief", xanchor="center")
|
|
|
fig.add_annotation(**common, y=-0.06, text="▼ Conservatief", xanchor="center")
|
|
|
|
