athena-python-docx 0.21.2__tar.gz → 0.21.5__tar.gz

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: athena-python-docx
-Version: 0.21.2
+Version: 0.21.5
 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.21.2 → athena_python_docx-0.21.5}/docx/__init__.py

@@ -6,10 +6,10 @@ See CLAUDE.md for the API parity contract.
 
 from __future__ import annotations
 
-__version__ = "0.21.2"
+__version__ = "0.21.5"
 
 from docx.api import Document
-from docx._buffer import flush_all
+from docx._buffer import discard_all, flush_all
 
 # Re-exports python-docx ships at docx top-level for convenience.
 from docx.shared import Emu, Inches, Pt, Cm, Mm, Twips, Length, RGBColor
@@ -25,6 +25,7 @@ __all__ = [
     "Length",
     "RGBColor",
     "flush_all",
+    "discard_all",
     "__version__",
 ]
 

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/docx/_buffer.py

@@ -124,10 +124,12 @@ if TYPE_CHECKING:
 # HTTP POST to agora (see ``_ptc._send``), so emitting one card per low-level
 # mutation produces hundreds of sub-cards per script and pays full network
 # RTT on every one. The allow-list keeps the per-action signal — one card
-# per logical block creation (paragraph, heading, table) — without the spam
-# or the cumulative latency. Asset-level creation events (``CreateDocument``)
-# are emitted from ``Document.create`` directly, not through this buffer path.
-_PTC_EMIT_TOOLS: frozenset[str] = frozenset({"CreateParagraph", "CreateHeading", "CreateTable"})
+# per logical block/citation creation — without the spam or the cumulative
+# latency. Asset-level creation events (``CreateDocument``) are emitted from
+# ``Document.create`` directly, not through this buffer path.
+_PTC_EMIT_TOOLS: frozenset[str] = frozenset(
+    {"CreateParagraph", "CreateHeading", "CreateTable", "AddCitation"}
+)
 
 
 def _should_emit_ptc(cmd: Command) -> bool:
@@ -243,6 +245,42 @@ def flush_all(*, strict: bool = False) -> None:
         raise FlushAllError(failures=failures)
 
 
+def discard_all() -> int:
+    """Drop the pending commands of every live CommandBuffer; return the count.
+
+    The failed-script counterpart of :func:`flush_all`: after user code
+    raises, the executor discards the half-buffered tail instead of posting
+    it (see :meth:`CommandBuffer.discard_pending`). Safe to call when no
+    buffers exist (returns 0).
+
+    Buffers from a previous ``execute_word_document_code`` call are skipped
+    (mirroring :func:`flush_all`'s stale handling) so cross-execution
+    leftovers stay visible to diagnostics instead of being silently
+    swallowed. Best-effort like :meth:`CommandBuffer.discard_pending`: a
+    batch already handed to an in-flight flush cannot be recalled.
+    """
+    with _registry_lock:
+        snapshot = list(_active_buffers)
+        live = [ref for ref in snapshot if ref() is not None]
+        _active_buffers[:] = live
+
+    dropped = 0
+    for ref in live:
+        buf = ref()
+        if buf is None:
+            continue
+        if buf.is_stale_for_current_execution:
+            pending_count = buf.pending_count
+            if pending_count > 0:
+                sys.stderr.write(
+                    f"[docx-sdk] discard_all: skipping stale buffer "
+                    f"{buf.asset_id} with {pending_count} unflushed command(s)\n",
+                )
+            continue
+        dropped += buf.discard_pending()
+    return dropped
+
+
 # ---------------------------------------------------------------------------
 # CommandBuffer
 # ---------------------------------------------------------------------------
@@ -314,6 +352,12 @@ class CommandBuffer:
         # original semantics.
         self._change_mode: str | None = None
         self._user: dict[str, str] | None = None
+        # A batch the background idle timer failed to deliver. The timer
+        # thread can't raise into user code, so the failure is stashed here
+        # and re-raised on the NEXT buffer interaction (call/flush) — a
+        # dropped batch must never be reported as success by a later
+        # ``doc.save()`` that finds an empty buffer.
+        self._deferred_flush_error: Exception | None = None
         # client_node_id → list of (proxy, attr) pairs to update with the
         # real nodeId after flush. Populated by ``add_paragraph`` /
         # ``add_heading`` / etc. when they queue a Create with a
