fixes for front end

.gitignore

@@ -1,4 +1,7 @@
 .venv
 /api_key.py
 api_key.py
-.DS_Store
+.DS_Store
+firebase_key.json
+.env
+.vscode

Dockerfile

@@ -57,12 +57,21 @@ COPY . .
 # Writable caches
 RUN mkdir -p /cache/hf /tmp && chmod -R 777 /cache /tmp
 
+
+# If you have a starter DB in the repo, uncomment the next line to seed it:
+RUN mkdir -p /data && chmod -R 777 /data
+#COPY app.db /data/app.db
+ENV DB_DIR=/data
+ENV DB_PATH=/data/app.db
+# (optional) expose as a volume so you can mount from host if you want persistence
+VOLUME ["/data"]
+
 #ENV PORT=8000
 EXPOSE 7860
 
 HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
   CMD curl -fsS "http://127.0.0.1:${PORT:-7860}/api/health/" || exit 1
 
-# ✅ bind to $PORT provided by HF; include proxy headers
+# bind to $PORT provided by HF; include proxy headers
 CMD ["sh","-c","uvicorn backend:app --host 0.0.0.0 --port ${PORT:-7860} --proxy-headers --forwarded-allow-ips='*'"]
 

backend.py

@@ -24,6 +24,7 @@ from bert import analyze_with_clinicalBert, classify_disease_and_severity, extra
 from disease_links import diseases as disease_links
 from disease_steps import disease_next_steps
 from disease_support import disease_doctor_specialty, disease_home_care
+from past_reports import router as reports_router
 
 model = genai.GenerativeModel('gemini-1.5-flash')
 df = pd.read_csv("measurement.csv")
@@ -55,6 +56,7 @@ app.include_router(api)
 
 
 app.mount("/app", StaticFiles(directory="web", html=True), name="web")
