Upload folder using huggingface_hub

home.py

@@ -0,0 +1,352 @@
+import os
+from datetime import datetime
+from typing import Dict, Any, List, Tuple
+
+import gradio as gr
+import pandas as pd
+from plotly.graph_objects import Figure, Scatter
+
+# ----- DB wiring -----
+# Expects your SheamiDB class to be in modules/db.py
+# from modules.db import SheamiDB
+# For illustration, we lazy-import at runtime to avoid import errors if path differs.
+from dotenv import load_dotenv
+
+from ui import get_app_theme, get_app_title, get_css
+
+load_dotenv(override=True)
+DB_URI = os.getenv("MONGODB_URI")
+DB_NAME = os.getenv("MONGODB_DB", "sheami")
+
+
+def get_db():
+    from modules.db import SheamiDB  # imported here so this file stays portable
+
+    return SheamiDB(DB_URI, db_name=DB_NAME)
+
+
+# ----- Data shaping helpers -----
+
+
+def _fmt(dt: Any) -> str:
+    if isinstance(dt, (datetime,)):
+        return dt.strftime("%Y-%m-%d %H:%M")
+    if isinstance(dt, str):
+        return dt
+    return ""
+
+
+def flatten_reports(reports: List[Dict[str, Any]]) -> pd.DataFrame:
+    """Explode parsed tests inside each report to a flat table."""
+    rows = []
+    for r in reports:
+        rid = str(r.get("_id", ""))
+        uploaded_at = _fmt(r.get("uploaded_at"))
+        file_name = r.get("file_name", "")
+        tests = (r.get("parsed_data") or {}).get("tests", [])
+        if not tests:
+            rows.append(
+                {
+                    "report_id": rid,
+                    "uploaded_at": uploaded_at,
+                    "file_name": file_name,
+                    "test_name": "",
+                    "value": "",
+                    "unit": "",
+                    "reference_range": "",
+                }
+            )
+        else:
+            for t in tests:
+                rows.append(
+                    {
+                        "report_id": rid,
+                        "uploaded_at": uploaded_at,
+                        "file_name": file_name,
+                        "test_name": t.get("name", ""),
+                        "value": t.get("value", ""),
+                        "unit": t.get("unit", ""),
+                        "reference_range": t.get("reference_range", ""),
+                    }
+                )
+    if not rows:
+        rows = [
+            {
+                k: ""
+                for k in [
+                    "report_id",
+                    "uploaded_at",
+                    "file_name",
+                    "test_name",
+                    "value",
+                    "unit",
+                    "reference_range",
+                ]
+            }
+        ]
+    return pd.DataFrame(rows)
+
+
+def trends_index(trends: List[Dict[str, Any]]) -> List[str]:
+    names = sorted({t.get("test_name", "") for t in trends if t.get("test_name")})
+    return names
+
+
+def build_trend_figure(trend_doc: Dict[str, Any]) -> Figure:
+    """Make a Plotly line chart for a single test's trend_data."""
+    points = trend_doc.get("trend_data", [])
+    if not points:
+        fig = Figure()
+        fig.update_layout(
+            title="No trend data", xaxis_title="Date", yaxis_title="Value"
+        )
+        return fig
+    dates = [pd.to_datetime(p.get("date")) for p in points]
+    values = [p.get("value") for p in points]
+    fig = Figure()
+    fig.add_trace(
+        Scatter(
+            x=dates,
+            y=values,
+            mode="lines+markers",
+            name=trend_doc.get("test_name", "Trend"),
+        )
+    )
+    fig.update_layout(
+        margin=dict(l=30, r=20, t=40, b=30),
+        xaxis_title="Date",
+        yaxis_title="Value",
+        title=f"Trend — {trend_doc.get('test_name','')} ({len(points)} points)",
+    )
+    return fig
+
+
+# ----- App state + loaders -----
+
+
+def load_user(email: str) -> Tuple[Dict[str, Any], List[Tuple[str, str]]]:
+    """Return (user_dict, patient_choices[(label, value), ...])"""
+    if not email:
+        return {}, []
+    db = get_db()
+    user = db.get_user_by_email(email)
+    if not user:
+        return {}, []
+    # Preload patients
+    patients = db.get_patients_by_user(str(user["_id"]))
+    choices = [(p.get("name", str(p["_id"])), str(p["_id"])) for p in patients]
+    return user, choices
+
+
+def load_patient_bundle(
+    patient_id: str,
+) -> Tuple[pd.DataFrame, List[str], Dict[str, Any], List[Dict[str, Any]]]:
+    """
+    Given patient_id, return:
+    - reports_df
+    - test_names (for dropdown)
+    - meta dict with patient basics
+    - final_reports list
+    """
+    if not patient_id:
+        return pd.DataFrame(), [], {}, []
+    db = get_db()
+    # patient
+    patient = (
+        db.patients.find_one(
+            {
+                "_id": db.patients._Database__client.codec_options.document_class.objectid_class(
+                    patient_id
+                )
+            }
+        )
+        if False
+        else db.patients.find_one({"_id": __import__("bson").ObjectId(patient_id)})
+    )
+    # related
+    reports = db.get_reports_by_patient(patient_id)
+    trends = db.get_trends_by_patient(patient_id)
+    finals = db.get_final_reports_by_patient(patient_id)
+
+    reports_df = flatten_reports(reports)
+    test_names = trends_index(trends)
+
+    meta = {
+        "Patient": patient.get("name", ""),
+        "Gender": patient.get("gender", ""),
+        "DOB": patient.get("dob", ""),
+        "Created": _fmt(patient.get("created_at")),
+    }
+    return reports_df, test_names, meta, finals
+
+
+def load_trend_figure(patient_id: str, test_name: str) -> Figure:
+    if not (patient_id and test_name):
+        return Figure()
+    db = get_db()
+    doc = db.trends.find_one(
+        {"patient_id": __import__("bson").ObjectId(patient_id), "test_name": test_name}
+    )
+    return build_trend_figure(doc or {})
+
+
+def format_final_reports(finals: List[Dict[str, Any]]) -> pd.DataFrame:
+    rows = []
+    for fr in finals:
+        rows.append(
+            {
+                "final_report_id": str(fr.get("_id", "")),
+                "generated_at": _fmt(fr.get("generated_at")),
+                "summary": fr.get("summary", ""),
+                "recommendations": "; ".join(fr.get("recommendations", [])),
+            }
+        )
+    return pd.DataFrame(
+        rows
+        or [
+            {
+                "final_report_id": "",
+                "generated_at": "",
+                "summary": "",
+                "recommendations": "",
+            }
+        ]
+    )
+
+
+def add_patient_ui(user_email, name, age, gender):
+    db = get_db()
+    user = db.get_user_by_email(user_email)
+    if not user:
+        return "User not found"
+    pid = db.add_patient(user["_id"], name, age, gender)
+    return f"✅ Patient {name} added (ID: {pid})"
+
+
+def edit_patient_ui(patient_id, name, age, gender):
+    db = get_db()
+    success = db.update_patient(
+        patient_id, {"name": name, "age": age, "gender": gender}
+    )
+    return "✅ Updated" if success else "❌ Patient not found"
+
+
+def delete_patient_ui(patient_id):
+    db = get_db()
+    success = db.delete_patient(patient_id)
+    return "✅ Deleted" if success else "❌ Patient not found"
+
+
+# ----- Gradio UI -----
+# ----- Gradio UI (Sidebar Layout) -----
+with gr.Blocks(
+    title=get_app_title(), theme=get_app_theme(), css=get_css(), fill_height=True
+) as demo:
+    with gr.Row():
+        with gr.Column(scale=1):  # Sidebar
+            gr.Markdown("### Sidebar")
+
+            email_in = gr.Textbox(label="User Email", placeholder="doctor1@sheami.com")
+            load_btn = gr.Button("🔍 Load Patients")
+
+            patient_list = gr.Radio(label="Patients", choices=[], interactive=True)
+
+            with gr.Accordion("➕ Add Patient", open=False):
+                new_name = gr.Textbox(label="Name")
+                new_age = gr.Number(label="Age")
+                new_gender = gr.Dropdown(["M", "F"], label="Gender")
+                add_btn = gr.Button("Add")
+                add_out = gr.Textbox(label="Status")
+
+            delete_btn = gr.Button("🗑️ Delete Selected")
+            delete_out = gr.Textbox(label="Status")
+
+        with gr.Column(scale=3):  # Main area
+            with gr.Row():
+                edit_name = gr.Textbox(label="Edit Name")
+                edit_age = gr.Number(label="Edit Age")
+                edit_gender = gr.Dropdown(["M", "F"], label="Edit Gender")
+                edit_btn = gr.Button("✏️ Save Changes")
+                edit_out = gr.Textbox(label="Status")
+
+            meta_box = gr.JSON(label="Patient Details")
+
+            with gr.Tabs():
+                with gr.Tab("📄 Reports"):
+                    reports_df = gr.DataFrame(
+                        headers=[
+                            "report_id",
+                            "uploaded_at",
+                            "file_name",
+                            "test_name",
+                            "value",
+                            "unit",
+                            "reference_range",
+                        ],
+                        row_count=(0, "dynamic"),
+                        wrap=True,
+                        interactive=False,
+                    )
+                with gr.Tab("📈 Trends"):
+                    test_dd = gr.Dropdown(
+                        choices=[], label="Select Test", interactive=True
+                    )
+                    trend_plot = gr.Plot(label="Trend Chart")
+                with gr.Tab("✅ Final Reports"):
+                    final_df = gr.DataFrame(
+                        headers=[
+                            "final_report_id",
+                            "generated_at",
+                            "summary",
+                            "recommendations",
+                        ],
+                        row_count=(0, "dynamic"),
+                        wrap=True,
+                        interactive=False,
+                    )
+
+    # ---- Events ----
+    def on_load(email):
+        user, patient_choices = load_user(email)
+        return gr.update(choices=patient_choices), {}
+
+    load_btn.click(on_load, inputs=[email_in], outputs=[patient_list, meta_box])
+
+    def on_patient_select(patient_id):
+        reports_df_val, test_names, meta, finals = load_patient_bundle(patient_id)
+        return (
+            meta,
+            reports_df_val,
+            gr.update(choices=test_names),
+            format_final_reports(finals),
+        )
+
+    patient_list.change(
+        on_patient_select,
+        inputs=[patient_list],
+        outputs=[meta_box, reports_df, test_dd, final_df],
+    )
+
+    def on_test_change(patient_id, test_name):
+        return load_trend_figure(patient_id, test_name)
+
+    test_dd.change(on_test_change, inputs=[patient_list, test_dd], outputs=trend_plot)
+
+    add_btn.click(
+        add_patient_ui,
+        inputs=[email_in, new_name, new_age, new_gender],
+        outputs=add_out,
+    )
+
+    delete_btn.click(
+        delete_patient_ui, inputs=[patient_list], outputs=delete_out
+    )
+
+    edit_btn.click(
+        edit_patient_ui,
+        inputs=[patient_list, edit_name, edit_age, edit_gender],
+        outputs=edit_out,
+    )
+
+if __name__ == "__main__":
+    demo.launch()

