#!/usr/bin/env python3 """JARVIS Health Dashboard v4. Mobile, privacy-hardened evolution of the complete v3 dashboard: - laboratory trend charts with reference ranges and clinical-event markers - Apple Health Auto Export modules (sleep/HRV/pulse/activity/SpO2/respiration) - nutrition adherence - doctor-report PDF link / Drive upload metadata """ from __future__ import annotations import argparse import html import json import os import re import sqlite3 import sys from collections import defaultdict from datetime import datetime, timedelta from pathlib import Path from statistics import mean, median from typing import Any, Mapping BASE = Path.home() / ".hermes" / "assets" / "Gesundheit" DB = BASE / "health_data.db" REPORTS = BASE / "reports" sys.path.insert(0, str(Path(__file__).resolve().parent)) from health_pipeline import best_reference_xlsx, parse_reference_xlsx, get_lab_matrix, split_reference, db_counts # noqa: E402 from apple_health_analytics import ( # noqa: E402 ANALYTICS_VERSION as APPLE_ANALYTICS_VERSION, LOCAL_TZ as APPLE_LOCAL_TZ, coverage_summary as apple_coverage_summary, daily_series as canonical_apple_daily, unit_for as canonical_apple_unit, ) APPLE_CHARTS = [ ("step_count", "Schritte", "sum"), ("walking_running_distance", "Geh-/Laufdistanz", "sum"), ("resting_heart_rate", "Ruhepuls", "avg"), ("heart_rate", "Herzfrequenz", "avg"), ("heart_rate_variability", "HRV", "avg"), ("sleep_analysis", "Schlafdauer", "sum"), ("blood_oxygen_saturation", "SpO₂", "avg"), ("respiratory_rate", "Atemfrequenz", "avg"), ("active_energy", "Aktive Energie", "sum"), ("physical_effort", "Physical Effort", "avg"), ("weight_body_mass", "Gewicht", "last"), ] def conn() -> sqlite3.Connection: c = sqlite3.connect(DB) c.row_factory = sqlite3.Row return c def calendar_axis(day_values: Any, max_days: int | None = None) -> list[str]: parsed = [] for value in day_values: try: parsed.append(datetime.strptime(str(value)[:10], "%Y-%m-%d").date()) except ValueError: continue if not parsed: return [] end = max(parsed) start = min(parsed) if max_days is not None: start = max(start, end - timedelta(days=max_days - 1)) return [ (start + timedelta(days=offset)).isoformat() for offset in range((end - start).days + 1) ] def sparse_calendar_series(days: list[str], observed: dict[str, Any]) -> list[Any]: return [observed.get(day) for day in days] def rolling_median_baseline( days: list[str], observed: Mapping[str, float | int], *, window_days: int = 14, min_observations: int = 7 ) -> list[float | None]: parsed = [datetime.strptime(day, "%Y-%m-%d").date() for day in days] result: list[float | None] = [] for current in parsed: start = current - timedelta(days=window_days - 1) values = [ float(value) for day, value in observed.items() if start <= datetime.strptime(day, "%Y-%m-%d").date() <= current ] result.append(round(median(values), 3) if len(values) >= min_observations else None) return result def format_measurement(value: Any, precision: int = 1, suffix: str = "") -> str: if value is None: return "unbekannt" return f"{float(value):.{precision}f}{suffix}" def complete_histamine(row: sqlite3.Row | None) -> tuple[str, str]: if row is None: return "unknown", "unbekannt" keys = set(row.keys()) unknown_count = row["histamine_unknown_count"] if "histamine_unknown_count" in keys else None item_count = row["item_count"] if "item_count" in keys else None score = row["histamine_score"] if "histamine_score" in keys else None label = row["histamine_label"] if "histamine_label" in keys else None if ( unknown_count is None or item_count is None or int(item_count) < 1 or int(unknown_count) != 0 or score is None or label not in {"green", "yellow", "orange", "red"} ): return "unknown", "unbekannt" return str(label), format_measurement(score, 1) def item_histamine_label(row: sqlite3.Row) -> str: traffic = str(row["traffic_light"] or "").strip().casefold() canonical_food = str(row["canonical_food"] or "").strip() confidence = str(row["confidence"] or "").strip().casefold() try: score = float(row["sighi_score"]) except (TypeError, ValueError): return "unknown" if ( traffic not in {"green", "yellow", "orange", "red"} or not canonical_food or canonical_food.casefold() in {"unknown", "unbekannt"} or confidence not in {"medium", "high", "mittel", "hoch", "verified"} or not 0 <= score <= 3 ): return "unknown" return traffic def is_administered_event(event_type: Any) -> bool: return str(event_type or "").strip().casefold() in {"administered", "verabreicht"} def source_freshness( latest_day: str | None, *, today: str, expected_within_days: int ) -> tuple[str, int | None]: if not latest_day: return "unbekannt", None text = str(latest_day).strip() try: if re.fullmatch(r"\d{4}-\d{2}-\d{2}", text): latest = datetime.strptime(text, "%Y-%m-%d").date() elif re.fullmatch( r"\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?(?:Z|[+-]\d{2}:\d{2})?", text, ): latest = datetime.fromisoformat(text.replace("Z", "+00:00")).date() else: return "unbekannt", None current = datetime.strptime(today, "%Y-%m-%d").date() except ValueError: return "unbekannt", None age = (current - latest).days if age < 0: return "prüfen", age return ("aktuell" if age <= expected_within_days else "prüfen"), age def resolve_doc_path(*values: Any) -> Path | None: for value in values: if not value: continue raw = str(value) for p in [Path(os.path.expanduser(raw)), BASE / raw, Path("/home/agent") / raw, Path(raw.replace("/home/agent/Gesundheit", str(BASE)))]: try: if p.exists(): return p.resolve() except OSError: pass return None def doc_url(row: sqlite3.Row) -> str | None: """Return browser-openable URL for dashboard documents. iPhone/Safari cannot open local file:// links from the Tailscale dashboard, so local HealthManager docs are exposed via the dashboard's restricted /health-doc/ route. Drive remains only a fallback. """ keys = row.keys() vals = [] if "local_original_path" in keys: vals.append(row["local_original_path"]) if "dateipfad" in keys: vals.append(row["dateipfad"]) p = resolve_doc_path(*vals) if p and "id" in keys: return f"/health-doc/{int(row['id'])}" if "drive_web_url" in keys and row["drive_web_url"]: return str(row["drive_web_url"]) return None def link_doc(row: sqlite3.Row) -> str: name = html.escape(str(row["datei_name"])) url = doc_url(row) return f"{name}" if url else name def num(x: Any) -> float | None: try: return float(str(x).replace(",", ".").replace("<", "").replace(">", "").strip()) except Exception: return None def row_value(row: Any, key: str, default: Any = None) -> Any: try: value = row[key] except (KeyError, IndexError, TypeError): return default return default if value is None else value def parse_comparison_value(raw: Any) -> tuple[str, float] | None: match = re.fullmatch(r"\s*(<=|>=|<|>|=)?\s*([-+]?\d+(?:[.,]\d+)?)\s*", str(raw or "")) if not match: return None return match.group(1) or "=", float(match.group(2).replace(",", ".")) def evaluate_lab_warning(row: Any) -> tuple[str, str, str] | None: """Return a conservative reference-range warning for verified lab data only.""" if str(row_value(row, "validierungsstatus", "")).lower() != "validiert": return None if int(row_value(row, "verified_against_original", 0) or 0) != 1: return None if str(row_value(row, "reference_range_source", "")).lower() != "scanned_original": return None unit = str(row_value(row, "einheit", "")).strip() parsed = parse_comparison_value(row_value(row, "wert")) lower = num(row_value(row, "reference_min")) upper = num(row_value(row, "reference_max")) if not unit or parsed is None or (lower is None and upper is None): return None operator, value = parsed direction = None if operator == "=" and upper is not None and value > upper: direction = "über" elif operator == "=" and lower is not None and value < lower: direction = "unter" elif operator == ">" and upper is not None and value >= upper: direction = "über" elif operator == ">=" and upper is not None and value > upper: direction = "über" elif operator == "<" and lower is not None and value <= lower: direction = "unter" elif operator == "<=" and lower is not None and value < lower: direction = "unter" if direction is None: return None name = str(row_value(row, "parameter_name", "Laborwert")) date = str(row_value(row, "abnahme_datum", row_value(row, "befund_datum", ""))) reference = f"{lower if lower is not None else '–'} bis {upper if upper is not None else '–'} {unit}" display_value = f"{operator if operator != '=' else ''}{value:g} {unit}".strip() return ( "orange", f"Validierten Laborwert ärztlich prüfen: {name}", f"{display_value} liegt sicher {direction} dem Referenzbereich ({reference}); Messdatum {date}.", ) def ref_nums(ref: str | None) -> tuple[float | None, float | None]: rmin, rmax, _ = split_reference(ref) return num(rmin), num(rmax) def nutrition_score(text: str) -> dict[str, Any]: t = (text or "").lower() negatives = { "Schweinefleisch": ["schwein", "bratwurst", "salami", "speck", "schinken"], "Weizen/Gluten": ["hörnli", "hoernli", "weizen", "pasta", "brot", "pizza", "teigwaren"], "Industriezucker": ["torte", "kuchen", "süss", "suess", "zucker", "dessert", "glace"], "Histamin": ["alter käse", "kaese", "rotwein", "salami", "ferment", "bier", "wein"], "Nachtschatten": ["tomate", "aubergine", "kartoffel", "paprika", "peperoni"], "Gesättigte Fette": ["butter", "bratwurst", "kokos", "rahm", "sahne", "speck"], "Alkohol": ["alkohol", "bier", "wein", "panaché", "panache"], } positives = { "Fisch/Omega-3": ["lachs", "sardine", "makrele", "forelle", "fisch", "algenöl", "algenoel"], "Ballaststoffe": ["hafer", "linsen", "bohnen", "gemüse", "gemuese", "salat", "beeren"], "Protein gut": ["skyr", "quark", "huhn", "poulet", "ei", "tofu", "fisch"], } neg_hits = sorted({label for label, words in negatives.items() if any(w in t for w in words)}) pos_hits = sorted({label for label, words in positives.items() if any(w in t for w in words)}) score = max(0, min(100, 85 + 5 * len(pos_hits) - 16 * len(neg_hits))) return {"score": score, "neg_hits": neg_hits, "pos_hits": pos_hits, "histamine": 100 if "Histamin" in neg_hits else 0, "satfat": 100 if "Gesättigte Fette" in neg_hits else 0, "sugar": 100 if "Industriezucker" in neg_hits else 0, "gluten": int("Weizen/Gluten" in neg_hits), "pork": int("Schweinefleisch" in neg_hits), "nightshade": int("Nachtschatten" in neg_hits), "alcohol": int("Alkohol" in neg_hits), "fiber": 70 if "Ballaststoffe" in pos_hits else 20, "protein": 70 if "Protein gut" in pos_hits else 30, "omega3": 80 if "Fisch/Omega-3" in pos_hits else 10} def compute_nutrition_features(c: sqlite3.Connection) -> list[sqlite3.Row]: by_day: dict[str, list[str]] = defaultdict(list) for r in c.execute("SELECT datum,beschreibung,wirkung,notizen FROM ernaehrung ORDER BY datum"): by_day[str(r["datum"])[:10]].append(" ".join(str(r[k] or "") for k in r.keys() if k != "datum")) for r in c.execute("SELECT datum,kategori,titel,inhalt,wirkung,notizen FROM tagebuch WHERE lower(kategori) LIKE 'ern%' ORDER BY datum"): by_day[str(r["datum"])[:10]].append(" ".join(str(r[k] or "") for k in r.keys() if k != "datum")) for day, texts in by_day.items(): s = nutrition_score(" ".join(texts)) c.execute(""" INSERT OR REPLACE INTO nutrition_daily_features (datum, plan_adherence_score, histamine_score, saturated_fat_score, sugar_score, gluten_flag, pork_flag, nightshade_flag, alcohol_flag, fiber_proxy, protein_proxy, omega3_proxy, positive_hits, negative_hits, source, computed_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,CURRENT_TIMESTAMP) """, (day, s["score"], s["histamine"], s["satfat"], s["sugar"], s["gluten"], s["pork"], s["nightshade"], s["alcohol"], s["fiber"], s["protein"], s["omega3"], ", ".join(s["pos_hits"]), ", ".join(s["neg_hits"]), "dashboard_v31_keyword_heuristic")) c.commit() return list(c.execute("SELECT * FROM nutrition_daily_features ORDER BY datum")) def apple_series( metric: str, mode: str, rows: list[sqlite3.Row], ) -> dict[str, Any] | None: # Use canonical aggregation over rows supplied by the dashboard connection. # This keeps synthetic/test databases isolated from the production DB path. series = canonical_apple_daily(metric, mode, _rows=rows) if not series: return None labels = sorted(series) data = [series[d] for d in labels] unit = canonical_apple_unit(metric, _rows=rows) return {"labels": labels, "data": data, "unit": unit, "count": len(data), "first": labels[0], "last": labels[-1], "latest": data[-1], "avg": round(mean(data), 2), "min": round(min(data), 2), "max": round(max(data), 2)} def load_doctor_report_meta() -> dict[str, Any] | None: p = REPORTS / "arztbericht_drive_link.json" if not p.exists(): return None try: return json.loads(p.read_text(encoding="utf-8")) except Exception: return None def main(output: Path | None = None) -> None: REPORTS.mkdir(parents=True, exist_ok=True) counts = db_counts() labs = parse_reference_xlsx(best_reference_xlsx()) if best_reference_xlsx().exists() else [] dates, _params, matrix, _cats, refs = get_lab_matrix(labs) if labs else ([], [], {}, {}, {}) c = conn() try: docs = list(c.execute("SELECT id,datei_name,dateipfad,kategorie,status,review_status,upload_datum,drive_web_url,local_original_path,length(COALESCE(extrahierte_inhalte,'')) text_len FROM dokumente ORDER BY id DESC LIMIT 25")) lab_docs = list(c.execute("SELECT id,datei_name,dateipfad,kategorie,status,drive_web_url,local_original_path FROM dokumente WHERE upper(COALESCE(kategorie,'')) LIKE '%LABOR%' ORDER BY id DESC LIMIT 40")) events = list(c.execute(""" SELECT date,category,parameter,value,notes,source FROM health_events WHERE date IS NOT NULL AND date(date) IS NOT NULL AND upper(COALESCE(category,'')) NOT IN ('LABOR','PROFIL','BEFUNDE') ORDER BY date """)) symptoms = list(c.execute("SELECT datum,kategori,symptom,schwergrad,notizen FROM symptome WHERE date(datum) IS NOT NULL ORDER BY datum")) symptom_quick_rows = list(c.execute("SELECT id,datum,symptom,schwergrad FROM symptom_log WHERE kontext='daily_quick_score' ORDER BY id")) periods = list(c.execute("SELECT start_date,end_date,event_type,label,severity,location,notes FROM health_event_periods ORDER BY start_date DESC LIMIT 50")) # Legacy keyword scoring is intentionally not regenerated: incomplete # food logs must never become implicit non-exposures or plan adherence. nutrition_v2_daily = list(c.execute("SELECT * FROM nutrition_daily_summary_v2 ORDER BY datum")) nutrition_v2_meals = list(c.execute("SELECT * FROM nutrition_meal_summary ORDER BY datum, CASE meal WHEN 'breakfast' THEN 1 WHEN 'lunch' THEN 2 WHEN 'dinner' THEN 3 WHEN 'snack' THEN 4 ELSE 9 END")) nutrition_v2_items = list(c.execute(""" SELECT i.datum,i.meal,i.name,i.amount,i.kcal,i.protein_g,i.carb_g,i.fat_g, h.traffic_light,h.canonical_food,h.sighi_score,h.tags,h.confidence FROM nutrition_items i LEFT JOIN nutrition_histamine_scores h ON h.item_id=i.id WHERE i.source='yazio_api' ORDER BY i.datum, CASE i.meal WHEN 'breakfast' THEN 1 WHEN 'lunch' THEN 2 WHEN 'dinner' THEN 3 WHEN 'snack' THEN 4 ELSE 9 END, i.id """)) medication_admins = list(c.execute("SELECT datum,medication_name,dose,route,event_type,scheduled_next_date,notes FROM medication_administrations ORDER BY datum DESC LIMIT 50")) administered_medications = [ row for row in medication_admins if is_administered_event(row["event_type"]) ] nutrition_review = list(c.execute("SELECT example_name,occurrence_count,first_seen,last_seen,reason FROM nutrition_review_queue WHERE status='open' ORDER BY occurrence_count DESC,last_seen DESC LIMIT 25")) if c.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='multimodal_correlation_results'").fetchone(): multimodal_correlations = list(c.execute(""" SELECT predictor,target,lag_days,medication_phase,n,eligible_target_days, expected_target_days,target_coverage,rho,q_value,status,interpretation FROM multimodal_correlation_results ORDER BY CASE status WHEN 'computed' THEN 0 ELSE 1 END, COALESCE(q_value, 2), predictor, lag_days, medication_phase LIMIT 100 """)) else: multimodal_correlations = [] personal_tolerances = list(c.execute("SELECT canonical_food,personal_status,evidence_level,notes,updated_at FROM personal_food_tolerance ORDER BY CASE personal_status WHEN 'problematic' THEN 1 WHEN 'unclear' THEN 2 WHEN 'safe' THEN 3 ELSE 4 END, canonical_food")) apple_raw_by_metric: dict[str, list[sqlite3.Row]] = defaultdict(list) for row in c.execute( """SELECT id,metric,value,unit,start_date,end_date,source_name,file_name,file_hash FROM apple_health_records WHERE value IS NOT NULL AND start_date IS NOT NULL ORDER BY metric,start_date,end_date,source_name,id""" ): apple_raw_by_metric[str(row["metric"])].append(row) apple = { metric: apple_series(metric, mode, apple_raw_by_metric.get(metric, [])) for metric, _label, mode in APPLE_CHARTS } finally: c.close() key_params = [ "C-Reaktives Protein (CRP)", "Blutsenkungsreaktion miniiSED", "Leukozyten", "Neutrophile", "Lymphozyten", "Monozythen", "Thrombozyten", "Ferritin", "Fibrinogen", "D-Dimer", "Faktor VIII", "Cholesterin gesamt", "LDL-Cholesterin", "HDL-Cholesterin", "Triglyceride", "Homocystein", "Kreatinin", "eGFR (Niere)", "Albumin/Kreatinin", "Protein", "Blut", "Erythrozyten", "ALAT (GPT)", "ASAT (GOT)", "GGT", "Vitamin D (25-OH)", "Vitamin B12 (Active)", "Folsäure", "HLA-B51" ] event_by_date: dict[str, list[str]] = defaultdict(list) for r in events: event_by_date[str(r["date"])[:10]].append(f"{r['category']}: {r['parameter']} {r['value'] or ''}".strip()) for r in symptoms: event_by_date[str(r["datum"])[:10]].append(f"Symptom: {r['symptom']} ({r['schwergrad'] or 'n/a'})") charts = [] for p in key_params: vals = [] for d in dates: v = matrix.get((p, d)) if v and num(v.value) is not None: vals.append((d, num(v.value))) if not vals: continue labels = [d for d, _ in vals] data = [v for _, v in vals] event_points = [{"x": d, "label": "; ".join(event_by_date[d])[:180]} for d in labels if d in event_by_date] rmin, rmax = ref_nums(refs.get(p)) cid = re.sub(r"\W+", "_", p) charts.append(f"""