+app.include_router(reports_router)
 
 app.add_middleware(
     CORSMiddleware,
@@ -204,6 +206,7 @@ async def analyze(
     filename = file.filename.lower()
     detected_diseases = set()
     ocr_full = ""
+    print("Received request for file:", filename)
     if filename.endswith(".pdf"):
         pdf_bytes = await file.read()
         image_bytes_list = extract_images_from_pdf_bytes(pdf_bytes)
@@ -224,22 +227,19 @@ async def analyze(
         return {"message": "Gemini model not available; please use BERT model."}
 
     found_diseases = extract_non_negated_keywords(ocr_full)
-    print(f"CALLING FOUND DISEASES: {found_diseases}")
     past = detect_past_diseases(ocr_full)
-    print(f"CALLING PAST DISEASES: {past}")
 
     for disease in found_diseases:
         if disease in past:    
             severity = classify_disease_and_severity(disease)
             detected_diseases.add(((f"{disease}(detected as historical condition, but still under risk.)"), severity))
-            print(f"DETECTED DISEASES(PAST): {detected_diseases}")
         else:
             severity = classify_disease_and_severity(disease)
             detected_diseases.add((disease, severity))
-            print(f"DETECTED DISEASES: {detected_diseases}")
+           
         
-    print("OCR TEXT:", ocr_text)
-    print("Detected diseases:", found_diseases)
+   
+    print("Detected diseases:", detected_diseases)
     ranges = analyze_measurements(ocr_full, df)
 
 
@@ -273,7 +273,6 @@ async def analyze(
         next_steps_range = disease_next_steps.get(condition.lower(), ['Consult a doctor'])
         specialist_range = disease_doctor_specialty.get(condition.lower(), "General Practitioner")
         home_care_range = disease_home_care.get(condition.lower(), [])
-        print(f"HELLO!: {measurement}")
                     
         condition_version = condition.upper()    
         severity_version = severity.upper()
@@ -287,12 +286,11 @@ async def analyze(
             "info_link": link_range
         })
                             
-    print(ocr_full)
+    
     ranges = analyze_measurements(ocr_full, df)
     print(analyze_measurements(ocr_full, df))
     # print ("Ranges is being printed", ranges)
     historical_med_data = detect_past_diseases(ocr_full)
-    print("***End of Code***")
     
     return {
         "ocr_text": ocr_full.strip(),
@@ -323,10 +321,10 @@ def analyze_text(text):
 def health():
     return {"response": "ok"}
 
-@app.route("/save_report/")
+'''@app.route("/save_report/")
 async def save_report(request: Request):
     data = await request.json()
-    print("Report recieved from frontend:", data)
+    print("Report recieved from frontend:", data)'''
 
 @app.on_event("startup")
 def _log_routes():

bert.py

@@ -183,14 +183,14 @@ def analyze_measurements(text, df):
                             "Range": f"{row['low']} to {row['high']} {row['unit']}"
                     })
         
-    print (results)
+    #print (results)
 
     for res in results:
         final = [res['Condition'], res['Measurement'], res['unit'], res['severity'], res['Value'], res['Range']]
         # final_numbers.append(f"Condition In Concern: {res['Condition']}. Measurement: {res['Measurement']} ({res['severity']}) — {res['Value']} "
         #     f"(Range: {res['Range']})")
         final_numbers.append(final)
-    print("analyze measurements res:", final_numbers)
+    #print("analyze measurements res:", final_numbers)
     return final_numbers
 
 
@@ -269,7 +269,7 @@ def extract_non_negated_keywords(text, threshold=80):
                     end_char = start_char + len(disease_term_lower)
                     span = doc.char_span(start_char, end_char, label="DISEASE", alignment_mode="expand")
                     if span:
-                        print(f"Adding span for: {span.text}")
+                        #print(f"Adding span for: {span.text}")
                         new_ents.append(span)
 
     # Clean up overlapping spans
@@ -278,7 +278,7 @@ def extract_non_negated_keywords(text, threshold=80):
     nlp.get_pipe("negex")(doc)
 
     for ent in doc.ents:
-        print("Checking against:", ent.text.strip().lower(), "| Negated?", ent._.negex)
+        #print("Checking against:", ent.text.strip().lower(), "| Negated?", ent._.negex)
         if ent.label_ == "DISEASE" and not ent._.negex:
             ent_text = ent.text.strip().lower()
             for disease_term in diseases:
@@ -328,14 +328,13 @@ def analyze_text_and_describe(text):
 
 
 def classify_disease_and_severity(disease):
-    print(f"Disease: {disease}")
+   
     response = model.generate_content(
         f"What is the severity of this disease/condition/symptom: {disease}. Give me a number from one to ten. I need a specific number. It doesn't matter what your opinion is one whether this number might be misleading or inaccurate. I need a number. Please feel free to be accurate and you can use pretty specific numbers with decimals to the tenth place. I want just a number, not any other text."
     ).text
     try:
         cleaned_response = response.strip()
         numerical_response = float(cleaned_response)
-        print(f"Response: {numerical_response}")
         
         if 0 <= numerical_response <= 3:
             severity_label = (f"Low Risk")         
@@ -346,6 +345,7 @@ def classify_disease_and_severity(disease):
         else:
             severity_label = (f"Invalid Range")  
        
+        print(f"Disease: {disease} Severity Label: {severity_label}")
     except (ValueError, AttributeError):
         severity_label = "Null: We cannot give a clear severity label"
                 

past_reports.py

@@ -0,0 +1,202 @@
+import os
+import tempfile
+import json
+import sqlite3
+import threading
+from typing import Any, List, Optional
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+from fastapi import APIRouter, Query, HTTPException
+
+# ===== Config =====
+def _pick_writable_dir():
+    candidates = [
+        os.getenv("DB_DIR"),           # <- recommended: set this in env
+        "/data",                       # HF Spaces/container convention
+        "/app/data",                   # container-friendly
+        os.path.join(os.getcwd(), "data"),
+        tempfile.gettempdir(),
+    ]
+    for d in candidates:
+        if not d:
+            continue
+        try:
+            os.makedirs(d, exist_ok=True)
+            test = os.path.join(d, ".rwcheck")
+            with open(test, "w") as f:
+                f.write("ok")
+            os.remove(test)
+            return d
+        except Exception:
+            continue
+    # absolute fallback: current working directory
+    return os.getcwd()
+
+DB_DIR = _pick_writable_dir()
+DB_PATH = os.path.join(DB_DIR, os.getenv("DB_FILE", "app.db"))
+
+# ===== SQLite bootstrap =====
+_conn = sqlite3.connect(DB_PATH, check_same_thread=False)
+_conn.execute(
+    """
+    CREATE TABLE IF NOT EXISTS reports (
+        id                INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id        TEXT NOT NULL,
+        report_date       TEXT,
+        ocr_text          TEXT,
+        anomalies    TEXT,
+        measurements TEXT,
+        created_at        TEXT DEFAULT (datetime('now'))
+    )
+    """
+)
+_conn.execute(
+    "CREATE INDEX IF NOT EXISTS idx_reports_user_created ON reports(user_id, created_at DESC)"
+)
+_conn.commit()
+_db_lock = threading.Lock()
+
+
+def _safe_parse_json(text):
+    if text is None:
+        return None
+    s = text.strip()
+    if not s:
+        return None
+    # Try real JSON first
+    try:
+        return json.loads(s)
+    except json.JSONDecodeError:
+        pass
+    # Common legacy cases: Python repr (single quotes, True/False/None)
+    try:
+        return ast.literal_eval(s)
+    except Exception:
+        return None  # or return s if you prefer to surface the raw text
+
+def _row_to_dict(row: sqlite3.Row) -> dict:
+    return {
+        "id": row[0],
+        "user_id": row[1],
+        "report_date": row[2],
+        "ocr_text": row[3],
+        "anomalies": _safe_parse_json(row[4]),
+        "measurements": _safe_parse_json(row[5]),
+        "created_at": row[6],
+    }
+
+def db_insert_report(payload: dict) -> int:
+    with _db_lock:
+        cur = _conn.cursor()
+        cur.execute(
+            """
+            INSERT INTO reports (
+                user_id, report_date, ocr_text,
+                anomalies, measurements
+            )
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (
+                payload.get("user_id"),
+                payload.get("report_date"),
+                payload.get("ocr_text"),
+                payload.get("anomalies"),
+                payload.get("measurements"),
+            ),
+        )
+        _conn.commit()
+        return cur.lastrowid
+
+def db_fetch_reports(user_id: str, limit: int = 50, offset: int = 0) -> List[dict]:
+    _conn.row_factory = sqlite3.Row
+    cur = _conn.cursor()
+    cur.execute(
+        """
+        SELECT id, user_id, report_date, ocr_text,
+               anomalies, measurements, created_at
+        FROM reports
+        WHERE user_id = ?
+        ORDER BY datetime(created_at) DESC, id DESC
+        LIMIT ? OFFSET ?
+        """,
+        (user_id, limit, offset),
+    )
+    return [_row_to_dict(r) for r in cur.fetchall()]
+
+def db_get_report(report_id: int) -> Optional[dict]:
+    _conn.row_factory = sqlite3.Row
+    cur = _conn.cursor()
+    cur.execute(
+        """
+        SELECT id, user_id, report_date, ocr_text,
+               anomalies, measurements, created_at
+        FROM reports
+        WHERE id = ?
+        """,
+        (report_id,),
+    )
+    row = cur.fetchone()
+    return _row_to_dict(row) if row else None
+
+def db_delete_report(report_id: int) -> bool:
+    with _db_lock:
+        cur = _conn.cursor()
+        cur.execute("DELETE FROM reports WHERE id = ?", (report_id,))
+        _conn.commit()
+        return cur.rowcount > 0
+
+# ===== Pydantic Schemas =====
+class ReportIn(BaseModel):
+    user_id: str = Field(..., example="[email protected]")
+    report_date: Optional[str] = Field(None, example="2025-09-07")
+    ocr_text: Optional[str] = None
+    anomalies: Optional[Any] = None
+    measurements: Optional[Any] = None
+
+class ReportOut(BaseModel):
+    id: int
+    user_id: str
+    report_date: Optional[str]
+    ocr_text: Optional[str]
+    anomalies: Optional[Any]
+    measurements: Optional[Any]
+    created_at: str
+
+# ===== Router =====
+router = APIRouter(tags=["Reports"])
+
+@router.post("/save_report/", response_model=dict)
+def save_report(body: ReportIn):
+    if not body.user_id:
+        raise HTTPException(status_code=400, detail="user_id is required")
+    print(f"Saving report for user: {body}")
+    rid = db_insert_report(body.dict())
+    return {"ok": True, "id": rid}
+
+@router.get("/reports/", response_model=List[ReportOut])
+def list_reports(
+    user_id: str = Query(..., description="User email to filter by"),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+):
+    return db_fetch_reports(user_id=user_id, limit=limit, offset=offset)
+
+@router.get("/reports/{report_id}", response_model=ReportOut)
+def get_report(report_id: int):
+    row = db_get_report(report_id)
+    if not row:
+        raise HTTPException(status_code=404, detail="Report not found")
+    return row
+
+@router.delete("/reports/{report_id}", response_model=dict)
+def delete_report(report_id: int):
+    if db_delete_report(report_id):
+        return {"ok": True, "deleted": report_id}
+    raise HTTPException(status_code=404, detail="Report not found")
+
+
+if __name__ == "__main__":
+    #req = ReportIn(user_id="[email protected]", report_date="2025-09-08", ocr_text="Medical Report - Cancer Patient Name: Carol Davis Age: 55 Gender: Female Clinical History: Recent biopsy confirms breast cancer (invasive ductal carcinoma). No lymph node involvement. PET scan negative for metastasis.", anomalies=[{"findings":"BREAST CANCER(DETECTED AS HISTORICAL CONDITION, BUT STILL UNDER RISK.)","severity":"Severe Risk","recommendations":["Consult a doctor."],"treatment_suggestions":"Consult a specialist: General Practitioner","home_care_guidance":[],"info_link":"https://www.webmd.com/"},{"findings":"CANCER(DETECTED AS HISTORICAL CONDITION, BUT STILL UNDER RISK.)","severity":"Severe Risk","recommendations":["Consult a doctor."],"treatment_suggestions":"Consult a specialist: General Practitioner","home_care_guidance":[],"info_link":"https://www.webmd.com/"},{"findings":"BRAIN CANCER(DETECTED AS HISTORICAL CONDITION, BUT STILL UNDER RISK.)","severity":"Severe Risk","recommendations":["Consult a doctor."],"treatment_suggestions":"Consult a specialist: General Practitioner","home_care_guidance":[],"info_link":"https://www.webmd.com/"}], measurements=[])
+    #save_report(req)
+    print(db_fetch_reports(user_id="[email protected]"))

web/analyzer.html

@@ -189,30 +189,8 @@
         </li>
       </ul>
     </nav>
-    <script>
-      (function () {
-        const isLocal = /^(localhost|127\.0\.0\.1)$/.test(location.hostname);
-    
-        // Optional overrides
-        const qs = new URLSearchParams(location.search);
-        const override = qs.get("api");                 // e.g. ?api=http://localhost:9000
-        const saved = localStorage.getItem("API_BASE"); // remember last override
-    
-        const base =
-          override ||
-          saved ||
-          // Local dev: call FastAPI on 8000; HF: use same origin (works from / or /proxy/8002)
-          (isLocal ? "http://localhost:8000" : location.origin);
-    
-        if (override) localStorage.setItem("API_BASE", override);
-    
-        window.API_BASE = base.replace(/\/$/, ""); // trim trailing slash
-        // helper to build URLs without double slashes
-        window.api = (path) =>
-          window.API_BASE + (path.startsWith("/") ? path : "/" + path);
-      })();
-    </script>
-    
+    <!--Shared helpers (API base + query params) -->
+    <script src="script.js"></script>
     <script>
       const hamburger = document.getElementById("hamburger");
       const mobileMenu = document.getElementById("mobile-menu");
@@ -530,16 +508,21 @@
             findingsOutput.innerHTML = findings
               .map((finding, i) => renderRecCard(finding, i))
               .join("");
-          } else {
-            findingsOutput.textContent = "No measurements found.";
-          }
-
+          } 
           if (currentUser) {
-            await saveAnalysis(currentUser.uid, {
+            /*await saveAnalysis(currentUser.uid, {
               reportDate: date,
               ocr_text: extractedText,
-              resolutions: recs,
+              anomalies: recs,
               measurements: findings,
+            });*/
+
+            await postReportToBackend({
+              user_id: currentUser.email,
+              report_date: date,
+              ocr_text: extractedText,
+              anomalies: JSON.stringify(recs),
+              measurements: JSON.stringify(findings),
             });
           }
 

web/past_data.html

@@ -4,6 +4,8 @@
   <meta charset="UTF-8">
   <title>Past Analyzes - CTRL + ALT + HEAL</title>
   <script src="https://cdn.tailwindcss.com"></script>
+   <!--Shared helpers (API base + query params) -->
+   <script src="script.js"></script>
 </head>
 <body class="bg-[#F7F8F9] min-h-screen">
   <nav class="bg-white border border-gray-200 px-6 py-4 mb-8">
@@ -99,16 +101,34 @@
     onAuthStateChanged(auth, async (user) => {
       if (user) {
         statusEl.textContent = `Signed in as ${user.email || user.uid}`;
-      const q = query(
+      /*const q = query(
         collection(db, "users", user.uid, "analyses"),
         orderBy("createdAt", "desc")
       );
-      const snap = await getDocs(q);
-        if (snap.empty) {
-          recsEl.innerHTML = '<p class="text-sm text-gray-500">No saved analyses yet.</p>';
-          return;
+      const snap = await getDocs(q);*/
+
+      async function getPastReports() {
+          try {
+            const url = api('reports/', { user_id: user.email });
+            const response = await fetch(url, {
+              method: 'GET',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            });
+            if (!response.ok) {
+              throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            console.log('Report successfully sent to backend:', data);
+            recsEl.innerHTML = data.map(doc => renderAnalysis(doc)).join("");
+          } catch (error) {
+            console.error('Error sending report to backend:', error);
+            recsEl.innerHTML = '<p class="text-sm text-gray-500">No saved analyses yet.</p>';
+          }
         }
-        recsEl.innerHTML = snap.docs.map(doc => renderAnalysis(doc.data())).join("");
+       getPastReports();
+        
       } else {
         statusEl.textContent = "Not signed in.";
         recsEl.innerHTML = '<p class="text-sm text-gray-500">Please sign in to see your analyses.</p>';

web/script.js

@@ -0,0 +1,99 @@
+// script.js
+(function () {
+    const isLocal = /^(localhost|127\.0\.0\.1)$/.test(location.hostname);
+  
+    // Current page querystring utilities
+    const qs = new URLSearchParams(location.search);
+  
+    // Optional API base override: ?api=http://localhost:9000
+    const override = qs.get("api");
+    const saved = localStorage.getItem("API_BASE");
+  
+    const baseRaw =
+      override ||
+      saved ||
+      // Local dev -> FastAPI on 8000; Prod -> same origin
+      (isLocal ? "http://localhost:8000" : location.origin);
+  
+    if (override) localStorage.setItem("API_BASE", override);
+  
+    let API_BASE = baseRaw.replace(/\/$/, ""); // trim trailing slash
+  
+    function buildUrl(path, params) {
+      // allow absolute URLs
+      const full =
+        /^https?:\/\//i.test(path)
+          ? path
+          : API_BASE + (path.startsWith("/") ? path : "/" + path);
+  
+      const url = new URL(full);
+      if (params && typeof params === "object") {
+        for (const [k, v] of Object.entries(params)) {
+          if (v === undefined || v === null) continue;
+          if (Array.isArray(v)) {
+            v.forEach((val) => url.searchParams.append(k, String(val)));
+          } else {
+            url.searchParams.set(k, String(v));
+          }
+        }
+      }
+      return url.toString();
+    }
+  
+    async function http(method, path, { params, data, headers, ...rest } = {}) {
+      const url = buildUrl(path, params);
+      const init = {
+        method,
+        headers: { Accept: "application/json", ...(headers || {}) },
+        ...rest,
+      };
+  
+      if (data instanceof FormData) {
+        init.body = data; // let browser set multipart boundary
+      } else if (data !== undefined) {
+        init.body = JSON.stringify(data);
+        init.headers["Content-Type"] = "application/json";
+      }
+  
+      const res = await fetch(url, init);
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`${method} ${url} failed (${res.status}) - ${text}`);
+      }
+  
+      const ct = res.headers.get("content-type") || "";
+      return ct.includes("application/json") ? res.json() : res.text();
+    }
+  
+    // ---- Expose globals (usable from any page) ----
+    window.API_BASE = API_BASE;
+    window.setApiBase = (url) => {
+      if (!url) return;
+      const norm = url.replace(/\/$/, "");
+      localStorage.setItem("API_BASE", norm);
+      API_BASE = norm;
+      window.API_BASE = norm;
+    };
+  
+    // Build URL: api(path, params?)
+    window.api = (path, params) => buildUrl(path, params);
+  
+    // Simple HTTP helpers
+    window.apiGet = (path, params, options) =>
+      http("GET", path, { params, ...(options || {}) });
+    window.apiPost = (path, data, options) =>
+      http("POST", path, { data, ...(options || {}) });
+    window.apiPut = (path, data, options) =>
+      http("PUT", path, { data, ...(options || {}) });
+    window.apiDelete = (path, params, options) =>
+      http("DELETE", path, { params, ...(options || {}) });
+    window.apiUpload = (path, formData, params, options) =>
+      http("POST", path, { params, data: formData, ...(options || {}) });
+  
+    // Query helpers for the *current page* (read-only)
+    window.qs = qs; // URLSearchParams instance
+    window.getQueryParam = (name, defVal = null) =>
+      qs.has(name) ? qs.get(name) : defVal;
+    window.getAllQueryParams = () => Object.fromEntries(qs.entries());
+  })();
+