athena-python-docx 0.9.0__tar.gz → 0.10.0__tar.gz

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/CLAUDE.md

@@ -88,13 +88,28 @@ not file-backed. Each is documented in the relevant docstring.
   hits `POST {base_url}/docs/empty`. The constructor positional-arg
   shape (`Document(asset_id)`) is preserved for parity.
 
-- **`Document.save(path_or_stream=None)`** — argument is optional.
-  Stock python-docx requires it and `TypeError`s on no-arg, but in an
+- **`Document.asset_id: str`** read-only property — the Athena asset
+  id this Document is bound to (`asset_<uuid>`). Agent-callable so
+  the typical pattern `doc = Document.create(...); print(doc.asset_id)`
+  works without reaching into `doc._session._asset_id`. Stock
+  python-docx has no analogue (it operates on local files), so this
+  is an Athena-only addition. Mirrors the parallel public accessors
+  on the other studios: `Workbook.workbook_id` (xlsx) and
+  `Presentation.deck_id` (pptx).
+
+- **`Document.save(path_or_stream=None)`** — argument is optional and,
+  when supplied, raises
+  :class:`docx.errors.LocalSaveTargetNotSupportedError`. Stock
+  python-docx requires it and `TypeError`s on no-arg, but in an
   asset-backed SDK there is no local file to write — writes are always
   in-place against the Y.Doc. Forcing the upstream signature broke
   every agent invocation that reflexively called `doc.save()` (a
-  near-universal Python pattern), so we accept it for parity-friendly
-  call sites and ignore the value at runtime.
+  near-universal Python pattern), so the no-arg form is supported.
+  When a path or stream IS supplied, the SDK cannot fulfill the
+  implied "write bytes to this target" contract, so the call raises
+  loudly rather than silently flushing — agents must use Olympus's
+  Export DOCX (which goes through the SuperDoc session that already
+  has the bytes) instead of expecting a local file.
 
 - **`Document.track_revisions: bool`** — when `True`, all subsequent
   mutations are recorded as tracked revisions instead of direct edits.

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/PKG-INFO

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

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

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/docx/_http_doc.py

@@ -30,6 +30,7 @@ format is now typed end-to-end either way.
 from __future__ import annotations
 
 import json
+import os
 from typing import Any
 
 import requests
