"""
gui/pages/models.py โ ๐ Models
Reads config/models.json live on every render โ no hardcoding.
Schema: { "cloud": { "linear": {...}, "agentic": {...} },
"local": { "linear": {...}, "agentic": {...} } }
"""
import json
import streamlit as st
import pandas as pd
import plotly.express as px
from pathlib import Path
from gui.config import PROJECT_ROOT, WF_COLORS
from gui.db import q_safe
from gui.helpers import fl
# โโ Theme helpers โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
def _is_dark() -> bool:
return st.session_state.get("theme", "dark") == "dark"
def _tok() -> dict:
if _is_dark():
return dict(
bg0="#0d1117", bg1="#111827", bg2="#1f2937", bg3="#374151",
t1="#f1f5f9", t2="#94a3b8", t3="#475569",
brd="#1f2937", brd2="#374151", accent="#3b82f6",
)
return dict(
bg0="#f3f4f6", bg1="#ffffff", bg2="#f9fafb", bg3="#d1d5db",
t1="#1f2937", t2="#4b5563", t3="#6b7280",
brd="#d1d5db", brd2="#9ca3af", accent="#3b82f6",
)
# โโ Load models.json โ no caching so changes show immediately โโโโโโโโโโโโโโโโโ
def _load_models() -> dict:
for candidate in [
PROJECT_ROOT / "config" / "models.json",
PROJECT_ROOT / "models.json",
]:
if candidate.exists():
try:
return json.loads(candidate.read_text())
except Exception as e:
return {"_error": str(e), "_path": str(candidate)}
return {"_missing": True}
# โโ DB stats keyed by (model_name, workflow_type) โโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
def _load_stats() -> dict:
stats = {}
try:
df, _ = q_safe("""
SELECT e.model_name, r.workflow_type,
COUNT(*) AS runs,
ROUND(AVG(r.total_energy_uj)/1e6, 4) AS avg_j,
ROUND(AVG(r.dynamic_energy_uj)/1e6, 4) AS avg_dyn_j,
ROUND(AVG(r.duration_ns)/1e9, 3) AS avg_dur_s,
ROUND(AVG(r.total_tokens), 1) AS avg_tokens,
ROUND(AVG(CASE WHEN r.total_tokens > 0
THEN r.total_energy_uj / r.total_tokens
END) / 1e3, 4) AS avg_mj_tok,
ROUND(AVG(r.ipc), 3) AS avg_ipc,
ROUND(AVG(r.carbon_g)*1000, 4) AS avg_carbon_mg
FROM runs r
JOIN experiments e ON r.exp_id = e.exp_id
WHERE e.model_name IS NOT NULL
GROUP BY e.model_name, r.workflow_type
""")
if not df.empty:
for _, row in df.iterrows():
stats[(str(row["model_name"]), str(row["workflow_type"]))] = row.to_dict()
except Exception:
pass
return stats
def _find_stat(stats: dict, spec: dict, wf: str) -> dict | None:
"""Match a spec to a stats row. Tries model_id then name."""
for field in ("model_id", "name"):
v = spec.get(field)
if v:
hit = stats.get((str(v), wf))
if hit:
return hit
return None
# โโ Spec block (linear or agentic half of a card) โโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
def _spec_block(spec: dict, wf: str, wf_stats: dict | None, t: dict) -> str:
bg2, bg3 = t["bg2"], t["bg3"]
t1, t2, t3 = t["t1"], t["t2"], t["t3"]
brd = t["brd"]
wf_clr = "#16a34a" if wf == "linear" else "#ef4444"
name = spec.get("name", "โ")
mid = spec.get("model_id", "")
ep = spec.get("api_endpoint", "")
mpath = spec.get("model_path", "")
mtok = spec.get("max_tokens", "โ")
temp = spec.get("temperature", "โ")
tools_s = spec.get("tools_supported", False)
tools = spec.get("tools", [])
def _row(k, v, vc=None):
vc = vc or t2
return (
f"
"
f"{k}"
f"{str(v) if v not in (None,'') else 'โ'}
"
)
html = (
f""
f"
{wf}
"
f"
"
f"{name}
"
)
if mid: html += _row("Model ID", mid)
if ep: html += _row("Endpoint", ep.replace("https://","")[:38])
if mpath: html += _row("Model file", Path(mpath).name)
html += _row("Max tokens", mtok)
html += _row("Temperature", temp)
if tools_s and tools:
html += _row("Tools", "โ " + ", ".join(tools), "#16a34a")
else:
html += _row("Tools", "โ enabled" if tools_s else "โ disabled",
"#16a34a" if tools_s else t3)
# Measured energy section
if wf_stats:
avg_j = wf_stats.get("avg_j", 0) or 0
avg_mj = wf_stats.get("avg_mj_tok", 0) or 0
avg_dur = wf_stats.get("avg_dur_s", 0) or 0
avg_tok = wf_stats.get("avg_tokens", 0) or 0
runs = int(wf_stats.get("runs", 0) or 0)
html += (
f"
"
f"
"
f"Measured ยท {runs} runs ยท {avg_tok:.0f} avg tokens
"
f"
"
)
for lbl, val, unit in [
("Energy", avg_j, "J"),
("mJ/token", avg_mj, "mJ"),
("Duration", avg_dur, "s"),
]:
html += (
f"
"
f"
{lbl}
"
f"
{val:.3f}
"
f"
{unit}
"
f"
"
)
html += "
"
else:
html += (
f"
"
f"Not yet measured
"
)
html += "
"
return html
# โโ Full group card (cloud / local) โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
def _group_card(gkey: str, gcfg: dict, stats: dict, t: dict) -> str:
bg1, bg2, bg3 = t["bg1"], t["bg2"], t["bg3"]
t1, t2, t3 = t["t1"], t["t2"], t["t3"]
brd = t["brd"]
clr = {"cloud": "#38bdf8", "local": "#22c55e"}.get(gkey, "#7c3aed")
icon = {"cloud": "โ", "local": "๐ป" }.get(gkey, "โ")
lin_spec = gcfg.get("linear", {})
age_spec = gcfg.get("agentic", {})
lin_stats = _find_stat(stats, lin_spec, "linear")
age_stats = _find_stat(stats, age_spec, "agentic")
html = (
f""
# header
f"
"
f"{icon}"
f""
f"{gkey.title()} provider"
f"{gkey}"
f"
"
)
html += _spec_block(lin_spec, "linear", lin_stats, t)
html += _spec_block(age_spec, "agentic", age_stats, t)
# Tax multiple if both measured
if lin_stats and age_stats:
lj = lin_stats.get("avg_j") or 0
aj = age_stats.get("avg_j") or 0
if lj > 0:
mult = aj / lj
mc = "#ef4444" if mult >= 2 else "#d97706" if mult >= 1.2 else "#16a34a"
html += (
f"
"
f"
"
f"
Orchestration tax
"
f"
agentic รท linear
"
f"
"
f"
{mult:.2f}ร"
f"
"
)
html += "
"
return html
# โโ Main render โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
def render(ctx: dict = None):
t = _tok()
bg1 = t["bg1"]; bg2 = t["bg2"]; bg3 = t["bg3"]
t1 = t["t1"]; t2 = t["t2"]; t3 = t["t3"]
brd = t["brd"]; brd2 = t["brd2"]; accent = t["accent"]
# โโ Page header โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
h_col, btn_col = st.columns([7, 1])
with h_col:
st.markdown(
f""
f"๐ Models"
f"Apple-to-Apple energy comparison"
f"
",
unsafe_allow_html=True)
with btn_col:
if st.button("โบ Reload", key="models_reload"):
st.rerun() # No cache โ file is always re-read
# โโ Load config live โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
cfg = _load_models()
if cfg.get("_missing"):
st.markdown(
f""
f"config/models.json not found.
"
f"Expected at: "
f""
f"{PROJECT_ROOT}/config/models.json"
f"
",
unsafe_allow_html=True)
return
if cfg.get("_error"):
st.error(f"Error reading models.json: {cfg['_error']}")
return
# Show config path + mod time
cfg_path = PROJECT_ROOT / "config" / "models.json"
_mtime = "โ"
try:
import datetime as _dt
_mtime = _dt.datetime.fromtimestamp(
cfg_path.stat().st_mtime).strftime("%Y-%m-%d %H:%M:%S")
except Exception:
pass
groups = [k for k in cfg
if not k.startswith("_") and isinstance(cfg[k], dict)]
st.markdown(
f""
f"Live from "
f""
f"config/models.json"
f" ยท modified {_mtime}"
f" ยท {len(groups)} provider group{'s' if len(groups) != 1 else ''}: "
f"{', '.join(groups)}
",
unsafe_allow_html=True)
# โโ Model config cards โ one per provider group โโโโโโโโโโโโโโโโโโโโโโโโโโโ
stats = _load_stats()
cols = st.columns(max(len(groups), 1))
for i, gkey in enumerate(groups):
with cols[i]:
st.markdown(_group_card(gkey, cfg[gkey], stats, t),
unsafe_allow_html=True)
st.markdown(
f"",
unsafe_allow_html=True)
# โโ Apple-to-Apple charts โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
st.markdown(
f""
f"Measured comparison โ all runs
",
unsafe_allow_html=True)
_full_df = pd.DataFrame()
try:
_full_df, _ = q_safe("""
SELECT e.model_name, e.provider, r.workflow_type, e.task_name,
COUNT(*) AS runs,
ROUND(AVG(r.total_energy_uj)/1e6, 4) AS avg_energy_j,
ROUND(AVG(r.dynamic_energy_uj)/1e6, 4) AS avg_dynamic_j,
ROUND(AVG(r.duration_ns)/1e9, 3) AS avg_duration_s,
ROUND(AVG(r.total_tokens), 1) AS avg_tokens,
ROUND(AVG(CASE WHEN r.total_tokens > 0
THEN r.total_energy_uj / r.total_tokens
END) / 1e3, 4) AS avg_mj_per_token,
ROUND(AVG(r.ipc), 3) AS avg_ipc,
ROUND(AVG(r.carbon_g)*1000, 4) AS avg_carbon_mg,
ROUND(AVG(r.water_ml), 4) AS avg_water_ml
FROM runs r
JOIN experiments e ON r.exp_id = e.exp_id
WHERE e.model_name IS NOT NULL
GROUP BY e.model_name, e.provider, r.workflow_type, e.task_name
ORDER BY e.provider, e.model_name, r.workflow_type
""")
except Exception:
pass
if _full_df.empty:
st.markdown(
f""
f"No run data yet โ run experiments to see charts here.
",
unsafe_allow_html=True)
return
# Task filter
_, fc = st.columns([4, 1])
with fc:
_tasks = sorted(_full_df.task_name.dropna().unique().tolist())
_sel = st.selectbox("Task", ["all"] + _tasks, key="models_task")
_filt = (_full_df if _sel == "all"
else _full_df[_full_df.task_name == _sel]).copy()
_filt["model_wf"] = (
_filt["model_name"].astype(str) + " ยท " +
_filt["workflow_type"].astype(str))
_pl = dict(
paper_bgcolor=bg1, plot_bgcolor=bg2,
font=dict(color=t1, size=10),
margin=dict(t=20, b=70, l=50, r=10),
legend=dict(bgcolor=bg1, bordercolor=brd,
borderwidth=0.5, font=dict(color=t2)),
height=260)
for (ch_l, ch_r), (col_l, col_r), (lbl_l, lbl_r) in [
(("avg_energy_j", "avg_mj_per_token"),
st.columns(2),
("Energy (J) โ model ร workflow", "mJ / token โ model ร workflow")),
(("avg_duration_s", "avg_carbon_mg"),
st.columns(2),
("Avg duration (s)", "Carbon footprint (mg COโ)")),
]:
for col, metric, lbl in [(ch_l, col_l, lbl_l), (ch_r, col_r, lbl_r)]:
pass # loop structure โ see below
# Draw charts explicitly (avoid loop variable confusion)
ch1, ch2 = st.columns(2)
for col_ctx, metric, lbl in [
(ch1, "avg_energy_j", "Energy (J) โ model ร workflow"),
(ch2, "avg_mj_per_token","mJ / token โ model ร workflow"),
]:
with col_ctx:
st.markdown(
f"{lbl}
", unsafe_allow_html=True)
fig = px.bar(
_filt.groupby(["model_wf","workflow_type"])[metric]
.mean().reset_index(),
x="model_wf", y=metric, color="workflow_type",
barmode="group", color_discrete_map=WF_COLORS,
labels={metric: lbl, "model_wf": ""})
fig.update_xaxes(tickangle=30)
fig.update_layout(**_pl)
st.plotly_chart(fl(fig), use_container_width=True)
ch3, ch4 = st.columns(2)
for col_ctx, metric, lbl in [
(ch3, "avg_duration_s", "Avg duration (s)"),
(ch4, "avg_carbon_mg", "Carbon footprint (mg COโ)"),
]:
with col_ctx:
st.markdown(
f"{lbl}
", unsafe_allow_html=True)
fig = px.bar(
_filt.groupby(["model_wf","workflow_type"])[metric]
.mean().reset_index(),
x="model_wf", y=metric, color="workflow_type",
barmode="group", color_discrete_map=WF_COLORS,
labels={metric: lbl, "model_wf": ""})
fig.update_xaxes(tickangle=30)
fig.update_layout(**_pl)
st.plotly_chart(fl(fig), use_container_width=True)
# โโ Full matrix โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
st.markdown(
f"",
unsafe_allow_html=True)
st.markdown(
f"Full comparison matrix
",
unsafe_allow_html=True)
_show = [c for c in [
"model_name","provider","workflow_type","task_name","runs",
"avg_energy_j","avg_dynamic_j","avg_duration_s","avg_tokens",
"avg_mj_per_token","avg_ipc","avg_carbon_mg","avg_water_ml"]
if c in _filt.columns]
st.dataframe(_filt[_show].round(4),
use_container_width=True, hide_index=True)