athena-python-docx 0.6.0__tar.gz → 0.6.2__tar.gz

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: athena-python-docx
-Version: 0.6.0
+Version: 0.6.2
 Summary: Drop-in replacement for python-docx that connects to Athena's Superdoc/Keryx collaborative document stack
 Project-URL: Homepage, https://athenaintelligence.ai
 Author-email: Athena Intelligence <engineering@athenaintelligence.ai>

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/docx/__init__.py

@@ -6,7 +6,7 @@ See CLAUDE.md for the API parity contract.
 
 from __future__ import annotations
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"
 
 from docx.api import Document
 from docx._buffer import flush_all

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/docx/_buffer.py

@@ -278,7 +278,11 @@ class CommandBuffer:
         # PTC begin: one event per user-facing method call, before any
         # batching. Failures here can't crash the user's code path.
         try:
-            cmd._ptc_call_id = _ptc.emit_begin(type(cmd).__name__, cmd.to_dict())  # type: ignore[attr-defined]
+            cmd._ptc_call_id = _ptc.emit_begin(  # type: ignore[attr-defined]
+                type(cmd).__name__,
+                cmd.to_dict(),
+                asset_id=self._asset_id,
+            )
         except Exception:  # noqa: BLE001
             pass
 

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/docx/_http_doc.py

