258 lines
8.5 KiB
Python
258 lines
8.5 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
conversione/validate.py — Validazione batch di tutti gli stem convertiti
|
||
|
||
Legge i report.json prodotti da pipeline.py, stampa una tabella di stato
|
||
e assegna un voto (0-100) a ogni documento per misurare la bontà del
|
||
Markdown prodotto.
|
||
|
||
Voto:
|
||
90-100 A — ottimo, pronto per il chunker
|
||
75-89 B — buono, qualche sezione lunga ma accettabile
|
||
60-74 C — accettabile, anomalie minori da verificare
|
||
40-59 D — da rivedere, problemi strutturali o residui evidenti
|
||
0-39 F — da riprocessare, struttura assente o testo corrotto
|
||
|
||
Uso:
|
||
python conversione/validate.py # tutti gli stem
|
||
python conversione/validate.py analisi1 # stem specifico
|
||
python conversione/validate.py --stem analisi1
|
||
python conversione/validate.py --analisi1 # compatibilità
|
||
"""
|
||
|
||
import json
|
||
import argparse
|
||
import sys
|
||
from pathlib import Path
|
||
|
||
|
||
# ─── Punteggio ───────────────────────────────────────────────────────────────
|
||
|
||
def _score(r: dict) -> int:
|
||
"""
|
||
Calcola un punteggio 0-100 sulla qualità del Markdown prodotto.
|
||
|
||
Penalità:
|
||
- struttura assente o piatta → -40 / -15
|
||
- backtick residui nel testo → -2 per occorrenza (max -30)
|
||
- URL / watermark residui → -5 per occorrenza (max -15)
|
||
- immagini residue → -5 per occorrenza (max -10)
|
||
- dot-leader residui → -5 per occorrenza (max -10)
|
||
- header senza titolo (bare) → -3 per occorrenza (max -15)
|
||
- troppe sezioni > 1500 chars → -5 / -10 (in % sul totale h3)
|
||
"""
|
||
score = 100
|
||
structure = r.get("structure", {})
|
||
anomalie = r.get("anomalie", {})
|
||
residui = r.get("residui", {})
|
||
|
||
livello = structure.get("livello_struttura", 0)
|
||
n_h3 = max(structure.get("n_h3", 0), 1)
|
||
|
||
# Struttura
|
||
if livello == 0:
|
||
score -= 40
|
||
elif livello == 1:
|
||
score -= 15
|
||
|
||
# Residui nel testo
|
||
score -= min(30, residui.get("backtick", 0) * 2)
|
||
score -= min(15, residui.get("url", 0) * 5)
|
||
score -= min(10, residui.get("immagini", 0) * 5)
|
||
score -= min(10, residui.get("dotleader", 0) * 5)
|
||
|
||
# Anomalie strutturali
|
||
score -= min(15, anomalie.get("bare_headers", 0) * 3)
|
||
|
||
# Sezioni troppo lunghe (in % sul totale delle sezioni ###)
|
||
long_ratio = anomalie.get("long_sections", 0) / n_h3
|
||
if long_ratio > 0.6:
|
||
score -= 10
|
||
elif long_ratio > 0.35:
|
||
score -= 5
|
||
|
||
return max(0, score)
|
||
|
||
|
||
def _grade(score: int) -> str:
|
||
if score >= 90: return "A"
|
||
if score >= 75: return "B"
|
||
if score >= 60: return "C"
|
||
if score >= 40: return "D"
|
||
return "F"
|
||
|
||
|
||
# ─── CLI ─────────────────────────────────────────────────────────────────────
|
||
|
||
def _normalize_target(token: str) -> str:
|
||
"""
|
||
Normalizza un target CLI in stem:
|
||
- analisi1
|
||
- --analisi1 (compatibilità)
|
||
- conversione/analisi1/report.json
|
||
- analisi1.pdf / analisi1.md / report.json
|
||
"""
|
||
raw = token.strip()
|
||
if not raw:
|
||
return raw
|
||
|
||
# Compatibilità con invocazione tipo: --analisi1
|
||
if raw.startswith("--") and len(raw) > 2:
|
||
raw = raw[2:]
|
||
|
||
p = Path(raw)
|
||
|
||
# Path diretto al report
|
||
if p.name == "report.json" and p.parent.name:
|
||
return p.parent.name
|
||
|
||
name = p.name
|
||
if name.endswith((".pdf", ".md", ".json")):
|
||
name = Path(name).stem
|
||
|
||
return name
|
||
|
||
|
||
def _parse_cli_args(argv: list[str]) -> list[str]:
|
||
parser = argparse.ArgumentParser(
|
||
description="Valida i report Markdown prodotti in conversione/<stem>/report.json"
|
||
)
|
||
parser.add_argument(
|
||
"targets",
|
||
nargs="*",
|
||
help="Stem, file o path da validare (es: analisi1 oppure conversione/analisi1/report.json)",
|
||
)
|
||
parser.add_argument(
|
||
"-s",
|
||
"--stem",
|
||
action="append",
|
||
default=[],
|
||
help="Stem specifico (ripetibile, es: --stem analisi1 --stem nietzsche)",
|
||
)
|
||
|
||
args, unknown = parser.parse_known_args(argv)
|
||
|
||
targets = [*args.targets, *args.stem]
|
||
|
||
# Compatibilità: `python validate.py --analisi1`
|
||
for tok in unknown:
|
||
if tok.startswith("--") and len(tok) > 2:
|
||
targets.append(tok[2:])
|
||
else:
|
||
parser.error(f"Argomento non riconosciuto: {tok}")
|
||
|
||
stems = []
|
||
seen = set()
|
||
for t in targets:
|
||
stem = _normalize_target(t)
|
||
if not stem or stem in seen:
|
||
continue
|
||
seen.add(stem)
|
||
stems.append(stem)
|
||
|
||
return stems
|
||
|
||
|
||
# ─── Validazione ─────────────────────────────────────────────────────────────
|
||
|
||
def validate(stems: list[str], project_root: Path) -> None:
|
||
conv_dir = project_root / "conversione"
|
||
|
||
if stems:
|
||
paths = [conv_dir / s / "report.json" for s in stems]
|
||
else:
|
||
paths = sorted(conv_dir.glob("*/report.json"))
|
||
|
||
if not paths:
|
||
print("Nessun report.json trovato in conversione/*/")
|
||
sys.exit(0)
|
||
|
||
rows = []
|
||
for path in paths:
|
||
if not path.exists():
|
||
rows.append({"stem": path.parent.name, "_missing": True})
|
||
continue
|
||
r = json.loads(path.read_text(encoding="utf-8"))
|
||
rows.append(r)
|
||
|
||
# ── Intestazione ─────────────────────────────────────────────────────
|
||
col_stem = max(len(r.get("stem", "stem")) for r in rows) + 2
|
||
header = (
|
||
f"{'stem':<{col_stem}}"
|
||
f"{'h2':>4}{'h3':>5} "
|
||
f"{'strategia':<20}"
|
||
f"{'bare':>5}{'corte':>6}{'lunghe':>7}"
|
||
f"{'backtick':>9}{'dotlead':>8}{'url':>4}"
|
||
f" {'voto':>4} {'grade'}"
|
||
)
|
||
sep = "─" * len(header)
|
||
print()
|
||
print(header)
|
||
print(sep)
|
||
|
||
scores = []
|
||
scored_docs = []
|
||
|
||
# ── Righe ─────────────────────────────────────────────────────────────
|
||
for r in rows:
|
||
if r.get("_missing"):
|
||
print(f"{r['stem']:<{col_stem}} (report.json non trovato)")
|
||
continue
|
||
|
||
stem = r.get("stem", "?")
|
||
structure = r.get("structure", {})
|
||
anomalie = r.get("anomalie", {})
|
||
residui = r.get("residui", {})
|
||
|
||
h2 = structure.get("n_h2", 0)
|
||
h3 = structure.get("n_h3", 0)
|
||
strat = structure.get("strategia_chunking", "?")
|
||
bare = anomalie.get("bare_headers", 0)
|
||
corte = anomalie.get("short_sections", 0)
|
||
lunghe = anomalie.get("long_sections", 0)
|
||
backtick = residui.get("backtick", 0)
|
||
dotlead = residui.get("dotleader", 0)
|
||
url = residui.get("url", 0)
|
||
|
||
s = _score(r)
|
||
g = _grade(s)
|
||
scores.append(s)
|
||
scored_docs.append((stem, s, g))
|
||
|
||
print(
|
||
f"{stem:<{col_stem}}"
|
||
f"{h2:>4}{h3:>5} "
|
||
f"{strat:<20}"
|
||
f"{bare:>5}{corte:>6}{lunghe:>7}"
|
||
f"{backtick:>9}{dotlead:>8}{url:>4}"
|
||
f" {s:>4} {g}"
|
||
)
|
||
|
||
# ── Riepilogo ─────────────────────────────────────────────────────────
|
||
print(sep)
|
||
if scores:
|
||
media = sum(scores) / len(scores)
|
||
grade_media = _grade(int(media))
|
||
print(f"Documenti: {len(scores)} "
|
||
f"Voto medio: {media:.0f}/100 {grade_media} "
|
||
f"(A≥90 B≥75 C≥60 D≥40 F<40)")
|
||
if len(scored_docs) == 1:
|
||
stem, score, grade = scored_docs[0]
|
||
print(f"Voto finale Markdown ({stem}): {score}/100 {grade}")
|
||
else:
|
||
voti = ", ".join(
|
||
f"{stem}={score}/100 {grade}"
|
||
for stem, score, grade in scored_docs
|
||
)
|
||
print(f"Voti Markdown: {voti}")
|
||
print()
|
||
print("Penalità: struttura assente −40, backtick residui −2/cad, "
|
||
"bare headers −3/cad, sezioni >1500ch >35% −5")
|
||
print()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
project_root = Path(__file__).parent.parent
|
||
stems = _parse_cli_args(sys.argv[1:])
|
||
validate(stems, project_root)
|