athena-python-docx 0.7.0__tar.gz → 0.8.0__tar.gz

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/CLAUDE.md

@@ -39,6 +39,18 @@ These standard python-docx members don't apply to a Superdoc-backed SDK:
   `Comment.tables` — SuperDoc models a comment as a single text body,
   not a `BlockItemContainer`. Use `Comment.text` instead. The
   paragraph/table-bearing surface raises `CommentsNotImplementedError`.
+- **`docx.oxml.*`** — the entire raw-OOXML module tree (``ns.qn``,
+  ``OxmlElement``, ``CT_*`` classes, etc.) is unavailable because the
+  SDK is HTTP-only against a SuperDoc Y.Doc; there is no local lxml
+  tree to manipulate. As of 0.8.0, ``docx.oxml`` is a real stub
+  package that raises a typed
+  :class:`docx.oxml.OxmlNotAvailableError` (subclass of
+  ``ImportError``) on any attribute access, with an inline pointer at
+  the high-level API (``Document.add_paragraph``, ``Run.bold``,
+  ``_Cell.text``, …) or the typed command surface in
+  ``docx.commands``. Pre-0.8.0 this used to fail with the stdlib's
+  generic ``ModuleNotFoundError: No module named 'docx.oxml'`` and
+  agents had to retry to discover the gap.
 
 ### Phase-3b upstream-blocked surface
 
@@ -149,13 +161,26 @@ This is a **thin HTTP client** that mimics the sync python-docx API.
   the context-manager exit drain explicitly; `docx.flush_all()` is
   the Daytona-prelude hook that flushes every live buffer in the
   process.
