codex-pdf 0.1.1__py3-none-any.whl

codex_pdf/__init__.py

@@ -0,0 +1,6 @@
+"""codexPDF public package surface."""
+
+from codex_pdf.models.v1 import CodexDocument
+from codex_pdf.version import __version__
+
+__all__ = ["CodexDocument", "__version__"]

codex_pdf/cli.py

@@ -0,0 +1,125 @@
+"""codex-pdf CLI."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from jsonschema import validate
+
+from codex_pdf.extract import extract_from_path
+from codex_pdf.parity import run_parity_from_namespace
+from codex_pdf.schema import codex_document_schema, load_published_schema
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parent.parent.parent
+
+
+def cmd_extract(args: argparse.Namespace) -> int:
+    doc = extract_from_path(Path(args.input_pdf))
+    payload = doc.model_dump(mode="json")
+    if args.pretty:
+        print(json.dumps(payload, indent=2, sort_keys=True))
+    else:
+        print(json.dumps(payload, separators=(",", ":")))
+    return 0
+
+
+def cmd_schema(args: argparse.Namespace) -> int:
+    if args.published:
+        schema = load_published_schema(_repo_root())
+    else:
+        schema = codex_document_schema()
+    print(json.dumps(schema, indent=2, sort_keys=True))
+    return 0
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    payload = json.loads(Path(args.codex_json).read_text(encoding="utf-8"))
+    schema = load_published_schema(_repo_root())
+    validate(payload, schema)
+    print("valid")
+    return 0
+
+
+def cmd_probe(args: argparse.Namespace) -> int:
+    doc = extract_from_path(Path(args.input_pdf))
+    result = {
+        "pdf_version": doc.pdf_version,
+        "page_count": len(doc.pages),
+        "is_encrypted": doc.is_encrypted,
+        "output_intents": [x.model_dump(mode="json") for x in doc.output_intents],
+        "document_id": doc.document_id,
+    }
+    if args.json:
+        print(json.dumps(result, indent=2, sort_keys=True))
+    else:
+        print(
+            f"pdf_version={result['pdf_version']} "
+            f"page_count={result['page_count']} "
+            f"is_encrypted={result['is_encrypted']}"
+        )
+    return 0
+
+
+def cmd_parity(args: argparse.Namespace) -> int:
+    return run_parity_from_namespace(args, _repo_root())
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="codex-pdf")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    extract = sub.add_parser("extract", help="Extract a CodexDocument from a PDF.")
+    extract.add_argument("input_pdf")
+    extract.add_argument("--pretty", action="store_true")
+    extract.set_defaults(func=cmd_extract)
+
+    schema = sub.add_parser("schema", help="Print JSON Schema for CodexDocument.")
+    schema.add_argument("--version", default="1")
+    schema.add_argument("--name", default="codex-document")
+    schema.add_argument("--published", action="store_true")
+    schema.set_defaults(func=cmd_schema)
+
+    validate_cmd = sub.add_parser("validate", help="Validate codex JSON against published schema.")
+    validate_cmd.add_argument("codex_json")
+    validate_cmd.set_defaults(func=cmd_validate)
+
+    probe = sub.add_parser("probe", help="Fast metadata probe.")
+    probe.add_argument("input_pdf")
+    probe.add_argument("--json", action="store_true")
+    probe.set_defaults(func=cmd_probe)
+
+    parity = sub.add_parser("parity", help="Run consumer-agnostic parity projection checks.")
+    parity.add_argument("--profile", choices=["summary", "inventory", "deep"], default="summary")
+    parity.add_argument("--fixtures-root", required=True, help="Path to fixture corpus root.")
+    parity.add_argument(
+        "--output",
+        default=str(_repo_root() / "reports" / "parity" / "viewer_essentials.json"),
+        help="Path to write parity JSON report.",
+    )
+    parity.add_argument("--max-files", type=int, default=10, help="Limit number of PDFs.")
+    parity.add_argument(
+        "--baseline-command",
+        default=None,
+        help=(
+            "Optional shell command template that prints JSON projection to stdout. "
+            "Use {pdf} placeholder for input path."
+        ),
+    )
+    parity.add_argument("--fail-on-diff", action="store_true", help="Return non-zero if any diff exists.")
+    parity.set_defaults(func=cmd_parity)
+
+    return parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_pdf/extract/__init__.py

@@ -0,0 +1,5 @@
+"""Extraction interfaces."""
+
+from codex_pdf.extract.document import extract_document, extract_from_path
+
+__all__ = ["extract_document", "extract_from_path"]

codex_pdf/extract/annotations.py

@@ -0,0 +1,39 @@
+"""Annotation extraction."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from codex_pdf.extract.common import safe_box
+from codex_pdf.models.v1 import CodexAnnotation
+
+
+def extract_annotations_fitz(doc: Any) -> list[CodexAnnotation]:
+    annotations: list[CodexAnnotation] = []
+    for page_num, page in enumerate(doc, start=1):
+        try:
+            annots = page.annots()
+            if not annots:
+                continue
+            for ann in annots:
+                rect = getattr(ann, "rect", None)
+                bbox = safe_box(rect) if rect is not None else None
+                subtype = getattr(ann, "type", None)
+                subtype_name = str(subtype[1]) if isinstance(subtype, tuple) and len(subtype) > 1 else None
+                contents = None
+                info = getattr(ann, "info", {})
+                if isinstance(info, dict):
+                    contents = info.get("content")
+                annotations.append(
+                    CodexAnnotation(
+                        annotation_id=f"p{page_num}-a{len(annotations)+1}",
+                        subtype=subtype_name,
+                        page_num=page_num,
+                        rect=bbox,
+                        contents=contents,
+                        has_appearance_stream=False,
+                    )
+                )
+        except Exception:
+            continue
+    return annotations

