Update app.py

app.py

@@ -3,49 +3,55 @@ import json
 import os
 import gradio as gr
 import tempfile
+import shutil # Needed for rmtree
+import traceback # For detailed error logging
 
-# Set JAVA_HOME environment variable
-# os.environ['JAVA_HOME'] = '/usr/lib/jvm/java-11-openjdk-amd64'
+# Set JAVA_HOME environment variable (Uncomment and set if needed)
+# os.environ['JAVA_HOME'] = '/usr/lib/jvm/java-11-openjdk-amd64' # Example path
 
-def grade_pdf(input_pdf, pdffigures2_jar):
+def grade_pdf(input_pdf_path, pdffigures2_jar):
     """
     Process a PDF file using pdffigures2 and return the extracted JSON output.
-
     Args:
-        input_pdf (str): Path to the input PDF file.
-        output_dir (str): Path to the directory where JSON output will be saved.
+        input_pdf_path (str): Path to the input PDF file.
         pdffigures2_jar (str): Path to the pdffigures2 JAR file.
-
     Returns:
-        dict: Parsed JSON data extracted by pdffigures2.
-
+        list: List of issues found based on figure/table caption rules.
     Raises:
         FileNotFoundError: If the input PDF or JAR file does not exist.
         Exception: If the command fails or the JSON output is not generated.
     """
     # Check if input file and JAR file exist
-    if not os.path.exists(input_pdf):
-        raise FileNotFoundError(f"Input PDF file not found: {input_pdf}")
+    if not os.path.exists(input_pdf_path):
+        raise FileNotFoundError(f"Input PDF file not found: {input_pdf_path}")
     if not os.path.exists(pdffigures2_jar):
         raise FileNotFoundError(f"pdffigures2 JAR file not found: {pdffigures2_jar}")
 
+    temp_output_dir = None # Initialize
+    try:
+        # Create a temporary directory for the output JSON
+        temp_output_dir = tempfile.mkdtemp()
+        # Construct the expected output JSON file path INSIDE the temp directory
+        # pdffigures2 creates a JSON named after the input file inside the dir specified by -d
+        output_json_file = os.path.join(temp_output_dir, os.path.splitext(os.path.basename(input_pdf_path))[0] + ".json")
+        print(f"Expecting output JSON at: {output_json_file}")
 
-    # Command to execute pdffigures2
-    command = [
-        "java", "-jar", pdffigures2_jar,
-        input_pdf,
-        "-d", '_'
-    ]
-    print(input_pdf)
+        # Command to execute pdffigures2
+        # Use -d to specify the *directory* for the JSON output
+        command = [
+            "java", "-jar", pdffigures2_jar,
+            input_pdf_path,
+            "-d", temp_output_dir # Output JSON to the temp directory
+        ]
+        print(f"Running command: {' '.join(command)}")
 
-    try:
         # Run the command
-        subprocess.run(command, capture_output=True, text=True, check=True)
+        result = subprocess.run(command, capture_output=True, text=True, check=True, timeout=60) # Added timeout
+        print("pdffigures2 stdout:", result.stdout)
+        # Stderr might contain useful info even on success for pdffigures2
+        if result.stderr:
+             print("pdffigures2 stderr:", result.stderr)
 
-        # Construct the output JSON file path
-        # print()
-        output_json_file = "_"+os.path.splitext(os.path.basename(input_pdf))[0] +".json"
-        print("output_json_file: ", output_json_file)
 
         # Read and return the JSON data
         if os.path.exists(output_json_file):
@@ -55,81 +61,207 @@ def grade_pdf(input_pdf, pdffigures2_jar):
             issueList = list()
 
             for region in regions:
-                issues = dict()
-                if(region["captionBoundary"]["y1"]>region["regionBoundary"]["y1"]):
-                    region["captionLocation"]="Below"
+                # Determine caption location
+                caption_loc = "Above" # Default
+                # Ensure keys exist before accessing
+                if "captionBoundary" in region and "regionBoundary" in region and \
+                   isinstance(region["captionBoundary"], dict) and isinstance(region["regionBoundary"], dict) and \
+                   "y1" in region["captionBoundary"] and "y1" in region["regionBoundary"]:
+
+                    if(region["captionBoundary"]["y1"] > region["regionBoundary"]["y1"]):
+                        caption_loc = "Below"
                 else:
