python-hwpx-automation 6.0.3__py3-none-any.whl

hwpx_automation/office/authoring/builder/report.py

@@ -0,0 +1,195 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from os import PathLike
+from typing import Any
+
+from hwpx.quality import VisualCompleteReport
+from hwpx.tools.id_integrity import IdIntegrityReport, check_id_integrity
+from hwpx.tools.idempotence import IdempotenceReport
+from hwpx.tools.package_reconcile import PackageReconcileReport
+from hwpx.tools.package_validator import EditorOpenSafetyReport, PackageValidationReport
+from hwpx.tools.validator import ValidationReport
+
+
+# Explicit scope of what the builder's automated gates prove vs. don't, so a
+# green ``hard_gates`` is never mistaken for full Hancom/visual fidelity. The
+# gates answer "will Hancom likely open this", NOT "did every authored element
+# round-trip". Surfaced in every report's ``to_dict()``.
+FIDELITY_CONTRACT: dict[str, list[str]] = {
+    "proves": [
+        "package opens as a valid HWPX (mimetype/OPC structure, required entries)",
+        "no dangling id references or orphan BinData (id_integrity)",
+        "no known editor-open breakage patterns (editor_open_safety)",
+        "re-saving reproduces identical part contents (idempotent serialization)",
+        "the document reopens with our reader (reopen)",
+    ],
+    "does_not_prove": [
+        "visual layout fidelity in Hancom (line/page breaks, overlap) — needs the "
+        "visual oracle / ComputerUse",
+        "every authored element round-tripped byte-for-byte: merges, shapes, BinData "
+        "bytes, and equation script are not value-diffed",
+        "macOS Hancom acceptance for untested element combinations",
+    ],
+}
+
+
+@dataclass(frozen=True)
+class ReopenReport:
+    """Result of reopening a generated document."""
+
+    ok: bool
+    error: str | None = None
+    document: Any | None = None
+
+
+@dataclass(frozen=True)
+class BuilderSaveReport:
+    """Validation and reopen report returned by builder saves."""
+
+    path: str | PathLike[str]
+    validate_package: PackageValidationReport
+    validate_document: ValidationReport
+    reopened: ReopenReport
+    metadata: dict[str, str] | None = None
+    hard_gates: dict[str, str] = field(default_factory=dict)
+    visual_review_required: bool = False
+    feature_flags: dict[str, bool] = field(default_factory=dict)
+    id_integrity: IdIntegrityReport | None = None
+    editor_open_safety: EditorOpenSafetyReport | None = None
+    # The uniform Phase-B report from the SavePipeline the builder save funnelled
+    # through (plan §2 Phase B). Additive: ``None`` only if a caller builds a
+    # report by hand without going through ``Document.save_to_path``.
+    visual_complete: VisualCompleteReport | None = None
+
+    def __post_init__(self) -> None:
+        hard_gates = dict(self.hard_gates)
+        if hard_gates.get("id_integrity") in {None, "unavailable"}:
+            id_integrity = None
+            if self.reopened.ok and self.reopened.document is not None:
+                id_integrity = check_id_integrity(self.reopened.document)
+                hard_gates["id_integrity"] = "pass" if id_integrity.ok else "fail"
+            else:
+                hard_gates["id_integrity"] = "fail"
+            object.__setattr__(self, "hard_gates", hard_gates)
+            object.__setattr__(self, "id_integrity", id_integrity)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "path": str(self.path),
+            "metadata": dict(self.metadata or {}),
+            "hard_gates": dict(self.hard_gates),
+            "fidelity_contract": {
+                "proves": list(FIDELITY_CONTRACT["proves"]),
+                "does_not_prove": list(FIDELITY_CONTRACT["does_not_prove"]),
+            },
+            "visual_review_required": self.visual_review_required,
+            "feature_flags": dict(self.feature_flags),
+            "visual_complete": (
+                None if self.visual_complete is None else self.visual_complete.to_dict()
+            ),
+            "editor_open_safety": (
+                None
+                if self.editor_open_safety is None
+                else self.editor_open_safety.to_dict()
+            ),
+            "validate_package": {
+                "ok": self.validate_package.ok,
+                "checked_parts": list(self.validate_package.checked_parts),
+                "errors": [str(issue) for issue in self.validate_package.errors],
+                "warnings": [str(issue) for issue in self.validate_package.warnings],
+                "issues": [str(issue) for issue in self.validate_package.issues],
+            },
+            "validate_document": {
+                "ok": self.validate_document.ok,
+                "validated_parts": list(self.validate_document.validated_parts),
+                "errors": [str(issue) for issue in self.validate_document.errors],
+                "warnings": [str(issue) for issue in self.validate_document.warnings],
+                "issues": [str(issue) for issue in self.validate_document.issues],
+            },
+            "reopened": {
+                "ok": self.reopened.ok,
+                "error": self.reopened.error,
+            },
+            "id_integrity": (
+                None
+                if self.id_integrity is None
+                else {
+                    "ok": self.id_integrity.ok,
+                    "dangling": [str(item) for item in self.id_integrity.dangling],
+                    "orphan_bin_data": [
+                        {
+                            "item_id": item.item_id,
+                            "path": item.path,
+                            "aliases": list(item.aliases),
+                            "sources": list(item.sources),
+                            "severity": item.severity,
+                        }
+                        for item in self.id_integrity.orphan_bin_data
+                    ],
+                    "ignored": [
+                        {
+                            "part": item.part,
+                            "element": item.element,
+                            "attr": item.attr,
+                            "value": item.value,
+                            "reason": item.reason,
+                        }
+                        for item in self.id_integrity.ignored
+                    ],
+                }
+            ),
+        }
+
+
+@dataclass(frozen=True)
+class BuilderVerifyReport:
+    """Compact, no-disk pre-write verification signal from ``Document.verify()``.
+
+    Lowers the built document to bytes in memory and runs the same hard gates as
+    a real save plus a two-round idempotence check — without writing a file — so
+    a caller (agent, fuzz loop) can branch on ``ok`` before committing a path.
+    See :data:`FIDELITY_CONTRACT` for what these gates prove vs. don't.
+    """
+
+    ok: bool
+    reopen_ok: bool
+    package_ok: bool
+    document_ok: bool
+    editor_open_safety_ok: bool
+    id_integrity_ok: bool
+    idempotent: bool
+    sections_reconciled: bool = True
+    section_count: int = 0
+    paragraph_count: int = 0
+    byte_length: int = 0
+    reopen_error: str | None = None
+    serialize_error: str | None = None
+    idempotence: IdempotenceReport | None = None
+    reconcile: PackageReconcileReport | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "ok": self.ok,
+            "reopen_ok": self.reopen_ok,
+            "package_ok": self.package_ok,
+            "document_ok": self.document_ok,
+            "editor_open_safety_ok": self.editor_open_safety_ok,
+            "id_integrity_ok": self.id_integrity_ok,
+            "idempotent": self.idempotent,
+            "sections_reconciled": self.sections_reconciled,
+            "section_count": self.section_count,
+            "paragraph_count": self.paragraph_count,
+            "byte_length": self.byte_length,
+            "reopen_error": self.reopen_error,
+            "serialize_error": self.serialize_error,
+            "idempotence": (
+                None if self.idempotence is None else self.idempotence.to_dict()
+            ),
+            "reconcile": (None if self.reconcile is None else self.reconcile.to_dict()),
+            "fidelity_contract": {
+                "proves": list(FIDELITY_CONTRACT["proves"]),
+                "does_not_prove": list(FIDELITY_CONTRACT["does_not_prove"]),
+            },
+        }

