DEV Community: Praveen Pasco

python-docx gave me a sentence that was never in the document

Praveen Pasco — Wed, 07 Oct 2026 11:06:08 +0000

A paragraph came back from python-docx as this:

'The sample size was  participants.'

Two spaces where a number should be. The document itself was fine. Someone had changed "forty" to "forty-two" with Track Changes on, and nobody had accepted the change yet.

So python-docx didn't give me the old sentence, and it didn't give me the new one. It gave me a third version that never existed.

I wanted to know exactly what was going on before trusting any text I pull out of a .docx again. So I built the smallest file that reproduces it, where I know the right answer in advance.

The fixture

A tracked change in WordprocessingML is just markup inside the paragraph. A deletion wraps the old run in <w:del> and stores its text in <w:delText> instead of <w:t>. An insertion wraps the new run in <w:ins>. A moved sentence shows up twice: once inside <w:moveTo> where it landed, once inside <w:moveFrom> where it used to be.

This script writes one plain paragraph, one with a changed number, and one with a sentence moved to the front. The move is the same shape as the example in Microsoft's docs for moveFrom.

from docx import Document
from docx.oxml import parse_xml

NS = 'xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"'

def run(text):
    return f'<w:r {NS}><w:t xml:space="preserve">{text}</w:t></w:r>'

def tracked(tag, rid, inner):
    return (f'<w:{tag} {NS} w:id="{rid}" w:author="Reviewer" '
            f'w:date="2026-10-06T10:00:00Z">{inner}</w:{tag}>')

doc = Document()
doc.add_paragraph("A plain paragraph with no revisions.")

# a number changed with Track Changes on
p = doc.add_paragraph()._p
p.append(parse_xml(run("The sample size was ")))
p.append(parse_xml(tracked("del", 1, "<w:r><w:delText>forty</w:delText></w:r>")))
p.append(parse_xml(tracked("ins", 2, "<w:r><w:t>forty-two</w:t></w:r>")))
p.append(parse_xml(run(" participants.")))

# a sentence moved to the front (same shape as the spec's moveFrom example)
p = doc.add_paragraph()._p
p.append(parse_xml(tracked("moveTo", 3, '<w:r><w:t xml:space="preserve">Some moved text. </w:t></w:r>')))
p.append(parse_xml(run("Some text. ")))
p.append(parse_xml(tracked("moveFrom", 4, "<w:r><w:t>Some moved text.</w:t></w:r>")))

doc.save("tracked.docx")

Fair warning: I made this file by hand. Word writes a lot more attributes (rsids, run properties) and I haven't opened this exact file in Word. The element names are the ones from the spec, and that's all the extractors below care about.

Three ways to read it

python-docx 1.2.0:

from docx import Document

for p in Document("tracked.docx").paragraphs:
    print(repr(p.text))

'A plain paragraph with no revisions.'
'The sample size was  participants.'
'Some text. '

Both halves of the number edit are gone, and so is the moved sentence. Paragraph.text only looks at runs that are direct children of <w:p>. Everything wrapped in <w:ins>, <w:del>, <w:moveTo> or <w:moveFrom> is one level down, so it's skipped. This is a known issue. #1123 ("paragraph.text is missing text") has been open since July 2022, and #340 asked for revision support back in 2016.

The quick-and-dirty fix one commenter suggests in that thread is to skip python-docx and grab every <w:t> from the XML. Deleted text lives in <w:delText>, so it drops out:

unzip -p tracked.docx word/document.xml | grep -o '<w:t[ >][^<]*' | sed 's/<w:t[^>]*>//'

A plain paragraph with no revisions.
The sample size was 
forty-two
 participants.
Some moved text. 
Some text. 
Some moved text.

That fixes the number. But the moved sentence now appears twice, because the copy inside <w:moveFrom> uses an ordinary <w:t> too, not <w:delText>. Whether that's what you want depends on what you're doing with the text. For a word count or a diff, it isn't.

Asking for a specific view

What I actually want is to say which version I mean: the text as if every change were accepted, or as if every change were rejected. That's a short walk over the paragraph with a list of containers to skip:

import sys
import zipfile
import xml.etree.ElementTree as ET

W = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
HIDE = {"accepted": {W + "del", W + "moveFrom"},
        "original": {W + "ins", W + "moveTo"}}

def walk(el, view, out):
    for child in el:
        if child.tag in HIDE[view]:
            continue
        if child.tag in (W + "t", W + "delText"):
            out.append(child.text or "")
        elif child.tag == W + "tab":
            out.append("\t")
        elif child.tag in (W + "br", W + "cr"):
            out.append("\n")
        elif child.tag != W + "pPr":
            walk(child, view, out)