@@ -420,6 +464,7 @@ class CommandBuffer:
         proxy's ``_node_id`` in-place.
         """
         self._assert_current_execution()
+        self._raise_deferred_flush_error()
         if self._closed:
             raise RuntimeError(
                 f"CommandBuffer for {self._asset_id} is closed",
@@ -488,6 +533,7 @@ class CommandBuffer:
         UUID swap.
         """
         self._assert_current_execution()
+        self._raise_deferred_flush_error()
         with self._lock:
             self._cancel_timer_locked()
             pending = self._pending
@@ -633,12 +679,54 @@ class CommandBuffer:
             self._timer.cancel()
             self._timer = None
 
+    def _raise_deferred_flush_error(self) -> None:
+        """Re-raise a failure captured by the background idle timer.
+
+        Cleared on raise so the surfaced traceback is delivered exactly once;
+        the batch it describes is already gone either way.
+        """
+        with self._lock:
+            err = self._deferred_flush_error
+            self._deferred_flush_error = None
+        if err is not None:
+            raise err
+
+    def discard_pending(self) -> int:
+        """Drop buffered commands without sending them; return the count.
+
+        Used by the sandbox executor when user code raised: posting the dead
+        script's half-buffered tail writes content whose prerequisites failed
+        (and duplicates it when the agent retries the whole script).
+
+        Best-effort: only commands still sitting in the pending queue are
+        dropped. A batch the idle timer has already drained and handed to the
+        HTTP client is in flight and cannot be recalled (the module
+        docstring's timer-race note applies here too).
+        """
+        with self._lock:
+            self._cancel_timer_locked()
+            pending = self._pending
+            self._pending = []
+            self._proxy_id_refs = {}
+            self._deferred_flush_error = None
+        _ptc_emit_end_batch(pending, is_error=True)
+        return len(pending)
+
     def _auto_flush(self) -> None:
         if self.is_stale_for_current_execution:
             return
         try:
             self.flush()
         except Exception as e:  # noqa: BLE001
+            # The timer thread has no caller to raise into. Record the
+            # failure so the next call()/flush() (e.g. ``doc.save()``)
+            # surfaces it instead of reporting a drained buffer as success.
+            e.add_note(
+                "raised by a background docx-sdk auto-flush that failed earlier; "
+                "the commands in that batch were NOT applied",
+            )
+            with self._lock:
+                self._deferred_flush_error = e
             sys.stderr.write(
                 f"[docx-sdk] auto-flush failed for {self._asset_id}: {e}\n",
             )
@@ -650,4 +738,4 @@ class CommandBuffer:
         )
 
 
-__all__ = ["CommandBuffer", "flush_all", "DEFAULT_AUTO_FLUSH_SECONDS"]
+__all__ = ["CommandBuffer", "flush_all", "discard_all", "DEFAULT_AUTO_FLUSH_SECONDS"]

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/docx/client.py

@@ -223,9 +223,14 @@ class Session:
 
         handle = self._doc_handle
         buffer = getattr(handle, "buffer", None) if handle is not None else None
-        if buffer is not None:
-            buffer.flush()
-        _log_info(f"Saved {self._asset_id} (buffer drained)")
+        if buffer is None:
+            _log_info(f"Saved {self._asset_id} (no command buffer)")
+            return
+        flushed = buffer.flush()
+        # flush() raises on delivery failure — including one captured earlier
+        # by the background auto-flush — so this success line is only reached
+        # when nothing the buffer ever held was silently dropped.
+        _log_info(f"Saved {self._asset_id} ({len(flushed)} buffered command(s) flushed)")
 
     async def close(self) -> None:
         """Close the session. Idempotent."""

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/docx/table.py

@@ -458,6 +458,13 @@ class Table:
         # Cells written before 0.15 (the pre-tracking world) silently fall
         # back to the legacy append behavior on their first 0.15+ rewrite.
         self._written_cells: set[tuple[int, int]] = set()
