ocr-postprocess 0.1.0__py3-none-any.whl

ocr_postprocess/extractors/structured/mrz_cccd.py

@@ -0,0 +1,111 @@
+"""Structured extractor: MRZ CCCD (ICAO 9303) lines."""
+
+from __future__ import annotations
+
+import logging
+
+import regex as re
+
+from ocr_postprocess.extractors.base import StructuredExtractor
+from ocr_postprocess.extractors.registry import register
+from ocr_postprocess.models import Candidate, PipelineContext
+
+logger = logging.getLogger(__name__)
+
+_MRZ_LINE = re.compile(r"[A-Z0-9<]{20,}")
+
+_MRZ_CHARSET: dict[str, int] = {str(i): i for i in range(10)}
+_MRZ_CHARSET.update({chr(c): c - ord("A") + 10 for c in range(ord("A"), ord("Z") + 1)})
+_MRZ_CHARSET["<"] = 0
+
+_WEIGHTS = [7, 3, 1]
+
+
+def _mrz_checksum(s: str) -> int:
+    total = 0
+    for i, ch in enumerate(s):
+        total += _MRZ_CHARSET.get(ch, 0) * _WEIGHTS[i % 3]
+    return total % 10
+
+
+def _check_field(data: str) -> bool:
+    """Verify last char is the checksum of preceding chars."""
+    if len(data) < 2:
+        return False
+    return _mrz_checksum(data[:-1]) == int(data[-1]) if data[-1].isdigit() else False
+
+
+def _parse_mrz(lines: list[str]) -> dict[str, str] | None:
+    """Parse 2-line or 3-line MRZ from CCCD/CMND."""
+    if len(lines) < 2:
+        return None
+
+    result: dict[str, str] = {}
+
+    if len(lines) >= 2 and len(lines[0]) >= 30:
+        line1 = lines[0]
+        # Line 1: doc type (2), country (3), names
+        result["doc_type"] = line1[:2].strip("<")
+        result["country"] = line1[2:5].strip("<")
+        name_part = line1[5:] if len(line1) > 5 else ""
+        if "<<" in name_part:
+            surname, given = name_part.split("<<", 1)
+            result["surname"] = surname.replace("<", " ").strip()
+            result["given_names"] = given.replace("<", " ").strip()
+        result["name_ascii"] = name_part.replace("<", " ").strip()
+
+    if len(lines) >= 2 and len(lines[1]) >= 28:
+        line2 = lines[1]
+        result["id_number"] = line2[:9].strip("<")
+        result["dob"] = _to_date(line2[13:19]) if len(line2) > 19 else ""
+        result["sex"] = line2[20] if len(line2) > 20 else ""
+        result["expiry"] = _to_date(line2[21:27]) if len(line2) > 27 else ""
+        result["nationality"] = line2[27:30].strip("<") if len(line2) > 30 else ""
+
+    return result
+
+
+def _to_date(s: str) -> str:
+    """Convert YYMMDD to YYYY-MM-DD (assume 1900/2000 cutoff 30)."""
+    if len(s) < 6:
+        return s
+    try:
+        yy, mm, dd = int(s[:2]), int(s[2:4]), int(s[4:6])
+    except ValueError:
+        return s  # malformed MRZ date field
+    year = 2000 + yy if yy <= 30 else 1900 + yy
+    return f"{year:04d}-{mm:02d}-{dd:02d}"
+
+
+@register("mrz_cccd")
+class MrzCccdExtractor(StructuredExtractor):
+    """Extract structured MRZ data from CCCD documents."""
+
+    def extract(self, ctx: PipelineContext, field=None) -> list[Candidate]:
+        text = ctx.normalized_text or ctx.raw_text
+        mrz_lines: list[str] = [m.group(0) for m in _MRZ_LINE.finditer(text)]
+
+        if len(mrz_lines) < 2:
+            return []
+
+        parsed = _parse_mrz(mrz_lines[:3])
+        if not parsed:
+            return []
+
+        prefix = "mrz_cccd"
+        candidates: list[Candidate] = []
+        for sub_key, value in parsed.items():
+            if value:
+                candidates.append(
+                    Candidate(
+                        key=f"{prefix}.{sub_key}",
+                        value=value,
+                        raw=value,
+                        extractor="mrz_cccd",
+                        sources=["structured:mrz"],
+                        confidence=0.92,
+                    )
+                )
+
+        logger.debug("MRZ CCCD: extracted %d candidates", len(candidates))
+        return candidates

