Update app.py

app.py

@@ -1,58 +1,59 @@
 # app.py
 import json
 import traceback
-import tempfile
+import tempfile # Not strictly needed by process_upload anymore, but good to keep if other parts use it.
 import os
 import gradio as gr
-from typing import Tuple, Optional, Any # Added Any for file_data_binary
+from typing import Tuple, Optional, Any 
 
 # Import config first to ensure JAVA_HOME is set early
 import config 
 
 from main_analyzer import analyze_pdf 
-# Import language_tool_python only for the test in __main__ if needed
-# import language_tool_python 
+# language_tool_python needed for the test in __main__
+import language_tool_python
 
-def process_upload(file_data_binary: Optional[Any]) -> Tuple[str, Optional[str]]: # Use Optional[Any] for Gradio File type="binary"
-    if file_data_binary is None or not hasattr(file_data_binary, 'read'): # Check if it's a file-like object
-        # Gradio's binary type for gr.File returns a tempfile._TemporaryFileWrapper object
-        # If it's None, no file was uploaded.
-        # If it's not None but doesn't have 'read', it's an unexpected type.
-        # However, gradio usually passes the bytes directly if type="binary" was used in older versions
-        # or a TemporaryFileWrapper which is file-like.
-        # For robustness, let's check if it's bytes.
-        if isinstance(file_data_binary, bytes):
-             pass # Good, it's bytes
-        elif file_data_binary is None:
-             return json.dumps({"error": "No file uploaded or file data is None"}, indent=2), None
-        elif not hasattr(file_data_binary, 'read'): # It's not None, not bytes, not file-like
-             return json.dumps({"error": f"Unexpected file data type: {type(file_data_binary)}"}), None
-        # If it has 'read', it's a file-like object, proceed.
 
-    # analyze_pdf now handles stream-to-temp-file logic internally via original_pdf_access_path
-    # So we can pass the file_data_binary (which is a file-like object from Gradio) directly.
+def process_upload(uploaded_file_input: Optional[Any]) -> Tuple[str, Optional[str]]:
+    """
+    Processes the uploaded file from Gradio.
+    'uploaded_file_input' is expected to be an object from gr.File(),
+    which could be a path string (like gradio.utils.NamedString) or a file-like object.
+    """
+    if uploaded_file_input is None:
+        print("App: No file uploaded.")
+        return json.dumps({"error": "No file uploaded."}, indent=2), None
+
     try:
-        print(f"App: Processing uploaded file...")
-        # If file_data_binary is bytes, wrap it in BytesIO for file-like interface
-        # analyze_pdf expects a path or a file-like object with read() and seek()
-        
-        # Gradio with type="binary" gives a tempfile._TemporaryFileWrapper.
-        # This object is already file-like and can be passed directly.
-        # No need to create another temp file here in app.py if main_analyzer handles it.
+        # Pass the uploaded_file_input directly to analyze_pdf.
+        # analyze_pdf is responsible for determining if it's a path or a stream
+        # and handling it accordingly (including creating a temp file for streams if needed).
+        print(f"App: Received file input of type: {type(uploaded_file_input)}. Passing to analyzer.")
         
-        # analyze_pdf will create its own temp file if it receives a stream.
-        results_dict, _ = analyze_pdf(file_data_binary) 
+        results_dict, _ = analyze_pdf(uploaded_file_input) 
         
+        # Check if analyze_pdf returned an error (it returns a dict with "error" key in that case)
+        if isinstance(results_dict, dict) and "error" in results_dict:
+            print(f"App: Analysis returned an error: {results_dict['error']}")
+            # Return the error JSON directly
+            return json.dumps(results_dict, indent=2, ensure_ascii=False), None
+
         results_json = json.dumps(results_dict, indent=2, ensure_ascii=False)
         return results_json, None 
 
     except Exception as e:
-        print(f"Error in process_upload: {e}\n{traceback.format_exc()}")
-        error_message = json.dumps({"error": str(e), "traceback": traceback.format_exc()}, indent=2)
+        # This catches unexpected errors during the call to analyze_pdf or JSON dumping.
+        print(f"App: Error in process_upload: {e}\n{traceback.format_exc()}")
+        error_detail = str(e)
+        # If the error is due to an invalid input type that analyze_pdf couldn't handle:
+        if "Invalid PDF input type" in error_detail: # Check for specific error from analyze_pdf
+             error_detail = f"Invalid PDF input type received from uploader: {type(uploaded_file_input)}. Details: {str(e)}"
+        
+        error_message = json.dumps({"error": error_detail, "traceback": traceback.format_exc()}, indent=2)
         return error_message, None
-    # No finally block needed here for temp file, as analyze_pdf handles its own if it creates one
-    # and Gradio handles the temp file wrapper it provides.
-
+    # No explicit temp file cleanup needed here in process_upload for the Gradio-provided file object.
+    # Gradio manages its own temporary files.
+    # analyze_pdf manages any internal temporary files it creates.
 
 def create_interface():
     with gr.Blocks(title="PDF Analyzer") as interface:
@@ -67,8 +68,9 @@ def create_interface():
         with gr.Row():
             file_input = gr.File(
                 label="Upload PDF",
-                file_types=[".pdf"],
-                # type="binary" # Gradio's File component returns a TemporaryFileWrapper which is file-like
+                file_types=[".pdf"]
+                # Default type: Gradio provides a path-like object (e.g., NamedString)
+                # or a TemporaryFileWrapper. Both should be acceptable by analyze_pdf.
             )
         
         with gr.Row():
@@ -76,7 +78,7 @@ def create_interface():
         
         with gr.Row():
             results_output = gr.JSON(
-                label="Analysis Results", # Simplified label
+                label="Analysis Results",
                 show_label=True
             )
         
@@ -84,7 +86,7 @@ def create_interface():
             pdf_output = gr.File( 
                 label="Annotated PDF (Placeholder - View Coordinates in JSON)",
                 show_label=True,
-                interactive=False # Not interactive as it's a placeholder
+                interactive=False 
             )
         
         analyze_btn.click(
@@ -98,18 +100,15 @@ if __name__ == "__main__":
     print("\n--- Launching Gradio Interface ---")
     # config.set_java_home() is called when config.py is imported.
 
-    # Optional: Test LanguageTool initialization
     try:
-        import language_tool_python # Import here for the test
         lt_test = language_tool_python.LanguageTool('en-US')
         lt_test.close()
         print("App: LanguageTool initialized successfully for test.")
     except Exception as lt_e:
-        print(f"App: Warning: Could not initialize LanguageTool for test. Language checks might fail: {lt_e}")
+        print(f"App: Warning: Could not initialize LanguageTool for test. Language checks might fail: {lt_e}\n{traceback.format_exc(limit=1)}")
         print("Please ensure Java is installed and JAVA_HOME is correctly set (see config.py).")
     
     app_interface = create_interface()
     app_interface.launch(
-        share=False, # Set to True for public link if ngrok is installed and desired
-        # server_port=7860 # Optionally specify a port
+        share=False,
     )