+        # Cell → plain text the SDK itself wrote this session via ``.text``.
+        # Powers the read-free ``_Cell.paragraphs``/``runs`` fast path: while
+        # a cell's full content is SDK-known (single plain-text run), header/
+        # zebra formatting loops need zero query round-trips. Any write the
+        # SDK can't model (markdown text, ``add_paragraph``, cell-inner
+        # ``add_run``) evicts the entry and restores the query path.
+        self._fastpath_cell_text: dict[tuple[int, int], str] = {}
 
     def _fresh_node_info(self) -> tuple[str, dict]:
         """Resolve the live nodeId and return ``(node_id, info_dict)``.
@@ -1541,11 +1548,13 @@ class _Cell:
 
         Reads the proxy's stored ``_node_id`` with NO round-trip. DOCX Studio
         tables carry real (non-``t:N``) node ids → returns ``None`` so the
-        caller queries (DOCX Studio is pooled, so that read is cheap anyway). A
-        freshly-created docx-editor table still holds a client UUID until its
-        create flushes, so the first cell op falls back to the query (which
-        flushes + rotates ``_node_id`` to ``t:N``) and every subsequent cell
-        op fast-paths.
+        caller queries (DOCX Studio is pooled, so that read is cheap anyway).
+        A freshly-created docx-editor table still holds a client UUID until its
+        create flushes. For docx-editor, :meth:`Document.add_table` already
+        knows the table's eventual document-order index, so SDK-created body
+        tables can fast-path before a fragile first ``tables.get_cells`` query.
+        We first try to flush the pending create so DOCX Studio's non-positional
+        table ids can still fall back to the query path after the id rewrite.
 
         Gated to a **known uniform grid**: the table must have been created
         via :meth:`Document.add_table` (so ``_doc_index`` is set and the full
@@ -1557,11 +1566,27 @@ class _Cell:
         fall back to the query path to stay address-correct.
         """
         table = self._table
-        if getattr(table, "_doc_index", None) is None or getattr(table, "_has_merges", False):
+        doc_index = getattr(table, "_doc_index", None)
+        if doc_index is None or getattr(table, "_has_merges", False):
             return None
         nid = getattr(table, "_node_id", None)
         if isinstance(nid, str) and nid.startswith("t:") and nid[2:].isdigit():
             return f"tc:{nid[2:]}:{self._row}:{self._col}"
+        if (
+            isinstance(nid, str)
+            and nid.startswith("t_")
+            and getattr(table, "_header_footer_ref_id", None) is None
+        ):
+            handle = getattr(table._session, "_doc_handle", None)
+            buf = getattr(handle, "buffer", None) if handle is not None else None
+            if buf is not None:
+                buf.flush()
+                nid = getattr(table, "_node_id", None)
+                if isinstance(nid, str) and nid.startswith("t:") and nid[2:].isdigit():
+                    return f"tc:{nid[2:]}:{self._row}:{self._col}"
+                if not (isinstance(nid, str) and nid.startswith("t_")):
+                    return None
+            return f"tc:{doc_index}:{self._row}:{self._col}"
         return None
 
     def _cell_id(self) -> str:
@@ -1882,6 +1907,10 @@ class _Cell:
             # to the same position takes the clear-then-insert branch above
             # (see ``Table._written_cells`` docstring).
             self._table._written_cells.add(cell_key)
+            if _is_plain_text(value) and value:
+                self._table._fastpath_cell_text[cell_key] = value
+            else:
+                self._table._fastpath_cell_text.pop(cell_key, None)
             return
         except Exception as e:
             raise RuntimeError(
@@ -1902,6 +1931,38 @@ class _Cell:
         # debugger and gives ``_apply_inline`` and friends something
         # stable to consult when we eventually add a materialization
         # fallback at the SDK layer.
+        fast_text = self._table._fastpath_cell_text.get((self._row, self._col))
+        if fast_text is not None:
+            positional = self._positional_cell_id()
+            if positional is not None:
+                # Read-free fast path: the SDK wrote this cell's entire
+                # content itself (one plain-text run), so it can hand back a
+                # positional paragraph proxy without the per-cell
+                # ``getNodeById`` walk. Formatting on its runs buffers a
+                # whole-cell ``FormatApply`` against the ``tc:`` id — the
+                # applier's documented cell-formatting semantics — so header/
+                # zebra loops batch instead of paying one Y.Doc reload per
+                # cell.
+                ooxml_base = self._ooxml_address_base()
+                fast_p = Paragraph(
+                    session=self._table._session,
+                    node_id=positional,
+                    node_type="paragraph",
+                    in_cell=True,
+                    cell_ooxml_address=(
+                        (*ooxml_base, 0) if ooxml_base is not None else None
+                    ),
+                    cell=self,
+                )
+                fast_p._cell_inner = True  # type: ignore[attr-defined]
+                fast_p._cell_address = {  # type: ignore[attr-defined]
+                    "kind": "block",
+                    "nodeType": "tableCell",
+                    "nodeId": positional,
+                }
+                fast_p._fastpath_runs_text = fast_text  # type: ignore[attr-defined]
+                return [fast_p]
+
         pids = self._inner_paragraph_ids()
         # Resolve the cell address ONCE and re-use it for every
         # paragraph; the original draft called ``self._cell_address()``
@@ -1970,6 +2031,9 @@ class _Cell:
     ) -> "Paragraph":
         """Append a paragraph to the cell.
 
+        Evicts the cell from the read-free ``paragraphs`` fast path — the
+        cell no longer holds the single SDK-written run that path models.
+
         Mirrors python-docx ``_Cell.add_paragraph(text, style)``. The
         ``style`` argument accepts either a style id string or a
         :class:`docx.styles.style.ParagraphStyle` instance; previously
@@ -2007,6 +2071,10 @@ class _Cell:
                 f"{type(style).__name__} {style!r}",
             )
 
+        # Evict AFTER validation so a rejected call leaves the read-free
+        # fast path intact (nothing mutated).
+        self._table._fastpath_cell_text.pop((self._row, self._col), None)
+
         fragment: dict = {
             "kind": "paragraph",
             "paragraph": {

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/docx/text/paragraph.py

@@ -448,6 +448,27 @@ class Paragraph:
         """
         from docx.text.run import Run
 
