Update app.py

app.py

@@ -9,6 +9,7 @@ import hashlib
 import multiprocessing
 from functools import partial
 import logging
+import time
 
 # Suppress pdfplumber CropBox warnings
 logging.getLogger("pdfplumber").setLevel(logging.ERROR)
@@ -42,7 +43,7 @@ def extract_page_range(file_path: str, start_page: int, end_page: int) -> str:
     except Exception:
         return ""
 
-def extract_all_pages(file_path: str) -> str:
+def extract_all_pages(file_path: str, progress_callback=None) -> str:
     """Extract text from all pages of a PDF using parallel processing."""
     try:
         with pdfplumber.open(file_path) as pdf:
@@ -64,13 +65,18 @@ def extract_all_pages(file_path: str) -> str:
         # Process page ranges in parallel
         with multiprocessing.Pool(processes=num_processes) as pool:
             extract_func = partial(extract_page_range, file_path)
-            results = pool.starmap(extract_func, ranges)
+            results = []
+            for idx, result in enumerate(pool.starmap(extract_func, ranges)):
+                results.append(result)
+                if progress_callback:
+                    processed_pages = min((idx + 1) * pages_per_process, total_pages)
+                    progress_callback(processed_pages, total_pages)
         
         return "\n".join(filter(None, results))
     except Exception:
         return ""
 
-def convert_file_to_text(file_path: str, file_type: str) -> str:
+def convert_file_to_text(file_path: str, file_type: str, progress_callback=None) -> str:
     """Convert supported file types to text, caching results."""
     try:
         h = file_hash(file_path)
@@ -80,7 +86,7 @@ def convert_file_to_text(file_path: str, file_type: str) -> str:
                 return f.read()
 
         if file_type == "pdf":
-            text = extract_all_pages(file_path)
+            text = extract_all_pages(file_path, progress_callback)
         elif file_type == "csv":
             df = pd.read_csv(file_path, encoding_errors="replace", header=None, dtype=str,
                              skip_blank_lines=True, on_bad_lines="skip")
@@ -123,26 +129,26 @@ def parse_analysis_response(raw_response: str) -> Dict[str, List[str]]:
     
     return sections
 
-def analyze_medical_records(extracted_text: str) -> str:
-    """Analyze medical records and return structured response."""
+def analyze_medical_records(extracted_text: str, progress_callback=None) -> str:
+    """Analyze medical records and return generalized structured response."""
     # Split text into chunks to handle large inputs
     chunk_size = 10000
     chunks = [extracted_text[i:i + chunk_size] for i in range(0, len(extracted_text), chunk_size)]
     
-    # Placeholder for analysis (replace with model or rule-based logic)
+    # Generalized analysis template (replace with model or rule-based logic)
     raw_response_template = """
     Missed Diagnoses:
-    - Undiagnosed hypertension despite elevated BP readings.
-    - Family history of diabetes not evaluated for prediabetes risk.
+    - Chronic conditions potentially missed due to inconsistent monitoring of vital signs or symptoms. This may occur when patient visits are infrequent or records lack longitudinal tracking, leading to undetected trends. Undiagnosed conditions can progress, increasing risks of complications like organ damage. Recommended action: Implement regular screening protocols and trend analysis for key indicators (e.g., blood pressure, glucose levels).
+    - Risk factors for hereditary or lifestyle-related diseases not screened despite documented family history or patient demographics. Screening oversights often stem from time constraints or lack of standardized protocols. Delayed diagnosis may lead to preventable disease progression. Recommended action: Establish routine risk assessments based on family history and clinical guidelines.
     
     Medication Conflicts:
-    - SSRIs and NSAIDs detected, increasing GI bleeding risk.
+    - Potential interactions from polypharmacy or untracked over-the-counter medications. Conflicts may arise when multiple prescribers are involved or patients self-medicate, increasing risks of adverse events like bleeding or toxicity. Recommended action: Conduct comprehensive medication reconciliation at each visit and educate patients on reporting all medications.
     
     Incomplete Assessments:
-    - No cardiac stress test despite chest pain.
+    - Symptoms reported but not fully evaluated due to incomplete documentation or failure to follow clinical guidelines. This can occur in busy clinical settings where time limits prioritize acute issues over thorough investigation. Unaddressed symptoms may mask serious conditions, delaying treatment. Recommended action: Standardize symptom evaluation protocols and ensure adequate time for comprehensive assessments.
     
     Urgent Follow-up:
-    - Abnormal ECG requires cardiology referral.
+    - Critical findings requiring specialist referral or additional testing delayed due to communication gaps or scheduling issues. Delays often result from fragmented care coordination or underestimation of findings' severity. Untreated critical issues can lead to rapid deterioration. Recommended action: Establish clear referral pathways and prioritize urgent findings with defined timelines.
     """
     
     # Aggregate findings across chunks
