File size: 5,790 Bytes
1e9a6e5 b837da3 1e9a6e5 b837da3 1e9a6e5 b837da3 1e9a6e5 b837da3 1e9a6e5 b837da3 1e9a6e5 b837da3 1e9a6e5 b837da3 cb40a1c b837da3 1e9a6e5 b837da3 1e9a6e5 b837da3 cb40a1c 1e9a6e5 cb40a1c b837da3 cb40a1c b837da3 cb40a1c b837da3 1e9a6e5 b837da3 1e9a6e5 b837da3 1e9a6e5 b29fd1c b837da3 1e9a6e5 b837da3 1e9a6e5 b837da3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | """
Unstructured document layout inference.
Uses Unstructured API for document analysis.
"""
import asyncio
import os
import unstructured_client
from unstructured_client.models import operations, shared
from base import BaseInference, create_argument_parser, parse_args_with_extra
CATEGORY_MAP = {
"NarrativeText": "paragraph",
"ListItem": "paragraph",
"Title": "heading1",
"Address": "paragraph",
"Header": "header",
"Footer": "footer",
"UncategorizedText": "paragraph",
"Formula": "equation",
"FigureCaption": "caption",
"Table": "table",
"PageBreak": "paragraph",
"Image": "figure",
"PageNumber": "paragraph",
"CodeSnippet": "paragraph"
}
class UnstructuredInference(BaseInference):
"""Unstructured document layout inference."""
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 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
"""
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 ""
if not self.api_key or not self.url:
raise ValueError("Please set the environment variables for Unstructured")
self.languages = ["eng", "kor"]
self.get_coordinates = True
self.infer_table_structure = True
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]
# 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
xy_coord = [{"x": x, "y": y} for x, y in elem["metadata"]["coordinates"]["points"]]
if category == "table":
transcription = elem["metadata"]["text_as_html"]
data_dict = {
"coordinates": xy_coord,
"category": category,
"id": id_counter,
"content": {
"text": str(transcription) if category != "table" else "",
"html": transcription if category == "table" else "",
"markdown": ""
}
}
processed_dict[input_key]["elements"].append(data_dict)
id_counter += 1
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,
),
)
res = self.client.general.partition(request=req)
return res.elements
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__":
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,
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)
|