+        fast_text: object = getattr(self, "_fastpath_runs_text", None)
+        if isinstance(fast_text, str) and fast_text:
+            # Read-free fast path for a cell paragraph whose entire content
+            # the SDK wrote itself (see ``Table._fastpath_cell_text``): one
+            # synthetic run over the known text, no ``getNodeById`` walk.
+            # Format setters on it buffer a whole-cell ``FormatApply``
+            # against the positional ``tc:`` id; property READS may still
+            # trigger a live walk (the applier resolves ``tc:`` ids), so
+            # only the hot format-loop path is short-circuited.
+            self._text_len = len(fast_text)
+            fast_run = Run(
+                session=self._session,
+                block_id=self._node_id,
+                range_=(0, len(fast_text)),
+                inline={"type": "text", "text": fast_text},
+                in_cell=self._in_cell,
+                cell_ooxml_address=self._cell_ooxml_address,
+            )
+            fast_run._fastpath_text = fast_text  # type: ignore[attr-defined]
+            return [fast_run]
+
         info: object = self._node_info()
         inlines: list[dict] = _walk_inlines(info)
         runs: list["Run"] = []
@@ -1131,6 +1152,19 @@ class Paragraph:
                 f"or None; got {type(style).__name__} {style!r}",
             )
 
+        # Content beyond the single SDK-written run: evict this paragraph's
+        # cell from the read-free fast path so the next ``paragraphs``/
+        # ``runs`` read reflects real server state. After validation so a
+        # rejected call leaves the fast path intact (nothing mutated).
+        self._fastpath_runs_text = None  # type: ignore[attr-defined]
+        cell = self._cell
+        table = getattr(cell, "_table", None) if cell is not None else None
+        if table is not None:
+            row = getattr(cell, "_row", None)
+            col = getattr(cell, "_col", None)
+            if row is not None and col is not None:
+                getattr(table, "_fastpath_cell_text", {}).pop((row, col), None)
+
         # Use the cached paragraph text length when known — every
         # avoided ``_node_text`` here drops one ``get_node_by_id`` HTTP
         # round-trip. Linear ``doc.add_paragraph(); p.add_run(...);

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/docx/text/run.py

@@ -336,6 +336,12 @@ class Run:
     # ---- text ----
     @property
     def text(self) -> str:
+        # Fast-path runs (see ``Table._fastpath_cell_text``) carry their
+        # known text — the whole point is zero read round-trips. Mutations
+        # through this proxy keep the attr in sync or clear it.
+        fast: object = getattr(self, "_fastpath_text", None)
+        if isinstance(fast, str):
+            return fast
         full: str = _block_text(self._session, self._block_id)
         return full[self._range[0] : self._range[1]]
 
@@ -399,7 +405,10 @@ class Run:
                 f"{value!r}",
             )
         if self._check_cell_inner("text"):
+            # Warn-and-skip: nothing mutated, so the fast-path text cache
+            # (when present) still reflects reality — keep it.
             return
