athena-python-docx 0.1.6__tar.gz → 0.1.8__tar.gz

{athena_python_docx-0.1.6 → athena_python_docx-0.1.8}/PKG-INFO

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

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

{athena_python_docx-0.1.6 → athena_python_docx-0.1.8}/docx/text/paragraph.py

@@ -36,18 +36,38 @@ _STUB_SUFFIX = (
 
 
 def _node_text(session: "Session", node_id: str) -> str:
-    """Fetch a block's full text via doc.get_node_by_id."""
+    """Fetch a block's full text via doc.get_node_by_id.
+
+    The response shape for a paragraph is:
+        {"node": {"paragraph": {"inlines": [{"run": {"text": "..."}}, ...]}}}
+    We concatenate each run's ``text`` in order. Non-paragraph blocks or
+    empty responses return ``""``.
+    """
     info: object = run_sync(
         session.doc.get_node_by_id({"id": node_id}),
     )
     if not isinstance(info, dict):
         return ""
     node: object = info.get("node")
-    if isinstance(node, dict):
-        text: object = node.get("text")
+    if not isinstance(node, dict):
+        return ""
+    paragraph: object = node.get("paragraph")
+    if not isinstance(paragraph, dict):
+        return ""
+    inlines: object = paragraph.get("inlines")
+    if not isinstance(inlines, list):
+        return ""
+    parts: list[str] = []
+    for inline in inlines:
+        if not isinstance(inline, dict):
+            continue
+        run: object = inline.get("run")
+        if not isinstance(run, dict):
+            continue
+        text: object = run.get("text")
         if isinstance(text, str):
-            return text
-    return ""
+            parts.append(text)
+    return "".join(parts)
 
 
 class Paragraph:
@@ -131,17 +151,24 @@ class Paragraph:
         current: str = _node_text(self._session, self._node_id)
         start: int = len(current)
 
-        # Insert at end of the block. The insert params support targeting
-        # a block + offset: {blockId, start, end} at top level where start==end
-        # means an insertion point (not a range).
+        # Superdoc expects a selection target with text cursors. A zero-
+        # length selection (start == end) is an insertion point, not a
+        # replace-range.
+        cursor: dict = {
+            "kind": "text",
+            "blockId": self._node_id,
+            "offset": start,
+        }
         run_sync(
             self._session.doc.insert(
                 {
+                    "target": {
+                        "kind": "selection",
+                        "start": cursor,
+                        "end": cursor,
+                    },
                     "value": text,
                     "type": "text",
-                    "blockId": self._node_id,
-                    "start": start,
-                    "end": start,
                 },
             ),
         )

{athena_python_docx-0.1.6 → athena_python_docx-0.1.8}/pyproject.toml

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

@@ -119,7 +119,7 @@ CASES: list[Case] = [
     ),
     Case(
         name="cell_text_setter",
-        description="Set cell(0,0).text on a 2x2 table — known NotImplementedError in 0.1.5.",
+        description="Set cell(0,0).text on a 2x2 table — known NotImplementedError (Phase 2 stub).",
         script=(
             "t = doc.add_table(rows=2, cols=2)\n"
             't.cell(0, 0).text = "A1"'

{athena_python_docx-0.1.6 → athena_python_docx-0.1.8}/tests/fidelity/runner.py

@@ -128,6 +128,10 @@ import os
 import traceback
 from pathlib import Path
 
+import docx as _docx_mod
+print(f"[sandbox] athena-python-docx __version__ = {{_docx_mod.__version__}}")
+print(f"[sandbox] loaded from {{_docx_mod.__file__}}")
+
 OUT_DIR = Path("/tmp/fidelity_out")
 OUT_DIR.mkdir(parents=True, exist_ok=True)
 ASSET_ID = {asset_id!r}
@@ -295,6 +299,24 @@ async def run_daytona_batch(cases: list[Case], asset_id: str) -> tuple[list[dict
     print(f"[fidelity] sandbox {sandbox.id} started")
 
     try:
+        # Upload the latest-built athena-python-docx wheel so the sandbox runs
+        # whichever version is currently in dist/, not the one baked into the
+        # image. This keeps the fidelity harness honest during SDK iteration.
+        wheel_dir = _SDK_ROOT / "dist"
+        wheels = sorted(wheel_dir.glob("athena_python_docx-*.whl"))
+        if wheels:
+            latest_wheel = wheels[-1]
+            await sandbox.fs.upload_file(
+                latest_wheel.read_bytes(),
+                f"/tmp/{latest_wheel.name}",
+            )
+            install_cmd = f"pip install --quiet --force-reinstall --no-deps /tmp/{latest_wheel.name}"
+            install_res = await sandbox.process.exec(install_cmd, timeout=120)
+            print(
+                f"[fidelity] installed {latest_wheel.name} "
+                f"(exit={install_res.exit_code})",
+            )
+
         script = build_sandbox_script(cases, asset_id)
         await sandbox.fs.upload_file(script.encode(), "/tmp/fidelity_runner.py")
         exec_result = await sandbox.process.exec(
@@ -302,6 +324,12 @@ async def run_daytona_batch(cases: list[Case], asset_id: str) -> tuple[list[dict
             timeout=600,
         )
         print(f"[fidelity] sandbox exit_code={exec_result.exit_code}")
+        # Surface sandbox stdout so [sandbox] diagnostics are visible in the log.
+        sandbox_stdout = getattr(exec_result, "result", None) or ""
+        if sandbox_stdout:
+            print("─── sandbox stdout ─────────────────────────────────")
+            print(sandbox_stdout)
+            print("────────────────────────────────────────────────────")
         # Load the results JSON
         raw = await sandbox.fs.download_file("/tmp/fidelity_results.json")
         results: list[dict] = json.loads(raw.decode())
@@ -341,7 +369,10 @@ def print_scorecard(
     """Print a scorecard. Return exit code (0 = all green)."""
     print()
     print("=" * 88)
-    print("FIDELITY SCORECARD — athena-python-docx 0.1.5 vs stock python-docx")
+    from docx import __version__ as _sdk_version
+    print(
+        f"FIDELITY SCORECARD — athena-python-docx {_sdk_version} vs stock python-docx",
+    )
     print("=" * 88)
 
     by_name = {r["name"]: r for r in daytona_results}