docvortex 0.2.3__tar.gz → 0.2.4__tar.gz

{docvortex-0.2.3/src/docvortex.egg-info → docvortex-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docvortex
-Version: 0.2.3
+Version: 0.2.4
 Summary: A fast, multi-format document parsing and conversion engine
 License-Expression: MIT
 Project-URL: Repository, https://github.com/myhloli/DocVortex
@@ -35,6 +35,7 @@ Requires-Dist: olefile<1,>=0.47
 Requires-Dist: pylatexenc<3,>=2.10
 Requires-Dist: latex2mathml<4,>=3.81.0
 Requires-Dist: mathml2omml==0.0.2
+Requires-Dist: resvg_py<0.6,>=0.5.0
 Requires-Dist: reportlab
 Requires-Dist: ziamath<0.14,>=0.13
 Requires-Dist: fast-langdetect<0.3.0,>=0.2.3

{docvortex-0.2.3 → docvortex-0.2.4}/pyproject.toml

@@ -26,6 +26,7 @@ dependencies = [
     "python-docx>=1.2.0,<2", "pypptx-with-oxml>=1.0.3,<2",
     "mammoth>=1.11.0,<2", "openpyxl>=3.1.5,<4", "olefile>=0.47,<1",
     "pylatexenc>=2.10,<3", "latex2mathml>=3.81.0,<4", "mathml2omml==0.0.2",
+    "resvg_py>=0.5.0,<0.6",
     "reportlab", "ziamath>=0.13,<0.14", "fast-langdetect>=0.2.3,<0.3.0",
     "magika>=0.6.2,<1.1.0", "opencv-python>=4.11.0.86",
 ]

{docvortex-0.2.3 → docvortex-0.2.4}/src/docvortex/analyzers/native/models.py

@@ -66,14 +66,20 @@ class HtmlModel:
 
 
 class OfdModel:
-    """将 OFD 固定版式文档包装为无状态 Flash 模型。"""
+    """包装 OFD 固定版式解析，保留最近一次调用的非致命诊断。"""
+
+    def __init__(self) -> None:
+        """初始化实例级诊断，避免不同文档间串用结果。"""
+        self.diagnostics: list[dict[str, Any]] = []
 
     def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
         """转换调用方持有的整份 OFD 流，并返回逐物理页 model-list。"""
         from .ofd.converter import OfdConverter
 
+        self.diagnostics = []
         converter = OfdConverter()
         converter.convert(file_binary)
+        self.diagnostics = converter.diagnostics
         return converter.pages
 
 

docvortex-0.2.4/src/docvortex/analyzers/native/ofd/assembly.py

@@ -0,0 +1,192 @@
+"""在 OFD 所属区域内恢复视觉行、样式片段和保守段落。"""
+
+from __future__ import annotations
+
+import math
+import re
+import statistics
+from dataclasses import replace
+from typing import Any
+
+from ....schema import BBox, BlockType
+from .geometry import bbox_union
+from .models import TextLine
+from .text import format_line_html, format_line_spans
+
+_LIST_START = re.compile(r"^\s*(?:[•●▪◆]|[-*]\s|\d+[.)、]\s*|[一二三四五六七八九十]+[、）])")
+
+
+def upright_point(x: float, y: float, angle: int) -> tuple[float, float]:
+    """将页面点旋转到文字阅读方向，统一横排与直角旋转的几何计算。"""
+    radians = math.radians(angle)
+    cosine, sine = round(math.cos(radians), 12), round(math.sin(radians), 12)
+    return cosine * x + sine * y, -sine * x + cosine * y
+
+
+def upright_box(bbox: BBox, angle: int) -> BBox:
+    """在文字方向坐标内计算矩形外接框。"""
+    points = [upright_point(x, y, angle) for x in (bbox[0], bbox[2]) for y in (bbox[1], bbox[3])]
+    return min(p[0] for p in points), min(p[1] for p in points), max(p[0] for p in points), max(p[1] for p in points)
+
+
+def line_baseline(line: TextLine) -> float:
+    """优先读取真实字形基线，缺少字形时才退回视觉框中心。"""
+    if line.glyphs:
+        return statistics.median(upright_point(*glyph.origin, line.angle)[1] for glyph in line.glyphs)
+    box = upright_box(line.bbox, line.angle)
+    return (box[1] + box[3]) / 2
+
+
+def line_runs(line: TextLine) -> tuple[tuple[str, tuple[str, ...]], ...]:
+    """读取已组装行的样式片段，原始行按其自身样式返回单个片段。"""
+    return line.runs or ((line.text, line.styles),)
+
+
+def line_spans(line: TextLine) -> list[dict[str, object]]:
+    """将视觉行的各样式片段投影为既有结构化 Span。"""
+    return [span for text, styles in line_runs(line) for span in format_line_spans(text, styles)]
+
+
+def line_html(line: TextLine) -> str:
+    """按片段样式序列化单元格文字，不把首片段样式扩散到整行。"""
+    return "".join(format_line_html(text, styles) for text, styles in line_runs(line))
+
+
+def _fragment_separator(first: TextLine, second: TextLine) -> str:
+    """仅在英文单词片段之间存在可见词间距时补空格。"""
+    if not first.text or not second.text:
+        return ""
+    if not (first.text[-1].isascii() and second.text[0].isascii() and first.text[-1].isalnum() and second.text[0].isalnum()):
+        return ""
+    first_box = upright_box(first.glyphs[-1].bbox if first.glyphs else first.bbox, first.angle)
+    second_box = upright_box(second.glyphs[0].bbox if second.glyphs else second.bbox, second.angle)
+    widths = [box[2] - box[0] for box in (first_box, second_box)]
+    threshold = 0.2 * max(min(first.font_size, second.font_size), statistics.median(widths), 0.5)
+    return " " if second_box[0] - first_box[2] >= threshold else ""
+
+
+def merge_same_baseline_lines(lines: list[TextLine]) -> list[TextLine]:
+    """按真实基线聚行并沿阅读方向拼接，保留样式及层和模板隔离。"""
+    metrics = {id(line): (line_baseline(line), upright_box(line.bbox, line.angle)) for line in lines}
+    ordered = sorted(lines, key=lambda line: (line.angle, line.layer_type, line.template_id or -1, metrics[id(line)][0]))
+    rows: list[list[TextLine]] = []
+    for line in ordered:
+        previous = rows[-1][0] if rows else None
+        if (
+            previous is not None
+            and (line.angle, line.layer_type, line.template_id) == (previous.angle, previous.layer_type, previous.template_id)
+            and abs(metrics[id(line)][0] - metrics[id(previous)][0]) <= 0.2 * min(line.font_size, previous.font_size)
+        ):
+            rows[-1].append(line)
+        else:
+            rows.append([line])
+    output: list[TextLine] = []
+    for row in rows:
+        fragments = sorted(row, key=lambda line: (metrics[id(line)][1][0], line.paint_order))
+        assembled: list[TextLine] = []
+        for line in fragments:
+            previous = assembled[-1] if assembled else None
+            if previous is not None:
+                first_box, second_box = upright_box(previous.bbox, line.angle), metrics[id(line)][1]
+                size = min(previous.font_size, line.font_size)
+                gap = second_box[0] - first_box[2]
+                if size > 0 and max(previous.font_size, line.font_size) <= 1.35 * size and -0.25 * size <= gap <= 0.8 * size:
+                    separator = _fragment_separator(previous, line)
+                    runs = line_runs(previous) + (((separator, ()),) if separator else ()) + line_runs(line)
+                    assembled[-1] = replace(
+                        previous,
+                        text=previous.text + separator + line.text,
+                        bbox=bbox_union((previous.bbox, line.bbox)) or previous.bbox,
+                        glyphs=previous.glyphs + line.glyphs,
+                        paint_order=min(previous.paint_order, line.paint_order),
+                        runs=runs,
+                    )
+                    continue
+            assembled.append(line)
+        output.extend(assembled)
+    return output
+
+
+def _block_text(block: dict[str, Any]) -> str:
+    """读取 OFD 私有视觉行文本，避免依赖公共 Span 的序列化细节。"""
+    return block.get("text_line", "")
+
+
+def _paragraph_separator(previous: str, current: str) -> str:
+    """中文换行直接续接，英文词和句末标点后的换行补空格，保留已有空白与连字符。"""
+    last, first = previous[-1:], current[:1]
+    if not last or not first or not (last.isascii() and first.isascii()):
+        return ""
+    return " " if (last.isalnum() or last in '.,;:!?)]}"') and (first.isalnum() or first in '(["') else ""
+
+
+def merge_paragraph_blocks(blocks: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """在阅读顺序内按局部栏宽、行距及缩进合段，视觉块和辅助块作为屏障。"""
+    output: list[dict[str, Any]] = []
+    for index, block in enumerate(blocks):
+        if block["type"] != BlockType.TEXT:
+            output.append(block)
+            continue
+        angle = block["angle"]
+        current_box = upright_box(block["bbox_mm"], angle)
+        size = block["font_size_mm"]
+        # 只观察邻近且横向重叠的正文，防止另一栏或远处区域影响本栏尺度。
+        neighbors: list[dict[str, Any]] = []
+        for direction in (-1, 1):
+            for offset in range(1, 9):
+                position = index + direction * offset
+                if not 0 <= position < len(blocks):
+                    break
+                candidate = blocks[position]
+                if (
+                    candidate["type"] != BlockType.TEXT
+                    or candidate["angle"] != angle
+                    or candidate["text_scope"] != block["text_scope"]
+                ):
+                    break
+                box = upright_box(candidate["bbox_mm"], angle)
+                if abs(box[1] - current_box[1]) > 20 * size or min(box[2], current_box[2]) <= max(box[0], current_box[0]):
+                    break
+                if abs(box[0] - current_box[0]) <= 3 * size:
+                    neighbors.append(candidate)
+        context = neighbors + [block]
+        boxes = [upright_box(item["bbox_mm"], angle) for item in context]
+        right = max(box[2] for box in boxes)
+        baselines = sorted({item["baseline_mm"] for item in context})
+        gaps = [b - a for a, b in zip(baselines[:-1], baselines[1:], strict=True) if b - a >= 0.5 * size]
+        pitch = statistics.median(gaps) if gaps else 1.5 * size
+        previous = output[-1] if output else None
+        can_merge = (
+            previous is not None
+            and previous["type"] == BlockType.TEXT
+            and previous["angle"] == angle
+            and previous["text_scope"] == block["text_scope"]
+        )
+        if can_merge:
+            last_box = upright_box(previous["line_bboxes_mm"][-1], angle)
+            previous_size = previous["font_size_mm"]
+            delta = block["baseline_mm"] - previous["baseline_mm"]
+            previous_text, current_text = _block_text(previous).strip(), _block_text(block).strip()
+            can_merge = (
+                min(size, previous_size) > 0
+                and max(size, previous_size) <= 1.25 * min(size, previous_size)
+                and 0.5 * size <= delta <= min(1.4 * pitch, 3 * size)
+                and -2.5 * size <= current_box[0] - last_box[0] <= 0.8 * size
+                and right - last_box[2] <= 1.5 * size
+                and min(last_box[2], current_box[2]) > max(last_box[0], current_box[0])
+                and not _LIST_START.match(current_text)
+                and not (len(previous_text) <= 4 or len(current_text) <= 4)
+            )
+        if can_merge:
+            previous_text, current_text = _block_text(previous), _block_text(block)
+            separator = _paragraph_separator(previous_text, current_text)
+            previous["content"].extend(format_line_spans(separator, ()))
+            previous["content"].extend(block["content"])
+            previous["bbox_mm"] = bbox_union((previous["bbox_mm"], block["bbox_mm"]))
+            previous["line_bboxes_mm"].extend(block["line_bboxes_mm"])
+            previous["baseline_mm"] = block["baseline_mm"]
+            previous["text_line"] = current_text
+        else:
+            # 复制将被追加的列表，确保组段不会修改调用方的原始视觉行。
+            output.append({**block, "content": list(block["content"]), "line_bboxes_mm": list(block["line_bboxes_mm"])})
+    return output

docvortex-0.2.4/src/docvortex/analyzers/native/ofd/converter.py

@@ -0,0 +1,69 @@
+"""OFD 二进制流到分页 raw model-list 的转换入口。"""
+
+from __future__ import annotations
+
+from typing import BinaryIO
+import base64
+
+from .constants import MAX_TOTAL_BYTES
+from .errors import OfdResourceLimitError
+from .package import OfdPackage
+from .reading_order import OfdReadingOrderProjector
+from .scene import OfdSceneBuilder
+from .models import ImageItem
+from .vector import render_vector_page, UnsupportedVector
+
+
+class OfdConverter:
+    """编排 OFD 包读取、场景构建和阅读顺序投影。"""
+
+    def __init__(self) -> None:
+        """初始化空的分页输出。"""
+        self.pages: list[list[dict[str, object]]] = []
+        self.diagnostics: list[dict[str, object]] = []
+
+    def convert(self, file_binary: BinaryIO) -> None:
+        """读取整份 OFD 并更新分页 model-list。"""
+        self.pages = []
+        self.diagnostics = []
+        file_bytes = file_binary.read(MAX_TOTAL_BYTES + 1)
+        if len(file_bytes) > MAX_TOTAL_BYTES:
+            raise OfdResourceLimitError(f"OFD resource limit exceeded: max_total_bytes={MAX_TOTAL_BYTES}")
+        with OfdPackage(file_bytes) as package:
+            scenes = OfdSceneBuilder(package).build()
+            for scene in scenes:
+                if (
+                    not scene.text_object_count
+                    and not scene.image_object_count
+                    and scene.vector_paths
+                    and not scene.vector_unsupported
+                ):
+                    try:
+                        payload = render_vector_page(scene, package)
+                    except OfdResourceLimitError:
+                        raise
+                    except (UnsupportedVector, ValueError, RuntimeError, OSError) as exc:
+                        scene.diagnostics.append({"code": "ofd_vector_render_failed", "message": str(exc)})
+                    else:
+                        if payload is not None:
+                            scene.images.append(
+                                ImageItem(
+                                    scene.physical_box,
+                                    "data:image/png;base64," + base64.b64encode(payload).decode("ascii"),
+                                    0,
+                                    None,
+                                    "Body",
+                                    None,
+                                )
+                            )
+                            scene.diagnostics.append(
+                                {
+                                    "code": "ofd_vector_rasterized",
+                                    "message": "Vector-only page preserved as an image; no text recognition was performed",
+                                }
+                            )
+                self.diagnostics.extend({**item, "page_index": scene.page_idx} for item in scene.diagnostics)
+            self.pages = OfdReadingOrderProjector(scenes).project()
+
+
+__all__ = ["OfdConverter"]

{docvortex-0.2.3 → docvortex-0.2.4}/src/docvortex/analyzers/native/ofd/models.py

@@ -3,13 +3,16 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, TYPE_CHECKING
 
 from lxml import etree  # type: ignore[reportMissingImports]
 
 from ....schema import BBox
 from .geometry import Affine, Point, Quad
 
+if TYPE_CHECKING:
+    from .vector import VectorPath, ClipPath
+
 
 @dataclass(frozen=True, slots=True)
 class FontResource:
@@ -78,6 +81,7 @@ class TextLine:
     layer_type: str
     template_id: int | None
     styles: tuple[str, ...] = ()
+    runs: tuple[tuple[str, tuple[str, ...]], ...] = ()
 
 
 @dataclass(frozen=True, slots=True)
@@ -115,6 +119,10 @@ class OfdPageScene:
     axis_lines: list[AxisLine] = field(default_factory=list)
     images: list[ImageItem] = field(default_factory=list)
     diagnostics: list[dict[str, Any]] = field(default_factory=list)
+    vector_paths: list[VectorPath] = field(default_factory=list)
+    text_object_count: int = 0
+    image_object_count: int = 0
+    vector_unsupported: bool = False
 
 
 @dataclass(frozen=True, slots=True)
@@ -151,6 +159,7 @@ class PageBuildContext:
     layer_type: str
     template_id: int | None
     draw_style: dict[str, str] = field(default_factory=dict)
+    vector_clips: tuple[tuple[ClipPath, ...], ...] = ()
 
 
 __all__ = [

{docvortex-0.2.3 → docvortex-0.2.4}/src/docvortex/analyzers/native/ofd/package.py

@@ -101,6 +101,12 @@ class OfdPackage:
         self._asset_bytes = 0
         self._root: etree._Element | None = None
 
+    def charge_generated_asset(self, size: int) -> None:
+        """将生成的 PNG 与包内读取素材累计到同一文档资产预算。"""
+        if self._asset_bytes + size > MAX_ASSET_TOTAL_BYTES:
+            raise OfdResourceLimitError(f"OFD resource limit exceeded: max_asset_total_bytes={MAX_ASSET_TOTAL_BYTES}")
+        self._asset_bytes += size
+
     @staticmethod
     def _is_safe_member_name(name: str) -> bool:
         """判断 ZIP 成员是否为包内安全 POSIX 路径。"""

{docvortex-0.2.3 → docvortex-0.2.4}/src/docvortex/analyzers/native/ofd/path.py

@@ -80,49 +80,75 @@ def _line_bbox(first: tuple[float, float], second: tuple[float, float], width: f
     return None
 
 
-def _segments(value: str, transform: Affine, budget: OfdPathBudget) -> list[tuple[tuple[float, float], tuple[float, float]]]:
-    """流式提取 S/M/L/CM 直线段，曲线命令只推进当前位置。"""
-    result: list[tuple[tuple[float, float], tuple[float, float]]] = []
-    current: tuple[float, float] | None = None
-    subpath_start: tuple[float, float] | None = None
-    command: str | None = None
+PathCommand = tuple[str, tuple[float, ...]]
+
+
+def parse_path_commands(value: str, budget: OfdPathBudget) -> tuple[PathCommand, ...]:
+    """只扫描一次完整路径命令，绘制与表格检测共用同一份受限数值结果。"""
+    commands: list[PathCommand] = []
+    operator: str | None = None
     parameters: list[float] = []
-    commands = {"S", "M", "L", "Q", "B", "A", "C", "CM"}
     arity = {"S": 2, "M": 2, "L": 2, "Q": 4, "B": 6, "A": 7, "CM": 2}
+    cursor = 0
+    pending = False
     for match in _TOKEN_RE.finditer(value):
         budget.charge_token()
+        if value[cursor : match.start()].strip(" \t\r\n,"):
+            return ()
+        cursor = match.end()
         token = match.group()
-        if token in commands:
+        if token in {*arity, "C"}:
             if parameters:
-                return []
+                return ()
             budget.charge_command()
-            command = token
-            if command == "C":
-                if current is not None and subpath_start is not None and current != subpath_start:
-                    result.append((transform.apply(current), transform.apply(subpath_start)))
-                current = subpath_start
-                command = None
+            operator = token
+            pending = operator != "C"
+            if operator == "C":
+                commands.append((operator, ()))
+                operator = None
             continue
-        if command is None or command == "C":
-            return []
-        parsed = _finite_float(token)
-        if parsed is None:
-            return []
-        parameters.append(parsed)
-        if len(parameters) < arity[command]:
+        if operator is None:
+            return ()
+        number = _finite_float(token)
+        if number is None:
+            return ()
+        parameters.append(number)
+        if len(parameters) == arity[operator]:
+            if operator == "A" and (
+                parameters[0] < 0 or parameters[1] < 0 or parameters[3] not in (0, 1) or parameters[4] not in (0, 1)
+            ):
+                return ()
+            commands.append((operator, tuple(parameters)))
+            parameters.clear()
+            pending = False
+    return () if pending or parameters or value[cursor:].strip() else tuple(commands)
+
+
+def command_segments(
+    commands: tuple[PathCommand, ...], transform: Affine
+) -> list[tuple[tuple[float, float], tuple[float, float]]]:
+    """从已解析路径读取直线段，曲线只更新端点而不把控制线当表格边框。"""
+    result = []
+    current = start = None
+    for operator, values in commands:
+        if operator == "C":
+            if current is not None and start is not None and current != start:
+                result.append((transform.apply(current), transform.apply(start)))
+            current = start
             continue
-        endpoint = (parameters[-2], parameters[-1])
-        if command in {"S", "M"}:
-            current = endpoint
-            subpath_start = endpoint
-        elif command in {"L", "CM"}:
-            if current is not None:
-                result.append((transform.apply(current), transform.apply(endpoint)))
-            current = endpoint
+        endpoint = values[-2:]
+        if operator in {"S", "M"}:
+            current = start = endpoint
         else:
+            if operator in {"L", "CM"} and current is not None:
+                result.append((transform.apply(current), transform.apply(endpoint)))
             current = endpoint
-        parameters.clear()
-    return [] if parameters else result
+    return result
+
+
+def _segments(value: str, transform: Affine, budget: OfdPathBudget) -> list[tuple[tuple[float, float], tuple[float, float]]]:
+    """保留既有内部入口，复用完整命令解析提取直线段。"""
+    return command_segments(parse_path_commands(value, budget), transform)
 
 
 def build_axis_lines(
@@ -134,6 +160,7 @@ def build_axis_lines(
     template_id: int | None,
     budget: OfdPathBudget,
     resolved_style: dict[str, str] | None = None,
+    commands: tuple[PathCommand, ...] | None = None,
 ) -> list[AxisLine]:
     """从一个 PathObject 提取可见轴向线段。"""
     style = resolved_style or {}
@@ -157,42 +184,41 @@ def build_axis_lines(
     object_transform = parent_transform.compose(Affine.translation(boundary[0], boundary[1])).compose(
         parse_affine(path_object.get("CTM"))
     )
-    extracted: list[AxisLine] = []
     data = first_descendant(path_object, "AbbreviatedData")
-    segments = _segments(element_text(data), object_transform, budget) if data is not None else []
+    if commands is None:
+        commands = parse_path_commands(element_text(data), budget) if data is not None else ()
+    if any(operator in {"Q", "B", "A"} for operator, _ in commands):
+        return []
+    segments = command_segments(commands, object_transform)
+    stroke = style.get("Stroke", path_object.get("Stroke", "true")).casefold() not in {"false", "0"}
+    fill = style.get("Fill", path_object.get("Fill", "false")).casefold() in {"true", "1"}
+    extracted: list[AxisLine] = []
+    if fill and not stroke:
+        # 只把单个细长矩形归约为中心线，字形轮廓、背景和角点填充均不能提供边框证据。
+        if len(segments) != 4 or not commands or commands[-1][0] != "C":
+            return []
+        points = {point for segment in segments for point in segment}
+        xs, ys = sorted({p[0] for p in points}), sorted({p[1] for p in points})
+        if len(points) != 4 or len(xs) != 2 or len(ys) != 2:
+            return []
+        if any(first[0] != second[0] and first[1] != second[1] for first, second in segments):
+            return []
+        dx, dy = xs[-1] - xs[0], ys[-1] - ys[0]
+        if min(dx, dy) <= 0 or max(dx, dy) < 5 * min(dx, dy):
+            return []
+        orientation = "horizontal" if dx >= dy else "vertical"
+        clipped = bbox_intersection((xs[0], ys[0], xs[-1], ys[-1]), object_clip)
+        return [AxisLine(clipped, orientation, min(dx, dy), paint_order, template_id)] if clipped else []
+    if not stroke:
+        return []
+    width *= max(math.hypot(object_transform.a, object_transform.b), math.hypot(object_transform.c, object_transform.d))
     for first, second in segments:
         line = _line_bbox(first, second, width)
-        if line is None:
-            continue
-        line_bbox, orientation = line
-        clipped = bbox_intersection(line_bbox, object_clip)
-        if clipped is not None:
-            extracted.append(
-                AxisLine(
-                    bbox=clipped,
-                    orientation=orientation,
-                    width=width,
-                    paint_order=paint_order,
-                    template_id=template_id,
-                )
-            )
-    boundary_width = boundary_page[2] - boundary_page[0]
-    boundary_height = boundary_page[3] - boundary_page[1]
-    if (
-        not extracted
-        and not segments
-        and max(boundary_width, boundary_height) >= 5 * max(min(boundary_width, boundary_height), 0.01)
-    ):
-        orientation = "horizontal" if boundary_width >= boundary_height else "vertical"
-        extracted.append(
-            AxisLine(
-                bbox=object_clip,
-                orientation=orientation,
-                width=width,
-                paint_order=paint_order,
-                template_id=template_id,
-            )
-        )
+        if line is not None:
+            line_bbox, orientation = line
+            clipped = bbox_intersection(line_bbox, object_clip)
+            if clipped is not None:
+                extracted.append(AxisLine(clipped, orientation, width, paint_order, template_id))
     if not extracted and parse_int(path_object.get("ID")) is None:
         logger.debug("OFD_PATH_SKIPPED: path without stable ID produced no axis lines")
     return extracted