-                    region["captionLocation"]="Above"
-
-                if(region["captionLocation"]=="Below" and region["figType"] == "Table"):
-                    issues["page_number"]=region["page"]+1
-                    issues["caption_coordinate"]=region["captionBoundary"]
-                    issues["fig_type"] = region["figType"]
-                    issues["caption_location"] = region["captionLocation"]
-                    issues["description"]="Location of the caption for tables must be above the table."
-                    issueList.append(issues)
-                    
-                if(region["captionLocation"]=="Above" and region["figType"] == "Figure"):
-                    issues["page_number"]=region["page"]+1
-                    issues["caption_coordinate"]=region["captionBoundary"]
-                    issues["fig_type"] = region["figType"]
-                    issues["description"]="Location of the caption for figures must be below the table."
+                     print(f"Warning: Missing boundary information for a region on page {region.get('page', 'N/A')}. Skipping location check.")
+                     continue # Skip this region if boundaries are missing
+
+                region["captionLocation"] = caption_loc # Store for potential use/debugging
+
+                fig_type = region.get("figType") # Use .get for safety
+                page_num = region.get("page", -1) + 1 # Use .get and handle potential missing key
+
+                issues = {} # Initialize for this specific issue potential
+
+                # Check for Table caption below
+                if caption_loc == "Below" and fig_type == "Table":
+                    issues = {
+                        "page_number": page_num,
+                        "caption_coordinate": region.get("captionBoundary"),
+                        "fig_type": fig_type,
+                        "caption_location": caption_loc,
+                        "description": "Location of the caption for tables must be above the table."
+                    }
                     issueList.append(issues)
-                    
+
+                # Check for Figure caption above
+                elif caption_loc == "Above" and fig_type == "Figure":
+                     issues = {
+                        "page_number": page_num,
+                        "caption_coordinate": region.get("captionBoundary"),
+                        "fig_type": fig_type,
+                        "caption_location": caption_loc,
+                        "description": "Location of the caption for figures must be below the figure."
+                     }
+                     issueList.append(issues)
+
             return issueList
 
         else:
-            raise Exception(f"JSON output file not found: {output_json_file}")
+            # If JSON not found, include stderr from the process
+            raise Exception(f"JSON output file not found: {output_json_file}. pdffigures2 stderr: {result.stderr if result else 'No result object'}")
 
     except subprocess.CalledProcessError as e:
-        raise Exception(f"Error while running pdffigures2: {e.stderr}")
+        # Include command output/error in the exception
+        raise Exception(f"Error while running pdffigures2 (return code {e.returncode}):\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}")
+    except subprocess.TimeoutExpired as e:
+         raise Exception(f"pdffigures2 command timed out after {e.timeout} seconds.\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}")
+    except Exception as e:
+        # Re-raise other exceptions for clarity
+        print(f"An unexpected error occurred in grade_pdf:")
+        traceback.print_exc() # Print detailed traceback for debugging
+        raise e # Re-raise the original exception
+    finally:
+         # Clean up the temporary output directory and its contents
+         if temp_output_dir and os.path.exists(temp_output_dir):
+             try:
+                 shutil.rmtree(temp_output_dir)
+                 print(f"Cleaned up temporary output directory: {temp_output_dir}")
+             except Exception as cleanup_error:
+                 print(f"Warning: Failed to cleanup temporary output directory {temp_output_dir}: {cleanup_error}")
+
 
-def process_file(file):
+def process_file(file_bytes: bytes): # Expect raw bytes
     """
-    Wrapper to process a file via grade_pdf and return JSON data.
+    Wrapper to process PDF bytes received from Gradio client via grade_pdf
+    and return JSON data.
 
     Args:
-        file (str): Path to the uploaded PDF file.
+        file_bytes (bytes): The raw byte content of the uploaded PDF file.
 
     Returns:
-        str: JSON string of extracted data.
+        str: JSON string of extracted data or an error message.
     """
-    # Define paths
-    pdffigures2_jar_path = "pdffigures2.jar"  # Path to pdffigures2 JAR file
-    
-    temp_input = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
-    temp_input.write(file)
-    temp_input_path = temp_input.name
-    print("Path of the input file: ",temp_input_path)
+    # Define path relative to the script location or use an absolute path
+    pdffigures2_jar_path = "pdffigures2.jar"
+    temp_input_path = None  # Initialize path variable
+
+    # --- Input Sanity Check ---
+    if not file_bytes or not isinstance(file_bytes, bytes):
+        return json.dumps({"error": "Invalid input: No file data received or data is not in bytes format."}, indent=4)
+    # Simple check for PDF magic number (%PDF)
+    if not file_bytes.startswith(b'%PDF'):
+         print("Warning: Input data does not start with PDF magic number (%PDF).")
+         # Decide whether to proceed or return an error
+         # return json.dumps({"error": "Invalid input: File does not appear to be a PDF."}, indent=4)
+
+    print(f"Received {len(file_bytes)} bytes of file data.")
 
     try:
-        # Process the PDF and get JSON data
-        # print(file.name)
+        # Create a temporary file to store the received bytes
+        # 'wb' mode is crucial for writing bytes
+        # delete=False requires manual cleanup in the finally block
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf', mode='wb') as temp_input:
+            temp_input.write(file_bytes)
+            temp_input_path = temp_input.name  # Get the path *after* writing
+
+        # At this point, temp_input is closed, but the file persists because delete=False
+        print(f"PDF bytes written to temporary file: {temp_input_path}")
+
+        # Process the PDF using the path to the temporary file
         extracted_data = grade_pdf(temp_input_path, pdffigures2_jar_path)