def paragraphs(path, view):
    with zipfile.ZipFile(path) as z:
        root = ET.fromstring(z.read("word/document.xml"))
    for p in root.iter(W + "p"):
        out = []
        walk(p, view, out)
        yield "".join(out)

if __name__ == "__main__":
    view = sys.argv[2] if len(sys.argv) > 2 else "accepted"
    for text in paragraphs(sys.argv[1], view):
        print(repr(text))

$ python3 revtext.py tracked.docx
'A plain paragraph with no revisions.'
'The sample size was forty-two participants.'
'Some moved text. Some text. '

$ python3 revtext.py tracked.docx original
'A plain paragraph with no revisions.'
'The sample size was forty participants.'
'Some text. Some moved text.'

Both match what I put in. Standard library only. It recurses into anything that isn't a hidden container or the paragraph properties, so text inside hyperlinks and content controls comes along too.

The check I run first now

Most of the time I don't need either view. I just need to know that a file has unresolved changes before I treat its text as final:

import sys
import zipfile
from collections import Counter
import xml.etree.ElementTree as ET

W = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
KINDS = ("ins", "del", "moveFrom", "moveTo")

with zipfile.ZipFile(sys.argv[1]) as z:
    root = ET.fromstring(z.read("word/document.xml"))

seen = Counter()
for kind in KINDS:
    for el in root.iter(W + kind):
        seen[(kind, el.get(W + "author"))] += 1

for (kind, author), n in sorted(seen.items()):
    print(f"{kind:9} {n:3}  {author}")
sys.exit(1 if seen else 0)

$ python3 has_revisions.py tracked.docx; echo "exit=$?"
del         1  Reviewer
ins         1  Reviewer
moveFrom    1  Reviewer
moveTo      1  Reviewer
exit=1

On a fresh Document() with one paragraph and no revisions it prints nothing and exits 0, so it can sit in a pipeline and fail the step.

What this doesn't handle

I'd rather list these than have someone find them the hard way:

Deleted paragraph marks. If a whole paragraph break was deleted, Word records it as <w:del> inside the paragraph's own properties (w:pPr/w:rPr). In the accepted view those two paragraphs should become one. My script skips w:pPr entirely, so it keeps them separate.
Text boxes. I haven't tested these. Reading my own code, a paragraph inside a text box would be printed twice: once as part of the paragraph whose run holds the drawing, and once on its own, because root.iter() finds it too.
Only word/document.xml. Footnotes, endnotes, headers, footers and comments live in their own parts and can carry tracked changes of their own.
Formatting changes. w:rPrChange and w:pPrChange are revisions too. They don't change the text, so neither script reports them.
The has_revisions count includes paragraph-mark insertions. Those are w:ins elements as well, so a count of 3 doesn't necessarily mean three edits you can see.
Deleted table rows. A deleted row gets an empty <w:del/> in its row properties (w:trPr), and the spec says that marker says nothing about the cells' contents, which are marked separately. My script never looks at row properties, so if the cell text isn't wrapped in its own w:del, the accepted view still prints it.

The first one is the gap I actually care about, and I haven't written it yet. If anyone has a clean way to merge paragraphs across a deleted mark without rebuilding the tree, I'd like to see it.

Tracking vendor release notes without a browser: Notion's loadPageChunk and Zendesk's edited_at

Praveen Pasco — Fri, 02 Oct 2026 05:40:06 +0000

I keep a small text file of dates: the days a few AI writing detectors swapped the model that does the scoring. The reason is boring. If someone runs the same essay through the same detector two weeks apart and gets two different numbers, the first thing I want to know is whether the model changed in between. If it did, the two numbers aren't really comparable.

Keeping that file up to date by hand meant opening a browser on two kinds of pages I can't fetch with curl. This week I finally scripted both, and each one had a small gotcha I didn't expect. Writing them down here mostly so I stop relearning them.

Problem 1: a Notion page that is all JavaScript

GPTZero publishes its model release notes as a public Notion page:

https://gptzero.notion.site/GPTZero-Release-Notes-Model-and-API-6f58686f6381498baef35212463b7da6

Fetch it with curl and you get about 20 KB of HTML whose only visible text is "Notion JavaScript must be enabled in order to use Notion. Please enable JavaScript to continue." The content is loaded afterwards by the Notion client, from an endpoint called loadPageChunk. That endpoint answers plain POSTs for public pages.

The page ID is the 32 hex characters at the end of the URL, reformatted as a dashed UUID:

raw = "6f58686f6381498baef35212463b7da6"
page_id = f"{raw[:8]}-{raw[8:12]}-{raw[12:16]}-{raw[16:20]}-{raw[20:]}"
print(page_id)  # 6f58686f-6381-498b-aef3-5212463b7da6

Then:

curl -s -X POST https://gptzero.notion.site/api/v3/loadPageChunk \
  -H 'Content-Type: application/json' \
  -d '{"pageId":"6f58686f-6381-498b-aef3-5212463b7da6","limit":100,"cursor":{"stack":[]},"chunkNumber":0,"verticalColumns":false}' \
  -o chunk.json -w "%{http_code} %{size_download}\n"

That printed 200 139532 for me. Three things tripped me up on the way there:

Leave out the Content-Type header and you get a 415. curl's default for -d is form encoding, and the endpoint wants JSON.
Python's default user agent gets a 403. The exact same request from urllib failed until I set any custom User-Agent. A plain release-note-watcher/0.1 was enough. (I checked by sending Python-urllib/3.14 from curl too. 403 again, so it's the UA string, not something else urllib does.)
Every block comes back double wrapped, as {"value": {"value": {...the block...}}}. I peel layers until I hit a dict with a type key, so the code doesn't break if they ever drop one level.

The page has 219 top-level children and limit: 100 returned 104 blocks, so you don't get everything in one call. For a changelog that's fine because the newest entries are at the top. If you need the full history there's a cursor in the response you can feed back in, but I haven't needed it.

One more surprise: the entries aren't Notion headings. Each one is a plain text block like "September 13, 2026 (2026-09-13-base, Model 4.10b aka 4o) | released on September 18, 2026", followed by bulleted items. So I match the date pattern instead of looking for header blocks:

import json
import re
import urllib.request

PAGE_ID = "6f58686f-6381-498b-aef3-5212463b7da6"
API = "https://gptzero.notion.site/api/v3/loadPageChunk"
ENTRY = re.compile(r"^[A-Z][a-z]+ \d{1,2}, \d{4} \(")  # "September 13, 2026 (..."


def load_chunk(page_id, limit=100):
    payload = {"pageId": page_id, "limit": limit, "cursor": {"stack": []},
               "chunkNumber": 0, "verticalColumns": False}
    req = urllib.request.Request(
        API,
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json",
                 "User-Agent": "release-note-watcher/0.1"},  # default UA gets a 403
    )
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.load(resp)


def unwrap(record):
    while isinstance(record, dict) and "value" in record and "type" not in record:
        record = record["value"]
    return record


def text(block):
    return "".join(seg[0] for seg in block.get("properties", {}).get("title", []))


blocks = {k: unwrap(v) for k, v in load_chunk(PAGE_ID)["recordMap"]["block"].items()}
entries = 0
for child_id in blocks[PAGE_ID]["content"]:
    block = blocks.get(child_id)
    if not block or "type" not in block:
        break  # past what this chunk returned
    line = text(block).strip()
    if block["type"] == "text" and ENTRY.match(line):
        entries += 1
        if entries > 3:
            break
        print("\n" + line)
    elif entries and block["type"] == "bulleted_list" and line:
        print("  - " + line)

Output when I ran it on 2 October 2026:

September 13, 2026 (2026-09-13-base, Model 4.10b aka 4o) | released on September 18, 2026
  - Decreased false positive rate on a variety of domains
  - Improved performance on third party benchmarks

August 12, 2026 (2026-08-09-base, Model 4.9b) | released on August 12, 2026
  - Improved recall on frontier LLMs including Claude 5, GPT 5.6, Gemini 3.6, and Grok 4.5 series models

August 1, 2026 (2026-08-01-base, Model 4.8b) | released on August 1, 2026
  - Robustness to headers; headers are now excluded from our model’s input

Fair warning: loadPageChunk is Notion's internal API, not a documented one. It works today and could change without notice. One request per run, and I only run it once a day.

The page record also has a last_edited_time. I print it, but I don't trust it as a change signal yet, because I haven't watched it long enough to know whether editing a child block bumps the page's timestamp. Hashing the text is cheap, so that's what I compare.

Problem 2: a help center behind Cloudflare, and a timestamp that lies

Turnitin's documentation lives at guides.turnitin.com. curl on any article page gets a 403 and a 5.6 KB page titled "Just a moment...". But the site is a Zendesk Help Center, and Zendesk's public Help Center API answers the same article as JSON with no fuss:

curl -s https://guides.turnitin.com/api/v2/help_center/en-us/articles/22774058814093.json \
  | python3 -c "import json,sys; a=json.load(sys.stdin)['article']; print(a['title'], a['edited_at'], a['updated_at'], len(a['body']))"

You get the full HTML body plus timestamps. And here's the part that made me rewrite my first version of this.

There are two timestamps, and the obvious one is the wrong one. updated_at sounds like "the article changed". It isn't. On the same article (it's called "Using the AI Writing Report") I pulled it around 03:44 UTC and again around 04:54 UTC. In between, updated_at went from 2026-10-02T02:57:47Z to 2026-10-02T04:23:31Z. Same body, byte for byte: 9,671 characters, same hash. Meanwhile edited_at sat at 2026-08-26T09:37:07Z both times.

