rdocx Python: the cost of an edit grows with styles.xml, the body and the cell's place in the table (filling a table is quadratic) #437

"""Case 1: an edit costs time in proportion to styles.xml. The same one-table document is opened with its own
styles part (6 KB) and with 2000 unused paragraph styles added (419 KB). Each edit should cost about the same in
both. Builds its own input with rdocx and zipfile."""
import io, sys, time, zipfile
import rdocx

LIMIT = 3.0  # allowed ratio between the large and the small styles part


def ms(fn, n):
    t0 = time.perf_counter()
    for i in range(n):
        fn(i)
    return 1000 * (time.perf_counter() - t0) / n


def with_styles(data, n):
    zin, out = zipfile.ZipFile(io.BytesIO(data)), io.BytesIO()
    extra = "".join(
        f'<w:style w:type="paragraph" w:customStyle="1" w:styleId="Extra{i}"><w:name w:val="Extra {i}"/>'
        f'<w:basedOn w:val="Normal"/><w:pPr><w:spacing w:after="{i}"/></w:pPr>'
        f'<w:rPr><w:sz w:val="{20 + i % 10}"/></w:rPr></w:style>' for i in range(n)).encode()
    with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as z:
        for item in zin.infolist():
            x = zin.read(item.filename)
            if item.filename == "word/styles.xml":
                x = x.replace(b"</w:styles>", extra + b"</w:styles>")
            z.writestr(item, x)
    return out.getvalue()


def document(styles):
    doc = rdocx.Document()
    doc.add_paragraph("Intro text")
    table = doc.add_table(3, 6)
    for r in range(3):
        for c in range(6):
            table.cell(r, c).text = f"r{r}c{c}"
    return rdocx.Document.from_bytes(with_styles(doc.to_bytes(), styles))


OPS = {
    "run.text = ...": lambda d, i: setattr(d.paragraphs[0].runs[0], "text", f"Intro {i}"),
    "try_replace_text": lambda d, i: d.try_replace_text(f"r0c{i % 3}", f"r0c{i % 3}"),
    "table.add_row()": lambda d, i: d.tables[0].add_row(),
    "table.clone_row(1)": lambda d, i: d.tables[0].clone_row(1),
    "cell paragraph alignment": lambda d, i: setattr(d.tables[0].cell(0, 5).paragraphs[0], "alignment", i % 2),
}
sizes = [len(zipfile.ZipFile(io.BytesIO(document(n).to_bytes())).read("word/styles.xml")) for n in (0, 2000)]
print(f"styles.xml: {sizes[0]} bytes, then {sizes[1]} bytes")
failed = False
for name, op in OPS.items():
    small, large = (ms(lambda i: op(d, i), 10) for d in (document(0), document(2000)))
    ratio = large / small
    if ratio <= LIMIT:
        print(f"PASS {name}: {small:.1f} ms, then {large:.1f} ms a call (x{ratio:.1f})")
    else:
        failed = True
        print(f"FAIL {name} grows with styles.xml: got {small:.1f} ms, then {large:.1f} ms a call "
              f"(x{ratio:.1f}), expected at most x{LIMIT:.0f}")
sys.exit(1 if failed else 0)

"""Case 2: a setter reached through a table cell's paragraph or run costs time in proportion to the cell's place
in the table and to the body around the table. The same setter on a body paragraph is constant. Builds its own
input with rdocx: a 40 x 6 table, then 2000 body paragraphs after it."""
import sys, time
import rdocx
from rdocx.shared import Pt

LIMIT = 3.0  # allowed ratio between the two sides of each check


def ms(fn, n=3):
    t0 = time.perf_counter()
    for i in range(n):
        fn(i)
    return 1000 * (time.perf_counter() - t0) / n


def document(body):
    doc = rdocx.Document()
    doc.add_paragraph("Intro text")
    table = doc.add_table(40, 6)
    for r in range(40):
        for c in range(6):
            table.cell(r, c).text = f"r{r}c{c}"
    for i in range(body):
        doc.add_paragraph(f"Body paragraph {i} with a few words.")
    doc.add_style("TT", based_on="Normal", font_size=Pt(9))
    return doc


SETTERS = {
    "paragraph.alignment": lambda p, i: setattr(p, "alignment", i % 2),
    "paragraph.style": lambda p, i: setattr(p, "style", "TT" if i % 2 else "Normal"),
    "runs[0].font.size": lambda p, i: setattr(p.runs[0].font, "size", Pt(9 + i % 2)),
}
failed = False


def check(what, small, large):
    global failed
    ratio = large / small
    if ratio <= LIMIT:
        print(f"PASS {what}: {small:.1f} ms, then {large:.1f} ms (x{ratio:.1f})")
    else:
        failed = True
        print(f"FAIL {what}: got {small:.1f} ms, then {large:.1f} ms (x{ratio:.1f}), expected at most x{LIMIT:.0f}")


doc = document(0)
body = ms(lambda i: setattr(doc.paragraphs[0], "alignment", i % 2), 20)
print(f"body paragraph alignment: {body:.2f} ms a call")
for name, setter in SETTERS.items():
    first = ms(lambda i: setter(doc.tables[0].cell(0, 5).paragraphs[0], i))
    last = ms(lambda i: setter(doc.tables[0].cell(39, 5).paragraphs[0], i))
    check(f"{name} in cell (39, 5) against cell (0, 5)", first, last)
# One untimed call on each document first, so both sides time warm calls.
ms(lambda i: setattr(doc.tables[0].cell(0, 5).paragraphs[0], "alignment", i % 2), 1)
alone = ms(lambda i: setattr(doc.tables[0].cell(0, 5).paragraphs[0], "alignment", i % 2))
big = document(2000)
ms(lambda i: setattr(big.tables[0].cell(0, 5).paragraphs[0], "alignment", i % 2), 1)
around = ms(lambda i: setattr(big.tables[0].cell(0, 5).paragraphs[0], "alignment", i % 2))
check("paragraph.alignment in cell (0, 5) with 2000 body paragraphs against none", alone, around)
sys.exit(1 if failed else 0)

"""Case 3: filling a table cell by cell costs time in the square of its cells. A paragraph style is set on every
cell paragraph of a fresh table, one call per cell. The time per call should not depend on the table's size.
Builds its own input with rdocx."""
import sys, time
import rdocx
from rdocx.shared import Pt

LIMIT = 2.0  # allowed ratio of the time per call between the 120-cell and the 30-cell table


def per_call(rows):
    doc = rdocx.Document()
    doc.add_paragraph("Intro text")
    doc.add_table(rows, 6)
    doc.add_style("TT", based_on="Normal", font_size=Pt(9))
    cells = [(r, c) for r in range(rows) for c in range(6)]
    t0 = time.perf_counter()
    for r, c in cells:
        doc.tables[0].cell(r, c).paragraphs[0].style = "TT"
    seconds = time.perf_counter() - t0
    print(f"{len(cells):3} cells: {1000 * seconds / len(cells):5.1f} ms per call, {seconds:5.2f} s for the table")
    return seconds / len(cells)


small, large = per_call(5), per_call(20)
ratio = large / small
if ratio <= LIMIT:
    print(f"PASS time per call is flat: x{ratio:.1f} from 30 to 120 cells")
    sys.exit(0)
print(f"FAIL time per call grows with the table: got x{ratio:.1f} from 30 to 120 cells, expected at most x{LIMIT:.0f}")
sys.exit(1)