ocr_postprocess/extractors/universal.py

@@ -0,0 +1,39 @@
+"""Universal extractor: runs all pattern+structured extractors for hints."""
+
+from __future__ import annotations
+
+import logging
+
+from ocr_postprocess.models import PipelineContext
+
+logger = logging.getLogger(__name__)
+
+_UNIVERSAL_EXTRACTORS = [
+    "phone_vn",
+    "date",
+    "email",
+    "currency_vnd",
+    "plate_vn",
+    "tax_code",
+    "cccd",
+    "cmnd",
+    "mrz_cccd",
+]
+
+
+def universal_extract(ctx: PipelineContext) -> dict[str, list]:
+    """Run all universal extractors and return a hints dict."""
+    from ocr_postprocess.extractors import registry
+
+    hints: dict[str, list] = {}
+
+    for extractor_name in _UNIVERSAL_EXTRACTORS:
+        try:
+            ext = registry.get_instance(extractor_name)
+            candidates = ext.extract(ctx, field=None)
+            if candidates:
+                hints[extractor_name] = [c.value for c in candidates]
+        except Exception:
+            logger.debug("Universal extractor '%s' unavailable", extractor_name)
+
+    return hints

ocr_postprocess/models.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, field_validator
+
+
+class Line(BaseModel):
+    """Một dòng text trong document sau reflow."""
+
+    index: int
+    text: str
+    original_indices: list[int] = []
+
+
+class LabelHit(BaseModel):
+    """Vị trí 1 label tìm thấy trong text."""
+
+    label: str
+    aliases_matched: list[str] = []
+    section_id: str
+    line_index: int
+    char_start: int
+    char_end: int
+    fuzzy_score: float = 1.0
+
+
+class Section(BaseModel):
+    """Một đoạn (section) trong document, nhóm các dòng có liên quan."""
+
+    id: str
+    title: str | None = None
+    lines: list[Line] = []
+
+
+class Candidate(BaseModel):
+    """Một giá trị đã trích cho 1 field."""
+
+    key: str
+    value: Any
+    raw: str | None = None
+    extractor: str
+    sources: list[str] = []
+    section_id: str | None = None
+    line_index: int | None = None
+    span: tuple[int, int] | None = None
+    confidence: float = 0.0
+    needs_llm_review: bool = False
+    needs_vision: bool = False
+    conflict: bool = False
+    notes: list[str] = []
+
+    @field_validator("confidence")
+    @classmethod
+    def confidence_range(cls, v: float) -> float:
+        if not 0.0 <= v <= 1.0:
+            raise ValueError(f"confidence must be in [0, 1], got {v}")
+        return v
+
+
+class StageTrace(BaseModel):
+    """Debug trace entry ghi lại thông tin thực thi của một stage."""
+
+    stage: str
+    duration_ms: float
+    input_hash: str | None = None  # MD5 của input để phát hiện thay đổi
+    diff: str | None = None  # Unified diff giữa input/output của stage
+    extra: dict[str, Any] = {}  # Dữ liệu bổ sung tuỳ từng stage
+
+
+class CrossCheck(BaseModel):
+    """Kết quả kiểm tra chéo giữa các nguồn trích xuất khác nhau cho cùng một field."""
+
+    field_key: str
+    sources: list[str]  # Danh sách nguồn tham gia cross-check
+    matched: bool  # True nếu tất cả nguồn đồng thuận
+    detail: str | None = None  # Mô tả chi tiết (internal, dùng cho log)
+    values: list[str] = []  # Unique values tìm được (dùng bởi renderer)
+    value_sources: list[dict[str, Any]] = []  # [{value, extractor, confidence}] cho từng giá trị
+
+
+class ProcessedDocument(BaseModel):
+    """Kết quả pipeline."""
+
+    profile_id: str
+    profile_score: float
+    profile_display_name: str = ""  # Tên hiển thị của profile (dùng bởi renderer)
+    canonical_text: str = (
+        ""  # Normalized text sau pipeline (dùng bởi renderer làm context tham chiếu)
+    )
+    sections: list[Section] = []
+    candidates: list[Candidate] = []
+    hints: dict[str, list[Any]] = {}
+    cross_checks: list[CrossCheck] = []
+    warnings: list[str] = []
+    overall_confidence: float = 0.0
+    debug_trace: list[StageTrace] = []
+    markdown: str = ""
+    field_labels: dict[str, str] = {}  # field key → VN label (aliases[0]) cho renderer
+
+    def get(self, key: str) -> Candidate | None:
+        """Return first candidate matching key."""
+        for c in self.candidates:
+            if c.key == key:
+                return c
+        return None
+
+    def to_json(self) -> dict[str, Any]:
+        """Serialise to plain dict (use json_renderer.to_json() for JSON string output)."""
+        return self.model_dump()
+
+
+class PipelineContext(BaseModel):
+    """Mutable state shared across pipeline stages."""
+
+    raw_text: str  # Text OCR thô ban đầu
+    normalized_text: str = ""  # Text sau stage 1 (Normalizer)
+    profile: Any | None = None  # DocumentProfile được chọn (forward ref tránh circular import)
+    classification_score: float = 0.0  # Điểm phân loại profile (0–1)
+    sections: list[Section] = []  # Danh sách section sau stage 4 (Reconstructor)
+    label_index: dict[str, list[LabelHit]] = (
+        {}
+    )  # Index label → vị trí, dùng bởi label-anchor extractors
+    candidates: list[Candidate] = []  # Tất cả giá trị đã trích xuất
+    cross_checks: list[CrossCheck] = []  # Kết quả cross-check từ stage 7 (Reconciler)
+    hints: dict[str, list[Any]] = {}  # Dữ liệu phụ trợ từ universal extractor
+    warnings: list[str] = []  # Cảnh báo tích luỹ qua các stage
+    overall_confidence: float = 0.0  # Điểm tổng hợp từ stage 8 (Scorer)
+    debug_trace: list[StageTrace] = []  # Trace chi tiết từng stage (chỉ khi debug=True)
+
+    model_config = {"arbitrary_types_allowed": True}

