Update backend.py

backend.py

@@ -1,60 +1,36 @@
+import os
 from ast import List
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException,APIRouter, Request
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from typing import Optional
-import pytesseract
-from PIL import Image
 import io
-import fitz  
-import base64
+import fitz
 import traceback
 import pandas as pd
+
+import base64
+import json
 import re
-import os
+import asyncio
+import functools
+from typing import Any, Optional
+
 import google.generativeai as genai
-from dotenv import load_dotenv
-from fastapi.responses import RedirectResponse
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException, APIRouter, Request
+from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 import firebase_admin
 from firebase_admin import credentials, firestore
 from google.generativeai import generative_models
-
-from api_key import GEMINI_API_KEY
-from bert import analyze_with_clinicalBert, classify_disease_and_severity, extract_non_negated_keywords, analyze_measurements, detect_past_diseases
-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 pydantic import BaseModel
 from past_reports import router as reports_router, db_fetch_reports
 
-model = genai.GenerativeModel('gemini-1.5-flash')
-df = pd.read_csv("measurement.csv")
-df.columns = df.columns.str.lower()
-df['measurement'] = df['measurement'].str.lower()
-
-disease_links = {"cholesterol": "https://www.webmd.com/cholesterol"}
-disease_next_steps = {"cholesterol": ["Consult a doctor for a lipid panel."]}
-disease_doctor_specialty = {"cholesterol": "Cardiologist"}
-disease_home_care = {"cholesterol": ["Maintain a healthy diet."]}
+from api_key import GEMINI_API_KEY 
 
 app = FastAPI()
-
 api = APIRouter(prefix="/api")
 app.include_router(api)
 
-
-'''app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "http://localhost:8002"
-        "http://localhost:9000"
-        "http://localhost:5501"
-    ],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)'''
-
+EXTRACTED_TEXT_CACHE = ""
 
 app.mount("/app", StaticFiles(directory="web", html=True), name="web")
 app.include_router(reports_router)
@@ -70,38 +46,60 @@ app.add_middleware(
 @app.get("/")
 def root():
     return RedirectResponse(url="/app/")
-    
-EXTRACTED_TEXT_CACHE: str = ""
-
-try:
-    gemini_api_key = os.environ.get("GEMINI_API_KEY", GEMINI_API_KEY)
-    if not gemini_api_key:
-        raise ValueError("No Gemini API key found in environment or api_key.py")
-    genai.configure(api_key=gemini_api_key)
-except Exception as e:
-    raise RuntimeError(f"Failed to configure Gemini API: {e}")
-
-try:
-    cred_path = os.environ.get("FIREBASE_SERVICE_ACCOUNT_KEY_PATH", "firebase_key.json")
-    
-    if not os.path.exists(cred_path):
-        raise ValueError(
-            f"Firebase service account key not found. Looked for: {cred_path}. "
-            "Set FIREBASE_SERVICE_ACCOUNT_KEY_PATH or place firebase_key.json in project root."
-        )
 
-    cred = credentials.Certificate(cred_path)
-    firebase_admin.initialize_app(cred)
-    db = firestore.client()
-except Exception as e:
-    raise RuntimeError(f"Failed to configure Firebase: {e}")
+class AnalyzeRequest(BaseModel):
+    image_base64: str
+    prompt: Optional[str] = None
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", GEMINI_API_KEY)
+
+if not GEMINI_API_KEY:
+    raise RuntimeError(
+        "No Gemini API key found. Put it in api_key.py as `GEMINI_API_KEY = '...'` or set env var GEMINI_API_KEY."
+    )
+
+genai.configure(api_key=GEMINI_API_KEY)
 
+generation_config = {
+    "temperature": 0.2,    
+    "top_p": 0.95,
+    "top_k": 40,
+    "max_output_tokens": 2048,
+}
+
+safety_settings = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+]
+
+# --- Pydantic Models for API Endpoints ---
 class ChatRequest(BaseModel):
     user_id: Optional[str] = "anonymous"
     question: str
-
+    
 class ChatResponse(BaseModel):
     answer: str