modules/db.py

@@ -0,0 +1,145 @@
+import os
+from pymongo import MongoClient
+from datetime import datetime
+from bson import ObjectId
+from dotenv import load_dotenv
+
+class SheamiDB:
+    def __init__(self, uri: str, db_name: str = "sheami"):
+        """Initialize connection to MongoDB Atlas (or local Mongo)."""
+        self.client = MongoClient(uri)
+        self.db = self.client[db_name]
+
+        # Collections
+        self.users = self.db["users"]
+        self.patients = self.db["patients"]
+        self.reports = self.db["reports"]
+        self.trends = self.db["trends"]
+        self.final_reports = self.db["final_reports"]
+
+    # ---------------------------
+    # USER FUNCTIONS
+    # ---------------------------
+    def add_user(self, email: str, name: str) -> str:
+        user = {
+            "email": email,
+            "name": name,
+            "created_at": datetime.utcnow()
+        }
+        result = self.users.insert_one(user)
+        return str(result.inserted_id)
+
+    def get_user(self, user_id: str) -> dict:
+        return self.users.find_one({"_id": ObjectId(user_id)})
+
+    # ---------------------------
+    # PATIENT FUNCTIONS
+    # ---------------------------
+    def add_patient(self, user_id: str, name: str, dob: str, gender: str) -> str:
+        patient = {
+            "user_id": ObjectId(user_id),
+            "name": name,
+            "dob": dob,
+            "gender": gender,
+            "created_at": datetime.utcnow()
+        }
+        result = self.patients.insert_one(patient)
+        return str(result.inserted_id)
+
+    def get_patients_by_user(self, user_id: str) -> list:
+        return list(self.patients.find({"user_id": ObjectId(user_id)}))
+
+    # ---------------------------
+    # REPORT FUNCTIONS
+    # ---------------------------
+    def add_report(self, patient_id: str, file_name: str, parsed_data: dict) -> str:
+        report = {
+            "patient_id": ObjectId(patient_id),
+            "uploaded_at": datetime.utcnow(),
+            "file_name": file_name,
+            "parsed_data": parsed_data
+        }
+        result = self.reports.insert_one(report)
+        return str(result.inserted_id)
+
+    def get_reports_by_patient(self, patient_id: str) -> list:
+        return list(self.reports.find({"patient_id": ObjectId(patient_id)}))
+
+    # ---------------------------
+    # TREND FUNCTIONS
+    # ---------------------------
+    def add_or_update_trend(self, patient_id: str, test_name: str, trend_data: list):
+        """Insert new trend or update existing one."""
+        self.trends.update_one(
+            {"patient_id": ObjectId(patient_id), "test_name": test_name},
+            {"$set": {"trend_data": trend_data, "last_updated": datetime.utcnow()}},
+            upsert=True
+        )
+
+    def get_trends_by_patient(self, patient_id: str) -> list:
+        return list(self.trends.find({"patient_id": ObjectId(patient_id)}))
+
+    # ---------------------------
+    # FINAL REPORT FUNCTIONS
+    # ---------------------------
+    def add_final_report(self, patient_id: str, summary: str, recommendations: list, trend_snapshots: list) -> str:
+        final_report = {
+            "patient_id": ObjectId(patient_id),
+            "generated_at": datetime.utcnow(),
+            "summary": summary,
+            "recommendations": recommendations,
+            "trend_snapshots": trend_snapshots
+        }
+        result = self.final_reports.insert_one(final_report)
+        return str(result.inserted_id)
+
+    def get_final_reports_by_patient(self, patient_id: str) -> list:
+        return list(self.final_reports.find({"patient_id": ObjectId(patient_id)}))
+
+    # ---------------------------
+    # FETCH FULL USER DATA
+    # ---------------------------
+    def get_user_by_email(self, email: str) -> dict:
+        """Fetch user by email."""
+        return self.users.find_one({"email": email})
+
+    def get_user_full_data(self, user_id: str) -> dict:
+        """
+        Fetch user + all patients, reports, trends, final reports
+        for populating UI (tabbed layout).
+        """
+        user = self.get_user(user_id)
+        if not user:
+            return {}
+
+        # Get patients for user
+        patients = self.get_patients_by_user(user_id)
+        full_patients = []
+
+        for patient in patients:
+            pid = str(patient["_id"])
+
+            # Fetch related collections
+            patient_reports = self.get_reports_by_patient(pid)
+            patient_trends = self.get_trends_by_patient(pid)
+            patient_final_reports = self.get_final_reports_by_patient(pid)
+
+            full_patients.append({
+                "patient": patient,
+                "reports": patient_reports,
+                "trends": patient_trends,
+                "final_reports": patient_final_reports
+            })
+
+        return {
+            "user": user,
+            "patients": full_patients
+        }
+
+    def update_patient(self, patient_id, fields: dict):
+        result = self.patients.update_one({"_id": patient_id}, {"$set": fields})
+        return result.modified_count > 0
+
+    def delete_patient(self, patient_id):
+        result = self.patients.delete_one({"_id": patient_id})
+        return result.deleted_count > 0

