| | 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)
|
| |
|
