Update app.py

app.py

@@ -10,7 +10,6 @@ import re
 from datetime import datetime
 import time
 
-# Configuration and setup
 persistent_dir = "/data/hf_cache"
 os.makedirs(persistent_dir, exist_ok=True)
 
@@ -40,33 +39,26 @@ def clean_response(text: str) -> str:
         text = text.encode('utf-8', 'surrogatepass').decode('utf-8')
     except UnicodeError:
         text = text.encode('utf-8', 'replace').decode('utf-8')
-    
     text = re.sub(r"\[.*?\]|\bNone\b", "", text, flags=re.DOTALL)
     text = re.sub(r"\n{3,}", "\n\n", text)
     text = re.sub(r"[^\n#\-\*\w\s\.,:\(\)]+", "", text)
     return text.strip()
 
-def parse_excel_to_prompts(file_path: str) -> List[str]:
-    try:
-        xl = pd.ExcelFile(file_path)
-        df = xl.parse(xl.sheet_names[0], header=0).fillna("")
-        groups = df.groupby("Booking Number")
-        prompts = []
-        
-        for booking, group in groups:
-            records = []
-            for _, row in group.iterrows():
-                record = f"- {row['Form Name']}: {row['Form Item']} = {row['Item Response']} ({row['Interview Date']} by {row['Interviewer']})\n{row['Description']}"
-                records.append(clean_response(record))
-            
-            record_text = "\n".join(records)
-            prompt = f"""
-Patient Booking Number: {booking}
+def parse_excel_as_whole_prompt(file_path: str) -> str:
+    xl = pd.ExcelFile(file_path)
+    df = xl.parse(xl.sheet_names[0], header=0).fillna("")
+    records = []
+    for _, row in df.iterrows():
+        record = f"- {row['Form Name']}: {row['Form Item']} = {row['Item Response']} ({row['Interview Date']} by {row['Interviewer']})\n{row['Description']}"
+        records.append(clean_response(record))
+    record_text = "\n".join(records)
+    prompt = f"""
+Patient Complete History:
 
 Instructions:
-Analyze the following patient case for missed diagnoses, medication conflicts, incomplete assessments, and any urgent follow-up needed. Summarize under the markdown headings.
+Based on the complete patient record below, identify any potential missed diagnoses, medication conflicts, incomplete assessments, and urgent follow-up needs. Provide a clinical summary under the markdown headings.
 
-Data:
+Patient History:
 {record_text}
 
 ### Missed Diagnoses
