Update app.py

app.py

@@ -51,152 +51,165 @@ def clean_response(text: str) -> str:
     text = re.sub(r"[^\n#\-\*\w\s\.,:\(\)]+", "", text)
     return text.strip()
 
-def extract_medical_data(df: pd.DataFrame) -> Dict[str, Any]:
-    """Extract and organize medical data from DataFrame"""
-    medical_data = defaultdict(list)
+def extract_patient_data(df: pd.DataFrame) -> Dict[str, Any]:
+    """Extract and organize all medical data for a single patient"""
+    patient_data = {
+        'appointments': [],
+        'timeline': defaultdict(list),
+        'doctors': set(),
+        'medications': defaultdict(list),
+        'diagnoses': defaultdict(list),
+        'tests': defaultdict(list)
+    }
+    
+    # Sort by interview date to create timeline
+    df = df.sort_values('Interview Date')
     
     for _, row in df.iterrows():
-        record = {
-            'booking': row.get('Booking Number', ''),
-            'form_name': row.get('Form Name', ''),
-            'form_item': row.get('Form Item', ''),
-            'response': row.get('Item Response', ''),
+        appointment = {
             'date': row.get('Interview Date', ''),
-            'interviewer': row.get('Interviewer', ''),
-            'description': row.get('Description', '')
+            'doctor': row.get('Interviewer', ''),
+            'form': row.get('Form Name', ''),
+            'item': row.get('Form Item', ''),
+            'response': row.get('Item Response', ''),
+            'notes': row.get('Description', '')
         }
-        medical_data[row['Booking Number']].append(record)
+        patient_data['appointments'].append(appointment)
+        patient_data['doctors'].add(row.get('Interviewer', ''))
+        
+        # Categorize data for analysis
+        form_name = row['Form Name'].lower()
+        item = row['Form Item'].lower()
+        response = row['Item Response']
+        
+        if 'medication' in form_name or 'drug' in form_name:
+            patient_data['medications'][item].append({
+                'date': row['Interview Date'],
+                'doctor': row['Interviewer'],
+                'response': response
+            })
+        elif 'diagnosis' in form_name:
+            patient_data['diagnoses'][item].append({
+                'date': row['Interview Date'],
+                'doctor': row['Interviewer'],
+                'response': response
+            })
+        elif 'test' in form_name or 'lab' in form_name:
+            patient_data['tests'][item].append({
+                'date': row['Interview Date'],
+                'doctor': row['Interviewer'],
+                'response': response
+            })
+        
+        # Add to timeline by date
+        patient_data['timeline'][row['Interview Date']].append({
+            'form': row['Form Name'],
+            'item': row['Form Item'],
+            'response': row['Item Response'],
+            'doctor': row['Interviewer']
+        })
     
-    return medical_data
+    return patient_data
 
-def identify_red_flags(records: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """Identify potential red flags across all medical records"""
-    red_flags = {
-        'symptoms': defaultdict(list),
-        'medications': defaultdict(list),
-        'diagnoses': defaultdict(list),
-        'vitals': defaultdict(list),
-        'labs': defaultdict(list),
-        'patients': defaultdict(list)
-    }
+def generate_patient_prompt(patient_data: Dict[str, Any]) -> str:
+    """Generate comprehensive analysis prompt for a single patient"""
+    # Create timeline summary
+    timeline_text = []
+    for date, entries in patient_data['timeline'].items():
+        timeline_text.append(f"\n### {date}")
+        for entry in entries:
+            timeline_text.append(
+                f"- {entry['form']}: {entry['item']} = {entry['response']} (by Dr. {entry['doctor']})"
+            )
     
-    for booking, patient_records in records.items():
-        for record in patient_records:
-            form_name = record['form_name'].lower()
-            item = record['form_item'].lower()
-            response = record['response'].lower()
-            
-            # Symptom patterns
-            if 'pain' in item or 'symptom' in form_name:
-                if 'severe' in response or 'chronic' in response:
-                    red_flags['symptoms'][item].append((booking, response))
-            
-            # Medication checks
-            elif 'medication' in form_name or 'drug' in form_name:
-                if 'interaction' in response or 'allergy' in response:
-                    red_flags['medications'][item].append((booking, response))
-            
-            # Diagnosis inconsistencies
-            elif 'diagnosis' in form_name:
-                if 'rule out' in response or 'possible' in response:
-                    red_flags['diagnoses'][item].append((booking, response))
-            
-            # Abnormal vitals
-            elif 'vital' in form_name:
-                try:
-                    value = float(re.search(r'\d+\.?\d*', response).group())
-                    if ('blood pressure' in item and value > 140) or \
-                       ('heart rate' in item and (value < 50 or value > 100)) or \
-                       ('temperature' in item and value > 38):
-                        red_flags['vitals'][item].append((booking, response))
-                except:
-                    pass
-            
-            # Abnormal labs
-            elif 'lab' in form_name or 'test' in form_name:
-                if 'abnormal' in response or 'high' in response or 'low' in response:
-                    red_flags['labs'][item].append((booking, response))
+    # Create medication history
+    meds_text = []
+    for med, records in patient_data['medications'].items():
+        meds_text.append(f"\n- {med}:")
+        for record in records:
+            meds_text.append(
+                f"  - Prescribed on {record['date']} by Dr. {record['doctor']}: {record['response']}"
+            )
     
-    return red_flags
-
-def generate_combined_prompt(all_records: Dict[str, Any], red_flags: Dict[str, Any]]) -> str:
-    """Generate a single comprehensive prompt for all patient data"""
-    # Create summary of all records
-    records_summary = []
-    for booking, records in all_records.items():
-        records_summary.append(f"\n## Patient {booking}")
-        for r in records:
-            records_summary.append(
-                f"- {r['form_name']}: {r['form_item']} = {r['response']} "
-                f"({r['date']} by {r['interviewer']})\n  {r['description']}"
+    # Create diagnosis history
+    diag_text = []
+    for diag, records in patient_data['diagnoses'].items():
+        diag_text.append(f"\n- {diag}:")
+        for record in records:
+            diag_text.append(
+                f"  - Diagnosed on {record['date']} by Dr. {record['doctor']}: {record['response']}"
             )
     
-    # Format red flags with patient references
-    red_flags_text = []
-    for category, items in red_flags.items():
-        if items:
-            red_flags_text.append(f"\n### {category.capitalize()} Red Flags")
-            for item, entries in items.items():
-                patient_entries = defaultdict(list)
-                for booking, response in entries:
-                    patient_entries[booking].append(response)
-                
-                for booking, responses in patient_entries.items():
-                    red_flags_text.append(
-                        f"- {item} (Patient {booking}): {', '.join(responses)}"
-                    )
+    # Create test history
+    tests_text = []
+    for test, records in patient_data['tests'].items():
+        tests_text.append(f"\n- {test}:")
+        for record in records:
+            tests_text.append(
+                f"  - Tested on {record['date']} by Dr. {record['doctor']}: {record['response']}"
+            )
     
     prompt = f"""
-**COMPREHENSIVE PATIENT ANALYSIS**
+**COMPREHENSIVE PATIENT HISTORY ANALYSIS**
+
+**Patient Timeline**:
+{"".join(timeline_text)}
+
+**Medical History Overview**:
+### Medications
+{"".join(meds_text) if meds_text else "No medication records found"}
 
-**Medical Records Summary**:
-{"".join(records_summary)}
+### Diagnoses
+{"".join(diag_text) if diag_text else "No diagnosis records found"}
 
-**Identified Red Flags Across All Patients**:
-{"".join(red_flags_text) if red_flags_text else "No obvious red flags detected"}
+### Test Results
+{"".join(tests_text) if tests_text else "No test records found"}
 
 **Analysis Instructions**:
-1. Review ALL patient data holistically
-2. Identify patterns that might indicate systemic issues
-3. Check for recurring medication problems across patients
-4. Note any common missed diagnoses
-5. Flag any urgent cases needing immediate attention
-6. Provide overall clinical recommendations
+1. Review the complete patient history across all appointments
+2. Identify any inconsistencies in diagnoses or treatments
+3. Check for medication conflicts or changes over time
+4. Note any unresolved symptoms or conditions
+5. Evaluate test result patterns over time
+6. Flag any concerning trends or gaps in care
+7. Provide comprehensive recommendations
 
 **Required Output Format**:
-### Summary of Findings
-[Overview of most significant findings across all patients]
+### Clinical Summary
+[Overview of patient's medical journey]
 
-### Common Missed Diagnoses
-- [Conditions frequently overlooked across multiple patients]
-- [Specific patients affected: Booking numbers]
+### Treatment Consistency
+- [Evaluation of consistency across different doctors]
+- [Notable changes in treatment approaches]
 
-### Recurring Medication Issues
-- [Common drug interactions or inappropriate prescriptions]
-- [Patients affected]
+### Medication Analysis
+- [Current medication list]
+- [Potential interactions or issues]
+- [Changes over time]
 
-### Systemic Assessment Gaps
-- [Patterns of incomplete assessments across patients]
-- [Recommended additional tests]
+### Diagnostic Evaluation
+- [Confirmed diagnoses]
+- [Potential missed diagnoses]
+- [Diagnostic consistency across providers]
 
-### Critical Cases Needing Follow-up
-- [Patients requiring urgent attention]
-- [Specific reasons]
+### Test Result Trends
+- [Notable patterns in lab/test results]
+- [Concerning values or changes]
 
-### Overall Recommendations
-- [General recommendations for clinical practice]
-- [Specific actions for different patient groups]
+### Recommended Actions
+- [Immediate follow-up needs]
+- [Long-term management suggestions]
+- [Referral recommendations if needed]
 """
     return prompt
 
-def parse_excel_to_combined_prompt(file_path: str) -> str:
-    """Parse Excel file into a single comprehensive analysis prompt"""
+def parse_excel_to_patient_prompt(file_path: str) -> str:
+    """Parse Excel file into a comprehensive patient analysis prompt"""
     try:
         xl = pd.ExcelFile(file_path)
         df = xl.parse(xl.sheet_names[0], header=0).fillna("")
-        medical_data = extract_medical_data(df)
-        red_flags = identify_red_flags(medical_data)
-        prompt = generate_combined_prompt(medical_data, red_flags)
+        patient_data = extract_patient_data(df)
+        prompt = generate_patient_prompt(patient_data)
         return prompt
     except Exception as e:
         raise ValueError(f"Error parsing Excel file: {str(e)}")
@@ -224,8 +237,8 @@ def init_agent():
 
 def create_ui(agent):
     """Create Gradio UI interface"""
-    with gr.Blocks(theme=gr.themes.Soft(), title="Clinical Oversight Assistant") as demo:
-        gr.Markdown("# 🏥 Comprehensive Clinical Analysis")
+    with gr.Blocks(theme=gr.themes.Soft(), title="Patient History Analyzer") as demo:
+        gr.Markdown("# 🏥 Comprehensive Patient History Analysis")
         
         with gr.Tabs():
             with gr.TabItem("Analysis"):
@@ -233,7 +246,7 @@ def create_ui(agent):
                     # Left column - Inputs
                     with gr.Column(scale=1):
                         file_upload = gr.File(
-                            label="Upload Excel File",
+                            label="Upload Patient Records (Excel)",
                             file_types=[".xlsx"], 
                             file_count="single",
                             interactive=True
@@ -245,12 +258,12 @@ def create_ui(agent):
                         )
                         with gr.Row():
                             clear_btn = gr.Button("Clear", variant="secondary")
-                            send_btn = gr.Button("Analyze All Patients", variant="primary")
+                            send_btn = gr.Button("Analyze Full History", variant="primary")
                     
                     # Right column - Outputs
                     with gr.Column(scale=2):
                         chatbot = gr.Chatbot(
-                            label="Comprehensive Analysis Results",
+                            label="Patient Analysis Results",
                             height=600,
                             bubble_full_width=False,
                             show_copy_button=True,
@@ -265,32 +278,34 @@ def create_ui(agent):
                 gr.Markdown("""
                 ## How to Use This Tool
                 
-                1. **Upload Excel File**: Select your patient records Excel file
+                1. **Upload Excel File**: Select the patient's medical records Excel file
                 2. **Add Instructions** (Optional): Provide any specific analysis requests
-                3. **Click Analyze**: The system will process ALL patient records together
+                3. **Click Analyze**: The system will process ALL appointments together
                 4. **Review Results**: Comprehensive analysis appears in the chat window
                 5. **Download Report**: Get a complete text report of all findings
                 
-                ### Key Features
-                - **Holistic analysis** of all patient records
-                - **Pattern detection** across multiple patients
-                - **Systemic issues** identification
-                - **Prioritized recommendations** based on severity
+                ### What This Analyzes
+                - Complete medical history across all appointments
+                - Treatment consistency across different doctors
+                - Medication changes and potential interactions
+                - Diagnostic patterns and potential oversights
+                - Test result trends over time
+                - Comprehensive care recommendations
                 """)
         
         def analyze(message: str, chat_history: List[Tuple[str, str]], file) -> Tuple[List[Tuple[str, str]], str]:
-            """Main analysis function for all patients"""
+            """Main analysis function for patient history"""
             if not file:
                 raise gr.Error("Please upload an Excel file first")
             
             try:
                 # Initialize chat history
                 new_history = chat_history + [(message, None)]
-                new_history.append((None, "⏳ Processing all patient data..."))
+                new_history.append((None, "⏳ Processing complete patient history..."))
                 yield new_history, None
                 
-                # Generate combined prompt
-                prompt = parse_excel_to_combined_prompt(file.name)
+                # Generate comprehensive prompt
+                prompt = parse_excel_to_patient_prompt(file.name)
                 
                 # Run analysis
                 full_output = ""
@@ -298,7 +313,7 @@ def create_ui(agent):
                     message=prompt,
                     history=[],
                     temperature=0.2,
-                    max_new_tokens=2048,  # Increased for comprehensive analysis
+                    max_new_tokens=2048,
                     max_token=4096,
                     call_agent=False,
                     conversation=[],
@@ -319,10 +334,10 @@ def create_ui(agent):
                 # Save report
                 file_hash_value = file_hash(file.name)
                 timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-                report_path = os.path.join(report_dir, f"comprehensive_{file_hash_value}_{timestamp}_report.md")
+                report_path = os.path.join(report_dir, f"patient_{file_hash_value}_{timestamp}_report.md")
                 
                 with open(report_path, "w", encoding="utf-8") as f:
-                    f.write("# Comprehensive Clinical Analysis Report\n\n")
+                    f.write("# Comprehensive Patient History Analysis\n\n")
                     f.write(f"**Generated on**: {timestamp}\n\n")
                     f.write(f"**Source file**: {file.name}\n\n")
                     f.write(full_output)