| """ |
| Utility functions for grouping per-page results into document-level results. |
| |
| This module provides common functionality for: |
| - Extracting page numbers from image filenames |
| - Converting page-level keys to document-level keys |
| - Grouping page-level elements into document-level structure |
| |
| Usage: |
| from doc_grouping import group_pages_to_documents |
| |
| # Group page-level results into document-level |
| doc_results = group_pages_to_documents( |
| page_results, |
| file_ext_mapping={"jpg": "pdf"}, |
| ) |
| """ |
|
|
| import re |
| from typing import Dict, List, Optional, Tuple |
|
|
|
|
| def extract_page_number(image_key: str) -> int: |
| """ |
| Extract page number from image key. |
| |
| Supports formats like: |
| - 'document_page0001.jpg' -> 1 |
| - 'document_page0042.pdf' -> 42 |
| |
| Args: |
| image_key: Image filename with page suffix |
| |
| Returns: |
| Page number (1-based), or 1 if no page number found |
| """ |
| match = re.search(r"_page(\d{4})\.", image_key) |
| if match: |
| return int(match.group(1)) |
| return 1 |
|
|
|
|
| def to_doc_key(image_key: str) -> str: |
| """ |
| Convert page image key to document key by removing the page suffix. |
| |
| Example: |
| 'mt_2020-06-25T04-07-00Z_s100j0q8_39-43_page0001.jpg' |
| -> 'mt_2020-06-25T04-07-00Z_s100j0q8_39-43.jpg' |
| |
| Args: |
| image_key: Page-level image filename |
| |
| Returns: |
| Document-level filename (without page suffix) |
| """ |
| return re.sub(r"_page\d{4}(?=\.)", "", image_key) |
|
|
|
|
| def replace_ext(filename: str, file_ext_mapping: Dict[str, str]) -> str: |
| """ |
| Replace file extension according to mapping. |
| |
| Args: |
| filename: Original filename |
| file_ext_mapping: Dict mapping source extensions to destination extensions |
| e.g., {"jpg": "pdf", "jpeg": "pdf"} |
| |
| Returns: |
| Filename with replaced extension |
| """ |
| if not file_ext_mapping: |
| return filename |
| src_ext = filename.split(".")[-1] |
| dst_ext = file_ext_mapping.get(src_ext, src_ext) |
| return filename[: -(len(src_ext))] + dst_ext |
|
|
|
|
| def parse_ext_mapping(mapping_str: str) -> Dict[str, str]: |
| """ |
| Parse file extension mapping from CLI string format. |
| |
| Supports two formats: |
| - Colon format: "jpg:pdf" (single mapping) |
| - Arrow format: "jpg->pdf,jpeg->pdf" (multiple mappings) |
| |
| Args: |
| mapping_str: String in format "src:dst" or "src1->dst1,src2->dst2" |
| |
| Returns: |
| Dict mapping source extensions to destination extensions |
| |
| Raises: |
| ValueError: If mapping format is invalid |
| """ |
| file_ext_mapping = {} |
| if not mapping_str: |
| return file_ext_mapping |
|
|
| |
| if ":" in mapping_str and "->" not in mapping_str: |
| parts = mapping_str.split(":") |
| if len(parts) == 2: |
| src, dst = parts[0].strip(), parts[1].strip() |
| if src and dst: |
| return {src: dst} |
|
|
| |
| for pair in mapping_str.split(","): |
| pair = pair.strip() |
| if "->" in pair: |
| src, dst = pair.split("->", 1) |
| src = src.strip() |
| dst = dst.strip() |
| if src and dst: |
| file_ext_mapping[src] = dst |
| elif ":" in pair: |
| src, dst = pair.split(":", 1) |
| src = src.strip() |
| dst = dst.strip() |
| if src and dst: |
| file_ext_mapping[src] = dst |
|
|
| if not file_ext_mapping and mapping_str: |
| raise ValueError( |
| f"Invalid mapping format: '{mapping_str}'. " |
| "Use 'src:dst' or 'src1->dst1,src2->dst2' format." |
| ) |
|
|
| return file_ext_mapping |
|
|
|
|
| def group_pages_to_documents( |
| page_data: Dict[str, Dict], |
| file_ext_mapping: Optional[Dict[str, str]] = None, |
| elements_key: str = "elements", |
| include_merged_tables: bool = True, |
| ) -> Dict[str, Dict]: |
| """ |
| Group page-level results into document-level results. |
| |
| Takes a dictionary of page-level results (keyed by page image filename) |
| and aggregates them into document-level results. |
| |
| Args: |
| page_data: Dict mapping page filenames to their data. |
| Each page data should have an 'elements' list. |
| Example: {"doc_page0001.jpg": {"elements": [...]}, ...} |
| file_ext_mapping: Optional dict mapping source extensions to destination. |
| e.g., {"jpg": "pdf"} to output "doc.pdf" instead of "doc.jpg" |
| elements_key: Key name for the elements list in each page (default: "elements") |
| include_merged_tables: Whether to include empty "merged_tables" list (default: True) |
| |
| Returns: |
| Dict mapping document filenames to aggregated data. |
| Example: {"doc.pdf": {"elements": [...], "merged_tables": []}} |
| """ |
| if file_ext_mapping is None: |
| file_ext_mapping = {} |
|
|
| result: Dict[str, Dict] = {} |
| id_counters: Dict[str, int] = {} |
|
|
| for page_key, page_content in page_data.items(): |
| |
| doc_key_raw = to_doc_key(page_key) |
| doc_key = replace_ext(doc_key_raw, file_ext_mapping) |
| page_number = extract_page_number(page_key) |
|
|
| |
| if doc_key not in result: |
| result[doc_key] = {elements_key: []} |
| if include_merged_tables: |
| result[doc_key]["merged_tables"] = [] |
| id_counters[doc_key] = 0 |
|
|
| |
| elements = page_content.get(elements_key, []) |
|
|
| |
| for elem in elements: |
| |
| new_elem = elem.copy() |
| if "content" in elem: |
| new_elem["content"] = elem["content"].copy() |
|
|
| new_elem["id"] = id_counters[doc_key] |
| new_elem["page"] = page_number |
|
|
| result[doc_key][elements_key].append(new_elem) |
| id_counters[doc_key] += 1 |
|
|
| return result |
|
|
|
|
| def is_multi_page_dataset(page_keys: List[str]) -> bool: |
| """ |
| Check if the dataset contains multi-page documents. |
| |
| Looks for page suffixes like '_page0001' in the filenames. |
| |
| Args: |
| page_keys: List of page-level filenames |
| |
| Returns: |
| True if any filename has a page suffix |
| """ |
| page_pattern = re.compile(r"_page\d{4}\.") |
| return any(page_pattern.search(key) for key in page_keys) |
|
|
|
|