-        # Clean up the temporary input file
-        os.unlink(temp_input_path)
-        
 
         # Return JSON as a formatted string
         return json.dumps(extracted_data, indent=4)
+
+    except FileNotFoundError as e:
+         # Provide more specific feedback
+         if "pdffigures2.jar" in str(e):
+             error_msg = f"Configuration error: pdffigures2 JAR file not found at '{pdffigures2_jar_path}'. Ensure it's present and accessible."
+             print(error_msg)
+             return json.dumps({"error": error_msg}, indent=4) # Return error as JSON
+         elif temp_input_path and str(temp_input_path) in str(e):
+             error_msg = f"Internal error: Could not find the temporary PDF file '{temp_input_path}' after creating it. {e}"
+             print(error_msg)
+             return json.dumps({"error": error_msg}, indent=4)
+         else:
+             error_msg = f"File system error: {e}"
+             print(error_msg)
+             return json.dumps({"error": error_msg}, indent=4)
     except Exception as e:
-        return f"An error occurred: {e}"
+        # Log the full error for server-side debugging
+        print("------ ERROR in process_file ------")
+        traceback.print_exc()
+        print("-----------------------------------")
+        # Return a generic error message as JSON to the client
+        return json.dumps({"error": f"An unexpected error occurred during processing: {type(e).__name__}"}, indent=4)
+    finally:
+        # Clean up the temporary *input* file if its path was assigned
+        if temp_input_path and os.path.exists(temp_input_path):
+            try:
+                os.unlink(temp_input_path)
+                print(f"Cleaned up temporary input file: {temp_input_path}")
+            except Exception as cleanup_error:
+                print(f"Warning: Failed to cleanup temporary input file {temp_input_path}: {cleanup_error}")
 
 # Gradio Interface
 def gradio_interface():
+    # --- Pre-launch Checks ---
+    pdffigures2_jar_path = "pdffigures2.jar"
+    if not os.path.exists(pdffigures2_jar_path):
+        print(f"ERROR: {pdffigures2_jar_path} not found in the current directory.")
+        print("Please download it and place it alongside this script.")
+        # Consider exiting if the JAR is essential for the app to function
+        # import sys
+        # sys.exit(1)
+
+    try:
+        # Check for Java (more robust check)
+        print("Checking for Java installation...")
+        java_check = subprocess.run(["java", "-version"], capture_output=True, text=True, timeout=10)
+        # java -version often prints to stderr
+        if java_check.returncode == 0 and ("version" in java_check.stdout or "version" in java_check.stderr):
+             print("Java installation found:")
+             print(java_check.stderr if "version" in java_check.stderr else java_check.stdout)
+        else:
+             print(f"Warning: 'java -version' returned code {java_check.returncode} or did not contain 'version'. Ensure Java is correctly installed and in PATH.")
+             print("STDOUT:", java_check.stdout)
+             print("STDERR:", java_check.stderr)
+             # Decide if this is critical enough to exit
+    except FileNotFoundError:
+         print("ERROR: 'java' command not found. Please install Java (JRE or JDK) and ensure it's in your system's PATH.")
+         # import sys
+         # sys.exit(1)
+    except subprocess.TimeoutExpired:
+         print("ERROR: 'java -version' command timed out. Java installation might be corrupted.")
+         # import sys
+         # sys.exit(1)
+    except Exception as e:
+         print(f"ERROR: An unexpected error occurred while checking for Java: {e}")
+         # import sys
+         # sys.exit(1)
+
+
+    # --- Define Interface ---
     interface = gr.Interface(
         fn=process_file,
-        
-        inputs=gr.File(label="Upload PDF File", file_types=[".pdf"], type="binary"),
-        
-        outputs=gr.Textbox(label="Extracted JSON Data", lines=20),
-        
-        title="PDF Grading Interface",
-        
-        description="Upload a PDF file, and this tool will extract figures and captions as JSON."
+        # Expect binary data from the client
+        inputs=gr.File(
+            label="Upload PDF File",
+            file_types=[".pdf"],
+            type="binary" # Crucial change: accept bytes
+        ),
+        outputs=gr.Textbox(
+            label="Analysis Results (JSON)", # More descriptive label
+            lines=20
+        ),
+        title="PDF Figure/Table Caption Placement Checker",
+        description="Upload a PDF file (via API or UI). This tool uses pdffigures2 to identify figures/tables and checks if captions are placed correctly (Tables: Above, Figures: Below). Returns results as JSON.",
+        # Optional: Add examples if running interactively
+        # examples=[["path/to/example1.pdf"], ["path/to/example2.pdf"]]
     )
     return interface
 
 if __name__ == "__main__":
     # Launch the Gradio app
-    gradio_interface().launch()
+    # share=True creates a public link (use with caution)
+    # server_name="0.0.0.0" makes it accessible on the network
+    gradio_interface().launch(server_name="0.0.0.0")