scripts/15_caption_split.py

"""Split a caption from its body (Arthur, 2026-09-25: "i think we should always split, even when in the same paragraph ...
5. Bananas You told me I love bananas (pay attention where there isnt a period but there is an extra space or something,
like a capitzalized item) ... mark all unreviewed"). Supersedes 1-ce-5 rubric fork F5 (A: caption + unmarked paragraph
one record); follows F12 (B) and "1. Bananas." / "I love bananas" -> 1 / 1-paragraph.

A content row splits in two when its SOT text opens with a marker and a caption:
  marker   "5.", "5.1", "(a)", "Section 5", "Article IV", "A." ...
  caption  1 to 16 words right after the marker, title case or capitals (short words of / and / the ... allowed inside),
           ending at the first of: a word ending with "." or ":" (not an abbreviation: U.S., Inc., No., Co. ...), a line break
           or 2+ spaces in the source, or a word that opens a sentence (The, This, Each, If, You, Such, Subject ...) when the
           caption already has a word; never a caption that itself opens with such a word ("5. The Company shall ...")
  body     at least 4 words, starting with a capital, a quote or a bracket
The caption row keeps the row (its marker, level, id); the body row is new: full_marker "<marker>-paragraph", the same level
(markers.py: "2-paragraph -> 1"), row_id "<row_id>#body". Both lose their review and get code_edit {what: caption_split}
(the viewer's "caption split by code" flag, heinous, until reviewed). Ranges are cut where the caption's last word ends in
the source; a row whose SOT text and source text disagree before that point is not split: it gets caption_check (the
viewer's "caption glued to its body" flag) for Arthur to split by hand.
Writes a backup (/tmp/sot_provisioned.before_caption_split.jsonl) before changing claude_run/NEW/sot_provisioned.jsonl.
Usage: uv run python claude_run/NEW/scripts/15_caption_split.py [--dry-run] [--show N]
"""
import argparse
import copy
import json
import re
import shutil
from collections import Counter, defaultdict
from datetime import datetime, timezone
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
MARKER = re.compile(r"^\s*((?:section|article)\s+[0-9IVXLCivxlc]+(?:\.\d+)*[.:]?|\(?[0-9]{1,3}(?:\.[0-9]+)*[.)]|\(?[A-Za-z]{1,2}[.)]|\([0-9A-Za-z]{1,5}\)|[IVXLC]{1,6}\.)(?=\s)", re.I)
SMALL = {"of", "and", "the", "to", "in", "for", "on", "or", "a", "an", "with", "by", "&", "-", "–", "—", "/", "under", "upon", "from", "at", "as", "its", "their", "no"}
OPENERS = {"The", "This", "These", "That", "Those", "Each", "Any", "All", "If", "In", "On", "Upon", "Subject", "Notwithstanding", "Except", "For", "Such",
           "It", "You", "We", "Our", "Your", "I", "Unless", "Within", "During", "Without", "At", "By", "To", "As", "When", "Where", "There", "Neither",
           "Nothing", "Either", "Both", "Following", "Prior", "After", "Before", "From", "Following", "Company", "Executive", "Employee", "Employer",
           "Borrower", "Lender", "Seller", "Buyer", "Purchaser", "Consultant", "Participant", "Licensee", "Licensor", "Tenant", "Landlord", "He", "She", "They",
           "Should", "Shall", "May", "Will", "Whereas"}
# a capitalised word that always opens a sentence, even inside what looked like a caption ("G. Bankruptcy If Tenant ...")
ALWAYS = {"The", "This", "These", "That", "Each", "If", "Subject", "Notwithstanding", "Except", "It", "You", "We", "Unless", "During",
          "Neither", "Nothing", "Such", "When", "Where", "There", "Should", "Shall", "May", "Will", "Whereas"}   # not Without / In / Upon: "Termination Without Cause"
ABBREV = re.compile(r"^(?:[A-Z]\.){1,3}$|^(?:U\.S\.|Inc\.|No\.|Co\.|Corp\.|Ltd\.|L\.P\.|LLC\.|Mr\.|Ms\.|Dr\.|St\.|vs\.|v\.|etc\.|Sec\.|Art\.)$")
TRANS = str.maketrans({"“": '"', "”": '"', "‘": "'", "’": "'", " ": " "})


