feat: Sync evaluation codes and leaderboard with the latest version

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.py[cod]
+predictions/
+*.eval.json

README.md

@@ -201,8 +201,16 @@ It contains a wide range of document layouts, from text-heavy pages to complex t
 The dataset comes with annotations for layout elements such as paragraphs, headings, and tables.
 
 The following options are required for evaluation:
-- **`--ref_path`**: Specifies the path to the reference JSON file, predefined as `dataset/reference.json` for evaluation purposes.
-- **`--pred_path`**: Indicates the path to the predicted JSON file. You can either use a sample result located in the `dataset/sample_results` folder, or generate your own by using the inference script provided in the `scripts` folder.
+- **`--ref-path`**: Specifies the path to the reference JSON file, predefined as `dataset/reference.json` for evaluation purposes.
+- **`--pred-path`**: Indicates the path to the predicted JSON file. You can either use a sample result located in the `dataset/sample_results` folder, or generate your own by using the inference script provided in the `scripts` folder.
+- **`--mode`**: One of `layout`, `table`, `all`, or `speed` (default: `all`).
+  - `layout` — NID for element detection and serialization
+  - `table` — TEDS and TEDS-S for table structure recognition
+  - `all` — run both `layout` and `table`
+  - `speed` — average latency and throughput from `time_sec` fields
+- **`--evaluate-merged-table`**: Optional. Enables merged-table preprocessing when the prediction or reference declares a `merged_tables` key.
+
+Per-image scores and metric summaries are written next to the prediction file as `<pred-file>.eval.json`.
 
 #### Element detection and serialization evaluation
 This evaluation will compute the NID metric to assess how accurately the text in the document is recognized considering the structure and order of the document layout.
@@ -210,8 +218,8 @@ To evaluate the document layout results, run the following command:
 
 ```
 $ python evaluate.py \
-  --ref_path <path to the reference json file> \
-  --pred_path <path to the predicted json file> \
+  --ref-path <path to the reference json file> \
+  --pred-path <path to the predicted json file> \
   --mode layout
 ```
 
@@ -222,21 +230,22 @@ To evaluate table recognition performance, use the following command:
 
 ```
 $ python evaluate.py \
-  --ref_path <path to the reference json file> \
-  --pred_path <path to the predicted json file> \
+  --ref-path <path to the reference json file> \
+  --pred-path <path to the predicted json file> \
   --mode table
 ```
 
 # Leaderboard
 <div style="max-width: 800px; width: 100%; overflow-x: auto; margin: 0 auto;">
   
-| Source               | Request date | TEDS ↑     | TEDS-S ↑  | NID ↑       |  Avg. Time (secs) ↓ |
-|:---------------------|:------------:|-----------:|----------:|------------:|------------:|
-| upstage              | 2024-10-24   | **93.48**  | **94.16** | **97.02**   |  **3.79**   |
-| aws                  | 2024-10-24   | 88.05      | 90.79     | 96.71       |  14.47      |
-| llamaparse           | 2024-10-24   | 74.57      | 76.34     | 92.82       |  4.14       |
-| unstructured         | 2024-10-24   | 65.56      | 70.00     | 91.18       |  13.14      |
-| google               | 2024-10-24   | 66.13      | 71.58     | 90.86       |  5.85       |
-| microsoft            | 2024-10-24   | 87.19      | 89.75     | 87.69       |  4.44       |
+| Source                      | Request date | TEDS ↑    | TEDS-S ↑  | NID ↑     | Avg. Time (secs) ↓ |
+|:----------------------------|:------------:|----------:|----------:|----------:|-------------------:|
+| upstage (enhanced) | 2026-02-09   | 95.59     | **97.62** | **96.62** | 7.56               |
+| upstage (standard) | 2026-02-09   | **96.06** | 97.25     | 96.29     | 3.77               |
+| aws                | 2026-02-09   | 95.48     | 96.99     | 95.97     | 7.95               |
+| unstructured       | 2026-02-09   | 80.26     | 89.51     | 91.78     | 6.80               |
+| llamaparse         | 2026-02-09   | 90.73     | 93.20     | 90.53     | 10.88              |
+| microsoft          | 2026-02-09   | 77.85     | 85.74     | 87.03     | **3.39**           |
+| google             | 2026-02-09   | 78.30     | 80.71     | 82.17     | 37.00              |
 
 </div>

evaluate.py

@@ -1,33 +1,56 @@
 import argparse
+import json
+from pathlib import Path
 
-from src.utils import read_file, check_data_validity
+from src.utils import read_file, check_data_validity, preprocess_merged_tables
 from src.layout_evaluation import evaluate_layout
 from src.table_evaluation import evaluate_table
 
-
 def parse_args():
     parser = argparse.ArgumentParser(description="Arguments for evaluation")
     parser.add_argument(
-        "--ref_path",
+        "--ref-path",
         type=str, required=True,
         help="Path to the ground truth file"
     )
     parser.add_argument(
-        "--pred_path",
+        "--pred-path",
         type=str, required=True,
         help="Path to the prediction file"
     )
     parser.add_argument(
-        "--ignore_classes_for_layout",
+        "--ignore-classes-for-layout",
         type=list, default=["figure", "table", "chart"],
         help="List of layout classes to ignore. This is used only for layout evaluation."
     )
+    parser.add_argument(
+        "--filter-by-gt-area",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Filter out prediction text within GT ignored regions (default: True). Use --no-filter-by-gt-area to disable."
+    )
     parser.add_argument(
         "--mode",
-        type=str, default="layout",
-        help="Mode for evaluation (layout/table)"
+        type=str, default="all",
+        choices=["layout", "table", "all", "speed"],
+        help="Mode for evaluation (layout/table/all/speed). 'all' runs both layout and table evaluations. 'speed' evaluates latency and throughput."
+    )
+    parser.add_argument(
+        "--min-match-score",
+        type=float, default=0.1,
+        help="Minimum match score for table evaluation"
+    )
+    parser.add_argument(
+        "--max-workers",
+        type=int, default=8,
+        help="Maximum number of workers for table evaluation"
+    )
+    parser.add_argument(
+        "--evaluate-merged-table",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Enable merged table evaluation mode. When enabled, tables specified in 'merged_tables' will be preprocessed and merged before evaluation (default: False)."
     )
-
     return parser.parse_args()
 
 
@@ -42,20 +65,188 @@ def main():
     label_data = read_file(args.ref_path)
     pred_data = read_file(args.pred_path)
 
-    check_data_validity(label_data, pred_data)
+    # Apply merged table preprocessing if enabled
+    if args.evaluate_merged_table:
+        print("Merged table evaluation mode enabled")
+        print("Preprocessing ground truth data (merging tables)...")
+        label_data = preprocess_merged_tables(label_data)
+        
+        # Check if prediction data has merged_tables key
+        has_merged_tables_in_pred = any(
+            isinstance(doc, dict) and "merged_tables" in doc
+            for doc in pred_data.values()
+        )
+        
+        if has_merged_tables_in_pred:
+            print("Preprocessing prediction data (merging tables)...")
+            pred_data = preprocess_merged_tables(pred_data)
+        else:
+            print("Prediction data does not contain 'merged_tables' key - skipping preprocessing (assuming already merged)")
 