@@ -68,6 +68,8 @@ from docx.commands import (
     Insert,
     InsertLineBreak,
     InsertTab,
+    ListsAttach,
+    ListsCreate,
     ListsMerge,
     ListsSplit,
     MarkdownToFragment,
@@ -503,9 +505,14 @@ _OP_TO_COMMAND: dict[str, type[Command]] = {
     "header_footers.get": HeaderFootersGet,
     "header_footers.resolve": HeaderFootersResolve,
     "header_footers.refs.set_linked_to_previous": HeaderFootersRefsSetLinkedToPrevious,
-    # Lists & Selection (SuperDoc 1.8.1 additions; not exposed on the
-    # python-docx parity surface — registered here for typed-bus
-    # completeness when advanced callers reach for them).
+    # Lists & Selection. ``lists.create`` and ``lists.attach`` are
+    # consumed internally by ``Document.add_paragraph`` to make
+    # ``style="List Bullet" | "List Number"`` produce real list
+    # structure (not just a style attribute on a flat paragraph).
+    # ``lists.merge``/``lists.split`` stay typed-bus-only — no
+    # python-docx parity surface for them.
+    "lists.create": ListsCreate,
+    "lists.attach": ListsAttach,
     "lists.merge": ListsMerge,
     "lists.split": ListsSplit,
     "selection.current": SelectionCurrent,

athena_python_docx-0.6.2/docx/_ptc.py

@@ -0,0 +1,138 @@
+"""Programmatic Tool Calling (PTC) — client side.
+
+Activated only when ``ATHENA_PTC_URL`` is set. The URL is a presigned
+endpoint URL with an HMAC-signed token embedded as ``?t=…``; the token
+carries the (thread, parent_tool_call_id, run) triple and an expiry.
+The SDK doesn't need to know that triple — it just POSTs to the URL
+verbatim, and the server derives identity from the token.
+
+Without ``ATHENA_PTC_URL`` set, every call here is a no-op.
+
+Emits are fire-and-forget on a background daemon thread:
+
+- Never raise into user code.
+- Never block the calling thread.
+- Re-read ``ATHENA_PTC_URL`` on every emit so updates between sandbox
+  executions take effect immediately (the SDK module itself is cached
+  across runs).
+- Snapshot the URL at ``emit_begin`` time and carry it to ``emit_end``
+  so late end events can't be misattributed if a new sandbox run
+  swapped in a different URL between begin and end.
+
+This module is *intentionally byte-identical* across the docx / pptx /
+xlsx SDKs — the three SDKs have no shared base. Duplicating ~100 LOC
+of stdlib code is cheaper than spinning up a 4th release pipeline.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import queue
+import threading
+import time
+import urllib.error
+import urllib.request
+import uuid
+from typing import Any
+
+_MAX_QUEUE = 4096
+_MAX_BODY = 64 * 1024
+_HTTP_TIMEOUT = 2.0
+
+# Singleton state. PTC has exactly one outbox per process.
+_outbox: queue.Queue[tuple[str, dict[str, Any]]] = queue.Queue(maxsize=_MAX_QUEUE)
+_thread_lock = threading.Lock()
+_thread_started = False
+# call_id -> URL snapshot at begin time; lets emit_end target the
+# original run's endpoint even if ATHENA_PTC_URL changed since.
+_call_url: dict[str, str] = {}
+
+
+def _drain() -> None:
+    while True:
+        item = _outbox.get()
+        if item is None:
+            return
+        url, body = item
+        try:
+            raw = json.dumps(body).encode("utf-8")
+            if len(raw) > _MAX_BODY:
+                key = "args" if body.get("phase") == "begin" else "result"
+                body[key] = {"__truncated__": True}
+                raw = json.dumps(body).encode("utf-8")
+            req = urllib.request.Request(
+                url,
+                data=raw,
+                method="POST",
+                headers={"Content-Type": "application/json"},
+            )
+            urllib.request.urlopen(req, timeout=_HTTP_TIMEOUT).close()
+        except (urllib.error.URLError, OSError, ValueError):
+            pass  # never propagate
+
+
+def _ensure_thread() -> None:
+    global _thread_started
+    if _thread_started:
+        return
+    with _thread_lock:
+        if _thread_started:
+            return
+        threading.Thread(target=_drain, name="athena-ptc", daemon=True).start()
+        _thread_started = True
+
+
+def _send(url: str, body: dict[str, Any]) -> None:
+    _ensure_thread()
+    try:
+        _outbox.put_nowait((url, body))
+    except queue.Full:
+        pass  # drop on backpressure; never block user code
+
+
+def emit_begin(
+    tool_name: str,
+    args: dict[str, Any],
+    *,
+    asset_id: str | None = None,
+) -> str:
+    call_id = uuid.uuid4().hex
+    url = os.environ.get("ATHENA_PTC_URL")
+    if not url:
+        return call_id
+    _call_url[call_id] = url
+    body: dict[str, Any] = {
+        "callId": call_id,
+        "toolName": tool_name,
+        "phase": "begin",
+        "args": args,
+        "ts": time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime()),
+    }
+    if asset_id is not None:
+        body["assetId"] = asset_id
+    _send(url, body)
+    return call_id
+
+
+def emit_end(
+    *,
+    call_id: str,
+    tool_name: str,
+    result: dict[str, Any] | None,
+    is_error: bool,
+) -> None:
+    url = _call_url.pop(call_id, None)
+    if url is None:
+        return  # PTC was disabled at begin, or begin wasn't emitted
+    _send(
+        url,
+        {
+            "callId": call_id,
+            "toolName": tool_name,
+            "phase": "end",
+            "result": result,
+            "isError": is_error,
+            "ts": time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime()),
+        },
+    )

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/docx/commands.py

@@ -619,6 +619,40 @@ class HeaderFootersRefsSetLinkedToPrevious(Command):
 # every other op.
 
 
+@dataclass
+class ListsCreate(Command):
+    """Create a new list — either an empty list at an anchor, or by
+    converting an existing paragraph (range) into a list.
+
+    SuperDoc: ``doc.lists.create``.
+
+    - ``mode="empty"`` requires ``at`` (BlockAddress).
+    - ``mode="fromParagraphs"`` requires ``target`` (BlockAddressOrRange).
+    - ``kind`` is ``"bullet"`` or ``"ordered"``.
+    """
+
+    mode: str = "fromParagraphs"
+    at: dict[str, Any] | None = None
+    target: dict[str, Any] | None = None
+    kind: str | None = None
+    level: int | None = None
+    preset: str | None = None
+
+
+@dataclass
+class ListsAttach(Command):
+    """Attach an existing paragraph to an existing list as a new item.
+
+    SuperDoc: ``doc.lists.attach``. ``attach_to`` is the list item to
+    attach next to (defines list membership); ``target`` is the
+    paragraph being converted.
+    """
+
+    attach_to: dict[str, Any] = dataclasses.field(default_factory=dict)
+    target: dict[str, Any] = dataclasses.field(default_factory=dict)
+    level: int | None = None
+
+
 @dataclass
 class ListsMerge(Command):
     """Merge a list item with an adjacent list / list item.
@@ -768,6 +802,12 @@ _RESPONSE_BEARING_TYPES: frozenset[str] = frozenset(
         # describing the entities affected by accept/reject — callers
         # need that synchronously to invalidate their Revision proxies.
         "TrackChangesDecide",
+        # ListsCreate / ListsAttach return {item: {nodeId: <listItemId>}}.
+        # Document.add_paragraph reads listItemId to (1) update the
+        # Paragraph proxy's node_id so subsequent ops target the
+        # listItem, and (2) chain the next list item via lists.attach.
+        "ListsCreate",
+        "ListsAttach",
     }
 )
 

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/docx/comments.py

@@ -314,6 +314,26 @@ class Comments:
         Use :meth:`Document.add_comment` to thread a run-anchored
         target — this method creates an unanchored comment.
         """
+        # python-docx 1.x routes ``text`` / ``author`` / ``initials``
+        # through lxml's element setters which TypeError on non-str.
+        # Was: any value shipped to wire (text) or stashed as-is on
+        # the local info dict (author/initials) — caller's intent was
+        # lost when they passed a wrong type.
+        if not isinstance(text, str):
+            raise TypeError(
+                f"Comments.add_comment text requires str; got "
+                f"{type(text).__name__} {text!r}",
+            )
+        if not isinstance(author, str):
+            raise TypeError(
+                f"Comments.add_comment author requires str; got "
+                f"{type(author).__name__} {author!r}",
+            )
+        if initials is not None and not isinstance(initials, str):
+            raise TypeError(
+                f"Comments.add_comment initials requires str or None; "
+                f"got {type(initials).__name__} {initials!r}",
+            )
         result: object = run_sync(
             self._session.doc.comments.create({"text": text}),
         )

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/docx/document.py

@@ -79,6 +79,49 @@ class _InlineShapeIdAdapter:
         )
 
 
+def _classify_list_style(style_id: str | None) -> tuple[str, int] | None:
+    """Map a python-docx list-style id to a SuperDoc (kind, level) pair.
+
+    Returns ``None`` for non-list styles. Recognized styles:
+
+    - ``"List Bullet"``    → ``("bullet", 0)``
+    - ``"List Bullet 2"``  → ``("bullet", 1)``     (... up to ``5`` → level 4)
+    - ``"List Number"``    → ``("ordered", 0)``
+    - ``"List Number 2"``  → ``("ordered", 1)``    (... up to ``5`` → level 4)
+
+    Accepts both display-name (``"List Bullet 2"``) and style-id
+    (``"ListBullet2"``) forms. ``"List Paragraph"`` and ``"List Continue"``
+    are intentionally NOT classified as bullet/number lists — those styles
+    indicate "indented body text", not a numbered/bulleted list, and Word
+    renders them without a marker. Callers wanting those effects should
+    use the style as-is via the generic ``setStyle`` path.
+    """
+    if not isinstance(style_id, str) or not style_id:
+        return None
+    # Normalize: lower-case, strip spaces.
+    norm = style_id.lower().replace(" ", "")
+    if norm.startswith("listbullet"):
+        suffix = norm[len("listbullet"):]
+        kind = "bullet"
+    elif norm.startswith("listnumber"):
+        suffix = norm[len("listnumber"):]
+        kind = "ordered"
+    else:
+        return None
+    if suffix == "":
+        level = 0
+    else:
+        try:
+            n = int(suffix)
+        except ValueError:
+            return None
+        if n < 1 or n > 9:
+            return None
+        # "List Bullet 2" → level 1 (zero-indexed depth).
+        level = n - 1
+    return (kind, level)
+
+
 class IgnoredSaveTargetWarning(UserWarning):
     """Emitted when ``Document.save(path_or_stream=...)`` is called with a
     non-None argument.
@@ -123,6 +166,13 @@ class Document:
         self._pending_user_name: str | None = user_name
         self._pending_user_email: str | None = user_email
         self._pending_track_revisions: bool = bool(track_revisions)
+        # List-chain state. When the most-recent ``add_paragraph`` call
+        # produced a list item, subsequent ``add_paragraph(..., style="List
+        # Bullet"|"List Number")`` calls attach to it (lists.attach)
+        # instead of starting a new list (lists.create). Any non-list
+        # ``add_paragraph`` / ``add_heading`` / ``add_table`` resets this.
+        self._last_list_item_id: str | None = None
+        self._last_list_kind: str | None = None
 
     @classmethod
     def create(
@@ -596,9 +646,24 @@ class Document:
 
         # Coerce ParagraphStyle instances to their style id so the rest
         # of this method can treat `style` as an Optional[str].
-        style_str: str | None = (
-            style.style_id if isinstance(style, ParagraphStyle) else style
-        )
+        # python-docx 1.x accepts ``str | ParagraphStyle | None`` and
+        # raises ``TypeError`` at the style-lookup layer for anything
+        # else. Mirror that — the previous code accepted ``style`` as
+        # the literal value when it wasn't a ParagraphStyle, so e.g.
+        # ``add_paragraph(style=42)`` shipped ``42`` as the style id.
+        style_str: str | None
+        if style is None:
+            style_str = None
+        elif isinstance(style, ParagraphStyle):
+            style_str = style.style_id
+        elif isinstance(style, str):
+            style_str = style
+        else:
+            raise TypeError(
+                f"Document.add_paragraph style requires str, "
+                f"ParagraphStyle, or None; got "
+                f"{type(style).__name__} {style!r}",
+            )
 
         # Use Superdoc's canonical primitive `doc.create.paragraph`. It
         # accepts an `at` anchor and a `text` body; an empty `text` creates
@@ -624,8 +689,9 @@ class Document:
         # heavy lifting.
         normalized: str = self._normalize_text(text)
         has_control_chars = any(ch in "\t\n\r" for ch in normalized)
+        wire_text: str = "" if has_control_chars else normalized
         params: dict = {
-            "text": "" if has_control_chars else normalized,
+            "text": wire_text,
             "at": {"kind": "documentEnd"},
         }
         # When inside ``with doc.batch():`` we pre-assign a client UUID
@@ -650,8 +716,13 @@ class Document:
                 raise RuntimeError(
                     f"Superdoc did not return a nodeId for add_paragraph: {result!r}",
                 )
+        # Seed the text-length cache so the next ``p.add_run(...)``
+        # call can skip its ``get_node_by_id`` HTTP round-trip.
         para = Paragraph(
-            session=self._session, node_id=node_id, node_type="paragraph",
+            session=self._session,
+            node_id=node_id,
+            node_type="paragraph",
+            text_len=len(wire_text),
         )
         if client_node_id is not None:
             self._register_proxy_for_batch(client_node_id, para)
@@ -668,8 +739,142 @@ class Document:
             # or transport error otherwise leaves the user with a
             # paragraph that quietly missed the style they asked for.
             para.style = style_str
+
+        # python-docx parity: ``add_paragraph(text, style="List Bullet")``
+        # is the canonical way to author a bulleted/numbered list (the
+        # upstream library exposes no separate list primitive — the style
+        # is the list). On Word/OOXML the style's ``<w:numPr/>`` makes
+        # bullets appear; on SuperDoc/ProseMirror the style attribute
+        # alone does NOT, because lists are a distinct node type
+        # (``bulletList > listItem > paragraph``) rather than a flat
+        # paragraph with a style.
+        #
+        # To make the python-docx contract render correctly we follow
+        # up the paragraph create + setStyle with SuperDoc's
+        # ``doc.lists.create`` / ``doc.lists.attach`` so the paragraph
+        # is structurally converted into a list item under a real
+        # bulletList / orderedList node. Consecutive list-styled
+        # ``add_paragraph`` calls (of the same kind) chain into a
+        # single list via ``lists.attach``; the first one starts a new
+        # list via ``lists.create(mode="fromParagraphs")``.
+        list_info = _classify_list_style(style_str)
+        if list_info is not None:
+            kind, level = list_info
+            self._convert_paragraph_to_list_item(
+                paragraph_node_id=node_id,
+                kind=kind,
+                level=level,
+            )
+        else:
+            # Any non-list paragraph breaks the chain — the next list
+            # item will start a fresh list.
+            self._last_list_item_id = None
+            self._last_list_kind = None
         return para
 
+    def _convert_paragraph_to_list_item(
+        self,
+        *,
+        paragraph_node_id: str,
+        kind: str,
+        level: int,
+    ) -> None:
+        """Promote a flat paragraph into a list item.
+
+        Chains with the previous list (same ``kind``) via
+        ``lists.attach``; otherwise starts a new list via
+        ``lists.create(mode="fromParagraphs")``. Updates the
+        ``_last_list_item_id`` / ``_last_list_kind`` chain state so the
+        next list-styled ``add_paragraph`` call attaches to this item.
+
+        Failures don't raise — the paragraph + setStyle already
+        landed, and surfacing a structural-promotion error here would
+        roll back work the caller can't undo. We emit a console warning
+        and reset the chain so subsequent items start fresh rather than
+        attaching to an orphaned id.
+        """
+        para_target: dict = {
+            "kind": "block",
+            "nodeType": "paragraph",
+            "nodeId": paragraph_node_id,
+        }
+        try:
+            if (
+                self._last_list_item_id is not None
+                and self._last_list_kind == kind
+            ):
+                result = run_sync(
+                    self._session.doc.lists.attach(
+                        {
+                            "attach_to": {
+                                "kind": "block",
+                                "nodeType": "listItem",
+                                "nodeId": self._last_list_item_id,
+                            },
+                            "target": para_target,
+                            "level": level,
+                        },
+                    ),
+                )
+            else:
+                result = run_sync(
+                    self._session.doc.lists.create(
+                        {
+                            "mode": "fromParagraphs",
+                            "target": para_target,
+                            "kind": kind,
+                            "level": level,
+                        },
+                    ),
+                )
+        except Exception as e:  # noqa: BLE001
+            _log_warn(
+                f"list-item promotion failed for paragraph "
+                f"{paragraph_node_id!r} ({kind}, level {level}): {e}; "
+                f"paragraph remains flat with the style attribute set.",
+            )
+            self._last_list_item_id = None
+            self._last_list_kind = None
+            return
+
+        item_id = self._extract_list_item_id(result)
+        if item_id:
+            self._last_list_item_id = item_id
+            self._last_list_kind = kind
+        else:
+            # Couldn't read back the listItem id — break the chain so the
+            # next call doesn't attach to a stale or missing target.
+            _log_warn(
+                f"list op returned no item.nodeId for paragraph "
+                f"{paragraph_node_id!r}; list chain reset. Response: "
+                f"{result!r}",
+            )
+            self._last_list_item_id = None
+            self._last_list_kind = None
+
+    def _reset_list_chain(self) -> None:
+        """Break the consecutive-list-items chain. Called by any block
+        insertion that isn't a list-styled paragraph (heading, table,
+        picture, page break, section break) so the next list item
+        starts a fresh list rather than attaching to a stale predecessor.
+        """
+        self._last_list_item_id = None
+        self._last_list_kind = None
+
+    @staticmethod
+    def _extract_list_item_id(result: object) -> str | None:
+        """Pull ``item.nodeId`` out of a ``lists.create`` / ``lists.attach``
+        SuperDoc response. Returns ``None`` if the shape is unexpected."""
+        if not isinstance(result, dict):
+            return None
+        item = result.get("item")
+        if not isinstance(item, dict):
+            return None
+        node_id = item.get("nodeId") or item.get("node_id")
+        if isinstance(node_id, str) and node_id:
+            return node_id
+        return None
+
     def add_heading(
         self,
         text: str = "",
@@ -679,6 +884,7 @@ class Document:
         from docx.text.paragraph import Paragraph
 
         self._ensure_open()
+        self._reset_list_chain()
         if not 0 <= level <= 9:
             raise ValidationError(
                 f"level must be in 0..9; got {level}",
@@ -722,6 +928,7 @@ class Document:
                 session=self._session,
                 node_id=node_id,
                 node_type="paragraph",
+                text_len=len(wire_text),
             )
             if client_node_id is not None:
                 self._register_proxy_for_batch(client_node_id, paragraph)
@@ -753,7 +960,10 @@ class Document:
                     f"Superdoc did not return a nodeId for add_heading: {result!r}",
                 )
         heading = Paragraph(
-            session=self._session, node_id=node_id, node_type="heading",
+            session=self._session,
+            node_id=node_id,
+            node_type="heading",
+            text_len=len(wire_text),
         )
         if client_node_id is not None:
             self._register_proxy_for_batch(client_node_id, heading)
@@ -771,6 +981,7 @@ class Document:
         from docx.table import Table
 
         self._ensure_open()
+        self._reset_list_chain()
         if rows < 1 or cols < 1:
             raise ValidationError(
                 f"rows and cols must be >= 1; got rows={rows} cols={cols}",
@@ -858,6 +1069,7 @@ class Document:
         from docx.text.run import _build_inline_shape_info
 
         self._ensure_open()
+        self._reset_list_chain()
 
         image_bytes: bytes
         fallback_path: str = ""

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/docx/enum/section.py

@@ -4,6 +4,17 @@ from __future__ import annotations
 
 from enum import Enum
 
+from docx.enum.text import _warn_enum_coercion
+
+__all__ = [
+    "WD_HEADER_FOOTER",
+    "WD_HEADER_FOOTER_INDEX",
+    "WD_ORIENT",
+    "WD_ORIENTATION",
+    "WD_SECTION",
+    "WD_SECTION_START",
+]
+
 
 class WD_ORIENTATION(Enum):
     PORTRAIT = "portrait"
@@ -31,6 +42,13 @@ class WD_SECTION_START(Enum):
             return "evenPage"
         if self == WD_SECTION_START.ODD_PAGE:
             return "oddPage"
+        if self == WD_SECTION_START.NEW_PAGE:
+            return "nextPage"
+        # NEW_COLUMN — SuperDoc 1.8 doesn't have a column-break section
+        # type, so we collapse to "nextPage" but emit
+        # PendingEnumCoercionWarning so callers don't silently get a
+        # page break when they asked for a column break.
+        _warn_enum_coercion(self, "nextPage")
         return "nextPage"
 
 

{athena_python_docx-0.6.0 → athena_python_docx-0.6.2}/docx/enum/text.py

@@ -13,6 +13,19 @@ import warnings
 from enum import Enum
 
 
+_INT_TO_ALIGN: "dict[int, str]" = {
+    0: "LEFT",
+    1: "CENTER",
+    2: "RIGHT",
+    3: "JUSTIFY",
+    4: "DISTRIBUTE",
+    5: "JUSTIFY_MED",
+    7: "JUSTIFY_HI",
+    8: "JUSTIFY_LOW",
+    9: "THAI_JUSTIFY",
+}
+
+
 class PendingEnumCoercionWarning(UserWarning):
     """Emitted when an enum member's :meth:`to_superdoc` collapses the
     value to a different SuperDoc-supported primitive.
@@ -58,6 +71,20 @@ class WD_ALIGN_PARAGRAPH(Enum):
     JUSTIFY_LOW = "justifyLow"
     THAI_JUSTIFY = "thaiJustify"
 
+    @classmethod
+    def from_int(cls, value: int) -> "WD_ALIGN_PARAGRAPH | None":
+        """Coerce a python-docx-style int alignment to the enum.
+
+        python-docx 1.x's ``WD_ALIGN_PARAGRAPH`` is keyed on int (its
+        ``BaseXmlEnum`` mapping: LEFT=0, CENTER=1, RIGHT=2, JUSTIFY=3,
+        DISTRIBUTE=4, JUSTIFY_MED=5, JUSTIFY_HI=7, JUSTIFY_LOW=8,
+        THAI_JUSTIFY=9). Callers passing ``paragraph.alignment = 1``
+        get CENTER. We mirror that without changing our enum's
+        string-valued definition.
+        """
+        name = _INT_TO_ALIGN.get(value)
+        return getattr(cls, name) if name is not None else None
+
     def to_superdoc(self) -> str:
         # Superdoc only supports left/center/right/justify; coerce the
         # distributed/thai variants to "justify" so set_alignment doesn't