Update app.py

app.py

@@ -25,14 +25,8 @@ for d in [model_cache_dir, tool_cache_dir, file_cache_dir, report_dir]:
 os.environ["HF_HOME"] = model_cache_dir
 os.environ["TRANSFORMERS_CACHE"] = model_cache_dir
 
-# Fixed this line - added missing closing parenthesis
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "src")))
-
-try:
-    from txagent.txagent import TxAgent
-except ImportError as e:
-    print(f"Error importing TxAgent: {e}")
-    sys.exit(1)
+from txagent.txagent import TxAgent
 
 MAX_MODEL_TOKENS = 32768
 MAX_CHUNK_TOKENS = 8192
@@ -48,37 +42,40 @@ def clean_response(text: str) -> str:
 def estimate_tokens(text: str) -> int:
     return len(text) // 3.5 + 1
 
-def extract_text_from_excel(file_obj: Union[str, os.PathLike, BinaryIO]) -> str:
-    """Extract text from Excel file which can be a path, file-like object, or Gradio file object."""
+def extract_text_from_excel(file_obj) -> str:
+    """Handle both Gradio file objects and direct file paths"""
     all_text = []
     try:
-        # Handle different file input types
-        if hasattr(file_obj, 'name'):  # Gradio file object
+        # Handle Gradio file object
+        if hasattr(file_obj, 'name'):
             file_path = file_obj.name
-        elif isinstance(file_obj, (str, os.PathLike)):  # Path string or Path object
-            file_path = file_obj
-        else:  # File-like object
+        # Handle direct file path
+        elif isinstance(file_obj, (str, os.PathLike)):
             file_path = file_obj
+        else:
+            raise ValueError("Unsupported file input type")
             
         # Verify file exists
         if not os.path.exists(file_path):
-            raise ValueError(f"File not found at path: {file_path}")
+            raise FileNotFoundError(f"File not found at path: {file_path}")
             
         xls = pd.ExcelFile(file_path)
+        
+        for sheet_name in xls.sheet_names:
+            try:
+                df = xls.parse(sheet_name).astype(str).fillna("")
+                rows = df.apply(lambda row: " | ".join([cell for cell in row if cell.strip()]), axis=1)
+                sheet_text = [f"[{sheet_name}] {line}" for line in rows if line.strip()]
+                all_text.extend(sheet_text)
+            except Exception as e:
+                print(f"Warning: Could not parse sheet {sheet_name}: {e}")
+                continue
+                
+        return "\n".join(all_text)
+        
     except Exception as e:
-        raise ValueError(f"❌ Error reading Excel file: {e}")
-    
-    for sheet_name in xls.sheet_names:
-        try:
-            df = xls.parse(sheet_name).astype(str).fillna("")
-            rows = df.apply(lambda row: " | ".join([cell for cell in row if cell.strip()]), axis=1)
-            sheet_text = [f"[{sheet_name}] {line}" for line in rows if line.strip()]
-            all_text.extend(sheet_text)
-        except Exception as e:
-            print(f"Warning: Could not parse sheet {sheet_name}: {e}")
-            continue
-            
-    return "\n".join(all_text)
+        raise ValueError(f"❌ Error processing Excel file: {str(e)}")
+
 def split_text_into_chunks(text: str, max_tokens: int = MAX_CHUNK_TOKENS, max_chunks: int = 30) -> List[str]:
     effective_max = max_tokens - PROMPT_OVERHEAD
     lines, chunks, curr_chunk, curr_tokens = text.split("\n"), [], [], 0
@@ -119,7 +116,6 @@ Respond in well-structured bullet points with medical reasoning.
 def init_agent():
     tool_path = os.path.join(tool_cache_dir, "new_tool.json")
     if not os.path.exists(tool_path):
-        # Create default tool file if it doesn't exist
         default_tool = {
             "name": "new_tool",
             "description": "Default tool configuration",
@@ -141,24 +137,19 @@ def init_agent():
     agent.init_model()
     return agent
 
-def stream_report(agent, input_file: Union[str, BinaryIO], full_output: str) -> Generator[Tuple[str, Union[str, None], str], None, None]:
+def stream_report(agent, input_file, full_output: str) -> Generator[Tuple[str, Union[str, None], str], None, None]:
     accumulated_text = ""
     try:
         if input_file is None:
             yield "❌ Please upload a valid Excel file.", None, ""
             return
 
-        # Verify file exists before processing
-        if hasattr(input_file, 'name'):
-            if not os.path.exists(input_file.name):
-                yield "❌ The uploaded file could not be found. Please try uploading again.", None, ""
-                return
-        elif isinstance(input_file, str):
-            if not os.path.exists(input_file):
-                yield "❌ The specified file path does not exist.", None, ""
-                return
+        try:
+            text = extract_text_from_excel(input_file)
+        except Exception as e:
+            yield f"❌ {str(e)}", None, ""
+            return
 
-        text = extract_text_from_excel(input_file)
         chunks = split_text_into_chunks(text)
 
         for i, chunk in enumerate(chunks):
@@ -198,7 +189,8 @@ def stream_report(agent, input_file: Union[str, BinaryIO], full_output: str) ->
         yield accumulated_text, report_path, cleaned
 
     except Exception as e:
-        yield f"❌ Error: {str(e)}", None, ""
+        yield f"❌ Unexpected error: {str(e)}", None, ""
+
 def create_ui(agent):
     with gr.Blocks(css="""
         body {