+    
+class TextRequest(BaseModel):
+    text: str
+
+system_prompt = """ As a highly skilled medical practitioner specializing in image analysis, you are tasked with examining medical images for a renowned hospital. Your expertise is crucial in identifying any anomalies, diseases, or health issues that may be present in the images. Your responsibilities include: 
+1. Detailed Analysis: Thoroughly analyze each image, focusing on identifying any abnormal findings that may indicate underlying medical conditions. 
+2. Finding Report: Document all observed anomalies or signs of disease. Clearly articulate these findings in a structured report format, ensuring accuracy and clarity. Also include any measurement found such as trygliceride, HBa1c, and hdl levels. When presenting any found measurement, relay it in this format: {"findings": "Condition that this measurement could affect only if the value is in a risky rang: masurement type -- value with unit(current range). For example: {"findings": "Diabetes: Hba1c -- 8%(diabetic)", "ldl -- 80mg/dL(optimal)"}"
+    At the beginning of every finding, if needed try to simplify the information given in 3 words.
+3. Checking for Past: If a disease is considered family history or is a disease that the patient recovered from(anything anomoly that is historical), please mention this in severity using this format: "severity" : "severity of the anomoly (Past Anomoly but Still Under Risk)"
+4. Recommendations and Next Steps: Provide detailed recommendations based on your findings. Outline the necessary follow-up actions or additional tests required to confirm diagnoses or assess treatment options. 
+5. Treatment Suggestions: Offer preliminary treatment suggestions or interventions based on the identified conditions, collaborating with the healthcare team to develop comprehensive patient care plans. 
+6. Output Format: Your output should be a JSON array (list) of objects, each describing one disease or medical finding using the structure below: 
+[{"findings": "Description of the first disease or condition.", "severity": "MILD/SEVERE/CRITICAL", "recommendations": ["Follow-up test 1", "Follow-up test 2"], "treatment_suggestions": ["Treatment 1", "Treatment 2"], "home_care_guidance": ["Care tip 1", "Care tip 2"] }, { "findings": "Description of the second disease or condition.", "severity": "MILD/SEVERE/CRITICAL", "recommendations": ["Follow-up test A", "Follow-up test B"], "treatment_suggestions": ["Treatment A", "Treatment B"], "home_care_guidance": ["Care tip A", "Care tip B"] } ] 
+Important Notes: 
+    1. Scope of Response: Only respond if the image pertains to a human health issue. 
+    2. Clarity of Image: Ensure the image is clear and suitable for accurate analysis. 
+    3. As an AI, don't produce any output than doesn't follow this format and also remember that we need your input on the medical report for a team of renowned doctors to recheck your readings and determine AI's role in the medical industry. 
+    4. Your Insights are Invaluable: Your insights play a crucial role in guiding clinical decisions. Please proceed with your analysis, adhering to the structured approach outlined above.
+    5. Completely UPPERCASE the main concern in the finding """
 
 system_prompt_chat = """
 *** Role: Medical Guidance Facilitator
@@ -112,7 +110,9 @@ Analyze medical data, provide concise, evidence-based insights, and recommend ac
 2. Historical Context – Compare current findings with any available previous reports.
 3. Medical Q&A – Answer specific questions about the report using trusted medical sources.
 4. Specialist Matching – Recommend relevant physician specialties for identified conditions.
-5. Safety Protocols – Include a brief disclaimer encouraging users to verify information, confirm insurance coverage, and consult providers directly.
+5. Local Physician Recommendations – List at least two real physician or clinic options within the user-specified mile radius (include name, specialty, address, distance from user, and contact info) based on the patient’s location and clinical need.
+6. Insurance Guidance – If insurance/network information is provided, prioritize in-network physicians.
+7. Safety Protocols – Include a brief disclaimer encouraging users to verify information, confirm insurance coverage, and consult providers directly.
 *** Response Structure:
 Start with a direct answer to the user’s primary question (maximum 4 concise sentences, each on a new line).
 If a physician/specialist is needed, recommend at least two local providers within the requested radius (include name, specialty, address, distance, and contact info).
@@ -124,55 +124,56 @@ User Question: {user_question}
 Assistant Answer:
 """
 