@@ -159,9 +165,12 @@ def analyze_medical_records(extracted_text: str) -> str:
         parsed = parse_analysis_response(raw_response)
         for section, items in parsed.items():
             all_sections[section].update(items)
+        if progress_callback:
+            progress_callback(chunk_idx, len(chunks))
     
-    # Format final response
+    # Format generalized response
     response = ["### Clinical Oversight Analysis\n"]
+    response.append("This analysis reviews patient records to identify common reasons for potential oversights that could impact clinical outcomes. Findings highlight systemic or procedural gaps, associated risks, and actionable recommendations applicable across various patient records.\n")
     has_findings = False
     for section, items in all_sections.items():
         response.append(f"#### {section}")
@@ -169,13 +178,14 @@ def analyze_medical_records(extracted_text: str) -> str:
             response.extend(sorted(items))
             has_findings = True
         else:
-            response.append("- None identified.")
+            response.append("- No issues identified in this category.")
         response.append("")
     
     response.append("### Summary")
-    summary = ("The analysis identified potential oversights in diagnosis, medication management, "
-               "assessments, and follow-up needs. Immediate action is recommended.") if has_findings else \
-              "No significant oversights identified. Continue monitoring."
+    if has_findings:
+        summary = ("The analysis identified common procedural and systemic gaps that may lead to oversights in diagnosis, medication management, assessments, and follow-up care. These gaps, such as inconsistent monitoring, incomplete documentation, or communication delays, pose risks of disease progression, adverse events, or delayed treatment. Recommended actions include standardizing screening and assessment protocols, improving medication reconciliation, and establishing clear referral pathways. Implementing these measures can enhance patient safety and care quality across diverse clinical scenarios.")
+    else:
+        summary = ("No significant oversights were identified in the provided records. Current practices appear aligned with general clinical standards. To maintain care quality, continue regular monitoring, ensure comprehensive documentation, and adhere to guideline-based screening and follow-up protocols.")
     response.append(summary)
     
     return "\n".join(response)
@@ -183,28 +193,51 @@ def analyze_medical_records(extracted_text: str) -> str:
 def create_ui():
     """Create Gradio UI for clinical oversight analysis."""
     def analyze(message: str, history: List[dict], files: List):
-        """Handle analysis and return results."""
+        """Handle analysis with animated progress updates."""
         history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": "⏳ Extracting text from files..."})
         yield history, None
 
         extracted_text = ""
         file_hash_value = ""
         if files:
+            # Progress callback for extraction
+            total_pages = 0
+            processed_pages = 0
+            def update_extraction_progress(current, total):
+                nonlocal processed_pages, total_pages
+                processed_pages = current
+                total_pages = total
+                animation = ["🌀", "🔄", "⚙️", "🔃"][(int(time.time() * 2) % 4)]
+                history[-1] = {"role": "assistant", "content": f"Extracting text... {animation} Page {processed_pages}/{total_pages}"}
+                return history, None
+
             with ThreadPoolExecutor(max_workers=4) as executor:
-                futures = [executor.submit(convert_file_to_text, f.name, f.name.split(".")[-1].lower()) for f in files]
+                futures = [executor.submit(convert_file_to_text, f.name, f.name.split(".")[-1].lower(), update_extraction_progress) for f in files]
                 results = [f.result() for f in futures]
                 extracted_text = "\n".join(sanitize_utf8(r) for r in results if r)
                 file_hash_value = file_hash(files[0].name) if files else ""
 
-        history.pop()  # Remove "Extracting..."
-        history.append({"role": "assistant", "content": "⏳ Analyzing medical records..."})
+        history.append({"role": "assistant", "content": "✅ Text extraction complete."})
         yield history, None
 
         report_path = os.path.join(report_dir, f"{file_hash_value}_report.txt") if file_hash_value else None
 
         try:
-            response = analyze_medical_records(extracted_text)
+            # Progress callback for analysis
+            total_chunks = 0
+            processed_chunks = 0
+            def update_analysis_progress(current, total):
+                nonlocal processed_chunks, total_chunks
+                processed_chunks = current
+                total_chunks = total
+                animation = ["🔍", "📊", "🧠", "🔎"][(int(time.time() * 2) % 4)]
+                history[-1] = {"role": "assistant", "content": f"Analyzing records... {animation} Chunk {processed_chunks}/{total_chunks}"}
+                return history, None
+
+            history.append({"role": "assistant", "content": "Analyzing records... 🔍"})
+            yield history, None
+            response = analyze_medical_records(extracted_text, update_analysis_progress)
+            
             history.pop()  # Remove "Analyzing..."
             history.append({"role": "assistant", "content": response})
             if report_path: