File size: 6,446 Bytes
24702c6 | 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 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 | """
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
# Try colon format first (single 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}
# Try arrow format (multiple mappings)
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():
# Get document key and page number
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)
# Initialize document entry if not exists
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
# Get elements from page data
elements = page_content.get(elements_key, [])
# Add each element with updated id and page number
for elem in elements:
# Create a copy to avoid modifying original
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)
|