@@ -106,6 +107,7 @@ from docx.commands import (
     TablesSetRowHeight,
     TablesSetStyle,
     TablesSetTableOptions,
+    TableSetCell,
     TrackChangesDecide,
     TrackChangesGet,
     TrackChangesList,
@@ -372,6 +374,9 @@ def _http_post_json(
         "Accept": "application/json",
         "User-Agent": _user_agent(),
     }
+    custom_attr = os.environ.get("ATHENA_DOCX_CUSTOM_ATTRIBUTIONS")
+    if custom_attr:
+        headers["X-Custom-Attributions"] = custom_attr
     try:
         resp = session.post(
             url,
@@ -647,6 +652,7 @@ _OP_TO_COMMAND: dict[str, type[Command]] = {
     "tables.set_cell_properties": TablesSetCellProperties,
     "tables.set_column_width": TablesSetColumnWidth,
     "tables.set_row_height": TablesSetRowHeight,
+    "tables.set_cell": TableSetCell,
     # Images (mutations)
     "images.set_size": SetImageSize,
     "images.set_alt_text": SetImageAltText,

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/docx/api.py

@@ -6,7 +6,10 @@ python-docx signature:
 Our signature deviates from the path-based one because we don't open
 .docx files from disk — we open Y.Doc assets from Keryx. The parameter
 is reused: pass an asset_id string where python-docx would take a file
-path.
+path. The id MUST be ``asset_<uuid>``; anything else (a title, a file
+path, etc.) raises ``ValueError`` before any HTTP request. To mint a
+new asset, call ``Document.create(name=...)`` and reuse the returned
+``doc.asset_id`` on subsequent ``Document(...)`` opens.
 
 For net-new asset creation, use the classmethod ``Document.create()``
 (see ``docx.document``). Stock python-docx returns a blank document
@@ -18,8 +21,18 @@ write that has to happen first. ``Document.create()`` handles that via
 
 from __future__ import annotations
 
+import re
+
 from docx.document import Document as _Document
 
+# Asset-id shape validation. Athena SuperDocument assets are
+# ``asset_<uuid>``. Rejecting anything else up front prevents the
+# common agent failure mode of passing a document TITLE
+# (``Document("Q4 Report Draft")``) instead of its id, which would
+# otherwise round-trip through the docx-studio session and fail with
+# an opaque server error.
+_ASSET_ID_PATTERN = re.compile(r"^asset_[A-Za-z0-9_-]+$")
+
 
 def Document(
     docx: str | None = None,
@@ -67,14 +80,49 @@ def Document(
             "To create a brand-new document, call "
             "Document.create(name=..., base_url=..., api_key=...).",
         )
-    return _Document(
-        asset_id=docx,
-        http_base_url=base_url,
-        http_api_key=api_key,
-        user_name=user_name,
-        user_email=user_email,
-        track_revisions=track_revisions,
+    if not _ASSET_ID_PATTERN.match(docx):
+        raise ValueError(
+            f"Document({docx!r}) is not a valid SuperDocument asset id. "
+            f"Asset ids look like 'asset_<uuid>' "
+            f"(e.g., 'asset_3a9328bc-9c1c-4498-be8f-bda3883276f5'). To "
+            f"open an existing document, pass its asset id — NOT its "
+            f"title. To create a new document titled {docx!r}, call "
+            f"Document.create(name={docx!r}) and reuse the returned "
+            f"document's asset id on subsequent calls in the same "
+            f"conversation."
+        )
+
+    # PTC: surface document open as its own sub-tool-card so the
+    # frontend can react (e.g., auto-open the asset tab). The paired
+    # ``Document.create()`` path emits ``CreateDocument``; this open
+    # path emits ``OpenDocument`` with the asset id.
+    from docx import _ptc
+
+    call_id = _ptc.emit_begin("OpenDocument", {"assetId": docx})
+    try:
+        doc = _Document(
+            asset_id=docx,
+            http_base_url=base_url,
+            http_api_key=api_key,
+            user_name=user_name,
+            user_email=user_email,
+            track_revisions=track_revisions,
+        )
+    except Exception as exc:
+        _ptc.emit_end(
+            call_id=call_id,
+            tool_name="OpenDocument",
+            result={"ok": False, "error": str(exc)},
+            is_error=True,
+        )
+        raise
+    _ptc.emit_end(
+        call_id=call_id,
+        tool_name="OpenDocument",
+        result={"ok": True, "assetId": docx},
+        is_error=False,
     )
+    return doc
 
 
 # Re-export the classmethod factories at module level so callers can

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/docx/commands.py

@@ -140,6 +140,33 @@ class Insert(Command):
     content: dict[str, Any] | None = None
 
 
+@dataclass
+class TableSetCell(Command):
+    """Address a single table cell by ``(table_node_id, row, col)`` and insert
+    ``content`` into it. The applier resolves the cell's real nodeId
+    server-side (via one batch-wide ``tables.getCells`` call cached per
+    table), so the SDK doesn't need a prior ``tables.get_cells`` query —
+    each ``_Cell.text = …`` skips 1 HTTP round-trip and the whole table
+    flushes in one batch.
+
+    Buffered, not response-bearing. Placement defaults to ``insideEnd``
+    on the apps/api side (matches the prior ``_Cell.text`` setter
+    semantics: APPEND into the cell's existing paragraph, which produces
+    ``cell.text == value`` for a freshly created empty cell).
+
+    ``table_node_id`` may be a client-side UUID — the applier resolves
+    it through the per-batch ``clientIdMap`` set by the preceding
+    ``CreateTable``, so a freshly created table can be populated in the
+    same flush.
+    """
+
+    table_node_id: str
+    row_index: int
+    column_index: int
+    content: dict[str, Any]
+    placement: str | None = None
+
+
 @dataclass
 class Replace(Command):
     target: dict[str, Any]
@@ -899,6 +926,7 @@ __all__ = [
     "TablesSetCellProperties",
     "TablesSetColumnWidth",
     "TablesSetRowHeight",
+    "TableSetCell",
     # Images (mutations)
     "SetImageSize",
     # Queries

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/docx/document.py

@@ -17,13 +17,16 @@ from __future__ import annotations
 import base64
 import io
 import sys
-import warnings
 from contextlib import contextmanager
 from typing import TYPE_CHECKING, BinaryIO, Generator, Iterator
 
 from docx._batching import run_sync
 from docx.client import Session
-from docx.errors import DocumentClosedError, ValidationError
+from docx.errors import (
+    DocumentClosedError,
+    LocalSaveTargetNotSupportedError,
+    ValidationError,
+)
 
 # python-docx re-exports a subset of symbols at docx.document; mirror those
 # so `from docx.document import Emu` etc. works.
@@ -121,20 +124,6 @@ def _classify_list_style(style_id: str | None) -> tuple[str, int] | None:
     return (kind, level)
 
 
-class IgnoredSaveTargetWarning(UserWarning):
-    """Emitted when ``Document.save(path_or_stream=...)`` is called with a
-    non-None argument.
-
-    The SDK is asset-backed: edits are flushed in place against the
-    Y.Doc, and the ``path_or_stream`` parameter is accepted only for
-    parity-friendly call sites (see :meth:`Document.save`). A caller
-    passing a path or stream almost certainly expects a local-file
-    export, which this SDK cannot perform. Surfacing a warning makes
-    the silent gap visible without breaking agent-generated code that
-    reflexively calls ``doc.save()`` with no args.
-    """
-
-
 class Document:
     """A Word document backed by a Superdoc/Keryx Y.Doc.
 
@@ -258,6 +247,20 @@ class Document:
 
     # ---- Public properties ----
 
+    @property
+    def asset_id(self) -> str:
+        """Athena asset id this Document is bound to (``asset_<uuid>``).
+
+        Agent-callable accessor — use this to capture the id of a
+        ``Document.create(...)`` so subsequent ``Document(asset_id)``
+        opens can target the same document in later tool calls.
+
+        DEVIATION FROM python-docx: stock python-docx has no analogue
+        because it operates on local files, not assets. Documented in
+        ``docs/API_PARITY_EXCEPTIONS.md``.
+        """
+        return self._session.asset_id
+
     @property
     def paragraphs(self) -> list["Paragraph"]:
         """Return all paragraphs in document order.
@@ -939,7 +942,12 @@ class Document:
                 ),
             )
 
-        tbl = Table(session=self._session, node_id=node_id)
+        tbl = Table(
+            session=self._session,
+            node_id=node_id,
+            rows=rows,
+            columns=cols,
+        )
         self._register_proxy_id(client_node_id, tbl)
         return tbl
 
@@ -1108,30 +1116,28 @@ class Document:
         optional. Stock python-docx requires it and raises ``TypeError``
         on ``save()`` no-arg, but in this asset-backed SDK there is no
         local file to write to — writes are always in-place against the
-        Y.Doc. Agent-generated code reflexively calls ``doc.save()`` and
-        forcing the upstream signature broke every such invocation
-        (`Untitled Word Document` session
-        ``thread_3f6b59e0-ae25-4f6e-8391-c286b17a3334``). The argument
-        is accepted for parity-friendly call sites but ignored at
-        runtime. To export to a local file, use the Olympus UI's
-        Export DOCX.
-
-        When ``path_or_stream`` is non-None, an
-        :class:`IgnoredSaveTargetWarning` is emitted so the silent gap
-        is visible to callers. The flush still happens — the call does
-        not raise — but the user-supplied path/stream is not written
-        to. Previously a caller passing a string path got a fully
-        silent success and no file on disk.
+        Y.Doc. Agent-generated code reflexively calls ``doc.save()``;
+        forcing the upstream signature broke common agent call patterns,
+        so no-arg ``doc.save()`` is supported.
+
+        When ``path_or_stream`` IS supplied (e.g. ``doc.save("./out.docx")``
+        or ``doc.save(BytesIO())``), this raises
+        :class:`docx.errors.LocalSaveTargetNotSupportedError`. The SDK
+        cannot fulfill the implied contract of "write bytes to this
+        target"; previously the call emitted a warning and silently
+        flushed, leaving callers with no file on disk and no error.
+        Raising forces the caller to address the gap explicitly — use
+        Olympus's Export DOCX (which goes through the SuperDoc session
+        that already has the bytes).
         """
         if path_or_stream is not None:
-            warnings.warn(
-                "Document.save(path_or_stream=...) ignores its argument — "
-                "athena-python-docx is asset-backed and cannot write to a "
-                "local file or stream. The flush completed in-place against "
-                "the Y.Doc; no bytes were written to "
-                f"{path_or_stream!r}. To export, use Olympus's Export DOCX.",
-                IgnoredSaveTargetWarning,
-                stacklevel=2,
+            raise LocalSaveTargetNotSupportedError(
+                "Document.save(path_or_stream=...) cannot write to a "
+                "local file or stream — athena-python-docx is "
+                "asset-backed and edits flush in place against the "
+                f"Y.Doc. Got {path_or_stream!r}. Call doc.save() with "
+                "no arguments to flush, or use Olympus's Export DOCX "
+                "to obtain a .docx file."
             )
         self._flush()
 

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/docx/errors.py

@@ -31,10 +31,24 @@ class DocxError(Exception):
     :meth:`with_partial_applied` factory helper at raise sites instead.
     """
 
-    # Class-level default — ``except DocxError as exc`` handlers can
-    # read ``exc.partial_applied`` without ``hasattr`` even on errors
-    # raised the legacy way (no ``with_partial_applied`` call).
-    partial_applied: list[dict] = []
+    def __getattr__(self, name: str) -> list[dict]:
+        """Lazy default for ``partial_applied`` — returns an empty list
+        when the attribute hasn't been set via :meth:`with_partial_applied`.
+
+        Using ``__getattr__`` (only called when ordinary attribute
+        lookup misses) instead of a class-level mutable default avoids
+        the footgun where ``exc.partial_applied.append(x)`` on a
+        legacy-raised error would mutate a shared list and make every
+        subsequent ``DocxError`` look partially applied. Each call here
+        returns a fresh empty list; mutating it has no cross-instance
+        effect.
+        """
+        if name == "partial_applied":
+            return []
+        # Match Python's default ``AttributeError`` for unknown attrs.
+        raise AttributeError(
+            f"{type(self).__name__!r} object has no attribute {name!r}",
+        )
 
     def with_partial_applied(
         self,
@@ -48,6 +62,8 @@ class DocxError(Exception):
             raise DocxError("...").with_partial_applied(prefix)
         """
         if applied:
+            # Writes to ``self.__dict__`` — subsequent reads bypass
+            # ``__getattr__`` entirely and see the per-instance list.
             self.partial_applied = list(applied)
         return self
 
@@ -71,6 +87,23 @@ class DocumentClosedError(DocxError):
     """Raised when operating on a closed Document."""
 
 
+class LocalSaveTargetNotSupportedError(DocxError, NotImplementedError):
+    """Raised when ``Document.save(path_or_stream=...)`` is called with a
+    non-None argument.
+
+    The SDK is asset-backed: edits flush in place against the Y.Doc, so
+    there is no local file or stream to write to. The bare ``doc.save()``
+    no-arg form remains supported as the documented deviation from stock
+    python-docx (see :meth:`docx.document.Document.save`). To get a
+    ``.docx`` file out, use Olympus's Export DOCX action — the SuperDoc
+    session already has the bytes the caller wanted.
+
+    Subclasses :class:`NotImplementedError` so a generic
+    ``except NotImplementedError`` catches it without importing the
+    typed class.
+    """
+
+
 class ValidationError(DocxError):
     """Raised when SDK-level validation fails (bad args, out-of-range indices)."""
 

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/docx/table.py

@@ -234,9 +234,26 @@ def _collect_block_ids(
 
 
 class Table:
-    def __init__(self, *, session: "Session", node_id: str) -> None:
+    def __init__(
+        self,
+        *,
+        session: "Session",
+        node_id: str,
+        rows: int | None = None,
+        columns: int | None = None,
+    ) -> None:
         self._session: "Session" = session
         self._node_id: str = node_id
+        # Locally-cached grid dimensions. Populated by
+        # ``Document.add_table`` (which knows the rows/cols up-front)
+        # so ``Table.cell()`` can validate bounds without round-tripping
+        # to ``tables.get``. Stays ``None`` for Tables resolved later
+        # via ``find`` / iteration; ``cell()`` falls back to
+        # ``_fresh_node_info()`` in that case. ``tables.insert_row`` /
+        # ``tables.insert_column`` invalidate this cache so the next
+        # access re-fetches authoritative counts.
+        self._cached_rows: int | None = rows
+        self._cached_cols: int | None = columns
 
     def _fresh_node_info(self) -> tuple[str, dict]:
         """Resolve the live nodeId and return ``(node_id, info_dict)``.
@@ -332,21 +349,35 @@ class Table:
 
         Negative indices are accepted Python-style (``-1`` is the last
         row/column).
+
+        Fast path: when the Table proxy was constructed with known
+        dimensions (``Document.add_table`` and ``Table.insert_row`` /
+        ``insert_column`` keep this cache current), bounds-check
+        against the local cache without round-tripping to
+        ``tables.get``. This is what keeps a 30-cell write loop at
+        zero query-shaped HTTP calls — pre-cache this was one
+        ``tables.get`` per ``cell()`` access.
         """
-        _, info_dict = self._fresh_node_info()
-        row_count: int = int(
-            info_dict.get("rows")
-            or info_dict.get("rowCount")
-            or (info_dict.get("table", {}) or {}).get("rows")
-            or 0,
-        )
-        col_count: int = int(
-            info_dict.get("columns")
-            or info_dict.get("cols")
-            or info_dict.get("columnCount")
-            or (info_dict.get("table", {}) or {}).get("columns")
-            or 0,
-        )
+        row_count: int
+        col_count: int
+        if self._cached_rows is not None and self._cached_cols is not None:
+            row_count = self._cached_rows
+            col_count = self._cached_cols
+        else:
+            _, info_dict = self._fresh_node_info()
+            row_count = int(
+                info_dict.get("rows")
+                or info_dict.get("rowCount")
+                or (info_dict.get("table", {}) or {}).get("rows")
+                or 0,
+            )
+            col_count = int(
+                info_dict.get("columns")
+                or info_dict.get("cols")
+                or info_dict.get("columnCount")
+                or (info_dict.get("table", {}) or {}).get("columns")
+                or 0,
+            )
         # Normalize negative indices the same way list[] does.
         if row_idx < 0:
             row_idx += row_count
@@ -399,6 +430,10 @@ class Table:
                 },
             ),
         )
+        # Keep the bounds-check cache current so the next ``cell()``
+        # access still hits the fast path.
+        if self._cached_rows is not None:
+            self._cached_rows += 1
         return _Row(table=self, index=row_count)
 
     def add_column(self, width: "Length") -> "_Column":
@@ -432,6 +467,9 @@ class Table:
                 },
             ),
         )
+        # Keep the bounds-check cache current.
+        if self._cached_cols is not None:
+            self._cached_cols += 1
         new_col = _Column(table=self, index=col_count)
         new_col.width = width
         return new_col
@@ -1009,10 +1047,10 @@ class _Cell:
 
         The cell's single inner paragraph is addressed indirectly — Superdoc
         doesn't expose a paragraph ref that's usable as a `blockId` for text
-        selections. Instead we use `doc.insert` with a structural paragraph
-        fragment at `placement=insideEnd`, which APPENDS inline runs to the
-        cell's existing paragraph. For a freshly-created (empty) cell this
-        produces `cell.text == value` on read-back.
+        selections. The apps/api applier wraps a `tables.getCells` lookup +
+        a `doc.insert` with placement=insideEnd, which APPENDS inline runs
+        to the cell's existing paragraph. For a freshly-created (empty)
+        cell this produces `cell.text == value` on read-back.
 
         For cells that already contain text, callers who truly want "replace"
         semantics should first resolve the cell's paragraph via `doc.find`
@@ -1028,34 +1066,27 @@ class _Cell:
             raise TypeError(
                 f"_Cell.text must be a str; got {type(value).__name__}",
             )
-        cell_id = self._cell_id()
-        session = self._table._session
-        cell_target: dict = {
-            "kind": "block",
-            "nodeType": "tableCell",
-            "nodeId": cell_id,
-        }
-        # Superdoc only accepts block-typed fragments at the top level
-        # (paragraph/heading/table/image/list/sectionBreak/sdt/tableOfContents).
-        # We need to materialize ``value`` into a
-        # ``{kind:"paragraph", paragraph:{inlines:[...]}}`` fragment.
+        # As of 0.10.0 the setter buffers a ``TableSetCell`` command
+        # addressed by ``(table_node_id, row, col)`` and skips both
+        # eager queries that used to fire per cell — the
+        # ``Table._fresh_node_info()`` call (``tables.get`` query)
+        # AND the ``_cell_info()`` call (``tables.get_cells`` query).
+        # The apps/api applier resolves the cell nodeId server-side
+        # against a per-batch cache so N cell writes against one table
+        # share one ``tables.getCells`` call.
         #
-        # 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
+        # Pre-0.10.0 a 30-cell table assignment was ~60 HTTP round-
+        # trips (one ``tables.get`` + one ``tables.get_cells`` per
+        # cell); post-0.10.0 it's a single ``POST /commands`` batch
+        # containing the 30 TableSetCell commands plus whatever else
+        # was already buffered. See
         # ``docx-studio/PERFORMANCE_BATCHING_ANALYSIS.md``.
         #
-        # Confirmed against real staging Superdoc. This is the ONLY shape
-        # that actually lands text inside a tableCell:
-        #   - text mode + placement  → rejected ("placement only valid
-        #     with structural content")
-        #   - doc.replace + tableCell target → replaces the cell itself,
-        #     destroying the table structure
+        # For plain text we build the fragment client-side. For
+        # markdown content we still need one eager
+        # ``markdown_to_fragment`` query (the parsed fragment isn't
+        # something the apps/api applier can build for us yet).
+        session = self._table._session
         try:
             fragment: dict
             if _is_plain_text(value):
@@ -1092,11 +1123,22 @@ class _Cell:
                             ],
                         },
                     }
+            # ``self._table._node_id`` is the raw client-or-server id
+            # the Table proxy currently holds. The applier resolves it
+            # through the per-batch clientIdMap so a freshly-created
+            # table (still on its client UUID locally) routes to the
+            # real id without forcing a flush here.
+            #
+            # Routed via the standard path-proxy (``tables.set_cell`` →
+            # ``TableSetCell`` per ``_OP_TO_COMMAND``) so test fakes
+            # that intercept at the namespace level see the call the
+            # same way they see every other op.
             run_sync(
-                session.doc.insert(
+                session.doc.tables.set_cell(
                     {
-                        "target": cell_target,
-                        "placement": "insideEnd",
+                        "tableNodeId": self._table._node_id,
+                        "rowIndex": self._row,
+                        "columnIndex": self._col,
                         "content": fragment,
                     },
                 ),
@@ -1105,7 +1147,7 @@ class _Cell:
         except Exception as e:
             raise RuntimeError(
                 f"Failed to set _Cell.text on cell ({self._row}, {self._col}) "
-                f"of table {self._table._fresh_node_id()}: {e!r}",
+                f"of table {self._table._node_id}: {e!r}",
             ) from e
 
     @property

{athena_python_docx-0.9.0 → athena_python_docx-0.10.0}/pyproject.toml

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