codex_pdf/extract/color.py

@@ -0,0 +1,99 @@
+"""Color space and output intent extraction (pikepdf fallback)."""
+
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Any
+
+from codex_pdf.extract.common import obj_id, pdf_name
+from codex_pdf.models.v1 import CodexColorSpace, CodexOutputIntent, CodexSpotColorant
+
+
+def extract_color_space(value: Any, cs_id: str) -> CodexColorSpace | None:
+    try:
+        if str(value).startswith("/"):
+            family = pdf_name(value)
+            if family in {
+                "DeviceGray",
+                "DeviceRGB",
+                "DeviceCMYK",
+                "Pattern",
+                "Lab",
+                "CalRGB",
+                "CalGray",
+                "Indexed",
+            }:
+                return CodexColorSpace(id=cs_id, family=family, canonical={"raw": str(value)})
+
+        if isinstance(value, list) and len(value) > 0:
+            first = pdf_name(value[0]) or "ICCBased"
+            if first == "Separation":
+                spot_name = pdf_name(value[1]) if len(value) > 1 else "Unknown"
+                alt = pdf_name(value[2]) if len(value) > 2 else None
+                return CodexColorSpace(
+                    id=cs_id,
+                    family="Separation",
+                    canonical={"raw": [str(v) for v in value]},
+                    alternate_space_id=alt,
+                    spot_colorants=[CodexSpotColorant(name=spot_name or "Unknown", alternate_space_id=alt)],
+                )
+            if first == "DeviceN":
+                names = value[1] if len(value) > 1 else []
+                alt = pdf_name(value[2]) if len(value) > 2 else None
+                spots: list[CodexSpotColorant] = []
+                if isinstance(names, list):
+                    for n in names:
+                        if pdf_name(n) and pdf_name(n) not in {"All", "None"}:
+                            spots.append(CodexSpotColorant(name=pdf_name(n) or "Unknown", alternate_space_id=alt))
+                return CodexColorSpace(
+                    id=cs_id,
+                    family="DeviceN",
+                    canonical={"raw": [str(v) for v in value]},
+                    alternate_space_id=alt,
+                    spot_colorants=spots,
+                )
+            if first in {"ICCBased", "Lab", "CalRGB", "CalGray", "Indexed", "Pattern"}:
+                return CodexColorSpace(id=cs_id, family=first, canonical={"raw": [str(v) for v in value]})
+    except Exception:
+        return None
+    return None
+
+
+def extract_color_world_pikepdf(pdf_bytes: bytes) -> tuple[list[CodexOutputIntent], list[CodexColorSpace]]:
+    output_intents: list[CodexOutputIntent] = []
+    color_spaces: list[CodexColorSpace] = []
+    try:
+        import pikepdf
+
+        with pikepdf.open(BytesIO(pdf_bytes)) as pdf:
+            root = pdf.Root
+            out_arr = root.get("/OutputIntents", [])
+            for idx, oi in enumerate(out_arr):
+                output_intents.append(
+                    CodexOutputIntent(
+                        subtype=pdf_name(oi.get("/S")) if hasattr(oi, "get") else None,
+                        output_condition_identifier=str(oi.get("/OutputConditionIdentifier"))
+                        if hasattr(oi, "get") and oi.get("/OutputConditionIdentifier") is not None
+                        else None,
+                        profile_id=obj_id(oi.get("/DestOutputProfile"), f"outputintent-{idx}")
+                        if hasattr(oi, "get")
+                        else None,
+                    )
+                )
+
+            cs_seen: set[str] = set()
+            for page in pdf.pages:
+                resources = page.obj.get("/Resources", {}) if hasattr(page.obj, "get") else {}
+                cs_dict = resources.get("/ColorSpace", {}) if hasattr(resources, "get") else {}
+                if hasattr(cs_dict, "items"):
+                    for cs_name, cs_val in cs_dict.items():
+                        cs_id = str(cs_name)
+                        if cs_id in cs_seen:
+                            continue
+                        cs_seen.add(cs_id)
+                        cs = extract_color_space(cs_val, cs_id)
+                        if cs is not None:
+                            color_spaces.append(cs)
+    except Exception:
+        pass
+    return output_intents, color_spaces