-def extract_images_from_pdf_bytes(pdf_bytes: bytes) -> list:
-    print("***Start of Code***")
-    doc = fitz.open(stream=pdf_bytes, filetype="pdf")
-    images = []
-    for page in doc:
-        pix = page.get_pixmap()
-        buf = io.BytesIO()
-        buf.write(pix.tobytes("png"))
-        images.append(buf.getvalue())
-    return images
-
-
-def clean_ocr_text(text: str) -> str:
-    text = text.replace("\x0c", " ")
-    text = text.replace("\u00a0", " ")    
-    text = re.sub(r'(\d)\s*\.\s*(\d)', r'\1.\2', text) 
-    text = re.sub(r'\s+', ' ', text)      
-    return text.strip()
-
-def ocr_text_from_image(image_bytes: bytes) -> str:
-    base64_image = base64.b64encode(image_bytes).decode('utf-8')
-
-    image_content = {
-        'mime_type': 'image/jpeg',
-        'data': base64_image
-    }
-
-    prompt = "Could you read this document and just take all the text that is in it and just paste it back to me in text format. Open and read this document:"
-
-    response = model.generate_content(
-        [prompt, image_content]
+# Initialize model
+model = genai.GenerativeModel(model_name="gemini-2.5-flash-lite")
+
+async def _call_model_blocking(request_inputs, generation_cfg, safety_cfg):
+    """Run blocking model call in threadpool (so uvicorn's event loop isn't blocked)."""
+    fn = functools.partial(
+        model.generate_content,
+        request_inputs,
+        generation_config=generation_cfg,
+        safety_settings=safety_cfg,
     )
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, fn)
 
-    response_text = response.text
-    print(response_text)
 
-    return response_text
-def get_past_reports_from_firestore(user_id: str):
+async def analyze_image(image_bytes: bytes, mime_type: str, prompt: Optional[str] = None) -> Any:
+    base64_img = base64.b64encode(image_bytes).decode("utf-8")
+    text_prompt = (prompt or system_prompt).strip()
+
+    request_inputs = [
+        {"inline_data": {"mime_type": mime_type, "data": base64_img}},
+        {"text": text_prompt},
+    ]
+
     try:
-        reports_ref = db.collection('users').document(request.user_id).collection('reports')
-        docs = reports_ref.order_by('timestamp', direction=firestore.Query.DESCENDING).limit(10).stream()
-        
-        history_text = ""
-        for doc in docs:
-            report_data = doc.to_dict()
-            history_text += f"Report from {report_data.get('timestamp', 'N/A')}:\n{report_data.get('ocr_text', 'No OCR text found')}\n\n"
+        response = await _call_model_blocking(request_inputs, generation_config, safety_settings)
     except Exception as e:
