athena-python-docx 0.41.0__tar.gz → 0.42.1__tar.gz

{athena_python_docx-0.41.0 → athena_python_docx-0.42.1}/AGENTS.md

@@ -1080,6 +1080,20 @@ architecture or a DOCX Studio constraint:
   name the document lacks raises `KeyError` unless docx-studio holds Word's
   definition of it (`BUILTIN_CHARACTER_STYLE_NAMES` in
   `docx/styles/_table.py`: `"Strong"`, `"Intense Emphasis"`, `"Book Title"`…).
+  A character style the uploaded file's runs name without defining it (a
+  generator's links naming `Hyperlink`) reads as the default character
+  style, as python-docx reads it, and the export leaves it undefined, so an
+  unedited download is the file (owner decision, 2026-10-26, #46935 A2).
+  The editor and the server's PDFs still draw those runs in Word's built-in
+  style, blue and underlined. docx-studio records the import's list, and a
+  format that gives a run one of those styles (`run.style = "Hyperlink"`):
+  from then on the export defines it, as Word adds a style's definition when
+  it is applied, and `Info`'s `undefinedRunStyleIds` no longer lists it, so
+  every session reads its runs as the built-in; the SDK asks `Info` again
+  after such a write. An edit in the editor that copies such a run (a paste,
+  the format painter) leaves the style undefined. A room imported before
+  the record (no `undefinedRunStyleIds`) reads them as the built-in and its
+  export adds the definition, as before.
   `Document.add_table(style=)` and `Paragraph.add_run(style=)` resolve the
   style before creating anything, so a rejected style leaves the document
   untouched; python-docx raises after adding the table or run to its
@@ -1258,6 +1272,30 @@ architecture or a DOCX Studio constraint:
   changes; the owner may overrule it. Recorded in
   `tests/parity/intentional_deviations.json` (`live_deviations`).
 
+- **The inner link of a nested link reads with its text.** A `w:hyperlink`
+  inside another (the duplicate wrapper Word writes around a pasted link,
+  each with a relationship of its own; 3 of 6,826 customer uploads) reads
+  its inner link's runs in `Hyperlink.runs` / `text`, `Paragraph.text` and
+  `iter_inner_content()`, as Word shows them; upstream reads only a link's
+  own `w:r` children, so the inner text is invisible to it and
+  `p.text = p.text.replace(...)` would delete it unseen. The same choice as
+  inline wrappers and tracked changes. Owner decision, 2026-10-26 (#46935,
+  A1). Recorded in `tests/parity/intentional_deviations.json`
+  (`live_deviations`) with the synthetic fixture `hyperlinks-nested`.
+
+- **An emoji written as `w16se:symEx` reads as its run's text.** Word 2016
+  writes an emoji as the run's `mc:AlternateContent`: an `mc:Choice
+  Requires="w16se"` holding `w16se:symEx` (its font and character), and an
+  `mc:Fallback` holding a `w:t` of the emoji (1 of 6,826 customer uploads).
+  `Run.text`, `iter_inner_content()` and the paragraph's text hold the emoji,
+  as Word shows it; upstream reads only a run's own `w:t` children and reads
+  `""`, so a script rewriting the paragraph would delete the emoji unseen.
+  An edited paragraph's export writes the emoji in a plain `w:t`, without
+  the `w16se:symEx` choice, so upstream then reads it there too. Owner
+  decision, 2026-10-26 (#46935, A5). Recorded in
+  `tests/parity/intentional_deviations.json` (`live_deviations`) with the
+  synthetic fixture `symbols-emoji-alternate-content`.
+
 - **Two things a source writes that the model holds otherwise read as the
   model holds them** (2026-10-22 SDK live parity run over 398 customer
   documents). Each is recorded in
@@ -1434,6 +1472,22 @@ architecture or a DOCX Studio constraint:
   exported file. Against a docx-studio that predates `fieldRun` reads, a
   field reads as no runs and no text, as before (`tests/test_field_runs.py`).
 
+- **A header or footer run holding text beside a whole field reads as more
+  runs.** A generator writes a page number as one `w:r` holding `Page ` and a
+  `PAGE` field's begin, code, separate and end characters (1 of 6,826
+  customer uploads). Upstream reads one run, `Page `. The import cuts that
+  `w:r` into a run of the text and the field's own run (and a run of any text
+  after the field; `RunParseOptions.cutRunsAtFields`), so the paragraph's
+  text reads as upstream's and the editor and the server's PDFs draw it;
+  before, the field took the whole run and the text was lost, from the reads
+  and from an edited footer's export. `paragraph.runs` holds the extra runs,
+  and an edited paragraph's export writes them as runs of their own: a
+  cosmetic run split. A body run of that shape is still read the old way, as
+  its room stores what its import read. Owner decision, 2026-10-26 (#46935,
+  A4). Recorded in `tests/parity/intentional_deviations.json`
+  (`live_deviations`) with the synthetic fixture
+  `footers-text-and-field-one-run`.
+
 - **A run that holds a page number block refuses a tracked whole-run format
   and two text writes.** A page number block (`w:pgNum`) reads as a run with
   no text, and a run that holds text and blocks (or two blocks) reads as

{athena_python_docx-0.41.0 → athena_python_docx-0.42.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: athena-python-docx
-Version: 0.41.0
+Version: 0.42.1
 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.41.0 → athena_python_docx-0.42.1}/docx/__init__.py

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

{athena_python_docx-0.41.0 → athena_python_docx-0.42.1}/docx/_buffer.py

@@ -29,6 +29,7 @@ alive.
 from __future__ import annotations
 
 import copy
+import dataclasses
 import json
 import sys
 import threading
@@ -58,6 +59,7 @@ from docx.errors import DocxError, DocxUnsupportedCommandError, FlushAllError
 def _apply_proxy_id_rewrites(
     results: list[Any],
     proxy_id_refs: "dict[str, list[tuple[object, str]]]",
+    resolved: "dict[str, str] | None" = None,
 ) -> None:
     """Walk ``results`` and rewrite registered proxy ids from client UUIDs
     to the real DOCX Studio ids the applier echoed back.
@@ -79,7 +81,7 @@ def _apply_proxy_id_rewrites(
     ``clientIdMap`` rewrite still resolves them server-side on the
     *next* call.
     """
-    if not proxy_id_refs:
+    if not proxy_id_refs and resolved is None:
         return
     for result in results:
         if not isinstance(result, dict):
@@ -92,6 +94,8 @@ def _apply_proxy_id_rewrites(
             real = result.get(real_key)
             if not (isinstance(cli, str) and isinstance(real, str)):
                 continue
+            if resolved is not None:
+                resolved[cli] = real
             refs = proxy_id_refs.pop(cli, [])
             for proxy, attr in refs:
                 try:
@@ -104,6 +108,44 @@ def _apply_proxy_id_rewrites(
                     pass
 
 
+_MINTED_ID_FIELDS: frozenset[str] = frozenset({"client_node_id", "client_entity_id"})
+
+
+def _with_resolved_ids(value: Any, resolved: "dict[str, str]") -> Any:
+    """``value`` with every string that is a client id in ``resolved`` swapped
+    for its real id; the same object when nothing changed."""
+    if isinstance(value, str):
+        return resolved.get(value, value)
+    if isinstance(value, dict):
+        out = {k: _with_resolved_ids(v, resolved) for k, v in value.items()}
+        return value if all(out[k] is value[k] for k in value) else out
+    if isinstance(value, list):
+        items = [_with_resolved_ids(v, resolved) for v in value]
+        return value if all(a is b for a, b in zip(items, value)) else items
+    return value
+
+
+def _resolve_client_ids(cmd: Command, resolved: "dict[str, str]") -> None:
+    """Point ``cmd`` at the real ids of the creates an earlier batch landed.
+
+    A proxy's own id is rewritten when its create's batch returns, but a copy
+    of the client id taken before then (a ``Run``'s paragraph id, the id
+    ``add_paragraph`` promotes to a list item) still names the client id. Only
+    the docx-studio pod that applied the create can resolve that id when the
+    replicas share no client-id map, so a later batch that reaches another pod
+    fails with ``block "p_…" not found``.
+    """
+    if not resolved or not dataclasses.is_dataclass(cmd):
+        return
+    for f in dataclasses.fields(cmd):
+        if f.name in _MINTED_ID_FIELDS:
+            continue
+        value = getattr(cmd, f.name)
+        new = _with_resolved_ids(value, resolved)
+        if new is not value:
+            setattr(cmd, f.name, new)
+
+
 _WRITES_UNAPPLIED = "_docx_writes_unapplied"
 
 
@@ -551,6 +593,10 @@ class CommandBuffer:
         # ``add_heading`` / etc. when they queue a Create with a
         # client-assigned id. Drained on every flush.
         self._proxy_id_refs: dict[str, list[tuple[object, str]]] = {}
+        # client id → real id of every create a batch landed, so a command
+        # that still names a client id is sent with the real one
+        # (:func:`_resolve_client_ids`).
+        self._resolved_client_ids: dict[str, str] = {}
         # The last command's ``GetNodeById`` key, result and time, while
         # nothing has been sent or buffered after it (see :meth:`call`), for a
         # docx-studio that gives no version.
@@ -866,6 +912,7 @@ class CommandBuffer:
                 user = None if self._user is None else dict(self._user)
             version = self._version_request()
             sent_at = _now()
+            self._resolve_drained(cmds)
             try:
                 outcome = self._client.execute_batch(
                     self._asset_id,
@@ -944,6 +991,7 @@ class CommandBuffer:
         proxy's ``_node_id`` in-place.
         """
         self.ensure_usable()
+        _resolve_client_ids(cmd, self._resolved_client_ids)
         # A write whose text holds a character XML does not allow raises
         # python-docx's ValueError here, before anything is sent: every command
         # comes through, a path-proxy op's and a direct ``send_command``'s.
@@ -1073,6 +1121,7 @@ class CommandBuffer:
             self._proxy_id_refs = {}
         if not pending:
             return []
+        self._resolve_drained(pending)
         try:
             results, _skipped_by_index = self._client.execute_batch(
                 self._asset_id,
@@ -1088,7 +1137,9 @@ class CommandBuffer:
             # batch ships REAL ids for the survivors (vs. dead client
             # UUIDs that would cascade into another "Block not found").
             # See ``_apply_proxy_id_rewrites`` for the full rationale.
-            _apply_proxy_id_rewrites(_extract_partial_results(exc), proxy_id_refs)
+            _apply_proxy_id_rewrites(
+                _extract_partial_results(exc), proxy_id_refs, self._resolved_client_ids
+            )
             _ptc_emit_end_batch(pending, is_error=True)
             _unapplied_writes(exc)
             raise
@@ -1099,7 +1150,7 @@ class CommandBuffer:
         finally:
             _forget_reads_of_others(self)
         _ptc_emit_end_batch(pending, is_error=False)
-        _apply_proxy_id_rewrites(results, proxy_id_refs)
+        _apply_proxy_id_rewrites(results, proxy_id_refs, self._resolved_client_ids)
         return results
 
     def close(self) -> None:
@@ -1126,6 +1177,14 @@ class CommandBuffer:
 
     # ----- internals -----
 
+    def _resolve_drained(self, cmds: "list[Command]") -> None:
+        """Point ``cmds``, about to be sent under ``_post_lock``, at the real
+        ids every earlier batch returned: one queued while the idle timer's
+        batch with its create was still in flight missed that id in
+        :meth:`call`."""
+        for queued in cmds:
+            _resolve_client_ids(queued, self._resolved_client_ids)
+
     def _eager_flush_with(self, cmd: Command) -> Any:
         """Drain pending + run ``cmd`` in one batch; return cmd's result.
 
@@ -1151,6 +1210,7 @@ class CommandBuffer:
             self._proxy_id_refs = {}
             writes = self._writes
         all_cmds: list[Command] = [*pending, cmd]
+        self._resolve_drained(all_cmds)
         trailing_index = len(all_cmds) - 1
         # A batch that answers a read asks for the document's version (a
         # docx-studio that predates it ignores the question).
@@ -1175,7 +1235,9 @@ class CommandBuffer:
             # ``table.cell(0, 0)`` → ``tables.get``), so a failure on
             # the trailing ``cmd`` would otherwise abandon every
             # buffered Create's rewrite at once.
-            _apply_proxy_id_rewrites(_extract_partial_results(exc), proxy_id_refs)
+            _apply_proxy_id_rewrites(
+                _extract_partial_results(exc), proxy_id_refs, self._resolved_client_ids
+            )
             _ptc_emit_end_batch([cmd], is_error=True)
             if pending:
                 self._settle_writes_of_failed_read(
@@ -1198,7 +1260,7 @@ class CommandBuffer:
         # Proxy-id rewrites still run for the buffered prefix that DID apply —
         # the trailing skip (if any) doesn't strand the supported Creates that
         # flushed alongside it.
-        _apply_proxy_id_rewrites(results, proxy_id_refs)
+        _apply_proxy_id_rewrites(results, proxy_id_refs, self._resolved_client_ids)
         # This is the AWAITED-result path: the caller is about to read the
         # trailing command's result. If the server skipped that command
         # (capability gap), there is no result to return — returning some
@@ -1260,11 +1322,13 @@ class CommandBuffer:
             # ``MAX_BATCH_COMMANDS``: those a failed request's earlier ones
             # applied keep their ids, as a flush's do, and only the rest are
             # the failure's unapplied writes.
-            _apply_proxy_id_rewrites(_extract_partial_results(again), proxy_id_refs)
+            _apply_proxy_id_rewrites(
+                _extract_partial_results(again), proxy_id_refs, self._resolved_client_ids
+            )
             _ptc_emit_end_batch(pending, is_error=True)
             raise _unapplied_writes(again) from exc
         _ptc_emit_end_batch(pending, is_error=False)
-        _apply_proxy_id_rewrites(results, proxy_id_refs)
+        _apply_proxy_id_rewrites(results, proxy_id_refs, self._resolved_client_ids)
         _as_the_read_s_own_failure(exc, failed)
 
     def _reset_timer_locked(self) -> None:

{athena_python_docx-0.41.0 → athena_python_docx-0.42.1}/docx/_http.py

@@ -141,7 +141,10 @@ def create_empty_document(
         )
 
     url: str = resolved_base.rstrip("/") + "/docs/empty"
-    body: dict[str, str] = {}
+    # The document is born as its creator's: its first write is signed as the
+    # caller, with the agent run's attributions when the script runs in one
+    # (``X-Custom-Attributions``), so the run's turn replay starts with it.
+    body: dict[str, str] = {"seedAuthor": "requester"}
     if name is not None:
         body["name"] = name
     if parent_folder_id is not None:
@@ -152,6 +155,7 @@ def create_empty_document(
     # Lazy import — _http is loaded lazily by Document.create(), so the
     # package is fully initialized by the time we reach this code.
     from docx import __version__
+    from docx._http_doc import _delegation_headers
 
     payload: bytes = json.dumps(body).encode("utf-8")
     req = urllib.request.Request(  # noqa: S310
@@ -163,6 +167,7 @@ def create_empty_document(
             "Authorization": f"Bearer {resolved_key}",
             "Accept": "application/json",
             "User-Agent": f"athena-python-docx/{__version__}",
+            **_delegation_headers(),
         },
     )
 
@@ -308,7 +313,16 @@ def upload_document(
     with open(docx_path, "rb") as f:
         file_bytes: bytes = f.read()
 
-    create_body: dict[str, str] = {"name": title}
+    # The document is born holding the uploaded file: the create seeds no
+    # template (``seed_template``), and the import below is its first write,
+    # signed as the caller with the agent run's attributions when the script
+    # runs in one (``seed_author``, ``X-Custom-Attributions``). An agora that
+    # predates both seeds the template, which the overwrite import replaces.
+    create_body: dict[str, str | bool] = {
+        "name": title,
+        "seed_author": "requester",
+        "seed_template": False,
+    }
     if parent_folder_id is not None:
         create_body["parent_folder_id"] = parent_folder_id
     if workspace_id is not None:
@@ -317,6 +331,7 @@ def upload_document(
     create_url: str = resolved_agora_base.rstrip("/") + "/api/docx-studio/assets"
 
     from docx import __version__
+    from docx._http_doc import _delegation_headers
 
     req = urllib.request.Request(  # noqa: S310
         create_url,
@@ -327,6 +342,7 @@ def upload_document(
             "Authorization": f"Bearer {resolved_key}",
             "Accept": "application/json",
             "User-Agent": f"athena-python-docx/{__version__}",
+            **_delegation_headers(),
         },
     )
 
@@ -374,6 +390,7 @@ def upload_document(
     import_body = {
         "docx_base64": base64.b64encode(file_bytes).decode("ascii"),
         "overwrite": True,
+        "seed_author": "requester",
     }
     import_req = urllib.request.Request(  # noqa: S310
         import_url,
@@ -384,6 +401,7 @@ def upload_document(
             "Authorization": f"Bearer {resolved_key}",
             "Accept": "application/json",
             "User-Agent": f"athena-python-docx/{__version__}",
+            **_delegation_headers(),
         },
     )
 

{athena_python_docx-0.41.0 → athena_python_docx-0.42.1}/docx/_http_doc.py

@@ -33,6 +33,7 @@ from __future__ import annotations
 import dataclasses
 import json
 import os
+import re
 import urllib.parse
 import warnings
 from typing import Any, TypedDict
@@ -477,6 +478,9 @@ _PARAGRAPH_TARGETING_COMMANDS: frozenset[str] = frozenset(
 )
 
 
+# The id ``Document._mint_client_node_id`` gives a node it creates.
+_SDK_MINTED_ID = re.compile(r"[a-z]+_[0-9a-f]{12}")
+
 _CELL_PARAGRAPH_HINT: str = (
     "\n\nHint: DOCX Studio 1.8.1 cannot format paragraphs nested inside "
     "table cells via SetParagraphAlignment / SetParagraphStyle / "
@@ -534,6 +538,15 @@ _TABLE_QUERY_COMMANDS: frozenset[str] = frozenset(
 )
 
 
+_SDK_CLIENT_ID_HINT: str = (
+    "\n\nHint: this id is one the SDK minted for a block it created "
+    "(``p_xxxxxxxxxxxx``), not one docx-studio assigned. The create that "
+    "minted it failed or was discarded in an earlier batch, or it belongs "
+    "to a previous execution. This is not a table-cell problem: re-read "
+    "the block (``doc.paragraphs`` / ``doc.tables``) and use the proxy it "
+    "returns, or create the block again."
+)
+
 _TABLE_CLIENT_ID_HINT: str = (
     "\n\nHint: this looks like a stale client-side table UUID "
     "(``t_xxxxxxxxxxxx``). Either an earlier batch in this execution "
@@ -882,8 +895,12 @@ def _http_post_json(
                     isinstance(cmd_type, str) and cmd_type in _PARAGRAPH_TARGETING_COMMANDS
                 )
                 table_query = isinstance(cmd_type, str) and cmd_type in _TABLE_QUERY_COMMANDS
-                if _missing_block_id(err_obj.get("message")) in header_footer_block_ids:
+                missing = _missing_block_id(err_obj.get("message"))
+                if missing in header_footer_block_ids:
                     hint = _HEADER_FOOTER_PARAGRAPH_HINT
+                elif missing is not None and _SDK_MINTED_ID.fullmatch(missing):
+                    # A block this SDK created, not a cell's own paragraph.
+                    hint = _SDK_CLIENT_ID_HINT
                 elif paragraph_targeting:
                     hint = _CELL_PARAGRAPH_HINT
                 elif table_query:

{athena_python_docx-0.41.0 → athena_python_docx-0.42.1}/docx/styles/_table.py

@@ -159,6 +159,15 @@ _latent: "weakref.WeakKeyDictionary[Any, dict[str, Any] | None]" = weakref.WeakK
 #: Each session's paragraph style ids its document's source names without
 #: defining them, as ``Info`` reports them (``undefinedStyleIds``).
 _undefined: "weakref.WeakKeyDictionary[Any, frozenset[str]]" = weakref.WeakKeyDictionary()
+#: Each session's character style ids the runs of its uploaded file name
+#: without the file defining them and no write has given a run, as ``Info``
+#: reports them (``undefinedRunStyleIds``; none from a room imported before the
+#: record): the export leaves them undefined.
+_undefined_runs: "weakref.WeakKeyDictionary[Any, frozenset[str]]" = weakref.WeakKeyDictionary()
+#: Sessions whose script gave a run one of ``_undefined_runs``: docx-studio
+#: records the write (the export defines the style from then on), so the next
+#: read of such a style asks ``Info`` again, after the write.
+_runs_restyled: "weakref.WeakSet[Any]" = weakref.WeakSet()
 
 
 def _records(info: object) -> tuple[StyleRecord, ...] | None:
@@ -229,6 +238,12 @@ def style_table(session: Any) -> tuple[StyleRecord, ...] | None:
         if isinstance(undefined_ids, list)
         else frozenset()
     )
+    undefined_run_ids: object = info.get("undefinedRunStyleIds") if isinstance(info, dict) else None
+    _undefined_runs[session] = (
+        frozenset(i for i in undefined_run_ids if isinstance(i, str))
+        if isinstance(undefined_run_ids, list)
+        else frozenset()
+    )
     _stale.discard(session)
     # A server that showed it writes styles still does once deletes leave its
     # table without the entries that told: the signal holds for the session.
@@ -577,11 +592,15 @@ def style_of(
     default style, else None.
 
     A Word built-in the document does not define reads back as that built-in,
-    as ``style_id_for`` lets it be set. A document without styles reads its
-    defaults as Word's, as python-docx's default ``styles.xml`` gives them.
-    Without a style table: the stored style as given, else Word's default.
-    The style reads the definition it was found as (its record), as
-    python-docx's wraps that ``w:style``.
+    as ``style_id_for`` lets it be set; not a character style the runs of the
+    uploaded file already named without defining it and no write has given a
+    run (``Info``'s ``undefinedRunStyleIds``), which python-docx reads as the
+    default character style and the export leaves undefined. A document
+    without styles reads its defaults as Word's,
+    as python-docx's default ``styles.xml`` gives them. Without a style table:
+    the stored style as given, else Word's default. The style reads the
+    definition it was found as (its record), as python-docx's wraps that
+    ``w:style``.
     """
     from docx.styles.style import _style_of_record
 
@@ -592,7 +611,12 @@ def style_of(
         name, style_id = builtin or (BabelFish.internal2ui(stored_style_id), stored_style_id)
         return _new_style(session, name, style_id, style_type)
     record = first_of_id(table or (), stored_style_id) if stored_style_id else None
-    if record is None and builtin is not None and _defined_builtin(style_type, builtin[1]):
+    if (
+        record is None
+        and builtin is not None
+        and _defined_builtin(style_type, builtin[1])
+        and not _file_left_undefined(session, stored_style_id, style_type)
+    ):
         return _new_style(session, *builtin, style_type)
     if record is None or record.type != style_type:
         record = default_style(table, style_type) if table else None
@@ -601,6 +625,39 @@ def style_of(
     return _style_of_record(record, session)
 
 
+def _file_left_undefined(session: Any, style_id: str | None, style_type: WD_STYLE_TYPE) -> bool:
+    """Whether ``style_id`` is a character style the uploaded file's runs name
+    without the file defining it and no write has given a run, as ``Info``
+    reports them (``undefinedRunStyleIds``): python-docx reads such a run's
+    style as the default character style, and the export leaves the style
+    undefined. After the script gave a run one of them, ``Info`` is read again
+    first (it sends the write before it), so the answer is docx-studio's
+    record, as every later session reads it."""
+    if style_type != WD_STYLE_TYPE.CHARACTER or not style_id:
+        return False
+    try:
+        if session in _runs_restyled:
+            _runs_restyled.discard(session)
+            forget_style_table(session)
+            style_table(session)
+        return style_id in _undefined_runs.get(session, frozenset())
+    except TypeError:
+        return False
+
+
+def _note_applied_run_style(session: Any, style_id: str | None, style_type: WD_STYLE_TYPE) -> None:
+    """Note that the script gives a run ``style_id``, one the uploaded file's
+    runs name undefined: docx-studio records the write if it applies, so the
+    next read of such a style asks ``Info`` again."""
+    if style_type != WD_STYLE_TYPE.CHARACTER or not style_id:
+        return
+    try:
+        if style_id in _undefined_runs.get(session, frozenset()):
+            _runs_restyled.add(session)
+    except TypeError:
+        pass
+
+
 def style_id_for(
     session: Any,
     style_or_name: object,
@@ -643,7 +700,10 @@ def style_id_for(
             f"{owner} requires str, {kind} (with ``.style_id``/``.name``), or None; "
             f"got {type(style_or_name).__name__} {style_or_name!r}",
         )
-    return None if style_id == _document_default_style_id(session, style_type) else style_id
+    if style_id == _document_default_style_id(session, style_type):
+        return None
+    _note_applied_run_style(session, style_id, style_type)
+    return style_id
 
 
 def _style_id_of_name(session: Any, requested: str, style_type: WD_STYLE_TYPE) -> str:

{athena_python_docx-0.41.0 → athena_python_docx-0.42.1}/pyproject.toml

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

@@ -140,6 +140,9 @@ class FakeDocState:
         # The paragraph style ids the document's source names without defining
         # them, as ``Info`` reports them beside the style table (``undefinedStyleIds``).
         self.undefined_style_ids: list[str] | None = None
+        # The character style ids the uploaded file's runs name without defining
+        # them, as ``Info`` reports them beside the style table (``undefinedRunStyleIds``).
+        self.undefined_run_style_ids: list[str] | None = None
         # What an older server's ``Info`` lists instead: the paragraph styles in use.
         self.paragraph_styles_in_use: list[dict] = []
         # ``docProps/core.xml`` as ``Info`` reports it (``includeCoreProperties``):
@@ -254,6 +257,8 @@ class FakeDocState:
                     info["latentStyles"] = self.latent_styles
                 if "styleTable" in info and self.undefined_style_ids is not None:
                     info["undefinedStyleIds"] = list(self.undefined_style_ids)
+                if "styleTable" in info and self.undefined_run_style_ids is not None:
+                    info["undefinedRunStyleIds"] = list(self.undefined_run_style_ids)
                 if (params or {}).get("includeCoreProperties") and self.core_properties is not None:
                     info["coreProperties"] = dict(self.core_properties)
                     if self.core_properties_default:

{athena_python_docx-0.41.0 → athena_python_docx-0.42.1}/tests/live/fixture_scripts.py

@@ -417,6 +417,16 @@ FIXTURE_SCRIPTS: list[FixtureScript] = [
             "caption.runs[4].italic = True\n"
         ),
     ),
+    FixtureScript(
+        # A run added to a footer paragraph whose one run holds "Page " and a
+        # whole PAGE field: python-docx appends a w:r after it; the SDK adds
+        # its run after the field, and the export writes the edited paragraph
+        # with the text, the field and the new run each a run of its own (the
+        # recorded run split, #46935 item A4), keeping "Page ".
+        name="fixture-footers-text-and-field-one-run-writes",
+        fixture="footers-text-and-field-one-run",
+        script=('doc.sections[0].footer.paragraphs[0].add_run(" (draft)")\n'),
+    ),
     FixtureScript(
         # Run writes in a header whose style turns bold on and a footer whose
         # fields are each written whole in one run, read back one `w:r` at a
@@ -711,6 +721,75 @@ FIXTURE_SCRIPTS: list[FixtureScript] = [
             'last.header.paragraphs[0].add_run(" (revised)")\n'
         ),
     ),
+    FixtureScript(
+        # Runs added to the paragraphs that anchor a VML and a DrawingML text
+        # box whose text is not wrapped, and a paragraph added after them:
+        # python-docx writes the runs after the boxes' runs and keeps the
+        # boxes as they are, as does the SDK.
+        name="fixture-textboxes-no-wrap-writes",
+        fixture="textboxes-no-wrap",
+        script=(
+            'doc.paragraphs[0].add_run(" (anchor kept)").bold = True\n'
+            'doc.paragraphs[2].add_run(" (second anchor kept)")\n'
+            'doc.add_paragraph("A paragraph added after the boxes.")\n'
+        ),
+    ),
+    FixtureScript(
+        # Writes to the header row of a table that names a style and has no
+        # w:tblLook, which Word reads by its default look: the cells' text,
+        # a run added and one made italic, a paragraph added to a header cell
+        # and a row added. python-docx writes none of the style's bold as the
+        # runs' own and no look, nor does the SDK.
+        name="fixture-tables-default-look-writes",
+        fixture="tables-default-look",
+        script=(
+            "table = doc.tables[0]\n"
+            'table.cell(0, 1).text = "Summary"\n'
+            'table.cell(0, 0).paragraphs[0].add_run(" (code)")\n'
+            "table.cell(0, 2).paragraphs[0].runs[0].italic = True\n"
+            'table.cell(0, 2).add_paragraph("Region")\n'
+            "row = table.add_row()\n"
+            'row.cells[0].text = "Delta"\n'
+        ),
+    ),
+    FixtureScript(
+        # Writes to a table merged the legacy way (w:hMerge), which python-docx
+        # reads as written, each w:tc its own cell: text added after the
+        # nested table of a merge's first cell, a merge's first cell and a
+        # cell that continues it rewritten, bold on a row's runs, and a row
+        # added. The export writes each cell's w:hMerge back, as python-docx
+        # keeps it.
+        name="fixture-tables-horizontal-merges-writes",
+        fixture="tables-horizontal-merges",
+        script=(
+            "table = doc.tables[0]\n"
+            'table.cell(0, 0).paragraphs[-1].add_run("Issued")\n'
+            'table.cell(2, 0).text = "Merged text rewritten"\n'
+            'table.cell(2, 1).text = "Continued"\n'
+            "for run in table.cell(1, 3).paragraphs[0].runs:\n"
+            "    run.bold = True\n"
+            "row = table.add_row()\n"
+            'row.cells[0].text = "Beta"\n'
+        ),
+    ),
+    FixtureScript(
+        # Writes to tables whose rows of one cell set no span in a grid of two
+        # columns: python-docx reads such a row's one cell as written, and
+        # writes it so; a row added after one, and a column added, as
+        # python-docx adds them (a w:tc in every row).
+        name="fixture-tables-implied-span-writes",
+        fixture="tables-implied-span",
+        script=(
+            "form = doc.tables[0]\n"
+            'form.rows[2].cells[0].text = "Reviewed"\n'
+            'form.rows[4].cells[0].paragraphs[0].add_run(" (internal)")\n'
+            'form.rows[5].cells[1].text = "Closed"\n'
+            "closing = doc.tables[1]\n"
+            "row = closing.add_row()\n"
+            'row.cells[0].text = "Total"\n'
+            "closing.add_column(Pt(72))\n"
+        ),
+    ),
     FixtureScript(
         # Writes to a footer part written with a header's root element and to
         # a header part written with a footer's: python-docx edits the part's