codex_pdf/extract/common.py

@@ -0,0 +1,31 @@
+"""Shared extraction helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from codex_pdf.models.v1 import CodexBBox
+
+
+def safe_box(rect: object) -> CodexBBox:
+    x0 = float(getattr(rect, "x0", 0.0))
+    y0 = float(getattr(rect, "y0", 0.0))
+    x1 = float(getattr(rect, "x1", 0.0))
+    y1 = float(getattr(rect, "y1", 0.0))
+    return CodexBBox(x0=x0, y0=y0, x1=x1, y1=y1)
+
+
+def pdf_name(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value)
+    if text.startswith("/"):
+        return text[1:]
+    return text
+
+
+def obj_id(value: Any, fallback: str) -> str:
+    objgen = getattr(value, "objgen", None)
+    if isinstance(objgen, tuple) and len(objgen) >= 1:
+        return f"obj-{objgen[0]}"
+    return fallback

codex_pdf/extract/content_inventory.py

@@ -0,0 +1,68 @@
+"""Content inventory extraction (object-level placeholders)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from codex_pdf.models.v1 import (
+    CodexColorUsage,
+    CodexGraphicsStateSnapshot,
+    CodexPageObject,
+)
+
+
+def extract_page_inventory_fitz(doc: Any) -> dict[int, list[CodexPageObject]]:
+    """Return page_num -> content object inventory.
+
+    This approximates object classes from currently exposed fitz APIs and serves
+    as codex's canonical object list until deeper content-stream parser stages
+    are plugged in.
+    """
+    inventories: dict[int, list[CodexPageObject]] = {}
+    for page_num, page in enumerate(doc, start=1):
+        objects: list[CodexPageObject] = []
+
+        # Text spans via textpage dictionary.
+        try:
+            tdict = page.get_text("dict")
+            block_idx = 0
+            for block in tdict.get("blocks", []):
+                block_idx += 1
+                if block.get("type") == 0:
+                    objects.append(
+                        CodexPageObject(
+                            object_id=f"p{page_num}-text-{block_idx}",
+                            kind="text",
+                            graphics_state=CodexGraphicsStateSnapshot(),
+                            color_usage=CodexColorUsage(),
+                        )
+                    )
+                elif block.get("type") == 1:
+                    objects.append(
+                        CodexPageObject(
+                            object_id=f"p{page_num}-raster-{block_idx}",
+                            kind="raster",
+                            graphics_state=CodexGraphicsStateSnapshot(),
+                            color_usage=CodexColorUsage(),
+                        )
+                    )
+        except Exception:
+            pass
+
+        # Drawings become vector objects.
+        try:
+            drawings = page.get_drawings() or []
+            for idx, _draw in enumerate(drawings, start=1):
+                objects.append(
+                    CodexPageObject(
+                        object_id=f"p{page_num}-vector-{idx}",
+                        kind="vector",
+                        graphics_state=CodexGraphicsStateSnapshot(),
+                        color_usage=CodexColorUsage(),
+                    )
+                )
+        except Exception:
+            pass
+
+        inventories[page_num] = objects
+    return inventories

