Update app.py

app.py

@@ -9,7 +9,6 @@ import base64
 from datetime import datetime
 from typing import List, Dict, Optional, Tuple
 from enum import Enum
-
 from fastapi import FastAPI, HTTPException, UploadFile, File, Query, Form
 from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
@@ -19,7 +18,7 @@ from bson import ObjectId
 import speech_recognition as sr
 from gtts import gTTS
 from pydub import AudioSegment
-from pydub.playback import play
+import PyPDF2
 from txagent.txagent import TxAgent
 from db.mongo import get_mongo_client
 
@@ -28,12 +27,14 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(
 logger = logging.getLogger("TxAgentAPI")
 
 # App
-app = FastAPI(title="TxAgent API", version="2.3.0")  # Updated version for voice support
+app = FastAPI(title="TxAgent API", version="2.4.0")  # Updated version for file upload support
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"], allow_credentials=True,
-    allow_methods=["*"], allow_headers=["*"]
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"]
 )
 
 # Pydantic Models
@@ -54,6 +55,10 @@ class VoiceOutputRequest(BaseModel):
     slow: bool = False
     return_format: str = "mp3"  # mp3 or base64
 
+class PatientReportAnalysisRequest(BaseModel):
+    patient_id: str
+    file_type: str = "text"  # text, pdf, audio
+
 # Enums
 class RiskLevel(str, Enum):
     NONE = "none"
@@ -122,13 +127,11 @@ def detect_suicide_risk(text: str) -> Tuple[RiskLevel, float, List[str]]:
         'no reason to live', 'plan to die'
     ]
     
-    # Check for explicit mentions
     explicit_mentions = [kw for kw in suicide_keywords if kw in text.lower()]
     
     if not explicit_mentions:
         return RiskLevel.NONE, 0.0, []
     
