File size: 8,955 Bytes
1ef1de7 | 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 | """End-to-end parsing pipeline and file exports."""
from __future__ import annotations
import json
import shutil
from pathlib import Path
from .engines import create_engine
from .errors import EngineUnavailableError, ParseError
from .markdown import render_document_markdown
from .quality import evaluate_document_quality
from .schemas import Document
from .structure import build_document
from .tables import write_table_files
_CROPPABLE_IMAGE_SUFFIXES = {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff"}
def parse_document(
input_path: str | Path,
output_dir: str | Path,
*,
engine_name: str = "auto",
model_config: str | Path | None = None,
fallback_engine: str | None = None,
fallback_model_config: str | Path | None = None,
low_confidence_threshold: float = 0.80,
) -> Document:
source = Path(input_path)
out = Path(output_dir)
if not source.exists():
raise ParseError(f"Input does not exist: {source}")
out.mkdir(parents=True, exist_ok=True)
engine_kwargs = {"model_config": model_config} if engine_name in {"candidate", "ours"} else {}
engine = create_engine(engine_name, **engine_kwargs)
engine_output = engine.recognize(source)
avg_confidence = engine_output.average_confidence
fallback_decision = _fallback_decision(
primary_engine=engine_name,
fallback_engine=fallback_engine,
fallback_model_config=fallback_model_config,
primary_average_confidence=avg_confidence,
low_confidence_threshold=low_confidence_threshold,
)
if fallback_decision is not None:
engine_output.metadata["fallback"] = fallback_decision
if fallback_decision is not None and fallback_decision["triggered"]:
try:
fallback_kwargs = {"model_config": fallback_model_config} if fallback_model_config is not None else {}
fallback = create_engine(str(fallback_decision["fallback_engine"]), **fallback_kwargs)
fallback_output = fallback.recognize(source)
fallback_decision["outcome"] = "success"
fallback_output.metadata["fallback"] = fallback_decision
engine_output = fallback_output
except EngineUnavailableError as exc:
fallback_decision["outcome"] = "error"
fallback_decision["error"] = str(exc)
engine_output.metadata["fallback"] = fallback_decision
engine_output.metadata["fallback_error"] = str(exc)
except Exception as exc:
fallback_decision["outcome"] = "error"
fallback_decision["error"] = f"{type(exc).__name__}: {exc}"
engine_output.metadata["fallback"] = fallback_decision
engine_output.metadata["fallback_error"] = f"{type(exc).__name__}: {exc}"
document = build_document(str(source), engine_output)
quality = evaluate_document_quality(document)
document.metadata["quality"] = quality.to_dict()
export_document(document, out, source)
return document
def _fallback_decision(
*,
primary_engine: str,
fallback_engine: str | None,
fallback_model_config: str | Path | None,
primary_average_confidence: float | None,
low_confidence_threshold: float,
) -> dict[str, object] | None:
if not fallback_engine and fallback_model_config is None:
return None
resolved_fallback_engine = fallback_engine or "candidate"
decision: dict[str, object] = {
"configured": True,
"triggered": False,
"outcome": "not_triggered",
"primary_engine": primary_engine,
"fallback_engine": resolved_fallback_engine,
"fallback_model_config": str(fallback_model_config) if fallback_model_config is not None else None,
"primary_average_confidence": primary_average_confidence,
"threshold": low_confidence_threshold,
}
if fallback_model_config is None and resolved_fallback_engine.lower() == primary_engine.lower():
decision["reason"] = "same_engine"
return decision
if primary_average_confidence is None:
decision["reason"] = "confidence_not_available"
return decision
if primary_average_confidence >= low_confidence_threshold:
decision["reason"] = "confidence_above_threshold"
return decision
decision["triggered"] = True
decision["outcome"] = "triggered"
decision["reason"] = "average_confidence_below_threshold"
return decision
def export_document(document: Document, output_dir: Path, source_path: Path) -> None:
tables_dir = output_dir / "tables"
figures_dir = output_dir / "figures"
for table in document.tables:
write_table_files(table, tables_dir)
figures_dir.mkdir(parents=True, exist_ok=True)
for figure in document.figures:
_export_figure_image(figure, figures_dir, source_path)
(figures_dir / "metadata.json").write_text(
json.dumps([figure.to_dict() for figure in document.figures], ensure_ascii=False, indent=2) + "\n",
encoding="utf-8",
)
quality = document.metadata.get("quality")
if isinstance(quality, dict):
(output_dir / "quality.json").write_text(json.dumps(quality, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
(output_dir / "document.json").write_text(
json.dumps(document.to_dict(), ensure_ascii=False, indent=2) + "\n",
encoding="utf-8",
)
(output_dir / "document.md").write_text(render_document_markdown(document), encoding="utf-8")
def _export_figure_image(figure: object, figures_dir: Path, source_path: Path) -> None:
image_path = getattr(figure, "image_path", None)
if image_path:
source_figure = Path(str(image_path))
if not source_figure.is_absolute():
source_base = source_path if source_path.is_dir() else source_path.parent
source_figure = source_base / source_figure
if source_figure.exists():
target = figures_dir / source_figure.name
shutil.copy2(source_figure, target)
setattr(figure, "image_path", str(target))
return
_record_figure_export_warning(figure, f"figure image_path does not exist: {source_figure}")
_crop_figure_from_source(figure, figures_dir, source_path)
def _crop_figure_from_source(figure: object, figures_dir: Path, source_path: Path) -> None:
source_image = _source_image_for_figure(figure, source_path)
if source_image is None:
return
try:
from PIL import Image
except ImportError as exc:
_record_figure_export_warning(figure, f"Pillow is required to crop figure image: {exc}")
return
try:
bbox = getattr(figure, "bbox")
left = max(0, int(round(bbox.x)))
top = max(0, int(round(bbox.y)))
right = max(left, int(round(bbox.right)))
bottom = max(top, int(round(bbox.bottom)))
with Image.open(source_image) as image:
right = min(right, image.width)
bottom = min(bottom, image.height)
if right <= left or bottom <= top:
_record_figure_export_warning(figure, f"figure bbox is outside source image bounds: {bbox.to_list()}")
return
target = figures_dir / f"{getattr(figure, 'figure_id', 'figure')}.png"
image.crop((left, top, right, bottom)).save(target)
setattr(figure, "image_path", str(target))
metadata = getattr(figure, "metadata")
if isinstance(metadata, dict):
metadata["export_source"] = "source_crop"
except Exception as exc:
_record_figure_export_warning(figure, f"{type(exc).__name__}: {exc}")
def _source_image_for_figure(figure: object, source_path: Path) -> Path | None:
if source_path.is_dir():
page_paths = [
path
for path in sorted(source_path.iterdir())
if path.is_file() and path.suffix.lower() in _CROPPABLE_IMAGE_SUFFIXES
]
if not page_paths:
_record_figure_export_warning(figure, f"page bundle has no croppable image files: {source_path}")
return None
page_index = getattr(figure, "page_index", 0)
if not isinstance(page_index, int) or page_index < 0 or page_index >= len(page_paths):
_record_figure_export_warning(figure, f"figure page_index is outside page bundle bounds: {page_index}")
return None
return page_paths[page_index]
if source_path.suffix.lower() not in _CROPPABLE_IMAGE_SUFFIXES:
_record_figure_export_warning(figure, f"source image format cannot be cropped: {source_path.suffix or '<none>'}")
return None
return source_path
def _record_figure_export_warning(figure: object, message: str) -> None:
metadata = getattr(figure, "metadata", None)
if isinstance(metadata, dict):
warnings = metadata.setdefault("export_warnings", [])
if isinstance(warnings, list):
warnings.append(message)
|