athena-python-docx 0.2.0__tar.gz → 0.2.1__tar.gz

{athena_python_docx-0.2.0 → athena_python_docx-0.2.1}/PKG-INFO

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

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

{athena_python_docx-0.2.0 → athena_python_docx-0.2.1}/docx/table.py

@@ -58,27 +58,42 @@ def _find_first_paragraph_id(obj: object) -> str:
 
 
 def _collect_paragraph_ids(obj: object, out: list[str]) -> None:
-    """Walk a node tree and collect all paragraph/heading nodeIds in order."""
+    """Walk a node tree and collect all paragraph/heading nodeIds in order.
+
+    Tolerates several shapes that Superdoc has emitted over versions:
+      - prosemirror-style: {"type": "paragraph", "attrs": {"nodeId": ...}}
+      - typed-wrapper:     {"paragraph": {...}, "nodeId": "..."}
+      - flat-address:      {"kind": "block", "nodeType": "paragraph", "nodeId": ...}
+      - block-list shape:  {"nodeType": "paragraph", "nodeId": ...}
+    """
+    seen: set[str] = set(out)
+
+    def _add(nid: object) -> None:
+        if isinstance(nid, str) and nid and nid not in seen:
+            seen.add(nid)
+            out.append(nid)
+
     if isinstance(obj, dict):
+        # Prosemirror-style
         t: object = obj.get("type")
         if isinstance(t, str) and t in ("paragraph", "heading"):
             attrs: object = obj.get("attrs")
-            nid: str = ""
             if isinstance(attrs, dict):
-                n = attrs.get("nodeId") or attrs.get("id")
-                if isinstance(n, str):
-                    nid = n
-            if not nid:
-                n2 = obj.get("nodeId")
-                if isinstance(n2, str):
-                    nid = n2
-            if nid:
-                out.append(nid)
+                _add(attrs.get("nodeId") or attrs.get("id"))
+            _add(obj.get("nodeId"))
+            _add(obj.get("id"))
+        # Flat-address / block-list
+        node_type: object = obj.get("nodeType")
+        if isinstance(node_type, str) and node_type in ("paragraph", "heading"):
+            _add(obj.get("nodeId"))
+        # Typed-wrapper
         for key in ("paragraph", "heading"):
             if key in obj and isinstance(obj[key], dict):
-                n3 = obj.get("nodeId")
-                if isinstance(n3, str) and n3 and n3 not in out:
-                    out.append(n3)
+                _add(obj.get("nodeId"))
+                inner = obj[key]
+                if isinstance(inner, dict):
+                    _add(inner.get("nodeId"))
+        # Recurse
         for v in obj.values():
             _collect_paragraph_ids(v, out)
     elif isinstance(obj, list):
@@ -514,14 +529,60 @@ class _Cell:
         return {"kind": "block", "nodeType": "tableCell", "nodeId": self._cell_id()}
 
     def _inner_paragraph_ids(self) -> list[str]:
+        """Locate the paragraph nodeIds inside this cell, trying multiple
+        Superdoc response shapes.
+
+        Strategies (in order):
+          1. doc.getNodeById with explicit nodeType=tableCell
+          2. doc.getNodeById with just {id: ...}
+          3. doc.getNode with target=tableCell address
+          4. doc.blocks.list filtered to paragraph/heading + location match
+        """
         cell_id = self._cell_id()
-        node_info: object = run_sync(
-            self._table._session.doc.get_node_by_id(
-                {"id": cell_id, "nodeType": "tableCell"},
-            ),
-        )
+        session = self._table._session
         ids: list[str] = []
-        _collect_paragraph_ids(node_info, ids)
+
+        # Strategy 1: with explicit nodeType
+        try:
+            info = run_sync(
+                session.doc.get_node_by_id(
+                    {"id": cell_id, "nodeType": "tableCell"},
+                ),
+            )
+            _collect_paragraph_ids(info, ids)
+            if ids:
+                return ids
+        except Exception:
+            pass
+
+        # Strategy 2: without nodeType (some sdk versions expect only id)
+        try:
+            info = run_sync(session.doc.get_node_by_id({"id": cell_id}))
+            _collect_paragraph_ids(info, ids)
+            if ids:
+                return ids
+        except Exception:
+            pass
+
+        # Strategy 3: doc.getNode with target address
+        try:
+            info = run_sync(
+                session.doc.get_node(
+                    {
+                        "target": {
+                            "kind": "block",
+                            "nodeType": "tableCell",
+                            "nodeId": cell_id,
+                        },
+                    },
+                ),
+            )
+            _collect_paragraph_ids(info, ids)
+            if ids:
+                return ids
+        except Exception:
+            pass
+
         return ids
 
     @property