codex_pdf/extract/document.py

@@ -0,0 +1,97 @@
+"""Document extraction entrypoints."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+from codex_pdf.models.v1 import CodexDocument, CodexInfoDict, CodexSourceRef, CodexXmpPacket
+from codex_pdf.version import __version__
+from codex_pdf.extract.annotations import extract_annotations_fitz
+from codex_pdf.extract.color import extract_color_world_pikepdf
+from codex_pdf.extract.content_inventory import extract_page_inventory_fitz
+from codex_pdf.extract.fonts import extract_fonts_fitz
+from codex_pdf.extract.forms import extract_forms_pikepdf
+from codex_pdf.extract.images import extract_images_fitz
+from codex_pdf.extract.ocg import extract_ocgs_pikepdf
+from codex_pdf.extract.structure import (
+    conformance_claims_from_metadata,
+    extract_structure_fitz,
+)
+from codex_pdf.extract.trapping import derive_trapped_flag, extract_trap_evidence
+from codex_pdf.extract.transparency import extract_transparency_fitz
+
+
+def extract_document(pdf_bytes: bytes, *, source_uri: str | None = None) -> CodexDocument:
+    """Extract a baseline CodexDocument from raw PDF bytes."""
+    digest = hashlib.sha256(pdf_bytes).hexdigest()
+    pages = []
+    fonts = []
+    images = []
+    annotations = []
+    output_intents = []
+    color_spaces = []
+    ocgs = []
+    form_xobjects = []
+    info = CodexInfoDict()
+    xmp = CodexXmpPacket(present=False)
+    pdf_version = "unknown"
+    is_encrypted = False
+    trapped_flag = None
+
+    try:
+        import fitz
+
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+        pdf_version, is_encrypted, info, xmp, pages = extract_structure_fitz(doc)
+        fonts = extract_fonts_fitz(doc)
+        images = extract_images_fitz(doc)
+        annotations = extract_annotations_fitz(doc)
+
+        page_inventory = extract_page_inventory_fitz(doc)
+        transparency = extract_transparency_fitz(doc)
+        for page in pages:
+            page.inventory = page_inventory.get(page.page_num, [])
+            if 0 < page.page_num <= len(transparency):
+                page.transparency_tree = transparency[page.page_num - 1]
+
+        trapped_flag = derive_trapped_flag(doc)
+    except Exception:
+        # Fall back to skeleton with minimal metadata.
+        pass
+
+    # Structural fallback extraction not exposed through PyMuPDF APIs.
+    output_intents, color_spaces = extract_color_world_pikepdf(pdf_bytes)
+    ocgs = extract_ocgs_pikepdf(pdf_bytes)
+    form_xobjects = extract_forms_pikepdf(pdf_bytes)
+    trap_evidence = extract_trap_evidence(
+        trapped_flag=trapped_flag,
+        ocg_names=[x.name for x in ocgs],
+        annotation_subtypes=[x.subtype or "" for x in annotations],
+    )
+
+    return CodexDocument(
+        codex_version=__version__,
+        document_id=digest,
+        source=CodexSourceRef(uri=source_uri, sha256=digest, size_bytes=len(pdf_bytes)),
+        pdf_version=pdf_version,
+        is_encrypted=is_encrypted,
+        conformance=conformance_claims_from_metadata(info, xmp),
+        info=info,
+        xmp=xmp,
+        trapped_flag=trapped_flag,
+        output_intents=output_intents,
+        color_spaces=color_spaces,
+        fonts=fonts,
+        images=images,
+        ocgs=ocgs,
+        form_xobjects=form_xobjects,
+        trap_evidence=trap_evidence,
+        annotations=annotations,
+        pages=pages,
+    )
+
+
+def extract_from_path(path: Path) -> CodexDocument:
+    data = path.read_bytes()
+    return extract_document(data, source_uri=str(path))

codex_pdf/extract/fonts.py

@@ -0,0 +1,50 @@
+"""Font extraction."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from codex_pdf.models.v1 import CodexFont
+
+
+def _outline_type(subtype: str) -> str:
+    if "TrueType" in subtype:
+        return "TrueType"
+    if "CFF" in subtype or "Type1C" in subtype:
+        return "CFF"
+    if "Type1" in subtype:
+        return "Type1"
+    if "Type3" in subtype:
+        return "Type3"
+    if "CID" in subtype:
+        return "CID"
+    return "unknown"
+
+
+def extract_fonts_fitz(doc: Any) -> list[CodexFont]:
+    fonts: list[CodexFont] = []
+    for idx, page in enumerate(doc, start=1):
+        try:
+            for font in page.get_fonts(full=True):
+                font_key = str(font[0]) if len(font) > 0 else f"page{idx}-font"
+                base_name = str(font[3]) if len(font) > 3 else None
+                subtype = str(font[2]) if len(font) > 2 else "unknown"
+                existing = next((f for f in fonts if f.font_id == font_key), None)
+                if existing is None:
+                    embedded = "subset" if base_name and "+" in base_name else "unknown"
+                    fonts.append(
+                        CodexFont(
+                            font_id=font_key,
+                            base_name=base_name,
+                            subtype=subtype,
+                            outline_type=_outline_type(subtype),
+                            embedded=embedded,  # best-effort from naming convention.
+                            missing_glyphs_detected=False,
+                            page_refs=[idx],
+                        )
+                    )
+                elif idx not in existing.page_refs:
+                    existing.page_refs.append(idx)
+        except Exception:
+            continue
+    return fonts