pyproject.toml

@@ -7,6 +7,7 @@ requires-python = ">=3.13"
 dependencies = [
     "authlib>=1.6.1",
     "dotenv>=0.9.9",
+    "faker>=37.5.3",
     "fastapi>=0.116.1",
     "gradio>=5.42.0",
     "gradio-modal>=0.0.4",
@@ -17,7 +18,8 @@ dependencies = [
     "markdown2>=2.5.4",
     "matplotlib>=3.10.5",
     "pandas>=2.3.1",
-    "pymongo[srv]>=4.14.0",
+    "plotly>=6.3.0",
+    "pymongo>=4.14.0",
     "pypdf>=6.0.0",
     "python-multipart>=0.0.20",
     "reportlab>=4.4.3",

tests/generate_test_data.py

@@ -0,0 +1,202 @@
+"""
+scripts/generate_test_data.py
+
+Generates realistic test data for Sheami using your modules.db.SheamiDB API.
+
+Behavior:
+- Creates N users (default 100)
+- Each user: 3-5 patients (enforced)
+- Each patient: 2-6 reports
+- Each report: 3-6 tests drawn from TEST_POOL
+- For each patient we write trends (per test) using add_or_update_trend
+- For each patient we write a final report using add_final_report
+
+Usage:
+  pip install faker pymongo python-dotenv
+  MONGODB_URI="mongodb+srv://<user>:<pass>@cluster0.xxxxx.mongodb.net" \
+  MONGODB_DB="sheami" \
+  python scripts/generate_test_data.py --num-users 100
+
+The script CALLS THESE EXACT methods on your SheamiDB:
+- add_user(email, name)
+- add_patient(user_id, name, dob, gender)
+- add_report(patient_id, file_name, parsed_data)
+- add_or_update_trend(patient_id, test_name, trend_data)
+- add_final_report(patient_id, summary, recommendations, trend_snapshots)
+"""
+import argparse
+import random
+from collections import defaultdict
+from datetime import datetime, timedelta
+import os
+
+from faker import Faker
+from dotenv import load_dotenv
+
+# Ensure env is loaded
+load_dotenv()
+
+# import your DB wrapper
+from modules.db import SheamiDB
+
+# ---------- Config & test pool ----------
+faker = Faker()
+TEST_POOL = {
+    "Hemoglobin": (11.0, 17.5, "g/dL", "11.0-17.5"),
+    "Glucose (Fasting)": (60, 130, "mg/dL", "70-99 fasting"),
+    "Total Cholesterol": (120, 300, "mg/dL", "<200 desirable"),
+    "Triglycerides": (40, 300, "mg/dL", "<150 normal"),
+    "HDL": (30, 90, "mg/dL", ">40 desirable"),
+    "LDL": (50, 200, "mg/dL", "<100 ideal"),
+    "Creatinine": (0.5, 1.8, "mg/dL", "0.5-1.2"),
+    "Urea (BUN)": (7, 30, "mg/dL", "7-20"),
+    "Sodium": (130, 150, "mmol/L", "135-145"),
+    "Potassium": (3.2, 5.2, "mmol/L", "3.5-5.0"),
+    "ALT": (7, 55, "U/L", "<45"),
+    "AST": (8, 48, "U/L", "<40"),
+}
+
+def random_date_between(start_year=2019):
+    start = datetime(start_year, 1, 1)
+    end = datetime.now()
+    days = (end - start).days
+    return start + timedelta(days=random.randint(0, days))
+
+def make_test_values(k):
+    """Return list of test dicts matching parsed_data.tests schema."""
+    chosen = random.sample(list(TEST_POOL.items()), k=k)
+    tests = []
+    for name, (low, high, unit, ref) in chosen:
+        # generate float for float ranges, int for integer-like
+        if isinstance(low, float) or isinstance(high, float):
+            value = round(random.uniform(low, high), 2)
+        else:
+            value = int(round(random.uniform(low, high)))
+        tests.append({
+            "name": name,
+            "value": value,
+            "unit": unit,
+            "reference_range": ref
+        })
+    return tests
+
+def compute_direction(points):
+    if len(points) < 2:
+        return "stable"
+    if points[-1]["value"] > points[-2]["value"]:
+        return "increasing"
+    if points[-1]["value"] < points[-2]["value"]:
+        return "decreasing"
+    return "stable"
+
+# ---------- Generator function ----------
+def generate_test_data(db_uri: str, db_name: str, num_users: int = 100,
+                       min_patients=3, max_patients=5,
+                       min_reports=2, max_reports=6,
+                       min_tests=3, max_tests=6,
+                       seed: int = None):
+    if seed is not None:
+        random.seed(seed)
+        Faker.seed(seed)
+
+    db = SheamiDB(db_uri, db_name=db_name)
+
+    counters = {"users": 0, "patients": 0, "reports": 0, "trends": 0, "final_reports": 0}
+
+    for u_idx in range(num_users):
+        # create user
+        user_name = faker.name()
+        user_email = faker.unique.safe_email()
+        user_id = db.add_user(email=user_email, name=user_name)
+        counters["users"] += 1
+
+        # 3-5 patients per user (as requested)
+        num_patients = random.randint(min_patients, max_patients)
+        for _p in range(num_patients):
+            patient_name = faker.name()
+            # realistic DOB between 18 and 85
+            age = random.randint(18, 85)
+            dob_dt = datetime.now() - timedelta(days=365 * age + random.randint(0, 365))
+            dob_str = dob_dt.strftime("%Y-%m-%d")
+            gender = random.choice(["male", "female", "other"])
+
+            patient_id = db.add_patient(user_id=user_id, name=patient_name, dob=dob_str, gender=gender)
+            counters["patients"] += 1
+
+            # collect trend points per test name
+            trends_map = defaultdict(list)
+
+            # 2-6 reports per patient
+            num_reports = random.randint(min_reports, max_reports)
+            for r_i in range(num_reports):
+                report_date_dt = random_date_between()
+                report_date = report_date_dt.strftime("%Y-%m-%d")
+                num_tests = random.randint(min_tests, max_tests)
+                tests = make_test_values(num_tests)
+
+                parsed_data = {
+                    "tests": tests,
+                    "report_date": report_date
+                }
+                file_name = f"report_{report_date.replace('-', '')}_{random.randint(1000,9999)}.pdf"
+                report_id = db.add_report(patient_id=patient_id, file_name=file_name, parsed_data=parsed_data)
+                counters["reports"] += 1
+
+                # append to trends_map
+                for t in tests:
+                    trends_map[t["name"]].append({"date": report_date, "value": t["value"]})
+
+            # write trends to DB using add_or_update_trend (upsert)
+            for test_name, points in trends_map.items():
+                # sort points by date
+                pts_sorted = sorted(points, key=lambda x: x["date"])
+                db.add_or_update_trend(patient_id=patient_id, test_name=test_name, trend_data=pts_sorted)
+                counters["trends"] += 1
+
+            # create a final report summarizing trends
+            trend_snapshots = []
+            for test_name, points in trends_map.items():
+                pts_sorted = sorted(points, key=lambda x: x["date"])
+                latest_value = pts_sorted[-1]["value"]
+                direction = compute_direction(pts_sorted)
+                trend_snapshots.append({
+                    "test_name": test_name,
+                    "latest_value": latest_value,
+                    "direction": direction
+                })
+
+            summary = f"Auto-generated summary for {patient_name} ({len(trend_snapshots)} tests)"
+            recommendations = []
+            # simple heuristic: if any trending up, recommend follow-up
+            if any(ts["direction"] == "increasing" for ts in trend_snapshots):
+                recommendations.append("Follow up for rising values")
+            else:
+                recommendations.append("Continue routine monitoring")
+            db.add_final_report(patient_id=patient_id,
+                                summary=summary,
+                                recommendations=recommendations,
+                                trend_snapshots=trend_snapshots)
+            counters["final_reports"] += 1
+
+        # occasional progress print
+        if (u_idx + 1) % 10 == 0 or (u_idx + 1) == num_users:
+            print(f"Created {u_idx+1}/{num_users} users so far...")
+
+    # summary
+    print("Generation complete. Summary:")
+    for k, v in counters.items():
+        print(f"  {k}: {v}")
+
+# ---------- CLI ----------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Generate test data for Sheami (matches your db.py).")
+    parser.add_argument("--num-users", type=int, default=100, help="Number of users to create")
+    parser.add_argument("--db-uri", type=str, default=os.getenv("MONGODB_URI", "mongodb://localhost:27017"),
+                        help="MongoDB connection URI")
+    parser.add_argument("--db-name", type=str, default=os.getenv("MONGODB_DB", "sheami"),
+                        help="Database name")
+    parser.add_argument("--seed", type=int, default=None, help="Random seed (optional)")
+    args = parser.parse_args()
+
+    generate_test_data(db_uri=args.db_uri, db_name=args.db_name,
+                       num_users=args.num_users, seed=args.seed)

tests/test_db.py

@@ -0,0 +1,71 @@
+# ---------------------------
+# Example usage
+# ---------------------------
+import json
+import os
+from dotenv import load_dotenv
+
+from modules.db import SheamiDB
+
+if __name__ == "__main__":
+    load_dotenv(override=True)
+    db = SheamiDB(os.getenv("DB_URI"))
+
+    # Suppose logged-in user email is known
+    user = db.get_user_by_email("doctor1@sheami.com")
+    if user:
+        user_id = str(user["_id"])
+        data = db.get_user_full_data(user_id)
+        print("data = ",json.dumps(data,indent=1))
+
+        # Now `data` looks like:
+        # {
+        #   "user": {...},
+        #   "patients": [
+        #       {
+        #          "patient": {...},
+        #          "reports": [...],
+        #          "trends": [...],
+        #          "final_reports": [...]
+        #       }, ...
+        #   ]
+        # }
+        print(data)
+    else:        
+        # Add user
+        user_id = db.add_user("doctor1@sheami.com", "Dr. Smith")
+
+        # Add patient
+        patient_id = db.add_patient(user_id, "John Doe", "1980-05-20", "male")
+
+        # Add report
+        parsed_data = {
+            "tests": [
+                {"name": "Hemoglobin", "value": 13.5, "unit": "g/dL", "reference_range": "13.0-17.0"},
+                {"name": "Cholesterol", "value": 210, "unit": "mg/dL", "reference_range": "<200"}
+            ]
+        }
+        report_id = db.add_report(patient_id, "bloodwork_july.pdf", parsed_data)
+
+        # Add trend
+        db.add_or_update_trend(patient_id, "Hemoglobin", [
+            {"date": "2025-05-01", "value": 13.2},
+            {"date": "2025-07-01", "value": 13.5},
+            {"date": "2025-08-19", "value": 13.8}
+        ])
+
+        # Add final report
+        final_report_id = db.add_final_report(
+            patient_id,
+            "Hemoglobin stable, cholesterol slightly high.",
+            ["Maintain healthy diet", "Check cholesterol in 3 months"],
+            [
+                {"test_name": "Hemoglobin", "latest_value": 13.8, "direction": "stable"},
+                {"test_name": "Cholesterol", "latest_value": 210, "direction": "increasing"}
+            ]
+        )
+
+        print("User ID:", user_id)
+        print("Patient ID:", patient_id)
+        print("Report ID:", report_id)
+        print("Final Report ID:", final_report_id)

tests/test_pdf_generation.py

@@ -0,0 +1,51 @@
+import os
+import tempfile
+import matplotlib.pyplot as plt
+import base64
+from weasyprint import HTML
+
+from config import SheamiConfig
+from pdf_helper import generate_pdf
+
+def test_generate_pdf():
+    from pathlib import Path
+
+    # Temporary directory for plots
+    tmp_dir = tempfile.mkdtemp()
+    
+    # 1. Fake interpretation HTML
+    interpretation_html = """
+    <h1>Test Patient: John Doe</h1>
+    <p>Age: 45, Sex: Male</p>
+    <p>Clinical Summary:</p>
+    <ul>
+        <li>All vitals normal ✅</li>
+        <li>Minor deviation in cholesterol ▲</li>
+        <li>Vitamin D slightly low ▼</li>
+    </ul>
+    """
+
+    # 2. Generate 4 fake plots
+    plot_files = []
+    for i in range(4):
+        plt.figure(figsize=(4,3))
+        plt.plot([1,2,3,4], [i*2+1, i*2+2, i*2+1, i*2+3], marker='o')
+        plt.title(f"Test Plot {i+1}")
+        plt.xlabel("X")
+        plt.ylabel("Y")
+        plot_path = os.path.join(tmp_dir, f"plot_{i+1}.png")
+        plt.savefig(plot_path)
+        plt.close()
+        plot_files.append((f"Test {i+1}", plot_path))
+
+    # 3. Use your SheamiConfig logo path, or fallback to a sample image
+    logo_path = SheamiConfig.logo_path if hasattr(SheamiConfig, 'logo_path') else plot_files[0][1]
+
+    # 4. Call the generate_pdf function
+    pdf_path = os.path.join(tmp_dir, "test_report.pdf")
+    generate_pdf(pdf_path=pdf_path, interpretation_html=interpretation_html, plot_files=plot_files)
+
+    print(f"Test PDF generated at: {pdf_path}")
+
+
+test_generate_pdf()

uv.lock

@@ -362,6 +362,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892, upload-time = "2025-02-19T22:15:01.647Z" },
 ]
 