ocr_postprocess/pipeline.py

@@ -0,0 +1,179 @@
+"""Pipeline orchestrator."""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+from typing import Callable
+
+from ocr_postprocess.models import PipelineContext, ProcessedDocument, StageTrace
+
+logger = logging.getLogger(__name__)
+
+Stage = Callable[[PipelineContext], None]
+
+# Default profiles directory bundled with the package.
+# When installed via pip, profiles live next to this file inside the package.
+_BUNDLED_PROFILES_DIR = Path(__file__).parent / "profiles"
+
+
+class Pipeline:
+    """9-stage OCR post-processing pipeline."""
+
+    def __init__(
+        self,
+        stages: list[Stage],
+        profiles_dir: str | Path = "profiles",
+    ) -> None:
+        self._stages = stages
+        self._profiles_dir = Path(profiles_dir)
+        self._profiles: dict = {}
+
+    @classmethod
+    def from_default(cls, profiles_dir: str | Path | None = None) -> "Pipeline":
+        """Factory: build pipeline with all default stages loaded.
+
+        Args:
+            profiles_dir: Path to YAML profiles directory. Defaults to the
+                profiles bundled with the package so no external files are
+                required after ``pip install``.
+        """
+        # Import lazily to avoid circular imports at module level
+        from ocr_postprocess.classifier import classify_stage
+        from ocr_postprocess.engine.denoiser import denoise_stage
+        from ocr_postprocess.engine.extractor_stage import extract_stage
+        from ocr_postprocess.engine.normalizer import normalize_stage
+        from ocr_postprocess.engine.reconciler import reconcile_stage
+        from ocr_postprocess.engine.reconstructor import reconstruct_stage
+        from ocr_postprocess.engine.transform_stage import transform_stage
+        from ocr_postprocess.renderer.markdown import render_stage
+        from ocr_postprocess.scorer import score_stage
+
+        stages: list[Stage] = [
+            normalize_stage,
+            classify_stage,
+            denoise_stage,
+            reconstruct_stage,
+            extract_stage,
+            transform_stage,
+            reconcile_stage,
+            score_stage,
+            render_stage,
+        ]
+        resolved_dir = Path(profiles_dir) if profiles_dir is not None else _BUNDLED_PROFILES_DIR
+        instance = cls(stages=stages, profiles_dir=resolved_dir)
+        instance._load_profiles()
+        return instance
+
+    def _load_profiles(self) -> None:
+        """Load all YAML profiles from profiles_dir into memory."""
+        from ocr_postprocess.profiles.loader import load_profiles
+
+        self._profiles = load_profiles(self._profiles_dir)
+        logger.info("Pipeline loaded %d profiles", len(self._profiles))
+
+    def classify(self, raw: str) -> tuple[str, float]:
+        """Classify raw text and return (profile_id, score)."""
+        from ocr_postprocess.profiles.matcher import evaluate
+
+        best_id = "_generic"
+        best_score = 0.0
+
+        for pid, profile in self._profiles.items():
+            if pid.startswith("_"):
+                continue  # skip fallback profiles
+            score = evaluate(profile.classify, raw)
+            if score > best_score:
+                best_score = score
+                best_id = pid
+
+        if best_score < 0.5:
+            best_id = "_generic"
+
+        return best_id, best_score
+
+    def process(self, raw: str, debug: bool = False) -> ProcessedDocument:
+        """Run full pipeline on raw OCR text.
+
+        Args:
+            raw: Raw text from OCR engine. Must be a non-empty string.
+            debug: When True, attach per-stage timing to the returned document.
+
+        Raises:
+            ValueError: If *raw* is not a non-empty string.
+        """
+        if not isinstance(raw, str):
+            raise ValueError(f"raw must be a str, got {type(raw).__name__}")
+        if not raw.strip():
+            raise ValueError("raw text is empty — nothing to process")
+
+        ctx = PipelineContext(raw_text=raw)
+
+        # Inject loaded profiles into context using __dict__ bypass because
+        # PipelineContext is a Pydantic model with no _profiles field — we store
+        # transient data here without modifying the public schema.
+        ctx.__dict__["_profiles"] = self._profiles
+
+        logger.info(
+            "Pipeline starting — %d chars, %d profile(s) loaded",
+            len(raw),
+            len(self._profiles),
+        )
+
+        failed_stages: list[str] = []
+
+        for stage in self._stages:
+            stage_name = getattr(stage, "__name__", str(stage))
+            logger.debug("[%s] start", stage_name)
+            t0 = time.perf_counter()
+            try:
+                stage(ctx)
+            except Exception:
+                logger.exception("[%s] FATAL — stage raised an exception", stage_name)
+                failed_stages.append(stage_name)
+                raise
+            finally:
+                elapsed_ms = (time.perf_counter() - t0) * 1000
+                logger.debug("[%s] done in %.1f ms", stage_name, elapsed_ms)
+                if debug:
+                    ctx.debug_trace.append(StageTrace(stage=stage_name, duration_ms=elapsed_ms))
+
+        from ocr_postprocess.renderer.markdown import render_markdown
+
+        profile_id = ctx.profile.id if ctx.profile else "_unknown"
+        profile_display_name = ctx.profile.display_name if ctx.profile else ""
+        field_labels: dict[str, str] = {}
+        if ctx.profile:
+            for fdef in ctx.profile.fields:
+                if fdef.aliases:
+                    field_labels[fdef.key] = fdef.aliases[0]
+        doc = ProcessedDocument(
+            profile_id=profile_id,
+            profile_score=ctx.classification_score,
+            profile_display_name=profile_display_name,
+            canonical_text=ctx.normalized_text,
+            sections=ctx.sections,
+            candidates=ctx.candidates,
+            cross_checks=ctx.cross_checks,
+            hints=ctx.hints,
+            warnings=ctx.warnings,
+            overall_confidence=ctx.overall_confidence,
+            debug_trace=ctx.debug_trace,
+            field_labels=field_labels,
+        )
+        try:
+            doc.markdown = render_markdown(doc)
+        except Exception:
+            logger.exception("render_markdown raised an exception; markdown output will be empty")
+            doc.markdown = ""
+
+        logger.info(
+            "Pipeline done — profile=%s score=%.2f confidence=%.2f " "candidates=%d warnings=%d",
+            profile_id,
+            ctx.classification_score,
+            ctx.overall_confidence,
+            len(ctx.candidates),
+            len(ctx.warnings),
+        )
+        return doc

