| """ |
| Google Document AI layout inference. |
| |
| 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 base import BaseInference, create_argument_parser, parse_args_with_extra |
|
|
| CATEGORY_MAP = { |
| "paragraph": "paragraph", |
| "footer": "footer", |
| "header": "header", |
| "heading-1": "heading1", |
| "heading-2": "heading1", |
| "heading-3": "heading1", |
| "table": "table", |
| "title": "heading1" |
| } |
|
|
|
|
| class GoogleInference(BaseInference): |
| """Google Document AI 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 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 "" |
| self.endpoint = os.getenv("GOOGLE_ENDPOINT") or "" |
|
|
| if not all([self.project_id, self.processor_id, self.location, self.endpoint]): |
| raise ValueError("Please set the environment variables for Google Cloud") |
|
|
| self.processor_version = "rc" |
|
|
| @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: |
| |
| 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" |
|
|
| for row in table_data["bodyRows"]: |
| html += " <tr>\n" |
| for cell in row["cells"]: |
| 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" |
| html += " </tr>\n" |
|
|
| html += "</table>" |
| return html |
|
|
| @staticmethod |
| def iterate_blocks(data): |
| """Iterate through document blocks and extract content.""" |
| block_sequence = [] |
|
|
| def recurse_blocks(blocks): |
| for block in blocks: |
| block_id = block.get("blockId", "") |
| block_type = block.get("textBlock", {}).get("type", "") |
| block_text = block.get("textBlock", {}).get("text", "") |
|
|
| if block_type: |
| block_sequence.append((block_id, block_type, block_text)) |
|
|
| 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 block.get("textBlock", {}).get("blocks", []): |
| recurse_blocks(block["textBlock"]["blocks"]) |
|
|
| if "documentLayout" in data: |
| recurse_blocks(data["documentLayout"].get("blocks", [])) |
|
|
| 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": []} |
|
|
| blocks = self.iterate_blocks(output_data) |
|
|
| id_counter = 0 |
| for _, category, transcription in blocks: |
| category = CATEGORY_MAP.get(category, "paragraph") |
|
|
| data_dict = { |
| "coordinates": [{"x": 0, "y": 0}] * 4, |
| "category": category, |
| "id": id_counter, |
| "content": { |
| "text": 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 _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( |
| chunk_size=chunk_size, |
| include_ancestor_headings=True, |
| ) |
| ) |
| ) |
| document = self._process_document(file_path, mime_type, process_options=process_options) |
| return json.loads(google.cloud.documentai_v1.Document.to_json(document)) |
|
|
| 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=self.endpoint) |
| ) |
|
|
| |
| 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 |
| ) |
| request = documentai.ProcessRequest( |
| name=name, |
| 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 _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 |
| ) |
|
|
| 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__": |
| 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, |
| 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) |
|
|