+[[package]]
+name = "faker"
+version = "37.5.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/5d/7797a74e8e31fa227f0303239802c5f09b6722bdb6638359e7b6c8f30004/faker-37.5.3.tar.gz", hash = "sha256:8315d8ff4d6f4f588bd42ffe63abd599886c785073e26a44707e10eeba5713dc", size = 1907147, upload-time = "2025-07-30T15:52:19.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/bf/d06dd96e7afa72069dbdd26ed0853b5e8bd7941e2c0819a9b21d6e6fc052/faker-37.5.3-py3-none-any.whl", hash = "sha256:386fe9d5e6132a915984bf887fcebcc72d6366a25dd5952905b31b141a17016d", size = 1949261, upload-time = "2025-07-30T15:52:17.729Z" },
+]
+
 [[package]]
 name = "fastapi"
 version = "0.116.1"
@@ -1004,6 +1016,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
 ]
 
+[[package]]
+name = "narwhals"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/f0/b0550d9b84759f4d045fd43da2f811e8b23dc2001e38c3254456da7f3adb/narwhals-2.1.2.tar.gz", hash = "sha256:afb9597e76d5b38c2c4b7c37d27a2418b8cc8049a66b8a5aca9581c92ae8f8bf", size = 533772, upload-time = "2025-08-15T08:24:50.916Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/01/824fff6789ce92a53242d24b6f5f3a982df2f610c51020f934bf878d2a99/narwhals-2.1.2-py3-none-any.whl", hash = "sha256:136b2f533a4eb3245c54254f137c5d14cef5c4668cff67dc6e911a602acd3547", size = 392064, upload-time = "2025-08-15T08:24:48.788Z" },
+]
+
 [[package]]
 name = "numpy"
 version = "2.3.2"