-        history_text = "No past reports found for this user."
-    return history_text
+        raise RuntimeError(f"Model call failed: {e}")
+
+    text = getattr(response, "text", None)
+    if not text and isinstance(response, dict):
+        candidates = response.get("candidates") or []
+        if candidates:
+            text = candidates[0].get("content") or candidates[0].get("text")
+    if not text:
+        text = str(response)
+
+    clean = re.sub(r"```(?:json)?", "", text).strip()
+
+    try:
+        parsed = json.loads(clean)
+        return parsed
+    except json.JSONDecodeError:
+        match = re.search(r"(\[.*\]|\{.*\})", clean, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except json.JSONDecodeError:
+                return {"raw_found_json": match.group(1)}
+        return {"raw_output": clean}
 
 def get_past_reports_from_sqllite(user_id: str):
     try:
@@ -187,156 +188,46 @@ def get_past_reports_from_sqllite(user_id: str):
 
 @app.post("/chat/", response_model=ChatResponse)
 async def chat_endpoint(request: ChatRequest):
-    """
-    Chatbot endpoint that answers questions based on the last analyzed document and user history.
-    """
-    print("Received chat request for user:", request.user_id)
-    #history_text = get_past_reports_from_firestore(request.user_id)
-    history_text = get_past_reports_from_sqllite(request.user_id)
-
-    full_document_text = EXTRACTED_TEXT_CACHE + "\n\n" + "PAST REPORTS:\n" + history_text
-
-    if not full_document_text:
-        raise HTTPException(status_code=400, detail="No past reports or current data exists for this user")
-    
-    
-   
-    
+    global result
     try:
+        document_text = json.dumps(result) if result else "No parsed text available"
         full_prompt = system_prompt_chat.format(
-            document_text=full_document_text,
+            document_text=document_text,
             user_question=request.question
         )
+        data = await request.json()
+        question = data.get("question")
+        report_text = data.get("report_text")
+        user_id = data.get("user_id")
+
         response = model.generate_content(full_prompt)
         return ChatResponse(answer=response.text)
     except Exception as e:
-        print(f"Gemini API error: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"An error occurred during chat response generation: {e}")
-
-@app.post("/analyze/")
-async def analyze(
-    file: UploadFile = File(...),
-    model: Optional[str] = Form("bert"),
-    mode: Optional[str] = Form(None)
-):
-    global resolution, EXTRACTED_TEXT_CACHE
-    if not file.filename:
-        raise HTTPException(status_code=400, detail="No file uploaded.")
-
-    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)
-    else:
-        content = await file.read()
-        image_bytes_list = [content]
-
-    for img_bytes in image_bytes_list:
-        ocr_text = ocr_text_from_image(img_bytes)
-        ocr_full += ocr_text + "\n\n"
-        ocr_full = clean_ocr_text(ocr_full)
-        print(f"CALLING OCR FULL: {ocr_full}")
-    
-    EXTRACTED_TEXT_CACHE = ocr_full
-
-
-    if model.lower() == "gemini":
-        return {"message": "Gemini model not available; please use BERT model."}
+        raise HTTPException(status_code=500, detail=f"Chat error: {e}")
 
-    found_diseases = extract_non_negated_keywords(ocr_full)
-    past = detect_past_diseases(ocr_full)
-
-    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))
-        else:
-            severity = classify_disease_and_severity(disease)
-            detected_diseases.add((disease, severity))
-           
-        
-   
-    print("Detected diseases:", detected_diseases)
-    ranges = analyze_measurements(ocr_full, df)
-
-
-    resolution = []
-    detected_ranges = []
-    for disease, severity in detected_diseases:
-        link = disease_links.get(disease.lower(), "https://www.webmd.com/")
-        next_steps = disease_next_steps.get(disease.lower(), ["Consult a doctor."])
-        specialist = disease_doctor_specialty.get(disease.lower(), "General Practitioner")
-        home_care = disease_home_care.get(disease.lower(), [])
-
-        resolution.append({
-            "findings": disease.upper(),
-            "severity": severity,
-            "recommendations": next_steps,
-            "treatment_suggestions": f"Consult a specialist: {specialist}",
-            "home_care_guidance": home_care,
-            "info_link": link
-                      
-    })
-    
-    for i in ranges:
-        condition = i[0]
-        measurement = i[1]
-        unit = i[2]
-        severity = i[3]
-        value = i[4]
-        range_value = i[5]   # renamed to avoid overwriting Python's built-in "range"
-                    
-        link_range = disease_links.get(condition.lower(), "https://www.webmd.com/")
-        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(), [])
-                    
-        condition_version = condition.upper()    
-        severity_version = severity.upper()
-                
-        resolution.append({
-            "findings": f"{condition_version} -- {measurement}",
-            "severity": f"{value} {unit} - {severity_version}",
-            "recommendations": next_steps_range,
-            "treatment_suggestions": f"Consult a specialist: {specialist_range}",
-            "home_care_guidance": home_care_range,
-            "info_link": link_range
-        })
-                            
-    
-    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)
-    
-    return {
-        "ocr_text": ocr_full.strip(),
-        "Detected_Anomolies": resolution,
-    }
-
-class TextRequest(BaseModel):
-    text: str
-    
-@app.post("/analyze-text")
-async def analyze_text_endpoint(request: TextRequest):
+@app.post("/analyze")
+async def analyze_endpoint(file: UploadFile = File(...), prompt: str = Form(None)):
+    global result
+    """
+    Upload an image file (field name `file`) and optional text `prompt`.
+    Returns parsed JSON (or raw model output if JSON couldn't be parsed).
+    """
+    contents = await file.read()  # <-- this gets the uploaded file bytes
+    mime = file.content_type or "image/png"
+    result = await analyze_image(contents, mime, prompt)
     try:
-        return analyze_text(request.text)
+        result = await analyze_image(contents, mime, prompt)
     except Exception as e:
-        print("ERROR in /analyze-text:", traceback.format_exc())
-        raise HTTPException(status_code=500, detail=f"Error analyzing text: {str(e)}")
-    
-
-def analyze_text(text):
-    severity, disease = classify_disease_and_severity(text)
-    return {
-        "extracted_text": text,
-        "summary": f"Detected Disease: {disease}, Severity: {severity}"
-    }
-
-
+        raise HTTPException(status_code=500, detail=str(e))
+    return JSONResponse(content={"Detected_Anomolies": result})
+
+@app.post("/analyze_json")
+async def analyze_json(req: AnalyzeRequest):
+    import base64
+    image_bytes = base64.b64decode(req.image_base64)
+    result = await analyze_image(image_bytes, "image/png", req.prompt)
+    return {"result": result}
+   
 @app.get("/health/")
 def health():
     return {"response": "ok"}
@@ -347,4 +238,4 @@ def _log_routes():
     print("Mounted routes:")
     for r in app.routes:
         if isinstance(r, APIRoute):
-            print(" ", r.path, r.methods)
+            print(" ", r.path, r.methods)