Update app.py

app.py

@@ -4,52 +4,71 @@ import traceback
 import tempfile
 import os
 import gradio as gr
-from typing import Tuple, Optional # For type hinting
+from typing import Tuple, Optional, Any # Added Any for file_data_binary
 
-# Ensure JAVA_HOME is set before LanguageTool might be initialized.
-# config.py should be imported early if it handles this.
-import config # This will run set_java_home() from config.py
+# Import config first to ensure JAVA_HOME is set early
+import config 
 
-# Import the main analysis function
 from main_analyzer import analyze_pdf 
-import language_tool_python # For the test initialization
+# Import language_tool_python only for the test in __main__ if needed
+# import language_tool_python 
 
-def process_upload(file_data_binary: bytes) -> Tuple[str, Optional[str]]:
-    if file_data_binary is None:
-        return json.dumps({"error": "No file uploaded"}, indent=2), None
+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.
 
-    temp_input_path = None
+    # 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.
     try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_input_file:
-            temp_input_file.write(file_data_binary)
-            temp_input_path = temp_input_file.name
-        print(f"Temporary PDF for analysis: {temp_input_path}")
+        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()
         
-        results_dict, _ = analyze_pdf(temp_input_path) 
+        # 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.
+        
+        # analyze_pdf will create its own temp file if it receives a stream.
+        results_dict, _ = analyze_pdf(file_data_binary) 
         
         results_json = json.dumps(results_dict, indent=2, ensure_ascii=False)
-        return results_json, None
+        return results_json, None 
 
     except Exception as e:
-        print(f"Error in process_upload: {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)
         return error_message, None
-    finally:
-        if temp_input_path and os.path.exists(temp_input_path):
-            os.unlink(temp_input_path)
-            print(f"Cleaned up temporary file: {temp_input_path}")
+    # 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.
 
 
 def create_interface():
     with gr.Blocks(title="PDF Analyzer") as interface:
         gr.Markdown("# PDF Analyzer")
-        gr.Markdown("Upload a PDF document to analyze its structure, references, language, and more. Language issues will include PDF coordinates if found, and are filtered to appear between 'Abstract' and 'References/Bibliography'.")
+        gr.Markdown(
+            "Upload a PDF document to analyze its structure, references, language, and more. "
+            "Language issues are derived from font-filtered text. "
+            "Regex issues and general document checks use unfiltered text from the original PDF. "
+            "All issue coordinates (if found) are mapped back to the original PDF."
+        )
         
         with gr.Row():
             file_input = gr.File(
                 label="Upload PDF",
                 file_types=[".pdf"],
-                type="binary"
+                # type="binary" # Gradio's File component returns a TemporaryFileWrapper which is file-like
             )
         
         with gr.Row():
@@ -57,14 +76,15 @@ def create_interface():
         
         with gr.Row():
             results_output = gr.JSON(
-                label="Analysis Results (Coordinates for issues in 'issues' list)",
+                label="Analysis Results", # Simplified label
                 show_label=True
             )
         
         with gr.Row():
-            pdf_output = gr.File(
-                label="Annotated PDF (Functionality Removed - View Coordinates in JSON)",
+            pdf_output = gr.File( 
+                label="Annotated PDF (Placeholder - View Coordinates in JSON)",
                 show_label=True,
+                interactive=False # Not interactive as it's a placeholder
             )
         
         analyze_btn.click(
@@ -76,20 +96,20 @@ def create_interface():
 
 if __name__ == "__main__":
     print("\n--- Launching Gradio Interface ---")
-    # config.py handles JAVA_HOME setting upon its import
+    # config.set_java_home() is called when config.py is imported.
 
-    # Optional: Check if LanguageTool can be initialized (as in original)
+    # 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("LanguageTool initialized successfully for test.")
+        print("App: LanguageTool initialized successfully for test.")
     except Exception as lt_e:
-        print(f"Warning: Could not initialize LanguageTool for test. Language checks might fail: {lt_e}")
-        print("Please ensure Java is installed and JAVA_HOME is correctly set by config.py or environment.")
-        print("For example, on Ubuntu with OpenJDK 11: export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64")
-
-    interface = create_interface()
-    interface.launch(
-        share=False, 
-        server_port=None 
+        print(f"App: Warning: Could not initialize LanguageTool for test. Language checks might fail: {lt_e}")
+        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
     )