Skip to content

armgit / OXR

Public Imported from GitHub
0

An open-source document parsing model with SOTA accuracy and speed, using an RSI loop during post-training.

Add optional header and footer recognition to online demo

BinyangQiu8fc684ecdec6
diff --git a/.gitignore b/.gitignore
index 8463cce..5893e72 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,6 +39,7 @@ config.local.yaml
.DS_Store
.superpowers/
.worktrees/
+.python-version
# Local coding-assistant instructions and private validation records.
[Aa][Gg][Ee][Nn][Tt][Ss].md
diff --git a/oxr/pipeline/orchestrator.py b/oxr/pipeline/orchestrator.py
index 28790af..4ef354d 100644
--- a/oxr/pipeline/orchestrator.py
+++ b/oxr/pipeline/orchestrator.py
@@ -141,7 +141,8 @@ async def _process_decoded_document(
)
filtered_types = {BlockType.PAGE_HEADER, BlockType.PAGE_FOOTER}
- # Demo retains these detections for overlays only, outside recognition and RO.
+ # Demo margins stay outside body reading order and cleanup. Recognition is
+ # optional; disabled margins retain the original overlay-only behavior.
demo_page_margins = [
[deepcopy(block) for block in blocks if block.type in filtered_types]
for blocks in pages_blocks
@@ -162,21 +163,32 @@ async def _process_decoded_document(
model_options,
element_formats,
)
- if settings.layout_analyze_model.provides_reading_order:
- pages_blocks = await recognize_pages(*recognition_args)
- else:
+ async def recognize_body():
+ if settings.layout_analyze_model.provides_reading_order:
+ return await recognize_pages(*recognition_args)
reading_order_task = asyncio.create_task(
resolve_reading_orders(pages_blocks, images, semaphore)
)
recognition_task = asyncio.create_task(recognize_pages(*recognition_args))
- reading_orders, pages_blocks = await gather_cancel_on_error(
+ reading_orders, recognized_pages = await gather_cancel_on_error(
reading_order_task,
recognition_task,
)
- pages_blocks = [
+ return [
[blocks[local_id] for local_id in order]
- for blocks, order in zip(pages_blocks, reading_orders)
+ for blocks, order in zip(recognized_pages, reading_orders)
]
+
+ if demo and keep_header_footer:
+ pages_blocks, demo_page_margins = await gather_cancel_on_error(
+ recognize_body(),
+ recognize_pages(
+ demo_page_margins, images, file_name, semaphore,
+ model_options, element_formats,
+ ),
+ )
+ else:
+ pages_blocks = await recognize_body()
recognition_end_time = time.perf_counter()
# Table pictures have already been restored (or retained in the raster
@@ -211,6 +223,30 @@ async def _process_decoded_document(
pages_blocks = [dedupe_complete_text(blocks) for blocks in pages_blocks]
pages_blocks = [dedupe_exact_textual_blocks(blocks) for blocks in pages_blocks]
+ if demo and keep_header_footer:
+ for page_index, (blocks, margins) in enumerate(zip(pages_blocks, demo_page_margins)):
+ def margin_order(block):
+ return block.bbox[1], block.bbox[0], block.idx
+
+ headers = sorted(
+ (block for block in margins if block.type == BlockType.PAGE_HEADER),
+ key=margin_order,
+ )
+ footers = sorted(
+ (block for block in margins if block.type == BlockType.PAGE_FOOTER),
+ key=margin_order,
+ )
+ # Preserve gaps left by cleanup: formula numbering uses adjacent
+ # indexes to associate each surviving witness with its formula.
+ for block in blocks:
+ block.idx += len(headers)
+ footer_start = max((block.idx for block in blocks), default=len(headers) - 1) + 1
+ for idx, block in enumerate(headers):
+ block.idx = idx
+ for offset, block in enumerate(footers):
+ block.idx = footer_start + offset
+ pages_blocks[page_index] = headers + blocks + footers
+
# 4. Phase 3: Assembly & Output Formatting
outputs = {}
@@ -269,6 +305,7 @@ async def _process_decoded_document(
}
if demo:
+ metadata["keep_header_footer"] = keep_header_footer
demo_pages = []
for i, blocks in enumerate(pages_blocks):
markdown, ranges = blocks_to_markdown_with_ranges(blocks)
@@ -286,7 +323,7 @@ async def _process_decoded_document(
"content": "", "format": b.format.value,
"start_line": None, "end_line": None,
}
- for offset, b in enumerate(demo_page_margins[i])
+ for offset, b in enumerate(demo_page_margins[i] if not keep_header_footer else [])
]
demo_page = {
"page_num": i,
diff --git a/oxr/server/demo/index.html b/oxr/server/demo/index.html
index f91f971..ff319fe 100644
--- a/oxr/server/demo/index.html
+++ b/oxr/server/demo/index.html
@@ -66,6 +66,13 @@
<input id="file-input" type="file" accept="application/pdf,image/png,image/jpeg,image/webp,image/bmp,image/tiff,.pdf,.png,.jpg,.jpeg,.webp,.bmp,.tif,.tiff" hidden>
<section class="config-section" aria-labelledby="parameters-title">
<h2 class="config-heading" id="parameters-title">Parsing Parameters</h2>
+ <div class="parameter-control">
+ <label class="parameter-toggle" for="keep-header-footer">
+ <span>Header &amp; Footer</span>
+ <input id="keep-header-footer" type="checkbox" role="switch" checked aria-describedby="keep-header-footer-help">
+ </label>
+ <p class="parameter-help" id="keep-header-footer-help">Recognize page headers and footers. Applies to the next parse.</p>
+ </div>
<div class="parameter-control">
<div class="parameter-label-row">
<label for="temperature-value">Temperature</label>
diff --git a/oxr/server/demo/lib/config.js b/oxr/server/demo/lib/config.js
index ef7330e..29b5889 100644
--- a/oxr/server/demo/lib/config.js
+++ b/oxr/server/demo/lib/config.js
@@ -35,6 +35,10 @@ export function readModelOptions() {
return options;
}
+export function readParsingOptions() {
+ return { keep_header_footer: $("keep-header-footer").checked };
+}
+
function setState(state, label) {
$("status-state").dataset.state = state;
$("status-state").textContent = label;
diff --git a/oxr/server/demo/lib/index.js b/oxr/server/demo/lib/index.js
index 1acc1d5..59159b4 100644
--- a/oxr/server/demo/lib/index.js
+++ b/oxr/server/demo/lib/index.js
@@ -1,8 +1,8 @@
-import { createRenderer, sanitizeMarkup, renderedNodesForRange, sourceNodesForRange, addPageDivider, renderSource } from "./rendering.js";
+import { createRenderer, sanitizeMarkup, renderedNodesForRange, sourceNodesForRange, moveRenderedNodes, addPageDivider, renderSource } from "./rendering.js";
import { createPageImage, createLegend } from "./layout.js";
import { PageSync, initSplitter } from "./page-sync.js";
import { downloadLayoutImage } from "./layout-export.js";
-import { readModelOptions, resetStatus, startStatus, updateStatusPages, finishStatus } from "./config.js";
+import { readModelOptions, readParsingOptions, resetStatus, startStatus, updateStatusPages, finishStatus } from "./config.js";
const $ = (id) => document.getElementById(id);
const fileViewport = $("file-viewport");
@@ -125,7 +125,7 @@ function updatePageImages(incoming) {
function showResult(result) {
markdown = String(result.outputs?.markdown || "");
const images = new Map(pages.map((page) => [page.page_num, page]));
- pages = (result.demo_pages || []).map((page) => ({ ...images.get(page.page_num), ...page })).sort((a, b) => a.page_num - b.page_num);
+ pages = (result.demo_pages || []).map((page) => ({ ...images.get(page.page_num), ...page, keep_header_footer: result.metadata?.keep_header_footer === true })).sort((a, b) => a.page_num - b.page_num);
if (!pages.length) throw new Error("The server returned no document pages.");
blockMap.clear();
renderFiles();
@@ -145,10 +145,40 @@ function showResult(result) {
// values are cell-local, not page-local. The table root owns this block.
rendered.querySelectorAll("table[data-line] [data-line]").forEach((node) => node.removeAttribute("data-line"));
for (const node of rendered.querySelectorAll("[data-line]")) node.classList.add("bi-direction-jump__target");
+ const headers = [];
+ const footers = [];
(page.blocks || []).forEach((block, position) => {
const key = `${page.page_num}:${position}`;
const sourceNodes = sourceNodesForRange(source, block.start_line, block.end_line);
let renderedNodes = renderedNodesForRange(rendered, block.start_line, block.end_line);
+ const margin = page.keep_header_footer && ["Page-header", "Page-footer"].includes(block.type);
+ if (margin) {
+ const wrapper = document.createElement("aside");
+ wrapper.className = "page-margin bi-direction-jump__target";
+ wrapper.dataset.marginKey = key;
+ const label = document.createElement("span");
+ label.className = "fallback-label";
+ label.textContent = block.type === "Page-header" ? "Header" : "Footer";
+ const text = document.createElement("div");
+ text.className = "page-margin-content";
+ // Move the original rendered nodes, keeping their Markdown and
+ // page-local line mappings intact without duplicating content.
+ moveRenderedNodes(rendered, renderedNodes, text);
+ if (!renderedNodes.length && String(block.content || "").trim()) {
+ try {
+ text.append(sanitizeMarkup(renderer.render(String(block.content)), `page-${page.page_num}-margin-${position}-`));
+ text.querySelectorAll("[data-line]").forEach((node) => {
+ if (Number.isInteger(block.start_line)) node.dataset.line = String(Number(node.dataset.line) + block.start_line);
+ else node.removeAttribute("data-line");
+ });
+ } catch { text.textContent = String(block.content); }
+ if (!text.textContent.trim()) text.textContent = String(block.content);
+ }
+ wrapper.append(label, text);
+ (block.type === "Page-header" ? headers : footers).push(wrapper);
+ for (const node of sourceNodes) node.dataset.marginKey = key;
+ renderedNodes = [wrapper];
+ }
// Markdown definitions (for example unreferenced footnotes) may have no
// rendered node. Keep their nonempty content visible and selectable.
if (!renderedNodes.length && sourceNodes.length && String(block.content || "").trim()) {
@@ -167,6 +197,9 @@ function showResult(result) {
}
blockMap.set(key, { page: page.page_num, block, position, rendered: renderedNodes, source: sourceNodes });
});
+ // Footnote fallbacks are appended during the loop; footers follow them.
+ rendered.prepend(...headers);
+ rendered.append(...footers);
fragments[0].append(rendered);
fragments[1].append(source);
appendImagePage(fragments[2], page, "layout");
@@ -196,8 +229,9 @@ function selectBlock(key, origin = "tab") {
for (const node of [...entry.rendered, ...entry.source]) node.classList.add("bi-direction-jump__target--active");
for (const node of document.querySelectorAll(".layout-box")) node.classList.toggle("selected", node.dataset.blockKey === key);
const viewport = $(`${activeTab}-viewport`);
- sync.setPage(entry.page, origin === "layout" ? viewport : fileViewport);
- if (origin === "layout") {
+ const fromResult = ["layout", "rendered", "source"].includes(origin);
+ sync.setPage(entry.page, fromResult ? viewport : fileViewport);
+ if (fromResult) {
const fileBox = Array.from(fileViewport.querySelectorAll(".layout-box")).find((node) => node.dataset.blockKey === key);
sync.reveal(fileViewport, fileBox);
}
@@ -232,6 +266,7 @@ async function upload(file) {
let modelOptions;
try { modelOptions = readModelOptions(); }
catch (error) { finishStatus(error.message); return; }
+ const parsingOptions = readParsingOptions();
requestController?.abort();
requestController = new AbortController();
const signal = requestController.signal;
@@ -261,6 +296,7 @@ async function upload(file) {
const form = new FormData();
form.append("file", file);
for (const [key, value] of Object.entries(modelOptions)) form.append(key, String(value));
+ for (const [key, value] of Object.entries(parsingOptions)) form.append(key, String(value));
const job = await request("/v1/demo/jobs", { method: "POST", body: form });
if (currentGeneration !== generation) return;
setProgress("parse");
@@ -301,6 +337,13 @@ async function upload(file) {
$("retry-button").addEventListener("click", () => upload(lastFile));
$("upload-button").addEventListener("click", () => $("file-input").click());
+for (const name of ["rendered", "source"]) {
+ $(`${name}-viewport`).addEventListener("click", (event) => {
+ if (event.target.closest("a, button, input, select, textarea") || !window.getSelection()?.isCollapsed) return;
+ const target = event.target.closest("[data-margin-key]");
+ if (target) selectBlock(target.dataset.marginKey, name);
+ });
+}
for (const viewport of [fileViewport, $("layout-viewport")]) {
viewport.addEventListener("click", (event) => {
if (!event.target.closest('.layout-box[role="button"]')) clearSelection();
diff --git a/oxr/server/demo/lib/layout.js b/oxr/server/demo/lib/layout.js
index ee1f59f..ef82800 100644
--- a/oxr/server/demo/lib/layout.js
+++ b/oxr/server/demo/lib/layout.js
@@ -44,6 +44,7 @@ export function createPageImage(page, mode, onSelect, currentKey) {
wrap.append(image);
const blocks = (page.blocks || []).map((block, position) => ({ ...block, position, key: `${page.page_num}:${position}` })).filter(validBox);
const readingBlocks = blocks.filter((block) => !["Page-header", "Page-footer"].includes(block.type));
+ const selectableBlocks = page.keep_header_footer === true ? blocks : readingBlocks;
// Number the same reading sequence as the arrows, independently of JSON IDs.
const readingNumbers = new Map(readingBlocks.map((block, index) => [block.key, index + 1]));
const overlay = svgElement("svg", { viewBox: `0 0 ${w} ${h}`, class: "layout-overlay", "aria-label": `Page ${page.page_num + 1} layout` });
@@ -69,8 +70,9 @@ export function createPageImage(page, mode, onSelect, currentKey) {
for (const block of blocks) {
const [x1, y1, x2, y2] = block.bbox;
const color = categoryColor(String(block.type));
- const displayOnly = !readingBlocks.includes(block);
- const blockLabel = displayOnly ? String(block.type) : `[${readingNumbers.get(block.key)}] ${block.type}`;
+ const margin = !readingBlocks.includes(block);
+ const displayOnly = !selectableBlocks.includes(block);
+ const blockLabel = margin ? String(block.type) : `[${readingNumbers.get(block.key)}] ${block.type}`;
const rect = svgElement("rect", { x: x1, y: y1, width: x2 - x1, height: y2 - y1, stroke: color, class: `layout-box${displayOnly ? " layout-box--display-only" : ""}`, "aria-label": blockLabel, "data-block-key": block.key });
rect.style.setProperty("--box-color", color);
const title = svgElement("title", {});
@@ -84,7 +86,7 @@ export function createPageImage(page, mode, onSelect, currentKey) {
const bounds = overlay.getBoundingClientRect();
const x = (event.clientX - bounds.left) / bounds.width * w;
const y = (event.clientY - bounds.top) / bounds.height * h;
- const hits = readingBlocks.filter((candidate) => x >= candidate.bbox[0] && x <= candidate.bbox[2] && y >= candidate.bbox[1] && y <= candidate.bbox[3]);
+ const hits = selectableBlocks.filter((candidate) => x >= candidate.bbox[0] && x <= candidate.bbox[2] && y >= candidate.bbox[1] && y <= candidate.bbox[3]);
const selected = hits.findIndex((candidate) => candidate.key === currentKey());
const next = hits.length ? hits[(selected + 1) % hits.length] : block;
onSelect(next.key, hits.length);
diff --git a/oxr/server/demo/lib/rendering.js b/oxr/server/demo/lib/rendering.js
index 67ac579..daff859 100644
--- a/oxr/server/demo/lib/rendering.js
+++ b/oxr/server/demo/lib/rendering.js
@@ -102,6 +102,22 @@ export function sourceNodesForRange(container, start, end) {
.filter((node) => Number(node.dataset.sourceLine) >= start && Number(node.dataset.sourceLine) < end);
}
+export function moveRenderedNodes(container, nodes, destination) {
+ // Adjacent Markdown lists can share an outer list across OCR blocks. Keep
+ // that structural context when extracting only the margin's list items.
+ const parents = new Map([[container, destination]]);
+ const destinationFor = (parent) => {
+ if (parents.has(parent)) return parents.get(parent);
+ const clone = parent.cloneNode(false);
+ clone.removeAttribute("id");
+ clone.removeAttribute("data-line");
+ destinationFor(parent.parentElement).append(clone);
+ parents.set(parent, clone);
+ return clone;
+ };
+ for (const node of nodes) destinationFor(node.parentElement).append(node);
+}
+
export function addPageDivider(parent, previous, next) {
const divider = document.createElement("div");
divider.className = "page-divider";
diff --git a/oxr/server/demo/style/index.css b/oxr/server/demo/style/index.css
index 45c5388..d4bb362 100644
--- a/oxr/server/demo/style/index.css
+++ b/oxr/server/demo/style/index.css
@@ -182,6 +182,12 @@ a.resource-badge:hover { border-color: var(--accent-color); color: var(--text-co
.config-section { margin-top: 1.25rem; padding-top: 1.1rem; border-top: 1px solid var(--border-color); }
.config-heading { margin: 0 0 0.9rem; color: var(--text-muted); font: 0.6875rem/1.4 monospace; letter-spacing: 0.05em; text-transform: uppercase; }
.parameter-control + .parameter-control { margin-top: 0.85rem; }
+.parameter-toggle { display: flex; align-items: center; justify-content: space-between; gap: 0.5rem; font-size: 0.75rem; color: var(--text-muted); cursor: pointer; }
+.parameter-toggle input { appearance: none; position: relative; flex: 0 0 2rem; width: 2rem; height: 1.125rem; margin: 0; border: 1px solid var(--input-border); border-radius: 1rem; background: var(--input-bg); cursor: pointer; }
+.parameter-toggle input::after { content: ""; position: absolute; top: 2px; left: 2px; width: 0.75rem; height: 0.75rem; border-radius: 50%; background: var(--text-muted); transition: transform var(--transition-normal); }
+.parameter-toggle input:checked { background: var(--accent-color); border-color: var(--accent-color); }
+.parameter-toggle input:checked::after { transform: translateX(0.875rem); background: #fff; }
+.parameter-help { margin: 0.4rem 0 0; color: var(--text-muted-half); font-size: 0.625rem; line-height: 1.5; }
.parameter-label-row { display: flex; align-items: center; justify-content: space-between; gap: 0.5rem; margin-bottom: 0.4rem; font-size: 0.75rem; color: var(--text-muted); }
.parameter-label-row input { width: 3.75rem; min-width: 0; padding: 0.3rem 0.35rem; border: 1px solid var(--input-border); border-radius: 0.3rem; background: var(--input-bg); color: var(--text-color); font: 0.75rem monospace; font-variant-numeric: tabular-nums; }
.parameter-label-row input:hover { border-color: var(--accent-color); }
@@ -219,6 +225,12 @@ a.resource-badge:hover { border-color: var(--accent-color); color: var(--text-co
.block-fallback { margin: 1rem 0; padding: 0.6rem 0; }
.fallback-label { display: block; color: var(--text-muted-half); font: 0.625rem monospace; text-transform: uppercase; letter-spacing: 0.05em; margin-bottom: 0.5rem; }
.fallback-content { white-space: pre-wrap; overflow-wrap: anywhere; }
+.rendered-page .page-margin { --text-color: #a1a1aa; margin: 1rem 0; font-size: 0.85em; color: #a1a1aa; }
+.rendered-page.somarkdown-container .page-margin :is(h1, h2, h3, h4, h5, h6) { font-size: 1em; color: inherit; }
+.page-margin > .fallback-label { text-transform: none; }
+.page-margin-content { overflow-wrap: anywhere; }
+.page-margin-content > :first-child { margin-top: 0; }
+.page-margin-content > :last-child { margin-bottom: 0; }
.retry-button { margin: 0.65rem 0 0; padding: 0.35rem 0.6rem; color: var(--accent-color); border: 1px solid var(--border-color); }
diff --git a/oxr/server/demo_api.py b/oxr/server/demo_api.py
index ed24f77..b357151 100644
--- a/oxr/server/demo_api.py
+++ b/oxr/server/demo_api.py
@@ -54,6 +54,7 @@ def _decode_and_publish(store: DemoStore, job_id: str, data: bytes, file_name: s
async def _process_job(
store: DemoStore, job_id: str, data: bytes, file_name: str,
model_options: dict[str, float] | None = None,
+ keep_header_footer: bool = True,
) -> None:
decode_task = None
publish_task = None
@@ -66,6 +67,7 @@ async def _process_job(
images,
file_name,
["markdown", "json"],
+ keep_header_footer=keep_header_footer,
model_options=model_options,
demo=True,
asset_dir=store.job_dir(job_id) / "images",
@@ -136,6 +138,7 @@ async def submit_demo_job(
temperature: str = Form("0"),
top_p: str = Form("1"),
repetition_penalty: str = Form("1"),
+ keep_header_footer: bool = Form(True),
):
# Read the raw form as well: FastAPI substitutes defaults for empty fields,
# but explicitly blank model parameters must be rejected rather than reset.
@@ -175,7 +178,9 @@ async def submit_demo_job(
except OSError:
return _error("The demo's temporary storage is unavailable or full. Try again later.", 503)
job_id = manifest["id"]
- task = asyncio.create_task(_process_job(store, job_id, bytes(data), file_name, model_options))
+ task = asyncio.create_task(_process_job(
+ store, job_id, bytes(data), file_name, model_options, keep_header_footer,
+ ))
request.app.state.demo_tasks[job_id] = task
task.add_done_callback(lambda _: request.app.state.demo_tasks.pop(job_id, None))
return _response({"id": job_id, "status": "queued"})
diff --git a/tests/unit/test_demo_api.py b/tests/unit/test_demo_api.py
index 6cdb219..1fb4c30 100644
--- a/tests/unit/test_demo_api.py
+++ b/tests/unit/test_demo_api.py
@@ -57,6 +57,7 @@ def test_demo_upload_publishes_page_before_result_and_decodes_only_once(monkeypa
assert len(images) == 1 and images[0].shape == (18, 24, 3)
assert formats == ["markdown", "json"]
assert kwargs["demo"] is True
+ assert kwargs["keep_header_footer"] is True
assert kwargs["started_at"] > 0
while not release.is_set():
await asyncio.sleep(0.01)
@@ -137,6 +138,47 @@ def test_demo_model_options_reach_pipeline(monkeypatch, demo_store, submitted, e
assert received == [expected]
[email protected]("submitted, expected", [({}, True),
+ ({"keep_header_footer": "true"}, True), ({"keep_header_footer": "false"}, False),
+])
+def test_demo_header_footer_option_reaches_pipeline_separately(
+ monkeypatch, demo_store, submitted, expected,
+):
+ received = []
+
+ async def process(images, name, formats, **kwargs):
+ received.append(kwargs)
+ return {"file_name": name, "outputs": {}, "metadata": {}, "demo_pages": []}
+
+ monkeypatch.setattr(orchestrator, "process_decoded_document", process)
+ with TestClient(app) as client:
+ response = client.post(
+ "/v1/demo/jobs", data=submitted,
+ files={"file": ("example.png", image_bytes(), "image/png")},
+ )
+ assert response.status_code == 200
+ wait_status(client, response.json()["data"]["id"], "success")
+ assert len(received) == 1
+ assert received[0]["keep_header_footer"] is expected
+ assert "keep_header_footer" not in received[0]["model_options"]
+
+
+def test_demo_rejects_invalid_header_footer_option_before_creating_job(monkeypatch, demo_store):
+ def unexpected_create(*_args):
+ pytest.fail("Invalid header/footer option must not create a job")
+
+ monkeypatch.setattr(demo_store, "create", unexpected_create)
+ with TestClient(app) as client:
+ response = client.post(
+ "/v1/demo/jobs", data={"keep_header_footer": "sometimes"},
+ files={"file": ("example.png", image_bytes(), "image/png")},
+ )
+ assert response.status_code == 422
+ assert "keep_header_footer" in response.text
+ assert not app.state.demo_tasks
+ assert not list(demo_store.root.glob("*/manifest.json"))
+
+
@pytest.mark.parametrize("name, value", [
(name, value)
for name in ("temperature", "top_p", "repetition_penalty")
diff --git a/tests/unit/test_demo_pipeline.py b/tests/unit/test_demo_pipeline.py
index f51dbc9..1123c66 100644
--- a/tests/unit/test_demo_pipeline.py
+++ b/tests/unit/test_demo_pipeline.py
@@ -134,10 +134,11 @@ def test_demo_header_footer_are_layout_only(
)
result = asyncio.run(orchestrator.process_decoded_document(
[np.zeros((30, 40, 3), dtype=np.uint8)], "test.png", ["markdown", "json"],
- demo=True,
+ demo=True, keep_header_footer=False,
))
expected_inputs = [[BlockType.FORMULA] if with_body else []]
+ assert result["metadata"]["keep_header_footer"] is False
assert captured["recognition"] == expected_inputs
if not provides_reading_order:
assert captured["reading_order"] == expected_inputs
@@ -173,6 +174,99 @@ def test_demo_header_footer_are_layout_only(
assert body == []
[email protected]("provides_reading_order", [False, True])
[email protected]("with_body", [False, True])
[email protected]("full_overlap_dedupe", [False, True])
+def test_demo_recognizes_margins_outside_body_order_and_preserves_source_ranges(
+ monkeypatch, provides_reading_order, with_body, full_overlap_dedupe,
+):
+ header_right = block(0, BlockType.PAGE_HEADER, "")
+ header_right.bbox = [21, 0, 40, 4]
+ header_left = block(4, BlockType.PAGE_HEADER, "")
+ header_left.bbox = [0, 0, 19, 4]
+ footer_bottom = block(2, BlockType.PAGE_FOOTER, "")
+ footer_bottom.bbox = [0, 28, 40, 30]
+ footer_top = block(3, BlockType.PAGE_FOOTER, "")
+ footer_top.bbox = [0, 24, 40, 26]
+ formula = block(1, BlockType.FORMULA, "x = 1")
+ formula.bbox = [0, 8, 20, 18]
+ formula.text_before = "(1)"
+ formula.text_after = "(2)"
+ captured = {"recognition": [], "semaphores": [], "reading_order": []}
+ margin_contents = {
+ 0: "Right **header**", 4: "Left header", 2: "Bottom footer", 3: "Top footer",
+ }
+
+ async def layout(*_args):
+ return [[header_right, footer_bottom, *([formula] if with_body else []),
+ header_left, footer_top]]
+
+ async def recognize(pages, _images, _name, semaphore, *_args):
+ captured["recognition"].append([[b.type for b in page] for page in pages])
+ captured["semaphores"].append(semaphore)
+ for page in pages:
+ for region in page:
+ if region.type in {BlockType.PAGE_HEADER, BlockType.PAGE_FOOTER}:
+ region.content = margin_contents[region.idx]
+ return pages
+
+ async def reading_order(pages, _images, semaphore):
+ captured["reading_order"].append([[b.type for b in page] for page in pages])
+ captured["semaphores"].append(semaphore)
+ return [list(range(len(page))) for page in pages]
+
+ monkeypatch.setattr(orchestrator, "analyze_layouts", layout)
+ monkeypatch.setattr(orchestrator, "recognize_pages", recognize)
+ monkeypatch.setattr(orchestrator, "resolve_reading_orders", reading_order)
+ monkeypatch.setattr(orchestrator.settings.pipeline, "full_overlap_dedupe", full_overlap_dedupe)
+ monkeypatch.setattr(
+ orchestrator.settings.layout_analyze_model, "provides_reading_order", provides_reading_order,
+ )
+ result = asyncio.run(orchestrator.process_decoded_document(
+ [np.zeros((30, 40, 3), dtype=np.uint8)], "test.png", ["markdown", "json"],
+ demo=True, keep_header_footer=True,
+ ))
+
+ body_inputs = [[BlockType.FORMULA] if with_body else []]
+ assert len(captured["recognition"]) == 2
+ assert body_inputs in captured["recognition"]
+ margin_inputs = next(pages for pages in captured["recognition"] if pages != body_inputs)
+ assert sorted(kind.value for kind in margin_inputs[0]) == [
+ "Page-footer", "Page-footer", "Page-header", "Page-header",
+ ]
+ assert captured["reading_order"] == ([] if provides_reading_order else [body_inputs])
+ assert all(sem is captured["semaphores"][0] for sem in captured["semaphores"])
+ assert result["metadata"]["keep_header_footer"] is True
+ page = result["demo_pages"][0]
+ regions = page["blocks"]
+ assert len({region["idx"] for region in regions}) == len(regions)
+ assert [region["type"] for region in regions] == [
+ "Page-header", "Page-header", *(["Formula"] if with_body else []),
+ "Page-footer", "Page-footer",
+ ]
+ assert [region["content"] for region in regions[:2]] == ["Left header", "Right **header**"]
+ assert [region["content"] for region in regions[-2:]] == ["Top footer", "Bottom footer"]
+ assert page["markdown"] == result["outputs"]["markdown"]
+ lines = page["markdown"].splitlines()
+ for region in regions:
+ assert region["start_line"] is not None and region["end_line"] > region["start_line"]
+ selected = "\n".join(lines[region["start_line"]:region["end_line"]])
+ expected_content = ["x = 1", "(1)", "(2)"] if region["type"] == "Formula" else [region["content"]]
+ for content in expected_content:
+ assert content in selected
+ assert page["markdown"].count(content) == 1
+ assert all(a["end_line"] <= b["start_line"] for a, b in zip(regions, regions[1:]))
+ assert [
+ {key: value for key, value in region.items() if key not in {"start_line", "end_line"}}
+ for region in regions
+ ] == result["outputs"]["json"]["pages"][0]["blocks"]
+ if with_body:
+ assert regions[2]["content"] == r"x = 1\leqno (1)\tag{2}"
+ # Formula-numbering slots remain adjacent after shifting the body indices.
+ assert regions[2]["idx"] == 3
+ assert regions[3]["idx"] == 5
+
+
def test_demo_orphan_numbering_is_a_note_without_a_layout_region(monkeypatch):
formula = block(0, BlockType.FORMULA, "x = 1")
formula.text_after = "(48)"
@@ -201,6 +295,89 @@ def test_demo_orphan_numbering_is_a_note_without_a_layout_region(monkeypatch):
assert page["markdown"] == result["outputs"]["markdown"] == "(48)\n"
[email protected]("provides_reading_order", [False, True])
+def test_demo_margin_failure_cancels_body_work(monkeypatch, provides_reading_order):
+ async def scenario():
+ body_started = asyncio.Event()
+ body_cancelled = asyncio.Event()
+ order_started = asyncio.Event()
+ order_cancelled = asyncio.Event()
+
+ async def layout(*_args):
+ return [[block(0, BlockType.PAGE_HEADER, ""), block(1, BlockType.TEXT, "")]]
+
+ async def recognize(pages, *_args):
+ if pages[0][0].type == BlockType.PAGE_HEADER:
+ await body_started.wait()
+ if not provides_reading_order:
+ await order_started.wait()
+ raise RuntimeError("margin recognition failed")
+ body_started.set()
+ try:
+ await asyncio.Future()
+ finally:
+ body_cancelled.set()
+
+ async def reading_order(*_args):
+ order_started.set()
+ try:
+ await asyncio.Future()
+ finally:
+ order_cancelled.set()
+
+ monkeypatch.setattr(orchestrator, "analyze_layouts", layout)
+ monkeypatch.setattr(orchestrator, "recognize_pages", recognize)
+ monkeypatch.setattr(orchestrator, "resolve_reading_orders", reading_order)
+ monkeypatch.setattr(
+ orchestrator.settings.layout_analyze_model, "provides_reading_order", provides_reading_order,
+ )
+ with pytest.raises(RuntimeError, match="margin recognition failed"):
+ await asyncio.wait_for(orchestrator.process_decoded_document(
+ [np.zeros((30, 40, 3), dtype=np.uint8)], "test.png", ["markdown"],
+ demo=True, keep_header_footer=True,
+ ), timeout=2)
+ # Check while this loop is still running, before asyncio.run's own cleanup.
+ assert body_cancelled.is_set()
+ if not provides_reading_order:
+ assert order_cancelled.is_set()
+ assert image_assets.get() is None
+
+ asyncio.run(scenario())
+
+
[email protected]("keep_header_footer", [None, False, True])
+def test_non_demo_header_footer_recognition_policy_is_unchanged(monkeypatch, keep_header_footer):
+ captured = []
+ header = block(0, BlockType.PAGE_HEADER, "Header")
+ header.bbox = [0, 0, 40, 4]
+ body = block(1, BlockType.TEXT, "Body")
+ body.bbox = [0, 8, 40, 18]
+ footer = block(2, BlockType.PAGE_FOOTER, "Footer")
+ footer.bbox = [0, 26, 40, 30]
+
+ async def layout(*_args):
+ return [[header, body, footer]]
+
+ async def recognize(pages, *_args):
+ captured.append([[region.type for region in page] for page in pages])
+ return pages
+
+ monkeypatch.setattr(orchestrator, "analyze_layouts", layout)
+ monkeypatch.setattr(orchestrator, "recognize_pages", recognize)
+ monkeypatch.setattr(orchestrator.settings.layout_analyze_model, "provides_reading_order", True)
+ options = {} if keep_header_footer is None else {"keep_header_footer": keep_header_footer}
+ result = asyncio.run(orchestrator.process_decoded_document(
+ [np.zeros((30, 40, 3), dtype=np.uint8)], "test.png", ["markdown", "json"], **options,
+ ))
+ expected = [BlockType.PAGE_HEADER, BlockType.TEXT, BlockType.PAGE_FOOTER] if keep_header_footer else [BlockType.TEXT]
+ assert captured == [[expected]]
+ assert [region["type"] for region in result["outputs"]["json"]["pages"][0]["blocks"]] == [kind.value for kind in expected]
+ assert ("Header" in result["outputs"]["markdown"]) is bool(keep_header_footer)
+ assert ("Footer" in result["outputs"]["markdown"]) is bool(keep_header_footer)
+ assert "keep_header_footer" not in result["metadata"]
+ assert "demo_pages" not in result
+
+
def test_markdown_delimiter_repair_preserves_entire_json_and_demo_regions(monkeypatch):
from oxr.pipeline.postprocess import assembly_postprocess
diff --git a/tests/unit/test_recognition_routing.py b/tests/unit/test_recognition_routing.py
index db227d4..fceea09 100644
--- a/tests/unit/test_recognition_routing.py
+++ b/tests/unit/test_recognition_routing.py
@@ -1,6 +1,7 @@
import asyncio
import numpy as np
+import pytest
from oxr.config.settings import settings
from oxr.model.client import ModelOutput
from oxr.pipeline.models import Block, BlockType, ContentFormat
@@ -88,6 +89,27 @@ def test_recognition_outputs_table_markdown_when_requested(monkeypatch):
assert result.content == "| A |\n| --- |\n| B |"
[email protected]("block_type", [BlockType.PAGE_HEADER, BlockType.PAGE_FOOTER])
+def test_recognition_routes_page_margins_to_text(monkeypatch, block_type):
+ calls = []
+ options = {"temperature": 0.4}
+
+ async def recognize_text(image, model_options=None):
+ calls.append((image.shape, model_options))
+ return "Recognized **margin**"
+
+ monkeypatch.setattr(settings.oxr_model, "retry_times", 1)
+ monkeypatch.setattr("oxr.pipeline.recognition.model_client.recognize_text", recognize_text)
+ result = asyncio.run(recognize_block(
+ _block(block_type), np.zeros((8, 8, 3), dtype=np.uint8),
+ asyncio.Semaphore(1), "demo.png", 0, model_options=options,
+ ))
+ assert calls == [((4, 4, 3), options)]
+ assert result.type == block_type
+ assert result.content == "Recognized **margin**"
+ assert result.format == ContentFormat.TEXT
+
+
def test_recognition_routes_chemical_structure_smiles(monkeypatch):
async def recognize_chemical_structure(_image, _model_options=None):
return "CCO"