+        self._fastpath_text = None  # type: ignore[attr-defined]
         old_len: int = self._range[1] - self._range[0]
         run_sync(
             self._session.doc.replace(
@@ -435,6 +444,7 @@ class Run:
                 in_cell=True,
                 cell_ooxml_address=getattr(self, "_cell_ooxml_address", None),
             )
+        self._fastpath_text = None  # type: ignore[attr-defined]
         end: int = self._range[1]
         cursor: dict = {"kind": "text", "blockId": self._block_id, "offset": end}
         run_sync(

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "athena-python-docx"
-version = "0.21.2"
+version = "0.21.5"
 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.21.2 → athena_python_docx-0.21.5}/tests/fidelity/fake_session.py

@@ -162,6 +162,31 @@ class FakeDocState:
                 return t
         return None
 
+    def _resolve_cell_ref(self, node_id: object) -> tuple[_Table, int, int, _Block] | None:
+        if not isinstance(node_id, str) or not node_id:
+            return None
+
+        parts = node_id.split(":")
+        if len(parts) == 4 and parts[0] == "tc":
+            try:
+                table_idx = int(parts[1])
+                row_idx = int(parts[2])
+                col_idx = int(parts[3])
+            except ValueError:
+                return None
+            if 0 <= table_idx < len(self.tables):
+                table = self.tables[table_idx]
+                if 0 <= row_idx < len(table.cells) and 0 <= col_idx < len(table.cells[row_idx]):
+                    return (table, row_idx, col_idx, table.cells[row_idx][col_idx])
+            return None
+
+        for table in self.tables:
+            for row_idx, row in enumerate(table.cells):
+                for col_idx, cell in enumerate(row):
+                    if node_id in {cell.node_id, f"cell_{table.node_id}_{row_idx}_{col_idx}"}:
+                        return (table, row_idx, col_idx, cell)
+        return None
+
     def respond(self, op: str, params: dict) -> Any:
         # ---- header/footer part orchestration ----
         # _HeaderFooter.add_paragraph / add_table mint a new part on
@@ -273,33 +298,29 @@ class FakeDocState:
                     "node": node,
                     "address": {"kind": "block", "nodeType": b.node_type, "nodeId": b.node_id},
                 }
-            # Table cell
-            for t in self.tables:
-                for r_idx, row in enumerate(t.cells):
-                    for c_idx, cell in enumerate(row):
-                        if cell.node_id == nid or (
-                            params.get("nodeType") == "tableCell"
-                            and nid == f"cell_{t.node_id}_{r_idx}_{c_idx}"
-                        ):
-                            # Return a tree containing the inner paragraph
-                            inner = {
-                                "type": "paragraph",
-                                "attrs": {"nodeId": cell.node_id},
-                                "content": [{"type": "text", "text": cell.text}]
-                                if cell.text
-                                else [],
-                            }
-                            return {
-                                "node": {
-                                    "nodeType": "tableCell",
-                                    "tableCell": {"content": [inner]},
-                                },
-                                "address": {
-                                    "kind": "block",
-                                    "nodeType": "tableCell",
-                                    "nodeId": cell.node_id,
-                                },
-                            }
+            # Table cell. The real docx-editor surface addresses cells by
+            # positional ids (tc:<tableIndex>:<row>:<col>), while DOCX Studio
+            # also exposes table-specific ids from tables.getCells. Support
+            # both so the fake exercises the same no-query fast path as agents.
+            cell_ref = self._resolve_cell_ref(nid)
+            if cell_ref is not None:
+                _table, _row_idx, _col_idx, cell = cell_ref
+                inner = {
+                    "type": "paragraph",
+                    "attrs": {"nodeId": cell.node_id},
+                    "content": [{"type": "text", "text": cell.text}] if cell.text else [],
+                }
+                return {
+                    "node": {
+                        "nodeType": "tableCell",
+                        "tableCell": {"content": [inner]},
+                    },
+                    "address": {
+                        "kind": "block",
+                        "nodeType": "tableCell",
+                        "nodeId": cell.node_id,
+                    },
+                }
             return {"node": {}, "address": {}}
 
         if op == "blocks.list":
@@ -515,16 +536,11 @@ class FakeDocState:
                                         if isinstance(t, str):
                                             appended += t
                 # Find cell and append to its first paragraph.
-                for t in self.tables:
-                    for r_idx, row in enumerate(t.cells):
-                        for c_idx, cell in enumerate(row):
-                            expected_ids = {
-                                f"cell_{t.node_id}_{r_idx}_{c_idx}",
-                                cell.node_id,
-                            }
-                            if cell_nid in expected_ids:
-                                cell.text = cell.text + appended
-                                cell.inlines = [{"run": {"text": cell.text}}] if cell.text else []
+                cell_ref = self._resolve_cell_ref(cell_nid)
+                if cell_ref is not None:
+                    _table, _row_idx, _col_idx, cell = cell_ref
+                    cell.text = cell.text + appended
+                    cell.inlines = [{"run": {"text": cell.text}}] if cell.text else []
             return {"ok": True}
 
         # TableSetCell: address a cell by (tableNodeId, row, col) and