-    if args.mode == "layout":
-        score = evaluate_layout(
-            label_data, pred_data,
+    valid_keys, error_keys, missing_keys = check_data_validity(label_data, pred_data)
+    
+    # Report data quality statistics
+    total_gt_samples = len(label_data)
+    print(f"Total GT samples: {total_gt_samples}")
+    print(f"Valid predictions: {len(valid_keys)}")
+    print(f"Predictions with errors: {len(error_keys)}")
+    print(f"Missing predictions: {len(missing_keys)}")
+    
+    if error_keys:
+        print(f"\nSkipping {len(error_keys)} samples with errors:")
+        for key in error_keys[:5]:  # Show first 5
+            print(f"  - {key}")
+        if len(error_keys) > 5:
+            print(f"  ... and {len(error_keys) - 5} more")
+    
+    if missing_keys:
+        print(f"\nWarning: {len(missing_keys)} samples missing from predictions")
+    
+    if not valid_keys:
+        raise ValueError("No valid predictions found. Cannot perform evaluation.")
+    
+    print("-" * 50)
+    
+    # Filter data to only include valid keys
+    filtered_label_data = {k: label_data[k] for k in valid_keys}
+    filtered_pred_data = {k: pred_data[k] for k in valid_keys}
+
+    # Prepare output file path
+    pred_path_obj = Path(args.pred_path)
+    eval_output_path = pred_path_obj.with_suffix(".eval.json")
+
+    # Collect evaluation results
+    eval_results = {
+        "ref_path": args.ref_path,
+        "pred_path": args.pred_path,
+        "mode": args.mode,
+        "evaluate_merged_table": args.evaluate_merged_table,
+        "data_statistics": {
+            "total_gt_samples": total_gt_samples,
+            "valid_predictions": len(valid_keys),
+            "error_predictions": len(error_keys),
+            "missing_predictions": len(missing_keys),
+        },
+        "per_image_results": {}
+    }
+
+    if args.mode == "layout" or args.mode == "all":
+        if args.mode == "all":
+            print("=" * 50)
+            print("Layout Evaluation")
+            print("=" * 50)
+        score, per_image_layout_scores = evaluate_layout(
+            filtered_label_data, filtered_pred_data,
             ignore_classes=args.ignore_classes_for_layout,
+            filter_by_gt_area=args.filter_by_gt_area,
         )
         print(f"NID Score: {score:.4f}")
-    elif args.mode == "table":
-        teds_score, teds_s_score = evaluate_table(label_data, pred_data)
-        print(f"TEDS Score: {teds_score:.4f}")
+        eval_results["layout"] = {
+            "nid_score": score,
+            "ignore_classes": args.ignore_classes_for_layout,
+            "filter_by_gt_area": args.filter_by_gt_area,
+        }
+        
+        # Merge per-image layout scores into per_image_results
+        for image_key, scores_dict in per_image_layout_scores.items():
+            if image_key not in eval_results["per_image_results"]:
+                eval_results["per_image_results"][image_key] = {}
+            eval_results["per_image_results"][image_key]["layout"] = scores_dict
+        
+        if args.filter_by_gt_area:
+            print("Note: Spatial filtering by GT area is enabled (predictions within GT ignored regions are filtered)")
+        if args.mode == "all":
+            print()
+
+    if args.mode == "table" or args.mode == "all":
+        if args.mode == "all":
+            print("=" * 50)
+            print("Table Evaluation")
+            print("=" * 50)
+        table_f1_score, teds_score, teds_s_score, per_image_table_scores = evaluate_table(
+            filtered_label_data, filtered_pred_data,
+            min_match_score=args.min_match_score,
+            max_workers=args.max_workers,
+        )
+        print(f"Table F1 Score: {table_f1_score:.4f}")
         print(f"TEDS-S Score: {teds_s_score:.4f}")
-    else:
-        raise ValueError(f"{args.mode} mode not supported")
+        print(f"TEDS Score: {teds_score:.4f}")
+        eval_results["table"] = {
+            "table_f1_score": table_f1_score,
+            "teds_score": teds_score,
+            "teds_s_score": teds_s_score,
+            "min_match_score": args.min_match_score,
+        }
+        
+        # Merge per-image table scores into per_image_results
+        for image_key, scores_dict in per_image_table_scores.items():
+            if image_key not in eval_results["per_image_results"]:
+                eval_results["per_image_results"][image_key] = {}
+            eval_results["per_image_results"][image_key]["table"] = scores_dict
+
+    if args.mode == "speed" or args.mode == "all":
+        if args.mode == "all":
+            print("=" * 50)
+            print("Speed Evaluation")
+            print("=" * 50)
+        
+        # Calculate latency and throughput from time_sec fields (including errors)
+        total_time = 0.0
+        count = 0
+        
+        for image_key, image_data in pred_data.items():
+            if image_key == "_metadata":
+                continue  # Skip metadata entry
+            if isinstance(image_data, dict) and "time_sec" in image_data:
+                total_time += image_data["time_sec"]
+                count += 1
+        
+        if count > 0:
+            avg_latency = total_time / count
+            sequential_throughput = 60.0 / avg_latency if avg_latency > 0 else 0.0
+            
+            print(f"Average Latency: {avg_latency:.4f} sec/image")
+            print(f"Sequential Throughput: {sequential_throughput:.2f} images/min (based on avg latency)")
+            print(f"Total Images: {count}")
+            print(f"Sum of Latencies: {total_time:.2f} sec")
+            
+            eval_results["speed"] = {
+                "avg_latency_sec": avg_latency,
+                "sequential_throughput_per_minute": sequential_throughput,
+                "total_images": count,
+                "sum_of_latencies_sec": total_time,
+            }
+            
+            # Report concurrent throughput from inference metadata if available
+            metadata = pred_data.get("_metadata")
+            if metadata and "total_elapsed_time_sec" in metadata:
+                elapsed_time = metadata["total_elapsed_time_sec"]
+                concurrent_limit = metadata.get("concurrent_limit")
+                num_files = metadata.get("num_files", count)
+                concurrent_throughput = (num_files / elapsed_time) * 60 if elapsed_time > 0 else 0.0
+                
+                print(f"\nConcurrent Throughput: {concurrent_throughput:.2f} images/min (wall-clock time)")
+                print(f"  - Elapsed Time: {elapsed_time:.2f} sec")
+                if concurrent_limit:
+                    print(f"  - Concurrency: {concurrent_limit}")
+                
+                eval_results["speed"]["concurrent_throughput_per_minute"] = concurrent_throughput
+                eval_results["speed"]["elapsed_time_sec"] = elapsed_time
+                eval_results["speed"]["concurrent_limit"] = concurrent_limit
+        else:
+            print("Warning: No time_sec fields found in prediction data")
+            eval_results["speed"] = {
+                "avg_latency_sec": None,
+                "sequential_throughput_per_minute": None,
+                "total_images": 0,
+                "sum_of_latencies_sec": 0.0,
+            }
+
+    # Save evaluation results to JSON file
+    with open(eval_output_path, "w", encoding="utf-8") as f:
+        json.dump(eval_results, f, indent=2, ensure_ascii=False)
+    
+    print(f"\nEvaluation results saved to: {eval_output_path}")
 
 
 if __name__ == "__main__":

requirements.txt

@@ -1,4 +1,7 @@
 rapidfuzz==3.6.1
 distance==0.1.3
 apted==1.0.3
-lxml==5.1.0
+lxml==5.1.0
+numpy
+scipy
+shapely

scripts/README.md

@@ -1,125 +1,273 @@
 # Document Parsing Models - Inference Guide
+
 ## Overview
-The scripts in this folder allow users to extract structured data from unstructured documents using different document parsing services and libraries. 
-Each service follows a standard installation procedure and provides an `infer_*` script to perform inference on PDF or Image samples.
 
-You can choose from document parsing products such as **Upstage DP**, **AWS Textract**, **Google Document AI**, **Microsoft Azure Form Recognizer**, **LlamaParse**, or **Unstructured**. 
-Most of these services require an API key for access, so ensure you follow specific setup instructions for each product to configure the environment correctly.    
+The scripts in this folder allow users to extract structured data from unstructured documents using different document parsing services and libraries. Each service follows a standard installation procedure and provides an `infer_*` script to perform inference on PDF/Image samples.
 
-Each service generates a JSON output file in a consistent format.
-You can find detailed information about the output format [here](https://github.com/UpstageAI/document-parse-benchmark-private?tab=readme-ov-file#dataset-format).
+You can choose from document parsing products such as **Upstage DP**, **AWS Textract**, **Google Document AI**, **Microsoft Azure Form Recognizer**, **LlamaParse**, or **Unstructured**. Most of these services require an API key for access. Make sure to follow specific setup instructions for each product to properly configure the environment.
 
+Each service generates a JSON output file in a consistent format with `time_sec` field for performance measurement.
 
-## Upstage
+---
 
-Follow the [official Upstage DP Documentation](https://developers.upstage.ai/docs/apis/document-parse) to set up Upstage for Document Parsing.
+## Quick Start
+
+**Run a single inference script:**
+```bash
+python scripts/infer_upstage.py \
+    --data-path <path to dataset> \
+    --save-path <output.json> \
+    [--concurrent 4] [--sampling-rate 0.5] [--request-timeout 600]
+```
+
+---
+
+## Common CLI Arguments
+
+All `infer_*` scripts share these arguments:
 
-**Note:** Ensure that the `UPSTAGE_ENDPOINT` and `UPSTAGE_API_KEY` variables are set up to run the code.
+| Argument | Description | Default |
+|----------|-------------|---------|
+| `--data-path` | Path to documents directory | Required |
+| `--save-path` | Output JSON file path | Required |
+| `--input-formats` | File extensions to process | `.pdf .jpg .jpeg .png .bmp .tiff .heic` |
+| `--concurrent` | Enable async mode with N concurrent requests | None (sync mode) |
+| `--sampling-rate` | Fraction of files to process (0.0-1.0) | 1.0 |
+| `--request-timeout` | API timeout in seconds | 600 |
+| `--random-seed` | Random seed for reproducible sampling | None (random) |
+
+---
+
+## Common Features
+
+All inference scripts share the following features:
+
+- **Time Measurement**: Automatically measures API latency and stores `time_sec` in each result
+- **Interim Results**: Saves individual API results to avoid redundant API calls on re-runs
+- **Error Handling**: Continues execution even if some files fail
+- **Progress Tracking**: Shows progress and completion status for each document
+- **Cost Optimization**: Skips already processed files to avoid unnecessary API costs
+- **Concurrency**: Optional async mode with semaphore-based rate limiting
+- **Sampling**: Optional random sampling with reproducible seeds
+
+### How Interim Results Work
+
+Each inference script creates an interim directory (named after the output file) where individual API results are stored:
 
-Use the script below to make an inference:
 ```
-$ python infer_upstage.py \
-    --data_path <path to the benchmark dataset> \
-    --save_path <path to save the .json file>
+predictions/
+├── upstage_infer.json              # Final merged results
+└── upstage_infer/                  # Interim directory
+    ├── document1.pdf.json
+    ├── document2.pdf.json
+    └── document3.pdf.json
 ```
 
-## AWS
-To use AWS Textract for document parsing, install AWS CLI and Boto3 for API interaction:
+Benefits:
+1. **Crash Recovery**: If the script crashes, already processed files are preserved
+2. **Incremental Processing**: Re-running the script only processes new files
+3. **Cost Savings**: Avoids redundant API calls for successful results
 
+### Sampling and Reproducible Results
+
+All inference scripts support random sampling of input files using the `--sampling-rate` parameter (0.0-1.0). For reproducible results across multiple runs, use the `--random-seed` parameter:
+
+```bash
+# Sample 50% of files with reproducible selection
+python scripts/infer_upstage.py \
+    --data-path ./documents \
+    --save-path results.json \
+    --sampling-rate 0.5 \
+    --random-seed 42
 ```
-$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
-$ unzip awscliv2.zip
-$ sudo ./aws/install
-$ aws configure
-$ pip install boto3
-```
-Refer to the [AWS Textract Documentation](https://docs.aws.amazon.com/en_us/textract/latest/dg/getting-started.html) for detailed instructions.  
 
-**Note:** To run the AWS inference code, you need to set the following variables: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`, and `AWS_S3_BUCKET_NAME`.
+**Benefits:**
+- **Reproducible Experiments**: Same seed + same sampling rate = identical file selection
+- **Performance Testing**: Compare different services on the exact same documents
+- **Cost Control**: Test on smaller datasets while maintaining representative samples
+
+**Note**: Without `--random-seed`, sampling will be different each run (standard random behavior).
+
+---
+
+## Upstage
+
+Follow the [official Upstage DP Documentation](https://developers.upstage.ai/docs/apis/document-parse) to set up Upstage for Document Parsing.
 
-Use the script below to make an inference:
+### Environment Variables
+```bash
+export UPSTAGE_API_KEY="your-api-key"
+export UPSTAGE_ENDPOINT="https://api.upstage.ai/v1/document-ai/document-parse"
 ```
-$ python infer_aws.py \
-    --data_path <path to the benchmark dataset> \
-    --save_path <path to save the .json file>
+
+### Inference
+```bash
+python scripts/infer_upstage.py \
+    --data-path <path to dataset> \
+    --save-path <output.json> \
+    [--model-name document-parse-nightly] \
+    [--mode standard|enhanced] \
+    [--output-formats text html markdown]
 ```
 
-## Google
-Install Google Cloud SDK and Google Document AI for document parsing on Google's platform:
+**Service-specific arguments:**
+- `--model-name`: Model version (default: `document-parse-nightly`)
+- `--mode`: Parsing mode - `standard` or `enhanced`
+- `--output-formats`: Output formats to request
 
-```
-$ apt-get install apt-transport-https ca-certificates gnupg curl
-$ curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg
-$ echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | tee -a /etc/apt/sources.list.d/google-cloud-sdk.list
-$ apt-get update && apt-get install google-cloud-cli
-$ gcloud init
-$ pip install google-cloud-documentai
+---
+
+## AWS Textract
+
+### Installation
+```bash
+curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
+unzip awscliv2.zip
+sudo ./aws/install
+aws configure
+pip install boto3
 ```
 
-More information can be found in the [Google Document AI Documentation](https://console.cloud.google.com/ai/document-ai?hl=en)  
+Refer to the [AWS Textract Documentation](https://docs.aws.amazon.com/en_us/textract/latest/dg/getting-started.html) for detailed instructions.
 
-**Note:** To run the Google inference code, you need to set the following variables: `GOOGLE_PROJECT_ID`, `GOOGLE_PROCESSOR_ID`, `GOOGLE_LOCATION`, and `GOOGLE_ENDPOINT`.
+### Environment Variables
+```bash
+export AWS_ACCESS_KEY_ID="your-access-key"
+export AWS_SECRET_ACCESS_KEY="your-secret-key"
+export AWS_REGION="your-region"
+export AWS_S3_BUCKET_NAME="your-bucket"  # Required for PDF processing
+```
 
-Use the script below to make an inference:
+### Inference
+```bash
+python scripts/infer_aws.py \
+    --data-path <path to dataset> \
+    --save-path <output.json>
 ```
-$ python infer_google.py \
-    --data_path <path to the benchmark dataset> \
-    --save_path <path to save the .json file>
+
+**Note:** PDFs use async Textract jobs (S3 upload + polling); images use direct analysis.
+
+---
+
+## Google Document AI
+
+### Installation
+```bash
+apt-get install apt-transport-https ca-certificates gnupg curl
+curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg
+echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | tee -a /etc/apt/sources.list.d/google-cloud-sdk.list
+apt-get update && apt-get install google-cloud-cli
+gcloud init
+pip install google-cloud-documentai
 ```
 
-## LlamaParse
-Refer to the [official LlamaParse Documentation](https://docs.cloud.llamaindex.ai/category/API/parsing) to install and use LlamaParse for document analysis.  
+More information in the [Google Document AI Documentation](https://console.cloud.google.com/ai/document-ai).
 
-**Note:** Ensure that the `LLAMAPARSE_API_KEY`, `LLAMAPARSE_POST_URL`, and `LLAMAPARSE_GET_URL` variables are set before running the code.
+### Environment Variables
+```bash
+export GOOGLE_PROJECT_ID="your-project-id"
+export GOOGLE_PROCESSOR_ID="your-processor-id"
+export GOOGLE_LOCATION="us"
+export GOOGLE_ENDPOINT="us-documentai.googleapis.com"
+export GOOGLE_APPLICATION_CREDENTIALS="/path/to/credentials.json"
+```
 
-Use the script below to make an inference:
+### Inference
+```bash
+python scripts/infer_google.py \
+    --data-path <path to dataset> \
+    --save-path <output.json>
 ```
-$ python infer_llamaparse.py \
-    --data_path <path to the benchmark dataset> \
-    --save_path <path to save the .json file>
+
+---
+
+## Microsoft Azure Document Intelligence
+
+### Installation
+```bash
+pip install azure-ai-formrecognizer==3.3.0
 ```
 
-## Microsoft
-Install the Azure AI Form Recognizer SDK:
+See the [Microsoft Azure Form Recognizer Documentation](https://learn.microsoft.com/en-us/azure/ai-services/document-intelligence/quickstarts/get-started-sdks-rest-api) for additional details.
+
+### Environment Variables
+```bash
+export MICROSOFT_API_KEY="your-api-key"
+export MICROSOFT_ENDPOINT="https://your-resource.cognitiveservices.azure.com/"
 ```
-$ pip install azure-ai-formrecognizer==3.3.0
+
+### Inference
+```bash
+python scripts/infer_microsoft.py \
+    --data-path <path to dataset> \
+    --save-path <output.json>
 ```
-See the [Microsoft Azure Form Recognizer Documentation](https://learn.microsoft.com/en-us/azure/ai-services/document-intelligence/quickstarts/get-started-sdks-rest-api?view=doc-intel-3.0.0&preserve-view=true&pivots=programming-language-python) for additional details.  
 
-**Note:** Set the `MICROSOFT_API_KEY` and `MICROSOFT_ENDPOINT` variables before running the code.
+---
+
+## LlamaParse
+
+Refer to the [official LlamaParse Documentation](https://docs.cloud.llamaindex.ai/category/API/parsing) to set up LlamaParse.
 
-Use the script below to make an inference:
+### Environment Variables
+```bash
+export LLAMAPARSE_API_KEY="your-api-key"
+export LLAMAPARSE_POST_URL="https://api.cloud.llamaindex.ai/api/v1/parsing/upload"
+export LLAMAPARSE_GET_URL="https://api.cloud.llamaindex.ai/api/v1/parsing/job"
 ```
-$ python infer_microsoft.py \
-    --data_path <path to the benchmark dataset> \
-    --save_path <path to save the .json file>
+
+### Inference
+```bash
+python scripts/infer_llamaparse.py \
+    --data-path <path to dataset> \
+    --save-path <output.json> \
+    [--mode cost-effective|agentic|agentic-plus]
 ```
 
+**Service-specific arguments:**
+- `--mode`: Parsing mode
+  - `cost-effective`: Fast, standard documents (default)
+  - `agentic`: Balanced quality/cost
+  - `agentic-plus`: Highest quality
+
+**Note:** Time measurement includes polling time for async API calls.
+
+---
+
 ## Unstructured
 
-To handle various document formats with Unstructured, follow the steps below:
-```
-$ pip install "unstructured-client"
+### Installation
+```bash
+pip install "unstructured[all-docs]"
+pip install poppler-utils
+
+apt install tesseract-ocr libtesseract-dev
+apt install tesseract-ocr-[lang]  # Use appropriate language code
 ```
-Detailed installation instructions can be found [here](https://docs.unstructured.io/api-reference/api-services/sdk-python). 
 
-**Note:** To run the Unstructured inference code, you must set the `UNSTRUCTURED_API_KEY` and `UNSTRUCTURED_URL` variables.
+Detailed installation instructions at [Unstructured Documentation](https://unstructured-io.github.io/unstructured/installing.html). Use [Tesseract Language Codes](https://tesseract-ocr.github.io/tessdoc/Data-Files-in-different-versions.html) for OCR support in different languages.
 
-Use the script below to make an inference:
+### Environment Variables
+```bash
+export UNSTRUCTURED_API_KEY="your-api-key"
+export UNSTRUCTURED_URL="https://api.unstructured.io/general/v0/general"
 ```
-$ python infer_unstructured.py \
-    --data_path <path to the benchmark dataset> \
-    --save_path <path to save the .json file>
+
+### Inference
+```bash
+python scripts/infer_unstructured.py \
+    --data-path <path to dataset> \
+    --save-path <output.json>
 ```
 
-# Standardize Layout Class Mapping
-Within each `infer_*` script, a `CATEGORY_MAP` is defined to standardize the mapping of layout elements across different products.  
-This ensures uniform evaluation by mapping the extracted document layout classes to the standardized layout categories for comparative analysis and evaluation purposes.  
+---
 
-Be sure to modify the `CATEGORY_MAP` in the inference scripts according to the document layout categories you are working with for accurate results.  
+## Category Mapping
 
-Below is an example of a [CATEGORY_MAP](https://github.com/UpstageAI/document-parse-benchmark-private/blob/776d9212fedb4a07671dcba666f400faf3faad4c/scripts/infer_llamaparse.py#L13) used inside LlamaParse inference script: 
-```
+Within each `infer_*` script, a `CATEGORY_MAP` is defined to standardize the mapping of layout elements across different products. This ensures uniform evaluation by mapping the extracted document layout classes to standardized categories.
+
+Example from LlamaParse:
+```python
 CATEGORY_MAP = {
     "text": "paragraph",
     "heading": "heading1",
@@ -127,4 +275,29 @@ CATEGORY_MAP = {
 }
 ```
 
+Modify the `CATEGORY_MAP` in inference scripts according to your document layout categories for accurate results.
+
+---
+
+## Utils Module
+
+The `utils.py` module provides shared functionality:
+
+- `read_file_paths()` - Find files with supported formats
+- `validate_json_save_path()` - Validate output file path
+- `load_json_file()` - Safely load existing JSON results
+- `get_interim_dir_path()` - Get interim directory path
+- `save_interim_result()` - Save individual API result
+- `load_interim_result()` - Load existing interim result
+- `collect_all_interim_results()` - Merge all interim results
+
+---
+
+## Base Classes (for developers)
+
+The `base.py` module provides inheritance hierarchy:
+
+- **`BaseInference`**: Core class with sync/async orchestration, interim result handling, performance metrics
+- **`HttpClientInference`**: For HTTP-based APIs (Upstage, LlamaParse) - manages `httpx.AsyncClient`
 
+Use `create_argument_parser()` from `base.py` to get standard CLI arguments when creating new inference scripts.

scripts/base.py

@@ -0,0 +1,899 @@
+"""
+Base class and utilities for inference scripts.
+
+This module provides:
+- BaseInference: A base class that captures common inference patterns
+- HttpClientInference: Base class for HTTP-based APIs (uses httpx)
+- print_performance_metrics: Utility for printing performance metrics
+- process_files_concurrently: Utility for concurrent file processing
+- create_argument_parser: Common CLI argument parser
+"""
+import os
+import json
+import asyncio
+import time
+import random
+import argparse
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import List, Tuple, Callable, Any, Optional, Dict
+from enum import Enum
+
+from utils import (
+    load_json_file,
+    read_file_paths,
+    validate_json_save_path,
+    get_interim_dir_path,
+    save_interim_result,
+    load_interim_result,
+    collect_all_interim_results
+)
+
+from doc_grouping import (
+    group_pages_to_documents,
+    parse_ext_mapping,
+    is_multi_page_dataset,
+)
+
+
+class ErrorType(Enum):
+    """Error categories for better error tracking."""
+    TIMEOUT = "timeout"
+    API_ERROR = "api_error"
+    NETWORK_ERROR = "network_error"
+    VALIDATION_ERROR = "validation_error"
+    UNKNOWN_ERROR = "unknown_error"
+
+
+def create_argument_parser(description: str = "Document inference script") -> argparse.ArgumentParser:
+    """Create a common argument parser with standard arguments.
+    
+    Args:
+        description: Description for the argument parser
+        
+    Returns:
+        argparse.ArgumentParser with common arguments configured
+    """
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument(
+        "--data-path",
+        type=str, default="", required=True,
+        help="Path containing the documents to process"
+    )
+    parser.add_argument(
+        "--save-path",
+        type=str, default="", required=True,
+        help="Path to save the results"
+    )
+    parser.add_argument(
+        "--input-formats",
+        type=str, nargs='+',
+        default=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"],
+        help="Supported input file formats"
+    )
+    parser.add_argument(
+        "--concurrent",
+        type=int, default=None,
+        help="Number of concurrent API requests (enables concurrent mode if specified)"
+    )
+    parser.add_argument(
+        "--sampling-rate",
+        type=float, default=1.0,
+        help="Fraction of files to process (0.0-1.0, default 1.0 = all files)"
+    )
+    parser.add_argument(
+        "--request-timeout",
+        type=float, default=600,
+        help="Timeout in seconds for API requests (default 600)"
+    )
+    parser.add_argument(
+        "--random-seed",
+        type=int, default=None,
+        help="Random seed for reproducible sampling (default None = random)"
+    )
+    parser.add_argument(
+        "--model",
+        type=str, default=None,
+        help="Model name to use for inference (default depends on provider)"
+    )
+    parser.add_argument(
+        "--mode",
+        type=str, default=None,
+        help="Inference mode (e.g., 'standard', 'enhanced', 'agentic'). None if not applicable."
+    )
+    parser.add_argument(
+        "--group-by-document",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Group per-page results into document-level entries (default: False)"
+    )
+    parser.add_argument(
+        "--file-ext-mapping",
+        type=str,
+        default=None,
+        help="File extension mapping for document grouping, e.g., 'jpg:pdf' or 'jpg->pdf,png->pdf'"
+    )
+    return parser
+
+
+def parse_args_with_extra(parser: argparse.ArgumentParser) -> argparse.Namespace:
+    """Parse arguments, gracefully ignoring unrecognized ones.
+    
+    This allows extra CLI arguments (e.g. --dpi, --jpeg-quality) to be passed
+    down from run_all.py / infer_all.py without breaking scripts that don't
+    understand them.  Unrecognized arguments are logged to stderr and silently
+    discarded.
+    
+    Args:
+        parser: ArgumentParser to use for parsing
+        
+    Returns:
+        argparse.Namespace with recognized arguments
+    """
+    args, unknown = parser.parse_known_args()
+    if unknown:
+        import sys as _sys
+        print(f"[INFO] Ignoring unrecognized arguments: {unknown}", file=_sys.stderr)
+    return args
+
+
+def print_performance_metrics(
+    sample_latencies: List[float],
+    total_elapsed_time: float,
+    concurrent_limit: Optional[int] = None,
+    num_total: Optional[int] = None,
+    num_errors: int = 0
+):
+    """Print performance metrics for concurrent processing.
+    
+    Args:
+        sample_latencies: List of latencies for each successful sample
+        total_elapsed_time: Total time elapsed for all processing
+        concurrent_limit: Optional concurrent limit (for display)
+        num_total: Optional total number of samples
+        num_errors: Number of failed samples
+    """
+    num_successful = len(sample_latencies)
+    total_samples = num_total if num_total is not None else (num_successful + num_errors)
+    success_rate = (num_successful / total_samples * 100) if total_samples > 0 else 0
+    
+    print("="*60)
+    print("PERFORMANCE METRICS")
+    if concurrent_limit is not None:
+        print(f"Concurrent Limit: {concurrent_limit}")
+    
+    print(f"\nSuccess Rate: {success_rate:.2f}% ({num_successful}/{total_samples})")
+    
+    if num_successful > 0:
+        # Latency metrics (sec/sample)
+        avg_latency = sum(sample_latencies) / num_successful
+        min_latency = min(sample_latencies)
+        max_latency = max(sample_latencies)
+        
+        print(f"\nLatency (sec/sample):")
+        print(f"  - Average: {avg_latency:.2f} sec/sample")
+        print(f"  - Min: {min_latency:.2f} sec/sample")
+        print(f"  - Max: {max_latency:.2f} sec/sample")
+        
+        # Throughput metrics (sample/min)
+        throughput_per_min = (num_successful / total_elapsed_time) * 60
+        
+        print(f"\nThroughput:")
+        print(f"  - {throughput_per_min:.2f} samples/min")
+        
+        print(f"\nTotal Processing Time: {total_elapsed_time:.2f} seconds")
+    print("="*60)
+
+
+def categorize_error(error: Exception) -> ErrorType:
+    """Categorize an exception into error types.
+    
+    Args:
+        error: Exception to categorize
+        
+    Returns:
+        ErrorType enum value
+    """
+    error_str = str(error).lower()
+    error_type = type(error).__name__
+    
+    if isinstance(error, asyncio.TimeoutError) or "timeout" in error_str:
+        return ErrorType.TIMEOUT
+    elif isinstance(error, (ConnectionError, OSError)) or "connection" in error_str or "network" in error_str:
+        return ErrorType.NETWORK_ERROR
+    elif "api" in error_str or "http" in error_str or "status" in error_str:
+        return ErrorType.API_ERROR
+    elif "validation" in error_str or "invalid" in error_str:
+        return ErrorType.VALIDATION_ERROR
+    else:
+        return ErrorType.UNKNOWN_ERROR
+
+
+async def process_files_concurrently(
+    paths: List,
+    process_single_file_fn: Callable,
+    concurrent_limit: int = 4,
+    processed_data: Optional[dict] = None,
+    *args, **kwargs
+) -> Tuple[dict, List[str], List[float], dict]:
+    """Process multiple files concurrently with semaphore-based rate limiting.
+    
+    Args:
+        paths: List of file paths to process
+        process_single_file_fn: Async function that processes a single file
+                                Should accept (filepath, file_index, total_files, *args, **kwargs) and return
+                                (filename, result, latency) or (filename, None, 0) on error
+        concurrent_limit: Maximum number of concurrent operations
+        processed_data: Optional dict of already processed data (to skip)
+        *args, **kwargs: Additional arguments to pass to process_single_file_fn
+    
+    Returns:
+        Tuple of (result_dict, error_files, sample_latencies, error_details)
+        error_details: dict mapping filename to (error_type, error_message)
+    """
+    if processed_data is None:
+        processed_data = {}
+    
+    error_files = []
+    error_details = {}  # filename -> (ErrorType, error_message)
+    sample_latencies = []
+    result_dict = {}
+    
+    # Create tasks for all files
+    tasks = []
+    for idx, filepath in enumerate(paths, 1):
+        task = process_single_file_fn(filepath, idx, len(paths), *args, **kwargs)
+        tasks.append(task)
+    
+    # Process all files concurrently (with semaphore limiting concurrency)
+    # Handle KeyboardInterrupt gracefully
+    interrupted = False
+    try:
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+    except KeyboardInterrupt:
+        interrupted = True
+        print("\n⚠️  KeyboardInterrupt detected! Collecting completed results...")
+        
+        # Cancel remaining tasks
+        for task in tasks:
+            if not task.done():
+                task.cancel()
+        
+        # Wait a moment for tasks to finish cancelling
+        await asyncio.sleep(0.1)
+        
+        # Collect completed results
+        results = []
+        for task in tasks:
+            if task.done() and not task.cancelled():
+                try:
+                    results.append(task.result())
+                except Exception as e:
+                    results.append(e)
+        
+        print(f"✓ Collected {len([r for r in results if not isinstance(r, Exception)])} completed results out of {len(paths)} total files")
+    
+    # Collect results
+    for i, result in enumerate(results):
+        if isinstance(result, Exception):
+            error_type = categorize_error(result)
+            error_msg = str(result)
+            # Try to get filename from the corresponding filepath
+            if i < len(paths):
+                filename = paths[i].name
+                error_files.append(filename)
+                error_details[filename] = (error_type, error_msg)
+            print(f"Error in task ({error_type.value}): {error_msg}")
+            continue
+        
+        filename, result_data, latency = result
+        
+        if result_data is not None:
+            result_dict[filename] = result_data
+            if latency > 0:
+                sample_latencies.append(latency)
+        elif latency == 0 and filename not in processed_data:
+            error_files.append(filename)
+            # If we get here, it means process_single_file returned (filename, None, 0)
+            # but didn't raise an exception, so it's a skipped file (already processed)
+    
+    if interrupted:
+        print("⚠️  Processing was interrupted. Partial results collected.")
+    
+    return result_dict, error_files, sample_latencies, error_details
+
+
+class BaseInference(ABC):
+    """Base class for all inference implementations.
+    
+    This class provides common functionality for:
+    - Initialization (save_path, interim_dir, processed_data)
+    - Concurrent mode setup (semaphore)
+    - Result collection and saving (_collect_and_save_results)
+    - Async inference orchestration (infer_async)
+    - Sync/async mode dispatching (infer)
+    
+    Subclasses must implement:
+    - post_process(): Process raw API results into standard format
+    - _call_api_async(): Make async API call for a file
+    - _call_api_sync(): Make sync API call for a file
+    """
+    
+    # Default input formats - can be overridden by subclasses
+    DEFAULT_INPUT_FORMATS = [".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"]
+    
+    def __init__(
+        self,
+        save_path,
+        input_formats=None,
+        concurrent_limit=None,
+        sampling_rate=1.0,
+        request_timeout=600,
+        random_seed=None,
+        group_by_document=False,
+        file_ext_mapping=None
+    ):
+        """Initialize the base inference class
+
+        Args:
+            save_path (str): the json path to save the results
+            input_formats (list, optional): the supported file formats.
+            concurrent_limit (int, optional): maximum number of concurrent API requests (enables concurrent mode)
+            sampling_rate (float, optional): fraction of files to process (0.0-1.0, default 1.0 = all files)
+            request_timeout (float, optional): timeout in seconds for API requests (default 600)
+            random_seed (int, optional): random seed for reproducible sampling (default None = random)
+            group_by_document (bool, optional): group per-page results into document-level entries (default False)
+            file_ext_mapping (str or dict, optional): file extension mapping for document grouping
+        """
+        if input_formats is None:
+            input_formats = self.DEFAULT_INPUT_FORMATS
+        
+        self.formats = input_formats
+        self.concurrent_limit = concurrent_limit
+        self.sampling_rate = max(0.0, min(1.0, sampling_rate))  # Clamp between 0 and 1
+        self.request_timeout = request_timeout
+        self.random_seed = random_seed
+        
+        # Document grouping settings
+        self.group_by_document = group_by_document
+        if isinstance(file_ext_mapping, str):
+            self.file_ext_mapping = parse_ext_mapping(file_ext_mapping) if file_ext_mapping else {}
+        else:
+            self.file_ext_mapping = file_ext_mapping or {}
+        
+        # Setup save_path and interim directory (used by both modes)
+        validate_json_save_path(save_path)
+        self.save_path = save_path
+        self.interim_dir = get_interim_dir_path(save_path)
+        os.makedirs(self.interim_dir, exist_ok=True)
+        self.processed_data = load_json_file(save_path)
+        
+        # Concurrent mode setup
+        if concurrent_limit is not None:
+            self.semaphore = asyncio.Semaphore(concurrent_limit)
+    
+    @abstractmethod
+    def post_process(self, data: Dict) -> Dict:
+        """Post-process the raw API response to match the standard format.
+        
+        This method must be implemented by subclasses to convert API-specific
+        response formats into the standard format.
+        
+        Args:
+            data (dict): raw API response data, keyed by filename
+            
+        Returns:
+            dict: processed data in standard format, keyed by filename
+        """
+        pass
+    
+    def _merge_processed_data(self, processed_dict: Dict) -> Dict:
+        """Merge previously processed data into the result dict.
+        
+        This is a common operation at the end of post_process().
+        Subclasses should call this at the end of their post_process implementation.
+        
+        Args:
+            processed_dict: The dict of newly processed results
+            
+        Returns:
+            The merged dict including previously processed data
+        """
+        for key in self.processed_data:
+            if key not in processed_dict:
+                processed_dict[key] = self.processed_data[key]
+        return processed_dict
+    
+    @abstractmethod
+    async def _call_api_async(self, filepath, *args, **kwargs):
+        """Make the actual async API call for a file.
+        
+        This method must be implemented by subclasses to perform the actual API call.
+        It should NOT handle interim result checking or saving - that's done by the base class.
+        
+        Args:
+            filepath: Path object to the file
+            *args, **kwargs: Additional arguments (e.g., client for HTTP requests)
+            
+        Returns:
+            The raw API response data (will be wrapped by base class)
+            
+        Raises:
+            Exception: If API call fails
+        """
+        pass
+    
+    async def process_single_file(self, filepath, file_index, total_files, *args, **kwargs):
+        """Process a single file asynchronously (for concurrent mode).
+        
+        This wrapper method handles:
+        - Checking if already processed
+        - Checking interim results
+        - Semaphore (if concurrent_limit is set)
+        - Timing
+        - File size tracking
+        - Saving interim results
+        - Error handling and categorization
+        
+        Subclasses only need to implement _call_api_async().
+        
+        Args:
+            filepath: Path object to the file
+            file_index: Current file index (for logging)
+            total_files: Total number of files
+            *args, **kwargs: Additional arguments passed to _call_api_async
+            
+        Returns:
+            tuple: (filename, result_data, latency) or (filename, None, 0) on error
+        """
+        filename = filepath.name
+        file_size_mb = filepath.stat().st_size / (1024 * 1024)
+        print(f"({file_index}/{total_files}) Processing {filepath} ({file_size_mb:.2f} MB)")
+        
+        # Check if already processed (in memory)
+        if filename in self.processed_data.keys():
+            print(f"'{filename}' is already in the loaded dictionary. Skipping this sample")
+            return (filename, None, 0)
+        
+        # Check if interim result exists (on disk)
+        existing_result = load_interim_result(self.interim_dir, filename)
+        if existing_result is not None:
+            print(f"'{filename}' interim result already exists. Skipping API call to save costs.")
+            return (filename, None, 0)
+        
+        try:
+            # Use semaphore if concurrent_limit is set (for file-level concurrency control)
+            # Note: Some subclasses may use semaphore inside _call_api_async for page-level control
+            if self.concurrent_limit is not None and hasattr(self, 'semaphore'):
+                async with self.semaphore:
+                    # Start timing AFTER acquiring semaphore (don't include wait time)
+                    sample_start_time = time.time()
+                    result_data = await asyncio.wait_for(
+                        self._call_api_async(filepath, *args, **kwargs),
+                        timeout=self.request_timeout
+                    )
+            else:
+                # Start timing right before API calls
+                sample_start_time = time.time()
+                result_data = await asyncio.wait_for(
+                    self._call_api_async(filepath, *args, **kwargs),
+                    timeout=self.request_timeout
+                )
+            
+            sample_latency = time.time() - sample_start_time
+            
+            # Save interim result with file size
+            result_with_time = {
+                "data": result_data,
+                "time_sec": sample_latency,
+                "file_size_mb": round(file_size_mb, 2)
+            }
+            save_interim_result(self.interim_dir, filename, result_with_time)
+            pct = file_index / total_files * 100
+            print(f"✓ ({file_index}/{total_files}, {pct:.1f}%) Saved '{filename}' (took {sample_latency:.2f}s)")
+            
+            # Return result_with_time (not result_data) to preserve time_sec/file_size_mb
+            return (filename, result_with_time, sample_latency)
+            
+        except asyncio.TimeoutError:
+            error_type = ErrorType.TIMEOUT
+            error_msg = f"Request timeout after {self.request_timeout}s"
+            print(f"✗ {filename} - {error_type.value}: {error_msg}")
+            # Raise exception so it can be caught and categorized in process_files_concurrently
+            raise asyncio.TimeoutError(error_msg)
+        except Exception as e:
+            error_type = categorize_error(e)
+            error_msg = str(e)
+            print(f"✗ {filename} - {error_type.value}: {error_msg}")
+            # Re-raise so it can be caught and categorized in process_files_concurrently
+            raise
+    
+    @abstractmethod
+    def _call_api_sync(self, filepath, *args, **kwargs):
+        """Make the actual sync API call for a file.
+        
+        This method must be implemented by subclasses to perform the actual API call.
+        It should NOT handle interim result checking or saving - that's done by the base class.
+        
+        Args:
+            filepath: Path object to the file
+            *args, **kwargs: Additional arguments
+            
+        Returns:
+            The raw API response data (will be wrapped by base class)
+            
+        Raises:
+            Exception: If API call fails
+        """
+        pass
+    
+    def process_file_sequential(self, filepath, file_index, total_files, *args, **kwargs):
+        """Process a single file sequentially (for sync mode).
+        
+        This wrapper method handles:
+        - Checking if already processed
+        - Checking interim results
+        - Timing
+        - File size tracking
+        - Saving interim results
+        - Error handling and categorization
+        
+        Subclasses only need to implement _call_api_sync().
+        
+        Args:
+            filepath: Path object to the file
+            file_index: Current file index (for logging)
+            total_files: Total number of files
+            *args, **kwargs: Additional arguments passed to _call_api_sync
+            
+        Returns:
+            tuple: (filename, result_data, latency) or (filename, None, 0) on error
+        """
+        filename = filepath.name
+        file_size_mb = filepath.stat().st_size / (1024 * 1024)
+        sample_start_time = time.time()
+        
+        try:
+            # Make the actual API call (implemented by subclass)
+            # Note: For sync calls, timeout handling should be done in the subclass
+            # or we could use signal.alarm on Unix, but that's complex
+            result_data = self._call_api_sync(filepath, *args, **kwargs)
+            
+            sample_latency = time.time() - sample_start_time
+            
+            # Save interim result with file size
+            result_with_time = {
+                "data": result_data,
+                "time_sec": sample_latency,
+                "file_size_mb": round(file_size_mb, 2)
+            }
+            save_interim_result(self.interim_dir, filename, result_with_time)
+            pct = file_index / total_files * 100
+            print(f"✓ ({file_index}/{total_files}, {pct:.1f}%) Saved '{filename}' (took {sample_latency:.2f}s)")
+            
+            # Return result_with_time (not result_data) to preserve time_sec/file_size_mb
+            return (filename, result_with_time, sample_latency)
+            
+        except Exception as e:
+            error_type = categorize_error(e)
+            error_msg = str(e)
+            print(f"✗ {filename} - {error_type.value}: {error_msg}")
+            # Re-raise so it can be caught and categorized in _infer_sequential
+            raise
+    
+    def _collect_and_save_results(self, raw_results, sample_latencies, total_elapsed_time, error_files, error_details=None):
+        """Common method to collect interim results, post-process, and save final results.
+        
+        Used by both sync and async modes. This method:
+        1. Collects all interim results from disk
+        2. Merges with current run results
+        3. Unwraps data from interim result format
+        4. Post-processes results
+        5. Preserves timing information
+        6. Saves final results
+        7. Prints performance metrics
+        
+        Args:
+            raw_results (dict): Results from current run, keyed by filename
+            sample_latencies (list): List of latencies for successful samples
+            total_elapsed_time (float): Total time elapsed for processing
+            error_files (list): List of filenames that had errors
+            error_details (dict, optional): Dict mapping filename to (ErrorType, error_message)
+            
+        Returns:
+            dict: Final processed results
+        """
+        if error_details is None:
+            error_details = {}
+        
+        # Collect all interim results
+        print("Collecting all interim results...")
+        collected_results = collect_all_interim_results(self.interim_dir)
+        
+        # Merge with raw_results (from current run)
+        for key, value in raw_results.items():
+            collected_results[key] = value
+        
+        raw_results = collected_results
+        
+        # Unwrap the data from interim results (extract 'data' field)
+        unwrapped_results = {}
+        for key, value in raw_results.items():
+            if isinstance(value, dict) and "data" in value:
+                unwrapped_results[key] = value["data"]
+            else:
+                unwrapped_results[key] = value
+        
+        # Post-process results
+        final_results = self.post_process(unwrapped_results)
+        
+        # Preserve time_sec and file_size_mb from raw_results to final_results
+        for key in final_results:
+            if key in raw_results:
+                raw_result = raw_results[key]
+                if isinstance(raw_result, dict):
+                    if "time_sec" in raw_result and isinstance(final_results[key], dict):
+                        final_results[key]["time_sec"] = raw_result["time_sec"]
+                    if "file_size_mb" in raw_result and isinstance(final_results[key], dict):
+                        final_results[key]["file_size_mb"] = raw_result["file_size_mb"]
+        
+        # Apply document-level grouping if enabled
+        if self.group_by_document:
+            # Filter out metadata keys before grouping
+            data_keys = [k for k in final_results.keys() if not k.startswith("_")]
+            if data_keys and is_multi_page_dataset(data_keys):
+                print("Grouping per-page results into document-level entries...")
+                
+                # Separate metadata and data
+                metadata_keys = [k for k in final_results.keys() if k.startswith("_")]
+                metadata = {k: final_results[k] for k in metadata_keys}
+                page_data = {k: final_results[k] for k in data_keys}
+                
+                # Group pages into documents
+                grouped_results = group_pages_to_documents(
+                    page_data,
+                    file_ext_mapping=self.file_ext_mapping,
+                    elements_key="elements",
+                    include_merged_tables=True,
+                )
+                
+                # Restore metadata
+                grouped_results.update(metadata)
+                final_results = grouped_results
+                
+                print(f"Grouped {len(data_keys)} pages into {len(grouped_results) - len(metadata_keys)} documents")
+        
+        # Calculate performance metrics from ALL results (including interim results)
+        # Extract time_sec from all collected raw_results to properly calculate metrics
+        # This is the authoritative source since raw_results contains both interim AND current run
+        all_latencies = []
+        for key, value in raw_results.items():
+            if isinstance(value, dict) and "time_sec" in value:
+                all_latencies.append(value["time_sec"])
+        
+        # Always prefer all_latencies since it's extracted from merged results (interim + current)
+        # This ensures metadata reflects ALL processed files, not just the current run
+        # Handles: full resume (all interim), partial resume, and fresh runs
+        if all_latencies:
+            sample_latencies = all_latencies
+        
+        num_successful = len(sample_latencies)
+        num_total = num_successful + len(error_files)
+        
+        # Estimate total_elapsed_time from latencies if current run processed nothing
+        # For concurrent processing: wall-clock time ≈ sum(latencies) / concurrent_limit
+        if total_elapsed_time < 1.0 and sample_latencies:
+            sum_latencies = sum(sample_latencies)
+            concurrent_limit = self.concurrent_limit or 1
+            total_elapsed_time = sum_latencies / concurrent_limit
+        
+        # Add metadata for reproducible throughput calculation in evaluation
+        final_results["_metadata"] = {
+            "total_elapsed_time_sec": round(total_elapsed_time, 4),
+            "concurrent_limit": self.concurrent_limit,
+            "num_files": num_total,
+            "num_successful": num_successful,
+            "num_errors": len(error_files)
+        }
+        
+        # Save final results
+        with open(self.save_path, "w", encoding="utf-8") as f:
+            json.dump(final_results, f, ensure_ascii=False, indent=4)
+        
+        print_performance_metrics(
+            sample_latencies,
+            total_elapsed_time,
+            self.concurrent_limit if self.concurrent_limit is not None else None,
+            num_total,
+            len(error_files)
+        )
+        
+        # Print error summary with categorization
+        if error_files:
+            print(f"\nErrors ({len(error_files)} files):")
+            error_by_type = {}
+            for error_file in error_files:
+                if error_file in error_details:
+                    error_type, error_msg = error_details[error_file]
+                    if error_type not in error_by_type:
+                        error_by_type[error_type] = []
+                    error_by_type[error_type].append((error_file, error_msg))
+                else:
+                    if ErrorType.UNKNOWN_ERROR not in error_by_type:
+                        error_by_type[ErrorType.UNKNOWN_ERROR] = []
+                    error_by_type[ErrorType.UNKNOWN_ERROR].append((error_file, "Unknown error"))
+            
+            for error_type, errors in error_by_type.items():
+                print(f"  {error_type.value.upper()} ({len(errors)} files):")
+                for error_file, error_msg in errors[:5]:  # Show first 5
+                    print(f"    - {error_file}: {error_msg}")
+                if len(errors) > 5:
+                    print(f"    ... and {len(errors) - 5} more")
+        
+        print("Finished processing all documents")
+        print("Results saved to: {}".format(self.save_path))
+        print("Interim results saved to: {}".format(self.interim_dir))
+        print("Number of errors: {}".format(len(error_files)))
+        print("Total processed files: {}".format(len(final_results)))
+        
+        return final_results
+    
+    async def infer_async(self, file_path, *args, **kwargs):
+        """Infer the layout of documents with concurrent processing.
+
+        This method orchestrates concurrent file processing using process_files_concurrently.
+        It can be overridden by subclasses if they need custom async behavior.
+
+        Args:
+            file_path (str): the path to the file or directory containing the documents to process
+            *args, **kwargs: Additional arguments to pass to process_single_file
+
+        Returns:
+            dict: Final processed results
+        """
+        paths = read_file_paths(file_path, supported_formats=self.formats)
+
+        # Apply sampling rate if less than 1.0
+        if self.sampling_rate < 1.0 and len(paths) > 0:
+            if self.random_seed is not None:
+                random.seed(self.random_seed)
+            sample_size = max(1, int(len(paths) * self.sampling_rate))
+            paths = random.sample(paths, sample_size)
+            print(f"Sampling {self.sampling_rate * 100:.1f}% of files: {len(paths)} out of {len(read_file_paths(file_path, supported_formats=self.formats))} total files")
+        
+        error_files = []
+        sample_latencies = []
+        total_start_time = time.time()
+        
+        # Process files concurrently
+        result_dict, error_files, sample_latencies, error_details = await process_files_concurrently(
+            paths,
+            self.process_single_file,
+            self.concurrent_limit,
+            self.processed_data,
+            *args,
+            **kwargs
+        )
+        
+        # Collect, post-process, and save results (same as sequential mode)
+        total_elapsed_time = time.time() - total_start_time
+        final_results = self._collect_and_save_results(
+            result_dict, sample_latencies, total_elapsed_time, error_files, error_details
+        )
+        
+        return final_results
+    
+    def infer(self, file_path, *args, **kwargs):
+        """Infer the layout of the documents in the given file path.
+        
+        This method dispatches to async mode if concurrent_limit is set,
+        otherwise runs sequential processing.
+        
+        Args:
+            file_path (str): the path to the file or directory containing the documents to process
+            *args, **kwargs: Additional arguments (passed to infer_async or process_file_sequential)
+            
+        Returns:
+            dict: Final processed results (or None for sequential mode without return)
+        """
+        # Use concurrent mode if concurrent_limit is set
+        if self.concurrent_limit is not None:
+            return asyncio.run(self.infer_async(file_path, *args, **kwargs))
+        
+        # Sequential mode - delegate to subclass implementation
+        return self._infer_sequential(file_path, *args, **kwargs)
+    
+    def _infer_sequential(self, file_path, *args, **kwargs):
+        """Internal method for sequential inference.
+
+        This template method can be overridden by subclasses for custom sequential behavior.
+        Default implementation processes files one by one using process_file_sequential.
+
+        Args:
+            file_path (str): the path to the file or directory containing the documents to process
+            *args, **kwargs: Additional arguments passed to process_file_sequential
+        """
+        paths = read_file_paths(file_path, supported_formats=self.formats)
+
+        # Apply sampling rate if less than 1.0
+        if self.sampling_rate < 1.0 and len(paths) > 0:
+            if self.random_seed is not None:
+                random.seed(self.random_seed)
+            sample_size = max(1, int(len(paths) * self.sampling_rate))
+            paths = random.sample(paths, sample_size)
+            print(f"Sampling {self.sampling_rate * 100:.1f}% of files: {len(paths)} out of {len(read_file_paths(file_path, supported_formats=self.formats))} total files")
+        
+        error_files = []
+        error_details = {}
+        sample_latencies = []
+        total_start_time = time.time()
+        
+        try:
+            for idx, filepath in enumerate(paths, 1):
+                filename = filepath.name
+                
+                # Check if interim result already exists
+                existing_result = load_interim_result(self.interim_dir, filename)
+                if existing_result is not None:
+                    print(f"'{filename}' interim result already exists. Skipping API call to save costs.")
+                    continue
+                
+                # Process the file
+                try:
+                    filename_result, result_data, latency = self.process_file_sequential(
+                        filepath, idx, len(paths), *args, **kwargs
+                    )
+                    
+                    if result_data is not None and latency > 0:
+                        sample_latencies.append(latency)
+                    elif latency == 0:
+                        error_files.append(filename)
+                except KeyboardInterrupt:
+                    raise  # Re-raise to be caught by outer handler
+                except Exception as e:
+                    error_type = categorize_error(e)
+                    error_details[filename] = (error_type, str(e))
+                    error_files.append(filename)
+                    continue
+        except KeyboardInterrupt:
+            print("\n⚠️  KeyboardInterrupt detected! Saving partial results...")
+            print(f"✓ Processed {len(sample_latencies)} files before interruption")
+        
+        # Collect, post-process, and save results (same as async mode)
+        total_elapsed_time = time.time() - total_start_time
+        
+        # Pass empty dict - _collect_and_save_results will collect all interim results
+        # All results from this run have already been saved to interim directory
+        raw_results = {}
+        
+        final_results = self._collect_and_save_results(
+            raw_results, sample_latencies, total_elapsed_time, error_files, error_details
+        )
+        
+        return final_results
+
+
+class HttpClientInference(BaseInference):
+    """Base class for HTTP-based API services (Upstage, LlamaParse).
+    
+    This class provides:
+    - Automatic httpx.AsyncClient management for async mode
+    - Common pattern for overriding infer_async with client context
+    
+    Subclasses should implement _call_api_async(filepath, client) and _call_api_sync(filepath).
+    """
+    
+    async def infer_async(self, file_path, *args, **kwargs):
+        """Infer the layout of documents with concurrent processing.
+        
+        Creates an httpx.AsyncClient and passes it to the parent's infer_async.
+        
+        Args:
+            file_path (str): the path to the file or directory containing the documents to process
+            
+        Returns:
+            dict: Final processed results
+        """
+        import httpx
+        async with httpx.AsyncClient() as client:
+            return await super().infer_async(file_path, client=client, *args, **kwargs)

scripts/doc_grouping.py

@@ -0,0 +1,210 @@
+"""
+Utility functions for grouping per-page results into document-level results.
+
+This module provides common functionality for:
+- Extracting page numbers from image filenames
+- Converting page-level keys to document-level keys
+- Grouping page-level elements into document-level structure
+
+Usage:
+    from doc_grouping import group_pages_to_documents
+
+    # Group page-level results into document-level
+    doc_results = group_pages_to_documents(
+        page_results,
+        file_ext_mapping={"jpg": "pdf"},
+    )
+"""
+
+import re
+from typing import Dict, List, Optional, Tuple
+
+
+def extract_page_number(image_key: str) -> int:
+    """
+    Extract page number from image key.
+
+    Supports formats like:
+    - 'document_page0001.jpg' -> 1
+    - 'document_page0042.pdf' -> 42
+
+    Args:
+        image_key: Image filename with page suffix
+
+    Returns:
+        Page number (1-based), or 1 if no page number found
+    """
+    match = re.search(r"_page(\d{4})\.", image_key)
+    if match:
+        return int(match.group(1))
+    return 1
+
+
+def to_doc_key(image_key: str) -> str:
+    """
+    Convert page image key to document key by removing the page suffix.
+
+    Example:
+        'mt_2020-06-25T04-07-00Z_s100j0q8_39-43_page0001.jpg'
+        -> 'mt_2020-06-25T04-07-00Z_s100j0q8_39-43.jpg'
+
+    Args:
+        image_key: Page-level image filename
+
+    Returns:
+        Document-level filename (without page suffix)
+    """
+    return re.sub(r"_page\d{4}(?=\.)", "", image_key)
+
+
+def replace_ext(filename: str, file_ext_mapping: Dict[str, str]) -> str:
+    """
+    Replace file extension according to mapping.
+
+    Args:
+        filename: Original filename
+        file_ext_mapping: Dict mapping source extensions to destination extensions
+                         e.g., {"jpg": "pdf", "jpeg": "pdf"}
+
+    Returns:
+        Filename with replaced extension
+    """
+    if not file_ext_mapping:
+        return filename
+    src_ext = filename.split(".")[-1]
+    dst_ext = file_ext_mapping.get(src_ext, src_ext)
+    return filename[: -(len(src_ext))] + dst_ext
+
+
+def parse_ext_mapping(mapping_str: str) -> Dict[str, str]:
+    """
+    Parse file extension mapping from CLI string format.
+
+    Supports two formats:
+    - Colon format: "jpg:pdf" (single mapping)
+    - Arrow format: "jpg->pdf,jpeg->pdf" (multiple mappings)
+
+    Args:
+        mapping_str: String in format "src:dst" or "src1->dst1,src2->dst2"
+
+    Returns:
+        Dict mapping source extensions to destination extensions
+
+    Raises:
+        ValueError: If mapping format is invalid
+    """
+    file_ext_mapping = {}
+    if not mapping_str:
+        return file_ext_mapping
+
+    # Try colon format first (single mapping)
+    if ":" in mapping_str and "->" not in mapping_str:
+        parts = mapping_str.split(":")
+        if len(parts) == 2:
+            src, dst = parts[0].strip(), parts[1].strip()
+            if src and dst:
+                return {src: dst}
+
+    # Try arrow format (multiple mappings)
+    for pair in mapping_str.split(","):
+        pair = pair.strip()
+        if "->" in pair:
+            src, dst = pair.split("->", 1)
+            src = src.strip()
+            dst = dst.strip()
+            if src and dst:
+                file_ext_mapping[src] = dst
+        elif ":" in pair:
+            src, dst = pair.split(":", 1)
+            src = src.strip()
+            dst = dst.strip()
+            if src and dst:
+                file_ext_mapping[src] = dst
+
+    if not file_ext_mapping and mapping_str:
+        raise ValueError(
+            f"Invalid mapping format: '{mapping_str}'. "
+            "Use 'src:dst' or 'src1->dst1,src2->dst2' format."
+        )
+
+    return file_ext_mapping
+
+
+def group_pages_to_documents(
+    page_data: Dict[str, Dict],
+    file_ext_mapping: Optional[Dict[str, str]] = None,
+    elements_key: str = "elements",
+    include_merged_tables: bool = True,
+) -> Dict[str, Dict]:
+    """
+    Group page-level results into document-level results.
+
+    Takes a dictionary of page-level results (keyed by page image filename)
+    and aggregates them into document-level results.
+
+    Args:
+        page_data: Dict mapping page filenames to their data.
+                   Each page data should have an 'elements' list.
+                   Example: {"doc_page0001.jpg": {"elements": [...]}, ...}
+        file_ext_mapping: Optional dict mapping source extensions to destination.
+                         e.g., {"jpg": "pdf"} to output "doc.pdf" instead of "doc.jpg"
+        elements_key: Key name for the elements list in each page (default: "elements")
+        include_merged_tables: Whether to include empty "merged_tables" list (default: True)
+
+    Returns:
+        Dict mapping document filenames to aggregated data.
+        Example: {"doc.pdf": {"elements": [...], "merged_tables": []}}
+    """
+    if file_ext_mapping is None:
+        file_ext_mapping = {}
+
+    result: Dict[str, Dict] = {}
+    id_counters: Dict[str, int] = {}
+
+    for page_key, page_content in page_data.items():
+        # Get document key and page number
+        doc_key_raw = to_doc_key(page_key)
+        doc_key = replace_ext(doc_key_raw, file_ext_mapping)
+        page_number = extract_page_number(page_key)
+
+        # Initialize document entry if not exists
+        if doc_key not in result:
+            result[doc_key] = {elements_key: []}
+            if include_merged_tables:
+                result[doc_key]["merged_tables"] = []
+            id_counters[doc_key] = 0
+
+        # Get elements from page data
+        elements = page_content.get(elements_key, [])
+
+        # Add each element with updated id and page number
+        for elem in elements:
+            # Create a copy to avoid modifying original
+            new_elem = elem.copy()
+            if "content" in elem:
+                new_elem["content"] = elem["content"].copy()
+
+            new_elem["id"] = id_counters[doc_key]
+            new_elem["page"] = page_number
+
+            result[doc_key][elements_key].append(new_elem)
+            id_counters[doc_key] += 1
+
+    return result
+
+
+def is_multi_page_dataset(page_keys: List[str]) -> bool:
+    """
+    Check if the dataset contains multi-page documents.
+
+    Looks for page suffixes like '_page0001' in the filenames.
+
+    Args:
+        page_keys: List of page-level filenames
+
+    Returns:
+        True if any filename has a page suffix
+    """
+    page_pattern = re.compile(r"_page\d{4}\.")
+    return any(page_pattern.search(key) for key in page_keys)
+

scripts/infer_aws.py

@@ -1,11 +1,14 @@
+"""
+AWS Textract document layout inference.
+
+Uses AWS Textract API for document analysis.
+"""
+import asyncio
 import os
-import cv2
-import json
-import time
+
 import boto3
-import argparse
 
-from utils import read_file_paths, validate_json_save_path, load_json_file
+from base import BaseInference, create_argument_parser, parse_args_with_extra
 
 CATEGORY_MAP = {
     "LAYOUT_TEXT": "paragraph",
@@ -21,17 +24,43 @@ CATEGORY_MAP = {
 }
 
 
-class AWSInference:
+class AWSInference(BaseInference):
+    """AWS Textract document layout inference."""
+    
     def __init__(
         self,
         save_path,
-        input_formats=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"]
+        input_formats=None,
+        concurrent_limit=None,
+        sampling_rate=1.0,
+        request_timeout=600,
+        random_seed=None,
+        group_by_document=False,
+        file_ext_mapping=None
     ):
-        """Initialize the AWSInference class
+        """Initialize the AWSInference class.
+
         Args:
             save_path (str): the json path to save the results
             input_formats (list, optional): the supported file formats.
+            concurrent_limit (int, optional): maximum number of concurrent API requests
+            sampling_rate (float, optional): fraction of files to process (0.0-1.0)
+            request_timeout (float, optional): timeout in seconds for API requests
+            random_seed (int, optional): random seed for reproducible sampling
+            group_by_document (bool, optional): group per-page results into document-level
+            file_ext_mapping (str or dict, optional): file extension mapping for grouping
         """
+        super().__init__(
+            save_path,
+            input_formats,
+            concurrent_limit,
+            sampling_rate,
+            request_timeout,
+            random_seed,
+            group_by_document,
+            file_ext_mapping
+        )
+
         AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID") or ""
         AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY") or ""
         AWS_REGION = os.getenv("AWS_REGION") or ""
@@ -47,40 +76,54 @@ class AWSInference:
             aws_secret_access_key=AWS_SECRET_ACCESS_KEY
         )
 
-        self.s3 = boto3.resource("s3")
+        self.s3 = boto3.resource(
+            "s3",
+            region_name=AWS_REGION,
+            aws_access_key_id=AWS_ACCESS_KEY_ID,
+            aws_secret_access_key=AWS_SECRET_ACCESS_KEY
+        )
         self.s3_bucket_name = AWS_S3_BUCKET_NAME
 
-        validate_json_save_path(save_path)
-        self.save_path = save_path
-        self.processed_data = load_json_file(save_path)
-
-        self.formats = input_formats
+    def _get_text(self, result, blocks_map):
+        """Extract text from a block using its relationships."""
+        text = ""
+        if "Relationships" in result:
+            for relationship in result["Relationships"]:
+                if relationship["Type"] == "CHILD":
+                    for child_id in relationship["Ids"]:
+                        word = blocks_map[child_id]
+                        if word["BlockType"] == "WORD":
+                            text += " " + word["Text"]
+        return text[1:] if text else ""
 
     def post_process(self, data):
-        def get_text(result, blocks_map):
-            text = ""
-            if "Relationships" in result:
-                for relationship in result["Relationships"]:
-                    if relationship["Type"] == "CHILD":
-                        for child_id in relationship["Ids"]:
-                            word = blocks_map[child_id]
-                            if word["BlockType"] == "WORD":
-                                text += " " + word["Text"]
-            return text[1:]
-
+        """Post-process AWS Textract API response to standard format."""
         processed_dict = {}
         for input_key in data.keys():
             output_data = data[input_key]
-
-            processed_dict[input_key] = {
-                "elements": []
-            }
+            
+            # Normalize output_data to always be a list of pages
+            if isinstance(output_data, dict) and "Blocks" in output_data:
+                output_data = [output_data]
+            
+            # Handle time_sec if present
+            time_sec = None
+            if isinstance(output_data, dict) and "time_sec" in output_data:
+                time_sec = output_data["time_sec"]
+                if "Blocks" in output_data:
+                    output_data = [output_data]
+                elif isinstance(output_data.get("data"), list):
+                    output_data = output_data["data"]
+
+            processed_dict[input_key] = {"elements": []}
+            
+            if time_sec is not None:
+                processed_dict[input_key]["time_sec"] = time_sec
 
             all_elems = {}
             for page_data in output_data:
                 for elem in page_data["Blocks"]:
-                    _id = elem["Id"]
-                    all_elems[_id] = elem
+                    all_elems[elem["Id"]] = elem
 
             for page_data in output_data:
                 for idx, elem in enumerate(page_data["Blocks"]):
@@ -88,114 +131,86 @@ class AWSInference:
                         continue
 
                     if "LAYOUT" in elem["BlockType"] and elem["BlockType"] != "LAYOUT_TABLE":
-
                         bbox = elem["Geometry"]["BoundingBox"]
+                        x, y, w, h = bbox["Left"], bbox["Top"], bbox["Width"], bbox["Height"]
 
-                        x = bbox["Left"]
-                        y = bbox["Top"]
-                        w = bbox["Width"]
-                        h = bbox["Height"]
-
-                        coord = [
-                            [x, y],
-                            [x + w, y],
-                            [x + w, y + h],
-                            [x, y + h]
-                        ]
+                        coord = [[x, y], [x + w, y], [x + w, y + h], [x, y + h]]
                         xy_coord = [{"x": x, "y": y} for x, y in coord]
-
                         category = CATEGORY_MAP.get(elem["BlockType"], "paragraph")
 
                         transcription = ""
-
-                        if elem["BlockType"] != "LAYOUT_FIGURE":
-                            for item in all_elems[elem["Id"]]["Relationships"]:
+                        if elem["BlockType"] not in ["LAYOUT_FIGURE", "LAYOUT_KEY_VALUE"]:
+                            for item in all_elems[elem["Id"]].get("Relationships", []):
                                 for id_ in item["Ids"]:
                                     if all_elems[id_]["BlockType"] == "LINE":
-                                        word = all_elems[id_]["Text"]
-                                        transcription += word + "\n"
+                                        transcription += all_elems[id_]["Text"] + "\n"
 
                         data_dict = {
                             "coordinates": xy_coord,
                             "category": category,
                             "id": idx,
-                            "content": {
-                                "text": transcription,
-                                "html": "",
-                                "markdown": ""
-                            }
+                            "content": {"text": transcription, "html": "", "markdown": ""}
                         }
                         processed_dict[input_key]["elements"].append(data_dict)
 
                     elif elem["BlockType"] == "TABLE":
-
                         bbox = elem["Geometry"]["BoundingBox"]
+                        x, y, w, h = bbox["Left"], bbox["Top"], bbox["Width"], bbox["Height"]
 
-                        x = bbox["Left"]
-                        y = bbox["Top"]
-                        w = bbox["Width"]
-                        h = bbox["Height"]
-
-                        coord = [
-                            [x, y],
-                            [x + w, y],
-                            [x + w, y + h],
-                            [x, y + h]
-                        ]
+                        coord = [[x, y], [x + w, y], [x + w, y + h], [x, y + h]]
                         xy_coord = [{"x": x, "y": y} for x, y in coord]
-
                         category = CATEGORY_MAP.get(elem["BlockType"], "paragraph")
 
                         table_cells = {}
                         for relationship in elem["Relationships"]:
                             if relationship["Type"] == "CHILD":
                                 for cell_id in relationship["Ids"]:
-                                    cell_block = next((block for block in page_data["Blocks"] if block["Id"] == cell_id), None)
-                                    if cell_block is not None and cell_block["BlockType"] == "CELL":
+                                    cell_block = next((b for b in page_data["Blocks"] if b["Id"] == cell_id), None)
+                                    if cell_block and cell_block["BlockType"] == "CELL":
                                         row_index = cell_block["RowIndex"] - 1
                                         column_index = cell_block["ColumnIndex"] - 1
-                                        row_span = cell_block["RowSpan"]
-                                        column_span = cell_block["ColumnSpan"]
                                         table_cells[(row_index, column_index)] = {
                                             "block": cell_block,
-                                            "span": (row_span, column_span),
-                                            "text": get_text(cell_block, all_elems),
+                                            "span": (cell_block["RowSpan"], cell_block["ColumnSpan"]),
+                                            "text": self._get_text(cell_block, all_elems),
                                         }
-                        max_row_index = max(cell[0] for cell in table_cells.keys())
-                        max_column_index = max(cell[1] for cell in table_cells.keys())
+                        
+                        if not table_cells:
+                            continue
+                        
+                        max_row = max(c[0] for c in table_cells.keys())
+                        max_col = max(c[1] for c in table_cells.keys())
+                        
                         for relationship in elem["Relationships"]:
                             if relationship["Type"] == "MERGED_CELL":
                                 for cell_id in relationship["Ids"]:
-                                    cell_block = next((block for block in page_data["Blocks"] if block["Id"] == cell_id), None)
-                                    if cell_block is not None and cell_block["BlockType"] == "MERGED_CELL":
+                                    cell_block = next((b for b in page_data["Blocks"] if b["Id"] == cell_id), None)
+                                    if cell_block and cell_block["BlockType"] == "MERGED_CELL":
                                         row_index = cell_block["RowIndex"] - 1
                                         column_index = cell_block["ColumnIndex"] - 1
                                         row_span = cell_block["RowSpan"]
                                         column_span = cell_block["ColumnSpan"]
                                         for i in range(row_span):
                                             for j in range(column_span):
-                                                del table_cells[(row_index + i, column_index + j)]
+                                                table_cells.pop((row_index + i, column_index + j), None)
                                         text = ""
-                                        for child_ids in cell_block["Relationships"][0]["Ids"]:
-                                            child_cell_block = next((block for block in page_data["Blocks"] if block["Id"] == child_ids), None)
-                                            text += " " + get_text(child_cell_block, all_elems)
+                                        for child_ids in cell_block.get("Relationships", [{}])[0].get("Ids", []):
+                                            child_cell = next((b for b in page_data["Blocks"] if b["Id"] == child_ids), None)
+                                            text += " " + self._get_text(child_cell, all_elems) if child_cell else ""
                                         table_cells[(row_index, column_index)] = {
                                             "block": cell_block,
                                             "span": (row_span, column_span),
-                                            "text": text[1:],
+                                            "text": text[1:] if text else "",
                                         }
+                        
                         html_table = "<table>"
-
-                        for row_index in range(max_row_index + 1):
+                        for row_index in range(max_row + 1):
                             html_table += "<tr>"
-                            for column_index in range(max_column_index + 1):
+                            for column_index in range(max_col + 1):
                                 cell_data = table_cells.get((row_index, column_index))
                                 if cell_data:
-                                    cell_block = cell_data["block"]
                                     row_span, column_span = cell_data["span"]
-
-                                    cell_text = cell_data["text"]
-                                    html_table += f"<td rowspan='{row_span}' colspan='{column_span}''>{cell_text}</td>"
+                                    html_table += f"<td rowspan='{row_span}' colspan='{column_span}'>{cell_data['text']}</td>"
                             html_table += "</tr>"
                         html_table += "</table>"
 
@@ -203,152 +218,124 @@ class AWSInference:
                             "coordinates": xy_coord,
                             "category": category,
                             "id": idx,
-                            "content": {
-                                "text": "",
-                                "html": html_table,
-                                "markdown": ""
-                            }
+                            "content": {"text": "", "html": html_table, "markdown": ""}
                         }
                         processed_dict[input_key]["elements"].append(data_dict)
 
-        for key in self.processed_data:
-            processed_dict[key] = self.processed_data[key]
-
-        return processed_dict
-
+        return self._merge_processed_data(processed_dict)
 
-    def start_job(self, object_name):
+    def _start_job(self, object_name):
+        """Start a Textract job for PDF processing."""
+        import time
         filename_with_ext = os.path.basename(object_name)
-
         print(f"uploading {filename_with_ext} to s3")
         self.s3.Bucket(self.s3_bucket_name).upload_file(object_name, filename_with_ext)
 
-        response = None
         response = self.client.start_document_analysis(
             DocumentLocation={
-                "S3Object": {
-                    "Bucket": self.s3_bucket_name,
-                    "Name": filename_with_ext
-                }
+                "S3Object": {"Bucket": self.s3_bucket_name, "Name": filename_with_ext}
             },
-            FeatureTypes = ["LAYOUT", "TABLES"]
+            FeatureTypes=["LAYOUT", "TABLES"]
         )
-
         return response["JobId"]
 
-    def is_job_complete(self, job_id):
+    def _is_job_complete(self, job_id):
+        """Check if Textract job is complete."""
+        import time
         time.sleep(1)
         response = self.client.get_document_analysis(JobId=job_id)
         status = response["JobStatus"]
-        print("Job status: {}".format(status))
+        print(f"Job status: {status}")
 
-        while(status == "IN_PROGRESS"):
+        while status == "IN_PROGRESS":
             time.sleep(1)
             response = self.client.get_document_analysis(JobId=job_id)
             status = response["JobStatus"]
-            print("Job status: {}".format(status))
+            print(f"Job status: {status}")
 
         return status
 
-    def get_job_results(self, job_id):
+    def _get_job_results(self, job_id):
+        """Get all pages of Textract job results."""
+        import time
         pages = []
         time.sleep(1)
         response = self.client.get_document_analysis(JobId=job_id)
         pages.append(response)
-        print("Resultset page received: {}".format(len(pages)))
-        next_token = None
-        if "NextToken" in response:
-            next_token = response["NextToken"]
+        print(f"Resultset page received: {len(pages)}")
+        next_token = response.get("NextToken")
 
         while next_token:
             time.sleep(1)
-            response = self.client.\
-                get_document_analysis(JobId=job_id, NextToken=next_token)
+            response = self.client.get_document_analysis(JobId=job_id, NextToken=next_token)
             pages.append(response)
-            print("Resultset page received: {}".format(len(pages)))
-            next_token = None
-            if "NextToken" in response:
-                next_token = response["NextToken"]
+            print(f"Resultset page received: {len(pages)}")
+            next_token = response.get("NextToken")
 
         return pages
 
-    def infer(self, file_path):
-        """Infer the layout of the documents in the given file path
-        Args:
-            file_path (str): the path to the file or directory containing the documents to process
-        """
-        paths = read_file_paths(file_path, supported_formats=self.formats)
-
-        error_files = []
-
-        result_dict = {}
-        for idx, filepath in enumerate(paths):
-            print("({}/{}) {}".format(idx+1, len(paths), filepath))
-
-            filename = filepath.name
-            if filename in self.processed_data.keys():
-                print(f"'{filename}' is already in the loaded dictionary. Skipping this sample")
-                continue
-
-            try:
-                if os.path.splitext(filepath)[-1] == ".pdf":
-                    job_id = self.start_job(filepath)
-                    print("Started job with id: {}".format(job_id))
-                    if self.is_job_complete(job_id):
-                        result = self.get_job_results(job_id)
-                else:
-                    with open(filepath, "rb") as file:
-                        img_test = file.read()
-                        bytes_test = bytearray(img_test)
-
-                    result = self.client.analyze_document(
-                        Document={"Bytes": bytes_test},
-                        FeatureTypes = ["LAYOUT", "TABLES"]
-                    )
-            except Exception as e:
-                print(e)
-                print("Error processing document..")
-                error_files.append(filepath)
-                continue
-
-            result_dict[filename] = result
-
-        result_dict = self.post_process(result_dict)
-
-        with open(self.save_path, "w", encoding="utf-8") as f:
-            json.dump(result_dict, f, ensure_ascii=False, indent=4)
-
-        for error_file in error_files:
-            print(f"Error processing file: {error_file}")
-
-        print("Finished processing all documents")
-        print("Results saved to: {}".format(self.save_path))
-        print("Number of errors: {}".format(len(error_files)))
+    async def _call_api_async(self, filepath, *args, **kwargs):
+        """Make the actual async API call for a file."""
+        loop = asyncio.get_event_loop()
+        
+        if filepath.suffix.lower() == ".pdf":
+            job_id = await loop.run_in_executor(None, self._start_job, str(filepath))
+            print(f"Started job with id: {job_id}")
+            
+            status = await loop.run_in_executor(None, self._is_job_complete, job_id)
+            if status == "SUCCEEDED":
+                result = await loop.run_in_executor(None, self._get_job_results, job_id)
+            else:
+                raise Exception(f"Job {job_id} failed with status: {status}")
+        else:
+            with open(filepath, "rb") as file:
+                img_test = file.read()
+                bytes_test = bytearray(img_test)
+
+            result = await loop.run_in_executor(
+                None,
+                lambda: self.client.analyze_document(
+                    Document={"Bytes": bytes_test},
+                    FeatureTypes=["LAYOUT", "TABLES"]
+                )
+            )
+        
+        return result
+
+    def _call_api_sync(self, filepath, *args, **kwargs):
+        """Make the actual sync API call for a file."""
+        if filepath.suffix.lower() == ".pdf":
+            job_id = self._start_job(str(filepath))
+            print(f"Started job with id: {job_id}")
+            status = self._is_job_complete(job_id)
+            if status == "SUCCEEDED":
+                result = self._get_job_results(job_id)
+            else:
+                raise Exception(f"Job {job_id} failed with status: {status}")
+        else:
+            with open(filepath, "rb") as file:
+                bytes_test = bytearray(file.read())
+
+            result = self.client.analyze_document(
+                Document={"Bytes": bytes_test},
+                FeatureTypes=["LAYOUT", "TABLES"]
+            )
+        
+        return result
 
 
 if __name__ == "__main__":
-    args = argparse.ArgumentParser()
-    args.add_argument(
-        "--data_path",
-        type=str, default="", required=True,
-        help="Path containing the documents to process"
-    )
-    args.add_argument(
-        "--save_path",
-        type=str, default="", required=True,
-        help="Path to save the results"
-    )
-    args.add_argument(
-        "--input_formats",
-        type=list, default=[
-            ".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"
-        ],
-        help="Supported input file formats"
-    )
-    args = args.parse_args()
+    parser = create_argument_parser("AWS Textract document layout inference")
+    args = parse_args_with_extra(parser)
 
     aws_inference = AWSInference(
         args.save_path,
-        input_formats=args.input_formats
+        input_formats=args.input_formats,
+        concurrent_limit=args.concurrent,
+        sampling_rate=args.sampling_rate,
+        request_timeout=args.request_timeout,
+        random_seed=args.random_seed,
+        group_by_document=args.group_by_document,
+        file_ext_mapping=args.file_ext_mapping
     )
     aws_inference.infer(args.data_path)

scripts/infer_google.py

@@ -1,15 +1,20 @@
-import os
-import json
-import google
-import argparse
+"""
+Google Document AI layout inference.
 
-from glob import glob
-from typing import Optional, Sequence
+Uses Google Cloud Document AI for document analysis.
+"""
+import asyncio
+import io
+import json
+import os
+from typing import Optional
 
+import google
 from google.api_core.client_options import ClientOptions
 from google.cloud import documentai
+from PIL import Image
 
-from utils import read_file_paths, validate_json_save_path, load_json_file
+from base import BaseInference, create_argument_parser, parse_args_with_extra
 
 CATEGORY_MAP = {
     "paragraph": "paragraph",
@@ -23,17 +28,43 @@ CATEGORY_MAP = {
 }
 
 
-class GoogleInference:
+class GoogleInference(BaseInference):
+    """Google Document AI layout inference."""
+    
     def __init__(
         self,
         save_path,
-        input_formats=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"]
+        input_formats=None,
+        concurrent_limit=None,
+        sampling_rate=1.0,
+        request_timeout=600,
+        random_seed=None,
+        group_by_document=False,
+        file_ext_mapping=None
     ):
-        """Initialize the GoogleInference class
+        """Initialize the GoogleInference class.
+
         Args:
             save_path (str): the json path to save the results
             input_formats (list, optional): the supported file formats.
+            concurrent_limit (int, optional): maximum number of concurrent API requests
+            sampling_rate (float, optional): fraction of files to process (0.0-1.0)
+            request_timeout (float, optional): timeout in seconds for API requests
+            random_seed (int, optional): random seed for reproducible sampling
+            group_by_document (bool, optional): group per-page results into document-level
+            file_ext_mapping (str or dict, optional): file extension mapping for grouping
         """
+        super().__init__(
+            save_path,
+            input_formats,
+            concurrent_limit,
+            sampling_rate,
+            request_timeout,
+            random_seed,
+            group_by_document,
+            file_ext_mapping
+        )
+
         self.project_id = os.getenv("GOOGLE_PROJECT_ID") or ""
         self.processor_id = os.getenv("GOOGLE_PROCESSOR_ID") or ""
         self.location = os.getenv("GOOGLE_LOCATION") or ""
@@ -44,21 +75,37 @@ class GoogleInference:
 
         self.processor_version = "rc"
 
-        validate_json_save_path(save_path)
-        self.save_path = save_path
-        self.processed_data = load_json_file(save_path)
-
-        self.formats = input_formats
+    @staticmethod
+    def convert_image_to_pdf_bytes(image_path: str) -> bytes:
+        """Convert an image file to PDF bytes for Layout Parser compatibility.
+        
+        Args:
+            image_path: Path to the image file
+            
+        Returns:
+            PDF content as bytes
+        """
+        with Image.open(image_path) as img:
+            # Convert to RGB if necessary (e.g., for RGBA or P mode images)
+            if img.mode in ('RGBA', 'P', 'LA'):
+                img = img.convert('RGB')
+            
+            pdf_buffer = io.BytesIO()
+            img.save(pdf_buffer, format='PDF')
+            pdf_buffer.seek(0)
+            return pdf_buffer.read()
 
     @staticmethod
     def generate_html_table(table_data):
+        """Generate HTML table from table data."""
         html = "<table border='1'>\n"
 
-        # Process body rows
         for row in table_data["bodyRows"]:
             html += "  <tr>\n"
             for cell in row["cells"]:
-                text = cell["blocks"][0]["textBlock"]["text"] if cell["blocks"] else ""
+                text = ""
+                if cell["blocks"]:
+                    text = cell["blocks"][0].get("textBlock", {}).get("text", "")
                 row_span = f" rowspan='{cell['rowSpan']}'" if cell["rowSpan"] > 1 else ""
                 col_span = f" colspan='{cell['colSpan']}'" if cell["colSpan"] > 1 else ""
                 html += f"    <td{row_span}{col_span}>{text}</td>\n"
@@ -69,6 +116,7 @@ class GoogleInference:
 
     @staticmethod
     def iterate_blocks(data):
+        """Iterate through document blocks and extract content."""
         block_sequence = []
 
         def recurse_blocks(blocks):
@@ -78,17 +126,13 @@ class GoogleInference:
                 block_text = block.get("textBlock", {}).get("text", "")
 
                 if block_type:
-                    # Append block information as a tuple to the sequence list
                     block_sequence.append((block_id, block_type, block_text))
 
-                block_id = block.get("blockId", "")
                 block_table = block.get("tableBlock", {})
-
                 if block_table:
                     block_table_html = GoogleInference.generate_html_table(block_table)
                     block_sequence.append((block_id, "table", block_table_html))
 
-                # If the block contains sub-blocks, recurse through them
                 if block.get("textBlock", {}).get("blocks", []):
                     recurse_blocks(block["textBlock"]["blocks"])
 
@@ -98,14 +142,12 @@ class GoogleInference:
         return block_sequence
 
     def post_process(self, data):
-
+        """Post-process Google Document AI API response to standard format."""
         processed_dict = {}
         for input_key in data.keys():
             output_data = data[input_key]
 
-            processed_dict[input_key] = {
-                "elements": []
-            }
+            processed_dict[input_key] = {"elements": []}
 
             blocks = self.iterate_blocks(output_data)
 
@@ -114,7 +156,7 @@ class GoogleInference:
                 category = CATEGORY_MAP.get(category, "paragraph")
 
                 data_dict = {
-                    "coordinates": [[0, 0], [0, 0], [0, 0], [0, 0]],
+                    "coordinates": [{"x": 0, "y": 0}] * 4,
                     "category": category,
                     "id": id_counter,
                     "content": {
@@ -124,15 +166,12 @@ class GoogleInference:
                     }
                 }
                 processed_dict[input_key]["elements"].append(data_dict)
-
                 id_counter += 1
 
-        for key in self.processed_data:
-            processed_dict[key] = self.processed_data[key]
-
-        return processed_dict
+        return self._merge_processed_data(processed_dict)
 
-    def process_document_layout_sample(self, file_path, mime_type, chunk_size=1000) -> None:
+    def _process_document_layout_sample(self, file_path, mime_type, chunk_size=1000):
+        """Process document with layout analysis."""
         process_options = documentai.ProcessOptions(
             layout_config=documentai.ProcessOptions.LayoutConfig(
                 chunking_config=documentai.ProcessOptions.LayoutConfig.ChunkingConfig(
@@ -141,122 +180,83 @@ class GoogleInference:
                 )
             )
         )
-        document = self.process_document(
-            file_path,
-            mime_type,
-            process_options=process_options,
-        )
-
-        document_dict = json.loads(google.cloud.documentai_v1.Document.to_json(document))
+        document = self._process_document(file_path, mime_type, process_options=process_options)
+        return json.loads(google.cloud.documentai_v1.Document.to_json(document))
 
-        return document_dict
-
-    def process_document(
-        self, file_path,
+    def _process_document(
+        self,
+        file_path,
         mime_type: str,
         process_options: Optional[documentai.ProcessOptions] = None,
     ) -> documentai.Document:
+        """Process a single document."""
         client = documentai.DocumentProcessorServiceClient(
-            client_options=ClientOptions(
-                api_endpoint=f"{self.endpoint}"
-            )
+            client_options=ClientOptions(api_endpoint=self.endpoint)
         )
 
-        with open(file_path, "rb") as image:
-            image_content = image.read()
+        # Convert image to PDF for Layout Parser compatibility
+        image_mime_types = ["image/jpeg", "image/png", "image/bmp", "image/tiff", "image/heic"]
+        if mime_type in image_mime_types:
+            file_content = self.convert_image_to_pdf_bytes(file_path)
+            mime_type = "application/pdf"
+        else:
+            with open(file_path, "rb") as f:
+                file_content = f.read()
 
         name = client.processor_version_path(
-            self.project_id,
-            self.location,
-            self.processor_id,
-            self.processor_version
+            self.project_id, self.location, self.processor_id, self.processor_version
         )
         request = documentai.ProcessRequest(
             name=name,
-            raw_document=documentai.RawDocument(
-                content=image_content, mime_type=mime_type
-            ),
+            raw_document=documentai.RawDocument(content=file_content, mime_type=mime_type),
             process_options=process_options,
         )
 
         result = client.process_document(request=request)
-
         return result.document
 
-    def infer(self, file_path):
-        """Infer the layout of the documents in the given file path
-        Args:
-            file_path (str): the path to the file or directory containing the documents to process
-        """
-        paths = read_file_paths(file_path, supported_formats=self.formats)
-
-        error_files = []
-
-        result_dict = {}
-        for idx, filepath in enumerate(paths):
-            print("({}/{}) {}".format(idx+1, len(paths), filepath))
-
-            if filepath.suffix == ".pdf":
-                mime_type = "application/pdf"
-            elif filepath.suffix == ".jpg" or filepath.suffix == ".jpeg":
-                mime_type = "image/jpeg"
-            elif filepath.suffix == ".png":
-                mime_type = "image/png"
-            else:
-                raise NotImplementedError
-
-            filename = filepath.name
-
-            if filename in self.processed_data.keys():
-                print(f"'{filename}' is already in the loaded dictionary. Skipping this sample")
-                continue
-
-            try:
-                document_dict = self.process_document_layout_sample(filepath, mime_type)
-            except Exception as e:
-                print(e)
-                print("Error processing document..")
-                error_files.append(filepath)
-                continue
-
-            result_dict[filename] = document_dict
-
-        result_dict = self.post_process(result_dict)
-
-        with open(self.save_path, "w") as f:
-            json.dump(result_dict, f)
-
-        for error_file in error_files:
-            print(f"Error processing file: {error_file}")
+    def _get_mime_type(self, filepath):
+        """Get MIME type from file path."""
+        suffix = filepath.suffix.lower()
+        mime_types = {
+            ".pdf": "application/pdf",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".png": "image/png",
+            ".bmp": "image/bmp",
+            ".tiff": "image/tiff",
+            ".heic": "image/heic"
+        }
+        if suffix not in mime_types:
+            raise NotImplementedError(f"Unsupported file type: {suffix}")
+        return mime_types[suffix]
+
+    async def _call_api_async(self, filepath, *args, **kwargs):
+        """Make the actual async API call for a file."""
+        mime_type = self._get_mime_type(filepath)
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None, self._process_document_layout_sample, filepath, mime_type
+        )
 
-        print("Finished processing all documents")
-        print("Results saved to: {}".format(self.save_path))
-        print("Number of errors: {}".format(len(error_files)))
+    def _call_api_sync(self, filepath, *args, **kwargs):
+        """Make the actual sync API call for a file."""
+        mime_type = self._get_mime_type(filepath)
+        return self._process_document_layout_sample(filepath, mime_type)
 
 
 if __name__ == "__main__":
-    args = argparse.ArgumentParser()
-    args.add_argument(
-        "--data_path",
-        type=str, default="", required=True,
-        help="Path containing the documents to process"
-    )
-    args.add_argument(
-        "--save_path",
-        type=str, default="", required=True,
-        help="Path to save the results"
-    )
-    args.add_argument(
-        "--input_formats",
-        type=list, default=[
-            ".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"
-        ],
-        help="Supported input file formats"
-    )
-    args = args.parse_args()
+    parser = create_argument_parser("Google Document AI layout inference")
+    args = parse_args_with_extra(parser)
 
     google_inference = GoogleInference(
         args.save_path,
-        input_formats=args.input_formats
+        input_formats=args.input_formats,
+        concurrent_limit=args.concurrent,
+        sampling_rate=args.sampling_rate,
+        request_timeout=args.request_timeout,
+        random_seed=args.random_seed,
+        group_by_document=args.group_by_document,
+        file_ext_mapping=args.file_ext_mapping
     )
     google_inference.infer(args.data_path)

scripts/infer_llamaparse.py

@@ -1,14 +1,16 @@
+"""
+LlamaParse document layout inference.
+
+Uses LlamaParse's Document Parse API.
+"""
+import asyncio
 import os
 import time
-import json
+
 import markdown
 import requests
-import argparse
-from pathlib import Path
-
-from bs4 import BeautifulSoup
-from utils import read_file_paths, validate_json_save_path, load_json_file
 
+from base import HttpClientInference, create_argument_parser, parse_args_with_extra
 
 CATEGORY_MAP = {
     "text": "paragraph",
@@ -17,36 +19,83 @@ CATEGORY_MAP = {
 }
 
 
-class LlamaParseInference:
+class LlamaParseInference(HttpClientInference):
+    """LlamaParse document layout inference."""
+    
     def __init__(
         self,
         save_path,
-        input_formats=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"]
+        input_formats=None,
+        mode="cost-effective",
+        concurrent_limit=None,
+        sampling_rate=1.0,
+        request_timeout=600,
+        random_seed=None,
+        group_by_document=False,
+        file_ext_mapping=None
     ):
-        """Initialize the LlamaParseInference class
+        """Initialize the LlamaParseInference class.
+
         Args:
             save_path (str): the json path to save the results
             input_formats (list, optional): the supported file formats.
+            mode (str, optional): parsing mode - 'cost-effective', 'agentic', or 'agentic-plus'
+            concurrent_limit (int, optional): maximum number of concurrent API requests
+            sampling_rate (float, optional): fraction of files to process (0.0-1.0)
+            request_timeout (float, optional): timeout in seconds for API requests
+            random_seed (int, optional): random seed for reproducible sampling
+            group_by_document (bool, optional): group per-page results into document-level
+            file_ext_mapping (str or dict, optional): file extension mapping for grouping
         """
-        self.formats = input_formats
-
+        super().__init__(
+            save_path,
+            input_formats,
+            concurrent_limit,
+            sampling_rate,
+            request_timeout,
+            random_seed,
+            group_by_document,
+            file_ext_mapping
+        )
+        
+        self.mode = mode
         self.api_key = os.getenv("LLAMAPARSE_API_KEY") or ""
-        self.post_url = os.getenv("LLAMAPARSE_POST_URL") or ""
-        self.get_url = os.getenv("LLAMAPARSE_GET_URL") or ""
+        self.post_url = os.getenv("LLAMAPARSE_POST_URL") or "https://api.cloud.llamaindex.ai/api/v1/parsing/upload"
+        self.get_url = os.getenv("LLAMAPARSE_GET_URL") or "https://api.cloud.llamaindex.ai/api/v1/parsing/job"
 
         if not all([self.api_key, self.post_url, self.get_url]):
             raise ValueError("Please set the environment variables for LlamaParse")
 
         self.headers = {
-              "Accept": "application/json",
-              "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
         }
 
-        validate_json_save_path(save_path)
-        self.save_path = save_path
-        self.processed_data = load_json_file(save_path)
+    def _get_parse_data(self):
+        """Get parse data configuration based on mode."""
+        data = {
+            "invalidate_cache": True,
+            "high_res_ocr": True,
+            "adaptive_long_table": True,
+            "outlined_table_extraction": True,
+            "output_tables_as_HTML": True,
+        }
+        
+        if self.mode == "cost-effective":
+            data["parse_mode"] = "parse_page_with_llm"
+        elif self.mode == "agentic":
+            data["parse_mode"] = "parse_page_with_agent"
+            data["model"] = "openai-gpt-4-1-mini"
+        elif self.mode == "agentic-plus":
+            data["parse_mode"] = "parse_page_with_agent"
+            data["model"] = "anthropic-sonnet-4.0"
+        else:
+            raise ValueError(f"Unknown mode: {self.mode}. Choose from 'cost-effective', 'agentic', or 'agentic-plus'")
+        
+        return data
 
     def post_process(self, data):
+        """Post-process LlamaParse API response to standard format."""
         processed_dict = {}
         for input_key in data.keys():
             output_data = data[input_key]
@@ -58,9 +107,9 @@ class LlamaParseInference:
             id_counter = 0
             for elem in output_data["pages"]:
                 for item in elem["items"]:
-
                     coord = [[0, 0], [0, 0], [0, 0], [0, 0]]
                     category = item["type"]
+                    
                     if category == "table":
                         transcription = markdown.markdown(
                             item["md"],
@@ -70,8 +119,7 @@ class LlamaParseInference:
                     else:
                         transcription = item["value"]
                         pts = item["bBox"]
-                        if "x" in pts and "y" in pts and \
-                                "w" in pts and "h" in pts:
+                        if "x" in pts and "y" in pts and "w" in pts and "h" in pts:
                             coord = [
                                 [pts["x"], pts["y"]],
                                 [pts["x"] + pts["w"], pts["y"]],
@@ -80,8 +128,8 @@ class LlamaParseInference:
                             ]
 
                     xy_coord = [{"x": x, "y": y} for x, y in coord]
-
                     category = CATEGORY_MAP.get(category, "paragraph")
+                    
                     data_dict = {
                         "coordinates": xy_coord,
                         "category": category,
@@ -93,107 +141,112 @@ class LlamaParseInference:
                         }
                     }
                     processed_dict[input_key]["elements"].append(data_dict)
-
                     id_counter += 1
 
-        for key in self.processed_data:
-            processed_dict[key] = self.processed_data[key]
-
-        return processed_dict
-
-    def infer(self, file_path):
-        """Infer the layout of the documents in the given file path
-        Args:
-            file_path (str): the path to the file or directory containing the documents to process
-        """
-        paths = read_file_paths(file_path, supported_formats=self.formats)
-
-        error_files = []
-
-        result_dict = {}
-        for filepath in paths:
-            print("({}/{}) Processing {}".format(paths.index(filepath) + 1, len(paths), filepath))
-
-            filename = filepath.name
-            if filename in self.processed_data.keys():
-                print(f"'{filename}' is already in the loaded dictionary. Skipping this sample")
-                continue
-
-            try:
-                with open(filepath, "rb") as file_data:
-                    file_data = {
-                        "file": ("dummy.pdf", file_data, "")
-                    }
-                    data = {
-                        "invalidate_cache": True,
-                        "premium_mode": True,
-                        "disable_ocr": False
-                    }
-                    response = requests.post(
-                        self.post_url, headers=self.headers, files=file_data, data=data
-                    )
-
+        return self._merge_processed_data(processed_dict)
+
+    async def _call_api_async(self, filepath, client=None):
+        """Make the actual async API call for a file."""
+        filename = filepath.name
+        
+        with open(filepath, "rb") as file_data:
+            files = {"file": ("dummy.pdf", file_data, "")}
+            data = self._get_parse_data()
+            
+            response = await client.post(
+                self.post_url, 
+                headers=self.headers, 
+                files=files, 
+                data=data,
+                timeout=60.0
+            )
+
+        result_data = response.json()
+        
+        if "status" not in result_data:
+            raise Exception(f"Missing 'status' key in response: {result_data}")
+        
+        status = result_data["status"]
+        id_ = result_data["id"]
+
+        # Poll for completion
+        while status == "PENDING":
+            get_url = f"{self.get_url}/{id_}"
+            response = await client.get(get_url, headers=self.headers, timeout=30.0)
+
+            response_json = response.json()
+            status = response_json.get("status", "UNKNOWN")
+            
+            if status == "SUCCESS":
+                get_url = f"{self.get_url}/{id_}/result/json"
+                response = await client.get(get_url, headers=self.headers, timeout=30.0)
                 result_data = response.json()
-                status = result_data["status"]
-                id_ = result_data["id"]
-
-                while status == "PENDING":
-                    get_url = f"{self.get_url}/{id_}"
-                    response = requests.get(get_url, headers=self.headers)
-
-                    response_json = response.json()
-                    status = response_json["status"]
-                    if status == "SUCCESS":
-                        get_url = f"{self.get_url}/{id_}/result/json"
-                        response = requests.get(get_url, headers=self.headers)
-                        break
-
-                    time.sleep(1)
-
-                result_dict[filename] = response.json()
-            except Exception as e:
-                print(e)
-                print("Error processing document..")
-                error_files.append(filepath)
-                continue
-
-        result_dict = self.post_process(result_dict)
-
-        with open(self.save_path, "w") as f:
-            json.dump(result_dict, f)
-
-        for error_file in error_files:
-            print(f"Error processing file: {error_file}")
-
-        print("Finished processing all documents")
-        print("Results saved to: {}".format(self.save_path))
-        print("Number of errors: {}".format(len(error_files)))
+                break
+            
+            await asyncio.sleep(1)
+        
+        if status != "SUCCESS":
+            raise Exception(f"{filename}: {result_data}")
+        
+        return result_data
+
+    def _call_api_sync(self, filepath):
+        """Make the actual sync API call for a file."""
+        filename = filepath.name
+        
+        with open(filepath, "rb") as file_data:
+            files = {"file": ("dummy.pdf", file_data, "")}
+            data = self._get_parse_data()
+            
+            response = requests.post(
+                self.post_url, headers=self.headers, files=files, data=data
+            )
+
+        result = response.json()
+        
+        if "status" not in result:
+            raise Exception(f"Missing 'status' key in response: {result}")
+        
+        status = result["status"]
+        id_ = result["id"]
+
+        while status == "PENDING":
+            get_url = f"{self.get_url}/{id_}"
+            response = requests.get(get_url, headers=self.headers)
+
+            result = response.json()
+            status = result.get("status", "UNKNOWN")
+            time.sleep(1)
+
+        if status == "SUCCESS":
+            get_url = f"{self.get_url}/{id_}/result/json"
+            response = requests.get(get_url, headers=self.headers)
+            result = response.json()
+        else:
+            raise Exception(f"{filename}: {result}")
+        
+        return result
 
 
 if __name__ == "__main__":
-    args = argparse.ArgumentParser()
-    args.add_argument(
-        "--data_path",
-        type=str, default="", required=True,
-        help="Path containing the documents to process"
-    )
-    args.add_argument(
-        "--save_path",
-        type=str, default="", required=True,
-        help="Path to save the results"
-    )
-    args.add_argument(
-        "--input_formats",
-        type=list, default=[
-            ".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"
-        ],
-        help="Supported input file formats"
-    )
-    args = args.parse_args()
+    parser = create_argument_parser("LlamaParse document layout inference")
+    # Override --mode with LlamaParse-specific choices
+    for action in parser._actions:
+        if action.dest == 'mode':
+            action.choices = ["cost-effective", "agentic", "agentic-plus"]
+            action.help = "Parsing mode: 'cost-effective' (default), 'agentic', or 'agentic-plus'"
+            break
+    args = parse_args_with_extra(parser)
 
     llamaparse_inference = LlamaParseInference(
-        args.save_path,
-        input_formats=args.input_formats
+        save_path=args.save_path,
+        input_formats=args.input_formats,
+        mode=args.mode or "cost-effective",
+        concurrent_limit=args.concurrent,
+        sampling_rate=args.sampling_rate,
+        request_timeout=args.request_timeout,
+        random_seed=args.random_seed,
+        group_by_document=args.group_by_document,
+        file_ext_mapping=args.file_ext_mapping
     )
     llamaparse_inference.infer(args.data_path)
-

scripts/infer_microsoft.py

@@ -1,12 +1,15 @@
+"""
+Microsoft Azure Document Intelligence layout inference.
+
+Uses Azure Document Intelligence (Form Recognizer) API for document analysis.
+"""
+import asyncio
 import os
-import json
-import argparse
 
 from azure.ai.formrecognizer import DocumentAnalysisClient
 from azure.core.credentials import AzureKeyCredential
 
-from utils import read_file_paths, validate_json_save_path, load_json_file
-
+from base import BaseInference, create_argument_parser, parse_args_with_extra
 
 CATEGORY_MAP = {
     "Title": "heading1",
@@ -21,17 +24,43 @@ CATEGORY_MAP = {
 }
 
 
-class MicrosoftInference:
+class MicrosoftInference(BaseInference):
+    """Microsoft Azure Document Intelligence layout inference."""
+    
     def __init__(
         self,
         save_path,
-        input_formats=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"]
+        input_formats=None,
+        concurrent_limit=None,
+        sampling_rate=1.0,
+        request_timeout=600,
+        random_seed=None,
+        group_by_document=False,
+        file_ext_mapping=None
     ):
-        """Initialize the MicrosoftInference class
+        """Initialize the MicrosoftInference class.
+
         Args:
             save_path (str): the json path to save the results
             input_formats (list, optional): the supported file formats.
+            concurrent_limit (int, optional): maximum number of concurrent API requests
+            sampling_rate (float, optional): fraction of files to process (0.0-1.0)
+            request_timeout (float, optional): timeout in seconds for API requests
+            random_seed (int, optional): random seed for reproducible sampling
+            group_by_document (bool, optional): group per-page results into document-level
+            file_ext_mapping (str or dict, optional): file extension mapping for grouping
         """
+        super().__init__(
+            save_path,
+            input_formats,
+            concurrent_limit,
+            sampling_rate,
+            request_timeout,
+            random_seed,
+            group_by_document,
+            file_ext_mapping
+        )
+
         MICROSOFT_API_KEY = os.getenv("MICROSOFT_API_KEY") or ""
         MICROSOFT_ENDPOINT = os.getenv("MICROSOFT_ENDPOINT") or ""
 
@@ -39,29 +68,21 @@ class MicrosoftInference:
             raise ValueError("Please set the environment variables for Microsoft")
 
         self.document_analysis_client = DocumentAnalysisClient(
-            endpoint=MICROSOFT_ENDPOINT, credential=AzureKeyCredential(MICROSOFT_API_KEY)
+            endpoint=MICROSOFT_ENDPOINT,
+            credential=AzureKeyCredential(MICROSOFT_API_KEY)
         )
 
-        validate_json_save_path(save_path)
-        self.save_path = save_path
-        self.processed_data = load_json_file(save_path)
-
-        self.formats = input_formats
-
     def post_process(self, data):
+        """Post-process Microsoft Document Intelligence API response to standard format."""
         processed_dict = {}
         for input_key in data.keys():
             output_data = data[input_key]
 
-            processed_dict[input_key] = {
-                "elements": []
-            }
+            processed_dict[input_key] = {"elements": []}
 
             id_counter = 0
             for par_elem in output_data["paragraphs"]:
-                category = par_elem["role"]
-                category = CATEGORY_MAP.get(category, "paragraph")
-
+                category = CATEGORY_MAP.get(par_elem["role"], "paragraph")
                 transcription = par_elem["content"]
                 coord = [[pt["x"], pt["y"]] for pt in par_elem["bounding_regions"][0]["polygon"]]
                 xy_coord = [{"x": x, "y": y} for x, y in coord]
@@ -70,14 +91,9 @@ class MicrosoftInference:
                     "coordinates": xy_coord,
                     "category": category,
                     "id": id_counter,
-                    "content": {
-                        "text": transcription,
-                        "html": "",
-                        "markdown": ""
-                    }
+                    "content": {"text": transcription, "html": "", "markdown": ""}
                 }
                 processed_dict[input_key]["elements"].append(data_dict)
-
                 id_counter += 1
 
             html_transcription = ""
@@ -85,16 +101,13 @@ class MicrosoftInference:
                 coord = [[pt["x"], pt["y"]] for pt in table_elem["bounding_regions"][0]["polygon"]]
                 xy_coord = [{"x": x, "y": y} for x, y in coord]
 
-                category = "table"
-
                 html_transcription += "<table>"
 
-                # Create a matrix to represent the table
                 table_matrix = [
-                    ["" for _ in range(table_elem["column_count"])] for _ in range(table_elem["row_count"])
+                    ["" for _ in range(table_elem["column_count"])]
+                    for _ in range(table_elem["row_count"])
                 ]
 
-                # Fill the matrix with table data
                 for cell in table_elem["cells"]:
                     row = cell["row_index"]
                     col = cell["column_index"]
@@ -102,116 +115,64 @@ class MicrosoftInference:
                     colspan = cell.get("column_span", 1)
                     content = cell["content"]
 
-                    # Insert content into the matrix, handle rowspan and colspan
                     for r in range(row, row + rowspan):
                         for c in range(col, col + colspan):
                             if r == row and c == col:
                                 table_matrix[r][c] = f"<td rowspan='{rowspan}' colspan='{colspan}'>{content}</td>"
                             else:
-                                # Mark cells covered by rowspan or colspan
                                 table_matrix[r][c] = None
 
-                # Generate HTML from the matrix
                 for row in table_matrix:
                     html_transcription += "<tr>"
                     for cell in row:
                         if cell is not None:
-                            html_transcription += f"{cell}"
+                            html_transcription += cell
                     html_transcription += "</tr>"
 
                 html_transcription += "</table>"
 
                 data_dict = {
                     "coordinates": xy_coord,
-                    "category": category,
+                    "category": "table",
                     "id": id_counter,
-                    "content": {
-                        "text": "",
-                        "html": html_transcription,
-                        "markdown": ""
-                    }
+                    "content": {"text": "", "html": html_transcription, "markdown": ""}
                 }
                 processed_dict[input_key]["elements"].append(data_dict)
-
                 id_counter += 1
 
-        for key in self.processed_data:
-            processed_dict[key] = self.processed_data[key]
-
-        return processed_dict
-
+        return self._merge_processed_data(processed_dict)
 
-    def infer(self, file_path):
-        """Infer the layout of the documents in the given file path
-        Args:
-            file_path (str): the path to the file or directory containing the documents to process
-        """
-        paths = read_file_paths(file_path, supported_formats=self.formats)
-
-        error_files = []
-
-        result_dict = {}
-        for idx, filepath in enumerate(paths):
-            print("({}/{}) {}".format(idx+1, len(paths), filepath))
-
-            filename = filepath.name
-            if filename in self.processed_data.keys():
-                print(f"'{filename}' is already in the loaded dictionary. Skipping this sample")
-                continue
-
-            input_data = open(filepath, "rb")
-
-            try:
-                poller = self.document_analysis_client.begin_analyze_document(
-                    "prebuilt-layout", document=input_data
-                )
-                result = poller.result()
+    def _analyze_document(self, filepath):
+        """Analyze document using Azure Document Intelligence."""
+        with open(filepath, "rb") as input_data:
+            poller = self.document_analysis_client.begin_analyze_document(
+                "prebuilt-layout", document=input_data
+            )
+            result = poller.result()
+            return result.to_dict()
 
-                json_result = result.to_dict()
-            except Exception as e:
-                print(e)
-                print("Error processing document..")
-                error_files.append(filepath)
-                continue
+    async def _call_api_async(self, filepath, *args, **kwargs):
+        """Make the actual async API call for a file."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._analyze_document, filepath)
 
-            result_dict[filename] = json_result
-
-        result_dict = self.post_process(result_dict)
-
-        with open(self.save_path, "w") as f:
-            json.dump(result_dict, f)
-
-        for error_file in error_files:
-            print(f"Error processing file: {error_file}")
-
-        print("Finished processing all documents")
-        print("Results saved to: {}".format(self.save_path))
-        print("Number of errors: {}".format(len(error_files)))
+    def _call_api_sync(self, filepath, *args, **kwargs):
+        """Make the actual sync API call for a file."""
+        return self._analyze_document(filepath)
 
 
 if __name__ == "__main__":
-    args = argparse.ArgumentParser()
-    args.add_argument(
-        "--data_path",
-        type=str, default="", required=True,
-        help="Path containing the documents to process"
-    )
-    args.add_argument(
-        "--save_path",
-        type=str, default="", required=True,
-        help="Path to save the results"
-    )
-    args.add_argument(
-        "--input_formats",
-        type=list, default=[
-            ".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"
-        ],
-        help="Supported input file formats"
-    )
-    args = args.parse_args()
+    parser = create_argument_parser("Microsoft Azure Document Intelligence layout inference")
+    args = parse_args_with_extra(parser)
 
     microsoft_inference = MicrosoftInference(
         args.save_path,
-        input_formats=args.input_formats
+        input_formats=args.input_formats,
+        concurrent_limit=args.concurrent,
+        sampling_rate=args.sampling_rate,
+        request_timeout=args.request_timeout,
+        random_seed=args.random_seed,
+        group_by_document=args.group_by_document,
+        file_ext_mapping=args.file_ext_mapping
     )
     microsoft_inference.infer(args.data_path)

scripts/infer_unstructured.py

@@ -1,14 +1,15 @@
+"""
+Unstructured document layout inference.
+
+Uses Unstructured API for document analysis.
+"""
+import asyncio
 import os
-import time
-import json
-import argparse
-from pathlib import Path
 
 import unstructured_client
 from unstructured_client.models import operations, shared
 
-from utils import read_file_paths, validate_json_save_path, load_json_file
-
+from base import BaseInference, create_argument_parser, parse_args_with_extra
 
 CATEGORY_MAP = {
     "NarrativeText": "paragraph",
@@ -28,18 +29,42 @@ CATEGORY_MAP = {
 }
 
 
-class UnstructuredInference:
+class UnstructuredInference(BaseInference):
+    """Unstructured document layout inference."""
+    
     def __init__(
         self,
         save_path,
-        input_formats=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"]
+        input_formats=None,
+        concurrent_limit=None,
+        sampling_rate=1.0,
+        request_timeout=600,
+        random_seed=None,
+        group_by_document=False,
+        file_ext_mapping=None
     ):
-        """Initialize the UnstructuredInference class
+        """Initialize the UnstructuredInference class.
+
         Args:
             save_path (str): the json path to save the results
             input_formats (list, optional): the supported file formats.
+            concurrent_limit (int, optional): maximum number of concurrent API requests
+            sampling_rate (float, optional): fraction of files to process (0.0-1.0)
+            request_timeout (float, optional): timeout in seconds for API requests
+            random_seed (int, optional): random seed for reproducible sampling
+            group_by_document (bool, optional): group per-page results into document-level
+            file_ext_mapping (str or dict, optional): file extension mapping for grouping
         """
-        self.formats = input_formats
+        super().__init__(
+            save_path,
+            input_formats,
+            concurrent_limit,
+            sampling_rate,
+            request_timeout,
+            random_seed,
+            group_by_document,
+            file_ext_mapping
+        )
 
         self.api_key = os.getenv("UNSTRUCTURED_API_KEY") or ""
         self.url = os.getenv("UNSTRUCTURED_URL") or ""
@@ -51,29 +76,28 @@ class UnstructuredInference:
         self.get_coordinates = True
         self.infer_table_structure = True
 
-        # create save basepath
-        validate_json_save_path(save_path)
-        self.save_path = save_path
-        self.processed_data = load_json_file(save_path)
-
         self.client = unstructured_client.UnstructuredClient(
             api_key_auth=self.api_key,
             server_url=self.url,
         )
 
     def post_process(self, data):
+        """Post-process Unstructured API response to standard format."""
         processed_dict = {}
         for input_key in data.keys():
             output_data = data[input_key]
 
-            processed_dict[input_key] = {
-                "elements": []
-            }
+            # Handle wrapped structure from interim results
+            if isinstance(output_data, dict) and "result" in output_data:
+                output_data = output_data["result"]
+
+            processed_dict[input_key] = {"elements": []}
 
             id_counter = 0
             for elem in output_data:
                 transcription = elem["text"]
                 category = CATEGORY_MAP.get(elem["type"], "paragraph")
+                
                 if elem["metadata"]["coordinates"] is None:
                     continue
 
@@ -93,96 +117,50 @@ class UnstructuredInference:
                     }
                 }
                 processed_dict[input_key]["elements"].append(data_dict)
-
                 id_counter += 1
 
-        for key in self.processed_data:
-            processed_dict[key] = self.processed_data[key]
+        return self._merge_processed_data(processed_dict)
+
+    def _partition_document(self, filepath):
+        """Partition document using Unstructured API."""
+        with open(filepath, "rb") as f:
+            data = f.read()
+
+        req = operations.PartitionRequest(
+            partition_parameters=shared.PartitionParameters(
+                files=shared.Files(content=data, file_name=str(filepath)),
+                strategy=shared.Strategy.HI_RES,
+                pdf_infer_table_structure=self.infer_table_structure,
+                coordinates=self.get_coordinates,
+                languages=self.languages,
+            ),
+        )
 
-        return processed_dict
+        res = self.client.general.partition(request=req)
+        return res.elements
 
-    def infer(self, file_path):
-        """Infer the layout of the documents in the given file path
-        Args:
-            file_path (str): the path to the file or directory containing the documents to process
-        """
-        paths = read_file_paths(file_path, supported_formats=self.formats)
-
-        error_files = []
-
-        result_dict = {}
-        for filepath in paths:
-            print("({}/{}) Processing {}".format(paths.index(filepath) + 1, len(paths), filepath))
-            filename = filepath.name
-            if filename in self.processed_data.keys():
-                print(f"'{filename}' is already in the loaded dictionary. Skipping this sample")
-                continue
-
-            with open(filepath, "rb") as f:
-                data = f.read()
-
-            req = operations.PartitionRequest(
-                partition_parameters=shared.PartitionParameters(
-                    files=shared.Files(
-                        content=data,
-                        file_name=str(filepath),
-                    ),
-                    # --- Other partition parameters ---
-                    strategy=shared.Strategy.HI_RES,
-                    pdf_infer_table_structure=self.infer_table_structure,
-                    coordinates=self.get_coordinates,
-                    languages=self.languages,
-                ),
-            )
-
-            try:
-                res = self.client.general.partition(request=req)
-                elements = res.elements
-            except Exception as e:
-                print(e)
-                print("Error processing document..")
-                error_files.append(filepath)
-                continue
-
-            result_dict[filename] = elements
-
-        result_dict = self.post_process(result_dict)
-
-        with open(self.save_path, "w") as f:
-            json.dump(result_dict, f)
-
-        for error_file in error_files:
-            print(f"Error processing file: {error_file}")
-
-        print("Finished processing all documents")
-        print("Results saved to: {}".format(self.save_path))
-        print("Number of errors: {}".format(len(error_files)))
+    async def _call_api_async(self, filepath, *args, **kwargs):
+        """Make the actual async API call for a file."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._partition_document, filepath)
+
+    def _call_api_sync(self, filepath, *args, **kwargs):
+        """Make the actual sync API call for a file."""
+        return self._partition_document(filepath)
 
 
 if __name__ == "__main__":
-    args = argparse.ArgumentParser()
-    args.add_argument(
-        "--data_path",
-        type=str, default="", required=True,
-        help="Path containing the documents to process"
-    )
-    args.add_argument(
-        "--save_path",
-        type=str, default="", required=True,
-        help="Path to save the results"
-    )
-    args.add_argument(
-        "--input_formats",
-        type=list, default=[
-            ".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"
-        ],
-        help="Supported input file formats"
-    )
-    args = args.parse_args()
+    parser = create_argument_parser("Unstructured document layout inference")
+    args = parse_args_with_extra(parser)
 
     unstructured_inference = UnstructuredInference(
         args.save_path,
-        input_formats=args.input_formats
+        input_formats=args.input_formats,
+        concurrent_limit=args.concurrent,
+        sampling_rate=args.sampling_rate,
+        request_timeout=args.request_timeout,
+        random_seed=args.random_seed,
+        group_by_document=args.group_by_document,
+        file_ext_mapping=args.file_ext_mapping
     )
     unstructured_inference.infer(args.data_path)
-

scripts/infer_upstage.py

@@ -1,28 +1,65 @@
+"""
+Upstage document layout inference.
+
+Uses Upstage's Document Parse API.
+"""
 import os
-import sys
-import json
+
 import requests
-import argparse
 
-from pathlib import Path
-from utils import read_file_paths, validate_json_save_path, load_json_file
+from base import HttpClientInference, create_argument_parser, parse_args_with_extra
 
 
-class UpstageInference:
+class UpstageInference(HttpClientInference):
+    """Upstage document layout inference."""
+    
     def __init__(
         self,
         save_path,
-        input_formats=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"],
-        output_formats=["text", "html", "markdown"],
-        model_name="document-parse-240910",
+        input_formats=None,
+        output_formats=None,
+        model=None,
+        mode=None,
+        concurrent_limit=None,
+        sampling_rate=1.0,
+        request_timeout=600,
+        random_seed=None,
+        group_by_document=False,
+        file_ext_mapping=None,
+        ocr=None,
+        dpi=None,
+        jpeg_quality=None,
+        schema=None,
     ):
-        """Initialize the UpstageInference class
+        """Initialize the UpstageInference class.
+
         Args:
             save_path (str): the json path to save the results
             input_formats (list, optional): the supported input file formats.
             output_formats (list, optional): the supported output formats.
-            model_name (str, optional): the model name. Defaults to "document-parse-240910".
+            model (str, optional): the model name. Defaults to "document-parse-nightly".
+            mode (str, optional): the parsing mode. Either "standard", "enhanced", or "auto".
+            concurrent_limit (int, optional): maximum number of concurrent API requests
+            sampling_rate (float, optional): fraction of files to process (0.0-1.0)
+            request_timeout (float, optional): timeout in seconds for API requests
+            random_seed (int, optional): random seed for reproducible sampling
+            group_by_document (bool, optional): group per-page results into document-level
+            file_ext_mapping (str or dict, optional): file extension mapping for grouping
+            ocr (str, optional): OCR option (e.g. "auto", "force")
+            dpi (int, optional): DPI value for the request
+            jpeg_quality (int, optional): JPEG quality value for the request
+            schema (str, optional): output schema (e.g. "ufso")
         """
+        super().__init__(
+            save_path,
+            input_formats,
+            concurrent_limit,
+            sampling_rate,
+            request_timeout,
+            random_seed,
+            group_by_document,
+            file_ext_mapping
+        )
 
         self.endpoint = os.getenv("UPSTAGE_ENDPOINT", "")
         self.api_key = os.getenv("UPSTAGE_API_KEY", "")
@@ -30,108 +67,151 @@ class UpstageInference:
         if not all([self.endpoint, self.api_key]):
             raise ValueError("Please set the environment variables for Upstage")
 
-        validate_json_save_path(save_path)
-        self.save_path = save_path
-        self.processed_data = load_json_file(save_path)
-
-        self.input_formats = input_formats
+        if output_formats is None:
+            output_formats = ["text", "html", "markdown"]
         self.output_formats = output_formats
 
         self.headers = {
             "Authorization": f"Bearer {self.api_key}",
+            "X-Upstage-Use-Cache": "false",
         }
 
         self.data = {
-            "ocr": "force",
-            "model": model_name,
-            "output_formats": f"{self.output_formats}"
+            "ocr": ocr or "force",
+            "output_formats": f"{self.output_formats}",
+            "mode": mode or "standard"
         }
-
-    def infer(self, file_path) -> None:
-        """Infer the layout of the documents in the given file path
+        # Only include model if explicitly provided (hosted API requires it, local doesn't)
+        if model:
+            self.data["model"] = model
+        if dpi is not None:
+            self.data["dpi"] = str(dpi)
+        if jpeg_quality is not None:
+            self.data["jpeg_quality"] = str(jpeg_quality)
+        if schema:
+            self.data["schema"] = schema
+
+    def post_process(self, data):
+        """Post-process is not needed for Upstage - it returns data directly."""
+        return self._merge_processed_data(data)
+
+    async def _call_api_async(self, filepath, client=None):
+        """Make the actual async API call for a file.
+        
         Args:
-            file_path (str): the path to the file or directory containing the documents to process
+            filepath: Path object to the file
+            client: httpx.AsyncClient instance
+            
+        Returns:
+            dict: Raw API response data
         """
-
-        paths = read_file_paths(file_path, self.input_formats)
-
-        error_files = []
-
-        result_dict = {}
-        for idx, filepath in enumerate(paths):
-            print("({}/{}) {}".format(idx+1, len(paths), filepath))
-
-            filename = Path(filepath).name
-            if filename in self.processed_data.keys():
-                print(f"'{filename}' is already in the loaded dictionary. Skipping this sample")
-                continue
-
-            files = {
-                "document": open(filepath, "rb"),
-            }
-
-            try:
-                # The API does not support files exceeding 50MB
-                # or containing more than 100 pages.
-                response = requests.post(
-                    self.endpoint,
-                    headers=self.headers,
-                    files=files,
-                    data=self.data
-                )
-                json_result = response.json()
-
-                result_dict[filename] = json_result
-
-            except Exception as e:
-                print(e)
-                print("Error processing document..")
-                error_files.append(filepath)
-                continue
-
-        for key in self.processed_data:
-            result_dict[key] = self.processed_data[key]
-
-        with open(self.save_path, "w", encoding="utf-8") as f:
-            json.dump(result_dict, f, ensure_ascii=False, indent=4)
-
-        for error_file in error_files:
-            print(f"Error processing file: {error_file}")
-
-        print("Finished processing all documents")
-        print("Results saved to: {}".format(self.save_path))
-        print("Number of errors: {}".format(len(error_files)))
+        filename = filepath.name
+        
+        with open(filepath, "rb") as f:
+            file_data = f.read()
+        
+        files = {
+            "document": (filename, file_data, "application/pdf")
+        }
+        
+        response = await client.post(
+            self.endpoint,
+            headers=self.headers,
+            files=files,
+            data=self.data,
+            timeout=300.0
+        )
+        
+        if response.status_code != 200:
+            error_result = response.json() if response.headers.get("content-type", "").startswith("application/json") else {"error": response.text}
+            raise Exception(f"HTTP {response.status_code}: {error_result}")
+        
+        return response.json()
+
+    def _call_api_sync(self, filepath):
+        """Make the actual sync API call for a file.
+        
+        Args:
+            filepath: Path object to the file
+            
+        Returns:
+            dict: Raw API response data
+        """
+        filename = filepath.name
+        
+        files = {
+            "document": open(filepath, "rb"),
+        }
+        
+        try:
+            response = requests.post(
+                self.endpoint,
+                headers=self.headers,
+                files=files,
+                data=self.data,
+                timeout=300.0
+            )
+            
+            if response.status_code != 200:
+                error_result = response.json() if response.headers.get("content-type", "").startswith("application/json") else {"error": response.text}
+                raise Exception(f"HTTP {response.status_code}: {error_result}")
+            
+            return response.json()
+        finally:
+            files["document"].close()
 
 
 if __name__ == "__main__":
-    args = argparse.ArgumentParser()
-    args.add_argument(
-        "--data_path",
-        type=str, default="", required=True,
-        help="Path containing the documents to process"
+    parser = create_argument_parser("Upstage document layout inference")
+    parser.add_argument(
+        "--output-formats",
+        type=str, nargs='+',
+        default=["text", "html", "markdown"],
+        help="Output formats supported by the API"
     )
-    args.add_argument(
-        "--save_path",
-        type=str, default="", required=True,
-        help="Path to save the results"
+    parser.add_argument(
+        "--ocr",
+        type=str, default=None,
+        help="OCR option (e.g. 'auto', 'force'). Default: force"
     )
-    args.add_argument(
-        "--input_formats",
-        type=list, default=[
-            ".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"
-        ],
-        help="Supported input file formats"
+    parser.add_argument(
+        "--dpi",
+        type=int, default=None,
+        help="DPI value for the request"
     )
-    args.add_argument(
-        "--output_formats",
-        type=list, default=["text", "html", "markdown"],
-        help="Output formats supported by the API"
+    parser.add_argument(
+        "--jpeg-quality",
+        type=int, default=None,
+        help="JPEG quality value for the request"
+    )
+    parser.add_argument(
+        "--schema",
+        type=str, default=None,
+        help="Output schema (e.g. 'ufso')"
     )
-    args = args.parse_args()
+    # Override --mode with Upstage-specific choices
+    for action in parser._actions:
+        if action.dest == 'mode':
+            action.choices = ["standard", "enhanced", "auto"]
+            action.help = "Parsing mode: 'standard' (default), 'enhanced', or 'auto'"
+            break
+    args = parse_args_with_extra(parser)
 
     upstage_inference = UpstageInference(
         args.save_path,
         input_formats=args.input_formats,
-        output_formats=args.output_formats
+        output_formats=args.output_formats,
+        model=args.model,
+        mode=args.mode,
+        concurrent_limit=args.concurrent,
+        sampling_rate=args.sampling_rate,
+        request_timeout=args.request_timeout,
+        random_seed=args.random_seed,
+        group_by_document=args.group_by_document,
+        file_ext_mapping=args.file_ext_mapping,
+        ocr=args.ocr,
+        dpi=args.dpi,
+        jpeg_quality=args.jpeg_quality,
+        schema=args.schema,
     )
     upstage_inference.infer(args.data_path)

scripts/utils.py

@@ -33,6 +33,9 @@ def read_file_paths(path: str, supported_formats: List[str] = [".jpg"]) -> List[
     else:
         file_paths = []
 
+    # sort by filename for deterministic ordering
+    file_paths.sort(key=lambda f: f.name)
+
     return file_paths
 
 
@@ -62,3 +65,49 @@ def load_json_file(path: str) -> dict:
     else:
         # If the file does not exist, return an empty dictionary
         return {}
+
+
+def get_interim_dir_path(save_path: str) -> Path:
+    """Get the interim directory path based on the output filename"""
+    save_path_obj = Path(save_path)
+    interim_dir_name = save_path_obj.stem  # Get filename without extension
+    return save_path_obj.parent / interim_dir_name
+
+
+def get_interim_file_path(interim_dir: Path, filename: str) -> Path:
+    """Get the interim file path for a specific document"""
+    safe_filename = filename.replace('/', '_').replace('\\', '_')  # Handle path separators
+    return interim_dir / f"{safe_filename}.json"
+
+
+def save_interim_result(interim_dir: Path, filename: str, result: dict) -> None:
+    """Save individual API result to interim JSON file"""
+    interim_path = get_interim_file_path(interim_dir, filename)
+    with open(interim_path, "w", encoding="utf-8") as f:
+        json.dump(result, f, ensure_ascii=False, indent=4)
+
+
+def load_interim_result(interim_dir: Path, filename: str) -> dict:
+    """Load individual API result from interim JSON file"""
+    interim_path = get_interim_file_path(interim_dir, filename)
+    if interim_path.exists():
+        with open(interim_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return None
+
+
+def collect_all_interim_results(interim_dir: Path) -> dict:
+    """Collect all interim results from the interim directory"""
+    result_dict = {}
+    
+    # Load all interim results
+    if interim_dir.exists():
+        for interim_file in interim_dir.glob("*.json"):
+            filename = interim_file.stem  # Remove .json extension
+            try:
+                with open(interim_file, "r", encoding="utf-8") as f:
+                    result_dict[filename] = json.load(f)
+            except Exception as e:
+                print(f"Error loading interim file {interim_file}: {e}")
+    
+    return result_dict

src/geometry.py

@@ -0,0 +1,9 @@
+from shapely.geometry import Polygon
+from shapely import affinity
+
+
+def is_included(points_0, points_1, soft=0.2):
+    polygon_0 = Polygon(points_0)
+    polygon_1 = Polygon(points_1)
+    polygon_1 = affinity.scale(polygon_1, xfact=1. - soft, yfact=1. - soft)
+    return polygon_0.contains(polygon_1)

src/layout_evaluation.py

@@ -1,4 +1,16 @@
 from rapidfuzz import fuzz
+from src.geometry import is_included
+
+
+def _normalize_coords(coordinates):
+    """Convert coordinates to list of [x, y] pairs.
+
+    Accepts either [{"x": x, "y": y}, ...] or [[x, y], ...].
+    """
+    return [
+        [coord["x"], coord["y"]] if isinstance(coord, dict) else list(coord)
+        for coord in coordinates
+    ]
 
 def calc_nid(
     gt_text : list,
@@ -27,68 +39,111 @@ def calc_nid(
 
 
 def extract_text(
-    data : dict,
+    gt_data : dict,
+    pred_data : dict,
     ignore_classes : list = [],
     strings_to_remove : list = ["\n"],
-) -> str:
-    """Extract text from the dictionary data.
+    filter_by_gt_area : bool = True,
+) -> tuple:
+    """Extract text from both GT and prediction data, optionally filtering out 
+    predictions that fall within GT ignored regions.
 
     Args:
-        data (dict): The data to extract text from.
+        gt_data (dict): The GT data to extract text from.
+        pred_data (dict): The prediction data to extract text from.
         ignore_classes (list): A list of classes to ignore during extraction.
         strings_to_remove (list): A list of strings to remove from the extracted text.
+        filter_by_gt_area (bool): If True, filter out prediction text within GT ignored regions.
+                                  If False, only filter by category. Defaults to True.
 
     Returns:
-        str: The concatenated text extracted from the data.
+        tuple: (gt_text, pred_text) - The concatenated text extracted from GT and predictions.
     """
 
     ignore_classes = [x.lower() for x in ignore_classes]
 
-    concatenated_text = ""
-
-    for elem in data["elements"]:
+    # Collect GT ignored regions' coordinates (only if spatial filtering is enabled)
+    gt_ignored_regions = []
+    if filter_by_gt_area:
+        for elem in gt_data["elements"]:
+            if elem["category"].lower() in ignore_classes:
+                coords = _normalize_coords(elem["coordinates"])
+                gt_ignored_regions.append(coords)
+
+    # Extract GT text (excluding ignored classes)
+    gt_text = ""
+    for elem in gt_data["elements"]:
         if elem["category"].lower() in ignore_classes:
             continue
-
-        concatenated_text += elem["content"]["text"] + ' '
-
-    # remove unwanted strings
+        gt_text += elem["content"]["text"] + ' '
+
+    # Extract prediction text (excluding ignored classes AND optionally elements within GT ignored regions)
+    pred_text = ""
+    if pred_data is not None:
+        for elem in pred_data["elements"]:
+            if elem["category"].lower() in ignore_classes:
+                continue
+            
+            # Check if this prediction element is included in any GT ignored region (only if enabled)
+            if filter_by_gt_area:
+                elem_coords = _normalize_coords(elem["coordinates"])
+                is_in_ignored_region = False
+                
+                for ignored_region in gt_ignored_regions:
+                    if is_included(ignored_region, elem_coords, soft=0.2):
+                        is_in_ignored_region = True
+                        break
+                
+                if is_in_ignored_region:
+                    continue
+                
+            pred_text += elem["content"]["text"] + ' '
+
+    # Remove unwanted strings from both texts
     for string in strings_to_remove:
-        concatenated_text = concatenated_text.replace(string, '')
+        gt_text = gt_text.replace(string, '')
+        pred_text = pred_text.replace(string, '')
 
-    return concatenated_text
+    return gt_text, pred_text
 
 
 def evaluate_layout(
     gt : dict,
     pred : dict,
     ignore_classes : list = [],
-) -> float:
+    filter_by_gt_area : bool = True,
+) -> tuple:
     """Evaluate the layout of the gt against the pred.
 
     Args:
         gt (dict): The gt layout to evaluate.
         pred (dict): The pred layout to evaluate against.
         ignore_classes (list): A list of classes to ignore during evaluation.
+        filter_by_gt_area (bool): If True, filter out prediction text within GT ignored regions.
+                                  If False, only filter by category. Defaults to True.
 
     Returns:
-        float: The layout evaluation score.
+        tuple: (avg_score, per_image_scores) - The average layout evaluation score and per-image scores dict.
     """
     scores = []
+    per_image_scores = {}
+    
     for image_key in gt.keys():
         gt_data = gt.get(image_key)
         pred_data = pred.get(image_key)
 
-        gt_text = extract_text(gt_data, ignore_classes)
-        pred_text = extract_text(pred_data, ignore_classes)
+        gt_text, pred_text = extract_text(gt_data, pred_data, ignore_classes, filter_by_gt_area=filter_by_gt_area)
 
         score = calc_nid(gt_text, pred_text)
 
         scores.append(score)
+        per_image_scores[image_key] = {
+            "nid_score": score / 100.0
+        }
 
     if len(scores) > 0:
         avg_score = sum(scores) / (len(scores) * 100)
     else:
         avg_score = 0
 
-    return avg_score
+    return avg_score, per_image_scores

src/table_evaluation.py

@@ -7,6 +7,12 @@ A slight modification has been added to the code to improve the evaluation proce
 
 import re
 import distance
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+try:
+    from scipy.optimize import linear_sum_assignment
+except Exception as _e:
+    linear_sum_assignment = None
 
 from lxml import etree, html
 from collections import deque
@@ -34,6 +40,55 @@ class TableTree(Tree):
             result += child.bracket()
         return "{{{}}}".format(result)
 
+    def visualize(self, indent=0, prefix="", is_last=True):
+        """Visualize tree structure in ASCII art format
+        
+        Args:
+            indent (int): Current indentation level
+            prefix (str): Prefix for tree branches
+            is_last (bool): Whether this is the last child of its parent
+            
+        Returns:
+            str: ASCII tree visualization
+        """
+        # Prepare node information
+        if self.tag == 'td':
+            content_preview = ''
+            if self.content:
+                content_str = ''.join(self.content) if isinstance(self.content, list) else str(self.content)
+                content_preview = content_str[:30] + '...' if len(content_str) > 30 else content_str
+                content_preview = f' "{content_preview}"' if content_preview else ''
+            
+            node_info = f"{self.tag}"
+            attrs = []
+            if self.colspan and self.colspan > 1:
+                attrs.append(f"colspan={self.colspan}")
+            if self.rowspan and self.rowspan > 1:
+                attrs.append(f"rowspan={self.rowspan}")
+            if attrs:
+                node_info += f" [{', '.join(attrs)}]"
+            if content_preview:
+                node_info += content_preview
+        else:
+            node_info = self.tag
+        
+        # Build the tree line
+        if indent == 0:
+            result = f"{node_info}\n"
+        else:
+            connector = "└── " if is_last else "├── "
+            result = f"{prefix}{connector}{node_info}\n"
+        
+        # Process children
+        for i, child in enumerate(self.children):
+            is_last_child = (i == len(self.children) - 1)
+            if indent == 0:
+                child_prefix = ""
+            else:
+                child_prefix = prefix + ("    " if is_last else "│   ")
+            result += child.visualize(indent + 1, child_prefix, is_last_child)
+        
+        return result
 
 class CustomConfig(Config):
     """Custom Configuration for APTED"""
@@ -62,7 +117,12 @@ class CustomConfig(Config):
 
 class TEDSEvaluator(object):
     """Tree Edit Distance basead Similarity"""
-    def __init__(self, structure_only=False, n_jobs=1, ignore_nodes=None):
+    def __init__(
+        self,
+        structure_only=False,
+        n_jobs=1,
+        ignore_nodes=None,
+    ):
         assert isinstance(n_jobs, int) and (n_jobs >= 1), (
             'n_jobs must be an integer greather than 1'
         )
@@ -84,26 +144,59 @@ class TEDSEvaluator(object):
             self.__tokens__ += list(node.tail)
 
     def load_html_tree(self, node, parent=None):
-        """Converts HTML tree to the format required by apted"""
+        """Converts HTML tree to the format required by apted
+        This version treats nested tables as separate tree nodes rather than content.
+        """
         global __tokens__
         if node.tag == 'td':
-            if self.structure_only:
-                cell = []
+            # Check if td contains nested table(s)
+            nested_tables = [n for n in node.getchildren() if n.tag == 'table']
+            
+            if nested_tables:
+                # td has nested table(s) - create td node and add tables as children
+                if self.structure_only:
+                    cell = []
+                else:
+                    self.__tokens__ = []
+                    if node.text is not None:
+                        self.__tokens__ += list(node.text)
+                    for n in node.getchildren():
+                        if n.tag != 'table':
+                            self.tokenize(n)
+                        if n.tail is not None:
+                            self.__tokens__ += list(n.tail)
+                    cell = self.__tokens__.copy() if self.__tokens__ else []
+                
+                new_node = TableTree(
+                    node.tag,
+                    int(node.attrib.get('colspan', '1')),
+                    int(node.attrib.get('rowspan', '1')),
+                    cell, *deque()
+                )
+                # Add nested tables as children
+                if parent is not None:
+                    parent.children.append(new_node)
+                for table in nested_tables:
+                    self.load_html_tree(table, new_node)
             else:
-                self.__tokens__ = []
-                self.tokenize(node)
-                cell = self.__tokens__[1:-1].copy()
-            new_node = TableTree(
-                node.tag,
-                int(node.attrib.get('colspan', '1')),
-                int(node.attrib.get('rowspan', '1')),
-                cell, *deque()
-            )
+                if self.structure_only:
+                    cell = []
+                else:
+                    self.__tokens__ = []
+                    self.tokenize(node)
+                    cell = self.__tokens__[1:-1].copy()
+                new_node = TableTree(
+                    node.tag,
+                    int(node.attrib.get('colspan', '1')),
+                    int(node.attrib.get('rowspan', '1')),
+                    cell, *deque()
+                )
+                if parent is not None:
+                    parent.children.append(new_node)
         else:
             new_node = TableTree(node.tag, None, None, None, *deque())
-        if parent is not None:
-            parent.children.append(new_node)
-        if node.tag != 'td':
+            if parent is not None:
+                parent.children.append(new_node)
             for n in node.getchildren():
                 self.load_html_tree(n, new_node)
         if parent is None:
@@ -113,13 +206,22 @@ class TEDSEvaluator(object):
         """Computes TEDS score between the prediction and the ground truth of a given sample"""
         if (not pred) or (not true):
             return 0.0
+
         parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
         pred = html.fromstring(pred, parser=parser)
         true = html.fromstring(true, parser=parser)
-
         if pred.xpath('body/table') and true.xpath('body/table'):
-            pred = pred.xpath('body/table')[0]
-            true = true.xpath('body/table')[0]
+            pred_tables = pred.xpath('body/table')
+            true_tables = true.xpath('body/table')
+            # Default behavior: if multiple tables present, compare concatenated wrappers by matching counts
+            # Here keep legacy single-table by choosing the first only when both are singletons
+            if len(pred_tables) == 1 and len(true_tables) == 1:
+                pred = pred_tables[0]
+                true = true_tables[0]
+            else:
+                # Fallback: wrap the entire body as a single root for structural comparison
+                pred = pred.xpath('body')[0]
+                true = true.xpath('body')[0]
             if self.ignore_nodes:
                 etree.strip_tags(pred, *self.ignore_nodes)
                 etree.strip_tags(true, *self.ignore_nodes)
@@ -168,6 +270,228 @@ def extract_tables(data : dict) -> str:
     return html
 
 
+def extract_table_list(data: dict):
+    """Return a list of individual <table>...</table> HTML snippets from a doc dict.
+
+    Each returned entry is a complete single-table HTML fragment (wrapped with <table> tags).
+    """
+    tables: list = []
+    elements = (data or {}).get('elements', []) or []
+    for elem in elements:
+        try:
+            category = (elem or {}).get('category', '')
+            if isinstance(category, str) and category.lower() == 'table':
+                html_contents = ((elem or {}).get('content', {}) or {}).get('html') or ''
+                if isinstance(html_contents, str):
+                    tables.append(html_contents)
+                elif isinstance(html_contents, list):
+                    for html_content in html_contents:
+                        if isinstance(html_content, str):
+                            tables.append(html_content)
+        except Exception:
+            continue
+    return tables
+
+def _simplify_single_table(table_elem):
+    """
+    Simplify a single table element. (Recursive handling of nested tables)
+    
+    Args:
+        table_elem: lxml element - MUST be a <table> element
+    
+    Returns:
+        lxml element: The simplified table element
+    """
+
+    # 1. Remove all attributes of the table element
+    table_elem.attrib.clear()
+    
+    # 2. Remove thead, tbody, tfoot wrappers (keep their children)
+    #    Only process wrappers that belong to this table, not nested tables
+    for wrapper_tag in ('thead', 'tbody', 'tfoot'):
+        # Find all wrappers but only process those directly under this table
+        for wrapper in list(table_elem.xpath(f'./{wrapper_tag}')):
+            parent = wrapper.getparent()
+            index = list(parent).index(wrapper)
+            for child in list(wrapper):
+                parent.insert(index, child)
+                index += 1
+            parent.remove(wrapper)
+
+    # 3. Get direct tr children, excluding those in nested tables
+    direct_rows = []
+    for tr in table_elem.xpath('.//tr'):
+        # Find the closest table ancestor
+        parent = tr.getparent()
+        while parent is not None and parent.tag != 'table':
+            parent = parent.getparent()
+        # Only include if the closest table ancestor is our table_elem
+        if parent is table_elem:
+            direct_rows.append(tr)
+    
+    # 4. Remove attributes of the tr and cell except for colspan and rowspan
+    for tr in direct_rows:
+        tr.attrib.clear()    
+        for cell in tr:
+            if cell.tag in ('th', 'td'): # Replace th with td
+                if cell.tag == 'th':
+                    cell.tag = 'td'
+                
+                # Keep only colspan and rowspan attributes
+                new_attrib = {}
+                if 'colspan' in cell.attrib:
+                    new_attrib['colspan'] = cell.attrib['colspan']
+                if 'rowspan' in cell.attrib:
+                    new_attrib['rowspan'] = cell.attrib['rowspan']
+                cell.attrib.clear()
+                cell.attrib.update(new_attrib)
+                
+                # Check if there is a nested table
+                nested_tables = cell.xpath('.//table')
+                
+                # Recursively handle nested tables
+                for nested in nested_tables:
+                    _simplify_single_table(nested)
+                
+                # Remove unnecessary tags (keep content, remove tag wrapper)
+                # These tags are stripped but their text content is preserved
+                unnecessary_tags = [
+                    'div', 'span', 'p', 'br', 'b', 'i', 'strong', 'em', 'u', 
+                    'font', 'a', 'sup', 'sub', 'small', 'big', 'center',
+                    'label', 'section', 'article', 'header', 'footer', 'nav'
+                ]
+                etree.strip_tags(cell, *unnecessary_tags)
+
+                # Get text content (include text of all sub-tags)
+                text_content = cell.text_content()
+                if text_content:
+                    text_content = text_content.strip().replace('\xa0', '').replace('&nbsp;', '').strip()
+                
+                # If completely empty, set it as an empty cell (no text and no nested table)
+                if (not text_content or text_content == '') and not nested_tables:
+                    for child in list(cell):
+                        cell.remove(child)
+                    cell.text = ''
+                    cell.tail = None
+    
+    return table_elem
+
+def preprocess_table(table_html_list):
+    """
+    Preprocess the HTML table list to the basic structure.
+    Recursively handle nested tables (TINT).
+
+    Args:
+        table_html_list (list): List of HTML table strings
+
+    Returns:
+        list: Simplified list of HTML table strings
+    """
+    preprocessed_tables = []
+    
+    for html_string in table_html_list:
+        try:
+            parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
+            
+            # Extract outermost <table>...</table> if exists, otherwise wrap with <table>
+            table_start = html_string.find('<table')
+            table_end = html_string.rfind('</table>')
+            if table_start != -1 and table_end != -1:
+                # Extract the outermost table
+                html_string = html_string[table_start:table_end + len('</table>')]
+            else:
+                # No table tag found, wrap content with <table>
+                html_string = f'<table>{html_string}</table>'
+            
+            root = html.fromstring(html_string, parser=parser)
+            
+            # root itself might be the table element
+            if root.tag == 'table':
+                table = root
+            else:
+                table = root.xpath('.//table')[0]
+    
+            # Simplify the table
+            table = _simplify_single_table(table)
+
+            table_string = etree.tostring(table, encoding='unicode', method='html')
+            table_string = '<html><body>' + re.sub(r'>\s+<', '><', table_string).strip() + '</body></html>'
+            preprocessed_tables.append(table_string)
+            
+        except Exception as e:
+            print(f"[WARNING] Failed to simplify table: {e}, {html_string}")
+            preprocessed_tables.append(html_string)
+    
+    return preprocessed_tables
+
+def _compute_single_pair_score(args):
+    """Helper function to compute score for a single (i, j) pair."""
+    i, j, gt_table, pred_table, evaluator = args
+    try:
+        s = float(evaluator.evaluate(pred_table, gt_table))
+    except Exception:
+        s = 0.0
+    return i, j, s
+
+def _compute_teds_s_score(args):
+    """Helper function to compute TEDS-S score for a matched pair."""
+    gt_table, pred_table, evaluator = args
+    try:
+        return float(evaluator.evaluate(pred_table, gt_table))
+    except Exception:
+        return 0.0
+
+def _hungarian_match_tables_by_score(
+    gt_tables: list,
+    pred_tables: list,
+    evaluator: TEDSEvaluator,
+    min_match_score: float = 0.1,
+    max_workers: int = 1,
+):
+    """Hungarian one-to-one matching of GT and Pred tables using the provided evaluator.
+
+    Returns list of tuples: (gt_idx, pred_idx, score)
+    """
+    matches: list = []
+    if not gt_tables or not pred_tables:
+        return matches
+    if linear_sum_assignment is None:
+        # Fallback: no scipy available, return empty
+        return matches
+
+    n = max(len(gt_tables), len(pred_tables))
+    cost = np.zeros((n, n), dtype=float)
+    score_mat = np.zeros((n, n), dtype=float)
+
+    # Initialize all costs to 1.0 (dummy pairs)
+    cost.fill(1.0)
+
+    # Build list of valid (i, j) pairs to compute
+    tasks = [
+        (i, j, gt_tables[i], pred_tables[j], evaluator)
+        for i in range(len(gt_tables))
+        for j in range(len(pred_tables))
+    ]
+
+    # Use ThreadPoolExecutor for parallel score computation within this process
+    if tasks:
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            results = list(executor.map(_compute_single_pair_score, tasks))
+        
+        for i, j, s in results:
+            score_mat[i, j] = s
+            cost[i, j] = 1.0 - s
+
+    row_ind, col_ind = linear_sum_assignment(cost)
+
+    for i, j in zip(row_ind, col_ind):
+        if i < len(gt_tables) and j < len(pred_tables):
+            s = float(score_mat[i, j])
+            if s >= min_match_score:
+                matches.append((i, j, s))
+    return matches
+
+
 def has_table_content(html_data : str) -> bool:
     """Check if the table has content between <html><body> and </body></html>.
 
@@ -212,41 +536,11 @@ def prepare_table_dataset(gt_data, pred_data):
     return gt_table_list, pred_table_list
 
 
-def calc_table_score(gt_string, pred_string, evaluator):
-    """Calculate the table evaluation score between the gold and pred strings.
-
-    Args:
-        gt_string (str): The ground truth html string to compare.
-        pred_string (str): The predicted html string to compare.
-        evaluator (TEDS/TEDS-S): The TEDS/TEDS-S evaluator to use.
-    Returns:
-        float: The table evaluation score.
-    """
-    refined_pred = pred_string
-    refined_gold = gt_string
-    if pred_string.startswith('<table>') and pred_string.endswith('</table>'):
-        refined_pred = '<html><body>' + pred_string + '</body></html>'
-    elif not pred_string.startswith('<html><body><table>') and not pred_string.endswith('</table></body></html>'):
-        refined_pred = '<html><body><table>' + refined_pred + '</table></body></html>'
-
-    if gt_string.startswith('<table>') and gt_string.endswith('</table>'):
-        refined_gold = '<html><body>' + gt_string + '</body></html>'
-    elif not gt_string.startswith('<html><body><table>') and not gt_string.endswith('</table></body></html>'):
-        refined_gold = '<html><body><table>' + refined_gold + '</table></body></html>'
-
-    # remove thead and tbody
-    for tok in ['<thead>', '</thead>', '<tbody>', '</tbody>']:
-        refined_pred = refined_pred.replace(tok, '')
-        refined_gold = refined_gold.replace(tok, '')
-
-    score = evaluator.evaluate(refined_pred, refined_gold)
-
-    return score
-
-
 def evaluate_table(
     gt : dict,
-    pred : dict
+    pred : dict,
+    min_match_score: float = 0.0,
+    max_workers: int = 1,
 ) -> tuple:
     """Evaluate the table of the gt against the pred.
 
@@ -255,35 +549,83 @@ def evaluate_table(
         pred (dict): The pred layout to evaluate against.
 
     Returns:
-        tuple(float, float): The TEDS and TEDS-S scores for the table evaluation.
+        tuple(float, float, float, dict): The Table F1, TEDS, TEDS-S scores and per-image results.
     """
-
-    gt_table_list, pred_table_list = prepare_table_dataset(gt, pred)
-
     avg_teds_score = 0.0
     avg_teds_s_score = 0.0
 
-    if len(gt_table_list) == 0:
-        print('[Warning] No tables found in the ground truth dataset.')
-    elif len(pred_table_list) == 0:
-        print('[Warning] No tables found in the prediction dataset.')
-    else:
-        # Construct Table Evaluator for TEDS
-        # TEDS only evaluates the structure of the table
-        table_evaluator = TEDSEvaluator(structure_only=True)
-        teds_s_scores = []
-        for gt_table_elem, pred_table_elem in zip(gt_table_list, pred_table_list):
-            teds_s_score = calc_table_score(gt_table_elem, pred_table_elem, table_evaluator)
-            teds_s_scores.append(teds_s_score)
-        avg_teds_s_score= sum(teds_s_scores) / len(teds_s_scores)
-
-        # Construct Table Evaluator for TEDS-S
-        # TEDS-S evaluates the structure and content of the table
-        table_evaluator = TEDSEvaluator(structure_only=False)
-        teds_scores = []
-        for gt_table_elem, pred_table_elem in zip(gt_table_list, pred_table_list):
-            teds_score = calc_table_score(gt_table_elem, pred_table_elem, table_evaluator)
-            teds_scores.append(teds_score)
-        avg_teds_score = sum(teds_scores) / len(teds_scores)
+    eval_s = TEDSEvaluator(structure_only=True)
+    eval_full = TEDSEvaluator(structure_only=False)
+
+    n_gt_tables = 0
+    n_pred_tables = 0
+    n_matched_tables = 0
+    teds_scores = []
+    teds_s_scores = []
+    per_image_scores = {}
+
+    for image_key in gt.keys():
+        gt_elem = gt.get(image_key)
+        pred_elem = pred.get(image_key)
+        gt_tables = extract_table_list(gt_elem)
+        pred_tables = extract_table_list(pred_elem)
+
+        n_gt_tables += len(gt_tables)
+        n_pred_tables += len(pred_tables)
+        
+        # Initialize per-image result
+        per_image_scores[image_key] = {
+            "n_gt_tables": int(len(gt_tables)),
+            "n_pred_tables": int(len(pred_tables)),
+            "n_matched_tables": 0,
+            "matched_tables": []
+        }
+        
+        if not gt_tables and not pred_tables:
+            continue
 
-    return avg_teds_score, avg_teds_s_score
+        # Simplify tables before comparison
+        gt_tables = preprocess_table(gt_tables)
+        pred_tables = preprocess_table(pred_tables)
+        # TEDS (structure+content) for matching via Hungarian
+        matches = _hungarian_match_tables_by_score(
+            gt_tables, pred_tables, eval_full, 
+            min_match_score=min_match_score,
+            max_workers=max_workers,
+            )
+
+        if matches:
+            n_matched_tables += len(matches)
+            per_image_scores[image_key]["n_matched_tables"] = int(len(matches))
+            
+            # Extract TEDS scores from matches
+            teds_scores.extend([s for _, _, s in matches])
+            
+            # Parallel computation of TEDS-S scores for matched pairs
+            teds_s_tasks = [(gt_tables[i], pred_tables[j], eval_s) for i, j, _ in matches]
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                teds_s_results = list(executor.map(_compute_teds_s_score, teds_s_tasks))
+            
+            # Store results and per-image details
+            for (i, j, teds_score), teds_s_score in zip(matches, teds_s_results):
+                teds_s_scores.append(teds_s_score)
+                
+                per_image_scores[image_key]["matched_tables"].append({
+                    "gt_table_idx": int(i),
+                    "pred_table_idx": int(j),
+                    "teds_score": float(teds_score),
+                    "teds_s_score": float(teds_s_score)
+                })
+
+    if len(teds_scores) > 0:
+        table_f1_score = 2 * n_matched_tables / (n_gt_tables + n_pred_tables)
+        avg_teds_score = sum(teds_scores) / len(teds_scores)
+        avg_teds_s_score = sum(teds_s_scores) / len(teds_s_scores)
+    else: 
+        print('[Warning] No matched tables found in the ground truth and prediction datasets.')
+        table_f1_score = 0.0
+        avg_teds_score = 0.0
+        avg_teds_s_score = 0.0
+        
+
+    return table_f1_score, avg_teds_score, avg_teds_s_score, per_image_scores

src/utils.py

@@ -1,6 +1,6 @@
 import json
 from pathlib import Path
-from typing import List
+from typing import List, Dict, Any
 
 
 def read_file(path: str, supported_formats: str = ".json") -> dict:
@@ -79,17 +79,27 @@ def read_file_paths(path: str, supported_formats: List[str] = [".jpg"]) -> List[
     return file_paths
 
 
-def check_dataset_format(data: dict, image_key: str) -> None:
+def check_dataset_format(data: dict, image_key: str, is_prediction: bool = False) -> bool:
     """Check the format of the dataset
 
     Args:
         data (dict): the gt/prediction dataset to check
         image_key (str): the image name acting as the key in the dataset
+        is_prediction (bool): if True, skip entries with errors instead of raising
+
+    Returns:
+        bool: True if valid, False if entry has error (only when is_prediction=True)
 
     Raises:
-        ValueError: if a key is missing in the dataset
+        ValueError: if a key is missing in the dataset (only when is_prediction=False)
     """
+    # For predictions, allow entries with "error" key - they will be skipped
+    if is_prediction and "error" in data[image_key]:
+        return False
+    
     if data[image_key].get("elements") is None:
+        if is_prediction:
+            return False
         raise ValueError(
             f"{image_key} does not have 'elements' key in the json file. "
             "Check if you are passing the correct data."
@@ -98,12 +108,16 @@ def check_dataset_format(data: dict, image_key: str) -> None:
     elements = data[image_key]["elements"]
     for elem in elements:
         if elem.get("category") is None:
+            if is_prediction:
+                return False
             raise ValueError(
                 f"{image_key} does not have 'category' key in the ground truth file. "
                 "Check if you are passing the correct data."
             )
 
         if elem.get("content") is None:
+            if is_prediction:
+                return False
             raise ValueError(
                 f"{image_key} does not have 'content' key in the ground truth file. "
                 "Check if you are passing the correct data."
@@ -111,19 +125,26 @@ def check_dataset_format(data: dict, image_key: str) -> None:
         else:
             content = elem["content"]
             if content.get("text") is None:
+                if is_prediction:
+                    return False
                 raise ValueError(
                     f"{image_key} does not have 'text' key in the ground truth file. "
                     "Check if you are passing the correct data."
                 )
+    
+    return True
 
 
-def check_data_validity(gt_data: dict, pred_data: dict) -> None:
+def check_data_validity(gt_data: dict, pred_data: dict) -> tuple:
     """Check the validity of the ground truth and prediction data
 
     Args:
         gt_data (dict): the ground truth data
         pred_data (dict): the prediction data
 
+    Returns:
+        tuple: (valid_keys, error_keys, missing_keys) - lists of valid, error, and missing prediction keys
+
     Raises:
         ValueError: if the ground truth or prediction data is invalid
     """
@@ -134,16 +155,135 @@ def check_data_validity(gt_data: dict, pred_data: dict) -> None:
     if not pred_data:
         raise ValueError("Prediction data is empty")
 
+    # Check ground truth format (must be valid)
     for image_key in gt_data.keys():
-        pred_elem = pred_data.get(image_key)
-        if pred_data is None:
-            raise ValueError(
-                f"{image_key} not found in prediction. "
-                "Check if you are passing the correct data."
-            )
+        check_dataset_format(gt_data, image_key, is_prediction=False)
 
+    # Check prediction format (allow errors)
+    valid_keys = []
+    error_keys = []
+    missing_keys = []
+    
     for image_key in gt_data.keys():
-        check_dataset_format(gt_data, image_key)
+        pred_elem = pred_data.get(image_key)
+        if pred_elem is None:
+            missing_keys.append(image_key)
+        elif check_dataset_format(pred_data, image_key, is_prediction=True):
+            valid_keys.append(image_key)
+        else:
+            error_keys.append(image_key)
+    
+    return valid_keys, error_keys, missing_keys
 
-    for image_key in pred_data.keys():
-        check_dataset_format(pred_data, image_key)
+def _merge_bboxes(bboxes: List[List[float]]) -> List[float]:
+    """
+    Merge multiple bounding boxes into a single union bbox.
+    
+    Args:
+        bboxes: List of bboxes in 4-corner format [{'x': x1, 'y': y1}, {'x': x2, 'y': y1}, {'x': x2, 'y': y2}, {'x': x1, 'y': y2}]
+    
+    Returns:
+        Union bbox covering all input boxes: [x1_min, y1_min, x2_max, y2_max]
+    """
+    if not bboxes:
+        return [0.0, 0.0, 0.0, 0.0]
+    x1_min = min(bbox[0]['x'] for bbox in bboxes)
+    y1_min = min(bbox[1]['y'] for bbox in bboxes)
+    x2_max = max(bbox[2]['x'] for bbox in bboxes)
+    y2_max = max(bbox[3]['y'] for bbox in bboxes)
+    
+    return [x1_min, y1_min, x2_max, y2_max]
+
+def preprocess_merged_tables(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Preprocess data to merge tables according to merged_tables information.
+    
+    For each document with merged_tables:
+    1. Remove child tables from elements list
+    2. Keep the representative (first) table
+    3. Replace representative table's HTML with merged_html
+    4. Update representative table's BBox to union of all child bboxes
+    
+    Args:
+        data: Dictionary of document data in OAC format
+    
+    Returns:
+        Preprocessed data with merged tables
+    """
+    processed_data = {}
+    
+    for doc_key, doc in data.items():
+        if not isinstance(doc, dict):
+            processed_data[doc_key] = doc
+            continue
+        
+        # Deep copy to avoid modifying original
+        doc_copy = json.loads(json.dumps(doc))
+        
+        merged_tables = doc_copy.get("merged_tables", [])
+        if not merged_tables:
+            # No merging needed
+            processed_data[doc_key] = doc_copy
+            continue
+        
+        elements = doc_copy.get("elements", [])
+        if not elements:
+            processed_data[doc_key] = doc_copy
+            continue
+        
+        # Build element "page-id" to index mapping for quick lookup
+        # Format: "page-id" (e.g., "1-7") -> element index
+        key_to_idx = {}
+        for idx, elem in enumerate(elements):
+            page = elem.get("page")
+            elem_id = elem.get("id")
+            if page is not None and elem_id is not None:
+                key = f"{int(page)}-{int(elem_id)}"
+                key_to_idx[key] = idx
+    
+        # Track indices to remove (child tables that are merged)
+        indices_to_remove = set()
+        
+        # Process each merge group
+        for merge_group in merged_tables:
+            table_ids = merge_group.get("table_ids", [])
+            if len(table_ids) < 2:
+                continue
+            
+            # table_ids are strings in format "page-id" (e.g., "1-7", "2-11")
+            # No conversion needed, use as-is
+            table_ids = sorted([str(tid) for tid in table_ids])
+            
+            # Get merged HTML - check both 'html' and 'table_html' keys
+            merged_html = merge_group.get("table_html") or merge_group.get("html")
+            
+            # Find representative table (first one in the list)
+            representative_id = table_ids[0]
+            representative_idx = key_to_idx.get(representative_id)
+            
+            # Collect bboxes from all tables in the merge group
+            bboxes_to_merge = []
+            for tid in table_ids:
+                idx = key_to_idx.get(tid)
+                elem = elements[idx]
+                bboxes_to_merge.append(elem.get("coordinates"))
+                if tid != representative_id:
+                    indices_to_remove.add(idx)
+            
+            # Update representative table
+            elements[representative_idx]["content"]["html"] = merged_html
+            elements[representative_idx]["coordinates"] = _merge_bboxes(bboxes_to_merge)
+        
+        # Remove child tables (in reverse order to maintain indices)
+        new_elements = [
+            elem for idx, elem in enumerate(elements)
+            if idx not in indices_to_remove
+        ]
+        doc_copy["elements"] = new_elements
+        
+        # Remove merged_tables key as it's been applied
+        doc_copy.pop("merged_tables", None)
+        
+        processed_data[doc_key] = doc_copy
+    
+    return processed_data