scripts/marine_rag/chunk_docs.py

#!/usr/bin/env python3
"""
chunk_docs.py — Section-aware chunking of marine_parsed VLM markdown.

Reuses the battle-tested chunker from cmip6_gpt/rag/chunk_papers.py
(noise filters, OCR-ris fixes, dedup, overlap, token budget) but assembles
a marine-specific prefix: product, document type (PUM/QUID/SQO), section path.
Images are ignored (markdown image refs are skipped by the parser).

Output: out/chunks.jsonl  — one JSON object per chunk. Resumable per md file.
"""
import hashlib
import json
import re
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parent
WS = ROOT.parent
PARSED = WS / "marine_parsed"
OUT = ROOT / "out"
CMIP6_RAG = Path("/Users/dmpantiu/cmip6/cmip6_gpt/rag")

sys.path.insert(0, str(CMIP6_RAG))
from chunk_papers import (  # noqa: E402
    parse_markdown_sections, fix_ocr_ris_stripping, clean_ui_from_text,
    is_garbage_section_path, is_figure_axis_gibberish, is_digit_heavy_garbage,
    is_boilerplate_noise, is_affiliation_fragment, is_reference_block,
    has_repeating_loop, is_url_only, chunk_text_block, add_overlap, count_tokens,
    MAX_TOKENS, MIN_QUALITY_TOKENS, MIN_TOKENS, OVERLAP_RATIO, TABLE_MAX_TOKENS,
)

DOC_TYPES = ("PUM", "QUID", "SQO")


def doc_type_of(doc_id: str) -> str:
    u = doc_id.upper()
    for t in DOC_TYPES:
        if re.search(rf"(^|[-_]){t}([-_]|$)", u) or t in u:
            return t
    return "OTHER"


def is_noise_table(tbl_text: str) -> bool:
    """Drop document-meta tables (change record, approval, acronyms) — pure noise."""
    head = "\n".join(tbl_text.lower().splitlines()[:3])
    if "description of change" in head:
        return True
    if ("validated by" in head or "checked by" in head) and ("issue" in head or "date" in head):
        return True
    if "acronym" in head and "description" in head:
        return True
    if head.count("|") >= 4 and ("abbreviation" in head and "meaning" in head):
        return True
    return False


def make_prefix(product_id: str, title: str, doc_id: str, doc_type: str, section_path: str) -> str:
    head = f'Product: "{title}" [{product_id}]' if title else f"Product: {product_id}"
    return (head + f"\nDocument: {doc_type} ({doc_id})"
            + f"\nSection: {section_path}\n---\n")