ocr_postprocess/profiles/_generic.yml

@@ -0,0 +1,13 @@
+id: _generic
+version: 1
+display_name: "Generic fallback"
+language: ["vi", "en"]
+
+classify:
+  regex: ".*"
+
+extract: []
+
+output:
+  markdown:
+    title: "Document"

ocr_postprocess/profiles/cccd_2024.yml

@@ -0,0 +1,113 @@
+id: cccd_2024
+version: 1
+display_name: "Căn cước công dân (mẫu 2024)"
+language: ["vi", "en"]
+
+classify:
+  any_of:
+    - all_of:
+        - contains_any: ["CĂN CƯỚC", "Citizen Identity"]
+        - regex: '\b\d{12}\b'
+    - contains_any: ["Số định danh cá nhân", "Personal identification number"]
+
+denoise:
+  drop_lines:
+    regex: ['^[\W_]{3,}$', '^Page \d+/\d+$']
+    contains_any: ["SOCIALIST REPUBLIC OF VIET NAM"]
+  collapse_repeats: true
+
+reconstruct:
+  bilingual_pairs:
+    - ["Họ và tên", "Full name"]
+    - ["Ngày, tháng, năm sinh", "Date of birth"]
+    - ["Giới tính", "Sex"]
+    - ["Quốc tịch", "Nationality"]
+    - ["Quê quán", "Place of origin"]
+    - ["Nơi thường trú", "Place of residence"]
+    - ["Có giá trị đến", "Date of expiry"]
+    - ["Số định danh cá nhân", "Personal identification number"]
+  fuzzy_threshold: 0.85
+  split_glued_labels: true
+  rejoin_wrapped_lines: true
+
+extract:
+  - name: so_cccd
+    aliases: ["Số", "Số định danh", "Personal identification number"]
+    extractor: cccd
+    required: true
+    cross_check_with: [mrz_cccd.so]
+
+  - name: ho_va_ten
+    aliases: ["Họ và tên", "Full name"]
+    extractor: value_in_same_line
+    required: true
+    cross_check_with: [mrz_cccd.ho_ten]
+
+  - name: ngay_sinh
+    aliases: ["Ngày, tháng, năm sinh", "Ngày sinh", "Date of birth"]
+    extractor: regex_after_label
+    pattern: '(\d{1,2}[/\-.\s]\d{1,2}[/\-.\s]\d{4})'
+    fuzzy_label: false
+    next_lines: 1
+    required: true
+    transform: [{op: to_date}]
+    cross_check_with: [mrz_cccd.ngay_sinh]
+
+  - name: gioi_tinh
+    aliases: ["Giới tính", "Sex"]
+    extractor: gender_vn
+    required: true
+    cross_check_with: [mrz_cccd.gioi_tinh]
+
+  - name: quoc_tich
+    aliases: ["Quốc tịch", "Nationality"]
+    extractor: value_in_same_line
+    default: "Việt Nam"
+
+  - name: que_quan
+    # Hỗ trợ cả mẫu cũ ("Quê quán") và mẫu 2024 ("Place of birth" biểu diễn trên dòng song ngữ)
+    aliases: ["Quê quán", "Place of origin", "Place of birth"]
+    extractor: text_until_next_label
+    fuzzy_label: false
+    stop_labels: ["Nơi thường trú", "Place of residence", "Nơi cư trú", "Ngày, tháng, năm cấp", "Date of issue"]
+    required: true
+
+  - name: noi_thuong_tru
+    # Hỗ trợ cả mẫu cũ ("Nơi thường trú") và mẫu 2024 ("Place of residence" trên dòng "Nơi cư trú /Place of residence")
+    aliases: ["Nơi thường trú", "Place of residence"]
+    extractor: text_until_next_label
+    fuzzy_label: false
+    stop_labels: ["Có giá trị đến", "Date of expiry", "Số định danh", "Nơi đăng ký khai sinh", "Place of birth", "Quê quán", "Place of origin"]
+    required: true
+
+  - name: ngay_het_han
+    aliases: ["Có giá trị đến", "Date of expiry"]
+    extractor: regex_after_label
+    pattern: '(\d{1,2}[/\-.\s]\d{1,2}[/\-.\s]\d{4})'
+    fuzzy_label: false
+    next_lines: 1
+    transform: [{op: to_date}]
+    cross_check_with: [mrz_cccd.ngay_het_han]
+
+  - name: mrz_cccd
+    extractor: mrz_cccd
+    optional: true
+
+compute:
+  - name: tuoi
+    expr: "year_now() - year(ngay_sinh)"
+    deps: [ngay_sinh]
+
+output:
+  markdown:
+    title: "Căn cước công dân"
+    sections:
+      - heading: "Thông tin cá nhân"
+        fields: [ho_va_ten, ngay_sinh, tuoi, gioi_tinh, quoc_tich]
+      - heading: "Định danh"
+        fields: [so_cccd, ngay_het_han]
+      - heading: "Địa chỉ"
+        fields: [que_quan, noi_thuong_tru]
+  json:
+    include_trace: true
+    include_candidates: true