@@ -1216,6 +1237,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835, upload-time = "2025-07-01T09:15:50.399Z" },
 ]
 
+[[package]]
+name = "plotly"
+version = "6.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "narwhals" },
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a0/64/850de5076f4436410e1ce4f6a69f4313ef6215dfea155f3f6559335cad29/plotly-6.3.0.tar.gz", hash = "sha256:8840a184d18ccae0f9189c2b9a2943923fd5cae7717b723f36eef78f444e5a73", size = 6923926, upload-time = "2025-08-12T20:22:14.127Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/a9/12e2dc726ba1ba775a2c6922d5d5b4488ad60bdab0888c337c194c8e6de8/plotly-6.3.0-py3-none-any.whl", hash = "sha256:7ad806edce9d3cdd882eaebaf97c0c9e252043ed1ed3d382c3e3520ec07806d4", size = 9791257, upload-time = "2025-08-12T20:22:09.205Z" },
+]
+
 [[package]]
 name = "pycparser"
 version = "2.22"
@@ -1550,6 +1584,7 @@ source = { virtual = "." }
 dependencies = [
     { name = "authlib" },
     { name = "dotenv" },
+    { name = "faker" },
     { name = "fastapi" },
     { name = "gradio" },
     { name = "gradio-modal" },
@@ -1560,6 +1595,7 @@ dependencies = [
     { name = "markdown2" },
     { name = "matplotlib" },
     { name = "pandas" },
+    { name = "plotly" },
     { name = "pymongo" },
     { name = "pypdf" },
     { name = "python-multipart" },
@@ -1572,6 +1608,7 @@ dependencies = [
 requires-dist = [
     { name = "authlib", specifier = ">=1.6.1" },
     { name = "dotenv", specifier = ">=0.9.9" },
+    { name = "faker", specifier = ">=37.5.3" },
     { name = "fastapi", specifier = ">=0.116.1" },
     { name = "gradio", specifier = ">=5.42.0" },
     { name = "gradio-modal", specifier = ">=0.0.4" },
@@ -1582,7 +1619,8 @@ requires-dist = [
     { name = "markdown2", specifier = ">=2.5.4" },
     { name = "matplotlib", specifier = ">=3.10.5" },
     { name = "pandas", specifier = ">=2.3.1" },
-    { name = "pymongo", extras = ["srv"], specifier = ">=4.14.0" },
+    { name = "plotly", specifier = ">=6.3.0" },
+    { name = "pymongo", specifier = ">=4.14.0" },
     { name = "pypdf", specifier = ">=6.0.0" },
     { name = "python-multipart", specifier = ">=0.0.20" },
     { name = "reportlab", specifier = ">=4.4.3" },