def chunk_marine_md(md_path: Path, product_id: str, title: str, doc_id: str | None = None) -> list[dict]:
    if doc_id is None:
        doc_id = md_path.stem
    doc_type = doc_type_of(doc_id)
    md_text = md_path.read_text(encoding="utf-8", errors="replace")
    sections = parse_markdown_sections(md_text)

    out: list[dict] = []
    counter = 0
    seen: set[str] = set()

    for section in sections:
        if section.paragraphs == ["__EXCLUDED__"]:
            continue
        section_path = section.path
        if is_garbage_section_path(section.name):
            section_path = "[section unknown]"

        # ── text ──
        if section.paragraphs:
            full = fix_ocr_ris_stripping("\n\n".join(section.paragraphs))
            raw = [full] if count_tokens(full) <= MAX_TOKENS else chunk_text_block(full, MAX_TOKENS)
            if len(raw) > 1:
                raw = add_overlap(raw, OVERLAP_RATIO)
            capped = []
            for rc in raw:
                capped.extend(chunk_text_block(rc, MAX_TOKENS) if count_tokens(rc) > MAX_TOKENS + 50 else [rc])
            for ct in capped:
                if count_tokens(ct) < MIN_QUALITY_TOKENS:
                    continue
                ct = clean_ui_from_text(ct)
                if not ct or count_tokens(ct) < MIN_QUALITY_TOKENS:
                    continue
                if (is_figure_axis_gibberish(ct) or is_digit_heavy_garbage(ct)
                        or is_boilerplate_noise(ct) or is_affiliation_fragment(ct)
                        or is_reference_block(ct) or has_repeating_loop(ct)):
                    continue
                h = hashlib.md5(ct.encode()).hexdigest()
                if h in seen:
                    continue
                seen.add(h)
                twp = make_prefix(product_id, title, doc_id, doc_type, section_path) + ct
                out.append({
                    "chunk_id": f"{product_id}__{doc_id}__{h[:12]}",
                    "product_id": product_id, "product_title": title,
                    "doc_id": doc_id, "doc_type": doc_type,
                    "section_path": section_path, "section_name": section.name,
                    "chunk_type": "text", "chunk_index": counter,
                    "token_count": count_tokens(twp),
                    "text_with_prefix": twp, "text_raw": ct,
                })
                counter += 1

        # ── tables ──
        for j, tbl in enumerate(section.tables):
            tbl_text = tbl.get("text", "")
            if not tbl_text or count_tokens(tbl_text) < 10:
                continue
            if is_noise_table(tbl_text):
                continue
            caption = section.captions[j] if j < len(section.captions) else ""
            ctx = f"[TABLE in section: {section_path}]" + (f"\nCaption: {caption}" if caption else "")
            if count_tokens(tbl_text) > TABLE_MAX_TOKENS:
                kept, tok = [], 0
                for tl in tbl_text.split("\n"):
                    lt = count_tokens(tl)
                    if tok + lt > TABLE_MAX_TOKENS - 20:
                        break
                    kept.append(tl); tok += lt
                tbl_text = "\n".join(kept) + "\n[... TABLE TRUNCATED ...]"
            body = ctx + "\n\n" + tbl_text
            twp = make_prefix(product_id, title, doc_id, doc_type, section_path) + body
            cid = hashlib.md5(f"{product_id}{doc_id}tbl{section_path}{j}".encode()).hexdigest()[:12]
            out.append({
                "chunk_id": f"{product_id}__{doc_id}__tbl_{cid}",
                "product_id": product_id, "product_title": title,
                "doc_id": doc_id, "doc_type": doc_type,
                "section_path": section_path, "section_name": section.name,
                "chunk_type": "table", "chunk_index": counter,
                "token_count": count_tokens(twp),
                "text_with_prefix": twp, "text_raw": body,
            })
            counter += 1

    # merge tiny adjacent text chunks
    merged: list[dict] = []
    ii = 0
    while ii < len(out):
        c = out[ii]
        if (c["token_count"] < MIN_TOKENS and c["chunk_type"] == "text"
                and ii + 1 < len(out) and out[ii + 1]["section_path"] == c["section_path"]
                and out[ii + 1]["chunk_type"] == "text"):
            nxt = out[ii + 1]
            mt = c["text_raw"] + "\n\n" + nxt["text_raw"]
            nxt["text_raw"] = mt
            nxt["text_with_prefix"] = nxt["text_with_prefix"].split("---\n", 1)[0] + "---\n" + mt
            nxt["token_count"] = count_tokens(nxt["text_with_prefix"])
            ii += 1
        else:
            merged.append(c); ii += 1
    for i, c in enumerate(merged):
        c["chunk_index"] = i
    return merged


def main() -> None:
    catalog = json.loads((OUT / "catalog.json").read_text())
    title_by_pid = {c["product_id"]: c["product_title"] for c in catalog}

    # Prefer CLEANED markdown (clean_md.py output) over raw marine_parsed.
    clean_dir = OUT / "cleaned"
    use_clean = clean_dir.exists() and any(clean_dir.glob("*.md"))
    if use_clean:
        md_files = sorted(clean_dir.glob("*.md"))
        print(f"source: CLEANED ({len(md_files)} files)")

        def product_of(md: Path) -> str:
            return md.stem.split("__", 1)[0]
    else:
        md_files = sorted(PARSED.rglob("vlm/*.md"))
        print(f"source: RAW marine_parsed ({len(md_files)} files)")

        def product_of(md: Path) -> str:
            return md.relative_to(PARSED).parts[0]

    out_path = OUT / "chunks.jsonl"
    done_docs: set[str] = set()
    if out_path.exists():
        with open(out_path) as f:
            for line in f:
                try:
                    r = json.loads(line)
                    done_docs.add(f"{r['product_id']}__{r['doc_id']}")
                except Exception:
                    pass
        print(f"resume: {len(done_docs)} docs already chunked")

    n_docs = n_chunks = 0
    with open(out_path, "a", encoding="utf-8") as fout:
        for md in md_files:
            pid = product_of(md)
            doc_id = md.stem.split("__", 1)[1] if use_clean and "__" in md.stem else md.stem
            doc_key = f"{pid}__{doc_id}"
            if doc_key in done_docs:
                continue
            try:
                chunks = chunk_marine_md(md, pid, title_by_pid.get(pid, ""), doc_id)
            except Exception as e:
                print(f"  ERROR {doc_key}: {repr(e)[:120]}", file=sys.stderr)
                continue
            for c in chunks:
                fout.write(json.dumps(c, ensure_ascii=False) + "\n")
            fout.flush()
            n_docs += 1
            n_chunks += len(chunks)
            if n_docs % 50 == 0:
                print(f"  [{n_docs} docs] {n_chunks} chunks")
    print(f"DONE: {n_docs} docs newly chunked, {n_chunks} chunks → {out_path}")


if __name__ == "__main__":
    main()