"""Convert the raw IMF PDF corpus into page-grounded Markdown and visual assets. The processor is deliberately separate from structured extraction. It creates a stable, auditable interim representation while preserving page boundaries, source hashes, PDF metadata, detected tables, and normalized visual hashes. """ from __future__ import annotations import argparse import concurrent.futures import datetime as dt import hashlib import json import os import re import shutil import subprocess import sys import tempfile import time from collections import Counter, defaultdict from pathlib import Path from typing import Any, Iterable, Sequence import imagehash import pymupdf import pymupdf4llm from PIL import Image, ImageOps PROCESSOR_VERSION = "1.0.1" EXTRACTION_METHOD = "pymupdf4llm+pymupdf-layout" IMAGE_DPI = 120 PHASH_BITS = 256 IMAGE_REF_RE = re.compile(r"!\[([^\]]*)\]\(([^)]+)\)") GENERATED_IMAGE_RE = re.compile( r"\.pdf-(\d+)-(\d+|full)\.(?:png|jpe?g)$", re.I ) HEADING_RE = re.compile(r"^(#{1,6})\s+(.+?)\s*$", re.M) def utc_now() -> str: return dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat() def load_jsonl(path: Path) -> list[dict[str, Any]]: if not path.exists(): return [] with path.open(encoding="utf-8") as source: return [json.loads(line) for line in source if line.strip()] def write_json(path: Path, value: Any) -> None: path.parent.mkdir(parents=True, exist_ok=True) temporary = path.with_suffix(path.suffix + ".tmp") temporary.write_text( json.dumps(value, ensure_ascii=False, indent=2, default=str) + "\n", encoding="utf-8", ) os.replace(temporary, path) def write_jsonl(path: Path, rows: Iterable[dict[str, Any]]) -> None: path.parent.mkdir(parents=True, exist_ok=True) temporary = path.with_suffix(path.suffix + ".tmp") with temporary.open("w", encoding="utf-8") as output: for row in rows: output.write(json.dumps(row, ensure_ascii=False, sort_keys=True, default=str)) output.write("\n") os.replace(temporary, path) def markdown_to_plain(markdown: str) -> str: text = IMAGE_REF_RE.sub("", markdown) text = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", text) text = re.sub(r"", " ", text, flags=re.I) text = re.sub(r"]+>", " ", text) text = re.sub(r"^\s*#{1,6}\s*", "", text, flags=re.M) text = re.sub(r"\*\*|__|`", "", text) text = re.sub(r"^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$", "", text, flags=re.M) text = text.replace("|", " ") text = re.sub(r"[ \t]+", " ", text) text = re.sub(r"\n{3,}", "\n\n", text) return text.strip() def content_metrics(text: str) -> dict[str, Any]: compact = re.sub(r"\s+", "", text) words = re.findall(r"\b\w+\b", text, flags=re.UNICODE) return { "characters": len(text), "non_whitespace_characters": len(compact), "words": len(words), "replacement_characters": text.count("\ufffd"), "headings": len(HEADING_RE.findall(text)), "markdown_table_rows": sum( 1 for line in text.splitlines() if line.count("|") >= 2 ), } def choose_benchmark_sample( inventory: list[dict[str, Any]], manifest: list[dict[str, Any]], count: int, ) -> list[str]: by_id = {row["report_id"]: row for row in inventory} manifest = [row for row in manifest if row["report_id"] in by_id] selected: list[str] = [] def add(report_id: str) -> None: if report_id in by_id and report_id not in selected: selected.append(report_id) ordered = sorted(inventory, key=lambda row: row.get("publication_date") or "") for row in ordered[:2] + ordered[-2:]: add(row["report_id"]) for series_prefix in ("cr-", "tar-", "legacy-"): group = [row for row in ordered if row["report_id"].startswith(series_prefix)] if group: for index in (0, len(group) // 2, len(group) - 1): add(group[index]["report_id"]) for row in inventory: languages = {value.lower() for value in row.get("language", [])} if languages - {"english"}: add(row["report_id"]) by_size = sorted(manifest, key=lambda row: row.get("bytes", 0)) if by_size: for quantile in (0.0, 0.25, 0.5, 0.75, 1.0): add(by_size[round((len(by_size) - 1) * quantile)]["report_id"]) return selected[:count] def _pymupdf4llm_chunks(pdf_path: str, *, write_images: bool, image_path: str = "") -> list[dict[str, Any]]: with pymupdf.open(pdf_path) as document: chunks = pymupdf4llm.to_markdown( document, page_chunks=True, write_images=write_images, image_path=image_path, image_format="png", image_size_limit=0.03, force_text=True, margins=0, dpi=IMAGE_DPI, table_strategy="lines_strict", graphics_limit=5000, ignore_code=True, extract_words=False, show_progress=False, ) if not isinstance(chunks, list) or len(chunks) != len(document): raise RuntimeError( f"unexpected page chunks: got {type(chunks).__name__}/" f"{len(chunks) if isinstance(chunks, list) else '?'} for {len(document)} pages" ) return chunks def benchmark_one(args: tuple[str, str]) -> dict[str, Any]: report_id, pdf_path = args started = time.perf_counter() chunks = _pymupdf4llm_chunks(pdf_path, write_images=False) layout_seconds = time.perf_counter() - started markdown = "\n\n".join(chunk.get("text", "") for chunk in chunks) started = time.perf_counter() completed = subprocess.run( ["pdftotext", "-layout", pdf_path, "-"], check=True, capture_output=True, ) poppler_text = completed.stdout.decode("utf-8", errors="replace") poppler_seconds = time.perf_counter() - started started = time.perf_counter() with pymupdf.open(pdf_path) as document: pymupdf_text = "\n\n".join(page.get_text("text", sort=True) for page in document) page_count = len(document) pymupdf_seconds = time.perf_counter() - started tables = sum(len(chunk.get("tables", [])) for chunk in chunks) return { "report_id": report_id, "pdf_path": pdf_path, "page_count": page_count, "pymupdf4llm": { "seconds": round(layout_seconds, 3), "detected_tables": tables, **content_metrics(markdown), }, "pdftotext_layout": { "seconds": round(poppler_seconds, 3), **content_metrics(poppler_text), }, "pymupdf_text": { "seconds": round(pymupdf_seconds, 3), **content_metrics(pymupdf_text), }, } def run_benchmark( inventory: list[dict[str, Any]], manifest: list[dict[str, Any]], *, interim_dir: Path, workers: int, sample_count: int, ) -> dict[str, Any]: paths = {row["report_id"]: row["local_path"] for row in manifest} selected = choose_benchmark_sample(inventory, manifest, sample_count) jobs = [(report_id, paths[report_id]) for report_id in selected] results: list[dict[str, Any]] = [] with concurrent.futures.ProcessPoolExecutor(max_workers=max(1, workers)) as pool: for result in pool.map(benchmark_one, jobs): results.append(result) print( f"benchmark: {len(results)}/{len(jobs)} {result['report_id']}", file=sys.stderr, ) ratios = [] for result in results: baseline = result["pdftotext_layout"]["non_whitespace_characters"] layout = result["pymupdf4llm"]["non_whitespace_characters"] if baseline: ratios.append(layout / baseline) summary = { "created_at": utc_now(), "sample_count": len(results), "sample_selection": "stratified by year, series, language, and PDF size", "results": results, "aggregate": { "pymupdf4llm_detected_tables": sum( result["pymupdf4llm"]["detected_tables"] for result in results ), "median_layout_to_pdftotext_non_whitespace_ratio": ( sorted(ratios)[len(ratios) // 2] if ratios else None ), "pymupdf4llm_seconds": round( sum(result["pymupdf4llm"]["seconds"] for result in results), 3 ), "pdftotext_seconds": round( sum(result["pdftotext_layout"]["seconds"] for result in results), 3 ), }, "selected_method": EXTRACTION_METHOD, "selection_rationale": ( "PyMuPDF4LLM with PyMuPDF Layout preserves page boundaries, headings, " "reading order, detected tables, and visual regions. pdftotext -layout " "is retained as an independent coverage baseline, not as the canonical format." ), "limitation": ( "The benchmark compares structural and coverage diagnostics without a " "human-transcribed ground truth; downstream extraction remains unreviewed." ), } write_json(interim_dir / "_benchmark" / "benchmark.json", summary) return summary def image_caption(page_markdown: str, source_name: str) -> str | None: lines = page_markdown.splitlines() target_index = next( (index for index, line in enumerate(lines) if source_name in line), None ) if target_index is None: return None caption_pattern = re.compile( r"^(?:#{1,6}\s*)?(?:\*\*)?\s*(Figure|Chart|Box|Table|Graph)\s+\w+", re.I, ) for distance in range(1, 7): for index in (target_index - distance, target_index + distance): if 0 <= index < len(lines): candidate = markdown_to_plain(lines[index]).strip() if caption_pattern.search(candidate): return candidate[:1000] return None def normalize_and_hash_image( source: Path, destination: Path ) -> tuple[dict[str, Any], tuple[int, int]]: with Image.open(source) as opened: image = ImageOps.exif_transpose(opened) if getattr(image, "is_animated", False): image.seek(0) if image.mode in {"RGBA", "LA"}: rgba = image.convert("RGBA") background = Image.new("RGBA", rgba.size, "white") background.alpha_composite(rgba) image = background.convert("RGB") else: image = image.convert("RGB") width, height = image.size destination.parent.mkdir(parents=True, exist_ok=True) image.save(destination, format="PNG", optimize=True) phash = str(imagehash.phash(image, hash_size=16)) dhash = str(imagehash.dhash(image, hash_size=8)) digest = hashlib.sha256(destination.read_bytes()).hexdigest() return ( { "sha256_normalized_png": digest, "phash_256": phash, "dhash_64": dhash, "width": width, "height": height, "color_mode": "RGB", }, (width, height), ) def classify_visual( *, page_number: int, image_size: tuple[int, int], page_size_points: tuple[float, float], caption: str | None, page_tables: list[dict[str, Any]], ) -> str: width, height = image_size rendered_width = page_size_points[0] * IMAGE_DPI / 72 rendered_height = page_size_points[1] * IMAGE_DPI / 72 coverage = (width * height) / max(1.0, rendered_width * rendered_height) if page_number == 1 and coverage >= 0.35: return "cover" if coverage >= 0.82: return "page_scan_or_full_page_visual" if caption: lowered = caption.lower() if lowered.startswith("table"): return "table_snapshot" if lowered.startswith("box"): return "box" return "figure" if page_tables and width >= 400: return "table_or_graphic" return "visual" def rewrite_and_catalog_images( *, report_id: str, chunks: list[dict[str, Any]], generated_dir: Path, figure_dir: Path, document: pymupdf.Document, final_report_dir: Path, ) -> tuple[list[dict[str, Any]], dict[int, list[str]]]: source_files = {path.name: path for path in generated_dir.glob("*") if path.is_file()} figures: list[dict[str, Any]] = [] page_assets: dict[int, list[str]] = defaultdict(list) replacement: dict[str, str] = {} ordered_sources = [] for name, source in source_files.items(): match = GENERATED_IMAGE_RE.search(name) if match: visual_order = ( int(match.group(2)) if match.group(2).isdigit() else 1_000_000 ) ordered_sources.append((int(match.group(1)), visual_order, name, source)) ordered_sources.sort() per_page_counter: Counter[int] = Counter() for page_index, _, source_name, source in ordered_sources: page_number = page_index + 1 per_page_counter[page_number] += 1 figure_id = f"{report_id}-fig-p{page_number:04d}-{per_page_counter[page_number]:03d}" destination_name = f"{figure_id}.png" destination = figure_dir / destination_name hashes, dimensions = normalize_and_hash_image(source, destination) page_markdown = chunks[page_index].get("text", "") if page_index < len(chunks) else "" caption = image_caption(page_markdown, source_name) page = document[page_index] classification = classify_visual( page_number=page_number, image_size=dimensions, page_size_points=(page.rect.width, page.rect.height), caption=caption, page_tables=chunks[page_index].get("tables", []), ) relative_asset_path = f"assets/figures/{destination_name}" replacement[source_name] = relative_asset_path page_assets[page_number].append(figure_id) figures.append( { "figure_id": figure_id, "report_id": report_id, "page": page_number, "asset_path": (final_report_dir / relative_asset_path).as_posix(), "caption": caption, "classification": classification, "render_dpi": IMAGE_DPI, "extraction_method": EXTRACTION_METHOD, **hashes, } ) def replace_reference(match: re.Match[str]) -> str: alt, target = match.groups() basename = Path(target).name return f"![{alt}]({replacement.get(basename, target)})" for chunk in chunks: chunk["text"] = IMAGE_REF_RE.sub(replace_reference, chunk.get("text", "")) return figures, page_assets def ocr_page(page: pymupdf.Page) -> str: """OCR one raster page with Tesseract without modifying the source PDF.""" pixmap = page.get_pixmap(dpi=300, colorspace=pymupdf.csRGB, alpha=False) completed = subprocess.run( ["tesseract", "stdin", "stdout", "-l", "eng", "--psm", "3"], input=pixmap.tobytes("png"), capture_output=True, check=True, timeout=180, ) return completed.stdout.decode("utf-8", errors="replace").strip() def page_scan_metrics(document: pymupdf.Document, page_number: int, plain_text: str) -> dict[str, Any]: page = document[page_number - 1] page_area = max(1.0, page.rect.width * page.rect.height) image_coverage = 0.0 for info in page.get_image_info(): bbox = pymupdf.Rect(info.get("bbox", (0, 0, 0, 0))) image_coverage = max(image_coverage, bbox.get_area() / page_area) text_characters = len(re.sub(r"\s+", "", plain_text)) return { "text_characters": text_characters, "maximum_raster_image_page_coverage": round(image_coverage, 4), "needs_ocr": text_characters < 30 and image_coverage >= 0.75, } def fallback_chunks(pdf_path: str) -> list[dict[str, Any]]: chunks: list[dict[str, Any]] = [] with pymupdf.open(pdf_path) as document: for page_index, page in enumerate(document): text = page.get_text("text", sort=True) chunks.append( { "metadata": { **document.metadata, "page_count": len(document), "page": page_index + 1, }, "toc_items": [], "tables": [], "images": page.get_image_info(), "graphics": [], "text": text, "words": [], } ) return chunks def process_one_document(job: dict[str, Any]) -> dict[str, Any]: report = job["report"] source = job["manifest"] report_id = report["report_id"] pdf_path = Path(source["local_path"]) interim_dir = Path(job["interim_dir"]) final_dir = interim_dir / report_id refresh = bool(job.get("refresh")) existing_metadata = final_dir / "document.json" if existing_metadata.exists() and not refresh: metadata = json.loads(existing_metadata.read_text(encoding="utf-8")) if ( metadata.get("source_sha256") == source["sha256"] and metadata.get("processor_version") == PROCESSOR_VERSION ): return { "report_id": report_id, "status": "existing", "page_count": metadata["page_count"], "figure_count": metadata["figure_count"], "table_count": metadata["table_count"], "needs_ocr_pages": metadata["needs_ocr_pages"], "ocr_applied_pages": metadata.get("ocr_applied_pages", []), "duration_seconds": 0.0, } started = time.perf_counter() work_parent = interim_dir / ".work" work_parent.mkdir(parents=True, exist_ok=True) work_dir = Path(tempfile.mkdtemp(prefix=f"{report_id}-", dir=work_parent)) generated_dir = work_dir / "generated" figure_dir = work_dir / "assets" / "figures" generated_dir.mkdir(parents=True) extraction_method = EXTRACTION_METHOD extraction_warnings: list[str] = [] try: try: chunks = _pymupdf4llm_chunks( str(pdf_path), write_images=True, image_path=str(generated_dir) ) except Exception as exc: extraction_method = "pymupdf-sorted-text-fallback" extraction_warnings.append(f"layout extraction failed: {type(exc).__name__}: {exc}") chunks = fallback_chunks(str(pdf_path)) with pymupdf.open(pdf_path) as document: figures, page_assets = rewrite_and_catalog_images( report_id=report_id, chunks=chunks, generated_dir=generated_dir, figure_dir=figure_dir, document=document, final_report_dir=final_dir, ) pages: list[dict[str, Any]] = [] markdown_pages: list[str] = [] total_tables = 0 needs_ocr_pages: list[int] = [] ocr_applied_pages: list[int] = [] headings: list[dict[str, Any]] = [] for page_index, chunk in enumerate(chunks): page_number = page_index + 1 markdown = chunk.get("text", "").strip() plain = markdown_to_plain(markdown) # Layout extraction may intentionally render a cover as one image. # Retain its embedded text layer in pages.jsonl for metadata and # evidence extraction, without duplicating it in the Markdown. source_text = document[page_index].get_text("text", sort=True).strip() if len(re.sub(r"\s+", "", plain)) < 30 and len(source_text) > len(plain): plain = source_text scan = page_scan_metrics(document, page_number, plain) if scan["needs_ocr"]: try: ocr_text = ocr_page(document[page_index]) if len(re.sub(r"\s+", "", ocr_text)) >= 30: plain = ocr_text markdown = ( markdown + "\n\n\n\n" + ocr_text ).strip() scan["needs_ocr"] = False scan["text_characters"] = len(re.sub(r"\s+", "", plain)) scan["ocr_applied"] = True ocr_applied_pages.append(page_number) else: needs_ocr_pages.append(page_number) except Exception as exc: needs_ocr_pages.append(page_number) extraction_warnings.append( f"OCR failed on page {page_number}: {type(exc).__name__}: {exc}" ) page_tables = chunk.get("tables", []) total_tables += len(page_tables) for level, title in HEADING_RE.findall(markdown): headings.append( { "page": page_number, "level": len(level), "title": markdown_to_plain(title), } ) pages.append( { "report_id": report_id, "page": page_number, "markdown": markdown, "text": plain, "tables": page_tables, "source_images": chunk.get("images", []), "source_graphics": chunk.get("graphics", []), "figure_ids": page_assets.get(page_number, []), **scan, } ) markdown_pages.append(f"\n\n{markdown}\n") metadata = { "report_id": report_id, "title": report.get("title"), "source_pdf": pdf_path.as_posix(), "source_sha256": source["sha256"], "source_bytes": source["bytes"], "source_page_url": report.get("source_page_url"), "processor_version": PROCESSOR_VERSION, "extraction_method": extraction_method, "pymupdf_version": pymupdf.version[0], "pymupdf4llm_version": getattr(pymupdf4llm, "__version__", None), "processed_at": utc_now(), "duration_seconds": round(time.perf_counter() - started, 3), "page_count": len(document), "text_characters": sum(len(page["text"]) for page in pages), "table_count": total_tables, "figure_count": len(figures), "needs_ocr_pages": needs_ocr_pages, "ocr_applied_pages": ocr_applied_pages, "ocr_engine": "Tesseract 5 (eng, 300 DPI)" if ocr_applied_pages else None, "headings": headings, "pdf_metadata": document.metadata, "warnings": extraction_warnings, } (work_dir / "document.md").write_text( "\n".join(markdown_pages), encoding="utf-8" ) write_jsonl(work_dir / "pages.jsonl", pages) write_jsonl(work_dir / "figures.jsonl", figures) write_json(work_dir / "document.json", metadata) shutil.rmtree(generated_dir, ignore_errors=True) if final_dir.exists(): shutil.rmtree(final_dir) os.replace(work_dir, final_dir) return { "report_id": report_id, "status": "processed", "page_count": metadata["page_count"], "figure_count": metadata["figure_count"], "table_count": metadata["table_count"], "needs_ocr_pages": needs_ocr_pages, "ocr_applied_pages": ocr_applied_pages, "duration_seconds": metadata["duration_seconds"], } except Exception: shutil.rmtree(work_dir, ignore_errors=True) raise def build_global_figure_index(interim_dir: Path) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: figures: list[dict[str, Any]] = [] for path in sorted(interim_dir.glob("*/figures.jsonl")): figures.extend(load_jsonl(path)) parent = list(range(len(figures))) def find(index: int) -> int: while parent[index] != index: parent[index] = parent[parent[index]] index = parent[index] return index def union(left: int, right: int) -> None: left_root, right_root = find(left), find(right) if left_root != right_root: parent[right_root] = left_root exact: dict[str, int] = {} phash_buckets: dict[str, list[int]] = defaultdict(list) for index, figure in enumerate(figures): digest = figure["sha256_normalized_png"] if digest in exact: union(index, exact[digest]) else: exact[digest] = index phash = figure.get("phash_256", "") if phash: phash_buckets[phash[:2]].append(index) # Compare perceptual hashes within a coarse prefix and adjacent first-byte # buckets. This bounds work while catching ordinary resize/re-encode variants. bucket_keys = sorted(phash_buckets) for key in bucket_keys: candidates = list(phash_buckets[key]) key_value = int(key, 16) for other_key in bucket_keys: if other_key <= key or abs(int(other_key, 16) - key_value) > 16: continue candidates.extend(phash_buckets[other_key]) own = phash_buckets[key] for left_pos, left in enumerate(own): left_hash = int(figures[left]["phash_256"], 16) left_ratio = figures[left]["width"] / max(1, figures[left]["height"]) for right in candidates: if right <= left: continue right_ratio = figures[right]["width"] / max(1, figures[right]["height"]) if max(left_ratio, right_ratio) / max(0.01, min(left_ratio, right_ratio)) > 1.2: continue distance = (left_hash ^ int(figures[right]["phash_256"], 16)).bit_count() if distance <= 12: union(left, right) groups: dict[int, list[int]] = defaultdict(list) for index in range(len(figures)): groups[find(index)].append(index) clusters: list[dict[str, Any]] = [] for indices in groups.values(): if len(indices) < 2: continue figure_ids = [figures[index]["figure_id"] for index in indices] cluster_id = "visual-cluster-" + hashlib.sha256( "|".join(sorted(figure_ids)).encode("utf-8") ).hexdigest()[:12] exact_cluster = len( {figures[index]["sha256_normalized_png"] for index in indices} ) == 1 clusters.append( { "cluster_id": cluster_id, "figure_ids": figure_ids, "size": len(indices), "match_type": "exact" if exact_cluster else "perceptual", "phash_distance_threshold": 12, } ) for index in indices: figures[index]["near_duplicate_cluster_id"] = cluster_id clusters.sort(key=lambda cluster: (-cluster["size"], cluster["cluster_id"])) figures.sort(key=lambda figure: figure["figure_id"]) write_jsonl(interim_dir / "figures.jsonl", figures) write_json(interim_dir / "figure_duplicate_clusters.json", clusters) return figures, clusters def process_corpus( inventory: list[dict[str, Any]], manifest: list[dict[str, Any]], *, interim_dir: Path, workers: int, refresh: bool, ) -> dict[str, Any]: source_by_id = {row["report_id"]: row for row in manifest} jobs = [ { "report": report, "manifest": source_by_id[report["report_id"]], "interim_dir": interim_dir.as_posix(), "refresh": refresh, } for report in inventory ] results: list[dict[str, Any]] = [] failures: list[dict[str, str]] = [] with concurrent.futures.ProcessPoolExecutor(max_workers=max(1, workers)) as pool: futures = {pool.submit(process_one_document, job): job for job in jobs} for future in concurrent.futures.as_completed(futures): job = futures[future] try: result = future.result() results.append(result) status = result["status"] except Exception as exc: failures.append( { "report_id": job["report"]["report_id"], "error": f"{type(exc).__name__}: {exc}", } ) status = "failed" completed = len(results) + len(failures) print( f"convert: {completed}/{len(jobs)} {status}: " f"{job['report']['report_id']}", file=sys.stderr, ) figures, clusters = build_global_figure_index(interim_dir) result_by_id = {result["report_id"]: result for result in results} ordered_results = [ result_by_id[report["report_id"]] for report in inventory if report["report_id"] in result_by_id ] write_jsonl(interim_dir / "conversion_manifest.jsonl", ordered_results) summary = { "updated_at": utc_now(), "processor_version": PROCESSOR_VERSION, "extraction_method": EXTRACTION_METHOD, "inventory_count": len(inventory), "processed_count": len(results), "failed_count": len(failures), "failures": failures, "page_count": sum(result["page_count"] for result in results), "table_count": sum(result["table_count"] for result in results), "figure_count": len(figures), "figure_near_duplicate_cluster_count": len(clusters), "needs_ocr_document_count": sum( bool(result["needs_ocr_pages"]) for result in results ), "needs_ocr_page_count": sum( len(result["needs_ocr_pages"]) for result in results ), "ocr_applied_document_count": sum( bool(result.get("ocr_applied_pages")) for result in results ), "ocr_applied_page_count": sum( len(result.get("ocr_applied_pages", [])) for result in results ), "status_counts": dict(Counter(result["status"] for result in results)), "duration_seconds_sum": round( sum(result["duration_seconds"] for result in results), 3 ), } write_json(interim_dir / "conversion_summary.json", summary) return summary def select_reports( inventory: list[dict[str, Any]], limit: int | None, ids: str | None ) -> list[dict[str, Any]]: if ids: selected_ids = {value.strip() for value in ids.split(",") if value.strip()} missing = selected_ids - {row["report_id"] for row in inventory} if missing: raise SystemExit(f"unknown report IDs: {sorted(missing)}") inventory = [row for row in inventory if row["report_id"] in selected_ids] if limit is not None: inventory = inventory[:limit] return inventory def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description="Convert IMF PDFs to interim Markdown") parser.add_argument( "command", choices=["benchmark", "convert", "all"], help="processing stage" ) parser.add_argument("--raw-dir", type=Path, default=Path("data/raw")) parser.add_argument("--interim-dir", type=Path, default=Path("data/interim")) parser.add_argument("--workers", type=int, default=min(6, os.cpu_count() or 1)) parser.add_argument("--sample-count", type=int, default=12) parser.add_argument("--limit", type=int) parser.add_argument("--ids", help="comma-separated report IDs") parser.add_argument("--refresh", action="store_true") return parser def main(argv: Sequence[str] | None = None) -> int: args = build_parser().parse_args(argv) inventory = load_jsonl(args.raw_dir / "manifests" / "inventory.jsonl") manifest = load_jsonl(args.raw_dir / "manifests" / "download_manifest.jsonl") if not inventory or not manifest: raise SystemExit("raw inventory/download manifest is missing") inventory = select_reports(inventory, args.limit, args.ids) manifest_ids = {row["report_id"] for row in manifest} missing = {row["report_id"] for row in inventory} - manifest_ids if missing: raise SystemExit(f"download manifest missing report IDs: {sorted(missing)}") if args.command in {"benchmark", "all"}: run_benchmark( inventory, manifest, interim_dir=args.interim_dir, workers=args.workers, sample_count=min(args.sample_count, len(inventory)), ) if args.command in {"convert", "all"}: summary = process_corpus( inventory, manifest, interim_dir=args.interim_dir, workers=args.workers, refresh=args.refresh, ) if summary["failed_count"]: return 1 return 0 if __name__ == "__main__": raise SystemExit(main())