athena-python-docx 0.31.0__tar.gz → 0.32.0__tar.gz

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/AGENTS.md

@@ -107,6 +107,12 @@ pinned by focused tests and documented in
   `horz_dpi`, `width`, `scaled_dimensions`, …). A picture in a table cell or
   a header has no id to read its image by, so `.image` raises `ValueError`;
   an older docx-studio does not report pictures, so they are not runs there.
+- **A run holding only a page or column break yields `""` from
+  `Run.iter_inner_content()`,** as python-docx reads a `w:br` of type `page`
+  or `column` as empty text; an empty run (a comment reference's) yields
+  nothing. docx-studio's read marks such a run with `break`, and
+  `Run.add_break` marks the run it adds one to. Against an older docx-studio,
+  which sends no `break`, a re-read run yields nothing.
 - **`Styles.latent_styles`** (`docx.styles.latent.LatentStyles`) reads
   the document's `<w:latentStyles>` (defaults and each `w:lsdException`)
   from docx-studio's `Info` (`includeStyles` → `latentStyles`), as python-docx

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/PKG-INFO

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

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/docx/__init__.py

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

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/docx/_run_order.py

@@ -332,6 +332,45 @@ def note_picture(run: "Run", picture_id: str, offset: int, *, before: str | None
     record.pictures.insert(index, (picture_id, offset))
 
 
+def read_stamp() -> int:
+    """The moment a read gives its runs (``Paragraph.runs``): a run ``add_run``
+    creates after it has a higher ``seq``."""
+    return next(_SEQ)
+
+
+def later_runs_at_end(run: "Run") -> int | None:
+    """How many runs after ``run`` end where it does, by which docx-studio
+    tells ``run`` from them (``run.laterRuns``) where the offset cannot: an
+    empty run ``add_run()`` made after it, or one of breaks alone, ends there
+    too.
+
+    For a run ``add_run`` created, the runs it created after it; for a run a
+    read gave (``Paragraph.runs``), the later runs of that read and the runs
+    ``add_run`` created since. Each where it ends now, not where it ended at
+    the read: a write through a run moves the live proxies (:func:`track_run`),
+    as clearing a run of text after a run of a break leaves an empty run that
+    ends where the break's run does. A read run holds the next run of its
+    read (``_next_read``), so the later ones stay live, and current, while it
+    is. None for a run proxy that is neither, which the SDK cannot tell from
+    the runs around it.
+    """
+    end = run._range[1]
+    records = _records_of(run)
+    own = getattr(run, "_run_record", None) or getattr(run, "_owner_record", None)
+    if own is not None and own in records:
+        return sum(1 for other in records[records.index(own) + 1 :] if other.range[1] == end)
+    read_seq = getattr(run, "_read_seq", None)
+    if read_seq is None:
+        return None
+    later = 0
+    following: Run | None = getattr(run, "_next_read", None)
+    while following is not None:
+        if following._range[1] == end:
+            later += 1
+        following = getattr(following, "_next_read", None)
+    return later + sum(1 for other in records if other.seq > read_seq and other.range[1] == end)
+
+
 def ends_last_at_its_end(run: "Run") -> bool:
     """True when no run ``add_run`` created after ``run`` ends where it does.
 

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/docx/commands.py

@@ -223,6 +223,10 @@ class Replace(Command):
     # …``), whose own properties docx-studio keeps for the new text; an older
     # docx-studio ignores it.
     whole_run: bool | None = None
+    # An empty run's identity among the runs at its place (``{"laterRuns": n}``,
+    # as ``Insert.run``), sent to a docx-studio reporting
+    # ``capabilities.runIdentity``.
+    run: dict[str, Any] | None = None
 
 
 @dataclass
@@ -233,13 +237,17 @@ class InsertLineBreak(Command):
     # ``True`` gives the break the formatting of the run it ends
     # (``Run.add_break``); an older docx-studio ignores it.
     inherit_marks: bool | None = None
-    # ``"column"``: a column break (``Run.add_break(WD_BREAK.COLUMN)``), which
-    # docx-studio writes after the paragraph's content, outside its
-    # text-address space; an older docx-studio ignores it and inserts a line
-    # break.
+    # ``"column"``: a column break (``Run.add_break(WD_BREAK.COLUMN)``),
+    # outside the paragraph's text-address space: with ``inline``, at the end
+    # of the run, in it; otherwise after the paragraph's content. An older
+    # docx-studio ignores it and inserts a line break.
     break_type: str | None = None
     # As ``Insert.run_edge``.
     run_edge: str | None = None
+    # ``True`` with ``break_type="column"``: the break at the end of the run,
+    # in it, as python-docx writes it. Sent only to a docx-studio reporting
+    # ``capabilities.inlineColumnBreak``; an older one ignores it.
+    inline: bool | None = None
 
 
 @dataclass
@@ -261,6 +269,10 @@ class FormatApply(Command):
     # (``run.bold = True``), which docx-studio keeps apart with their new
     # formatting; an older docx-studio ignores it.
     whole_run: bool | None = None
+    # The identity of an empty run that holds a page or column break
+    # (``{"laterRuns": n}``, as ``Insert.run``): its breaks take the
+    # formatting. Sent to a docx-studio reporting ``capabilities.runIdentity``.
+    run: dict[str, Any] | None = None
 
 
 @dataclass
@@ -725,6 +737,10 @@ class Info(Command):
     # ``docProps/core.xml``. An older docx-studio ignores the field, which
     # tells the SDK it has no ``SetCoreProperties``.
     include_core_properties: bool | None = None
+    # ``True`` also returns ``settings``: ``evenAndOddHeaders``, the
+    # document's ``w:evenAndOddHeaders`` in ``word/settings.xml``. An older
+    # docx-studio ignores the field and sends none.
+    include_settings: bool | None = None
 
 
 @dataclass

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/docx/drawing/__init__.py

@@ -29,9 +29,12 @@ class Drawing:
     def has_picture(self) -> bool:
         """True when `drawing` contains an embedded picture.
 
-        A drawing docx-studio reports in a run is always a picture.
+        As python-docx: False for a drawing whose graphic is not a picture (a
+        chart, a diagram, a group), which docx-studio reports with
+        ``hasPicture: false``. An older docx-studio reports none, and every
+        drawing it reports reads as a picture.
         """
-        return True
+        return self._info.get("hasPicture") is not False
 
     @property
     def image(self) -> "Image":
@@ -44,6 +47,8 @@ class Drawing:
         from docx.image.image import Image
         from docx.shape import _strip_data_uri
 
+        if not self.has_picture:
+            raise ValueError("drawing does not contain a picture")
         image_id = self._info.get("imageId")
         if not isinstance(image_id, str) or not image_id:
             raise ValueError("drawing image cannot be read: docx-studio reported no id for it")

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/docx/settings.py

@@ -4,8 +4,9 @@ Most Word app settings are not surfaced by DOCX Studio, so this proxy is
 intentionally minimal. The fields that ARE exposed have one-to-one
 DOCX Studio semantics:
 
-  * ``odd_and_even_pages_header_footer`` — toggles the document-level
-    ``<w:evenAndOddHeaders/>`` flag via DOCX Studio 1.8.1's
+  * ``odd_and_even_pages_header_footer`` — reads the document-level
+    ``<w:evenAndOddHeaders/>`` flag from ``Info`` (``includeSettings``) and
+    toggles it via DOCX Studio 1.8.1's
     ``doc.sections.setOddEvenHeadersFooters`` (doc-level despite its
     namespace — see ``commands.SetSectionsOddEvenHeadersFooters``).
   * ``track_revisions`` — alias for :attr:`docx.document.Document.track_revisions`.
@@ -50,6 +51,15 @@ class Settings:
 
     @property
     def odd_and_even_pages_header_footer(self) -> bool:
+        """The document's ``w:evenAndOddHeaders`` in ``word/settings.xml``, as
+        python-docx reads it (False when absent or off). A docx-studio that
+        does not report it (``Info`` without ``settings``) gives the value this
+        proxy last set."""
+        info: object = run_sync(self._session.doc.info({"includeSettings": True}))
+        settings: object = info.get("settings") if isinstance(info, dict) else None
+        reported: object = settings.get("evenAndOddHeaders") if isinstance(settings, dict) else None
+        if isinstance(reported, bool):
+            return reported
         return self._odd_and_even_pages_header_footer
 
     @odd_and_even_pages_header_footer.setter

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/docx/table.py

@@ -23,9 +23,11 @@ class PendingTableClearWarning(UserWarning):
     setter is asked to clear a property (``None`` assignment) that
     python-docx 1.x supports but DOCX Studio 1.8 has no clear-op for.
 
-    Covers: ``Table.alignment / direction / autofit``,
+    Covers: ``Table.alignment / autofit``,
     ``_Row.height / height_rule``, ``_Column.width``,
-    ``_Cell.width / vertical_alignment``. DOCX Studio's
+    ``_Cell.width / vertical_alignment``, and any ``Table.table_direction``
+    write to a docx-studio that does not report
+    ``capabilities.tableDirection`` (one that does writes None too). DOCX Studio's
     ``tables.set_layout`` / ``set_row_height`` / ``set_column_width``
     / ``set_cell_properties`` require explicit values — the wire
     can't represent the python-docx "revert to inherited" intent.
@@ -1241,36 +1243,48 @@ class Table:
         )
 
     @property
-    def direction(self) -> "WD_TABLE_DIRECTION | None":
-        from docx.enum.table import WD_TABLE_DIRECTION
-
+    def table_direction(self) -> "WD_TABLE_DIRECTION | None":
+        """The table's ``w:bidiVisual`` as python-docx 1.2.0 reads it: ``True``
+        (right to left), ``False`` (an explicit left to right) or None (none),
+        the ``bool`` python-docx returns behind its ``WD_TABLE_DIRECTION`` hint
+        (``True == WD_TABLE_DIRECTION.RTL``)."""
         info: object = run_sync(
             self._session.doc.tables.get_properties({"nodeId": self._fresh_node_id()}),
         )
-        if isinstance(info, dict):
-            return WD_TABLE_DIRECTION.from_docx_studio(info.get("direction"))
+        direction: object = info.get("direction") if isinstance(info, dict) else None
+        if direction == "rtl":
+            return cast("WD_TABLE_DIRECTION", True)
+        if direction == "ltr":
+            return cast("WD_TABLE_DIRECTION", False)
         return None
 
-    @direction.setter
-    def direction(self, value: "WD_TABLE_DIRECTION | int | str | None") -> None:
+    @table_direction.setter
+    def table_direction(self, value: "WD_TABLE_DIRECTION | int | str | None") -> None:
+        """As python-docx 1.2.0: RTL writes ``w:bidiVisual``, LTR writes
+        ``w:bidiVisual w:val="0"`` and None removes it. A docx-studio that does
+        not report ``capabilities.tableDirection`` drops the write, so the SDK
+        sends none there and warns (``PendingTableClearWarning``)."""
+        from docx._capabilities import server_takes
+        from docx.commands import NULL
         from docx.enum.table import WD_TABLE_DIRECTION
 
-        if value is None:
-            _warn_table_clear("direction")
+        # None goes on the wire as JSON null (``NULL``): a ``None`` field is left off it.
+        wire: object = NULL if value is None else WD_TABLE_DIRECTION._wire(value, "Table.table_direction")
+        if not server_takes(self._session, "tableDirection"):
+            warnings.warn(
+                "Table.table_direction was IGNORED: this DOCX Studio does not write a table's "
+                "direction (w:bidiVisual); the table keeps its previous direction.",
+                PendingTableClearWarning,
+                stacklevel=2,
+            )
             return
-        v: str = WD_TABLE_DIRECTION._wire(value, "Table.direction")
-        # DOCX Studio's setLayout takes ``tableDirection`` (not
-        # ``direction``). Same diagnostic as alignment above —
-        # setTableOptions silently swallowed the field.
+        # DOCX Studio's setLayout takes ``tableDirection`` (not ``direction``).
         run_sync(
             self._session.doc.tables.set_layout(
-                {"nodeId": self._fresh_node_id(), "tableDirection": v},
+                {"nodeId": self._fresh_node_id(), "tableDirection": wire},
             ),
         )
 
-    # python-docx aliases
-    table_direction = direction
-
     @property
     def autofit(self) -> bool:
         info: object = run_sync(

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/docx/text/paragraph.py

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING, Any
 from docx._athena_extension import athena_extension
 from docx._batching import run_sync
 from docx._buffer import writes_unapplied
-from docx._run_order import forget_paragraph, register_run
+from docx._run_order import forget_paragraph, read_stamp, register_run
 from docx._tracked import tracking
 
 #: The session attribute ``Paragraph.delete`` bumps, after which every
@@ -818,6 +818,13 @@ class Paragraph:
         # cache for free (avoids a follow-up ``get_node_by_id`` if the
         # caller does ``p.runs[...]; p.add_run(...)``).
         self._text_len = offset
+        # Each run holds the next one of this read: docx-studio tells it from
+        # the later ones that end where it does when content goes to it, by
+        # where they end then (``docx._run_order.later_runs_at_end``).
+        stamp = read_stamp()
+        for index, run_obj in enumerate(runs):
+            run_obj._next_read = runs[index + 1] if index + 1 < len(runs) else None
+            run_obj._read_seq = stamp
         return runs
 
     @property

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/docx/text/run.py

@@ -10,6 +10,7 @@ from docx._batching import run_sync
 from docx._capabilities import server_takes
 from docx._run_order import (
     ends_last_at_its_end,
+    later_runs_at_end,
     note_length_change,
     note_picture,
     note_tracked_replacement,
@@ -401,12 +402,47 @@ class Run:
 
     def _mark_append(self, command: dict) -> dict:
         """Mark content added at the end of this run as this run's
-        (``runEdge: "append"``), which docx-studio keeps one run, when the
-        offset names it: no later run ends there. Returns ``command``."""
-        if ends_last_at_its_end(self):
+        (``runEdge: "append"``), which docx-studio keeps one run. Where later
+        runs end where this one does (an empty run, or one of breaks alone),
+        to a docx-studio that reports ``capabilities.runIdentity``, with how
+        many (``run.laterRuns``), so the content goes into this run; to an
+        older one, only when the offset names it: no later run ends there.
+        The server is asked only then. Returns ``command``."""
+        later = later_runs_at_end(self)
+        if later and server_takes(self._session, "runIdentity"):
+            command["runEdge"] = "append"
+            command["run"] = {**(command.get("run") or {}), "laterRuns": later}
+        elif ends_last_at_its_end(self):
             command["runEdge"] = "append"
         return command
 
+    def _later_runs(self) -> int | None:
+        """The runs after this one that end where it does, by which a
+        docx-studio reporting ``capabilities.runIdentity`` tells this run from
+        them (``docx._run_order.later_runs_at_end``); None for an older one, or
+        a run the SDK cannot tell from the runs around it."""
+        if not server_takes(self._session, "runIdentity"):
+            return None
+        return later_runs_at_end(self)
+
+    def _break_run_identity(self) -> int | None:
+        """This empty run's identity (:meth:`_later_runs`) while it holds a
+        page or column break, which a whole-run ``FormatApply`` of its
+        collapsed range formats, untracked; else None. A column break only in
+        a room that reports ``capabilities.inlineColumnBreak``: one imported
+        before keeps it as a block after the paragraph, which takes no
+        formatting, so the formatting waits for content the run takes. So
+        does a break the read says is no node of the paragraph
+        (``breakApart``): one only its source run holds, a column-break
+        block's, or the page break that opens the paragraph."""
+        if not self._is_collapsed_range or not self._holds_break() or tracking(self._session):
+            return None
+        if self._inline_snapshot.get("breakApart") is True:
+            return None
+        if self._inline_snapshot.get("break") == "column" and not server_takes(self._session, "inlineColumnBreak"):
+            return None
+        return self._later_runs()
+
     def _add_run_ref(self, command: dict) -> dict:
         """Add the run identity of an insert at the end of this run.
 
@@ -415,7 +451,7 @@ class Run:
         """
         ref = run_ref(self)
         if ref is not None:
-            command["run"] = ref
+            command["run"] = {**(command.get("run") or {}), **ref}
         return command
 
     def _note_length_change(
@@ -580,9 +616,28 @@ class Run:
         set, so we ``getattr`` it.
         """
         pending = getattr(self, "_pending_inline", None)
-        if not pending or self._is_collapsed_range:
+        if not pending:
+            return
+        # An empty run that holds a page or column break: docx-studio formats
+        # the break's run, which it tells by the run's identity.
+        identity = self._break_run_identity()
+        if self._is_collapsed_range and identity is None:
             return
         self._pending_inline = {}
+        if identity is not None:
+            run_sync(
+                self._session.doc.format.apply(
+                    {
+                        "target": self._text_range,
+                        "inline": pending,
+                        "wholeRun": True,
+                        "run": {"laterRuns": identity},
+                    },
+                ),
+            )
+            # Its break holds the formatting now, which what it takes next continues.
+            self._fresh = False
+            return
         # An emptied run's kept formatting turns off each toggle it did not
         # read (``_formatting_from_snapshot``), only so that its next text takes
         # none from the paragraph or the run before it. Those are no
@@ -669,7 +724,9 @@ class Run:
         )
 
         drawing = self._inline_snapshot.get("drawing")
-        if isinstance(drawing, dict):
+        # A legacy VML picture or an OLE object (``w:pict``, ``w:object``) is no
+        # ``w:drawing``: python-docx yields nothing for it.
+        if isinstance(drawing, dict) and drawing.get("legacy") is not True:
             from docx.drawing import Drawing
 
             # The picture is at the run's start: text added to the run follows it.
@@ -682,6 +739,11 @@ class Run:
         if "\f" not in text:
             if _word_text(text, font):
                 yield _word_text(text, font)
+            elif self._inline_snapshot.get("break") in ("page", "column"):
+                # python-docx reads a page or column break as text, an empty
+                # string: a run holding one and no other text yields "". An
+                # empty run (a comment reference's) yields nothing.
+                yield ""
             return
         # Split on hard page-break sentinel; yield text segments and
         # RenderedPageBreak proxies between them. The proxy carries the
@@ -752,6 +814,16 @@ class Run:
             self._flush_pending_inline()
             return
         if self._is_collapsed_range:
+            # python-docx replaces all of the run's content, its page or
+            # column break too: an empty run holding one has it removed first.
+            if self._holds_break() and self._replaces_breaks():
+                clear: dict = {"target": self._text_range, "text": "", "wholeRun": True}
+                # Which of the runs at its place this one is, where more than one holds a break.
+                later = self._later_runs()
+                if later is not None:
+                    clear["run"] = {"laterRuns": later}
+                run_sync(self._session.doc.replace(clear))
+                self._forget_break()
             # An empty run has nothing to replace: the text is appended to
             # it, with the formatting rule of ``add_text``.
             if value and tracking(self._session) and any(ch in "\t\r\n" for ch in value):
@@ -814,6 +886,9 @@ class Run:
         # write replaces the run's ``w:footnoteReference`` too (``""`` included),
         # and the export then leaves out the note nothing references.
         getattr(self, "_inline_snapshot", {}).pop("noteReference", None)
+        # The run's page and column breaks went with its text.
+        if self._holds_break() and not tracked and self._replaces_breaks():
+            self._forget_break()
         if tracked:
             self._note_tracked_replacement(old_range, value)
         else:
@@ -929,6 +1004,41 @@ class Run:
         # any pending inline formatting now that there's text to mark.
         self._flush_pending_inline()
 
+    def _holds_break(self) -> bool:
+        """Whether this run holds a page or column break (``break``, as
+        docx-studio's read of it or :meth:`add_break` noted it)."""
+        snapshot: object = getattr(self, "_inline_snapshot", None)
+        return isinstance(snapshot, dict) and snapshot.get("break") in ("page", "column")
+
+    def _replaces_breaks(self) -> bool:
+        """Whether a ``wholeRun`` Replace of this run replaces its page and
+        column breaks too, as python-docx's ``run.text = …`` and
+        ``run.clear()`` do: on a docx-studio that reports
+        ``capabilities.wholeRunBreaks``, without tracked changes (a tracked
+        replacement keeps the breaks). An older one keeps a break at the run's
+        edge, and the proxy keeps it too."""
+        return not tracking(self._session) and server_takes(self._session, "wholeRunBreaks")
+
+    def _forget_break(self) -> None:
+        """The run holds no page or column break now: its ``break`` goes, and
+        whether the paragraph held it (``breakApart``) with it."""
+        self._inline_snapshot.pop("break", None)
+        self._inline_snapshot.pop("breakApart", None)
+
+    def _note_break(self, kind: str, *, held: bool) -> None:
+        """Record that this run holds a page or column break (``kind``), as
+        docx-studio's read of it says (``break``), so that
+        :meth:`iter_inner_content` yields python-docx's ``""`` for it while it
+        has no text. A break the paragraph holds (``held``: one ``add_break``
+        put in the run, inline) is one a format of the run reaches, with the
+        break apart from the paragraph it may hold too, as docx-studio then
+        reads the run: no longer ``breakApart``."""
+        snapshot: object = getattr(self, "_inline_snapshot", None)
+        if isinstance(snapshot, dict):
+            snapshot.setdefault("break", kind)
+            if held:
+                snapshot.pop("breakApart", None)
+
     def add_break(self, break_type: "WD_BREAK" = WD_BREAK.LINE) -> None:
         """Insert a break at the end of the run.
 
@@ -949,11 +1059,13 @@ class Run:
           matching ``breakType``
         - ``LINE`` → ``doc.insertLineBreak`` (a real Word line-break node)
         - ``COLUMN`` → ``doc.insertLineBreak`` with ``breakType: "column"``:
-          a ``<w:br w:type="column"/>`` that docx-studio writes after the
-          paragraph's content (where python-docx ends this run with it), so
-          it takes no room in the paragraph's text-address space and reads
-          as ``""``, as python-docx reads it. A docx-studio before column
-          breaks inserts a line break instead.
+          the ``<w:br w:type="column"/>`` at the end of the run, in it, as
+          python-docx writes it, when the server reports
+          ``capabilities.inlineColumnBreak`` in ``Info``. It takes no room in
+          the paragraph's text-address space, and a run holding nothing else
+          yields ``""``, as python-docx's does. An older server writes it
+          after the paragraph's content, as a run of its own; one before
+          column breaks inserts a line break instead.
         - ``LINE_CLEAR_LEFT`` / ``LINE_CLEAR_RIGHT`` / ``LINE_CLEAR_ALL``
           (``TEXT_WRAPPING`` is python-docx's alias of ``LINE_CLEAR_ALL``) —
           DOCX Studio has no dedicated wire op for these, so they degrade to
@@ -1002,6 +1114,9 @@ class Run:
             if self._continues_own_formatting():
                 page_break["inheritMarks"] = True
             run_sync(self._session.doc.insert_line_break(page_break))
+            self._note_break("page", held=True)
+            # Formatting set on the empty run before its break: the break's run takes it.
+            self._flush_pending_inline()
             return
 
         if bt is WD_BREAK.PAGE:
@@ -1040,9 +1155,17 @@ class Run:
             return
 
         if bt is WD_BREAK.COLUMN:
-            column_break = self._add_run_ref({"blockId": self._block_id, "offset": end})
-            column_break["breakType"] = "column"
-            run_sync(self._session.doc.insert_line_break(column_break))
+            column_break: dict = {"blockId": self._block_id, "offset": end, "breakType": "column"}
+            if server_takes(self._session, "inlineColumnBreak"):
+                # At the end of this run, in it, as python-docx writes it.
+                column_break["inline"] = True
+                self._mark_append(column_break)
+                if self._continues_own_formatting():
+                    column_break["inheritMarks"] = True
+            run_sync(self._session.doc.insert_line_break(self._add_run_ref(column_break)))
+            self._note_break("column", held=column_break.get("inline") is True)
+            # Formatting set on the empty run before its break: the break's run takes it.
+            self._flush_pending_inline()
             return
 
         if bt in degraded_to_line:
@@ -1603,6 +1726,23 @@ class Run:
             )
             return
         self._note_inline_applied(kwargs)
+        identity = self._break_run_identity()
+        if identity is not None:
+            # The run holds only a page or column break: python-docx formats its
+            # ``w:r``, and docx-studio its break, which it tells by the run's identity.
+            run_sync(
+                self._session.doc.format.apply(
+                    {
+                        "target": self._text_range,
+                        "inline": kwargs,
+                        "wholeRun": True,
+                        "run": {"laterRuns": identity},
+                    },
+                ),
+            )
+            # Its break holds the formatting now, which what it takes next continues.
+            self._fresh = False
+            return
         if self._is_collapsed_range:
             pending = getattr(self, "_pending_inline", None)
             if pending is None:

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "athena-python-docx"
-version = "0.31.0"
+version = "0.32.0"
 description = "Drop-in replacement for python-docx that connects to Athena's DOCX Studio collaborative document stack"
 readme = "README.md"
 license = "MIT"

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/tests/fidelity/complex_cases.py

@@ -299,7 +299,7 @@ CASES: list[ComplexCase] = [
             "from docx.enum.table import WD_TABLE_ALIGNMENT, WD_TABLE_DIRECTION\n"
             "t = doc.add_table(rows=2, cols=2)\n"
             "t.alignment = WD_TABLE_ALIGNMENT.CENTER\n"
-            "t.direction = WD_TABLE_DIRECTION.LTR\n"
+            "t.table_direction = WD_TABLE_DIRECTION.LTR\n"
             "t.autofit = True"
         ),
         expected_ops=("tables.setTableOptions", "tables.setLayout"),

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/tests/fidelity/fake_session.py

@@ -248,6 +248,8 @@ class FakeDocState:
                     info["latentStyles"] = self.latent_styles
                 if (params or {}).get("includeCoreProperties") and self.core_properties is not None:
                     info["coreProperties"] = dict(self.core_properties)
+                # `tables.setLayout` below writes `tableDirection`, as a docx-studio reporting it does.
+                info["capabilities"] = {"tableDirection": True}
                 return info
             return {"ok": True}
 

{athena_python_docx-0.31.0 → athena_python_docx-0.32.0}/tests/fidelity/op_snapshots/21_table_alignment_and_autofit.json

@@ -2,6 +2,7 @@
   "create.table",
   "tables.get",
   "tables.setLayout",
+  "info",
   "tables.get",
   "tables.setLayout",
   "tables.get",