@youweichen/pi-harness 1.0.0 → 1.2.0

package/dist/server/document-conversion/python/bridge.py

@@ -0,0 +1,424 @@
+"""Versioned, local-only Docling worker. stdout is one JSON response; logs use stderr."""
+import hashlib
+import importlib.metadata
+import json
+import logging
+import os
+from pathlib import Path
+import platform
+import re
+import shutil
+import sys
+import tempfile
+from contextlib import redirect_stdout
+from concurrent.futures import ThreadPoolExecutor
+
+VERSION = "2.136.0"
+PROFILE = "docling-cpu-zh-v1"
+MODEL_REVISIONS = {
+	"docling-project/docling-layout-heron": "8f39ad3c0b4c58e9c2d2c84a38465abf757272d8",
+	"docling-project/docling-models": "fc0f2d45e2218ea24bce5045f58a389aed16dc23",
+	"docling-project/CodeFormulaV2": "ecedbe111d15c2dc60bfd4a823cbe80127b58af4",
+}
+logging.basicConfig(stream=sys.stderr, level=logging.WARNING)
+# Hugging Face's HTTP downloader respects the host's proxy configuration and can
+# resume downloads without requiring Xet's separate network transport.
+os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
+
+
+def emit(value):
+	print(json.dumps(value, ensure_ascii=False), flush=True)
+
+
+def sha256(path):
+	hash_value = hashlib.sha256()
+	with path.open("rb") as stream:
+		for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+			hash_value.update(chunk)
+	return hash_value.hexdigest()
+
+
+def parser_assets():
+	return {path.name: sha256(path) for path in sorted(Path(__file__).parent.glob("*.py"))}
+
+
+LOADED_ASSET_HASHES = parser_assets()
+
+
+def offline():
+	for name in ("HF_HUB_OFFLINE", "TRANSFORMERS_OFFLINE", "HF_DATASETS_OFFLINE", "HF_HUB_DISABLE_TELEMETRY"):
+		os.environ[name] = "1"
+	# Protect all optional backends as well as Hugging Face. Conversion never opens
+	# TCP connections, including those to loopback or inherited proxy endpoints.
+	def audit(event, args):
+		if event in ("socket.connect", "socket.getaddrinfo", "socket.sendto"):
+			raise PermissionError("Network access is disabled during document conversion")
+	sys.addaudithook(audit)
+
+
+def doctor(root):
+	missing = []
+	warnings = []
+	try:
+		actual = importlib.metadata.version("docling")
+		if actual != VERSION:
+			missing.append("Expected Docling " + VERSION + "; found " + actual)
+	except importlib.metadata.PackageNotFoundError:
+		actual = None
+		missing.append("Docling is not installed")
+	if sys.version_info[:2] != (3, 12):
+		missing.append("This runtime profile requires Python 3.12")
+	try:
+		receipt = json.loads((root / "ready.json").read_text("utf-8"))
+		if receipt.get("profile") != PROFILE or receipt.get("docling") != VERSION or not receipt.get("smokePassed"):
+			missing.append("Runtime qualification receipt is invalid")
+		if receipt.get("parserAssets") != parser_assets():
+			missing.append("Parser implementation changed; run /pdf-md setup to requalify the offline profile")
+		for relative, metadata in receipt.get("models", {}).items():
+			path = root / "models" / relative
+			if not path.is_file() or path.stat().st_size != metadata["size"] or sha256(path) != metadata["sha256"]:
+				missing.append("Missing or changed model: " + relative)
+		for name, version in receipt.get("packages", {}).items():
+			try:
+				if importlib.metadata.version(name) != version:
+					missing.append("Runtime dependency changed: " + name)
+			except importlib.metadata.PackageNotFoundError:
+				missing.append("Runtime dependency missing: " + name)
+		if not receipt.get("models"):
+			missing.append("No model artifacts were recorded")
+	except (OSError, ValueError, KeyError):
+		missing.append("Run /pdf-md setup to download models and qualify offline conversion")
+	return {"ready": not missing, "parserVersion": actual, "missing": missing, "warnings": warnings}
+
+
+def converter(root):
+	from docling.datamodel.accelerator_options import AcceleratorDevice, AcceleratorOptions
+	from docling.datamodel.base_models import InputFormat
+	from docling.datamodel.pipeline_options import (
+		CodeFormulaVlmOptions, OcrMode, PdfPipelineOptions, RapidOcrOptions,
+		TableFormerMode, TableStructureOptions,
+	)
+	from docling.datamodel.vlm_engine_options import TransformersVlmEngineOptions
+	from docling.document_converter import DocumentConverter, PdfFormatOption
+	options = PdfPipelineOptions(
+		artifacts_path=root / "models",
+		enable_remote_services=False,
+		allow_external_plugins=False,
+		accelerator_options=AcceleratorOptions(device=AcceleratorDevice.CPU, num_threads=4),
+		do_ocr=True,
+		ocr_options=RapidOcrOptions(backend="onnxruntime", lang=["ch"], model_size="small", mode=OcrMode.PDF_AWARE_LAYOUT_REGIONS),
+		do_table_structure=True,
+		table_structure_options=TableStructureOptions(mode=TableFormerMode.ACCURATE, do_cell_matching=True),
+		do_code_enrichment=True,
+		do_formula_enrichment=True,
+		code_formula_options=CodeFormulaVlmOptions.from_preset("codeformulav2", engine_options=TransformersVlmEngineOptions(
+			device=AcceleratorDevice.CPU, torch_dtype="float32", quantized=False, compile_model=False,
+		)),
+		generate_picture_images=True,
+		generate_page_images=True,
+	)
+	options.heading_hierarchy_options.enabled = True
+	return DocumentConverter(allowed_formats=[InputFormat.PDF, InputFormat.DOCX, InputFormat.PPTX, InputFormat.XLSX], format_options={InputFormat.PDF: PdfFormatOption(pipeline_options=options)})
+
+
+def extract_blocks(document, suffix):
+	from docling_core.types.doc import TableItem
+	blocks = []
+	head = None
+	for item, level in document.iterate_items():
+		label = str(getattr(item, "label", ""))
+		text = getattr(item, "text", "")
+		if isinstance(item, TableItem):
+			text = item.export_to_markdown(doc=document)
+		if not text:
+			continue
+		if "section_header" in label or "title" in label:
+			head = text
+		locator = {"heading": head} if head else {}
+		provenance = [p.model_dump(mode="json") for p in getattr(item, "prov", [])]
+		if provenance:
+			page = provenance[0].get("page_no")
+			if page:
+				locator["slide" if suffix == ".pptx" else "page"] = page
+		blocks.append({"id": getattr(item, "self_ref", "block-" + str(len(blocks) + 1)), "text": text, "locator": locator, "provenance": provenance, "kind": label})
+	return blocks
+
+
+def excel_provenance(source, warnings):
+	from openpyxl import load_workbook
+	formulas = load_workbook(source, read_only=True, data_only=False)
+	values = load_workbook(source, read_only=True, data_only=True)
+	blocks = []
+	metadata = []
+	try:
+		for sheet in formulas:
+			cached = values[sheet.title]
+			for row, cached_row in zip(sheet.iter_rows(), cached.iter_rows()):
+				for cell, cached_cell in zip(row, cached_row):
+					if cell.value is None:
+						continue
+					value = cached_cell.value
+					is_formula = cell.data_type == "f"
+					if is_formula:
+						metadata.append({"sheet": sheet.title, "cell": cell.coordinate, "formula": str(cell.value), "cachedValue": value})
+						if value is None:
+							warnings.append("Missing formula cache: " + sheet.title + "!" + cell.coordinate)
+					blocks.append({"id": "cell-" + str(len(blocks) + 1), "text": str(value) if value is not None else "[formula result unavailable]", "locator": {"sheet": sheet.title, "cell": cell.coordinate}})
+		if metadata:
+			warnings.append("Spreadsheet formula results are saved cached values; no formulas were evaluated and cache freshness cannot be verified.")
+	finally:
+		formulas.close()
+		values.close()
+	return blocks, metadata
+
+
+def convert(root, request, engine=None):
+	from docling_core.types.doc import ImageRefMode, TableItem
+	source, output = Path(request["inputPath"]), Path(request["outputDir"])
+	output.mkdir(parents=True, exist_ok=True)
+	assets = output / "assets"
+	assets.mkdir(exist_ok=True)
+	warnings = []
+	enrichment_failed = False
+	material_defect = False
+	native_verified_ids = set()
+	expected_pages = None
+	if source.suffix.lower() == ".pdf":
+		import pypdfium2
+		pdf = pypdfium2.PdfDocument(source)
+		try:
+			expected_pages = len(pdf)
+			native = []
+			for index in range(expected_pages):
+				page = pdf[index]
+				try:
+					textpage = page.get_textpage()
+					try:
+						native.append({"page": index + 1, "text": textpage.get_text_range()})
+					finally:
+						textpage.close()
+				finally:
+					page.close()
+			(output / "pdf-text-layer.json").write_text(json.dumps({"sourceHash": request["sourceHash"], "pages": native}, ensure_ascii=False), "utf-8")
+		finally:
+			pdf.close()
+	class Capture(logging.Handler):
+		def emit(self, record):
+			nonlocal enrichment_failed
+			if record.levelno >= logging.ERROR:
+				enrichment_failed = True
+			if record.levelno >= logging.WARNING and len(warnings) < 100:
+				warnings.append(record.getMessage()[:1000])
+	capture = Capture()
+	logging.getLogger().addHandler(capture)
+	try:
+		result = (engine or converter(root)).convert(source, raises_on_error=False)
+	finally:
+		logging.getLogger().removeHandler(capture)
+	state = str(getattr(result.status, "value", result.status))
+	if state not in ("success", "partial_success"):
+		raise RuntimeError("Docling conversion failed: " + state + "; " + "; ".join(str(error) for error in result.errors))
+	for error in result.errors:
+		warnings.append(str(error))
+	material_defect = bool(result.errors)
+	document = result.document
+	if source.suffix.lower() == ".pdf":
+		from native_code import recover_native_code
+		recovery = recover_native_code(document, source)
+		native_verified_ids = {item["id"] for item in recovery["recoveries"]}
+		warnings.extend(recovery["warnings"])
+		material_defect = material_defect or recovery["needs_review"]
+		(output / "native-code.json").write_text(json.dumps({"sourceHash": request["sourceHash"], **recovery}, ensure_ascii=False, indent=2), "utf-8")
+	if expected_pages is not None and len(result.pages) != expected_pages:
+		warnings.append("Incomplete PDF page coverage: expected " + str(expected_pages) + ", received " + str(len(result.pages)))
+		material_defect = True
+	document.save_as_markdown(output / "document.md", artifacts_dir=assets, image_mode=ImageRefMode.REFERENCED)
+	document.save_as_json(output / "structure.json", artifacts_dir=assets, image_mode=ImageRefMode.REFERENCED)
+	# Staging directories are renamed by the host. Never persist absolute staging
+	# URIs even if a future serializer changes its reference-path default.
+	markdown_path = output / "document.md"
+	markdown = markdown_path.read_text("utf-8").replace(output.as_uri() + "/", "").replace(str(output) + os.sep, "")
+	markdown_path.write_text(markdown, "utf-8")
+	def relative_images(value):
+		if isinstance(value, dict):
+			for key, child in value.items():
+				if key in ("uri", "url") and isinstance(child, str):
+					value[key] = child.replace(output.as_uri() + "/", "").replace(str(output) + os.sep, "")
+				else:
+					relative_images(child)
+		elif isinstance(value, list):
+			for child in value:
+				relative_images(child)
+	structure = json.loads((output / "structure.json").read_text("utf-8"))
+	relative_images(structure)
+	(output / "structure.json").write_text(json.dumps(structure, ensure_ascii=False, indent=2), "utf-8")
+	blocks = extract_blocks(document, source.suffix.lower())
+	for block in blocks:
+		if "code" in block.get("kind", "") and len(block["text"]) >= 6000 and block["id"] not in native_verified_ids:
+			warnings.append("Long recognized code block may reach the parser token limit; compare " + block["id"] + " with the original PDF.")
+			material_defect = True
+		if source.suffix.lower() == ".pdf" and "code" not in block.get("kind", "") and re.match(r"^\s*(?:(?:async\s+)?def\s+\w+\([^)]*\)\s*:|(?:export\s+)?(?:async\s+)?function\s+\w*\s*\()", block["text"]):
+			warnings.append("Possible code region was parsed as plain text: " + block["id"] + "; compare the original PDF for line breaks and indentation.")
+			material_defect = True
+	formula_metadata = []
+	if source.suffix.lower() == ".xlsx":
+		blocks, formula_metadata = excel_provenance(source, warnings)
+	for index, table in enumerate(document.tables):
+		# Preserve merged cells in the native JSON and an HTML companion; GFM cannot
+		# represent row/column spans. CSV is provided for machine validation.
+		table.export_to_dataframe(doc=document).to_csv(assets / ("table-" + str(index + 1) + ".csv"), index=False)
+		(assets / ("table-" + str(index + 1) + ".html")).write_text(table.export_to_html(doc=document), encoding="utf-8")
+		cells = getattr(table.data, "table_cells", [])
+		if any(getattr(cell, "row_span", 1) > 1 or getattr(cell, "col_span", 1) > 1 for cell in cells):
+			warnings.append("Table " + str(index + 1) + " contains merged cells; Markdown is flattened. Refer to structure.json and table HTML/CSV.")
+			material_defect = True
+		try:
+			picture = table.get_image(document)
+			if picture:
+				picture.save(assets / ("table-" + str(index + 1) + ".png"))
+		except Exception:
+			warnings.append("Table " + str(index + 1) + " has no source image crop.")
+	if source.suffix.lower() == ".pdf":
+		warnings.append("OCR and code recognition require review; code enrichment covers detected regions only and long code blocks can be truncated.")
+	if not blocks:
+		warnings.append("No readable text blocks were extracted.")
+	status = "partial" if state == "partial_success" or not blocks or enrichment_failed or material_defect else "complete"
+	if any(warning.startswith("Missing formula cache:") for warning in warnings):
+		status = "partial"
+	(output / "source-map.json").write_text(json.dumps({"schemaVersion": 1, "source": str(source), "sourceHash": request["sourceHash"], "blocks": blocks, "formulas": formula_metadata}, ensure_ascii=False, indent=2, default=str), "utf-8")
+	return {"status": status, "warnings": list(dict.fromkeys(warnings))}
+
+
+def smoke(root):
+	from fixtures import make_fixtures
+	folder = Path(tempfile.mkdtemp(prefix="qualification-", dir=root))
+	try:
+		files = make_fixtures(folder)
+		engine = converter(root)
+		for source, expected in files:
+			print("Offline fixture: " + source.name, file=sys.stderr, flush=True)
+			output = folder / (source.stem + "-output")
+			response = convert(root, {"inputPath": str(source), "outputDir": str(output), "sourceHash": sha256(source)}, engine)
+			text = (output / "document.md").read_text("utf-8")
+			structure = json.loads((output / "structure.json").read_text("utf-8"))
+			source_map = json.loads((output / "source-map.json").read_text("utf-8"))
+			known_short_code_limit = source.name == "digital-short.pdf" and response["status"] == "partial" and any(warning.startswith("Possible code region was parsed as plain text:") for warning in response["warnings"])
+			ambiguous_code_is_partial = source.name == "digital-ambiguous.pdf" and response["status"] == "partial" and any(warning.startswith("Native code layout could not be verified") for warning in response["warnings"])
+			if source.name == "digital-ambiguous.pdf" and not ambiguous_code_is_partial:
+				raise RuntimeError("Ambiguous PDF code characters were not reported for review")
+			if (response["status"] != "complete" and not known_short_code_limit and not ambiguous_code_is_partial) or expected not in text:
+				raise RuntimeError("Offline conversion fixture failed: " + source.name)
+			if source.name in ("digital.pdf", "digital-short.pdf") and not known_short_code_limit:
+				for marker in ("公司技术资料", "Name", "Value", "calculate_total", "return"):
+					if marker not in text:
+						raise RuntimeError("PDF structure fixture omitted " + marker)
+				if not structure.get("tables"):
+					raise RuntimeError("PDF table structure was not detected")
+				if "```" not in text:
+					raise RuntimeError("PDF code block was not recognized; this profile has not passed code fidelity qualification")
+				if "def calculate_total(values):\n    return sum(values)" not in text:
+					raise RuntimeError("PDF code text or indentation did not survive recognition")
+			if source.name == "scanned.pdf":
+				for marker in ("Name", "Value", "Total", "123"):
+					if marker not in text:
+						raise RuntimeError("OCR table fixture omitted " + marker)
+				if not structure.get("tables"):
+					raise RuntimeError("OCR table structure was not detected")
+				if not all(marker in re.sub(r"\s+", "", text) for marker in ("公司资料", "扫描表格")):
+					raise RuntimeError("Chinese OCR text was not recognized")
+			if known_short_code_limit:
+				native = json.loads((output / "pdf-text-layer.json").read_text("utf-8"))
+				if not all(marker in native["pages"][0]["text"] for marker in ("def calculate_total(values):", "return sum(values)")):
+					raise RuntimeError("Unrecognized short code lost its original text-layer evidence")
+			if source.suffix == ".pdf":
+				expected_cells = {(0, 0): "Name", (0, 1): "Value", (1, 0): "Total", (1, 1): expected}
+				grids = [{(cell["start_row_offset_idx"], cell["start_col_offset_idx"]): cell["text"].strip() for cell in table["data"]["table_cells"]} for table in structure.get("tables", [])]
+				if not any(all(grid.get(position) == value for position, value in expected_cells.items()) for grid in grids):
+					raise RuntimeError("PDF fixture table cell values or row/column positions are incorrect")
+			if source.suffix == ".pdf" and not all(block["locator"].get("page") == 1 for block in source_map["blocks"]):
+				raise RuntimeError("PDF source blocks lost page locators")
+			if source.suffix == ".xlsx" and not all(block["locator"].get("sheet") and block["locator"].get("cell") for block in source_map["blocks"]):
+				raise RuntimeError("Spreadsheet source blocks lost cell locators")
+			if source.suffix == ".pptx" and not all(block["locator"].get("slide") == 1 for block in source_map["blocks"]):
+				raise RuntimeError("Presentation source blocks lost slide locators")
+	except Exception as error:
+		raise RuntimeError(str(error) + "; qualification artifacts retained at " + str(folder)) from error
+	shutil.rmtree(folder)
+	return [source.name for source, expected in files]
+
+
+def setup(root):
+	if importlib.metadata.version("docling") != VERSION:
+		raise RuntimeError("Unexpected Docling version")
+	(root / "ready.json").unlink(missing_ok=True)
+	from docling.utils.model_downloader import download_models
+	from huggingface_hub import snapshot_download
+	def fetch_model(repo):
+		print("Downloading CPU profile model: " + repo, file=sys.stderr, flush=True)
+		# The generic downloader includes both ONNX/Torch layout and fast/accurate
+		# tables. This profile uses the Torch layout and accurate table model only.
+		patterns = ["model_artifacts/tableformer/accurate/*", "README.md", "config.json"] if repo.endswith("/docling-models") else None
+		snapshot_download(repo_id=repo, revision=MODEL_REVISIONS[repo], local_dir=root / "models" / repo.replace("/", "--"), allow_patterns=patterns)
+		print("Downloaded CPU profile model: " + repo, file=sys.stderr, flush=True)
+	def fetch_ocr():
+		print("Downloading Chinese/English OCR models", file=sys.stderr, flush=True)
+		download_models(output_dir=root / "models", with_layout=False, with_tableformer=False, with_code_formula=False, with_picture_classifier=False, rapidocr_models=["onnxruntime:ch"], rapidocr_model_size="small", progress=True)
+	def report_failure(future):
+		if future.exception():
+			print("Model setup failed: " + str(future.exception()), file=sys.stderr, flush=True)
+	with ThreadPoolExecutor(max_workers=4) as pool:
+		futures = [pool.submit(fetch_model, repo) for repo in MODEL_REVISIONS] + [pool.submit(fetch_ocr)]
+		for future in futures:
+			future.add_done_callback(report_failure)
+		for future in futures:
+			future.result()
+	models = {}
+	for path in sorted((root / "models").rglob("*")):
+		if path.is_file() and ".cache" not in path.parts:
+			models[str(path.relative_to(root / "models"))] = {"sha256": sha256(path), "size": path.stat().st_size}
+	offline()
+	passed = smoke(root)
+	if parser_assets() != LOADED_ASSET_HASHES:
+		raise RuntimeError("Parser implementation changed during setup; retry qualification")
+	packages = {dist.metadata["Name"]: dist.version for dist in importlib.metadata.distributions()}
+	receipt = {"profile": PROFILE, "docling": VERSION, "python": platform.python_version(), "platform": platform.platform(), "parserAssets": LOADED_ASSET_HASHES, "modelRevisions": MODEL_REVISIONS, "models": models, "packages": packages, "smokePassed": passed}
+	(root / "ready.json").write_text(json.dumps(receipt, indent=2, sort_keys=True), "utf-8")
+	return doctor(root)
+
+
+def main():
+	action, root = sys.argv[1], Path(sys.argv[2])
+	if action == "setup":
+		with redirect_stdout(sys.stderr):
+			response = setup(root)
+		emit(response)
+	else:
+		offline()
+		if action == "doctor":
+			emit(doctor(root))
+		elif action == "convert":
+			request = json.load(sys.stdin)
+			with redirect_stdout(sys.stderr):
+				response = convert(root, request)
+			emit(response)
+		elif action == "serve":
+			engine = None
+			for line in sys.stdin:
+				try:
+					with redirect_stdout(sys.stderr):
+						if engine is None:
+							engine = converter(root)
+						response = convert(root, json.loads(line), engine)
+					emit(response)
+				except Exception as error:
+					emit({"error": str(error)})
+		elif action == "smoke":
+			with redirect_stdout(sys.stderr):
+				passed = smoke(root)
+			emit({"passed": passed})
+		else:
+			raise ValueError("Unknown operation")
+
+
+if __name__ == "__main__":
+	main()