@@ -81,18 +73,13 @@ Data:
 ### Urgent Follow-up
 - ...
 """
-            prompts.append(prompt)
-        return prompts
-    except Exception as e:
-        raise ValueError(f"Error parsing Excel file: {str(e)}")
+    return prompt
 
 def init_agent():
     default_tool_path = os.path.abspath("data/new_tool.json")
     target_tool_path = os.path.join(tool_cache_dir, "new_tool.json")
-    
     if not os.path.exists(target_tool_path):
         shutil.copy(default_tool_path, target_tool_path)
-    
     agent = TxAgent(
         model_name="mims-harvard/TxAgent-T1-Llama-3.1-8B",
         rag_model_name="mims-harvard/ToolRAG-T1-GTE-Qwen2-1.5B",
@@ -107,180 +94,60 @@ def init_agent():
     return agent
 
 def create_ui(agent):
-    with gr.Blocks(theme=gr.themes.Soft(), title="Clinical Oversight Assistant") as demo:
-        gr.Markdown("# 🏥 Clinical Oversight Assistant (Excel Optimized)")
-        
-        with gr.Tabs():
-            with gr.TabItem("Analysis"):
-                with gr.Row():
-                    # Left column - Inputs
-                    with gr.Column(scale=1):
-                        file_upload = gr.File(
-                            label="Upload Excel File",
-                            file_types=[".xlsx"], 
-                            file_count="single",
-                            interactive=True
-                        )
-                        msg_input = gr.Textbox(
-                            label="Additional Instructions",
-                            placeholder="Add any specific analysis requests...",
-                            lines=3
-                        )
-                        with gr.Row():
-                            clear_btn = gr.Button("Clear", variant="secondary")
-                            send_btn = gr.Button("Analyze", variant="primary")
-                    
-                    # Right column - Outputs
-                    with gr.Column(scale=2):
-                        chatbot = gr.Chatbot(
-                            label="Analysis Results",
-                            height=600,
-                            bubble_full_width=False,
-                            show_copy_button=True
-                        )
-                        download_output = gr.File(
-                            label="Download Full Report",
-                            interactive=False
-                        )
-            
-            with gr.TabItem("Instructions"):
-                gr.Markdown("""
-                ## How to Use This Tool
-                
-                1. **Upload Excel File**: Select your patient records Excel file
-                2. **Add Instructions** (Optional): Provide any specific analysis requests
-                3. **Click Analyze**: The system will process each patient record
-                4. **Review Results**: Analysis appears in the chat window
-                5. **Download Report**: Get a full text report of all findings
-                
-                ### Excel File Requirements
-                Your Excel file must contain these columns:
-                - Booking Number
-                - Form Name
-                - Form Item
-                - Item Response
-                - Interview Date
-                - Interviewer
-                - Description
-                
-                ### Analysis Includes
-                - Missed diagnoses
-                - Medication conflicts
-                - Incomplete assessments
-                - Urgent follow-up needs
-                """)
-        
-        def format_message(role: str, content: str) -> Tuple[str, str]:
-            """Format messages for the chatbot in (user, bot) format"""
-            if role == "user":
-                return (content, None)
-            else:
-                return (None, content)
-        
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("<h1 style='text-align: center;'>\ud83c\udfe5 Full Medical History Analyzer</h1>")
+        chatbot = gr.Chatbot(label="Summary Output", height=600)
+        file_upload = gr.File(label="Upload Excel File", file_types=[".xlsx"], file_count="single")
+        msg_input = gr.Textbox(label="Optional Message", placeholder="Add context or instructions...", lines=2)
+        send_btn = gr.Button("Analyze")
+        download_output = gr.File(label="Download Report")
+
         def analyze(message: str, chat_history: List[Tuple[str, str]], file) -> Tuple[List[Tuple[str, str]], str]:
             if not file:
-                raise gr.Error("Please upload an Excel file first")
-            
+                raise gr.Error("Please upload an Excel file.")
+            new_history = chat_history + [(message, None)]
+            new_history.append((None, "⏳ Analyzing full patient history..."))
+            yield new_history, None
+
             try:
-                # Initialize chat history with user message
-                new_history = chat_history + [format_message("user", message)]
-                new_history.append(format_message("assistant", "⏳ Processing Excel data..."))
-                yield new_history, None
-                
-                prompts = parse_excel_to_prompts(file.name)
+                prompt = parse_excel_as_whole_prompt(file.name)
                 full_output = ""
-                
-                for idx, prompt in enumerate(prompts, 1):
-                    chunk_output = ""
-                    try:
-                        for result in agent.run_gradio_chat(
-                            message=prompt,
-                            history=[],
-                            temperature=0.2,
-                            max_new_tokens=1024,
-                            max_token=4096,
-                            call_agent=False,
-                            conversation=[],
-                        ):
-                            if isinstance(result, list):
-                                for r in result:
-                                    if hasattr(r, 'content') and r.content:
-                                        cleaned = clean_response(r.content)
-                                        chunk_output += cleaned + "\n"
-                            elif isinstance(result, str):
-                                cleaned = clean_response(result)
-                                chunk_output += cleaned + "\n"
-                            
-                            if chunk_output:
-                                output = f"--- Booking {idx} ---\n{chunk_output.strip()}\n"
-                                new_history[-1] = format_message("assistant", output)
-                                yield new_history, None
-                                
-                    except Exception as e:
-                        error_msg = f"⚠️ Error processing booking {idx}: {str(e)}"
-                        new_history.append(format_message("assistant", error_msg))
-                        yield new_history, None
-                        continue
-                        
-                    if chunk_output:
-                        output = f"--- Booking {idx} ---\n{chunk_output.strip()}\n"
-                        new_history.append(format_message("assistant", output))
-                        full_output += output + "\n"
-                        yield new_history, None
-                
-                # Save report
-                file_hash_value = file_hash(file.name)
-                report_path = os.path.join(report_dir, f"{file_hash_value}_report.txt")
+                for result in agent.run_gradio_chat(
+                    message=prompt,
+                    history=[],
+                    temperature=0.2,
+                    max_new_tokens=2048,
+                    max_token=4096,
+                    call_agent=False,
+                    conversation=[],
+                ):
+                    if isinstance(result, list):
+                        for r in result:
+                            if hasattr(r, 'content') and r.content:
+                                full_output += clean_response(r.content) + "\n"
+                    elif isinstance(result, str):
+                        full_output += clean_response(result) + "\n"
+
+                new_history[-1] = (None, full_output.strip())
+                report_path = os.path.join(report_dir, f"{file_hash(file.name)}_final_report.txt")
                 with open(report_path, "w", encoding="utf-8") as f:
-                    f.write(full_output)
-                
-                yield new_history, report_path if os.path.exists(report_path) else None
-                
+                    f.write(full_output.strip())
+                yield new_history, report_path
             except Exception as e:
-                new_history.append(format_message("assistant", f"❌ Error: {str(e)}"))
+                new_history.append((None, f"❌ Error during analysis: {str(e)}"))
                 yield new_history, None
-                raise gr.Error(f"Analysis failed: {str(e)}")
-        
-        def clear_chat():
-            return [], None
-        
-        # Event handlers
-        send_btn.click(
-            analyze,
-            inputs=[msg_input, chatbot, file_upload],
-            outputs=[chatbot, download_output],
-            api_name="analyze"
-        )
-        
-        msg_input.submit(
-            analyze,
-            inputs=[msg_input, chatbot, file_upload],
-            outputs=[chatbot, download_output]
-        )
-        
-        clear_btn.click(
-            clear_chat,
-            inputs=[],
-            outputs=[chatbot, download_output]
-        )
-    
+
+        send_btn.click(analyze, inputs=[msg_input, chatbot, file_upload], outputs=[chatbot, download_output])
+        msg_input.submit(analyze, inputs=[msg_input, chatbot, file_upload], outputs=[chatbot, download_output])
     return demo
 
 if __name__ == "__main__":
-    try:
-        agent = init_agent()
-        demo = create_ui(agent)
-        
-        demo.queue(
-            api_open=False,
-            max_size=20
-        ).launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True,
-            allowed_paths=[report_dir],
-            share=False
-        )
-    except Exception as e:
-        print(f"Failed to launch application: {str(e)}")
-        sys.exit(1)
+    agent = init_agent()
+    demo = create_ui(agent)
+    demo.queue(api_open=False).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        allowed_paths=[report_dir],
+        share=False
+    )