{html.escape(p)}

Referenz: {html.escape(refs.get(p, 'n/a'))}
""") # Full lab matrix grouped by physician-style categories; includes every parsed value from the reference XLSX. category_order = [ "Entzündung", "Hämatologie", "Blutstatus Leuk", "Blutbild automatisch absolut", "Gerinnung", "Spezielle Gerinnung", "Immunologie / Infektion", "Auto-Antikörper gegen", "Virale Hepatitiden A,B,C,D,E", "Blutfette & Stoffwechsel", "Leber & Niere", "Elektrolyte & Vitamine", "Proteine", "Schilddrüse & Hormone", "Urin", "Sonstiges" ] params_by_cat: dict[str, list[str]] = defaultdict(list) for p_name in _params: params_by_cat[_cats.get(p_name, "Sonstiges")].append(p_name) lab_category_sections = [] for cat in category_order + sorted(set(params_by_cat) - set(category_order)): plist = params_by_cat.get(cat, []) if not plist: continue rows = [] for p_name in plist: vals = [] latest = "" for d in dates: v = matrix.get((p_name, d)) cell = html.escape(v.value) if v else "" vals.append(f"{cell}") if v: latest = f"{html.escape(v.value)} {html.escape(d)}" rows.append(f"{html.escape(p_name)}
Latest: {latest or 'n/a'}
{html.escape(refs.get(p_name, ''))}{''.join(vals)}") lab_category_sections.append(f"""
{html.escape(cat)} ({len(plist)} Parameter)
{''.join(f'' for d in dates)}{''.join(rows)}
ParameterReferenz{html.escape(d)}
""") all_lab_category_html = "".join(lab_category_sections) or "

Keine Laborwerte aus XLSX verfügbar.

" lab_param_count = len(_params) lab_value_count = len(matrix) apple_charts = [] apple_rows = [] apple_quality_rows = [] quality_end = datetime.now(APPLE_LOCAL_TZ).date() - timedelta(days=1) quality_start = quality_end - timedelta(days=29) for metric, label, mode in APPLE_CHARTS: quality = apple_coverage_summary( metric, start_date=quality_start.isoformat(), end_date=quality_end.isoformat(), mode=mode, _rows=apple_raw_by_metric.get(metric, []), ) coverage = float(quality["coverage_ratio"]) coverage_label = "vollständig" if coverage >= .8 else ("teilweise" if coverage >= .5 else "lückenhaft") apple_quality_rows.append( f"{html.escape(label)}{quality['observed_days']} / {quality['expected_observations']}" f"{coverage * 100:.0f}% ({coverage_label}){quality['coarse_fallback_days']}" f"{quality['days_with_source_conflict']}{quality['deduplicated_records']}" ) s = apple.get(metric) if not s: continue cid = "apple_" + re.sub(r"\W+", "_", metric) apple_charts.append(f"""