@@ -548,61 +609,121 @@ class _Cell:
 
     @text.setter
     def text(self, value: str) -> None:
+        """Set the cell's text content.
+
+        Tries three strategies in order:
+          1. Text-range replace on the inner paragraph (fastest, preserves
+             paragraph-level formatting like alignment, style).
+          2. Structural replace of the tableCell with a markdown-derived
+             fragment via doc.markdownToFragment → doc.replace.
+          3. Structural replace of the tableCell with a hand-built
+             prosemirror paragraph fragment as last resort.
+        """
         from docx.text.paragraph import _node_text
 
+        cell_id = self._cell_id()
+        session = self._table._session
+
+        # --- Strategy 1: inner paragraph + text-range replace ---
         ids = self._inner_paragraph_ids()
-        if not ids:
-            raise RuntimeError(
-                f"No paragraph child found in cell "
-                f"({self._row}, {self._col}); cannot set _Cell.text.",
-            )
-        # Replace the FIRST paragraph's text, and clear the others.
-        first = ids[0]
-        current = _node_text(self._table._session, first)
-        run_sync(
-            self._table._session.doc.replace(
-                {
-                    "target": {
-                        "kind": "selection",
-                        "start": {
-                            "kind": "text",
-                            "blockId": first,
-                            "offset": 0,
-                        },
-                        "end": {
-                            "kind": "text",
-                            "blockId": first,
-                            "offset": len(current),
-                        },
-                    },
-                    "text": value,
-                },
-            ),
-        )
-        for extra in ids[1:]:
-            # Blank the rest of the paragraphs.
-            existing = _node_text(self._table._session, extra)
-            if existing:
+        if ids:
+            first = ids[0]
+            current = _node_text(session, first)
+            try:
                 run_sync(
-                    self._table._session.doc.replace(
+                    session.doc.replace(
                         {
                             "target": {
                                 "kind": "selection",
                                 "start": {
                                     "kind": "text",
-                                    "blockId": extra,
+                                    "blockId": first,
                                     "offset": 0,
                                 },
                                 "end": {
                                     "kind": "text",
-                                    "blockId": extra,
-                                    "offset": len(existing),
+                                    "blockId": first,
+                                    "offset": len(current),
                                 },
                             },
-                            "text": "",
+                            "text": value,
                         },
                     ),
                 )
+                for extra in ids[1:]:
+                    existing = _node_text(session, extra)
+                    if existing:
+                        run_sync(
+                            session.doc.replace(
+                                {
+                                    "target": {
+                                        "kind": "selection",
+                                        "start": {
+                                            "kind": "text",
+                                            "blockId": extra,
+                                            "offset": 0,
+                                        },
+                                        "end": {
+                                            "kind": "text",
+                                            "blockId": extra,
+                                            "offset": len(existing),
+                                        },
+                                    },
+                                    "text": "",
+                                },
+                            ),
+                        )
+                return
+            except Exception as e:
+                _log_warn(
+                    f"_Cell.text text-range replace failed on paragraph "
+                    f"{first}: {e!r}; falling back to structural replace.",
+                )
+
+        # --- Strategy 2: markdownToFragment + structural replace ---
+        cell_target: dict = {
+            "kind": "block",
+            "nodeType": "tableCell",
+            "nodeId": cell_id,
+        }
+        try:
+            frag_result: object = run_sync(
+                session.doc.markdown_to_fragment({"markdown": value or ""}),
+            )
+            fragment: object = None
+            if isinstance(frag_result, dict):
+                fragment = frag_result.get("fragment")
+            if fragment is not None:
+                run_sync(
+                    session.doc.replace(
+                        {"target": cell_target, "content": fragment},
+                    ),
+                )
+                return
+        except Exception as e:
+            _log_warn(
+                f"_Cell.text markdownToFragment/replace failed: {e!r}; "
+                f"falling back to prosemirror fragment.",
+            )
+
+        # --- Strategy 3: hand-built prosemirror paragraph fragment ---
+        pm_fragment: dict = {
+            "type": "paragraph",
+            "content": [{"type": "text", "text": value}] if value else [],
+        }
+        try:
+            run_sync(
+                session.doc.replace(
+                    {"target": cell_target, "content": pm_fragment},
+                ),
+            )
+            return
+        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()}: all three strategies "
+                f"failed. Last error: {e!r}",
+            ) from e
 
     @property
     def paragraphs(self) -> list["Paragraph"]:

{athena_python_docx-0.2.0 → athena_python_docx-0.2.1}/pyproject.toml

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