-    # If found, ask AI for detailed assessment
     assessment_prompt = (
         "Assess the suicide risk level based on this text. "
         "Consider frequency, specificity, and severity of statements. "
@@ -141,11 +144,10 @@ def detect_suicide_risk(text: str) -> Tuple[RiskLevel, float, List[str]]:
         response = agent.chat(
             message=assessment_prompt,
             history=[],
-            temperature=0.2,  # Lower temp for more deterministic responses
+            temperature=0.2,
             max_new_tokens=256
         )
         
-        # Extract JSON from response
         json_match = re.search(r'\{.*\}', response, re.DOTALL)
         if json_match:
             assessment = json.loads(json_match.group())
@@ -157,8 +159,7 @@ def detect_suicide_risk(text: str) -> Tuple[RiskLevel, float, List[str]]:
     except Exception as e:
         logger.error(f"Error in suicide risk assessment: {e}")
     
-    # Fallback if JSON parsing fails
-    risk_score = min(0.1 * len(explicit_mentions), 0.9)  # Cap at 0.9 for fallback
+    risk_score = min(0.1 * len(explicit_mentions), 0.9)
     if risk_score > 0.7:
         return RiskLevel.HIGH, risk_score, explicit_mentions
     elif risk_score > 0.4:
@@ -185,25 +186,112 @@ def serialize_patient(patient: dict) -> dict:
         patient_copy["_id"] = str(patient_copy["_id"])
     return patient_copy
 
-def compute_patient_data_hash(patient: dict) -> str:
-    """Compute SHA-256 hash of patient data."""
-    serialized = json.dumps(patient, sort_keys=True)  # Sort keys for consistent hashing
+def compute_patient_data_hash(data: dict) -> str:
+    """Compute SHA-256 hash of patient data or report."""
+    serialized = json.dumps(data, sort_keys=True)
     return hashlib.sha256(serialized.encode()).hexdigest()
 
+def extract_text_from_pdf(pdf_data: bytes) -> str:
+    """Extract text from a PDF file."""
+    try:
+        pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_data))
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text() or ""
+        return clean_text_response(text)
+    except Exception as e:
+        logger.error(f"Error extracting text from PDF: {e}")
+        raise HTTPException(status_code=400, detail="Failed to extract text from PDF")
+
+async def analyze_patient_report(patient_id: str, report_content: str, file_type: str):
+    """Analyze a patient report and store results."""
+    try:
+        # Compute hash of report content
+        report_data = {"patient_id": patient_id, "content": report_content, "file_type": file_type}
+        report_hash = compute_patient_data_hash(report_data)
+        logger.info(f"🧾 Analyzing report for patient: {patient_id}")
+
+        # Check if analysis exists and hash matches
+        existing_analysis = await analysis_collection.find_one({"patient_id": patient_id, "report_hash": report_hash})
+        if existing_analysis:
+            logger.info(f"✅ No changes in report data for {patient_id}, skipping analysis")
+            return existing_analysis
+
+        # Construct analysis prompt
+        prompt = (
+            "You are a clinical decision support AI. Analyze the following patient report:\n"
+            "1. Summarize the patient's medical history.\n"
+            "2. Identify risks or red flags (including mental health and suicide risk).\n"
+            "3. Highlight missed diagnoses or treatments.\n"
+            "4. Suggest next clinical steps.\n"
+            f"\nPatient Report ({file_type}):\n{'-'*40}\n{report_content[:10000]}"
+        )
+
+        # Perform analysis
+        raw_response = agent.chat(
+            message=prompt,
+            history=[],
+            temperature=0.7,
+            max_new_tokens=1024
+        )
+        structured_response = structure_medical_response(raw_response)
+
+        # Suicide risk assessment
+        risk_level, risk_score, risk_factors = detect_suicide_risk(raw_response)
+        suicide_risk = {
+            "level": risk_level.value,
+            "score": risk_score,
+            "factors": risk_factors
+        }
+
+        # Store analysis
+        analysis_doc = {
+            "patient_id": patient_id,
+            "timestamp": datetime.utcnow(),
+            "summary": structured_response,
+            "suicide_risk": suicide_risk,
+            "raw": raw_response,
+            "report_hash": report_hash,
+            "file_type": file_type
+        }
+
+        await analysis_collection.update_one(
+            {"patient_id": patient_id, "report_hash": report_hash},
+            {"$set": analysis_doc},
+            upsert=True
+        )
+
+        # Create alert for high-risk cases
+        if risk_level in [RiskLevel.MODERATE, RiskLevel.HIGH, RiskLevel.SEVERE]:
+            await create_alert(patient_id, suicide_risk)
+
+        logger.info(f"✅ Stored analysis for patient report {patient_id}")
+        return analysis_doc
+
+    except Exception as e:
+        logger.error(f"Error analyzing patient report: {e}")
+        raise HTTPException(status_code=500, detail="Failed to analyze patient report")
+
+async def analyze_all_patients():
+    """Analyze all patients in the database."""
+    patients = await patients_collection.find({}).to_list(length=None)
+    for patient in patients:
+        await analyze_patient(patient)
+        await asyncio.sleep(0.1)
+
 async def analyze_patient(patient: dict):
+    """Analyze patient data (existing logic for patient records)."""
     try:
         serialized = serialize_patient(patient)
         patient_id = serialized.get("fhir_id")
         patient_hash = compute_patient_data_hash(serialized)
         logger.info(f"🧾 Analyzing patient: {patient_id}")
 
-        # Check if analysis exists and hash matches
         existing_analysis = await analysis_collection.find_one({"patient_id": patient_id})
         if existing_analysis and existing_analysis.get("data_hash") == patient_hash:
             logger.info(f"✅ No changes in patient data for {patient_id}, skipping analysis")
-            return  # Skip analysis if data hasn't changed
+            return
 