{html.escape(label)}

Apple Health Analytics v{APPLE_ANALYTICS_VERSION} · Einheit: {html.escape(s['unit'])}; Zeitraum: {s['first']} bis {s['last']}; Aggregation: {'Summe' if mode == 'sum' else ('letzter Wert' if mode == 'last' else 'Durchschnitt')} pro lokalem Tag
""") apple_rows.append(f"{html.escape(label)}{s['first']} bis {s['last']}{s['count']}{s['latest']} {html.escape(s['unit'])}{s['avg']}{s['min']}{s['max']}") cards = "".join(f"
{html.escape(str(v))}
{html.escape(k)}
" for k, v in counts.items()) doc_rows = "".join(f"{r['id']}{link_doc(r)}{html.escape(str(r['kategorie']))}{html.escape(str(r['status']))}{html.escape(str(r['review_status'] or ''))}{r['text_len']}" for r in docs) lab_doc_rows = "".join(f"{r['id']}{link_doc(r)}{html.escape(str(r['status']))}" for r in lab_docs) event_rows = "".join(f"{html.escape(str(r['date']))}{html.escape(str(r['category']))}{html.escape(str(r['parameter']))}{html.escape(str(r['value'] or r['notes'] or ''))}" for r in events[-30:]) symptom_rows = "".join(f"{html.escape(str(r['datum']))}Symptom{html.escape(str(r['symptom']))}{html.escape(str(r['schwergrad'] or '') + ' ' + str(r['notizen'] or ''))}" for r in symptoms[-30:]) period_rows = "".join(f"{html.escape(str(r['start_date']))}{html.escape(str(r['end_date'] or 'offen'))}{html.escape(str(r['event_type']))}{html.escape(str(r['label'] or ''))}{html.escape(str(r['severity'] or ''))}{html.escape(str(r['notes'] or ''))}" for r in periods) or "Noch keine Zeitraum-Events erfasst. Beispiel: Aphte von Start- bis Enddatum." light_icon = {"green":"🟢", "yellow":"🟡", "orange":"🟠", "red":"🔴", "unknown":"⚫"} meal_name = {"breakfast":"Frühstück", "lunch":"Mittagessen", "dinner":"Nachtessen", "snack":"Snacks", "unknown":"Unbekannt"} nutrient_labels = { "nutrient.sugar": "Zucker", "nutrient.fiber": "Ballaststoffe", "nutrient.salt": "Salz", "nutrient.sodium": "Natrium", "nutrient.saturated": "gesättigte Fettsäuren", "nutrient.protein": "Protein", "nutrient.carb": "Kohlenhydrate", "nutrient.fat": "Fett", "energy.energy": "Energie" } quick_dimensions = ['Aphthen/Mundulzera','GI/Darm','Müdigkeit/Fatigue','Haut','Augen','Gelenke','Vaskulär/Thrombose-Warnzeichen'] severity_exact = { 'keine (0)': 0, 'none (0)': 0, '0': 0, 'leicht (1)': 1, 'mild (1)': 1, '1': 1, 'mittel (2)': 2, 'moderat (2)': 2, '2': 2, 'schwer (3)': 3, 'stark (3)': 3, 'hoch (3)': 3, '3': 3, } quick_by_day: dict[str, dict[str, list[int | None]]] = defaultdict(lambda: defaultdict(list)) for r in symptom_quick_rows: dimension = str(r["symptom"]) if dimension in quick_dimensions: score = severity_exact.get(str(r["schwergrad"] or "").casefold().strip()) quick_by_day[str(r["datum"])[:10]][dimension].append(score) symptom_by_day = { day: sum(values[0] for values in dimensions.values() if values[0] is not None) for day, dimensions in quick_by_day.items() if set(dimensions) == set(quick_dimensions) and all(len(values) == 1 and values[0] is not None for values in dimensions.values()) } nutrition_rows_by_day = {str(r["datum"]): r for r in nutrition_v2_daily} nutrition_v2_labels = calendar_axis(nutrition_rows_by_day) nutrition_v2_histamine = [] for day in nutrition_v2_labels: row = nutrition_rows_by_day.get(day) value = None if ( row is not None and row["histamine_score"] is not None and int(row["item_count"] or 0) > 0 and int(row["histamine_unknown_count"] or 0) == 0 ): value = float(row["histamine_score"]) nutrition_v2_histamine.append(value) nutrition_v2_symptom = [symptom_by_day.get(day) for day in nutrition_v2_labels] by_day_meal: dict[tuple[str, str], list[sqlite3.Row]] = defaultdict(list) for r in nutrition_v2_items: by_day_meal[(str(r["datum"]), str(r["meal"]))].append(r) meal_summary_by_key = {(str(r["datum"]), str(r["meal"])): r for r in nutrition_v2_meals} recent_days = [r["datum"] for r in nutrition_v2_daily[-30:]][::-1] overview_cards = [] for idx, day in enumerate(recent_days): day_sum = next((r for r in nutrition_v2_daily if r["datum"] == day), None) if not day_sum: continue label, histamine_load = complete_histamine(day_sum) summary_line = ( f"" f"{html.escape(day)}" f"{light_icon.get(label,'⚫')} Histamin {html.escape(label)}" f"{format_measurement(day_sum['kcal'], 0, ' kcal')}" f"Load {histamine_load}" f"{format_measurement(day_sum['item_count'], 0, ' Items')}" f"" ) day_macro = ( f"
Protein {format_measurement(day_sum['protein_g'], 1, ' g')} · " f"KH {format_measurement(day_sum['carb_g'], 1, ' g')} · Fett {format_measurement(day_sum['fat_g'], 1, ' g')} · " f"Unbekannt {format_measurement(day_sum['histamine_unknown_count'], 0)}
" ) meals_html = [] for m in ["breakfast", "lunch", "dinner", "snack", "unknown"]: items_for = by_day_meal.get((day, m), []) if not items_for: continue ms = meal_summary_by_key.get((day, m)) meal_label, _meal_load = complete_histamine(ms) top_nutrients = [] if ms and ms["nutrient_json"]: try: nj = json.loads(ms["nutrient_json"]) for k in ["nutrient.sugar", "nutrient.fiber", "nutrient.salt", "nutrient.saturated"]: if k in nj and nj[k] is not None: top_nutrients.append(f"{nutrient_labels.get(k,k)} {format_measurement(nj[k], 1, ' g')}") except Exception: pass item_cards = "".join( f"
" f"{light_icon.get(item_histamine_label(r),'⚫')}" f"{html.escape(str(r['name']))}{html.escape(str(r['canonical_food'] or 'unbekannt'))}" f"{format_measurement(r['amount'], 0, ' g')}" f"{format_measurement(r['kcal'], 0, ' kcal')}" f"P {format_measurement(r['protein_g'])} · KH {format_measurement(r['carb_g'])} · F {format_measurement(r['fat_g'])}" f"
" for r in items_for ) meals_html.append(f"""