@@ -979,15 +995,13 @@ class FakeDocState:
         if op == "tables.setCellProperties":
             target = params.get("target") or {}
             nid = target.get("nodeId") or params.get("nodeId")
-            # Find the cell
-            for t in self.tables:
-                for r_idx, row in enumerate(t.cells):
-                    for c_idx, _cell in enumerate(row):
-                        if nid == f"cell_{t.node_id}_{r_idx}_{c_idx}":
-                            if "verticalAlign" in params:
-                                t.cell_verticals[r_idx][c_idx] = params["verticalAlign"]
-                            if "preferredWidthPt" in params:
-                                t.cell_widths[r_idx][c_idx] = params["preferredWidthPt"]
+            cell_ref = self._resolve_cell_ref(nid)
+            if cell_ref is not None:
+                t, r_idx, c_idx, _cell = cell_ref
+                if "verticalAlign" in params:
+                    t.cell_verticals[r_idx][c_idx] = params["verticalAlign"]
+                if "preferredWidthPt" in params:
+                    t.cell_widths[r_idx][c_idx] = params["preferredWidthPt"]
             return {"ok": True}
         if op == "tables.setTableOptions":
             # Per DOCX Studio 1.8.1 setTableOptions only handles

athena_python_docx-0.21.5/tests/fidelity/op_snapshots/20_table_cell_vertical_alignment.json

@@ -0,0 +1,6 @@
+[
+  "create.table",
+  "tables.setCellProperties",
+  "tables.setCellProperties",
+  "tables.setCellProperties"
+]

athena_python_docx-0.21.5/tests/fidelity/op_snapshots/22_table_cell_paragraphs_iteration.json

@@ -0,0 +1,9 @@
+[
+  "create.table",
+  "tables.setCell",
+  "insert",
+  "getNodeById",
+  "getNodeById",
+  "getNodeById",
+  "getNodeById"
+]

athena_python_docx-0.21.5/tests/fidelity/op_snapshots/35_full_report.json

@@ -0,0 +1,39 @@
+[
+  "sections.list",
+  "sections.setPageMargins",
+  "sections.setPageMargins",
+  "create.paragraph",
+  "styles.paragraph.setStyle",
+  "format.paragraph.setAlignment",
+  "create.paragraph",
+  "insert",
+  "format.apply",
+  "insert",
+  "insert",
+  "format.apply",
+  "format.apply",
+  "insert",
+  "format.paragraph.setSpacing",
+  "create.heading",
+  "create.table",
+  "tables.setStyle",
+  "tables.get",
+  "tables.setLayout",
+  "tables.get",
+  "tables.get",
+  "tables.setCell",
+  "tables.setCell",
+  "tables.setCell",
+  "tables.setCellProperties",
+  "format.apply",
+  "tables.setCellProperties",
+  "format.apply",
+  "tables.setCellProperties",
+  "format.apply",
+  "tables.setCell",
+  "tables.setCell",
+  "tables.setCell",
+  "tables.setCell",
+  "tables.setCell",
+  "tables.setCell"
+]

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/tests/fidelity/op_snapshots/45_cell_text_round_trip.json

@@ -1,8 +1,6 @@
 [
   "create.table",
   "tables.setCell",
-  "tables.get",
-  "tables.getCells",
   "getNodeById",
   "getNodeById"
 ]

{athena_python_docx-0.21.2 → athena_python_docx-0.21.5}/tests/fidelity/op_snapshots/56_everything_in_one.json

@@ -29,16 +29,10 @@
   "tables.get",
   "tables.setLayout",
   "tables.setCell",
-  "tables.get",
-  "tables.getCells",
   "tables.setCellProperties",
   "tables.setCell",
-  "tables.get",
-  "tables.getCells",
   "tables.setCellProperties",
   "tables.setCell",
-  "tables.get",
-  "tables.getCells",
   "tables.setCellProperties",
   "tables.setCell",
   "tables.setCell",

athena_python_docx-0.21.5/tests/fidelity/op_snapshots/61_cell_paragraph_with_runs.json

@@ -0,0 +1,8 @@
+[
+  "create.table",
+  "tables.setCell",
+  "getNodeById",
+  "insert",
+  "getNodeById",
+  "getNodeById"
+]