| """ |
| Microsoft Azure Document Intelligence layout inference. |
| |
| Uses Azure Document Intelligence (Form Recognizer) API for document analysis. |
| """ |
| import asyncio |
| import os |
|
|
| from azure.ai.formrecognizer import DocumentAnalysisClient |
| from azure.core.credentials import AzureKeyCredential |
|
|
| from base import BaseInference, create_argument_parser, parse_args_with_extra |
|
|
| CATEGORY_MAP = { |
| "Title": "heading1", |
| "SectionHeading": "heading1", |
| "footnote": "footnote", |
| "PageHeader": "header", |
| "PageFooter": "footer", |
| "Paragraph": "paragraph", |
| "Subheading": "heading1", |
| "SectionMarks": "paragraph", |
| "PageNumber": "paragraph" |
| } |
|
|
|
|
| class MicrosoftInference(BaseInference): |
| """Microsoft Azure Document Intelligence 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 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 "" |
|
|
| if not all([MICROSOFT_API_KEY, MICROSOFT_ENDPOINT]): |
| raise ValueError("Please set the environment variables for Microsoft") |
|
|
| self.document_analysis_client = DocumentAnalysisClient( |
| endpoint=MICROSOFT_ENDPOINT, |
| credential=AzureKeyCredential(MICROSOFT_API_KEY) |
| ) |
|
|
| 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": []} |
|
|
| id_counter = 0 |
| for par_elem in output_data["paragraphs"]: |
| 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] |
|
|
| data_dict = { |
| "coordinates": xy_coord, |
| "category": category, |
| "id": id_counter, |
| "content": {"text": transcription, "html": "", "markdown": ""} |
| } |
| processed_dict[input_key]["elements"].append(data_dict) |
| id_counter += 1 |
|
|
| html_transcription = "" |
| for table_elem in output_data["tables"]: |
| 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] |
|
|
| html_transcription += "<table>" |
|
|
| table_matrix = [ |
| ["" for _ in range(table_elem["column_count"])] |
| for _ in range(table_elem["row_count"]) |
| ] |
|
|
| for cell in table_elem["cells"]: |
| row = cell["row_index"] |
| col = cell["column_index"] |
| rowspan = cell.get("row_span", 1) |
| colspan = cell.get("column_span", 1) |
| content = cell["content"] |
|
|
| 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: |
| table_matrix[r][c] = None |
|
|
| for row in table_matrix: |
| html_transcription += "<tr>" |
| for cell in row: |
| if cell is not None: |
| html_transcription += cell |
| html_transcription += "</tr>" |
|
|
| html_transcription += "</table>" |
|
|
| data_dict = { |
| "coordinates": xy_coord, |
| "category": "table", |
| "id": id_counter, |
| "content": {"text": "", "html": html_transcription, "markdown": ""} |
| } |
| processed_dict[input_key]["elements"].append(data_dict) |
| id_counter += 1 |
|
|
| return self._merge_processed_data(processed_dict) |
|
|
| 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() |
|
|
| 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) |
|
|
| 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__": |
| 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, |
| 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) |
|
|