-- Other response-bearing ops without a client id (`Insert`,
-  `ListsCreate`, `ListsAttach`, `CommentsCreate`, `CommentsPatch`,
+- **Insert deferral (0.8.0+):** `Insert` was removed from the
+  response-bearing set because every in-tree caller
+  (`Paragraph._insert_run_text_segments`, `Run.add_text`, `_Cell.text`)
+  ignores the response — the Run proxy wraps a known client-side range
+  and doesn't need the server's echoed node id. Net result: a styled
+  run (one `add_run` + 6 format setters) ships as 1 HTTP request
+  instead of 2. The remaining response-bearing ops without a client id
+  (`ListsCreate`, `ListsAttach`, `CommentsCreate`, `CommentsPatch`,
   `TrackChangesDecide`) keep their eager-flush semantics so callers
   reading back ids still see real data. A `Document.add_paragraph`
   with `style="List Bullet"` flushes the queued CreateParagraph in
   the same batch as the follow-up `ListsCreate` — still one HTTP
   request per logical operation.
+- **Plain-text cell fast path (0.8.0+):** `_Cell.text = value` skips
+  the eager `doc.markdownToFragment` query when ``value`` contains no
+  markdown control characters (the dominant case for tabular data —
+  numbers, labels, currency strings). The fragment is built locally
+  and the follow-up `doc.insert` is buffered, so plain cell
+  assignments are 0 HTTP requests until the next flush. See
+  ``docx.table._is_plain_text`` for the trigger predicate.
 - The path-proxy in `_http_doc.py` is an internal translation layer:
   call sites that look like `await self._session.doc.create.paragraph(p)`
   resolve to `CommandBuffer.call(CreateParagraph(**p))`. Rewriting call

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/PKG-INFO

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

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

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/docx/_http_doc.py

@@ -112,6 +112,7 @@ from docx.commands import (
 )
 from docx.errors import (
     AuthenticationError,
+    BlockNotFoundError,
     DocxError,
     NotFoundError,
     SessionError,
@@ -134,6 +135,39 @@ _NOT_FOUND_ERROR_NAMES: frozenset[str] = frozenset(
 )
 
 
+def _looks_like_block_not_found(err_obj: dict) -> bool:
+    """Detect SuperDoc's ``Block "<type>:<id>" was not found`` shape.
+
+    Triggers the typed :class:`BlockNotFoundError` so agent code can
+    distinguish a missing-block miss (cell-inner-paragraph addressing
+    bug, stale id from a different session) from a generic transport
+    or validation error.
+    """
+    msg = err_obj.get("message")
+    if not isinstance(msg, str):
+        return False
+    lower = msg.lower()
+    if "not found" not in lower:
+        return False
+    # Be conservative: require either ``block "`` (the SuperDoc CLI's
+    # quoted-id format) or ``block <id>`` followed by ``not found``.
+    return 'block "' in lower or ('block ' in lower and ' was not found' in lower)
+
+
+_CELL_PARAGRAPH_HINT: str = (
+    "\n\nHint: SuperDoc 1.8.1 cannot format paragraphs nested inside "
+    "table cells via SetParagraphAlignment / SetParagraphStyle / "
+    "SetParagraphIndentation / SetParagraphSpacing or doc.insert with "
+    "a paragraph-block target. The cell's inner paragraph id is "
+    "returned by cell.getNodeById but isn't a top-level addressable "
+    "block. Materialize the cell's paragraph first via "
+    '``cell.text = "value"``, then re-read ``cell.paragraphs[0]`` and '
+    "apply format ops to that post-materialization Paragraph proxy. "
+    "Tracked upstream at docx-studio/SUPERDOC_UPSTREAM_REQUESTS.md "
+    "§ 'cell-inner paragraph addressing'."
+)
+
+
 def _looks_like_not_found(parsed: dict) -> bool:
     """Inspect a docx-studio partial-failure dict and decide whether it
     describes a "no such entity" miss (vs. a real transport / validation
@@ -285,11 +319,30 @@ def _http_post_json(
         # sites (``Comments.get``) can coerce it to ``None`` without
         # swallowing real transport / validation failures.
         err_obj = parsed.get("error") if isinstance(parsed, dict) else None
-        if isinstance(err_obj, dict) and _looks_like_not_found(err_obj):
-            raise NotFoundError(
-                f"docx-studio batch reported a partial failure: {parsed!r}",
-                payload=err_obj,
-            )
+        if isinstance(err_obj, dict):
+            base_msg = f"docx-studio batch reported a partial failure: {parsed!r}"
+            # ``BlockNotFoundError`` is the narrower miss — caller is most
+            # likely targeting a cell-inner paragraph or stale-session
+            # block id. Surface the typed exception plus an agent-readable
+            # workaround so the next attempt doesn't repeat the same
+            # mistake. The cell-paragraph hint only applies when the
+            # missing id has the ``paragraph:`` prefix (SuperDoc's quoted-
+            # id error format) — stale list-item / table-row / image ids
+            # would benefit from a different hint or none at all, and a
+            # red-herring "use cell.text" pointer would just waste the
+            # next retry.
+            if _looks_like_block_not_found(err_obj):
+                msg_str = err_obj.get("message")
+                paragraph_block = (
+                    isinstance(msg_str, str)
+                    and "paragraph:" in msg_str.lower()
+                )
+                raise BlockNotFoundError(
+                    base_msg + (_CELL_PARAGRAPH_HINT if paragraph_block else ""),
+                    payload=err_obj,
+                )
+            if _looks_like_not_found(err_obj):
+                raise NotFoundError(base_msg, payload=err_obj)
         raise DocxError(
             f"docx-studio batch reported a partial failure: {parsed!r}",
         )

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/docx/commands.py

@@ -814,8 +814,15 @@ _RESPONSE_BEARING_TYPES: frozenset[str] = frozenset(
         # CreateImage returns {image: {nodeId}}; SetImageSize and the
         # InlineShape proxy both need that nodeId, so it must flush.
         "CreateImage",
-        # Insert sometimes returns an id; treat as response-bearing for safety.
-        "Insert",
+        # Insert is INTENTIONALLY not here as of 0.8.0. All in-tree
+        # callers (``Paragraph._insert_run_text_segments``, ``Run.add_text``,
+        # ``_Cell.text``) wrap a known client-side range/cell target and
+        # never read Insert's response; deferring it lets a styled
+        # ``add_run`` flow ship its text-insert in the same HTTP batch
+        # as the format setters that follow it. If a future caller needs
+        # the Insert response, route it through ``CommandBuffer._eager_flush_with``
+        # at the call site rather than re-adding Insert here, so the
+        # batched path isn't penalized for the one outlier.
         # CreateSectionBreak intentionally NOT here — it returns no node id;
         # the caller resolves the new section via sections.list afterwards.
         # CommentsCreate returns the new comment's entityId — caller wraps

athena_python_docx-0.8.0/docx/errors.py

@@ -0,0 +1,88 @@
+"""Exception types for athena-python-docx."""
+
+from __future__ import annotations
+
+
+class DocxError(Exception):
+    """Base class for all athena-python-docx errors."""
+
+
+class SessionError(DocxError):
+    """Raised when the Superdoc SDK session cannot be established or used."""
+
+
+class AuthenticationError(SessionError):
+    """Raised when Keryx rejects the collab token."""
+
+
+class UnsupportedProviderError(SessionError):
+    """Raised when the asset is on ysweet instead of yhub.
+
+    Phase 1 only supports yhub; ysweet-routed assets must be migrated first.
+    """
+
+
+class DocumentClosedError(DocxError):
+    """Raised when operating on a closed Document."""
+
+
+class ValidationError(DocxError):
+    """Raised when SDK-level validation fails (bad args, out-of-range indices)."""
+
+
+class NotFoundError(DocxError):
+    """Raised when a server-side lookup determines that the addressed
+    entity does not exist (comment id, node id, …).
+
+    Distinct from :class:`DocxError` so callers can speculatively read
+    (``Comments.get``, future ``find_by_id`` patterns) and coerce a
+    typed miss to ``None`` without swallowing real transport/auth
+    failures.
+    """
+
+    def __init__(self, message: str, payload: dict | None = None) -> None:
+        super().__init__(message)
+        self.payload: dict = payload or {}
+
+
+class BlockNotFoundError(NotFoundError):
+    """Raised when SuperDoc reports ``Block "<type>:<id>" was not found``.
+
+    Most commonly fires when paragraph-format operations target a
+    paragraph node nested inside a table cell. SuperDoc 1.8.1's
+    ``format.paragraph.setAlignment`` / ``setStyle`` / ``setIndentation``
+    / ``setSpacing`` and ``doc.insert``-into-block-target ops don't
+    traverse into table cells: the inner paragraph's id is returned by
+    ``cell.getNodeById`` but isn't a valid top-level addressable block.
+
+    The agent-facing workaround is:
+
+        cell.text = "value"     # materializes the cell's paragraph as
+                                # a real block once content lands.
+        p = cell.paragraphs[0]  # the *post-materialization* paragraph
+        p.alignment = ...       # now resolves.
+
+    See ``docx-studio/SUPERDOC_UPSTREAM_REQUESTS.md`` § "cell-inner
+    paragraph addressing" for the upstream ask.
+    """
+
+    @property
+    def block_id(self) -> str | None:
+        """Best-effort extraction of the missing block id from the SuperDoc
+        error message. Returns ``None`` when the prefix can't be parsed.
+        """
+        msg = self.payload.get("message")
+        if not isinstance(msg, str):
+            return None
+        # SuperDoc formats the message as ``Block "<type>:<uuid>" was not
+        # found.`` (or ``Block "<uuid>" not found.`` for some shapes) —
+        # extract whatever sits between the quotes, then strip an optional
+        # ``<type>:`` prefix so callers can compare against bare ids.
+        start = msg.find('"')
+        end = msg.find('"', start + 1) if start >= 0 else -1
+        if start < 0 or end <= start:
+            return None
+        quoted = msg[start + 1 : end]
+        if ":" in quoted:
+            return quoted.split(":", 1)[1]
+        return quoted

athena_python_docx-0.8.0/docx/oxml/__init__.py

@@ -0,0 +1,148 @@
+"""Stub package — ``docx.oxml`` is intentionally unavailable in
+athena-python-docx.
+
+python-docx upstream exposes raw OOXML element classes (``OxmlElement``,
+``CT_*``, ``qn``, ``nsmap``, …) for advanced users who manipulate
+Word's XML directly. athena-python-docx is backed by a SuperDoc Y.Doc
++ Keryx pipeline, not a local OOXML tree, so there is no XML element
+to manipulate.
+
+Before 0.8.0 attempts to ``from docx.oxml.ns import qn`` failed with
+the stdlib's generic ``ModuleNotFoundError: No module named
+'docx.oxml'`` — agent code had to discover the gap by retry. As of
+0.8.0 this package is a typed stub: every import path resolves, but
+every attribute access raises :class:`OxmlNotAvailableError` with a
+single actionable message pointing at the high-level python-docx
+surface (``Document.add_paragraph``, ``Run.bold``, ``_Cell.text``, …)
+or the typed command bus (``docx.commands``).
+
+The gap is documented in ``docx-studio/python-sdk/CLAUDE.md`` § "Intentionally
+omitted" and locked into the parity matrix via
+``tests/parity/intentional_deviations.json`` (``docx.oxml**``).
+"""
+
+from __future__ import annotations
+
+import sys
+import types
+from typing import Any
+
+
+class OxmlNotAvailableError(ImportError):
+    """Raised on any access to ``docx.oxml.*`` symbols.
+
+    Inherits :class:`ImportError` so callers using
+    ``try: from docx.oxml import X / except ImportError`` still match,
+    while ``except OxmlNotAvailableError`` lets newer code distinguish
+    a "no oxml surface" miss from a real import-resolution failure.
+    """
+
+
+_MESSAGE: str = (
+    "docx.oxml is not available in athena-python-docx — the SuperDoc "
+    "backend doesn't expose raw OOXML elements. Use the high-level "
+    "python-docx API (Document.add_paragraph, Run.bold, _Cell.text, …) "
+    "or the typed command surface in docx.commands for any mutation "
+    "the high-level API doesn't cover. "
+    "See docx-studio/python-sdk/CLAUDE.md § 'Intentionally omitted' for "
+    "the parity rationale."
+)
+
+
+class _OxmlStubModule(types.ModuleType):
+    """ModuleType subclass that raises :class:`OxmlNotAvailableError`
+    on every attribute access.
+
+    Installed into :data:`sys.modules` at package-init time so
+    qualified imports like ``from docx.oxml.ns import qn`` find a real
+    module object (avoiding ``ModuleNotFoundError``) and raise the
+    typed exception when the symbol is dereferenced.
+
+    No ``__slots__`` — ``types.ModuleType`` itself carries a
+    ``__dict__``, so a slots declaration on a subclass is a no-op and
+    doesn't prevent ``docx.oxml.ns.qn = something`` from silently
+    bypassing :meth:`__getattr__` on the next read. If a future caller
+    needs to block that bypass we'd need a ``__setattr__`` guard that
+    rejects user-attribute writes while still letting the import
+    machinery install dunders (``__loader__``, ``__spec__``, …) on the
+    stub at package-init time.
+    """
+
+    def __getattr__(self, name: str) -> Any:  # noqa: ANN401
+        if name.startswith("__") and name.endswith("__"):
+            # Dunder access (e.g. ``__path__`` during submodule import)
+            # must fall through to AttributeError so Python's import
+            # machinery can probe without triggering our typed error.
+            raise AttributeError(name)
+        path = self.__name__
+        raise OxmlNotAvailableError(f"{path}.{name} — {_MESSAGE}")
+
+
+# Common upstream submodule paths. Listed explicitly rather than wild-
+# carded so adding a new one is a visible diff. Every entry maps to a
+# single sentinel module; no per-submodule state.
+_SUBMODULES: tuple[str, ...] = (
+    "ns",
+    "parser",
+    "element",
+    "xmlchemy",
+    "exceptions",
+    "ooxml",
+    "coreprops",
+    "document",
+    "text",
+    "table",
+    "comments",
+    "header_footer",
+    "footnote",
+    "endnote",
+    "shared",
+    "shape",
+    "section",
+    "settings",
+    "styles",
+    "numbering",
+)
+
+
+def _install_stub_submodules() -> None:
+    """Pre-populate :data:`sys.modules` with stub entries for every
+    well-known ``docx.oxml.*`` submodule.
+
+    Idempotent — re-running is a no-op for entries already installed
+    (covers the rare case of a test that reloads the package).
+    """
+    for short in _SUBMODULES:
+        full = f"docx.oxml.{short}"
+        if full in sys.modules:
+            continue
+        sys.modules[full] = _OxmlStubModule(full)
+
+
+_install_stub_submodules()
+
+
+def __getattr__(name: str) -> Any:  # noqa: ANN401
+    """PEP 562 attribute hook for ``from docx.oxml import X``.
+
+    Submodule names (handled via :data:`sys.modules` injection in
+    :func:`_install_stub_submodules`) and dunder names fall through to
+    the default ``AttributeError`` so Python's import machinery
+    behaves normally. Everything else raises the typed error.
+    """
+    if name.startswith("__") and name.endswith("__"):
+        raise AttributeError(name)
+    if name in _SUBMODULES:
+        # Should already be present in sys.modules; defensive fallback
+        # so we never leak ModuleNotFoundError if the caller reloaded
+        # the package between calls.
+        full = f"docx.oxml.{name}"
+        mod = sys.modules.get(full)
+        if mod is None:
+            mod = _OxmlStubModule(full)
+            sys.modules[full] = mod
+        return mod
+    raise OxmlNotAvailableError(f"docx.oxml.{name} — {_MESSAGE}")
+
+
+__all__ = ["OxmlNotAvailableError"]

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/docx/table.py

@@ -54,6 +54,33 @@ def _log_warn(msg: str) -> None:
     print(f"[docx-sdk] WARN: {msg}", file=sys.stderr)
 
 
+# Characters that, when present, force ``_Cell.text``'s setter to round-
+# trip through the server-side ``doc.markdownToFragment`` op so any
+# inline markdown gets rendered into structural runs. Plain-text values
+# (the common case for tabular data — numbers, labels, names) skip the
+# query entirely and build the fragment locally, saving one HTTP
+# round-trip per cell assignment. The set is conservative on purpose:
+# ``-``, ``.``, ``,``, parentheses, currency symbols, and percent are
+# considered plain so that ``cell.text = "$1,234.56 (-3.4%)"`` doesn't
+# eat a round-trip.
+_MARKDOWN_SPECIAL_CHARS: frozenset[str] = frozenset(
+    "*_~`#>[]<|\\"
+)
+
+
+def _is_plain_text(value: str) -> bool:
+    """Return True iff ``value`` contains no markdown control characters.
+
+    Used by ``_Cell.text`` to decide whether to construct the SuperDoc
+    paragraph fragment locally (plain text) or to defer to the
+    server-side ``doc.markdownToFragment`` op (anything that might
+    contain bold/italic/code/header/list/link/blockquote/html syntax).
+    """
+    if not value:
+        return True
+    return not any(ch in _MARKDOWN_SPECIAL_CHARS for ch in value)
+
+
 def _find_first_paragraph_id(obj: object) -> str:
     """Walk a getNodeById result to find the first paragraph nodeId."""
     if isinstance(obj, dict):
@@ -1010,10 +1037,18 @@ class _Cell:
         }
         # Superdoc only accepts block-typed fragments at the top level
         # (paragraph/heading/table/image/list/sectionBreak/sdt/tableOfContents).
-        # We convert the plain-text value through `doc.markdownToFragment`
-        # to get a guaranteed-valid `{kind:"paragraph", paragraph:{inlines:[...]}}`
-        # shape, then doc.insert appends its inline runs into the cell's
-        # existing paragraph (rather than adding a sibling paragraph).
+        # We need to materialize ``value`` into a
+        # ``{kind:"paragraph", paragraph:{inlines:[...]}}`` fragment.
+        #
+        # As of 0.8.0 we build the fragment locally when ``value`` has no
+        # markdown-special characters — that's the dominant cell-content
+        # case in practice (numeric cells, plain labels) and skipping
+        # the ``doc.markdownToFragment`` query removes one eager HTTP
+        # round-trip per ``cell.text = …``. Combined with
+        # ``Insert`` no longer being response-bearing (0.8.0), a 30-cell
+        # table assignment now ships in a single ``doc.insert`` batch
+        # instead of 60 sequential round-trips. See
+        # ``docx-studio/PERFORMANCE_BATCHING_ANALYSIS.md``.
         #
         # Confirmed against real staging Superdoc. This is the ONLY shape
         # that actually lands text inside a tableCell:
@@ -1022,17 +1057,8 @@ class _Cell:
         #   - doc.replace + tableCell target → replaces the cell itself,
         #     destroying the table structure
         try:
-            frag_result: object = run_sync(
-                session.doc.markdown_to_fragment({"markdown": value or ""}),
-            )
-            fragment: object = (
-                frag_result.get("fragment")
-                if isinstance(frag_result, dict)
-                else None
-            )
-            # Fall back to a hand-built fragment with Superdoc's native
-            # shape if markdownToFragment is unavailable.
-            if not isinstance(fragment, dict):
+            fragment: dict
+            if _is_plain_text(value):
                 fragment = {
                     "kind": "paragraph",
                     "paragraph": {
@@ -1043,6 +1069,29 @@ class _Cell:
                         ),
                     },
                 }
+            else:
+                frag_result: object = run_sync(
+                    session.doc.markdown_to_fragment({"markdown": value}),
+                )
+                resolved: object = (
+                    frag_result.get("fragment")
+                    if isinstance(frag_result, dict)
+                    else None
+                )
+                if isinstance(resolved, dict):
+                    fragment = resolved
+                else:
+                    # Server didn't return a fragment — fall back to the
+                    # hand-built shape so we still land text rather than
+                    # raising.
+                    fragment = {
+                        "kind": "paragraph",
+                        "paragraph": {
+                            "inlines": [
+                                {"kind": "run", "run": {"text": value}},
+                            ],
+                        },
+                    }
             run_sync(
                 session.doc.insert(
                     {
@@ -1063,14 +1112,36 @@ class _Cell:
     def paragraphs(self) -> list["Paragraph"]:
         from docx.text.paragraph import Paragraph
 
-        return [
-            Paragraph(
+        # Mark each Paragraph proxy as cell-inner so downstream format
+        # ops that hit a SuperDoc ``Block not found`` miss can correlate
+        # back to the well-known cell-paragraph addressing gap (see
+        # ``BlockNotFoundError`` and ``SUPERDOC_UPSTREAM_REQUESTS.md``).
+        # The flag is informational — no setter changes behavior based
+        # on it yet — but it makes the connection inspectable from a
+        # debugger and gives ``_apply_inline`` and friends something
+        # stable to consult when we eventually add a materialization
+        # fallback at the SDK layer.
+        pids = self._inner_paragraph_ids()
+        # Resolve the cell address ONCE and re-use it for every
+        # paragraph; the original draft called ``self._cell_address()``
+        # inside the loop, which hits ``_cell_id`` → ``_cell_info`` →
+        # ``tables.get_cells`` per iteration. A 10-paragraph cell would
+        # have eaten 10 redundant ``tables.get_cells`` round-trips just
+        # to stamp identical metadata — defeats the whole point of the
+        # 0.8.0 round-trip-reduction work. ``addr`` is ``None`` for an
+        # empty cell so we don't issue a no-op address query in that case.
+        addr = self._cell_address() if pids else None
+        out: list[Paragraph] = []
+        for pid in pids:
+            p = Paragraph(
                 session=self._table._session,
                 node_id=pid,
                 node_type="paragraph",
             )
-            for pid in self._inner_paragraph_ids()
-        ]
+            p._cell_inner = True  # type: ignore[attr-defined]
+            p._cell_address = addr  # type: ignore[attr-defined]
+            out.append(p)
+        return out
 
     @property
     def tables(self) -> list[Table]:

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/pyproject.toml

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

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/tests/fidelity/op_snapshots/101_table_cells_flat_iteration.json

@@ -5,26 +5,20 @@
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert"
 ]

athena_python_docx-0.8.0/tests/fidelity/op_snapshots/17_table_basic.json

@@ -0,0 +1,4 @@
+[
+  "create.table",
+  "tables.setStyle"
+]

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/tests/fidelity/op_snapshots/18_table_cell_text.json

@@ -3,31 +3,25 @@
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert"
 ]

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/tests/fidelity/op_snapshots/22_table_cell_paragraphs_iteration.json

@@ -3,7 +3,6 @@
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.getCells",
@@ -12,5 +11,7 @@
   "tables.get",
   "tables.getCells",
   "getNodeById",
+  "tables.get",
+  "tables.getCells",
   "getNodeById"
 ]

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/tests/fidelity/op_snapshots/23_nested_table.json

@@ -8,6 +8,5 @@
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert"
 ]

{athena_python_docx-0.7.0 → athena_python_docx-0.8.0}/tests/fidelity/op_snapshots/24_table_add_row_column.json

@@ -6,7 +6,6 @@
   "tables.get",
   "tables.get",
   "tables.getCells",
-  "markdownToFragment",
   "insert",
   "tables.get",
   "tables.get",