-        # Main clinical analysis
         doc = json.dumps(serialized, indent=2)
         message = (
             "You are a clinical decision support AI.\n\n"
@@ -218,7 +306,6 @@ async def analyze_patient(patient: dict):
         raw = agent.chat(message=message, history=[], temperature=0.7, max_new_tokens=1024)
         structured = structure_medical_response(raw)
         
-        # Suicide risk assessment
         risk_level, risk_score, risk_factors = detect_suicide_risk(raw)
         suicide_risk = {
             "level": risk_level.value,
@@ -226,14 +313,13 @@ async def analyze_patient(patient: dict):
             "factors": risk_factors
         }
         
-        # Store analysis with data hash
         analysis_doc = {
             "patient_id": patient_id,
             "timestamp": datetime.utcnow(),
             "summary": structured,
             "suicide_risk": suicide_risk,
             "raw": raw,
-            "data_hash": patient_hash  # Store the hash
+            "data_hash": patient_hash
         }
         
         await analysis_collection.update_one(
@@ -242,7 +328,6 @@ async def analyze_patient(patient: dict):
             upsert=True
         )
         
-        # Create alert if risk is above threshold
         if risk_level in [RiskLevel.MODERATE, RiskLevel.HIGH, RiskLevel.SEVERE]:
             await create_alert(patient_id, suicide_risk)
             
@@ -251,18 +336,11 @@ async def analyze_patient(patient: dict):
     except Exception as e:
         logger.error(f"Error analyzing patient: {e}")
 
-async def analyze_all_patients():
-    patients = await patients_collection.find({}).to_list(length=None)
-    for patient in patients:
-        await analyze_patient(patient)
-        await asyncio.sleep(0.1)
-
 def recognize_speech(audio_data: bytes, language: str = "en-US") -> str:
-    """Convert speech to text using Google's speech recognition"""
+    """Convert speech to text using Google's speech recognition."""
     recognizer = sr.Recognizer()
     
     try:
-        # Convert bytes to AudioFile
         with io.BytesIO(audio_data) as audio_file:
             with sr.AudioFile(audio_file) as source:
                 audio = recognizer.record(source)
@@ -279,7 +357,7 @@ def recognize_speech(audio_data: bytes, language: str = "en-US") -> str:
         raise HTTPException(status_code=500, detail="Error processing speech")
 
 def text_to_speech(text: str, language: str = "en", slow: bool = False) -> bytes:
-    """Convert text to speech using gTTS and return as MP3 bytes"""
+    """Convert text to speech using gTTS and return as MP3 bytes."""
     try:
         tts = gTTS(text=text, lang=language, slow=slow)
         mp3_fp = io.BytesIO()
@@ -323,16 +401,14 @@ async def status():
     return {
         "status": "running",
         "timestamp": datetime.utcnow().isoformat(),
-        "version": "2.3.0",
-        "features": ["chat", "voice-input", "voice-output", "patient-analysis"]
+        "version": "2.4.0",
+        "features": ["chat", "voice-input", "voice-output", "patient-analysis", "report-upload"]
     }
 
 @app.get("/patients/analysis-results")
 async def get_patient_analysis_results(name: Optional[str] = Query(None)):
     try:
         query = {}
-
-        # If a name filter is provided, we search the patients collection first
         if name:
             name_regex = re.compile(name, re.IGNORECASE)
             matching_patients = await patients_collection.find({"full_name": name_regex}).to_list(length=None)
@@ -341,10 +417,7 @@ async def get_patient_analysis_results(name: Optional[str] = Query(None)):
                 return []
             query = {"patient_id": {"$in": patient_ids}}
 
-        # Find analysis results based on patient_ids (or all if no filter)
         analyses = await analysis_collection.find(query).sort("timestamp", -1).to_list(length=100)
-
-        # Attach full_name to each analysis result
         enriched_results = []
         for analysis in analyses:
             patient = await patients_collection.find_one({"fhir_id": analysis["patient_id"]})
@@ -396,18 +469,13 @@ async def transcribe_voice(
     audio: UploadFile = File(...),
     language: str = Query("en-US", description="Language code for speech recognition")
 ):
-    """Convert speech to text"""
+    """Convert speech to text."""
     try:
-        # Read audio file
         audio_data = await audio.read()
-        
-        # Validate audio format
         if not audio.filename.lower().endswith(('.wav', '.mp3', '.ogg', '.flac')):
             raise HTTPException(status_code=400, detail="Unsupported audio format")
         
-        # Convert speech to text
         text = recognize_speech(audio_data, language)
-        
         return {"text": text}
     
     except HTTPException:
@@ -418,16 +486,13 @@ async def transcribe_voice(
 
 @app.post("/voice/synthesize")
 async def synthesize_voice(request: VoiceOutputRequest):
-    """Convert text to speech"""
+    """Convert text to speech."""
     try:
-        # Generate speech from text
         audio_data = text_to_speech(request.text, request.language, request.slow)
         
         if request.return_format == "base64":
-            # Return as base64 encoded string
             return {"audio": base64.b64encode(audio_data).decode('utf-8')}
         else:
-            # Return as MP3 file
             return StreamingResponse(
                 io.BytesIO(audio_data),
                 media_type="audio/mpeg",
@@ -440,9 +505,6 @@ async def synthesize_voice(request: VoiceOutputRequest):
         logger.error(f"Error in voice synthesis: {e}")
         raise HTTPException(status_code=500, detail="Error generating voice output")
 
-
-
-
 @app.post("/voice/chat")
 async def voice_chat_endpoint(
     audio: UploadFile = File(...),
@@ -450,13 +512,11 @@ async def voice_chat_endpoint(
     temperature: float = Query(0.7, ge=0.1, le=1.0),
     max_new_tokens: int = Query(512, ge=50, le=1024)
 ):
-    """Complete voice chat interaction (speech-to-text -> AI -> text-to-speech)"""
+    """Complete voice chat interaction (speech-to-text -> AI -> text-to-speech)."""
     try:
-        # Step 1: Convert speech to text
         audio_data = await audio.read()
         user_message = recognize_speech(audio_data, language)
         
-        # Step 2: Get AI response
         chat_response = agent.chat(
             message=user_message,
             history=[],
@@ -464,10 +524,8 @@ async def voice_chat_endpoint(
             max_new_tokens=max_new_tokens
         )
         
-        # Step 3: Convert response to speech
         audio_data = text_to_speech(chat_response, language.split('-')[0])
         
-        # Return as MP3 file
         return StreamingResponse(
             io.BytesIO(audio_data),
             media_type="audio/mpeg",
@@ -478,4 +536,47 @@ async def voice_chat_endpoint(
         raise
     except Exception as e:
         logger.error(f"Error in voice chat: {e}")
-        raise HTTPException(status_code=500, detail="Error processing voice chat")
+        raise HTTPException(status_code=500, detail="Error processing voice chat")
+
+@app.post("/patient/upload-report")
+async def upload_patient_report(
+    patient_id: str = Form(...),
+    file_type: str = Form("text", description="Type of file: text, pdf, audio"),
+    file: UploadFile = File(...)
+):
+    """Upload and analyze a patient report (text, PDF, or audio)."""
+    try:
+        # Validate patient ID
+        patient = await patients_collection.find_one({"fhir_id": patient_id})
+        if not patient:
+            raise HTTPException(status_code=404, detail=f"Patient {patient_id} not found")
+
+        # Validate file type
+        if file_type not in ["text", "pdf", "audio"]:
+            raise HTTPException(status_code=400, detail="Invalid file type. Supported: text, pdf, audio")
+
+        # Read and process file
+        file_content = await file.read()
+
+        if file_type == "text":
+            report_content = file_content.decode('utf-8')
+        elif file_type == "pdf":
+            report_content = extract_text_from_pdf(file_content)
+        elif file_type == "audio":
+            report_content = recognize_speech(file_content, language="en-US")
+        else:
+            raise HTTPException(status_code=400, detail="Unsupported file type")
+
+        # Analyze the report
+        analysis = await analyze_patient_report(patient_id, report_content, file_type)
+        return JSONResponse(content=analysis)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error processing patient report upload: {e}")
+        raise HTTPException(status_code=500, detail="Error processing patient report")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)