hwpx_automation/office/authoring/design/__init__.py

@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Template/Profile builder — new docs from verified Hancom saves (plan §2 E).
+
+New documents are composed from **verified Hancom-saved templates + harvested
+fragments**, never imagined XML. A :class:`~hwpx.design.profile.Profile` bundles a
+body-stripped skeleton ``template.hwpx`` (real styles + page setup) with real
+``<hp:p>``/``<hp:tbl>`` fragments; :func:`~hwpx.design.composer.compose` lowers a
+:class:`~hwpx.design.plan.DocumentPlan` onto it and saves through the one
+SavePipeline. Production mode forbids the minimal from-scratch builder.
+"""
+from __future__ import annotations
+
+from .composer import ComposeResult, ProfileRequiredError, compose, compose_bytes
+from .plan import Block, DocumentPlan
+from .profile import Profile, available_profiles, load_profile
+from .validator import StyleCoverage, style_coverage
+
+__all__ = [
+    "DocumentPlan",
+    "Block",
+    "compose",
+    "compose_bytes",
+    "ComposeResult",
+    "ProfileRequiredError",
+    "Profile",
+    "load_profile",
+    "available_profiles",
+    "StyleCoverage",
+    "style_coverage",
+]

hwpx_automation/office/authoring/design/_support.py

@@ -0,0 +1,144 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Shared XML helpers for the design composer/harvester (lxml element surgery).
+
+Kept tiny and dependency-free so both :mod:`hwpx.design.harvest` (build the
+skeleton + fragments once) and :mod:`hwpx.design.composer` (lower a plan) share
+exactly one implementation of the delicate bits: ``secPr`` preservation, body
+replacement, and lineseg-cache stripping.
+"""
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Iterable
+
+from lxml import etree  # pyright: ignore[reportAttributeAccessIssue]
+
+HP_NS = "http://www.hancom.co.kr/hwpml/2011/paragraph"
+
+
+def ln(tag: object) -> str:
+    return str(tag).rsplit("}", 1)[-1]
+
+
+def hp(element: etree._Element, name: str) -> str:
+    """Namespaced tag for *name* using the element's own paragraph namespace."""
+
+    ns = element.tag.rsplit("}", 1)[0].lstrip("{") if "}" in element.tag else HP_NS
+    return f"{{{ns}}}{name}"
+
+
+def iter_local(element: etree._Element, name: str) -> Iterable[etree._Element]:
+    for child in element.iter():
+        if ln(child.tag) == name:
+            yield child
+
+
+def children_local(element: etree._Element, name: str) -> list[etree._Element]:
+    return [c for c in element if ln(c.tag) == name]
+
+
+def first_run(paragraph: etree._Element) -> etree._Element | None:
+    for child in paragraph:
+        if ln(child.tag) == "run":
+            return child
+    return None
+
+
+def find_secpr(section_element: etree._Element) -> etree._Element | None:
+    for el in section_element.iter():
+        if ln(el.tag) == "secPr":
+            return el
+    return None
+
+
+def strip_lineseg(element: etree._Element) -> None:
+    """Remove every ``<hp:linesegarray>`` under *element* (edited → recompute)."""
+
+    for cache in list(iter_local(element, "linesegarray")):
+        parent = cache.getparent()
+        if parent is not None:
+            parent.remove(cache)
+
+
+def set_paragraph_text(paragraph: etree._Element, text: str) -> None:
+    """Put *text* in the paragraph's first ``<hp:t>``, clear the rest, drop cache.
+
+    Preserves the run's ``charPrIDRef`` (the harvested style) — only the text
+    content changes.
+    """
+
+    t_nodes = [t for t in iter_local(paragraph, "t") if not _under_table(paragraph, t)]
+    if t_nodes:
+        primary = t_nodes[0]
+        primary.text = text
+        for child in list(primary):  # drop inline children that held fragments
+            primary.remove(child)
+        for node in t_nodes[1:]:
+            node.text = ""
+            for child in list(node):
+                node.remove(child)
+    else:
+        run = first_run(paragraph)
+        if run is not None:
+            t = etree.SubElement(run, hp(paragraph, "t"))
+            t.text = text
+    strip_lineseg(paragraph)
+
+
+def _under_table(paragraph: etree._Element, node: etree._Element) -> bool:
+    parent = node.getparent()
+    while parent is not None and parent is not paragraph:
+        if ln(parent.tag) in ("tbl", "tc", "subList"):
+            return True
+        parent = parent.getparent()
+    return False
+
+
+def move_secpr_into(first_paragraph: etree._Element, secpr: etree._Element) -> None:
+    """Make *first_paragraph*'s first run carry *secpr* (page setup preserved).
+
+    HWPX requires ``secPr`` on the first paragraph's first run; the composer drops
+    the skeleton's empty carrier paragraph, so the secPr rides into the first real
+    fragment instead.
+    """
+
+    run = first_run(first_paragraph)
+    if run is None:
+        run = etree.SubElement(first_paragraph, hp(first_paragraph, "run"), {"charPrIDRef": "0"})
+        first_paragraph.insert(0, run)
+    # Remove any secPr already present, then insert the captured one first.
+    for existing in list(children_local(run, "secPr")):
+        run.remove(existing)
+    run.insert(0, deepcopy(secpr))
+
+
+def replace_section_body(
+    section_element: etree._Element, paragraphs: list[etree._Element]
+) -> None:
+    """Replace the section's ``<hp:p>`` children with *paragraphs* (in order)."""
+
+    insert_at = None
+    for index, child in enumerate(list(section_element)):
+        if ln(child.tag) == "p":
+            if insert_at is None:
+                insert_at = index
+            section_element.remove(child)
+    if insert_at is None:
+        insert_at = len(list(section_element))
+    for offset, paragraph in enumerate(paragraphs):
+        section_element.insert(insert_at + offset, paragraph)
+
+
+__all__ = [
+    "HP_NS",
+    "ln",
+    "hp",
+    "iter_local",
+    "children_local",
+    "first_run",
+    "find_secpr",
+    "strip_lineseg",
+    "set_paragraph_text",
+    "move_secpr_into",
+    "replace_section_body",
+]

