Upload app.py

app.py

@@ -1,498 +1,1362 @@
-from __future__ import annotations
-from datetime import datetime, timedelta
-
-"""Sundew Diabetes Commons – holistic, open Streamlit experience."""
-
-
-import json
-import logging
-import math
-import time
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
-
-import numpy as np
-import pandas as pd
-import streamlit as st
-from sklearn.linear_model import LogisticRegression
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import StandardScaler
-
-try:
-    from sundew import SundewAlgorithm  # type: ignore[attr-defined]
-    from sundew.config import SundewConfig
-    from sundew.config_presets import get_preset
-
-    _HAS_SUNDEW = True
-except Exception:  # fallback when package is unavailable
-    SundewAlgorithm = None  # type: ignore
-    SundewConfig = object  # type: ignore
-
-    def get_preset(_: str) -> Any:  # type: ignore
-        return None
-
-    _HAS_SUNDEW = False
-
-LOGGER = logging.getLogger("sundew.diabetes.commons")
-
-
-@dataclass
-class SundewGateConfig:
-    target_activation: float = 0.22
-    temperature: float = 0.08
-    mode: str = "tuned_v2"
-    use_native: bool = True
-
-
-def _build_sundew_runtime(config: SundewGateConfig) -> Optional[SundewAlgorithm]:
-    if not (config.use_native and _HAS_SUNDEW and SundewAlgorithm is not None):
-        return None
-    try:
-        preset = get_preset(config.mode)
-    except Exception:
-        preset = SundewConfig()  # type: ignore
-    for attr, value in (
-        ("target_activation_rate", config.target_activation),
-        ("gate_temperature", config.temperature),
-    ):
-        try:
-            setattr(preset, attr, value)
-        except Exception:
-            pass
-    for constructor in (
-        lambda: SundewAlgorithm(preset),  # type: ignore[arg-type]
-        lambda: SundewAlgorithm(config=preset),  # type: ignore[arg-type]
-        lambda: SundewAlgorithm(),
-    ):
-        try:
-            return constructor()
-        except Exception:
-            continue
-    return None
-
-
-class AdaptiveGate:
-    """Adapter that hides Sundew/Fallback branching."""
-
-    def __init__(self, config: SundewGateConfig) -> None:
-        self.config = config
-        self._ema = 0.0
-        self._tau = float(np.clip(config.target_activation, 0.05, 0.95))
-        self._alpha = 0.05
-        self.sundew: Optional[SundewAlgorithm] = _build_sundew_runtime(config)
-
-    def decide(self, score: float) -> bool:
-        if self.sundew is not None:
-            for attr in ("decide", "step", "open"):
-                fn = getattr(self.sundew, attr, None)
-                if callable(fn):
-                    try:
-                        return bool(fn(score))
-                    except Exception:
-                        continue
-        normalized = float(np.clip(score / 1.4, 0.0, 1.0))
-        temperature = max(self.config.temperature, 0.02)
-        probability = 1.0 / (1.0 + math.exp(-(normalized - self._tau) / temperature))
-        fired = bool(np.random.rand() < probability)
-        self._ema = (1 - self._alpha) * self._ema + self._alpha * (
-            1.0 if fired else 0.0
-        )
-        self._tau += 0.05 * (self.config.target_activation - self._ema)
-        self._tau = float(np.clip(self._tau, 0.05, 0.95))
-        return fired
-
-
-def load_example_dataset(n_rows: int = 720) -> pd.DataFrame:
-    rng = np.random.default_rng(17)
-    t0 = pd.Timestamp.utcnow().floor("5min") - pd.Timedelta(minutes=5 * n_rows)
-    timestamps = [t0 + pd.Timedelta(minutes=5 * i) for i in range(n_rows)]
-    base = 118 + 28 * np.sin(np.linspace(0, 7 * math.pi, n_rows))
-    noise = rng.normal(0, 12, n_rows)
-    meals = (rng.random(n_rows) < 0.05).astype(float) * rng.normal(50, 18, n_rows).clip(
-        0, 150
-    )
-    insulin = (rng.random(n_rows) < 0.03).astype(float) * rng.normal(
-        4.2, 1.5, n_rows
-    ).clip(0, 10)
-    steps = rng.integers(0, 200, size=n_rows)
-    heart_rate = 68 + (steps > 90) * rng.integers(20, 45, size=n_rows)
-    sleep_flag = (rng.random(n_rows) < 0.12).astype(float)
-    stress_index = rng.uniform(0, 1, n_rows)
-    glucose = base + noise
-    for i in range(n_rows):
-        if i >= 6:
-            glucose[i] += 0.4 * meals[i - 6 : i].sum() / 6
-        if i >= 4:
-            glucose[i] -= 1.2 * insulin[i - 4 : i].sum() / 4
-        if steps[i] > 100:
-            glucose[i] -= 15
-    glucose[180:200] = rng.normal(62, 5, 20)
-    glucose[350:365] = rng.normal(210, 10, 15)
-    return pd.DataFrame(
-        {
-            "timestamp": timestamps,
-            "glucose_mgdl": np.round(np.clip(glucose, 40, 350), 1),
-            "carbs_g": np.round(meals, 1),
-            "insulin_units": np.round(insulin, 1),
-            "steps": steps.astype(int),
-            "hr": (heart_rate + rng.normal(0, 5, n_rows)).round().astype(int),
-            "sleep_flag": sleep_flag,
-            "stress_index": stress_index,
-        }
-    )
-
-
-def compute_features(df: pd.DataFrame) -> pd.DataFrame:
-    df = df.copy().sort_values("timestamp").reset_index(drop=True)
-    df["timestamp"] = pd.to_datetime(df["timestamp"], utc=True)
-    df["glucose_prev"] = df["glucose_mgdl"].shift(1)
-    dt = (
-        df["timestamp"].astype("int64") - df["timestamp"].shift(1).astype("int64")
-    ) / 60e9
-    df["roc_mgdl_min"] = (df["glucose_mgdl"] - df["glucose_prev"]) / dt
-    df["roc_mgdl_min"] = df["roc_mgdl_min"].replace([np.inf, -np.inf], 0.0).fillna(0.0)
-    ema = df["glucose_mgdl"].ewm(span=48, adjust=False).mean()
-    df["deviation"] = (df["glucose_mgdl"] - ema).fillna(0.0)
-    df["iob_proxy"] = df["insulin_units"].rolling(12, min_periods=1).sum() / 12.0
-    df["cob_proxy"] = df["carbs_g"].rolling(12, min_periods=1).sum() / 12.0
-    df["variability"] = df["glucose_mgdl"].rolling(24, min_periods=2).std().fillna(0.0)
-    df["activity_factor"] = (df["steps"] / 200.0 + df["hr"] / 160.0).clip(0, 1)
-    df["sleep_flag"] = df["sleep_flag"].fillna(0.0) if "sleep_flag" in df else 0.0
-    df["stress_index"] = df["stress_index"].fillna(0.5) if "stress_index" in df else 0.5
-    return df[
-        [
-            "timestamp",
-            "glucose_mgdl",
-            "roc_mgdl_min",
-            "deviation",
-            "iob_proxy",
-            "cob_proxy",
-            "variability",
-            "activity_factor",
-            "sleep_flag",
-            "stress_index",
-        ]
-    ].copy()
-
-
-def lightweight_score(row: pd.Series) -> float:
-    glucose = row["glucose_mgdl"]
-    roc = row["roc_mgdl_min"]
-    deviation = row["deviation"]
-    iob = row["iob_proxy"]
-    cob = row["cob_proxy"]
-    stress = row["stress_index"]
-    score = 0.0
-    score += max(0.0, (glucose - 180) / 80)
-    score += max(0.0, (70 - glucose) / 30)
-    score += abs(roc) / 6.0
-    score += abs(deviation) / 100.0
-    score += stress * 0.4
-    score += max(0.0, (cob - iob) * 0.04)
-    return float(np.clip(score, 0.0, 1.4))
-
-
-def train_simple_model(df: pd.DataFrame):
-    features = df[
-        [
-            "glucose_mgdl",
-            "roc_mgdl_min",
-            "iob_proxy",
-            "cob_proxy",
-            "activity_factor",
-            "variability",
-        ]
-    ]
-    labels = (df["glucose_mgdl"] > 180).astype(int)
-    model = Pipeline(
-        [
-            ("scaler", StandardScaler()),
-            ("clf", LogisticRegression(max_iter=400, class_weight="balanced")),
-        ]
-    )
-    try:
-        model.fit(features, labels)
-        return model
-    except Exception:
-        return None
-
-
-def render_overview(
-    results: pd.DataFrame,
-    alerts: List[Dict[str, Any]],
-    gate_config: SundewGateConfig,
-) -> None:
-    total = len(results)
-    activations = int(results["activated"].sum())
-    activation_rate = activations / max(total, 1)
-    energy_savings = max(0.0, 1.0 - activation_rate)
-    col_a, col_b, col_c, col_d = st.columns(4)
-    col_a.metric("Events", f"{total}")
-    col_b.metric("Heavy activations", f"{activations} ({activation_rate:.1%})")
-    col_c.metric("Estimated energy saved", f"{energy_savings:.1%}")
-    col_d.metric("Alerts", f"{len(alerts)}")
-    if gate_config.use_native and _HAS_SUNDEW:
-        st.caption(
-            "Energy savings follow 1 − activation rate. With native Sundew gating we target "
-            f"≈{gate_config.target_activation:.0%} activations, so savings approach "
-            f"{1 - gate_config.target_activation:.0%}."
-        )
-    else:
-        st.warning(
-            "Fallback gate active – heavy inference runs frequently, so savings mirror the observed activation rate."
-        )
-    with st.expander("Recent alerts", expanded=False):
-        if alerts:
-            st.table(pd.DataFrame(alerts).tail(10))
-        else:
-            st.info("No high-risk alerts in this window.")
-    st.area_chart(results.set_index("timestamp")["glucose_mgdl"], height=220)
-
-
-def render_treatment_plan(medications: Dict[str, Any], next_visit: str) -> None:
-    st.subheader("Full-cycle treatment support")
-    st.write(
-        "Upload or edit medication schedules, insulin titration guidance, and clinician notes."
-    )
-    st.json(medications, expanded=False)
-    st.caption(f"Next scheduled review: {next_visit}")
-
-
-def render_lifestyle_support(results: pd.DataFrame) -> None:
-    st.subheader("Lifestyle & wellbeing")
-    recent = results.tail(96).copy()
-    avg_glucose = recent["glucose_mgdl"].mean()
-    active_minutes = int((recent["activity_factor"] > 0.4).sum() * 5)
-    col1, col2 = st.columns(2)
-    col1.metric("Average glucose (8h)", f"{avg_glucose:.1f} mg/dL")
-    col2.metric("Active minutes", f"{active_minutes} min")
-    st.markdown(
-        """
-- Aim for gentle movement every hour you are awake.
-- Pair carbohydrates with protein/fiber to smooth spikes.
-- Sleep flagged recently? Try 10-minute breathing before bed.
-- Journal one gratitude moment—stress strongly shapes risk.
-"""
-    )
-
-
-def render_community_actions() -> Dict[str, List[str]]:
-    st.subheader("Community impact")
-    st.write(
-        "Invite families, caregivers, and clinics to the commons. Set up alerts, shared logs, and outreach."
-    )
-    contact_list = [
-        "SMS: +233-200-000-111",
-        "WhatsApp: Care Circle Group",
-        "Clinic portal: sundew.health/community",
-    ]
-    st.table(pd.DataFrame({"Support channel": contact_list}))
-    return {
-        "Desired partners": ["Rural clinics", "Youth ambassadors", "Nutrition co-ops"],
-        "Needs": ["Smartphone grants", "Solar charging kits", "Translation volunteers"],
-    }
-
-
-def render_telemetry(results: pd.DataFrame, telemetry: List[Dict[str, Any]]) -> None:
-    st.subheader("Telemetry & export")
-    st.write(
-        "Download event-level telemetry for validation, research, or regulatory reporting."
-    )
-    st.caption(
-        "Energy savings are computed as 1 minus the observed activation rate. When the gate stays mostly open, savings naturally trend toward zero."
-    )
-    json_payload = json.dumps(telemetry, default=str, indent=2)
-    st.download_button(
-        label="Download telemetry (JSON)",
-        data=json_payload,
-        file_name="sundew_diabetes_telemetry.json",
-        mime="application/json",
-    )
-    st.dataframe(results.tail(100), use_container_width=True)
-
-
-def main() -> None:
-    st.set_page_config(
-        page_title="Sundew Diabetes Commons", layout="wide", page_icon="🕊"
-    )
-    st.title("Sundew Diabetes Commons")
-    st.caption(
-        "Open, compassionate diabetes care—monitoring, treatment, lifestyle, community."
-    )
-
-    st.sidebar.header("Load data")
-    uploaded = st.sidebar.file_uploader("CGM / diary CSV", type=["csv"])
-    use_example = st.sidebar.checkbox("Use synthetic example", True)
-
-    st.sidebar.header("Sundew configuration")
-    use_native = st.sidebar.checkbox(
-        "Use native Sundew gating",
-        value=_HAS_SUNDEW,
-        help="Disable to demo the lightweight fallback gate only.",
-    )
-    target_activation = st.sidebar.slider("Target activation", 0.05, 0.90, 0.22, 0.01)
-    temperature = st.sidebar.slider("Gate temperature", 0.02, 0.50, 0.08, 0.01)
-    mode = st.sidebar.selectbox(
-        "Preset", ["tuned_v2", "conservative", "aggressive", "auto_tuned"], index=0
-    )
-
-    if uploaded is not None:
-        df = pd.read_csv(uploaded)
-    elif use_example:
-        df = load_example_dataset()
-    else:
-        st.stop()
-
-    features = compute_features(df)
-    model = train_simple_model(features)
-    gate_config = SundewGateConfig(
-        target_activation=target_activation,
-        temperature=temperature,
-        mode=mode,
-        use_native=use_native,
-    )
-    gate = AdaptiveGate(gate_config)
-
-    telemetry: List[Dict[str, Any]] = []
-    records: List[Dict[str, Any]] = []
-    alerts: List[Dict[str, Any]] = []
-
-    progress = st.progress(0)
-    status = st.empty()
-    for idx, row in enumerate(features.itertuples(index=False), start=1):
-        score = lightweight_score(pd.Series(row._asdict()))
-        should_run = gate.decide(score)
-        risk_proba = None
-        if should_run and model is not None:
-            sample = np.array(
-                [
-                    [
-                        row.glucose_mgdl,
-                        row.roc_mgdl_min,
-                        row.iob_proxy,
-                        row.cob_proxy,
-                        row.activity_factor,
-                        row.variability,
-                    ]
-                ]
-            )
-            try:
-                risk_proba = float(model.predict_proba(sample)[0, 1])  # type: ignore[index]
-            except Exception:
-                risk_proba = None
-        if risk_proba is not None and risk_proba >= 0.6:
-            alerts.append(
-                {
-                    "timestamp": row.timestamp,
-                    "glucose": row.glucose_mgdl,
-                    "risk": risk_proba,
-                    "message": "Check CGM, hydrate, plan balanced snack/insulin",
-                }
-            )
-        records.append(
-            {
-                "timestamp": row.timestamp,
-                "glucose_mgdl": row.glucose_mgdl,
-                "roc_mgdl_min": row.roc_mgdl_min,
-                "deviation": row.deviation,
-                "iob_proxy": row.iob_proxy,
-                "cob_proxy": row.cob_proxy,
-                "variability": row.variability,
-                "activity_factor": row.activity_factor,
-                "score": score,
-                "activated": should_run,
-                "risk_proba": risk_proba,
-            }
-        )
-        telemetry.append(
-            {
-                "timestamp": str(row.timestamp),
-                "score": score,
-                "activated": should_run,
-                "risk_proba": risk_proba,
-            }
-        )
-        progress.progress(idx / len(features))
-        status.text(f"Processing event {idx}/{len(features)}")
-    progress.empty()
-    status.empty()
-
-    results = pd.DataFrame(records)
-
-
-tabs = st.tabs(["Overview", "Treatment", "Lifestyle", "Community", "Telemetry"])
-with tabs[0]:
-    render_overview(results, alerts, gate_config)
-with tabs[1]:
-    st.subheader("Full-cycle treatment support")
-    default_plan = {
-        "Insulin": {
-            "Basal": "14u glargine at 21:00",
-            "Bolus": "1u per 10g carbs + correction 1u per 40 mg/dL over 140",
-        },
-        "Oral medications": {
-            "Metformin": "500mg breakfast + 500mg dinner",
-            "Empagliflozin": "10mg once daily (if eGFR > 45)",
-        },
-        "Monitoring": [
-            "CGM sensor change every 10 days",
-            "Morning fasted CGM calibration",
-            "Weekly telehealth coaching",
-            "Quarterly in-person clinician review",
-        ],
-        "Safety plan": [
-            "Carry glucose tabs + glucagon kit",
-            "Emergency contact: +233-200-000-888",
-        ],
-        "Lifestyle": [
-            "30 min brisk walk 5x/week",
-            "Bedtime snack if glucose < 110 mg/dL",
-            "Hydrate 2L water daily unless contraindicated",
-        ],
-    }
-    st.caption(
-        "Upload or edit schedules, medication titration guidance, and clinician notes."
-    )
-    uploaded_plan = st.file_uploader(
-        "Optional plan JSON", type=["json"], key="plan_uploader"
-    )
-    plan_text = st.text_area(
-        "Edit plan JSON",
-        json.dumps(default_plan, indent=2),
-        height=240,
-    )
-    plan_data = default_plan
-    if uploaded_plan is not None:
-        try:
-            plan_data = json.load(uploaded_plan)
-        except Exception as exc:
-            st.error(f"Could not parse uploaded plan JSON: {exc}")
-            plan_data = default_plan
-    else:
-        try:
-            plan_data = json.loads(plan_text)
-        except Exception as exc:
-            st.warning(f"Using default plan because text could not be parsed: {exc}")
-            plan_data = default_plan
-    next_visit = (datetime.utcnow() + timedelta(days=30)).strftime(
-        "%Y-%m-%d (telehealth)"
-    )
-    render_treatment_plan(plan_data, next_visit=next_visit)
-with tabs[2]:
-    render_lifestyle_support(results)
-with tabs[3]:
-    community_items = render_community_actions()
-    st.json(community_items, expanded=False)
-with tabs[4]:
-    render_telemetry(results, telemetry)
-    st.sidebar.markdown("---")
-    status_text = (
-        "native gating"
-        if gate_config.use_native and gate.sundew is not None
-        else "fallback gate"
-    )
-    st.sidebar.caption(f"Sundew status: {status_text}")
-
-
-if __name__ == "__main__":
-    main()
+from __future__ import annotations
+
+
+from datetime import datetime, timedelta
+
+
+
+
+
+"""Sundew Diabetes Commons – holistic, open Streamlit experience."""
+
+
+
+
+
+
+
+
+import json
+
+
+import logging
+
+
+import math
+
+
+import time
+
+
+from dataclasses import dataclass
+
+
+from typing import Any, Dict, List, Optional, Tuple
+
+
+
+
+
+import numpy as np
+
+
+import pandas as pd
+
+
+import streamlit as st
+
+
+from sklearn.linear_model import LogisticRegression
+
+
+from sklearn.pipeline import Pipeline
+
+
+from sklearn.preprocessing import StandardScaler
+
+
+
+
+
+try:
+
+
+    from sundew import SundewAlgorithm  # type: ignore[attr-defined]
+
+
+    from sundew.config import SundewConfig
+
+
+    from sundew.config_presets import get_preset
+
+
+
+
+
+    _HAS_SUNDEW = True
+
+
+except Exception:  # fallback when package is unavailable
+
+
+    SundewAlgorithm = None  # type: ignore
+
+
+    SundewConfig = object  # type: ignore
+
+
+
+
+
+    def get_preset(_: str) -> Any:  # type: ignore
+
+
+        return None
+
+
+
+
+
+    _HAS_SUNDEW = False
+
+
+
+
+
+LOGGER = logging.getLogger("sundew.diabetes.commons")
+
+
+
+
+
+
+
+
+@dataclass
+
+
+class SundewGateConfig:
+
+
+    target_activation: float = 0.22
+
+
+    temperature: float = 0.08
+
+
+    mode: str = "tuned_v2"
+
+
+    use_native: bool = True
+
+
+
+
+
+
+
+
+def _build_sundew_runtime(config: SundewGateConfig) -> Optional[SundewAlgorithm]:
+
+
+    if not (config.use_native and _HAS_SUNDEW and SundewAlgorithm is not None):
+
+
+        return None
+
+
+    try:
+
+
+        preset = get_preset(config.mode)
+
+
+    except Exception:
+
+
+        preset = SundewConfig()  # type: ignore
+
+
+    for attr, value in (
+
+
+        ("target_activation_rate", config.target_activation),
+
+
+        ("gate_temperature", config.temperature),
+
+
+    ):
+
+
+        try:
+
+
+            setattr(preset, attr, value)
+
+
+        except Exception:
+
+
+            pass
+
+
+    for constructor in (
+
+
+        lambda: SundewAlgorithm(preset),  # type: ignore[arg-type]
+
+
+        lambda: SundewAlgorithm(config=preset),  # type: ignore[arg-type]
+
+
+        lambda: SundewAlgorithm(),
+
+
+    ):
+
+
+        try:
+
+
+            return constructor()
+
+
+        except Exception:
+
+
+            continue
+
+
+    return None
+
+
+
+
+
+
+
+
+class AdaptiveGate:
+
+
+    """Adapter that hides Sundew/Fallback branching."""
+
+
+
+
+
+    def __init__(self, config: SundewGateConfig) -> None:
+
+
+        self.config = config
+
+
+        self._ema = 0.0
+
+
+        self._tau = float(np.clip(config.target_activation, 0.05, 0.95))
+
+
+        self._alpha = 0.05
+
+
+        self.sundew: Optional[SundewAlgorithm] = _build_sundew_runtime(config)
+
+
+
+
+
+    def decide(self, score: float) -> bool:
+
+
+        if self.sundew is not None:
+
+
+            for attr in ("decide", "step", "open"):
+
+
+                fn = getattr(self.sundew, attr, None)
+
+
+                if callable(fn):
+
+
+                    try:
+
+
+                        return bool(fn(score))
+
+
+                    except Exception:
+
+
+                        continue
+
+
+        normalized = float(np.clip(score / 1.4, 0.0, 1.0))
+
+
+        temperature = max(self.config.temperature, 0.02)
+
+
+        probability = 1.0 / (1.0 + math.exp(-(normalized - self._tau) / temperature))
+
+
+        fired = bool(np.random.rand() < probability)
+
+
+        self._ema = (1 - self._alpha) * self._ema + self._alpha * (
+
+
+            1.0 if fired else 0.0
+
+
+        )
+
+
+        self._tau += 0.05 * (self.config.target_activation - self._ema)
+
+
+        self._tau = float(np.clip(self._tau, 0.05, 0.95))
+
+
+        return fired
+
+
+
+
+
+
+
+
+def load_example_dataset(n_rows: int = 720) -> pd.DataFrame:
+
+
+    rng = np.random.default_rng(17)
+
+
+    t0 = pd.Timestamp.utcnow().floor("5min") - pd.Timedelta(minutes=5 * n_rows)
+
+
+    timestamps = [t0 + pd.Timedelta(minutes=5 * i) for i in range(n_rows)]
+
+
+    base = 118 + 28 * np.sin(np.linspace(0, 7 * math.pi, n_rows))
+
+
+    noise = rng.normal(0, 12, n_rows)
+
+
+    meals = (rng.random(n_rows) < 0.05).astype(float) * rng.normal(50, 18, n_rows).clip(
+
+
+        0, 150
+
+
+    )
+
+
+    insulin = (rng.random(n_rows) < 0.03).astype(float) * rng.normal(
+
+
+        4.2, 1.5, n_rows
+
+
+    ).clip(0, 10)
+
+
+    steps = rng.integers(0, 200, size=n_rows)
+
+
+    heart_rate = 68 + (steps > 90) * rng.integers(20, 45, size=n_rows)
+
+
+    sleep_flag = (rng.random(n_rows) < 0.12).astype(float)
+
+
+    stress_index = rng.uniform(0, 1, n_rows)
+
+
+    glucose = base + noise
+
+
+    for i in range(n_rows):
+
+
+        if i >= 6:
+
+
+            glucose[i] += 0.4 * meals[i - 6 : i].sum() / 6
+
+
+        if i >= 4:
+
+
+            glucose[i] -= 1.2 * insulin[i - 4 : i].sum() / 4
+
+
+        if steps[i] > 100:
+
+
+            glucose[i] -= 15
+
+
+    glucose[180:200] = rng.normal(62, 5, 20)
+
+
+    glucose[350:365] = rng.normal(210, 10, 15)
+
+
+    return pd.DataFrame(
+
+
+        {
+
+
+            "timestamp": timestamps,
+
+
+            "glucose_mgdl": np.round(np.clip(glucose, 40, 350), 1),
+
+
+            "carbs_g": np.round(meals, 1),
+
+
+            "insulin_units": np.round(insulin, 1),
+
+
+            "steps": steps.astype(int),
+
+
+            "hr": (heart_rate + rng.normal(0, 5, n_rows)).round().astype(int),
+
+
+            "sleep_flag": sleep_flag,
+
+
+            "stress_index": stress_index,
+
+
+        }
+
+
+    )
+
+
+
+
+
+
+
+
+def compute_features(df: pd.DataFrame) -> pd.DataFrame:
+
+
+    df = df.copy().sort_values("timestamp").reset_index(drop=True)
+
+
+    df["timestamp"] = pd.to_datetime(df["timestamp"], utc=True)
+
+
+    df["glucose_prev"] = df["glucose_mgdl"].shift(1)
+
+
+    dt = (
+
+
+        df["timestamp"].astype("int64") - df["timestamp"].shift(1).astype("int64")
+
+
+    ) / 60e9
+
+
+    df["roc_mgdl_min"] = (df["glucose_mgdl"] - df["glucose_prev"]) / dt
+
+
+    df["roc_mgdl_min"] = df["roc_mgdl_min"].replace([np.inf, -np.inf], 0.0).fillna(0.0)
+
+
+    ema = df["glucose_mgdl"].ewm(span=48, adjust=False).mean()
+
+
+    df["deviation"] = (df["glucose_mgdl"] - ema).fillna(0.0)
+
+
+    df["iob_proxy"] = df["insulin_units"].rolling(12, min_periods=1).sum() / 12.0
+
+
+    df["cob_proxy"] = df["carbs_g"].rolling(12, min_periods=1).sum() / 12.0
+
+
+    df["variability"] = df["glucose_mgdl"].rolling(24, min_periods=2).std().fillna(0.0)
+
+
+    df["activity_factor"] = (df["steps"] / 200.0 + df["hr"] / 160.0).clip(0, 1)
+
+
+    df["sleep_flag"] = df["sleep_flag"].fillna(0.0) if "sleep_flag" in df else 0.0
+
+
+    df["stress_index"] = df["stress_index"].fillna(0.5) if "stress_index" in df else 0.5
+
+
+    return df[
+
+
+        [
+
+
+            "timestamp",
+
+
+            "glucose_mgdl",
+
+
+            "roc_mgdl_min",
+
+
+            "deviation",
+
+
+            "iob_proxy",
+
+
+            "cob_proxy",
+
+
+            "variability",
+
+
+            "activity_factor",
+
+
+            "sleep_flag",
+
+
+            "stress_index",
+
+
+        ]
+
+
+    ].copy()
+
+
+
+
+
+
+
+
+def lightweight_score(row: pd.Series) -> float:
+
+
+    glucose = row["glucose_mgdl"]
+
+
+    roc = row["roc_mgdl_min"]
+
+
+    deviation = row["deviation"]
+
+
+    iob = row["iob_proxy"]
+
+
+    cob = row["cob_proxy"]
+
+
+    stress = row["stress_index"]
+
+
+    score = 0.0
+
+
+    score += max(0.0, (glucose - 180) / 80)
+
+
+    score += max(0.0, (70 - glucose) / 30)
+
+
+    score += abs(roc) / 6.0
+
+
+    score += abs(deviation) / 100.0
+
+
+    score += stress * 0.4
+
+
+    score += max(0.0, (cob - iob) * 0.04)
+
+
+    return float(np.clip(score, 0.0, 1.4))
+
+
+
+
+
+
+
+
+def train_simple_model(df: pd.DataFrame):
+
+
+    features = df[
+
+
+        [
+
+
+            "glucose_mgdl",
+
+
+            "roc_mgdl_min",
+
+
+            "iob_proxy",
+
+
+            "cob_proxy",
+
+
+            "activity_factor",
+
+
+            "variability",
+
+
+        ]
+
+
+    ]
+
+
+    labels = (df["glucose_mgdl"] > 180).astype(int)
+
+
+    model = Pipeline(
+
+
+        [
+
+
+            ("scaler", StandardScaler()),
+
+
+            ("clf", LogisticRegression(max_iter=400, class_weight="balanced")),
+
+
+        ]
+
+
+    )
+
+
+    try:
+
+
+        model.fit(features, labels)
+
+
+        return model
+
+
+    except Exception:
+
+
+        return None
+
+
+
+
+
+
+
+
+def render_overview(
+
+
+    results: pd.DataFrame,
+
+
+    alerts: List[Dict[str, Any]],
+
+
+    gate_config: SundewGateConfig,
+
+
+) -> None:
+
+
+    total = len(results)
+
+
+    activations = int(results["activated"].sum())
+
+
+    activation_rate = activations / max(total, 1)
+
+
+    energy_savings = max(0.0, 1.0 - activation_rate)
+
+
+    col_a, col_b, col_c, col_d = st.columns(4)
+
+
+    col_a.metric("Events", f"{total}")
+
+
+    col_b.metric("Heavy activations", f"{activations} ({activation_rate:.1%})")
+
+
+    col_c.metric("Estimated energy saved", f"{energy_savings:.1%}")
+
+
+    col_d.metric("Alerts", f"{len(alerts)}")
+
+
+    if gate_config.use_native and _HAS_SUNDEW:
+
+
+        st.caption(
+
+
+            "Energy savings follow 1 − activation rate. With native Sundew gating we target "
+
+
+            f"≈{gate_config.target_activation:.0%} activations, so savings approach "
+
+
+            f"{1 - gate_config.target_activation:.0%}."
+
+
+        )
+
+
+    else:
+
+
+        st.warning(
+
+
+            "Fallback gate active – heavy inference runs frequently, so savings mirror the observed activation rate."
+
+
+        )
+
+
+    with st.expander("Recent alerts", expanded=False):
+
+
+        if alerts:
+
+
+            st.table(pd.DataFrame(alerts).tail(10))
+
+
+        else:
+
+
+            st.info("No high-risk alerts in this window.")
+
+
+    st.area_chart(results.set_index("timestamp")["glucose_mgdl"], height=220)
+
+
+
+
+
+
+
+
+def render_treatment_plan(medications: Dict[str, Any], next_visit: str) -> None:
+
+
+        st.subheader("Full-cycle treatment support")
+
+
+    st.write(
+
+
+        "Upload or edit medication schedules, insulin titration guidance, and clinician notes."
+
+
+    )
+
+
+        st.json(medications, expanded=False)
+
+
+        st.caption(f"Next scheduled review: {next_visit}")
+
+
+
+
+
+
+
+
+def render_lifestyle_support(results: pd.DataFrame) -> None:
+
+
+    st.subheader("Lifestyle & wellbeing")
+
+
+    recent = results.tail(96).copy()
+
+
+    avg_glucose = recent["glucose_mgdl"].mean()
+
+
+    active_minutes = int((recent["activity_factor"] > 0.4).sum() * 5)
+
+
+    col1, col2 = st.columns(2)
+
+
+    col1.metric("Average glucose (8h)", f"{avg_glucose:.1f} mg/dL")
+
+
+    col2.metric("Active minutes", f"{active_minutes} min")
+
+
+    st.markdown(
+
+
+        """
+
+
+- Aim for gentle movement every hour you are awake.
+
+
+- Pair carbohydrates with protein/fiber to smooth spikes.
+
+
+- Sleep flagged recently? Try 10-minute breathing before bed.
+
+
+- Journal one gratitude moment—stress strongly shapes risk.
+
+
+"""
+
+
+    )
+
+
+
+
+
+
+
+
+def render_community_actions() -> Dict[str, List[str]]:
+
+
+    st.subheader("Community impact")
+
+
+    st.write(
+
+
+        "Invite families, caregivers, and clinics to the commons. Set up alerts, shared logs, and outreach."
+
+
+    )
+
+
+    contact_list = [
+
+
+        "SMS: +233-200-000-111",
+
+
+        "WhatsApp: Care Circle Group",
+
+
+        "Clinic portal: sundew.health/community",
+
+
+    ]
+
+
+    st.table(pd.DataFrame({"Support channel": contact_list}))
+
+
+    return {
+
+
+        "Desired partners": ["Rural clinics", "Youth ambassadors", "Nutrition co-ops"],
+
+
+        "Needs": ["Smartphone grants", "Solar charging kits", "Translation volunteers"],
+
+
+    }
+
+
+
+
+
+
+
+
+def render_telemetry(results: pd.DataFrame, telemetry: List[Dict[str, Any]]) -> None:
+
+
+    st.subheader("Telemetry & export")
+
+
+    st.write(
+
+
+        "Download event-level telemetry for validation, research, or regulatory reporting."
+
+
+    )
+
+
+        st.caption(
+
+
+        "Energy savings are computed as 1 minus the observed activation rate. When the gate stays mostly open, savings naturally trend toward zero."
+
+
+    )
+
+
+    json_payload = json.dumps(telemetry, default=str, indent=2)
+
+
+    st.download_button(
+
+
+        label="Download telemetry (JSON)",
+
+
+        data=json_payload,
+
+
+        file_name="sundew_diabetes_telemetry.json",
+
+
+        mime="application/json",
+
+
+    )
+
+
+    st.dataframe(results.tail(100), use_container_width=True)
+
+
+
+
+
+
+
+
+def main() -> None:
+
+
+    st.set_page_config(
+
+
+        page_title="Sundew Diabetes Commons", layout="wide", page_icon="🕊"
+
+
+    )
+
+
+    st.title("Sundew Diabetes Commons")
+
+
+        st.caption(
+
+
+        "Open, compassionate diabetes care—monitoring, treatment, lifestyle, community."
+
+
+    )
+
+
+
+
+
+    st.sidebar.header("Load data")
+
+
+    uploaded = st.sidebar.file_uploader("CGM / diary CSV", type=["csv"])
+
+
+    use_example = st.sidebar.checkbox("Use synthetic example", True)
+
+
+
+
+
+    st.sidebar.header("Sundew configuration")
+
+
+    use_native = st.sidebar.checkbox(
+
+
+        "Use native Sundew gating",
+
+
+        value=_HAS_SUNDEW,
+
+
+        help="Disable to demo the lightweight fallback gate only.",
+
+
+    )
+
+
+    target_activation = st.sidebar.slider("Target activation", 0.05, 0.90, 0.22, 0.01)
+
+
+    temperature = st.sidebar.slider("Gate temperature", 0.02, 0.50, 0.08, 0.01)
+
+
+    mode = st.sidebar.selectbox(
+
+
+        "Preset", ["tuned_v2", "conservative", "aggressive", "auto_tuned"], index=0
+
+
+    )
+
+
+
+
+
+    if uploaded is not None:
+
+
+        df = pd.read_csv(uploaded)
+
+
+    elif use_example:
+
+
+        df = load_example_dataset()
+
+
+    else:
+
+
+        st.stop()
+
+
+
+
+
+    features = compute_features(df)
+
+
+    model = train_simple_model(features)
+
+
+    gate_config = SundewGateConfig(
+
+
+        target_activation=target_activation,
+
+
+        temperature=temperature,
+
+
+        mode=mode,
+
+
+        use_native=use_native,
+
+
+    )
+
+
+    gate = AdaptiveGate(gate_config)
+
+
+
+
+
+    telemetry: List[Dict[str, Any]] = []
+
+
+    records: List[Dict[str, Any]] = []
+
+
+    alerts: List[Dict[str, Any]] = []
+
+
+
+
+
+    progress = st.progress(0)
+
+
+    status = st.empty()
+
+
+    for idx, row in enumerate(features.itertuples(index=False), start=1):
+
+
+        score = lightweight_score(pd.Series(row._asdict()))
+
+
+        should_run = gate.decide(score)
+
+
+        risk_proba = None
+
+
+        if should_run and model is not None:
+
+
+            sample = np.array(
+
+
+                [
+
+
+                    [
+
+
+                        row.glucose_mgdl,
+
+
+                        row.roc_mgdl_min,
+
+
+                        row.iob_proxy,
+
+
+                        row.cob_proxy,
+
+
+                        row.activity_factor,
+
+
+                        row.variability,
+
+
+                    ]
+
+
+                ]
+
+
+            )
+
+
+            try:
+
+
+                risk_proba = float(model.predict_proba(sample)[0, 1])  # type: ignore[index]
+
+
+            except Exception:
+
+
+                risk_proba = None
+
+
+        if risk_proba is not None and risk_proba >= 0.6:
+
+
+            alerts.append(
+
+
+                {
+
+
+                    "timestamp": row.timestamp,
+
+
+                    "glucose": row.glucose_mgdl,
+
+
+                    "risk": risk_proba,
+
+
+                    "message": "Check CGM, hydrate, plan balanced snack/insulin",
+
+
+                }
+
+
+            )
+
+
+        records.append(
+
+
+            {
+
+
+                "timestamp": row.timestamp,
+
+
+                "glucose_mgdl": row.glucose_mgdl,
+
+
+                "roc_mgdl_min": row.roc_mgdl_min,
+
+
+                "deviation": row.deviation,
+
+
+                "iob_proxy": row.iob_proxy,
+
+
+                "cob_proxy": row.cob_proxy,
+
+
+                "variability": row.variability,
+
+
+                "activity_factor": row.activity_factor,
+
+
+                "score": score,
+
+
+                "activated": should_run,
+
+
+                "risk_proba": risk_proba,
+
+
+            }
+
+
+        )
+
+
+        telemetry.append(
+
+
+            {
+
+
+                "timestamp": str(row.timestamp),
+
+
+                "score": score,
+
+
+                "activated": should_run,
+
+
+                "risk_proba": risk_proba,
+
+
+            }
+
+
+        )
+
+
+        progress.progress(idx / len(features))
+
+
+        status.text(f"Processing event {idx}/{len(features)}")
+
+
+    progress.empty()
+
+
+    status.empty()
+
+
+
+
+
+        results = pd.DataFrame(records)
+
+
+
+
+
+
+    tabs = st.tabs(["Overview", "Treatment", "Lifestyle", "Community", "Telemetry"])
+    with tabs[0]:
+    render_overview(results, alerts, gate_config)
+    with tabs[1]:
+    st.subheader("Full-cycle treatment support")
+    default_plan = {
+        "Insulin": {
+            "Basal": "14u glargine at 21:00",
+            "Bolus": "1u per 10g carbs + correction 1u per 40 mg/dL over 140",
+        },
+        "Oral medications": {
+            "Metformin": "500mg breakfast + 500mg dinner",
+            "Empagliflozin": "10mg once daily (if eGFR > 45)",
+        },
+        "Monitoring": [
+            "CGM sensor change every 10 days",
+            "Morning fasted CGM calibration",
+            "Weekly telehealth coaching",
+            "Quarterly in-person clinician review",
+        ],
+        "Safety plan": [
+            "Carry glucose tabs + glucagon kit",
+            "Emergency contact: +233-200-000-888",
+        ],
+        "Lifestyle": [
+            "30 min brisk walk 5x/week",
+            "Bedtime snack if glucose < 110 mg/dL",
+            "Hydrate 2L water daily unless contraindicated",
+        ],
+    }
+    st.caption("Upload or edit schedules, medication titration guidance, and clinician notes.")
+    uploaded_plan = st.file_uploader(
+        "Optional plan JSON", type=["json"], key="plan_uploader"
+    )
+    plan_text = st.text_area(
+        "Edit plan JSON",
+        json.dumps(default_plan, indent=2),
+        height=240,
+    )
+    plan_data = default_plan
+    if uploaded_plan is not None:
+        try:
+            plan_data = json.load(uploaded_plan)
+        except Exception as exc:
+            st.error(f"Could not parse uploaded plan JSON: {exc}")
+            plan_data = default_plan
+    else:
+        try:
+            plan_data = json.loads(plan_text)
+        except Exception as exc:
+            st.warning(
+                f"Using default plan because text could not be parsed: {exc}"
+            )
+            plan_data = default_plan
+    next_visit = (datetime.utcnow() + timedelta(days=30)).strftime(
+        "%Y-%m-%d (telehealth)"
+    )
+    render_treatment_plan(plan_data, next_visit=next_visit)
+    with tabs[2]:
+    render_lifestyle_support(results)
+    with tabs[3]:
+    community_items = render_community_actions()
+    st.json(community_items, expanded=False)
+    with tabs[4]:
+    render_telemetry(results, telemetry)
+    st.sidebar.markdown("---")
+
+
+    status_text = (
+
+
+        "native gating"
+
+
+        if gate_config.use_native and gate.sundew is not None
+
+
+        else "fallback gate"
+
+
+    )
+
+
+    st.sidebar.caption(f"Sundew status: {status_text}")
+
+
+
+
+
+
+
+
+if __name__ == "__main__":
+
+
+    main()
+
+