Update app.py

app.py

@@ -3,55 +3,49 @@ 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 (Uncomment and set if needed)
-# os.environ['JAVA_HOME'] = '/usr/lib/jvm/java-11-openjdk-amd64' # Example path
+# Set JAVA_HOME environment variable
+# os.environ['JAVA_HOME'] = '/usr/lib/jvm/java-11-openjdk-amd64'
 
-def grade_pdf(input_pdf_path, pdffigures2_jar):
+def grade_pdf(input_pdf, pdffigures2_jar):
     """
     Process a PDF file using pdffigures2 and return the extracted JSON output.
+
     Args:
-        input_pdf_path (str): Path to the input PDF file.
+        input_pdf (str): Path to the input PDF file.
+        output_dir (str): Path to the directory where JSON output will be saved.
         pdffigures2_jar (str): Path to the pdffigures2 JAR file.
+
     Returns:
-        list: List of issues found based on figure/table caption rules.
+        dict: Parsed JSON data extracted by pdffigures2.
+
     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_path):
-        raise FileNotFoundError(f"Input PDF file not found: {input_pdf_path}")
+    if not os.path.exists(input_pdf):
+        raise FileNotFoundError(f"Input PDF file not found: {input_pdf}")
     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
-        # 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)}")
+    # Command to execute pdffigures2
+    command = [
+        "java", "-jar", pdffigures2_jar,
+        input_pdf,
+        "-d", '_'
+    ]
+    print(input_pdf)
 
+    try:
         # Run the command
-        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)
+        subprocess.run(command, capture_output=True, text=True, check=True)
 
+        # 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):
@@ -61,207 +55,81 @@ def grade_pdf(input_pdf_path, pdffigures2_jar):
             issueList = list()
 
             for region in regions:
-                # 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"
+                issues = dict()
+                if(region["captionBoundary"]["y1"]>region["regionBoundary"]["y1"]):
+                    region["captionLocation"]="Below"
                 else:
-                     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."
-                    }
+                    region["captionLocation"]="Above"
+
+                if(region["captionLocation"]=="Below" and region["figType"] == "Table"):
+                    issues["page_number"]=region["page"]
+                    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)
-
-                # 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)
-
+                    
+                if(region["captionLocation"]=="Above" and region["figType"] == "Figure"):
+                    issues["page_number"]=region["page"]
+                    issues["caption_coordinate"]=region["captionBoundary"]
+                    issues["fig_type"] = region["figType"]
+                    issues["description"]="Location of the caption for figures must be below the table."
+                    issueList.append(issues)
+                    
             return issueList
 
         else:
-            # 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'}")
+            raise Exception(f"JSON output file not found: {output_json_file}")
 
     except subprocess.CalledProcessError as e:
-        # 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}")
-
+        raise Exception(f"Error while running pdffigures2: {e.stderr}")
 
-def process_file(file_bytes: bytes): # Expect raw bytes
+def process_file(file):
     """
-    Wrapper to process PDF bytes received from Gradio client via grade_pdf
-    and return JSON data.
+    Wrapper to process a file via grade_pdf and return JSON data.
 
     Args:
-        file_bytes (bytes): The raw byte content of the uploaded PDF file.
+        file (str): Path to the uploaded PDF file.
 
     Returns:
-        str: JSON string of extracted data or an error message.
+        str: JSON string of extracted data.
     """
-    # 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.")
+    # 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)
 
     try:
-        # 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
+        # Process the PDF and get JSON data
+        # print(file.name)
         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:
-        # 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}")
+        return f"An error occurred: {e}"
 
 # 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,
-        # 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"]]
+        
+        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."
     )
     return interface
 
 if __name__ == "__main__":
     # Launch the Gradio app
-    # 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")
+    gradio_interface().launch()