hwpx_automation/office/authoring/design/composer.py

@@ -0,0 +1,282 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Compose a new document from a profile + plan (plan §2 Phase E, task 2/3).
+
+``compose`` lowers a :class:`~hwpx.design.plan.DocumentPlan` onto a verified
+Hancom-saved skeleton: it clones the harvested fragments (real ``<hp:p>``/
+``<hp:tbl>`` with real styles), fills their text/cells, preserves the template's
+``secPr``/page setup, checks ``styleCoverage``, and saves through the single
+:class:`~hwpx.quality.SavePipeline`. Every byte of structure traces to a real
+Hancom save — never imagined XML. Production mode forbids any minimal-XML fallback.
+"""
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass, field
+from os import PathLike
+from typing import Any
+from uuid import uuid4
+
+from lxml import etree  # pyright: ignore[reportAttributeAccessIssue]
+
+from hwpx.document import HwpxDocument
+from hwpx.quality import QualityPolicy
+
+import hwpx_automation.office.authoring.design._support as S
+from .plan import Block, DocumentPlan
+from .profile import Profile, load_profile
+from .validator import StyleCoverage, style_coverage
+
+# Roles a paragraph block may request; unknown roles fall back to body.
+_PARAGRAPH_ROLES = ("title", "heading", "subheading", "body")
+
+
+class ProfileRequiredError(RuntimeError):
+    """Production compose could not stay on the verified template + fragments."""
+
+
+@dataclass(slots=True)
+class ComposeResult:
+    ok: bool
+    profile: str
+    output_path: str | None
+    visual_complete: Any
+    style_coverage: StyleCoverage
+    block_count: int
+    warnings: list[str] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "ok": self.ok,
+            "profile": self.profile,
+            "outputPath": self.output_path,
+            "blockCount": self.block_count,
+            "styleCoverage": self.style_coverage.to_dict(),
+            "visualComplete": self.visual_complete.to_dict() if self.visual_complete else None,
+            "warnings": list(self.warnings),
+            "errors": list(self.errors),
+        }
+
+
+def compose(
+    plan: DocumentPlan | dict,
+    *,
+    profile: Profile | None = None,
+    output_path: str | PathLike[str] | None = None,
+    quality: QualityPolicy | None = None,
+    production: bool = True,
+) -> ComposeResult:
+    """Lower *plan* onto its profile and save (or gate) through the SavePipeline."""
+
+    if isinstance(plan, dict):
+        plan = DocumentPlan.from_dict(plan)
+    prof = profile or load_profile(plan.profile)
+    warnings: list[str] = []
+
+    doc = HwpxDocument.open(prof.template_bytes)
+    try:
+        section = doc.sections[0]
+        secpr = S.find_secpr(section.element)
+        if secpr is None:
+            raise ProfileRequiredError(f"profile {prof.id!r} skeleton has no secPr")
+        secpr = deepcopy(secpr)
+
+        new_paragraphs: list[etree._Element] = []
+        for block in plan.iter_blocks():
+            frag = _fragment_for(prof, block, production, warnings)
+            if frag is None:
+                continue
+            new_paragraphs.append(frag)
+
+        if not new_paragraphs:
+            raise ProfileRequiredError(
+                f"plan produced no content for profile {prof.id!r}"
+            )
+
+        S.move_secpr_into(new_paragraphs[0], secpr)
+        S.replace_section_body(section.element, new_paragraphs)
+        _reassign_paragraph_ids(new_paragraphs)
+        section.mark_dirty()
+
+        coverage = style_coverage(doc, new_paragraphs)
+        errors: list[str] = []
+        if production and not coverage.meets(prof.style_coverage_threshold):
+            errors.append(
+                f"STYLE_COVERAGE_TOO_LOW: {coverage.coverage:.3f} < "
+                f"{prof.style_coverage_threshold} (missing {coverage.missing[:5]})"
+            )
+            return ComposeResult(
+                ok=False, profile=prof.id, output_path=None, visual_complete=None,
+                style_coverage=coverage, block_count=len(new_paragraphs),
+                warnings=warnings, errors=errors,
+            )
+
+        policy = quality or _default_policy()
+        try:
+            report = doc.save_report(output_path, quality=policy)
+        except ValueError as exc:
+            # save_report raises (not returns) when the serialized bytes fail the
+            # open-safety floor — convert to the structured ok=False contract.
+            return ComposeResult(
+                ok=False, profile=prof.id, output_path=None, visual_complete=None,
+                style_coverage=coverage, block_count=len(new_paragraphs),
+                warnings=warnings, errors=[f"OPEN_SAFETY_FAILED: {exc}"],
+            )
+    finally:
+        doc.close()
+
+    return ComposeResult(
+        ok=report.ok and coverage.ok,
+        profile=prof.id,
+        output_path=report.output_path,
+        visual_complete=report,
+        style_coverage=coverage,
+        block_count=len(new_paragraphs),
+        warnings=warnings + list(report.warnings),
+        errors=[str(e) for e in report.errors],
+    )
+
+
+def compose_bytes(plan: DocumentPlan | dict, **kwargs: Any) -> tuple[bytes, ComposeResult]:
+    """Compose and return the serialized bytes (no file written).
+
+    The bytes are non-empty only when ``result.ok`` — on a gate failure the
+    SavePipeline withholds the output, so the returned bytes are ``b""``. Callers
+    MUST check ``result.ok`` before using the bytes.
+    """
+
+    import tempfile
+    from pathlib import Path
+
+    with tempfile.TemporaryDirectory() as tmp:
+        out = Path(tmp) / "composed.hwpx"
+        result = compose(plan, output_path=out, **kwargs)
+        data = out.read_bytes() if out.exists() else b""
+    return data, result
+
+
+def _default_policy() -> QualityPolicy:
+    # Structural-tier strict (no render here; the oracle gate runs separately):
+    # open-safety + reference + layout lint on, render off.
+    return QualityPolicy(
+        require_open_safety=True,
+        require_reference_integrity=True,
+        require_visual_complete=False,
+        render_check="off",
+        layout_lint="strict",
+        overflow_policy="warn",
+    )
+
+
+def _fragment_for(
+    prof: Profile, block: Block, production: bool, warnings: list[str]
+) -> etree._Element | None:
+    if block.type == "table":
+        if not prof.has_role("info_table"):
+            _forbid_fallback(production, f"profile {prof.id!r} has no info_table fragment", warnings)
+            return None
+        frag = prof.fragment("info_table")
+        _fill_table(frag, block.columns, block.rows, prof.id, warnings, production)
+        return frag
+
+    role = block.role if prof.has_role(block.role) else "body"
+    if not prof.has_role(role):
+        _forbid_fallback(production, f"profile {prof.id!r} has no {role!r} fragment", warnings)
+        return None
+    frag = prof.fragment(role)
+    S.set_paragraph_text(frag, block.text)
+    return frag
+
+
+def _forbid_fallback(production: bool, message: str, warnings: list[str]) -> None:
+    if production:
+        raise ProfileRequiredError("PROFILE_REQUIRED: " + message)
+    warnings.append("debug fallback: " + message)
+
+
+# --------------------------------------------------------------------------- #
+# Table filling (row-fit the harvested fragment to the plan's rows).
+# --------------------------------------------------------------------------- #
+def _fill_table(
+    paragraph_frag: etree._Element,
+    columns: list[str],
+    rows: list[list[str]],
+    profile_id: str = "",
+    warnings: list[str] | None = None,
+    production: bool = True,
+) -> None:
+    warnings = warnings if warnings is not None else []
+    tbl = next((el for el in paragraph_frag.iter() if S.ln(el.tag) == "tbl"), None)
+    if tbl is None:
+        return
+    trs = [c for c in tbl if S.ln(c.tag) == "tr"]
+    if not trs:
+        return
+    header = trs[0]
+    data_template = deepcopy(trs[1]) if len(trs) > 1 else deepcopy(trs[0])
+    col_count = len([c for c in header if S.ln(c.tag) == "tc"])
+
+    # The harvested grid has a fixed width; a plan asking for MORE columns would
+    # silently lose data (fewer just leaves blank trailing cells). Surface it —
+    # and in production refuse the lossy case rather than drop the user's content.
+    want = len(columns) or max((len(r) for r in rows), default=0)
+    if want > col_count:
+        message = (
+            f"TABLE_COLUMN_MISMATCH: plan asks for {want} columns but the "
+            f"{profile_id!r} info_table grid has {col_count}; extra columns dropped"
+        )
+        if production:
+            raise ProfileRequiredError("PROFILE_REQUIRED: " + message)
+        warnings.append("debug fallback: " + message)
+    elif 0 < want < col_count:
+        warnings.append(
+            f"table column-count mismatch: plan has {want} columns, "
+            f"{profile_id!r} grid has {col_count}; trailing columns left blank"
+        )
+
+    # Always re-fill the header (even when columns is empty) so the harvested
+    # {{cell}} placeholder never ships in the output.
+    _fill_row(header, columns, col_count, row_addr=0)
+    for tr in trs[1:]:
+        tbl.remove(tr)
+
+    header_index = list(tbl).index(header)
+    data_rows = rows or [["" for _ in range(col_count)]]
+    for offset, row in enumerate(data_rows):
+        new_tr = deepcopy(data_template)
+        _fill_row(new_tr, row, col_count, row_addr=offset + 1)
+        tbl.insert(header_index + 1 + offset, new_tr)
+
+    tbl.set("rowCnt", str(1 + len(data_rows)))
+    S.strip_lineseg(paragraph_frag)
+
+
+def _fill_row(tr: etree._Element, values: list[str], col_count: int, row_addr: int) -> None:
+    tcs = [c for c in tr if S.ln(c.tag) == "tc"]
+    for col_index, tc in enumerate(tcs):
+        addr = next((c for c in tc if S.ln(c.tag) == "cellAddr"), None)
+        if addr is not None:
+            addr.set("rowAddr", str(row_addr))
+            addr.set("colAddr", str(col_index))
+        value = values[col_index] if col_index < len(values) else ""
+        sublist = next((c for c in tc if S.ln(c.tag) == "subList"), None)
+        target = sublist if sublist is not None else tc
+        cell_paras = S.children_local(target, "p")
+        # Collapse the cell to a single paragraph — a source cell may hold several
+        # (empty) paragraphs, which Hancom flags as a damaged table after cloning.
+        for extra in cell_paras[1:]:
+            target.remove(extra)
+        if cell_paras:
+            S.set_paragraph_text(cell_paras[0], value)
+
+
+def _reassign_paragraph_ids(paragraphs: list[etree._Element]) -> None:
+    """Give every <hp:p> a fresh id so clones don't collide (id integrity)."""
+
+    for root in paragraphs:
+        for para in root.iter():
+            if S.ln(para.tag) == "p" and para.get("id") is not None:
+                para.set("id", str(uuid4().int % (2**31)))
+
+
+__all__ = ["compose", "compose_bytes", "ComposeResult", "ProfileRequiredError"]