ocr_postprocess/profiles/dang_kiem.yml

@@ -0,0 +1,105 @@
+id: dang_kiem
+version: 1
+display_name: "Giấy chứng nhận đăng kiểm xe"
+language: ["vi"]
+
+classify:
+  any_of:
+    - contains_any: ["GIẤY CHỨNG NHẬN KIỂM ĐỊNH", "ĐĂNG KIỂM"]
+    - all_of:
+        - contains_any: ["Biển số đăng ký", "Biển số"]
+        - contains_any: ["Số máy", "Số khung"]
+
+denoise:
+  drop_lines:
+    regex: ['^[\W_]{3,}$']
+  collapse_repeats: true
+
+reconstruct:
+  fuzzy_threshold: 0.85
+  split_glued_labels: true
+  rejoin_wrapped_lines: true
+
+extract:
+  - name: bien_so
+    aliases: ["Biển số đăng ký", "Biển số"]
+    extractor: plate_vn
+    required: true
+
+  - name: nhan_hieu
+    aliases: ["Nhãn hiệu"]
+    extractor: value_in_same_line
+    required: true
+
+  - name: so_loai
+    aliases: ["Số loại"]
+    extractor: value_in_same_line
+
+  - name: so_may
+    aliases: ["Số máy"]
+    extractor: value_in_same_line
+    required: true
+
+  - name: so_khung
+    aliases: ["Số khung"]
+    extractor: value_in_same_line
+    required: true
+
+  - name: nam_san_xuat
+    aliases: ["Năm sản xuất"]
+    extractor: value_in_same_line
+    transform: [{op: to_int}]
+
+  - name: niên_hạn
+    aliases: ["Niên hạn", "Niên hạn sử dụng"]
+    extractor: value_in_same_line
+
+  - name: trong_luong_ban_than
+    aliases: ["Trọng lượng bản thân", "Khối lượng bản thân"]
+    extractor: value_in_same_line
+    transform: [{op: strip_unit, units: ["kg"]}, {op: to_int}]
+
+  - name: so_nguoi_cho_phep
+    aliases: ["Số người cho phép chở", "Cho phép chở"]
+    extractor: value_in_same_line
+    transform: [{op: regex_group, pattern: '(\d+)'}, {op: to_int}]
+
+  - name: chu_so_huu
+    aliases: ["Tên chủ xe", "Chủ sở hữu", "Chủ xe"]
+    extractor: value_in_same_line
+    required: true
+
+  - name: dia_chi
+    aliases: ["Địa chỉ"]
+    extractor: text_until_next_label
+    stop_labels: ["Số máy", "Biển số", "Có giá trị đến"]
+
+  - name: ngay_kiem_dinh
+    aliases: ["Ngày kiểm định", "Kiểm định ngày"]
+    extractor: regex_after_label
+    pattern: '(\d{1,2}[/\-.\s]\d{1,2}[/\-.\s]\d{4})'
+    transform: [{op: to_date}]
+
+  - name: co_gia_tri_den
+    aliases: ["Có giá trị đến"]
+    extractor: regex_after_label
+    pattern: '(\d{1,2}[/\-.\s]\d{1,2}[/\-.\s]\d{4})'
+    transform: [{op: to_date}]
+    required: true
+
+output:
+  markdown:
+    title: "Giấy chứng nhận đăng kiểm"
+    sections:
+      - heading: "Thông tin xe"
+        fields: [bien_so, nhan_hieu, so_loai, nam_san_xuat, niên_hạn]
+      - heading: "Số máy / khung"
+        fields: [so_may, so_khung]
+      - heading: "Tải trọng"
+        fields: [trong_luong_ban_than, so_nguoi_cho_phep]
+      - heading: "Chủ sở hữu"
+        fields: [chu_so_huu, dia_chi]
+      - heading: "Kiểm định"
+        fields: [ngay_kiem_dinh, co_gia_tri_den]
+  json:
+    include_trace: true