|
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 |
|
|
|
|
|
class UpstageInference: |
|
def __init__( |
|
self, |
|
save_path, |
|
input_formats=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".heic"], |
|
output_formats=["text", "html", "markdown"], |
|
model_name="document-parse-240910", |
|
): |
|
"""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". |
|
""" |
|
|
|
self.endpoint = os.getenv("UPSTAGE_ENDPOINT", "") |
|
self.api_key = os.getenv("UPSTAGE_API_KEY", "") |
|
|
|
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 |
|
self.output_formats = output_formats |
|
|
|
self.headers = { |
|
"Authorization": f"Bearer {self.api_key}", |
|
} |
|
|
|
self.data = { |
|
"ocr": "force", |
|
"model": model_name, |
|
"output_formats": f"{self.output_formats}" |
|
} |
|
|
|
def infer(self, file_path) -> None: |
|
"""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, 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: |
|
|
|
|
|
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))) |
|
|
|
|
|
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.add_argument( |
|
"--output_formats", |
|
type=list, default=["text", "html", "markdown"], |
|
help="Output formats supported by the API" |
|
) |
|
args = args.parse_args() |
|
|
|
upstage_inference = UpstageInference( |
|
args.save_path, |
|
input_formats=args.input_formats, |
|
output_formats=args.output_formats |
|
) |
|
upstage_inference.infer(args.data_path) |
|
|
