Update app.py

app.py

@@ -19,6 +19,7 @@ import speech_recognition as sr
 from gtts import gTTS
 from pydub import AudioSegment
 import PyPDF2
+import mimetypes
 from txagent.txagent import TxAgent
 from db.mongo import get_mongo_client
 
@@ -27,7 +28,7 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(
 logger = logging.getLogger("TxAgentAPI")
 
 # App
-app = FastAPI(title="TxAgent API", version="2.4.0")  # Updated version for file upload support
+app = FastAPI(title="TxAgent API", version="2.6.0")  # Updated version for optional patient_id
 
 app.add_middleware(
     CORSMiddleware,
@@ -55,10 +56,6 @@ 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"
@@ -191,6 +188,10 @@ def compute_patient_data_hash(data: dict) -> str:
     serialized = json.dumps(data, sort_keys=True)
     return hashlib.sha256(serialized.encode()).hexdigest()
 
+def compute_file_content_hash(file_content: bytes) -> str:
+    """Compute SHA-256 hash of file content."""
+    return hashlib.sha256(file_content).hexdigest()
+
 def extract_text_from_pdf(pdf_data: bytes) -> str:
     """Extract text from a PDF file."""
     try:
@@ -203,18 +204,19 @@ def extract_text_from_pdf(pdf_data: bytes) -> str:
         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):
+async def analyze_patient_report(patient_id: Optional[str], report_content: str, file_type: str, file_content: bytes):
     """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}
+        # Use file content hash as identifier if no patient_id is provided
+        identifier = patient_id if patient_id else compute_file_content_hash(file_content)
+        report_data = {"identifier": identifier, "content": report_content, "file_type": file_type}
         report_hash = compute_patient_data_hash(report_data)
-        logger.info(f"🧾 Analyzing report for patient: {patient_id}")
+        logger.info(f"🧾 Analyzing report for identifier: {identifier}")
 
         # Check if analysis exists and hash matches
-        existing_analysis = await analysis_collection.find_one({"patient_id": patient_id, "report_hash": report_hash})
+        existing_analysis = await analysis_collection.find_one({"identifier": identifier, "report_hash": report_hash})
         if existing_analysis:
-            logger.info(f"✅ No changes in report data for {patient_id}, skipping analysis")
+            logger.info(f"✅ No changes in report data for {identifier}, skipping analysis")
             return existing_analysis
 
         # Construct analysis prompt
@@ -246,7 +248,8 @@ async def analyze_patient_report(patient_id: str, report_content: str, file_type
 
         # Store analysis
         analysis_doc = {
-            "patient_id": patient_id,
+            "identifier": identifier,
+            "patient_id": patient_id,  # May be None
             "timestamp": datetime.utcnow(),
             "summary": structured_response,
             "suicide_risk": suicide_risk,
@@ -256,16 +259,16 @@ async def analyze_patient_report(patient_id: str, report_content: str, file_type
         }
 
         await analysis_collection.update_one(
-            {"patient_id": patient_id, "report_hash": report_hash},
+            {"identifier": identifier, "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]:
+        # Create alert for high-risk cases only if patient_id is provided
+        if patient_id and 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}")
+        logger.info(f"✅ Stored analysis for identifier {identifier}")
         return analysis_doc
 
     except Exception as e:
@@ -314,6 +317,7 @@ async def analyze_patient(patient: dict):
         }
         
         analysis_doc = {
+            "identifier": patient_id,
             "patient_id": patient_id,
             "timestamp": datetime.utcnow(),
             "summary": structured,
@@ -323,7 +327,7 @@ async def analyze_patient(patient: dict):
         }
         
         await analysis_collection.update_one(
-            {"patient_id": patient_id},
+            {"identifier": patient_id},
             {"$set": analysis_doc},
             upsert=True
         )
@@ -401,7 +405,7 @@ async def status():
     return {
         "status": "running",
         "timestamp": datetime.utcnow().isoformat(),
-        "version": "2.4.0",
+        "version": "2.6.0",
         "features": ["chat", "voice-input", "voice-output", "patient-analysis", "report-upload"]
     }
 
@@ -420,7 +424,7 @@ async def get_patient_analysis_results(name: Optional[str] = Query(None)):
         analyses = await analysis_collection.find(query).sort("timestamp", -1).to_list(length=100)
         enriched_results = []
         for analysis in analyses:
-            patient = await patients_collection.find_one({"fhir_id": analysis["patient_id"]})
+            patient = await patients_collection.find_one({"fhir_id": analysis.get("patient_id")})
             if patient:
                 analysis["full_name"] = patient.get("full_name", "Unknown")
             analysis["_id"] = str(analysis["_id"])
@@ -540,20 +544,36 @@ async def voice_chat_endpoint(
 
 @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"),
+    patient_id: Optional[str] = Form(None),
     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")
+        # Validate patient_id if provided
+        if 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")
+            logger.info(f"Uploading report for patient: {patient_id}")
+        else:
+            logger.info("Uploading report without patient ID")
+
+        # Determine file type from extension or MIME type
+        file_extension = file.filename.lower().split('.')[-1] if file.filename else ''
+        mime_type = file.content_type or mimetypes.guess_type(file.filename)[0] or 'application/octet-stream'
+        logger.info(f"Detected file extension: {file_extension}, MIME type: {mime_type}")
+
+        if file_extension in ['txt'] or mime_type.startswith('text'):
+            file_type = 'text'
+        elif file_extension == 'pdf' or mime_type == 'application/pdf':
+            file_type = 'pdf'
+        elif file_extension in ['wav', 'mp3', 'ogg', 'flac'] or mime_type.startswith('audio'):
+            file_type = 'audio'
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Unsupported file type: {file_extension}. Supported: text (.txt), PDF (.pdf), audio (.wav, .mp3, .ogg, .flac)"
+            )
 
         # Read and process file
         file_content = await file.read()
@@ -565,10 +585,10 @@ async def upload_patient_report(
         elif file_type == "audio":
             report_content = recognize_speech(file_content, language="en-US")
         else:
-            raise HTTPException(status_code=400, detail="Unsupported file type")
+            raise HTTPException(status_code=400, detail="Error processing file type")
 
         # Analyze the report
-        analysis = await analyze_patient_report(patient_id, report_content, file_type)
+        analysis = await analyze_patient_report(patient_id, report_content, file_type, file_content)
         return JSONResponse(content=analysis)
 
     except HTTPException: