openmd-cli 0.1.0__py3-none-any.whl

openmd/ocr/layout.py

@@ -0,0 +1,92 @@
+"""Bounded external layout worker; never imports torch in the controller."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+from openmd.runtime.interpreters import owned_popen, communicate_interruptibly, process_options, terminate_quietly, wait_interruptibly, worker_command, worker_environment
+from .config import layout_runtime
+
+from openmd.runtime.tempdirs import owned_temporary_directory
+
+
+class LayoutUnavailable(RuntimeError):
+    pass
+
+
+def _run(args: list[str], timeout: float, directory: Path):
+    python, _ = layout_runtime()
+    if python is None:
+        raise LayoutUnavailable("fallback_unavailable: configure ocr_python / OPENMD_OCR_PYTHON")
+    environment = worker_environment()
+    # Windows CUDA may treat an empty value as unset. -1 hides every device.
+    environment["CUDA_VISIBLE_DEVICES"] = "-1"
+    with (directory / "layout.log").open("wb") as log:
+        process = owned_popen(worker_command(python, *args, module="openmd.ocr.layout_worker"), cwd=directory, env=environment, stdin=subprocess.DEVNULL, stdout=log, stderr=log, **process_options())
+        try:
+            wait_interruptibly(process, timeout)
+        except BaseException:
+            terminate_quietly(process)
+            raise
+    if process.returncode:
+        raise LayoutUnavailable("fallback_unavailable: external layout worker failed; check local torch/transformers and PP-DocLayoutV3 weights")
+
+
+def detect_regions(image, config: dict, deadline: float) -> tuple[list[dict], float]:
+    python, model = layout_runtime()
+    if python is None or model is None:
+        raise LayoutUnavailable("fallback_unavailable: configure ocr_python and a model_roots directory containing layout/PP-DocLayoutV3")
+    start = time.monotonic()
+    remaining = deadline - start
+    if remaining <= 0:
+        raise TimeoutError("page_deadline")
+    try:
+        with owned_temporary_directory(prefix="openmd-layout-") as tmp:
+            directory = Path(tmp)
+            source, result = directory / "input.png", directory / "result.json"
+            image.save(source)
+            _run(["--input", str(source), "--model", str(model), "--result", str(result), "--threshold", str(config["layout_threshold"])], min(config["layout_seconds"], remaining), directory)
+            if not result.is_file() or result.stat().st_size > 4 * 1024 * 1024:
+                raise LayoutUnavailable("fallback_unavailable: invalid layout worker result")
+            payload = json.loads(result.read_text(encoding="utf-8"))
+            regions = payload.get("regions")
+            if payload.get("schema") != "openmd.layout/v1" or not isinstance(regions, list) or not regions:
+                raise LayoutUnavailable("fallback_unavailable: no layout regions")
+            for region in regions:
+                box = region.get("bbox")
+                if not isinstance(region.get("category"), str) or not isinstance(box, list) or len(box) != 4 or not all(isinstance(v, int) for v in box) or not (0 <= box[0] < box[2] <= image.width and 0 <= box[1] < box[3] <= image.height):
+                    raise LayoutUnavailable("fallback_unavailable: invalid layout region")
+            return regions, time.monotonic() - start
+    except (OSError, ValueError, subprocess.SubprocessError) as exc:
+        raise LayoutUnavailable("fallback_unavailable: external layout worker unavailable") from exc
+
+
+def probe_layout() -> dict:
+    python, model = layout_runtime()
+    report = {"python_configured": python is not None, "model_available": model is not None, "ready": False}
+    if python is None or model is None:
+        return report
+    try:
+        with owned_temporary_directory(prefix="openmd-layout-probe-") as tmp:
+            directory = Path(tmp)
+            environment = worker_environment()
+            environment["CUDA_VISIBLE_DEVICES"] = "-1"
+            process = owned_popen(worker_command(python, "--probe", module="openmd.ocr.layout_worker"), cwd=directory, env=environment, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **process_options())
+            try:
+                stdout, _ = communicate_interruptibly(process, timeout=15)
+            except BaseException:
+                terminate_quietly(process)
+                raise
+            if process.returncode or len(stdout) > 1024 * 1024:
+                raise ValueError("layout probe failed")
+            payload = json.loads(stdout)
+            if payload.get("schema") != "openmd.layout-probe/v1":
+                raise ValueError("invalid layout probe")
+            report.update(payload)
+    except (OSError, ValueError, subprocess.SubprocessError):
+        report["error_code"] = "fallback_unavailable"
+    return report

openmd/ocr/layout_filter.py

@@ -0,0 +1,118 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# Verbatim rect-layout functions; polygon branch not used.
+from copy import deepcopy
+from typing import Dict,List,Tuple
+import numpy as np
+
+def _compute_pairwise_overlap_small(
+    coords: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Compute pairwise overlap ratio (mode="small") and bbox areas.
+
+    This only replaces the numeric overlap/area calculation. The caller keeps
+    the original sequential dropping order because it affects inline formulas.
+    """
+    x1 = coords[:, 0]
+    y1 = coords[:, 1]
+    x2 = coords[:, 2]
+    y2 = coords[:, 3]
+
+    areas = np.abs((x2 - x1) * (y2 - y1))
+
+    inter_x1 = np.maximum(x1[:, None], x1[None, :])
+    inter_y1 = np.maximum(y1[:, None], y1[None, :])
+    inter_x2 = np.minimum(x2[:, None], x2[None, :])
+    inter_y2 = np.minimum(y2[:, None], y2[None, :])
+
+    inter_w = np.maximum(0, inter_x2 - inter_x1)
+    inter_h = np.maximum(0, inter_y2 - inter_y1)
+    inter_area = inter_w * inter_h
+
+    small_area = np.minimum(areas[:, None], areas[None, :])
+    with np.errstate(divide="ignore", invalid="ignore"):
+        overlap = np.where(small_area > 0, inter_area / small_area, 0.0)
+    return overlap, areas
+
+
+def filter_overlap_boxes(
+    layout_det_res: Dict[str, List[Dict]], layout_shape_mode: str
+) -> Dict[str, List[Dict]]:
+    """
+    Remove overlapping boxes from layout detection results based on a given overlap ratio.
+
+    Args:
+        layout_det_res (Dict[str, List[Dict]]): Layout detection result dict containing a 'boxes' list.
+
+    Returns:
+        Dict[str, List[Dict]]: Filtered dict with overlapping boxes removed.
+    """
+    layout_det_res_filtered = deepcopy(layout_det_res)
+    boxes = [
+        box for box in layout_det_res_filtered["boxes"] if box["label"] != "reference"
+    ]
+    if not boxes:
+        layout_det_res_filtered["boxes"] = boxes
+        return layout_det_res_filtered
+
+    coords = np.array([box["coordinate"] for box in boxes], dtype=np.float64)
+    widths = coords[:, 2] - coords[:, 0]
+    heights = coords[:, 3] - coords[:, 1]
+    overlap_matrix, areas = _compute_pairwise_overlap_small(coords)
+    dropped_indexes = set()
+
+    for i in range(len(boxes)):
+        if widths[i] < 6 or heights[i] < 6:
+            dropped_indexes.add(i)
+        for j in range(i + 1, len(boxes)):
+            if i in dropped_indexes or j in dropped_indexes:
+                continue
+            overlap_ratio = overlap_matrix[i, j]
+            if (
+                boxes[i]["label"] == "inline_formula"
+                or boxes[j]["label"] == "inline_formula"
+            ):
+                if overlap_ratio > 0.5:
+                    if boxes[i]["label"] == "inline_formula":
+                        dropped_indexes.add(i)
+                    if boxes[j]["label"] == "inline_formula":
+                        dropped_indexes.add(j)
+                    continue
+            if overlap_ratio > 0.7:
+                if layout_shape_mode != "rect" and "polygon_points" in boxes[i]:
+                    poly_overlap_ratio = calculate_polygon_overlap_ratio(
+                        boxes[i]["polygon_points"], boxes[j]["polygon_points"], "small"
+                    )
+                    if poly_overlap_ratio < 0.7:
+                        continue
+                labels = {boxes[i]["label"], boxes[j]["label"]}
+                if labels & {"image", "table", "seal", "chart"} and len(labels) > 1:
+                    if "table" not in labels or labels <= {
+                        "table",
+                        "image",
+                        "seal",
+                        "chart",
+                    }:
+                        continue
+                if areas[i] >= areas[j]:
+                    dropped_indexes.add(j)
+                else:
+                    dropped_indexes.add(i)
+    layout_det_res_filtered["boxes"] = [
+        box for idx, box in enumerate(boxes) if idx not in dropped_indexes
+    ]
+    return layout_det_res_filtered