package/dist/server/document-conversion/python/fixtures.py

@@ -0,0 +1,201 @@
+"""Small synthetic fixtures; these verify engine wiring, not real-document fidelity."""
+from pathlib import Path
+from base64 import b64decode
+from io import BytesIO
+
+# Self-authored raster caption keeps the Chinese OCR check independent of OS fonts.
+CHINESE_CAPTION_PNG = (
+	"iVBORw0KGgoAAAANSUhEUgAAAa4AAAA8CAIAAACxTskxAAAegUlEQVR42u1dZ1gUV9uepYgsiIii2AVsoIIVFSwgIMUCEV+NEWKi"
+	"gmBDMKBIFLGESwFRQBGNSoIGX5RLUQELFlBiFBSVKgLSO7vALkvb8v04n+eazO7Ozi6L0Tfn/sE1zJw5c+bszD3PeSpNIBBgCAgI"
+	"CP9uKKApQEBAQFBCU4CA8OVj69atysrKbm5uU6ZMQbOBpMJ/Ej/99JOjo2NsbGx+fj6Px5Njz/v27Zs5c+by5cudnJx+/fVXqc69"
+	"cuXKuHHjFixYYGtru3r16qqqKnmNau/evQkJCQ0NDT09PZ9hegUCgb6+vpmZ2dKlS+3t7W/evCmyWVJSEo1Go9FoampqWVlZ+EOL"
+	"Fi0Ch1asWCHfsf3888/6+voLFixYtmyZr6+vvLotKChQVVXV0tJSU1MbNWpUZ2enuJY8Hi8+Pj48PHzq1KkjR468evUqeh/75BFE"
+	"kIi2trYBAwbASfvll1/k2HlERAToduTIkc3NzVKdm5OTA0cVHBwsx1F5eHjAnv/zn/98hkmeNGkSuNycOXNaWlpEtnn9+jVoY2pq"
+	"Sji0bt06cCg5OVm+AwsNDYVT8fr1a3l1i+c+8t/u3r17sKWFhUV7ezt6JeUO6aRCNptNk4Tly5fLzMuOjo40eYPJZJJc8cGDB5aW"
+	"lmlpaeQDO336NIvFAtuRkZF+fn5y/Bppa2uDDTMzMy0tLXHNcnNz16xZ09XVhd85atQouL148WI5jmrIkCFgQ09P77fffvsMX+XB"
+	"gweDjR07dgwcOFBkG01NTbBBo9EIhzQ0NMQd6iUGDRoENuh0+vTp0+XVrYqKirq6OtjW0dEhafnHH3/AkcTFxdHpdCTDfQUL5D//"
+	"/PPLsUorKirC51gYNTU1zs7Ojx49Mjc3Nzc3F0eIZWVlhw8fBtt79uzZtm2byGZ8Pr+np6ejo4PFYjGZzIaGBnEs3NLSEhYWBoUC"
+	"+GQrKyuDDQ6HM3PmzLNnz5aUlIA9Fy9eNDExuXbt2r59+/BdDRw4EL758qUASEZTpkxRVVUlHK2oqHj8+HFhYWFNTU1bW1tXVxeP"
+	"x4O/u0Ag6O7uZrFYdXV1BQUFqampFy5cIIyc5Ip4AZwANTU1cYeEBykvQMJSVVWV7ySTPJwQTCYzPj4ebB88eHDYsGGItv6BBXJ7"
+	"e7uFhUVcXFxXV5dAIICSETnevXsnm4zq4OAg37uj0+kkl3N1dSW0t7e3LywsxLfh8XjW1tayXf3MmTPCF/X29gbv89WrV8GeBw8e"
+	"gPbr168He/BasMuXLwsEgpMnT/7/t0tB4fnz5/gOITtkZmbKcb1w+vRp0K2Dg4Pw0djYWGlnQ09Pj/yKq1atAi1v3LgBdzY0NKSn"
+	"pxcVFTU1NXE4nObmZihBE07fs2cPOJSSksLj8fBcnJGRQbIe7yP4+/tT1wnExsaKaxMSEkL9ovr6+nw+H612ZYAEKoTaa3V1dWtr"
+	"awaDIa4ln88fMWIEaHzgwIF/9q78/f2hEEHSjMvlRkdHE9YmdDq9trYWtpF5LdyvX7+mpibhi65evRrSLtjz9OlTAhWGh4eDPebm"
+	"5nB6LSwsoJjW09MDO4TClHyp8MKFC/KlwtmzZ5Nfcf369cJUmJKS0ntWGjt27JdJhdOmTSOnQj6fP378eOoXDQ0NRaTWJ7pCSIVd"
+	"XV3btm0jkedpNJq9vT3Y/losXIqKim5ubh8+fPD29oYLn4CAAEiOERERQUFBJIs1AwMDXV3dESNGaGlp0el0RUVFeNTOzg4qv/DY"
+	"vHkz2Lh//35TU5PInh8+fAjNuHB6o6Ki+vXrh2FYXl4eFNkwDFNS6hOPKLl3K1HDBfUD/x5InOTExMTi4mKKvQ0YMGDTpk1opSt/"
+	"XSGLxbp27RrY9vPzk7h6/eabb8BGUVHR3bt3v5YpUFdXDw0NTU5OHjp0qJ2dnY+PD9h/8uTJnTt3Yp/sldBsV1hYCHULT58+LS0t"
+	"ra6ubm5ubm9vf/78OezWxcVF5OWsra2BrYPL5YoUedhs9v379zEMGz16NH5tPmnSJDiewMBABoMhx0l4/fr127dvq6qqWltbu7u7"
+	"+Xw+XikGFpuNjY0lJSUZGRlsNtvCwuLp06cFBQWVlZWNjY0tLS0cDqerq6unp4fL5fJxsLGxgWKyxC/T5/zdo6Ojnzx5kpWVVVBQ"
+	"AH/EtrY2cCNcLpfH44FbuHHjBjTsgD08Hq+np6e7u5vD4bBYLAaDUV9fX1FRUVRUlJOT8/z58wcPHgg/AF1dXUlJSW/evKmrq2Oz"
+	"2VwuF04yn89vbW2trKzMzs6+c+cOl8sFTwh+UfLy5UuR4szatWtBA1dXV3HmJoRe6QrPnj0L2owYMYLNZkuUMLlc7siRI7FP1swv"
+	"f4FMQG1tbWNjI9gODg6GUzR9+nQmkwmb7dixAx7av38/vgdbW1vsk6Gzs7NT3IUgo61Zs0Z4gRwTEwP+9fHxIZzIYDCgYP7TTz+B"
+	"nVD27M0CGRIWRs0hToaebWxsCIfS09Nfv35dWVnZ0tLS3d3t5uYGWl6/fp3BYBQXFz98+LC6ujojI6OoqKiurg7Yo8TpCuGPnpyc"
+	"3NPTAxSLpaWlmZmZ9+/f783jhKfC3vTT2NhIcYZZLJZAIIiKisLv/P7774X7LCgoUFBQACIhfHoRZIBY+ZzL5UI68PPzI7Hc4b/q"
+	"mzdvDgwMxDAsLS3t5s2bjo6OVH749vb2pKQkTU1NTU1NdXV1dXV1Op3er18/ZWVlZWVlBQUF8GPjbbXAXAue+La2tubm5vr6emtr"
+	"ayrjFAe80tDLy2vatGk7d+5UVVVNTU2FPhwfPnyIjo4Gyz0OhxMcHLxu3ToDAwNwF5MnT1ZWVi4pKbGyslJRURF3IScnp/DwcHV1"
+	"deiwggekwqVLlwobHHfu3BkYGEin0+FX5+uFl5fXq1evhPdDdSogBVNTU7zILLFbGo2mpKSkpKQEHJh1dXVJGpeUlOTn52tqampo"
+	"aIBnr3///uDBU1RUBP5YIgUIIBt2d3eDh5DNZrNYrJaWltbWVicnp95PDpvNPnjwIH7P1atXDx06NHbsWPxOT09PPp+PYdju3btF"
+	"Pk4IvZUKL168CEXCjo4Oisza3NwMPSFGjRrV1tZG5ayPHz/K5V4+fvzYG6kQuIAEBQUdPHgQ/Mtms/E+z11dXbNnzwY9JyQkAH9A"
+	"IyMjvMxIBTwe7/r16xwOR5zZpKys7Pz587ABQbJwcnKCd/pVS4WzZs2iKB9BQB8GEqkwJSWF+vAIklefvlNSSYXQxZ1Op0OP0R9+"
+	"+AHfIfT3HD16NGGiEORjQWYymdB96dSpU1L1+PPPP8NfdOXKlVRM+18IFT569AhY9IRfM7D8h197W1tbfBCCiYlJfX29zL+BMBVK"
+	"BblQYWZmZnZ2dkVFBZPJ7Ozs5HK50Ebs4ODQ2dnJZDJramoKCwvT0tKkeusQFeLDS27evPnXX38VFxc3Nzd3dnYaGxuDU3777Tc2"
+	"m11TU/Pu3bt79+7h4w5jY2PfvXsHhFMajfbs2TPQW35+PnB4pNFoqampiMv6hAqh1kZXV1dYJKypqSF3RcTL8N7e3l8+Fb548cLK"
+	"ygq/wiovLyd8G6AeUEdHp6qqCpCjiYkJ3JmYmEhFar5z505mZmZFRUVLSwvwTMZTITBQ1NfXl5aWvnr1KiUlBSqAeDyeSIdNuVAh"
+	"ibuMSGcauVDhvXv3nj179uHDh8bGRg6Hs2XLFtDy2rVrDQ0N+fn5SUlJeLchILaHhYWFhYXFx8cLax6DgoKCgoJKS0u/TCokoLq6"
+	"Gmp+8M40ubm5MHLG3d0d7ISm4YkTJ7a2tjY1NUFnIE9PT0RkfUKF0GoMFNiEoz09PYMHD161alVWVpa4TpOSkvBPhqurK5fLJRkE"
+	"m82+fv36/fv3X7x4kZeXV1ZWBo2SeIskUNDw+Xwul9vd3d3e3s5gMCorKwsLC58/f56YmAhtOxSpkM/n37p1y9zcHD/aiRMnEoJY"
+	"k5OTIblraGi8ePEC/zSPGTMGnjt37tyYmBhx8bNA+JL2vXr69Ck4cfbs2erq6gSO/qqpkABIhXi/QiogBPlUVVW9f/8+MzPzwYMH"
+	"cgkZlpfZhIDjx4/jRT+4v6OjIyEhwcLCYtq0aVAQYTAY8CG0s7ODipolS5aA8AcEOVNhTk4O/CKJtALjaW7WrFkiAyoEAsHu3bvx"
+	"77OFhYXwO/wPWpDLysoCAwMJCnU1NbVjx47hH6zMzEw7Ozu8XUXYoaG0tJSQN0lZWXnWrFnu7u4nTpwgRIbIRoWdnZ3Dhw8XR0z/"
+	"81T4/v17Jycnc3PzGTNm6OvrDx8+XFNTExg3CPY0TFTWny+TCvl8/oQJE/BUWFlZuX37dhC3ChdY+FNevnxJsAoaGxu3trYiFpM/"
+	"FVZUVEC7ZL9+/XJycoRPgM6DYCEJLQzCH2pLS0vs79HyERERn+cLJpEKYTIYiFWrVlVUVMAGaWlpCxYsIPgDitMMtLW1ubq6Cpsa"
+	"VVVVCXMos1SIT4jw8OHDf4oKwXL+M1NhQUGBzGvVY8eOiVRT3Lhx4/Hjx69evSoqKqqqqmpqampra+vo6ABLECpUCL0LOzs72Ww2"
+	"EEjLy8sLCwuzs7OfPn2anJxMorUErqN4oznwuyT3QsMr4jEMW7duXUNDA2IxOVNhcXExXko6cuSIcOvKykp8SEBISIiANLEVFOMh"
+	"xowZk5aW9o9TIZ/Ph0w3bty4pKQkQgMOhwPTLkyePPm///2vxItmZGTA2DiAw4cPE9q0tLSkpqYCAwWDweBwOOXl5TDkAOgK2Ww2"
+	"0BVmZ2c/fPgQmLD5fL6RkRH2KYfVP0KFd+/eNTIywjOamZkZdVaSlgpbW1sPHjzY2dnZ0NAgMxWGhYXJRU0hGyZNmiTuZvG6aQzD"
+	"IiIioMfozZs3hduXlpbipRC8hOHj4yOVTR+BjApfvnwJl2AYhllaWoJEIwTASAwMw+bNmyfROtzU1DRnzhz8L7d27dru7m5x7YFP"
+	"ogyIiYmR1sX62bNnysrKvr6+JNnfoqOj7927J3IqxCErK8vNzW3IkCF0Op0kZBsiICAA3gW5BRnKJiAe63NSYXJy8vz588G/y5cv"
+	"72sqjIqK8vf3HzRokIaGBvimimMWGLZM4IKwsDDsU0a1L5AKX7x4gf09GU9sbOzRo0ehuICPaMjPz3d1dcW7qYp0dTQ2Nt61a9eN"
+	"GzdKS0tRRgYZqfDWrVv4iR43bpxI1xAmkwl/ORqN9tdff1G5AIvFgh/AqVOnki+Qpc3hjOHSDsoQbVJWVga3YeqX3gDSBI/HKy4u"
+	"pqLvhzksIBXy+fzjx49XVlYKhLwRYWT+/Pnz+5oKf//9d5HxcFZWVn1NhXin/c7OTpiiUQYqjIqK+gKpEFjqjI2NoTtRbGxsfX09"
+	"8Ot2d3dvaWnp6OiIj4+3tbUlEN+UKVMyMjJu3rwpMsIduiKKTMaDICBPx2BraxsYGAjSvWlqaiYlJQ0dOlR4fk+cONHa2gq2nZ2d"
+	"586dSzHCNyUlxdPTE8OwM2fOkAeikiSqIwc09WBSJizBhPKn9gYw8aqCgoK+vr7E9teuXaupqcH+nspw5cqVvr6+0J8JQkFBAUwj"
+	"hmGtra1QVpIvPn78GBERYWNjAzOYgeoF/fr1c3R0jIuLS0xMxGvi0tPTc3JySktLa2pqmpubWSwWIYaX3Hmby+W+evUqNDTU3t6e"
+	"kO1m5syZe/fu5XK5EoOXMXnnyBF88qiHAT9KSkqPHz8GmhPqbxcMV8cjLi7uyZMn4CXC7x86dOjRo0cfPnxobm7u6empo6OzZs2a"
+	"u3fvwiyQAwcOPHHixJs3b0xNTR0cHHJzc2H0sXDc1Lx581D8iIw+UC9evBg+fDjB4onXNEO6GTBgALlroUCMI7HENrdv36buD4hP"
+	"nkiwTsjgYn39+vXeT6abm5tAmsgWQJdQtlq/fj14SeA7IxDyOhozZkxwcDBeyYCXCpubmxMTEz08PCi+7fjoF3d3d5H5oIYPH37q"
+	"1CmRCcd6aTbZvHmzyHQ1Li4uhKyR8pUKKfIgPmw0Kiqqrq7O09Nz+PDh4tgwJiZGoh68ubkZyBnKysq1tbV4qVDw9/h0PPr37+/t"
+	"7S3yJ3jy5MnChQsJ7eVbcOLfaEEmybng5eWFSarDwGAwEhISejMamKlFWiokvAkyUCGJw0RLS0tycjJJrDvM2bNlyxbqNwuTEp4/"
+	"fx6/QP7xxx9hyKNw5CJBw9De3g7V7aNHj8ZntCbRyQqDJE993znTiCuZJOxX+JmpsLW1dcmSJXA8R48e7enpgc4V58+fF4jK7AkC"
+	"n48fP06iqoOS4Lp16wS4eBtIhd3d3fj1lpqampeXV3V1NfmA09PTv/322+nTpy9btkxFRYWKcgaBLF+huFwGZWVlZ86cgeZUuEyD"
+	"6OzsDA4O1tfXX716NZTs/meQl5dnb2+vra09aNCgWbNmlZaW9r5PBoMBigTMnz9/8uTJ+EMhISFgoV1TU3Po0CHCiRwOJy0tLSws"
+	"zMXFZcqUKRoaGjBZC1AvQmG/vr6e+nhgFkWgKwgICMDn5ukjLFq0CIarBwcHf/fdd1/Cz52fnz9v3rxHjx6Bf4OCgvbt26ekpLRr"
+	"1y7sU/Y2kAEB4tdff129ejWXy+Vyub6+vkuWLBFZy+H8+fOXL18G2yKlPyAtxsXFaWhozJgxw8DAoL29PSwsbOTIkeQFfBYtWnT1"
+	"6tU5c+bcuXOHyWRSUc4gYDLUQfb29oaq68jISOEUmx8/fty/fz9o88MPP2RnZ+NjML52VFdXQ0Weg4ODnp5e7/vcsmULCM4X/q5o"
+	"aWkFBAR4enrq6urOmjUrKysLZMHLzc199+5dRUUFRloexMDAQE9Pb+zYsSSpcTBRWRTBpf38/LZu3Uqn0+FL23cYN27c2LFj/fz8"
+	"Nm7cqKys7O7uTt7+/fv34kqLgORAvVcWnTt3ztvbm8PhAKNNZGQkHNWOHTsiIyPLy8vz8vLi4uKAQNrW1rZz507o9TlmzJjt27fP"
+	"nz+/f//+hM7fvn0L07uZm5uT6PJ0dXXfv3+vo6Pj6uoqlU8lWB/0XY2XfzsVpqamwsWjs7MzwXEaPoiBgYEg5TKDwVi3bl16evpn"
+	"zsTZd/jw4QP2yWXa29u79x3GxMQA1eT48eNXr16NT/gKiZLFYnl5eW3atIk8JXj//v1BplUMw+7cubNs2TLZhjRx4kQfHx8/Pz8q"
+	"hYfkaGD98OHDF5K8+s2bN9u3b8/IyIDS2a1bt2DgOYZhKioqhw8f/v777zEM27t3r6OjY2pq6rZt28CXUkdH58CBA5s2bRJn5Bk1"
+	"atSgQYPq6uowDNu/fz9GIV+ctKT2L0wDjn22inccDmfr1q3wm4MvCIsJVUyHuQn+/PNPkjz4GLUMhhKrespsbpYW0Ats6dKlsPiZ"
+	"zMjJyYGLI19fX5EfDBUVFX9/fzqdTkhOBzBhwgRnZ+fIyMjMzMy2tjaYS7GXtdCOHz/+OXkQmGWlentl0BVSQXZ29po1a2bOnAl5"
+	"EMMwDQ0NPA9CUQD4wVRVVU2bNs3R0bG6ulpNTS0gIKC4uNjDw4PE2D148GCQC9nCwgKviCR7OT+FFZI7nAo7ISHIXyrcs2cPlImC"
+	"g4NFOtlgn1zAoqKi5syZAySUwMBAW1tb4WgTcvT09Mi8tOnlRBC0Pxgul/2zZ88woZSiIgH8TkhQXl5ua2sLDD6GhobQQoKRuvvQ"
+	"aDRjY2Nzc/NFixYtXLiQkKETrx9EDzR1NDY2JiYmxsTE4BlQXV2dJDssjUa7dOnStGnT2Gz2x48faTSai4tLUFAQ3jmUBA4ODosX"
+	"L8ZnYUD4OqTCx48fw3JCNjY2EivIzJw5E36guFyui4sLLPVLER0dHbLdRnd3dy8nglBqHcNZM0EVEXV19ZUrVwKNQU5OjlSdQFHX"
+	"xsYGOhKeOHFCYpWfhQsXXr58ubGxMTs7Oyws7JtvvhHOVAzqYJCwOQImVJR1xowZQBmH58FVq1a9fv0ak6TfhGsjZWXlFStWUORB"
+	"7JMnqbTyAcI/TIUsFuvHH38EgoaGhgZ0+CAQUFNTE4iWTUtLu337tqGhIVRsFxYWHjhwQKrRQBduaZ1pxBVfl+HSBP0AVOt4eHho"
+	"aGhUVFQ4OTkZGRlZWFjcuHGDIAaK7ATDGeihXOnk5EQlcfTUqVPXr19PEleAF0UlyqTyQlFRUWpqKrDn1NbWgtAIkIftq3jonZyc"
+	"Wltb8V+OSZMmJSUlJSQk4MNPMfHeo+Cj2N3dvWbNmn379lFfzcjFkx/hcyyQi4uLGxoaWlpaYmJiysvLsU8Oa/7+/iDCAQBskwtB"
+	"QPBxcnKiGJeCYZi4YpgSQYjZwGQqWwycvKDqjcfjbd68GegHtLW1Qfz15s2bQZjHkydPnjx5Mnbs2G3bti1YsGDcuHFAi0d+lSNH"
+	"jjQ0NCQmJsoxYyhkQCge9jXi4+MlKv7lqMToDcWLvOiwYcOio6NBJMmIESP8/f1dXV0lai3LysrOnTtnaWlpaWkZFxdnaWkJYk+D"
+	"goJu37598uRJkRZFihohpNz44qgwMjLy1KlTmJBjXV5enmwP8aZNm7Kzsylqx6XKQaKqqgpdsg0NDakvVEVi48aNGzduxHB+G25u"
+	"bunp6UBDdOHCBfA9/+WXX4YNGxYfHw+W5OXl5b6+vnQ6fcOGDV5eXhKpEMOw8PDwDRs24KUD+KrLtsLtIyqE3YrzX5H5tf9sJ5JM"
+	"qbW19XfffWdmZrZx40ZhxxfCPCQnJ589e/bu3buwQDudTk9KSlq0aBF4L3Jzc62srBYvXrxr1y57e3vqkYLw1sjp/sqVK1euXEFs"
+	"9VmpcOfOneHh4VS+UUpKSkOHDtXW1oZ/tbS0tLS0Bg8eXFtbC51O8vLyQkJC8OVcMQoefBi1gu7CNj7w9b516xbF2rvCyMzMjIiI"
+	"iIuLA8yioKAQHR29YsUK7FP4amxsbEhIyKlTp06fPg0kRA6HExUVBZr5+PiQJyno378/oQGkMBneeYFAAE8H3nC9oSpFRUVotXz5"
+	"8iX2yZwthcJFQUFBQQGY+EEMMnyWyO+Oz+dDAx2BfOF9yeBXSHJRieRSW1t74cKFc+fOVVZWYrhkkeCTqaWllZGR4ezsfOfOHXAo"
+	"LS0tLS1t4MCBVlZWpqamBgYGJiYm5MoNODyRlC2tqNh7jTmGYpDxwKfVotPphoaG9vb27u7uR44cuXTp0r1793JychoaGsgTAeEr"
+	"+GhoaJDkuBfIIyGwmZnZ0KFDR48eTdDFGBgYUOmhrKwsISHB09OTEISrra1NklyeyWQeOnQIpmDAcLYOQkkAipHX+PxXFIGnvz/+"
+	"+KM301hdXa2lpaWtra2np4d/gbdt20ZomZeXl5KSkpWVVVJSUl9fD0oviKvZAFWiJiYmhEMdHR1Tp07V09MzNDTEX5Ewe1BRIwNE"
+	"pt2kooBWUFAgGLU0NTU9PDwIdSz4fP7BgwdFmr+WLl0qsXo4NLmcPn1a+CjMmEkR27dvR/Fz8qxtEh8fHxoampqaCooZyQaY3cDa"
+	"2jovL6+vb0NcMoUdO3YISEv8GBkZifRPVFFRcXV1pZKDgMlk7t27l+AN++2331If/KVLlzAxVdwEFOpGwYuePXu2l9NIKLwL8Pvv"
+	"v8slBllfX19kCgNMVOgbvs3bt29lpsLdu3dTHGdJSUl4eLiwvxSNRrOysoqLiyMpgZuXlwfCdTBc9kCJPCgQCOCzJzLbNtTYUPQr"
+	"dHFxQYwm54p3vQeXyzU3NxeZj7cvwOFwhL/MkyZNqqurE5CmCxR2dp0wYUJAQAD5iSJFqg0bNoDl2/jx4ykWgAY4duyYVDKsQEyx"
+	"wKNHj/ZyGoWj+tauXUteoos6FQ4cOFBkeh68IK+kpLR3715Cm9TUVIlJoQmALtbAC4IK3r59S3iEBg8e7OPjU1JSQrGHpKQkkMZc"
+	"UVHx7du3AgrZKuG1hO9aIBCsWrVKKirEp5JEkBZKfbTuVlRUfPz48Wdb5quqqhoYGOTk5CgpKeno6EydOnXZsmUbN24UmQMK/+Jd"
+	"vHjRxMRkzJgxxsbGc+fONTc3p2L6EMaIESNiYmJcXV1379595swZqSJhhgwZAvhC2GcQo1AmuPf2d4jRo0cbGhoqKioaGBjMmDHD"
+	"zs4OFuqVGRMnTgQDA9pDQnQNcM179+7dnDlzTE1NbWxshN1NQLCaVBgwYABIJCOxDhSEkZGRh4cHKHpjaGjo7e29fv16cosKAfb2"
+	"9vb29rm5uenp6bD6AkaakgNu46V7iKqqKirXnTJlCnh+RMYmIVAE7X/Jii8QCORl7kT4F6K4uNjZ2Xnfvn0rVqxADxKiQgQEBAQM"
+	"RZsgICAgICpEQEBAQFSIgICAgKgQAQEBAVEhAgICAqJCBAQEBESFCAgICIgKERAQEBAVIiAgICAqREBAQEBUiICAgICoEAEBAQFR"
+	"IQICAgKiQgQEBAREhQgICAiIChEQEBAQFSIgICAgKkRTgICAgICoEAEBAQH7PzsHvqY55zH8AAAAAElFTkSuQmCC"
+)
+
+
+def make_fixtures(root):
+	from PIL import Image, ImageDraw
+	from docx import Document
+	from openpyxl import Workbook
+	from pptx import Presentation
+	from pptx.util import Inches
+	files = []
+	# Raster PDF exercises the actual OCR path without a hidden text layer.
+	image = Image.new("RGB", (1000, 600), "white")
+	draw = ImageDraw.Draw(image)
+	draw.text((80, 70), "TOTAL 123", fill="black", font_size=60)
+	draw.text((80, 180), "Document conversion fixture", fill="black", font_size=32)
+	image.paste(Image.open(BytesIO(b64decode(CHINESE_CAPTION_PNG))), (80, 260))
+	draw.rectangle((75, 350, 700, 520), outline="black", width=3)
+	draw.line((75, 430, 700, 430), fill="black", width=3)
+	draw.line((400, 350, 400, 520), fill="black", width=3)
+	draw.text((95, 375), "Name", fill="black", font_size=32)
+	draw.text((425, 375), "Value", fill="black", font_size=32)
+	draw.text((95, 455), "Total", fill="black", font_size=32)
+	draw.text((425, 455), "123", fill="black", font_size=32)
+	path = root / "scanned.pdf"
+	image.save(path, "PDF", resolution=120)
+	files.append((path, "123"))
+	# A born-digital PDF preserves text independently of OCR.
+	objects = [b"<< /Type /Catalog /Pages 2 0 R >>", b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>", b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 4 0 R /F2 6 0 R /F3 7 0 R >> >> /Contents 5 0 R >>", b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"]
+	chinese = "公司技术资料".encode("utf-16-be").hex().encode()
+	stream = b"BT /F1 18 Tf 72 720 Td (Document conversion fixture 456) Tj ET\n"
+	stream += b"BT /F3 16 Tf 72 680 Td <" + chinese + b"> Tj ET\n"
+	stream += b"72 500 400 100 re 72 550 m 472 550 l 272 500 m 272 600 l S\n"
+	stream += b"BT /F1 14 Tf 85 570 Td (Name) Tj 200 0 Td (Value) Tj ET\nBT /F1 14 Tf 85 520 Td (Total) Tj 200 0 Td (456) Tj ET\n"
+	header_stream = stream
+	code_lines = ["def calculate_total(values):", "    return sum(values)", "", "def print_report(values):", "    total = calculate_total(values)", "    print('Total:', total)", "", "print_report([1, 2, 3])"]
+	stream += b"0.95 g 62 284 470 164 re f 0 g\nBT /F2 12 Tf 72 430 Td\n"
+	for index, line in enumerate(code_lines):
+		if index:
+			stream += b"0 -18 Td\n"
+		escaped = line.replace("\\", "\\\\").replace("(", "\\(").replace(")", "\\)")
+		stream += b"(" + escaped.encode("ascii") + b") Tj\n"
+	stream += b"ET\n"
+	objects.append(b"<< /Length " + str(len(stream)).encode() + b" >>\nstream\n" + stream + b"\nendstream")
+	objects.extend([b"<< /Type /Font /Subtype /Type1 /BaseFont /Courier >>", b"<< /Type /Font /Subtype /Type0 /BaseFont /STSong-Light /Encoding /UniGB-UCS2-H /DescendantFonts [8 0 R] >>", b"<< /Type /Font /Subtype /CIDFontType0 /BaseFont /STSong-Light /CIDSystemInfo << /Registry (Adobe) /Ordering (GB1) /Supplement 4 >> /DW 1000 >>"])
+	def write_pdf(name, content):
+		objects[4] = b"<< /Length " + str(len(content)).encode() + b" >>\nstream\n" + content + b"\nendstream"
+		data, offsets = bytearray(b"%PDF-1.4\n"), [0]
+		for index, value in enumerate(objects, 1):
+			offsets.append(len(data))
+			data.extend(str(index).encode() + b" 0 obj\n" + value + b"\nendobj\n")
+		xref = len(data)
+		data.extend(("xref\n0 %d\n0000000000 65535 f \n" % (len(objects) + 1)).encode())
+		for offset in offsets[1:]:
+			data.extend(("%010d 00000 n \n" % offset).encode())
+		data.extend(("trailer\n<< /Root 1 0 R /Size %d >>\nstartxref\n%d\n%%%%EOF\n" % (len(objects) + 1, xref)).encode())
+		path = root / name
+		path.write_bytes(data)
+		files.append((path, "456"))
+	objects[5] = b"<< /Type /Font /Subtype /Type1 /BaseFont /Courier /Encoding /WinAnsiEncoding >>"
+	write_pdf("digital.pdf", stream)
+	# StandardEncoding maps this font's quote byte to U+2019. Retain the
+	# ambiguous original case: a recognizer must not silently turn it into ASCII.
+	objects[5] = b"<< /Type /Font /Subtype /Type1 /BaseFont /Courier >>"
+	write_pdf("digital-ambiguous.pdf", stream)
+	# Keep the short, unboxed snippet which the layout model misclassified in the
+	# first real qualification: this must be preserved or explicitly report partial.
+	write_pdf("digital-short.pdf", header_stream + b"BT /F2 12 Tf 72 430 Td (def calculate_total\\(values\\):) Tj 0 -18 Td (    return sum\\(values\\)) Tj ET\n")
+	document = Document()
+	document.add_heading("公司资料 Fixture document", 1)
+	document.add_paragraph("Office text 789")
+	table = document.add_table(rows=2, cols=2)
+	for cell, value in zip([cell for row in table.rows for cell in row.cells], ["Name", "Value", "Total", "789"]):
+		cell.text = value
+	path = root / "office.docx"
+	document.save(path)
+	files.append((path, "789"))
+	book = Workbook()
+	book.active.append(["Name", "Value"])
+	book.active.append(["Total", 321])
+	path = root / "sheet.xlsx"
+	book.save(path)
+	files.append((path, "321"))
+	presentation = Presentation()
+	slide = presentation.slides.add_slide(presentation.slide_layouts[6])
+	slide.shapes.add_textbox(Inches(1), Inches(1), Inches(7), Inches(2)).text = "Presentation fixture 654"
+	path = root / "slides.pptx"
+	presentation.save(path)
+	files.append((path, "654"))
+	return files