chore: rimuove chunker legacy, aggiunge dipendenze AST-based pipeline
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
@@ -1,413 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
chunker.py — Chunking semantico da Markdown pulito
|
||||
|
||||
Input: sources/<stem>.md — Markdown già strutturato (H1/H2/H3 + paragrafi)
|
||||
Output: chunks/<stem>/chunks.json
|
||||
chunks/<stem>/meta.json
|
||||
|
||||
Regole:
|
||||
- ogni paragrafo diventa un chunk; paragrafi di contesti diversi non si mescolano
|
||||
- se un paragrafo supera MAX_CHARS viene spezzato a confine di frase (mai a metà)
|
||||
- paragrafi brevi (< MIN_CHARS) vengono fusi col successivo finché non raggiungono
|
||||
MIN_CHARS, a patto che abbiano lo stesso contesto heading
|
||||
- tabelle, liste e codice sono blocchi atomici (non si spezzano)
|
||||
|
||||
Uso:
|
||||
python chunks/chunker.py --stem <stem>
|
||||
python chunks/chunker.py # tutti gli stem con .md in sources/
|
||||
python chunks/chunker.py --stem <stem> --force
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
_HERE = Path(__file__).resolve().parent
|
||||
if str(_HERE) not in sys.path:
|
||||
sys.path.insert(0, str(_HERE))
|
||||
import config as cfg
|
||||
|
||||
|
||||
# ─── Utilità ──────────────────────────────────────────────────────────────────
|
||||
|
||||
def split_sentences(text: str) -> list[str]:
|
||||
parts = re.split(cfg.SENTENCE_SPLIT_RE, text.strip())
|
||||
return [p.strip() for p in parts if p.strip()]
|
||||
|
||||
|
||||
def context_to_meta(context: str) -> tuple[str, str]:
|
||||
parts = [p.strip() for p in context.split(" > ") if p.strip()]
|
||||
if len(parts) >= 2:
|
||||
return " > ".join(parts[:-1]), parts[-1]
|
||||
return (parts[0] if parts else ""), ""
|
||||
|
||||
|
||||
# ─── Parser Markdown ──────────────────────────────────────────────────────────
|
||||
|
||||
_SKIP_HEADINGS_LOWER = {h.lower() for h in cfg.SKIP_HEADINGS}
|
||||
|
||||
|
||||
def _is_skip_heading(title: str) -> bool:
|
||||
t = title.lower()
|
||||
return any(t == s or t.startswith(s) for s in _SKIP_HEADINGS_LOWER)
|
||||
|
||||
|
||||
def parse_paragraphs(text: str) -> list[dict]:
|
||||
"""Estrae blocchi dal Markdown con il loro contesto heading.
|
||||
|
||||
Restituisce: [{"context": "H1 > H2 > H3", "text": "...", "kind": "text|table|list|code"}]
|
||||
|
||||
- Heading senza corpo non emettono chunk: aggiornano solo il contesto.
|
||||
- Tabelle (righe |), liste (righe -/*) e code block (```) sono atomici.
|
||||
- Sezioni in SKIP_HEADINGS vengono saltate completamente.
|
||||
- Contenuto pre-heading saltato se SKIP_PRE_HEADING è True.
|
||||
"""
|
||||
headings = ["", "", ""] # H1, H2, H3
|
||||
result: list[dict] = []
|
||||
buf: list[str] = []
|
||||
cur_kind = "text"
|
||||
in_code = False
|
||||
skip_level: int | None = None # livello heading che ha attivato lo skip
|
||||
|
||||
def current_context() -> str:
|
||||
parts = [h for h in headings if h]
|
||||
return " > ".join(parts[:cfg.CONTEXT_DEPTH]) if parts else "documento"
|
||||
|
||||
def is_skipping() -> bool:
|
||||
return skip_level is not None
|
||||
|
||||
def flush() -> None:
|
||||
if is_skipping():
|
||||
buf.clear()
|
||||
return
|
||||
if cfg.SKIP_PRE_HEADING and current_context() == "documento":
|
||||
buf.clear()
|
||||
return
|
||||
body = "\n".join(buf).strip()
|
||||
if body:
|
||||
result.append({"context": current_context(), "text": body, "kind": cur_kind})
|
||||
buf.clear()
|
||||
|
||||
for line in text.splitlines():
|
||||
# ── Code block toggle ─────────────────────────────────────────────────
|
||||
if line.strip().startswith("```"):
|
||||
if not in_code:
|
||||
flush()
|
||||
cur_kind = "code"
|
||||
in_code = True
|
||||
if not is_skipping():
|
||||
buf.append(line)
|
||||
else:
|
||||
if not is_skipping():
|
||||
buf.append(line)
|
||||
in_code = False
|
||||
flush()
|
||||
cur_kind = "text"
|
||||
continue
|
||||
|
||||
if in_code:
|
||||
if not is_skipping():
|
||||
buf.append(line)
|
||||
continue
|
||||
|
||||
# ── Heading ───────────────────────────────────────────────────────────
|
||||
m = re.match(r"^(#{1,3}) (.+)", line)
|
||||
if m:
|
||||
flush()
|
||||
level = len(m.group(1))
|
||||
title = m.group(2).strip()
|
||||
|
||||
# chiudi skip se torniamo a livello pari o superiore
|
||||
if skip_level is not None and level <= skip_level:
|
||||
skip_level = None
|
||||
|
||||
headings[level - 1] = title
|
||||
for i in range(level, 3):
|
||||
headings[i] = ""
|
||||
cur_kind = "text"
|
||||
|
||||
# apri skip se questo heading è nella lista
|
||||
if _is_skip_heading(title):
|
||||
skip_level = level
|
||||
|
||||
continue
|
||||
|
||||
# ── Tabella ───────────────────────────────────────────────────────────
|
||||
if line.strip().startswith("|"):
|
||||
if cur_kind != "table":
|
||||
flush()
|
||||
cur_kind = "table"
|
||||
buf.append(line)
|
||||
continue
|
||||
|
||||
# ── Lista ─────────────────────────────────────────────────────────────
|
||||
if re.match(r"^\s*[-*]\s", line):
|
||||
if cur_kind != "list":
|
||||
flush()
|
||||
cur_kind = "list"
|
||||
buf.append(line)
|
||||
continue
|
||||
|
||||
# ── Riga vuota: chiude il paragrafo corrente ──────────────────────────
|
||||
if line.strip() == "":
|
||||
flush()
|
||||
cur_kind = "text"
|
||||
continue
|
||||
|
||||
# ── Testo normale ─────────────────────────────────────────────────────
|
||||
if cur_kind in ("table", "list", "code"):
|
||||
flush()
|
||||
cur_kind = "text"
|
||||
buf.append(line)
|
||||
|
||||
flush()
|
||||
return result
|
||||
|
||||
|
||||
# ─── Merge paragrafi brevi ────────────────────────────────────────────────────
|
||||
|
||||
def merge_short(paragraphs: list[dict]) -> list[dict]:
|
||||
"""Fonde paragrafi di testo consecutivi sotto MIN_CHARS con il successivo,
|
||||
purché condividano lo stesso contesto heading."""
|
||||
if not cfg.MERGE_SHORT_PARAGRAPHS:
|
||||
return paragraphs
|
||||
|
||||
result: list[dict] = []
|
||||
buf_para: dict | None = None
|
||||
buf_text: str = ""
|
||||
|
||||
def flush_buf() -> None:
|
||||
nonlocal buf_para, buf_text
|
||||
if buf_para is not None:
|
||||
result.append({**buf_para, "text": buf_text})
|
||||
buf_para = None
|
||||
buf_text = ""
|
||||
|
||||
for para in paragraphs:
|
||||
if para["kind"] != "text":
|
||||
flush_buf()
|
||||
result.append(para)
|
||||
continue
|
||||
|
||||
if buf_para is None:
|
||||
buf_para = para
|
||||
buf_text = para["text"]
|
||||
elif buf_para["context"] == para["context"] and len(buf_text) < cfg.MIN_CHARS:
|
||||
buf_text = buf_text + "\n\n" + para["text"]
|
||||
else:
|
||||
flush_buf()
|
||||
buf_para = para
|
||||
buf_text = para["text"]
|
||||
|
||||
flush_buf()
|
||||
return result
|
||||
|
||||
|
||||
# ─── Chunking ─────────────────────────────────────────────────────────────────
|
||||
|
||||
def make_chunks(paragraphs: list[dict]) -> list[dict]:
|
||||
"""Genera chunk da parse_paragraphs (dopo eventuale merge).
|
||||
|
||||
- Blocchi atomici (table, list, code): un chunk, mai spezzato.
|
||||
- Testo: un chunk per paragrafo; se supera MAX_CHARS, spezza a confine frase.
|
||||
"""
|
||||
chunks: list[dict] = []
|
||||
idx = 0
|
||||
|
||||
for para in paragraphs:
|
||||
text = para["text"]
|
||||
context = para["context"]
|
||||
kind = para["kind"]
|
||||
sezione, titolo = context_to_meta(context)
|
||||
|
||||
def emit(body: str) -> None:
|
||||
nonlocal idx
|
||||
chunk_text = f"[{context}]\n{body}"
|
||||
chunks.append({
|
||||
"chunk_id": f"c{idx}",
|
||||
"text": chunk_text,
|
||||
"sezione": sezione,
|
||||
"titolo": titolo,
|
||||
"context": context,
|
||||
"n_chars": len(chunk_text),
|
||||
})
|
||||
idx += 1
|
||||
|
||||
# ── Atomici ───────────────────────────────────────────────────────────
|
||||
if kind in ("table", "list", "code"):
|
||||
emit(text)
|
||||
continue
|
||||
|
||||
# ── Testo: split a confine di frase se supera MAX_CHARS ───────────────
|
||||
sents = split_sentences(text)
|
||||
if not sents:
|
||||
continue
|
||||
|
||||
current: list[str] = []
|
||||
for sent in sents:
|
||||
projected = len(" ".join(current + [sent]))
|
||||
if projected <= cfg.MAX_CHARS or not current:
|
||||
current.append(sent)
|
||||
else:
|
||||
emit(" ".join(current))
|
||||
current = [sent]
|
||||
|
||||
if current:
|
||||
emit(" ".join(current))
|
||||
|
||||
return chunks
|
||||
|
||||
|
||||
# ─── Merge frasi spezzate ─────────────────────────────────────────────────────
|
||||
|
||||
_SENT_END = re.compile(
|
||||
"[.!?;:"
|
||||
+ chr(0xBB) + ")\\\\"
|
||||
+ chr(0x2018) + chr(0x2019)
|
||||
+ chr(0x201C) + chr(0x201D)
|
||||
+ "\"'"
|
||||
+ chr(0x2014) + chr(0x2013) + chr(0x2026) + chr(0xB7)
|
||||
+ "]$"
|
||||
+ r"|\d[\d.,/]*$" # numero o versione
|
||||
+ r"|\$$" # formula LaTeX inline
|
||||
+ r"|\}$" # blocco LaTeX
|
||||
+ r"|>$" # tag HTML
|
||||
+ r"|\\\\$" # \\ LaTeX
|
||||
+ r"|\|$" # riga tabella
|
||||
)
|
||||
|
||||
|
||||
def _body(chunk: dict) -> str:
|
||||
text = chunk["text"]
|
||||
nl = text.find("\n")
|
||||
return text[nl + 1:] if nl != -1 else text
|
||||
|
||||
|
||||
def merge_broken_sentences(chunks: list[dict]) -> list[dict]:
|
||||
"""Fonde chunk consecutivi con lo stesso contesto quando il primo termina
|
||||
senza punteggiatura di fine frase (frase spezzata dal sorgente)."""
|
||||
result: list[dict] = []
|
||||
i = 0
|
||||
while i < len(chunks):
|
||||
c = dict(chunks[i])
|
||||
body = _body(c)
|
||||
|
||||
while (
|
||||
i + 1 < len(chunks)
|
||||
and chunks[i + 1]["context"] == c["context"]
|
||||
and not _SENT_END.search(body.rstrip())
|
||||
):
|
||||
i += 1
|
||||
next_body = _body(chunks[i])
|
||||
body = body.rstrip() + " " + next_body.lstrip()
|
||||
|
||||
chunk_text = f"[{c['context']}]\n{body}"
|
||||
c["text"] = chunk_text
|
||||
c["n_chars"] = len(chunk_text)
|
||||
result.append(c)
|
||||
i += 1
|
||||
|
||||
for idx, c in enumerate(result):
|
||||
c["chunk_id"] = f"c{idx}"
|
||||
|
||||
return result
|
||||
|
||||
|
||||
# ─── Pipeline per documento ───────────────────────────────────────────────────
|
||||
|
||||
def process_stem(stem: str, project_root: Path, force: bool) -> bool:
|
||||
md_path = project_root / "sources" / f"{stem}_output" / "auto" / f"{stem}.md"
|
||||
if not md_path.exists():
|
||||
md_path = project_root / "sources" / f"{stem}.md"
|
||||
if not md_path.exists():
|
||||
print(f" ✗ {stem}.md non trovato (cercato in sources/{stem}_output/auto/ e sources/)")
|
||||
return False
|
||||
|
||||
out_dir = project_root / "chunks" / stem
|
||||
out_file = out_dir / "chunks.json"
|
||||
|
||||
if out_file.exists() and not force:
|
||||
print(f" ↩ chunks/{stem}/chunks.json già presente — skip (usa --force per rigenerare)")
|
||||
return True
|
||||
|
||||
print(f"[chunker] {stem}")
|
||||
|
||||
text = md_path.read_text(encoding="utf-8")
|
||||
paragraphs = parse_paragraphs(text)
|
||||
|
||||
if not paragraphs:
|
||||
print(f" ✗ Nessun paragrafo estratto da {md_path.name}")
|
||||
return False
|
||||
|
||||
if cfg.MERGE_SHORT_PARAGRAPHS:
|
||||
paragraphs = merge_short(paragraphs)
|
||||
|
||||
chunks = make_chunks(paragraphs)
|
||||
chunks = merge_broken_sentences(chunks)
|
||||
|
||||
if not chunks:
|
||||
print(f" ✗ Nessun chunk generato")
|
||||
return False
|
||||
|
||||
out_dir.mkdir(parents=True, exist_ok=True)
|
||||
out_file.write_text(
|
||||
json.dumps(chunks, ensure_ascii=False, indent=2), encoding="utf-8"
|
||||
)
|
||||
(out_dir / "meta.json").write_text(
|
||||
json.dumps({
|
||||
"stem": stem,
|
||||
"source": str(md_path.relative_to(project_root)),
|
||||
"max_chars": cfg.MAX_CHARS,
|
||||
"min_chars": cfg.MIN_CHARS,
|
||||
"merge_short": cfg.MERGE_SHORT_PARAGRAPHS,
|
||||
"strategy": "one_paragraph_per_chunk",
|
||||
}, ensure_ascii=False, indent=2),
|
||||
encoding="utf-8",
|
||||
)
|
||||
|
||||
lengths = [c["n_chars"] for c in chunks]
|
||||
over_max = sum(1 for l in lengths if l > cfg.MAX_CHARS)
|
||||
under_min = sum(1 for l in lengths if l < cfg.MIN_CHARS)
|
||||
avg = int(sum(lengths) / len(lengths))
|
||||
|
||||
print(f" ✅ {len(chunks)} chunk | media {avg} char | max {max(lengths)} char")
|
||||
if over_max:
|
||||
print(f" ⚠️ {over_max} chunk superano MAX_CHARS={cfg.MAX_CHARS}")
|
||||
if under_min:
|
||||
print(f" ℹ️ {under_min} chunk sotto MIN_CHARS={cfg.MIN_CHARS}")
|
||||
print(f" → chunks/{stem}/chunks.json")
|
||||
return True
|
||||
|
||||
|
||||
# ─── Entry point ──────────────────────────────────────────────────────────────
|
||||
|
||||
if __name__ == "__main__":
|
||||
project_root = Path(__file__).parent.parent
|
||||
sources_dir = project_root / "sources"
|
||||
|
||||
parser = argparse.ArgumentParser(description="Markdown pulito → chunks.json")
|
||||
parser.add_argument("--stem", help="Nome documento (es. analisi2)")
|
||||
parser.add_argument("--force", action="store_true",
|
||||
help="Rigenera chunks.json anche se già presente")
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.stem:
|
||||
stems = [args.stem]
|
||||
else:
|
||||
found = set()
|
||||
for p in sources_dir.glob("*_output/auto/*.md"):
|
||||
found.add(p.stem)
|
||||
for p in sources_dir.glob("*.md"):
|
||||
found.add(p.stem)
|
||||
stems = sorted(found)
|
||||
if not stems:
|
||||
print("Nessun file .md trovato in sources/")
|
||||
sys.exit(1)
|
||||
|
||||
results = [process_stem(s, project_root, args.force) for s in stems]
|
||||
ok = sum(results)
|
||||
print(f"\n{'✅' if all(results) else '⚠️ '} {ok}/{len(results)} documenti processati")
|
||||
sys.exit(0 if all(results) else 1)
|
||||
Reference in New Issue
Block a user