openmd/ocr/layout_worker.py

@@ -0,0 +1,89 @@
+"""Offline PP-DocLayoutV3 CPU worker. No OCR model is loaded here."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import importlib.util
+import json
+import math
+import os
+from pathlib import Path
+
+
+def detect(image, folder: Path, threshold: float) -> list[dict]:
+    import torch
+    import transformers
+    from .layout_filter import filter_overlap_boxes
+
+    assert_cpu_only(torch)
+    torch.set_num_threads(4)
+    processor_class = getattr(transformers, "PPDocLayoutV3ImageProcessorFast", transformers.AutoImageProcessor)
+    processor = processor_class.from_pretrained(folder, local_files_only=True, trust_remote_code=False)
+    model = transformers.AutoModelForObjectDetection.from_pretrained(folder, local_files_only=True, trust_remote_code=False, torch_dtype=torch.float32).to("cpu").eval()
+    inputs = processor(images=image, return_tensors="pt")
+    with torch.inference_mode():
+        output = model(**inputs)
+    result = processor.post_process_object_detection(output, target_sizes=[(image.height, image.width)], threshold=threshold)[0]
+    regions = []
+    for index, (box, label, score) in enumerate(zip(result["boxes"], result["labels"], result["scores"])):
+        left, top, right, bottom = [float(v) for v in box]
+        coords = [max(0, math.floor(left)), max(0, math.floor(top)), min(image.width, math.ceil(right)), min(image.height, math.ceil(bottom))]
+        if coords[2] <= coords[0] or coords[3] <= coords[1]:
+            continue
+        labels = model.config.id2label
+        category = labels.get(int(label), labels.get(str(int(label)), str(int(label))))
+        regions.append({"order": index, "category": category, "bbox": coords, "score": float(score), "label": category, "coordinate": coords})
+    # Preserve the learned upstream reading order, including inline formula filtering.
+    filtered = filter_overlap_boxes({"boxes": regions}, "rect")["boxes"]
+    return [{key: value for key, value in region.items() if key not in {"label", "coordinate"}} for region in filtered]
+
+
+def assert_cpu_only(torch=None) -> None:
+    # Reject a mis-launched worker instead of silently hiding a visible GPU.
+    # The controller passes -1: an empty Windows environment value can leave
+    # CUDA visible. Even an explicit mask must pass the actual runtime check.
+    if os.environ.get("CUDA_VISIBLE_DEVICES") not in {"", "-1"}:
+        raise RuntimeError("layout_cpu_only: CUDA_VISIBLE_DEVICES must hide all devices")
+    if torch is not None and torch.cuda.is_available():
+        raise RuntimeError("layout_cpu_only: CUDA is visible to the layout worker")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--probe", action="store_true")
+    parser.add_argument("--input", type=Path)
+    parser.add_argument("--model", type=Path)
+    parser.add_argument("--result", type=Path)
+    parser.add_argument("--threshold", type=float, default=0.5)
+    args = parser.parse_args()
+    assert_cpu_only()
+    os.environ.update({"HF_HUB_OFFLINE": "1", "TRANSFORMERS_OFFLINE": "1", "TOKENIZERS_PARALLELISM": "false"})
+    if args.probe:
+        modules = {name: importlib.util.find_spec(name) is not None for name in ("torch", "transformers", "PIL", "numpy", "torchvision")}
+        cuda_visible = None
+        if modules["torch"]:
+            import torch
+
+            assert_cpu_only(torch)
+            cuda_visible = torch.cuda.is_available()
+        versions = {}
+        for name in ("torch", "transformers", "torchvision"):
+            try:
+                versions[name] = importlib.metadata.version(name)
+            except importlib.metadata.PackageNotFoundError:
+                versions[name] = None
+        print(json.dumps({"schema": "openmd.layout-probe/v1", "ready": all(modules.values()), "modules": modules, "versions": versions, "device": "cpu", "cpu_only": True, "cuda_visible": cuda_visible}))
+        return 0
+    if args.input is None or args.model is None or args.result is None:
+        parser.error("--input, --model and --result required")
+    from PIL import Image
+
+    with Image.open(args.input) as source:
+        regions = detect(source.convert("RGB"), args.model, args.threshold)
+    args.result.write_text(json.dumps({"schema": "openmd.layout/v1", "regions": regions}), encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

openmd/ocr/native_math.py

@@ -0,0 +1,220 @@
+"""Restore supported DOCX formula structure only with unique native text proof."""
+
+from __future__ import annotations
+
+import re
+from io import BytesIO
+from pathlib import Path
+from xml.etree import ElementTree as ET
+from zipfile import BadZipFile, ZipFile
+
+
+_MATH = "{http://schemas.openxmlformats.org/officeDocument/2006/math}"
+_WORD_NAMESPACES = {"http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+                    "http://purl.oclc.org/ooxml/wordprocessingml/main"}
+_COMPATIBILITY = "{http://schemas.openxmlformats.org/markup-compatibility/2006}"
+
+
+def _xml_source(data):
+    """Retain namespace scopes needed to interpret mc:Ignorable accurately."""
+    scopes, pending, ignored = [], {}, {}
+    for event, value in ET.iterparse(BytesIO(data), events=("start", "end", "start-ns")):
+        if event == "start-ns":
+            pending[value[0]] = value[1]
+        elif event == "start":
+            names = dict(scopes[-1][0]) if scopes else {}
+            names.update(pending)
+            pending.clear()
+            namespaces = set(scopes[-1][1]) if scopes else set()
+            namespaces.update(names.get(prefix, "") for prefix in value.get(_COMPATIBILITY + "Ignorable", "").split())
+            ignored[value] = value.tag.partition("}")[0].removeprefix("{") in namespaces
+            scopes.append((names, namespaces))
+        else:
+            scopes.pop()
+    return value, ignored
+
+
+def _permitted_math_sources(roots, ignored) -> list[str]:
+    """Prove the entire ancestry, not just absence of known unsafe wrappers.
+
+    This intentionally accepts a small rendering grammar. Properties, extension
+    wrappers and other parts cannot acquire identity from matching PDF digits.
+    Header/footer math is checked but only main-document math is restored.
+    """
+    reasons = set()
+    for part, root in roots.items():
+        if not any(n.tag.rsplit('}', 1)[-1] in {"oMath", "oMathPara"} for n in root.iter()):
+            continue
+        expected = "document" if part == "word/document.xml" else (
+            "hdr" if re.fullmatch(r"word/header[0-9]+\.xml", part) else
+            "ftr" if re.fullmatch(r"word/footer[0-9]+\.xml", part) else None)
+        namespace = next((ns for ns in _WORD_NAMESPACES if root.tag == "{" + ns + "}" + str(expected)), None)
+        if expected is None or namespace is None:
+            reasons.add("omml_unapproved_part_or_root")
+            continue
+        word = "{" + namespace + "}"
+        # Every edge on the path to an equation must be explicitly recognized.
+        edges = {
+            word + "document": {word + "body"},
+            **{word + n: {word + "p", word + "tbl"} for n in ("body", "hdr", "ftr", "tc")},
+            word + "tbl": {word + "tr"}, word + "tr": {word + "tc"},
+            word + "p": {word + "r", _MATH + "oMathPara", _MATH + "oMath"},
+            # Inline (run-level) oMath is a sibling of w:r inside w:p. CT_R
+            # itself is not an equation container.
+            _MATH + "oMathPara": {_MATH + "oMath"},
+        }
+        def visit(node, permitted):
+            if node.tag.rsplit('}', 1)[-1] in {"oMath", "oMathPara"}:
+                if not permitted or node.tag not in {_MATH + "oMath", _MATH + "oMathPara"}:
+                    reasons.add("omml_unapproved_ancestor")
+            for child in node:
+                visit(child, permitted and child.tag in edges.get(node.tag, set()) and not ignored.get(child, False))
+        visit(root, not ignored.get(root, False))
+    return sorted(reasons)
+
+
+def _ambiguous_rendering(roots) -> list[str]:
+    """A source-wide veto avoids guessing a converter's rendered branch."""
+    reasons = set()
+    for root in roots:
+        for node in root.iter():
+            if node.tag == _COMPATIBILITY + "AlternateContent":
+                reasons.add("alternate_content")
+            for namespace in _WORD_NAMESPACES:
+                prefix = "{" + namespace + "}"
+                if not node.tag.startswith(prefix):
+                    continue
+                kind = node.tag.removeprefix(prefix)
+                if kind in {"ins", "del"} or kind.startswith(("moveFrom", "moveTo")) or kind.endswith("PrChange"):
+                    reasons.add("revision_markup")
+                if kind in {"fldSimple", "fldChar", "instrText", "delInstrText"}:
+                    reasons.add("field_code")
+                if kind in {"vanish", "webHidden"}:
+                    reasons.add("hidden_content")
+                if kind in {"altChunk", "subDoc", "dataBinding"}:
+                    reasons.add("dynamic_content")
+    return sorted(reasons)
+
+
+def _formula(node) -> tuple[str, str]:
+    """Return extraction-order characters and explicit source math structure.
+
+    This deliberately supports a small OMML subset. Unknown structures cannot
+    be flattened speculatively. Formatting properties do not supply characters.
+    """
+    kind = node.tag.removeprefix(_MATH)
+
+    def child(name):
+        matches = node.findall(_MATH + name)
+        if len(matches) != 1:
+            raise ValueError("missing_or_duplicate_math_component")
+        return _formula(matches[0])
+
+    if node.tag == _MATH + "t":
+        value = node.text or ""
+        # Do not interpret literal TeX syntax from a text run as markup.
+        if any(c in value for c in "\\{}$&#_%^"):
+            raise ValueError("literal_math_markup")
+        return value, value
+    containers = {"oMath", "r", "e", "sub", "sup", "num", "den"}
+    components = {"sSub": {"e", "sub", "sSubPr"}, "sSup": {"e", "sup", "sSupPr"},
+                  "sSubSup": {"e", "sub", "sup", "sSubSupPr"},
+                  "f": {"num", "den", "fPr"}, "nary": {"sub", "sup", "e", "naryPr"}}
+    if kind not in containers | components.keys() or not node.tag.startswith(_MATH):
+        raise ValueError("unsupported_math_structure")
+    if kind in components and any(c.tag not in {_MATH + n for n in components[kind]} for c in node):
+        raise ValueError("unsupported_math_component")
+    if kind in {"sSub", "sSup", "sSubSup"}:
+        plain, markup = child("e")
+        for name, operator in (("sub", "_"), ("sup", "^")):
+            if name == "sub" and kind == "sSup" or name == "sup" and kind == "sSub":
+                continue
+            raw, rendered = child(name)
+            plain += raw
+            markup += operator + "{" + rendered + "}"
+        return plain, markup
+    if kind == "f":
+        fraction_type = node.find(_MATH + "fPr/" + _MATH + "type")
+        if fraction_type is not None and fraction_type.get(_MATH + "val") != "bar":
+            raise ValueError("unsupported_fraction_type")
+        numerator, denominator = child("num"), child("den")
+        return numerator[0] + denominator[0], "\\frac{" + numerator[1] + "}{" + denominator[1] + "}"
+    if kind == "nary":
+        symbol = node.find(_MATH + "naryPr/" + _MATH + "chr")
+        symbol = symbol.get(_MATH + "val", "") if symbol is not None else ""
+        if symbol not in {"∑", "∏", "∫", "∬", "∭", "⋃", "⋂"}:
+            raise ValueError("unsupported_nary_symbol")
+        lower, upper, expression = child("sub"), child("sup"), child("e")
+        return symbol + lower[0] + upper[0] + expression[0], symbol + "_{" + lower[1] + "}^{" + upper[1] + "}" + expression[1]
+    pairs = [_formula(c) for c in node if c.tag not in {
+        _MATH + "rPr", "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}rPr"}]
+    return "".join(p[0] for p in pairs), "".join(p[1] for p in pairs)
+
+
+def restore_docx_math(path: Path, text: str) -> tuple[str, dict]:
+    """Never change characters without a unique, whitespace-only native match.
+
+    Caller must already have proved every output page's text layer reliable.
+    No OCR, URL resolution, normalization, numerical correction or guessing.
+    """
+    receipt = {"source": "docx_omml", "formulas": 0, "restored": 0, "unmatched": 0, "unsupported": 0,
+               "match_rule": "unique_raw_characters_ignoring_whitespace_within_paragraph"}
+    try:
+        with ZipFile(path) as archive:
+            roots, ignored = {}, {}
+            names = archive.namelist()
+            if len(names) != len(set(names)):
+                receipt.update(disabled=True, reason="ambiguous_source_parts", disabled_reasons=["duplicate_source_part"])
+                return text, receipt
+            for name in names:
+                data = archive.read(name)
+                # OPC XML parts need not use .xml names. Unrecognized XML can
+                # contain equations too; media bytes grant no source identity.
+                looks_xml = data.lstrip().startswith((b"<", b"\xef\xbb\xbf", b"\xff\xfe", b"\xfe\xff"))
+                if name.lower().endswith((".xml", ".vml")) or looks_xml:
+                    roots[name], scope = _xml_source(data)
+                    ignored.update(scope)
+            root = roots["word/document.xml"]
+    except (OSError, BadZipFile, KeyError, ET.ParseError):
+        receipt["source_unavailable"] = True
+        return text, receipt
+    reasons = _ambiguous_rendering(roots.values())
+    if reasons:
+        receipt.update({"disabled": True, "reason": "ambiguous_document_rendering", "disabled_reasons": reasons})
+        return text, receipt
+    reasons = _permitted_math_sources(roots, ignored)
+    if reasons:
+        receipt.update({"disabled": True, "reason": "unapproved_omml_rendering_path", "disabled_reasons": reasons})
+        return text, receipt
+    offsets = [i for i, c in enumerate(text) if not c.isspace()]
+    compact = "".join(text[i] for i in offsets)
+    replacements = []
+    for node in root.iter(_MATH + "oMath"):
+        receipt["formulas"] += 1
+        try:
+            plain, markup = _formula(node)
+        except ValueError:
+            receipt["unsupported"] += 1
+            continue
+        needle = "".join(c for c in plain if not c.isspace())
+        start = compact.find(needle)
+        if len(needle) < 4 or start < 0 or compact.find(needle, start + 1) >= 0:
+            receipt["unmatched"] += 1
+            continue
+        end = start + len(needle)
+        # Native PDF extraction uses blank lines for paragraph boundaries.
+        # Whitespace-insensitive matching must never bridge those boundaries
+        # (or a page break), even if the combined characters occur only once.
+        candidate = text[offsets[start]:offsets[end - 1] + 1]
+        if re.search(r"\n[ \t\r]*\n|\f", candidate):
+            receipt["unmatched"] += 1
+            receipt["paragraph_boundary_rejections"] = receipt.get("paragraph_boundary_rejections", 0) + 1
+            continue
+        replacements.append((offsets[start], offsets[end - 1] + 1, "$" + markup + "$"))
+    # Repeated source formulas or nested/overlapping matches are not unique proof.
+    unique = [r for r in replacements if sum(r[0] < s[1] and s[0] < r[1] for s in replacements) == 1]
+    receipt["unmatched"] += len(replacements) - len(unique)
+    for start, end, replacement in sorted(unique, reverse=True):
+        text = text[:start] + replacement + text[end:]
+        receipt["restored"] += 1
+    return text, receipt