codex_pdf/extract/forms.py

@@ -0,0 +1,46 @@
+"""Form XObject extraction."""
+
+from __future__ import annotations
+
+from io import BytesIO
+
+from codex_pdf.extract.common import obj_id, pdf_name
+from codex_pdf.models.v1 import CodexFormXObject
+
+
+def extract_forms_pikepdf(pdf_bytes: bytes) -> list[CodexFormXObject]:
+    form_xobjects: list[CodexFormXObject] = []
+    try:
+        import pikepdf
+
+        with pikepdf.open(BytesIO(pdf_bytes)) as pdf:
+            seen: set[str] = set()
+            for page_idx, page in enumerate(pdf.pages, start=1):
+                resources = page.obj.get("/Resources", {}) if hasattr(page.obj, "get") else {}
+                xobj_dict = resources.get("/XObject", {}) if hasattr(resources, "get") else {}
+                if not hasattr(xobj_dict, "items"):
+                    continue
+                for x_name, x_obj in xobj_dict.items():
+                    subtype = pdf_name(x_obj.get("/Subtype")) if hasattr(x_obj, "get") else None
+                    if subtype != "Form":
+                        continue
+                    x_id = obj_id(x_obj, f"p{page_idx}-{x_name}")
+                    if x_id in seen:
+                        continue
+                    seen.add(x_id)
+                    child_refs: list[str] = []
+                    child_res = x_obj.get("/Resources", {}) if hasattr(x_obj, "get") else {}
+                    child_xobj = child_res.get("/XObject", {}) if hasattr(child_res, "get") else {}
+                    if hasattr(child_xobj, "items"):
+                        for child_name, child_obj in child_xobj.items():
+                            child_refs.append(obj_id(child_obj, str(child_name)))
+                    form_xobjects.append(
+                        CodexFormXObject(
+                            object_id=x_id,
+                            parent_object_id=None,
+                            resource_refs=child_refs or [str(x_name)],
+                        )
+                    )
+    except Exception:
+        pass
+    return form_xobjects

codex_pdf/extract/images.py