{meal_name.get(m,m)}

{light_icon.get(meal_label,'⚫')} {html.escape(meal_label)}
{format_measurement(ms['kcal'] if ms else None, 0, ' kcal')} · Protein {format_measurement(ms['protein_g'] if ms else None, 1, ' g')} · KH {format_measurement(ms['carb_g'] if ms else None, 1, ' g')} · Fett {format_measurement(ms['fat_g'] if ms else None, 1, ' g')}
{html.escape(' · '.join(top_nutrients) if top_nutrients else 'Details abhängig von YAZIO-Produktdaten')}
{item_cards}
""") open_attr = "" overview_cards.append(f"
{summary_line}
{day_macro}{''.join(meals_html)}
") meal_explorer_html = "".join(overview_cards) or "
Noch keine Mahlzeiten importiert.
" medication_rows = "".join(f"{html.escape(str(r['datum']))}{html.escape(str(r['medication_name']))}{html.escape(str(r['event_type'] or ''))}{html.escape(str(r['dose'] or ''))}{html.escape(str(r['scheduled_next_date'] or ''))}{html.escape(str(r['notes'] or ''))}" for r in medication_admins) or "Noch keine Medikamentengaben erfasst." phase_label_v2 = { "baseline_pre_treatment": "Baseline vor Behandlung", "early_treatment": "Frühe Behandlungsphase", "stable_treatment": "Stabile Behandlungsphase", "unknown": "Behandlungsphase unbekannt", } corr_parts = [] for r in multimodal_correlations: rho = "" if r["rho"] is None else f"{float(r['rho']):.2f}" q_value = "" if r["q_value"] is None else f"{float(r['q_value']):.3f}" status_labels = { "computed": "berechnet", "insufficient_n": "unzureichende Paarzahl/Varianz", "insufficient_coverage": "Zielabdeckung unter 60 %", } status = status_labels.get(str(r["status"]), "nicht auswertbar") corr_parts.append( f"{html.escape(str(r['predictor']))}" f"{html.escape(phase_label_v2.get(str(r['medication_phase']), str(r['medication_phase'])))}" f"+{r['lag_days']} Tage{r['n']} / {r['eligible_target_days']} / {r['expected_target_days']}" f"{float(r['target_coverage'] or 0):.0%}" f"{rho}{q_value}{html.escape(status)}" f"{html.escape(str(r['interpretation']))}" ) correlation_rows = "".join(corr_parts) or "Noch keine ausreichend strukturierten vollständigen Datenpaare. Fehlende Symptomtage werden nicht als symptomfrei interpretiert." review_rows = "".join( f"{html.escape(str(r['example_name']))}{r['occurrence_count']}{html.escape(str(r['first_seen']))}{html.escape(str(r['last_seen']))}{html.escape(str(r['reason'] or ''))}" for r in nutrition_review ) or "Keine offenen unbekannten Produkte." tolerance_label = { 'safe': 'bisher persönlich dokumentiert vertragen', 'problematic': 'bisher persönlich als problematisch dokumentiert', 'unclear': 'persönliche Beobachtung unklar', 'unknown': 'unbekannt', } tolerance_rows = "".join( f"{html.escape(str(r['canonical_food']))}{html.escape(tolerance_label.get(r['personal_status'], 'unbekannt'))}{html.escape(str(r['evidence_level'] or ''))}{html.escape(str(r['notes'] or ''))}{html.escape(str(r['updated_at'] or ''))}" for r in personal_tolerances ) or "Noch keine persönliche Verträglichkeitsbeobachtung dokumentiert." # --- Extended operational cockpit sections --- c_ext = conn() doc_view_rows = "".join( f"{r['id']}{link_doc(r)}{html.escape(str(r['document_date'] or r['upload_datum'] or ''))}{html.escape(str(r['kategorie'] or ''))}{html.escape(str(r['institution'] or ''))}{html.escape(str(r['review_status'] or 'nicht_geprueft'))}" for r in list(c_ext.execute("SELECT id,datei_name,dateipfad,kategorie,status,review_status,upload_datum,drive_web_url,local_original_path,document_date,institution FROM dokumente ORDER BY COALESCE(document_date,upload_datum) DESC, id DESC LIMIT 30")) ) or "Keine Dokumente." doc_counts = list(c_ext.execute("SELECT COALESCE(review_status,'nicht_geprueft') review_status, COALESCE(kategorie,'unkategorisiert') kategorie, COUNT(*) c FROM dokumente GROUP BY review_status,kategorie ORDER BY c DESC LIMIT 20")) doc_review_rows = "".join(f"{html.escape(str(r['review_status']))}{html.escape(str(r['kategorie']))}{r['c']}" for r in doc_counts) or "Keine Dokumente." key_lab_names = ["C-Reaktives Protein (CRP)", "D-Dimer", "Thrombozyten", "Leukozyten", "Ferritin", "Vitamin D (25-OH)"] lab_latest = [] for name in key_lab_names: row = c_ext.execute("""SELECT parameter_name,wert,einheit,reference_min,reference_max, abnahme_datum,befund_datum,validierungsstatus, verified_against_original,reference_range_source FROM laborwerte WHERE parameter_name=? ORDER BY COALESCE(abnahme_datum,befund_datum,ermittlung_datum) DESC LIMIT 1""", (name,)).fetchone() if row: lab_latest.append(row) lab_latest_cards = "".join( f"
{html.escape(str(r['parameter_name']))}{html.escape(str(r['wert']))} {html.escape(str(r['einheit'] or ''))}{html.escape(str(r['abnahme_datum'] or r['befund_datum'] or ''))} · {html.escape(str(r['validierungsstatus'] or ''))}
" for r in lab_latest ) or "
Keine Schlüssellabore gefunden.
" appointment_docs = list(c_ext.execute("SELECT id,datei_name,dateipfad,kategorie,status,review_status,upload_datum,drive_web_url,local_original_path,document_date,institution FROM dokumente WHERE review_status IN ('arzttermin','relevant') ORDER BY COALESCE(document_date,upload_datum) DESC, id DESC LIMIT 12")) appointment_doc_rows = "".join(f"
  • {link_doc(r)} ({html.escape(str(r['kategorie'] or ''))}, {html.escape(str(r['document_date'] or r['upload_datum'] or ''))})
    • " for r in appointment_docs) or "
  • Noch keine Dokumente als relevant/Arzttermin markiert.
    • " medication_brief_cards = "".join( f"
    {html.escape(str(r['medication_name']))}{html.escape(str(r['dose'] or ''))}{html.escape(str(r['datum']))} · nächste: {html.escape(str(r['scheduled_next_date'] or 'n/a'))}
    " for r in administered_medications[:8] ) or "
    Keine verabreichte Medikation erfasst.
    " recent_sym_data = list(c_ext.execute("SELECT datum,symptom,schwergrad,notizen FROM symptom_log ORDER BY datum DESC, id DESC LIMIT 12")) recent_sym_cards = "".join( f"
    {html.escape(str(r['symptom']))}{html.escape(str(r['schwergrad'] or ''))}{html.escape(str(r['datum']))} · {html.escape(str(r['notizen'] or ''))}
    " for r in recent_sym_data[:8] ) or "
    Noch wenig Quick-Symptomdaten.
    " timeline = [] for r in administered_medications[:20]: timeline.append((str(r['datum'])[:10], '💉 Verabreichte Medikation', f"{r['medication_name']} {r['dose'] or ''}".strip())) for r in symptoms[-40:]: timeline.append((str(r['datum'])[:10], '🩺 Symptom', f"{r['symptom']} ({r['schwergrad'] or 'n/a'})")) for r in events[-60:]: timeline.append((str(r['date'])[:10], str(r['category'] or 'Event'), f"{r['parameter'] or ''} {r['value'] or r['notes'] or ''}".strip())) for r in nutrition_v2_daily[-20:]: nutrition_label, nutrition_load = complete_histamine(r) timeline.append((str(r['datum']), '🍽️ Ernährung', f"{format_measurement(r['kcal'], 0, ' kcal')} · Histamin {nutrition_label} · Load {nutrition_load}")) for r in lab_latest: timeline.append((str(r['abnahme_datum'] or r['befund_datum'] or '')[:10], '🧪 Labor', f"{r['parameter_name']}: {r['wert']} {r['einheit'] or ''}")) timeline = sorted([x for x in timeline if x[0]], key=lambda x: x[0], reverse=True)[:80] timeline_rows = "".join(f"{html.escape(d)}{html.escape(cat)}{html.escape(txt)}" for d,cat,txt in timeline) or "Keine Timeline-Daten." symptom_days = calendar_axis(quick_by_day, max_days=30) symptom_dims = quick_dimensions symptom_map = { day: { dimension: values[0] for dimension, values in dimensions.items() if len(values) == 1 } for day, dimensions in quick_by_day.items() } complete_symptom_days = [d for d in symptom_days if d in symptom_by_day] symptom_total = sparse_calendar_series(symptom_days, symptom_by_day) symptom_datasets = [{"label":"Total","data":symptom_total,"borderColor":"#1f4e78","backgroundColor":"rgba(31,78,120,.08)","tension":.25}] baseline = rolling_median_baseline(symptom_days, symptom_by_day) symptom_datasets.append({"label":"Persönliche 14-Tage-Baseline (Median)","data":baseline,"borderColor":"#111827","borderDash":[6,4],"pointRadius":0,"tension":0}) medication_days = {str(row['datum'])[:10] for row in administered_medications if row['datum']} event_days = {str(row['date'])[:10] for row in events if row['date']} symptom_datasets.append({"label":"Verabreichte Medikation","data":[21 if day in medication_days else None for day in symptom_days],"borderColor":"#0f766e","backgroundColor":"#0f766e","pointStyle":"triangle","pointRadius":7,"showLine":False}) symptom_datasets.append({"label":"Health Event","data":[20 if day in event_days else None for day in symptom_days],"borderColor":"#dc2626","backgroundColor":"#dc2626","pointStyle":"rectRot","pointRadius":6,"showLine":False}) colors = ['#ef4444','#f97316','#7c3aed','#16a34a','#0ea5e9','#a16207','#991b1b'] for dim, col in zip(symptom_dims, colors): observed_dimension = { day: dimensions.get(dim) for day, dimensions in symptom_map.items() } symptom_values = sparse_calendar_series(symptom_days, observed_dimension) symptom_datasets.append({"label": dim.split('/')[0], "data": symptom_values, "borderColor": col, "backgroundColor": col, "tension": .2}) symptom_chart = f"

    Symptom-Score Verlauf

    0..3 je Dimension; Total nur bei vollständig dokumentierten sieben Dimensionen. Lücken werden nicht als 0 dargestellt.
    " if symptom_days else "

    Symptom-Score Verlauf

    Noch keine Quick-Symptomdaten.

    " exp_rows = ( list(c_ext.execute("SELECT id,start_date,end_date,phase,challenge_food,hypothesis,notes,status FROM low_histamine_experiments ORDER BY id DESC LIMIT 20")) if c_ext.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='low_histamine_experiments'").fetchone() else [] ) experiment_rows = "".join(f"{r['id']}{html.escape(str(r['start_date']))}{html.escape(str(r['end_date'] or 'offen'))}{html.escape(str(r['phase']))}{html.escape(str(r['challenge_food'] or ''))}{html.escape(str(r['status']))}{html.escape(str(r['hypothesis'] or r['notes'] or ''))}" for r in exp_rows) or "Noch kein dokumentiertes Low-Histamine-Experiment vorhanden." warnings = [] for r in lab_latest: lab_warning = evaluate_lab_warning(r) if lab_warning: warnings.append(lab_warning) unreviewed = c_ext.execute("SELECT COUNT(*) FROM dokumente WHERE COALESCE(review_status,'nicht_geprueft')='nicht_geprueft'").fetchone()[0] if unreviewed: warnings.append(('yellow','Dokumente ungeprüft', f'{unreviewed} Dokumente haben noch keinen Review-Status.')) if len(complete_symptom_days) < 14: warnings.append(('yellow','Symptomdaten unzureichend', f'Nur {len(complete_symptom_days)} vollständig dokumentierte Tage; die neue Engine berechnet erst ab 14 vollständigen Paaren und wertet Signale erst ab 30 Paaren als korrigierte Hypothese.')) red_recent = c_ext.execute("SELECT COUNT(*) FROM nutrition_daily_summary_v2 WHERE histamine_label='red' AND date(datum) >= date('now','-30 day')").fetchone()[0] if red_recent: warnings.append(('orange','Hohe Histamin-Tage', f'{red_recent} rote Tage in den letzten 30 Tagen.')) warning_rows = "".join(f"{html.escape(cls)}{html.escape(title)}{html.escape(text)}" for cls,title,text in warnings) or "Keine automatischen Hinweise erkannt – dies schließt medizinische Risiken nicht aus." warning_cards = "".join(f"
    {html.escape(cls)}{html.escape(title)}{html.escape(text)}
    " for cls,title,text in warnings[:4]) or "
    InfoKeine automatischen Hinweise erkanntDies schließt medizinische Risiken nicht aus.
    " latest_nutrition = nutrition_v2_daily[-1] if nutrition_v2_daily else None latest_histamine_label, latest_histamine_load = complete_histamine(latest_nutrition) latest_nutrition_card = ( f"
    Ernährung zuletzt{latest_nutrition['datum']}: {format_measurement(latest_nutrition['kcal'], 0, ' kcal')}{light_icon.get(latest_histamine_label,'⚫')} Load {latest_histamine_load}
    " if latest_nutrition else "
    ErnährungKeine Daten
    " ) next_med = next((r for r in medication_admins if r['scheduled_next_date']), None) next_med_card = ( f"
    Nächste Medikation{html.escape(str(next_med['scheduled_next_date']))}{html.escape(str(next_med['medication_name']))} {html.escape(str(next_med['dose'] or ''))}
    " if next_med else "
    MedikationKein nächster Termin erfasst
    " ) today = datetime.now().date().isoformat() today_symptom_complete = today in symptom_by_day today_nutrition = nutrition_rows_by_day.get(today) today_nutrition_complete = bool( today_nutrition and int(today_nutrition["item_count"] or 0) > 0 and int(today_nutrition["histamine_unknown_count"] or 0) == 0 ) today_actions = "".join([ f"Symptom-Check-in{'vollständig' if today_symptom_complete else 'offen'}Fehlend bleibt unbekannt.", f"Ernährung heute{'vollständig klassifiziert' if today_nutrition_complete else 'prüfen oder ergänzen'}Unbekannte Klassifikationen werden nicht als null gewertet.", f"Dokumenten-Review{unreviewed} offenNur Datenqualität; keine medizinische Risikobewertung.", ]) stable_apple_days = [series["last"] for series in apple.values() if series] latest_stable_apple_day = max(stable_apple_days) if stable_apple_days else None freshness_specs = [ ("Apple Health – stabiler Datentag", latest_stable_apple_day, 2), ("Apple Health – Importzeit", c_ext.execute("SELECT MAX(imported_at) FROM apple_health_records").fetchone()[0], 2), ("Ernährung – Datentag", c_ext.execute("SELECT MAX(datum) FROM nutrition_daily_summary_v2").fetchone()[0], 2), ("Symptom-Quick-Log – Datentag", c_ext.execute("SELECT MAX(datum) FROM symptom_log WHERE kontext='daily_quick_score'").fetchone()[0], 2), ("Dokumentimport – Verarbeitungszeit", c_ext.execute("SELECT MAX(COALESCE(verarbeite_datum,upload_datum)) FROM dokumente").fetchone()[0], 30), ] freshness_rows = [] for source, latest, expected_days in freshness_specs: status, age = source_freshness(latest, today=today, expected_within_days=expected_days) css = "green" if status == "aktuell" else "yellow" if status == "prüfen" else "unknown" if age is None: age_text = "kein gültiger Zeitstempel" elif age < 0: age_text = f"Zukunftswert ({-age} Tag(e)) – prüfen" else: age_text = f"vor {age} Tag(en)" freshness_rows.append( f"{html.escape(source)}{html.escape(str(latest or 'unbekannt'))}" f"{status}{age_text}" ) source_freshness_table = "".join(freshness_rows) top_kpi_cards = ( f"
    Warnhinweise{len(warnings)}einfache Regeln
    " f"
    Dokumente Review{unreviewed}nicht geprüft
    " f"
    Symptomtage{len(complete_symptom_days)}vollständige Quick-Logs
    " f"
    Laborwerte{lab_param_count}{lab_value_count} Einzelwerte
    " + latest_nutrition_card + next_med_card ) c_ext.close() meta = load_doctor_report_meta() pdf_local = REPORTS / "arztbericht_aktuell.pdf" pdf_link = "PDF öffnen" if pdf_local.exists() else "Noch kein PDF generiert." drive_link = "" if meta: up = meta.get('drive_upload') or {} url = up.get('webViewLink') or up.get('file', {}).get('webViewLink') or up.get('webViewUrl') if url: drive_link = f" PDF in Google Drive öffnen" now = datetime.now().strftime("%Y-%m-%d %H:%M") out = output or (REPORTS / "health_dashboard_v4.html") html_text = f"""JARVIS Health Dashboard v4

    JARVIS Health Dashboard v4

    Generiert: {now}

    Heute & Aktionen

    {today_actions}

    Relevante Übersicht

    {top_kpi_cards}

    Quellenfrische

    Frische bewertet ausschließlich den technischen Datenstand, nicht Gesundheit oder medizinisches Risiko.
    {source_freshness_table}
    QuelleLetzter DatentagStatusAlter

    Aktuelle Hinweise

    {warning_cards}
    Arzttermin-Modus

    Schlüssellabore

    {lab_latest_cards}

    Medikation

    {medication_brief_cards}

    Relevante Dokumente

      {appointment_doc_rows}

    Letzte Symptome

    {recent_sym_cards}

    Arztbericht PDF

    {pdf_link}{drive_link}

    Aktualisieren: python3 {BASE}/scripts/generate_doctor_report.py && python3 {BASE}/scripts/health_pipeline.py dashboard

    Warnlogik & To-dos
    Automatische Hinweise unterstützen Datenprüfung und Arztvorbereitung. Keine erkannten Hinweise schließen medizinische Risiken nicht aus und sind keine Diagnose.
    {warning_rows}
    LevelHinweisDetails
    Ernährung & Histamin
    Hinweis: Histamin-Ampeln nutzen lokale SIGHi-inspirierte Regeln plus Alias-Mapping; rot nur bei hoher Gesamtlast.
    {meal_explorer_html}
    Explorative multimodale Zusammenhänge

    Histamin-Load und dokumentierte Symptomtage

    Lücken bleiben Lücken: nicht dokumentierte Symptomtage werden nicht als symptomfrei dargestellt.

    Vollständige Datenpaare nach Behandlungsphase

    Nur Hypothesen: Rangkorrelationen sind vollständig fallbasiert, phasenstratifiziert und mehrfachtestkorrigiert. Sie zeigen keine Ursache, Diagnose, Therapieempfehlung oder Entwarnung.
    {correlation_rows}
    PrädiktorPhaseLagn / beobachtet / erwartetZiel-CoverageρqStatusInterpretation
    Personal Tolerance
    Rein persönliche, zeitgebundene Dokumentation; keine Lebensmittel-Sicherheitsklassifikation oder allgemeine Verträglichkeitsaussage. Datenvollständigkeit und Beobachtungszeitraum können begrenzt sein. Automatische Legacy-Safe-/Trigger-Kandidaten bleiben deaktiviert.

    Personal Tolerance Layer

    {tolerance_rows}
    LebensmittelgruppeStatusEvidenzNotizAktualisiert
    Low-Histamine Experiment Tracker
    Dokumentationsansicht: Baseline-, Beobachtungs- und Challenge-Phasen sind rein prospektive persönliche Dokumentation. Sie prüfen keine Kausalität und sind keine Therapie- oder Challenge-Empfehlung. Fehlende Symptom- oder Ernährungsdaten bleiben unbekannt. Potenziell riskante Expositionen nur nach ärztlicher Abstimmung.
    {experiment_rows}
    IDStartEndePhaseDokumentierte ExpositionStatusHypothese/Notiz
    Mapping Review Queue
    {review_rows}
    BeispielproduktVorkommenErstmalsZuletztGrund
    Dokumente & PDFs

    Aktuelle Dokumente

    Links öffnen über Tailscale-Route.
    {doc_view_rows}
    IDDokumentDatumKategorieInstitutionReview

    Dokumenten-Inbox Review

    {doc_review_rows}
    ReviewKategorieAnzahl
    CLI: python3 {BASE}/scripts/health_doc_review.py ID --status arzttermin|relevant|archiviert
    Symptome
    {symptom_chart}

    Daily Symptom Quick Log

    Alle sieben Dimensionen sind Pflicht. Fehlende Angaben werden nicht als 0 gespeichert.
    {''.join(f"" for key,label in [('aphthen','Aphthen/Mundulzera'),('gi','GI/Darm'),('fatigue','Müdigkeit/Fatigue'),('skin','Haut'),('eyes','Augen'),('joints','Gelenke'),('vascular','Vaskulär/Thrombose-Warnzeichen')])}
    Health Timeline
    {timeline_rows}
    DatumTypEintrag
    System, Archiv & Legacy-Listen

    Technische/alte Listen — nützlich für Debugging, aber nicht primär für die tägliche Ansicht.

    Systemstatus
    {cards}
    Medikations-Timeline Rohdaten
    {medication_rows}
    DatumMedikamentEreignisDosisNächste geplantNotiz
    Health Event Periods
    {period_rows}
    StartEndeTypLabelSchweregradNotizen
    Laborberichte / Original-PDFs
    {lab_doc_rows}
    IDOriginalStatus
    Klinische Events, Medikamente & Symptome
    {event_rows}{symptom_rows}
    DatumKategorieParameter/SymptomWert/Notiz
    Letzte Dokumente Legacy
    {doc_rows}
    IDDateiKategorieStatusReviewVolltext-Zeichen

    Evidenz- und Provenienzhinweise

    Diese Ansicht unterstützt Dokumentation und Arztvorbereitung. Sie ist keine Diagnose, Therapieempfehlung oder Entwarnung.

    Laborangaben müssen gegen den validierten Originalbericht geprüft werden. Fehlende Daten bedeuten unbekannt und nicht symptomfrei oder unauffällig.

    Explorative Zusammenhänge sind hypothesengenerierend und belegen keine Ursache.

    """ out.parent.mkdir(parents=True, exist_ok=True) temporary_output = out.with_name(f".{out.name}.{os.getpid()}.tmp") try: temporary_output.write_text(html_text, encoding="utf-8") os.replace(temporary_output, out) finally: temporary_output.unlink(missing_ok=True) c = conn() c.execute( "INSERT INTO report_runs(report_type, output_path, summary) VALUES(?,?,?)", ("dashboard_v4", str(out), "Dashboard v4 mit lokaler Chart-Auslieferung generiert"), ) c.commit() c.close() print(out) if __name__ == "__main__": parser = argparse.ArgumentParser(description="Generate Health Dashboard v4") parser.add_argument("--output", type=Path, default=None) args = parser.parse_args() main(args.output)