Update app.py

app.py

@@ -306,7 +306,7 @@ Patient Record Excerpt (Chunk {0} of {1}):
         
         with gr.Row():
             with gr.Column(scale=3):
-                chatbot = gr.Chatbot(label="Analysis Summary", height=600)
+                chatbot = gr.Chatbot(label="Analysis Summary", height=600, value=[])
                 msg_input = gr.Textbox(placeholder="Ask about potential oversights...")
                 send_btn = gr.Button("Analyze", variant="primary")
                 file_upload = gr.File(file_types=[".pdf", ".csv", ".xls", ".xlsx"], file_count="multiple")
@@ -316,8 +316,14 @@ Patient Record Excerpt (Chunk {0} of {1}):
                 download_output = gr.File(label="Download Detailed Report")
                 progress_bar = gr.Progress()
 
-        def analyze(message: str, history: List[dict], files: List, progress=gr.Progress()):
-            history.append({"role": "user", "content": message})
+        def analyze(message: str, history: List[List[str]], files: List, progress=gr.Progress()):
+            """Optimized analysis pipeline with correct message formatting"""
+            # Initialize with empty history if None
+            if history is None:
+                history = []
+            
+            # Append user message
+            history.append([message, None])
             yield history, None, ""
 
             extracted = []
@@ -329,33 +335,44 @@ Patient Record Excerpt (Chunk {0} of {1}):
                     cache_key = f"{file_hash(f.name)}_{file_type}"
                     
                     if cache_key in cache:
-                        extracted.extend(cache[cache_key])
-                        history.append({"role": "assistant", "content": f"Using cached data for {os.path.basename(f.name)}"})
-                        yield history, None, ""
-                    else:
-                        result = process_file_cached(f.name, file_type)
-                        if result and not (len(result) == 1 and "error" in result[0]):
-                            cache[cache_key] = result
-                            extracted.extend(result)
-                            history.append({"role": "assistant", "content": f"Processed {os.path.basename(f.name)}"})
+                        cached_data = cache[cache_key]
+                        if isinstance(cached_data, list) and len(cached_data) > 0:
+                            extracted.extend(cached_data)
+                            history[-1][1] = f"✅ Using cached data for {os.path.basename(f.name)}"
                             yield history, None, ""
                         else:
-                            error_msg = result[0]["error"] if result else "Unknown error"
-                            history.append({"role": "assistant", "content": f"Failed to process {os.path.basename(f.name)}: {error_msg}"})
-                            yield history, None, error_msg
+                            history[-1][1] = f"❌ Cached data empty for {os.path.basename(f.name)}. Reprocessing..."
+                            yield history, None, ""
+                    else:
+                        try:
+                            result = process_file_cached(f.name, file_type)
+                            if result and not (len(result) == 1 and "error" in result[0]):
+                                cache[cache_key] = result
+                                extracted.extend(result)
+                                history[-1][1] = f"✅ Processed {os.path.basename(f.name)}"
+                                yield history, None, ""
+                            else:
+                                error_msg = result[0]["error"] if result else "Unknown error"
+                                history[-1][1] = f"❌ Failed to process {os.path.basename(f.name)}: {error_msg}"
+                                yield history, None, error_msg
+                                return
+                        except Exception as e:
+                            logger.error(f"File processing error: {e}")
+                            history[-1][1] = f"❌ Error processing {os.path.basename(f.name)}: {str(e)}"
+                            yield history, None, str(e)
                             return
                 
                 file_hash_value = file_hash(files[0].name) if files else ""
-
+            
             if not extracted:
-                history.append({"role": "assistant", "content": "❌ No valid content extracted"})
-                yield history, None, "No valid content extracted"
+                history[-1][1] = "❌ No valid content extracted. Please upload a supported file."
+                yield history, None, "No valid content extracted."
                 return
 
             chunks = [item["content"] for item in extracted if "content" in item]
             if not chunks:
-                history.append({"role": "assistant", "content": "❌ No processable content found"})
-                yield history, None, "No processable content found"
+                history[-1][1] = "❌ No processable content found in the file."
+                yield history, None, "No processable content found."
                 return
 
             combined_response = ""
@@ -365,15 +382,6 @@ Patient Record Excerpt (Chunk {0} of {1}):
                 for batch_idx in range(0, len(chunks), BATCH_SIZE):
                     batch_chunks = chunks[batch_idx:batch_idx + BATCH_SIZE]
                     
-                    batch_prompts = [
-                        PROMPT_TEMPLATE.format(
-                            batch_idx + i + 1,
-                            len(chunks),
-                            chunk=chunk[:1800]
-                        )
-                        for i, chunk in enumerate(batch_chunks)
-                    ]
-                    
                     progress(batch_idx / len(chunks), 
                            desc=f"Processing batch {(batch_idx // BATCH_SIZE) + 1}/{(len(chunks) + BATCH_SIZE - 1) // BATCH_SIZE}")
                     
@@ -391,12 +399,12 @@ Patient Record Excerpt (Chunk {0} of {1}):
                             try:
                                 response = clean_response(future.result())
                                 if response:
-                                    combined_response += f"--- Analysis for Chunk {batch_idx + chunk_idx + 1} ---\n{response}\n"
-                                    history[-1] = {"role": "assistant", "content": combined_response.strip()}
+                                    combined_response += f"\n--- Analysis for Chunk {batch_idx + chunk_idx + 1} ---\n{response}\n"
+                                    history[-1][1] = combined_response.strip()
                                     yield history, None, ""
                             except Exception as e:
                                 logger.error(f"Chunk processing error: {e}")
-                                history[-1] = {"role": "assistant", "content": f"Error processing chunk: {str(e)}"}
+                                history[-1][1] = f"Error processing chunk: {str(e)}"
                                 yield history, None, ""
                             finally:
                                 del future
@@ -404,12 +412,14 @@ Patient Record Excerpt (Chunk {0} of {1}):
                                 gc.collect()
 
                 summary = "Analysis complete. " + ("Download full report below." if report_path and os.path.exists(report_path) else "")
-                history.append({"role": "assistant", "content": "Analysis completed successfully"})
+                history.append(["Analysis completed", None])
+                history[-1][1] = summary
                 yield history, report_path, summary
 
             except Exception as e:
                 logger.error(f"Analysis error: {e}")
-                history.append({"role": "assistant", "content": f"❌ Error occurred: {str(e)}"})
+                history.append(["Analysis failed", None])
+                history[-1][1] = f"❌ Error occurred: {str(e)}"
                 yield history, None, f"Error occurred: {str(e)}"
             finally:
                 torch.cuda.empty_cache()