def caption_cut(text):
    """(number of words, marker included, that make marker + caption) or None, on text as the source has it."""
    m = MARKER.match(text)
    if not m: return None
    words = [(w.group(), w.start(), w.end()) for w in re.finditer(r"\S+", text)]
    nm = len(re.findall(r"\S+", m.group(1)))   # words of the marker itself ("Section 5" is two)
    if len(words) < nm + 5: return None
    def caption_like(k):
        bare = words[k][0].strip("\"'()[]*,;.:")
        return bool(bare) and (bare[:1].isupper() or bare[:1].isdigit() or bare.lower() in SMALL)
    def runs_to_period(k):
        """a caption that goes on past k (a line break, extra space or colon inside it): the words after k up to a
        period within 8 words are all caption-like -> the index of the word the caption ends with, else None"""
        for j in range(k + 1, min(len(words), k + 9)):
            w = words[j][0]
            if w in (".", ":"): return j
            if not caption_like(j): return None
            if w.endswith(".") and not ABBREV.match(w): return j
        return None
    def opens_sentence(k):   # "Company shall", "The Executive": an opener followed by a lower-case word that is not a short word
        bare = words[k][0].strip("\"'()[]*,;")
        nxt = words[k + 1][0].strip("\"'()[]*,;") if k + 1 < len(words) else ""
        return bare in OPENERS and (bare in ALWAYS or (nxt[:1].islower() and nxt.lower() not in SMALL))
    cap = []; k = nm
    while k < len(words):
        w, s, e = words[k]; bare = w.strip("\"'()[]*,;")
        if w in (".", ":") and cap: cap.append(k); break   # "Cause ." : a period after a space ends the caption
        if not bare: return None
        if not cap and (opens_sentence(k) or w.startswith(('"', "“"))): return None   # a sentence or a defined term, no caption
        if cap and (bare in ALWAYS or (opens_sentence(k) and k + 1 < len(words) and words[k + 1][0][:1].islower())): break   # a sentence opens here
        if not caption_like(k): return None
        cap.append(k)
        if len(cap) > 16: return None
        gap = text[e:words[k + 1][1]] if k + 1 < len(words) else ""
        ends = (w.endswith((".", ":")) and not ABBREV.match(w)) or "\n" in gap or "  " in gap.replace("\t", "  ")
        if ends:
            more = runs_to_period(k) if (w.endswith(":") or not w.endswith(".")) else None
            if more is None: break
            cap += list(range(k + 1, more + 1)); k = more; break
        k += 1
    else:
        return None
    if len(cap) > 17: return None
    last = cap[-1]
    if last + 1 >= len(words): return None
    body = words[last + 1:]
    if len(body) < 4 or not re.match(r"[A-Z\"'“(\[]", body[0][0]): return None
    capw = [x for x in (words[k][0].strip("\"'()[]*,;.:") for k in cap) if x]
    if not capw or capw[-1].lower() in SMALL: return None   # "Should the" / "Underwriter and the": a sentence, not a caption
    big = [w for w in capw if w.lower() not in SMALL]
    if not big or sum(1 for w in big if w[:1].isupper() or w[:1].isdigit()) < len(big): return None
    return last + 1   # words 0..last are marker + caption


def words_of(s):
    return [w.translate(TRANS) for w in re.findall(r"\S+", s)]


def main():
    ap = argparse.ArgumentParser(); ap.add_argument("--dry-run", action="store_true"); ap.add_argument("--show", type=int, default=0); a = ap.parse_args()
    path = ROOT / "sot_provisioned.jsonl"; texts = json.loads((ROOT / "viewer/data/texts.json").read_text())
    rows = [json.loads(l) for l in path.open() if l.strip()]
    at = datetime.now(timezone.utc).isoformat(timespec="seconds"); stats = Counter(); shown = 0; out = []; by_doc = defaultdict(list)
    for r in rows:
        if r.get("is_garbage") or not r.get("segment_text") or str(r.get("full_marker") or "").endswith("paragraph"): out.append(r); continue
        n = caption_cut(r["segment_text"])
        if n is None: out.append(r); continue
        t = texts.get(r["document_id"]); a0, b0 = r["source"]["ranges"][0]["start"], r["source"]["ranges"][-1]["end"]
        src = t[a0:b0] if t else ""
        cw = words_of(r["segment_text"]); cap_c = "".join(cw[:n])
        pos = [i for i, ch in enumerate(src) if not ch.isspace()]; src_c = "".join(src[i] for i in pos).translate(TRANS)
        if not src_c.startswith(cap_c) or len(src_c) <= len(cap_c):
            r = copy.deepcopy(r); r["caption_check"] = {"caption": " ".join(cw[:n]), "why": "caption found in the SOT text, but the source text differs before it: split by hand", "at": at}
            out.append(r); stats["flagged"] += 1; continue
        cap_end = a0 + pos[len(cap_c) - 1] + 1; body_start = a0 + pos[len(cap_c)]
        sm = list(re.finditer(r"\S+", r["segment_text"])); s_cap = r["segment_text"][:sm[n - 1].end()]; s_body = r["segment_text"][sm[n].start():]
        old = {k: r.get(k) for k in ("segment_text", "full_marker", "level")} | {"ranges": r["source"]["ranges"]}
        edit = {"what": "caption_split", "at": at, "why": "a caption is always its own unit (Arthur, 2026-09-25)", "old": old}
        c = copy.deepcopy(r); c.pop("review", None); c.pop("caption_check", None)
        c["segment_text"] = s_cap; c["literal"] = t[a0:cap_end]; c["source"] = {**c["source"], "ranges": [{"start": a0, "end": cap_end}]}
        c["code_edit"] = (c.get("code_edit") or []) + [edit]
        body = copy.deepcopy(c); body["row_id"] = f"{r['row_id']}#body"; body["segment_text"] = s_body; body["literal"] = t[body_start:b0]
        body["source"] = {**body["source"], "ranges": [{"start": body_start, "end": b0}]}
        fm = r.get("full_marker"); body["full_marker"] = f"{fm}-paragraph" if fm else None
        if body.get("path_id"): body["path_id"] = f"{body['path_id']}-paragraph"
        out += [c, body]; stats["split"] += 1
        if shown < a.show: print(f"{r['row_id']:18s} [{fm}] {s_cap!r}  ||  {' '.join(s_body.split())[:70]!r}"); shown += 1
    for r in out: by_doc[r["document_id"]].append(r)
    final = []
    for d in by_doc:   # the new body rows sit right after their caption: renumber each document's order
        seq = by_doc[d]
        for k, r in enumerate(seq): r["order"] = k
        final += seq
    print(dict(stats), "rows before", len(rows), "after", len(final))
    if a.dry_run: return
    shutil.copy2(path, "/tmp/sot_provisioned.before_caption_split.jsonl")
    path.write_text("\n".join(json.dumps(r, ensure_ascii=False) for r in final) + "\n")
    print("written; backup /tmp/sot_provisioned.before_caption_split.jsonl")


if __name__ == "__main__":
    main()