It isn't one weird article either. I pulled the 100 most recently updated articles (sort_by=updated_at&sort_order=desc) at about 04:55 UTC. 21 of them had an updated_at from that same day. Zero had an edited_at from that day. The page called "Welcome to Turnitin Guides" was last edited in July 2024, and its updated_at said 04:33 UTC that morning.

Zendesk's own Help Center API reference is pretty clear once you read it closely. edited_at is "The time the article was last edited in its displayed locale", and in the sorting section, "order by the last time the title or body was edited". updated_at is just "The time the article was last updated". I don't know what keeps touching updated_at, and the docs don't say. I just stopped using it.

Bonus: sort_by=edited_at works on the list endpoint, which gives you a real "recently changed" feed:

curl -s "https://guides.turnitin.com/api/v2/help_center/en-us/articles.json?per_page=10&sort_by=edited_at&sort_order=desc" \
  | python3 -c "import json,sys; [print(a['edited_at'], a['title']) for a in json.load(sys.stdin)['articles']]"

The locale is already in the path (en-us), which the docs say edited_at sorting needs.

The whole watcher

Both sources go into one small script that keeps a state.json next to it and prints what moved since last time. Standard library only:

import hashlib
import json
import pathlib
import urllib.request

UA = {"User-Agent": "release-note-watcher/0.1"}
STATE = pathlib.Path("state.json")
ZD = "https://guides.turnitin.com/api/v2/help_center/en-us/articles/{}.json"
TURNITIN_IDS = [28294949544717, 22774058814093]


def get_json(url, payload=None):
    headers = dict(UA)
    data = None
    if payload is not None:
        headers["Content-Type"] = "application/json"
        data = json.dumps(payload).encode()
    req = urllib.request.Request(url, data=data, headers=headers)
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.load(resp)


def turnitin(article_id):
    a = get_json(ZD.format(article_id))["article"]
    body_hash = hashlib.sha256(a["body"].encode()).hexdigest()[:12]
    return {"title": a["title"], "edited_at": a["edited_at"], "body": body_hash}


def gptzero_entries():
    page_id = "6f58686f-6381-498b-aef3-5212463b7da6"
    data = get_json(
        "https://gptzero.notion.site/api/v3/loadPageChunk",
        {"pageId": page_id, "limit": 100, "cursor": {"stack": []},
         "chunkNumber": 0, "verticalColumns": False},
    )
    blocks = {}
    for key, rec in data["recordMap"]["block"].items():
        while isinstance(rec, dict) and "value" in rec and "type" not in rec:
            rec = rec["value"]
        blocks[key] = rec
    lines = []
    for child in blocks[page_id]["content"]:
        b = blocks.get(child)
        if not b or "type" not in b:
            break
        title = b.get("properties", {}).get("title", [])
        lines.append("".join(seg[0] for seg in title))
    return hashlib.sha256("\n".join(lines).encode()).hexdigest()[:12]


now = {"gptzero": gptzero_entries()}
for aid in TURNITIN_IDS:
    now[f"turnitin:{aid}"] = turnitin(aid)

old = json.loads(STATE.read_text()) if STATE.exists() else {}
for key, value in now.items():
    if key not in old:
        print(f"new    {key}: {value}")
    elif old[key] != value:
        print(f"CHANGE {key}: {old[key]} -> {value}")
    else:
        print(f"same   {key}")
STATE.write_text(json.dumps(now, indent=2))

First run:

new    gptzero: 66ddc34ba254
new    turnitin:28294949544717: {'title': 'AI writing detection model', 'edited_at': '2026-05-15T08:03:20Z', 'body': 'fbebac616689'}
new    turnitin:22774058814093: {'title': 'Using the AI Writing Report', 'edited_at': '2026-08-26T09:37:07Z', 'body': '69f666c6c94a'}

Second run, right after: three lines of same. To make sure the change path actually works and isn't just always printing same, I hand-edited one edited_at in state.json and ran it again. It printed a CHANGE line for that article and same for the other two.

The first Turnitin ID is their model changelog page. Its updated_at that morning said 30 September. Its edited_at said 15 May. If I'd been watching updated_at I would have gone and reread an article that hadn't changed in four and a half months.

What this doesn't tell you

A release note is the vendor's description, not a log of what ran on a given day. GPTZero's own notes say the new model was "released on September 18, 2026", and their blog post about the same model says it became the default for all users on September 20. If you care about one specific scan from September 19, the notes alone won't settle it.

So my text file now has two columns per change, "what the notes say" and "what I could confirm", and the second column is often empty. That still beats guessing.

If anyone knows a cleaner way to read public Notion pages than the internal endpoint, I'd like to hear it. That's the piece I trust least.