@@ -0,0 +1,45 @@
+"""Image extraction."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from codex_pdf.models.v1 import CodexImage, CodexResolution
+
+
+def _estimate_dpi(width_px: int, height_px: int, page_width_pts: float, page_height_pts: float) -> CodexResolution:
+    width_in = max(page_width_pts / 72.0, 0.001)
+    height_in = max(page_height_pts / 72.0, 0.001)
+    return CodexResolution(x_dpi=width_px / width_in, y_dpi=height_px / height_in)
+
+
+def extract_images_fitz(doc: Any) -> list[CodexImage]:
+    images: list[CodexImage] = []
+    for page_num, page in enumerate(doc, start=1):
+        page_w = float(getattr(page.rect, "width", 0.0))
+        page_h = float(getattr(page.rect, "height", 0.0))
+        try:
+            for img in page.get_images(full=True):
+                xref = img[0] if len(img) > 0 else -1
+                width = int(img[2]) if len(img) > 2 else 0
+                height = int(img[3]) if len(img) > 3 else 0
+                bpc = int(img[4]) if len(img) > 4 else None
+                cs_name = str(img[5]) if len(img) > 5 else None
+                filters = str(img[8]) if len(img) > 8 and img[8] is not None else None
+                smask = bool(img[1]) if len(img) > 1 else False
+                images.append(
+                    CodexImage(
+                        image_id=f"p{page_num}-x{xref}",
+                        page_num=page_num,
+                        width_px=width,
+                        height_px=height,
+                        bits_per_component=bpc,
+                        color_space_id=cs_name,
+                        compression=filters,
+                        soft_mask=smask,
+                        effective_resolution_dpi=_estimate_dpi(width, height, page_w, page_h),
+                    )
+                )
+        except Exception:
+            continue
+    return images

codex_pdf/extract/ocg.py

@@ -0,0 +1,65 @@
+"""Optional content group extraction."""
+
+from __future__ import annotations
+
+from io import BytesIO
+
+from codex_pdf.extract.common import obj_id, pdf_name
+from codex_pdf.models.v1 import CodexOCG
+
+
+_STEP_HINTS = {
+    "trap": "Trap",
+    "white": "White",
+    "varnish": "Varnish",
+    "cut": "Cutting",
+    "fold": "Folding",
+    "dieline": "Dieline",
+    "emboss": "Emboss",
+    "bleed": "Bleed",
+}
+
+
+def _processing_step(name: str) -> str | None:
+    lower = name.lower()
+    for key, value in _STEP_HINTS.items():
+        if key in lower:
+            return value
+    return None
+
+
+def extract_ocgs_pikepdf(pdf_bytes: bytes) -> list[CodexOCG]:
+    ocgs: list[CodexOCG] = []
+    try:
+        import pikepdf
+
+        with pikepdf.open(BytesIO(pdf_bytes)) as pdf:
+            root = pdf.Root
+            oc_props = root.get("/OCProperties", {})
+            off_set: set[str] = set()
+            default_cfg = oc_props.get("/D", {}) if hasattr(oc_props, "get") else {}
+            off_list = default_cfg.get("/OFF", []) if hasattr(default_cfg, "get") else []
+            for item in off_list:
+                off_set.add(obj_id(item, str(item)))
+            ocg_arr = oc_props.get("/OCGs", []) if hasattr(oc_props, "get") else []
+            for idx, ocg in enumerate(ocg_arr):
+                ocg_id = obj_id(ocg, f"ocg-{idx}")
+                intent_raw = ocg.get("/Intent", []) if hasattr(ocg, "get") else []
+                intents: list[str] = []
+                if isinstance(intent_raw, list):
+                    intents = [pdf_name(x) or str(x) for x in intent_raw]
+                elif intent_raw is not None:
+                    intents = [pdf_name(intent_raw) or str(intent_raw)]
+                name = str(ocg.get("/Name")) if hasattr(ocg, "get") and ocg.get("/Name") else ocg_id
+                ocgs.append(
+                    CodexOCG(
+                        ocg_id=ocg_id,
+                        name=name,
+                        default_visible=ocg_id not in off_set,
+                        intent=intents,
+                        iso19593_processing_step=_processing_step(name),
+                    )
+                )
+    except Exception:
+        pass
+    return ocgs