434 lines
16 KiB
Python
434 lines
16 KiB
Python
|
#!/usr/bin/env python3
|
||
|
|
"""
|
||
|
|
Step 4 — Revisione automatica del Markdown
|
||
|
|
|
||
|
|
Trasforma clean.md da step-3 rivelando la struttura latente del documento.
|
||
|
|
Le trasformazioni sono euristiche universali che funzionano su qualsiasi PDF:
|
||
|
|
|
||
|
|
- Normalizza whitespace multiplo (artefatto PDF)
|
||
|
|
- Riduce righe vuote multiple
|
||
|
|
- Rimuove marcatori **bold** nelle intestazioni esistenti
|
||
|
|
- Converte righe ALL-CAPS standalone → ## header (euristico, qualsiasi lingua)
|
||
|
|
- Converte sezioni numerate "N. testo" → ### N. (qualsiasi numerazione)
|
||
|
|
- Rimuove blocchi TOC (righe che iniziano con parole-chiave indice)
|
||
|
|
|
||
|
|
Per ogni documento viene ricalcolato il profilo strutturale: il livello può
|
||
|
|
salire (es. livello 1 → 3) se le strutture latenti vengono rilevate.
|
||
|
|
|
||
|
|
Output in step-4/<stem>/:
|
||
|
|
raw.md — copia da step-3 (non modificare mai)
|
||
|
|
clean.md — MD revisionato
|
||
|
|
structure_profile.json — profilo aggiornato dopo la revisione
|
||
|
|
|
||
|
|
Uso:
|
||
|
|
python step-4/revise.py # tutti i documenti in step-3/
|
||
|
|
python step-4/revise.py --stem nietzsche # un solo documento
|
||
|
|
python step-4/revise.py --force # riesegui anche se già presente
|
||
|
|
"""
|
||
|
|
|
||
|
|
import argparse
|
||
|
|
import json
|
||
|
|
import re
|
||
|
|
import shutil
|
||
|
|
import sys
|
||
|
|
from datetime import date
|
||
|
|
from pathlib import Path
|
||
|
|
|
||
|
|
# Riusa la funzione analyze() già scritta nello step 3
|
||
|
|
sys.path.insert(0, str(Path(__file__).parent.parent / "step-3"))
|
||
|
|
from detect_structure import analyze # noqa: E402
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Costanti ─────────────────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
# Parole-chiave che identificano blocchi TOC (da rimuovere)
|
||
|
|
_TOC_KEYWORDS = frozenset([
|
||
|
|
"indice", "index", "contents", "table of contents",
|
||
|
|
"sommario", "inhaltsverzeichnis", "inhalt",
|
||
|
|
])
|
||
|
|
|
||
|
|
# Preposizioni/articoli da non capitalizzare nel title-case
|
||
|
|
_STOP_IT_EN = frozenset([
|
||
|
|
# italiano
|
||
|
|
"di", "del", "della", "dei", "delle", "da", "in", "e", "il", "la",
|
||
|
|
"lo", "le", "gli", "un", "una", "per", "a", "al", "alla", "ai",
|
||
|
|
"alle", "con", "su", "sul", "sulla", "che", "o",
|
||
|
|
# inglese
|
||
|
|
"of", "the", "a", "an", "and", "or", "but", "in", "on", "at",
|
||
|
|
"to", "for", "with", "by", "from", "as",
|
||
|
|
])
|
||
|
|
|
||
|
|
# Ordinali italiani → romani (per titoli come "CAPITOLO PRIMO")
|
||
|
|
_ORDINALS_IT = {
|
||
|
|
"PRIMO": "I", "SECONDO": "II", "TERZO": "III", "QUARTO": "IV",
|
||
|
|
"QUINTO": "V", "SESTO": "VI", "SETTIMO": "VII", "OTTAVO": "VIII",
|
||
|
|
"NONO": "IX", "DECIMO": "X",
|
||
|
|
}
|
||
|
|
|
||
|
|
# Ordinali inglesi → arabici (per "CHAPTER ONE")
|
||
|
|
_ORDINALS_EN = {
|
||
|
|
"ONE": "1", "TWO": "2", "THREE": "3", "FOUR": "4", "FIVE": "5",
|
||
|
|
"SIX": "6", "SEVEN": "7", "EIGHT": "8", "NINE": "9", "TEN": "10",
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Utilità ──────────────────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
def _sentence_case(s: str) -> str:
|
||
|
|
"""
|
||
|
|
Sentence-case: prima lettera maiuscola, resto minuscolo.
|
||
|
|
Corretto per l'italiano e accettabile per l'inglese accademico.
|
||
|
|
"""
|
||
|
|
if not s:
|
||
|
|
return s
|
||
|
|
lower = s.lower()
|
||
|
|
return lower[0].upper() + lower[1:]
|
||
|
|
|
||
|
|
|
||
|
|
def _is_allcaps_line(line: str) -> bool:
|
||
|
|
"""
|
||
|
|
True se la riga è una candidata per conversione a ## header.
|
||
|
|
Criterio: tutti i caratteri alfabetici sono maiuscoli, lunghezza >= 3.
|
||
|
|
"""
|
||
|
|
stripped = line.strip()
|
||
|
|
letters = [c for c in stripped if c.isalpha()]
|
||
|
|
return (
|
||
|
|
len(letters) >= 3
|
||
|
|
and all(c.isupper() for c in letters)
|
||
|
|
and not stripped.startswith("#")
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
def _allcaps_to_header(raw_line: str) -> str:
|
||
|
|
"""
|
||
|
|
Converte una riga ALL-CAPS in un ## header title-case.
|
||
|
|
Riconosce pattern specifici (CAPITOLO ORDINE, CHAPTER N) come bonus,
|
||
|
|
ma funziona in modalità generica su qualsiasi testo.
|
||
|
|
"""
|
||
|
|
text = raw_line.strip().rstrip('.').rstrip('?').strip()
|
||
|
|
|
||
|
|
# ── Pattern italiano: "CAPITOLO PRIMO. TITOLO DEL CAPITOLO"
|
||
|
|
_ORD_IT_PAT = "|".join(_ORDINALS_IT.keys())
|
||
|
|
m = re.match(rf'^CAPITOLO ({_ORD_IT_PAT})\. (.+)', text)
|
||
|
|
if m:
|
||
|
|
roman = _ORDINALS_IT[m.group(1)]
|
||
|
|
titolo = m.group(2).rstrip('.').rstrip('?').strip()
|
||
|
|
return f"## Capitolo {roman} — {_sentence_case(titolo)}"
|
||
|
|
|
||
|
|
# ── Pattern inglese: "CHAPTER ONE. TITLE" o "CHAPTER 1. TITLE"
|
||
|
|
_ORD_EN_PAT = "|".join(_ORDINALS_EN.keys())
|
||
|
|
m = re.match(rf'^CHAPTER ({_ORD_EN_PAT}|\d+)\.? (.+)', text)
|
||
|
|
if m:
|
||
|
|
n = _ORDINALS_EN.get(m.group(1), m.group(1))
|
||
|
|
titolo = m.group(2).rstrip('.').rstrip('?').strip()
|
||
|
|
return f"## Chapter {n} — {_sentence_case(titolo)}"
|
||
|
|
|
||
|
|
# ── Pattern generico con numerazione romana o arabica nel prefisso
|
||
|
|
m = re.match(r'^([IVXLCDM]+|[0-9]+)\. (.+)', text)
|
||
|
|
if m:
|
||
|
|
n = m.group(1)
|
||
|
|
titolo = m.group(2).rstrip('.').strip()
|
||
|
|
return f"## {n}. {_sentence_case(titolo)}"
|
||
|
|
|
||
|
|
# ── Caso generico: tutto maiuscolo senza pattern riconoscibile
|
||
|
|
return f"## {_sentence_case(text)}"
|
||
|
|
|
||
|
|
|
||
|
|
def _is_toc_line(line: str) -> bool:
|
||
|
|
"""True se la riga è l'intestazione di un blocco indice/TOC."""
|
||
|
|
first_word = line.strip().split('.')[0].strip().lower()
|
||
|
|
return first_word in _TOC_KEYWORDS
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Trasformazioni ────────────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
def apply_transforms(text: str) -> tuple[str, dict]:
|
||
|
|
"""
|
||
|
|
Applica tutte le trasformazioni strutturali al testo MD.
|
||
|
|
Restituisce (testo_modificato, statistiche).
|
||
|
|
"""
|
||
|
|
stats = {
|
||
|
|
"toc_rimosso": False,
|
||
|
|
"n_header_allcaps": 0,
|
||
|
|
"n_sezioni_numerate": 0,
|
||
|
|
"n_paragrafi_uniti": 0,
|
||
|
|
}
|
||
|
|
|
||
|
|
# ── 1. Rimuovi marcatori **bold** nelle intestazioni esistenti
|
||
|
|
# ## **Titolo** → ## Titolo
|
||
|
|
text = re.sub(
|
||
|
|
r'^(#{1,6})\s+\*\*(.+?)\*\*\s*$',
|
||
|
|
r'\1 \2',
|
||
|
|
text, flags=re.MULTILINE,
|
||
|
|
)
|
||
|
|
|
||
|
|
# ── 1b. Normalizza header esistenti con contenuto ALL-CAPS → sentence-case
|
||
|
|
# ## AL DI LA' DEL BENE E DEL MALE → ## Al di la' del bene e del male
|
||
|
|
def _norm_allcaps_header(m: re.Match) -> str:
|
||
|
|
hashes = m.group(1)
|
||
|
|
content = m.group(2).strip()
|
||
|
|
letters = [c for c in content if c.isalpha()]
|
||
|
|
if letters and all(c.isupper() for c in letters):
|
||
|
|
return f"{hashes} {_sentence_case(content)}"
|
||
|
|
return m.group(0)
|
||
|
|
|
||
|
|
text = re.sub(
|
||
|
|
r'^(#{1,6}) (.+)$',
|
||
|
|
_norm_allcaps_header,
|
||
|
|
text, flags=re.MULTILINE,
|
||
|
|
)
|
||
|
|
|
||
|
|
# ── 2. Rimuovi blocco TOC (riga indice + contenuto inline sulla stessa riga)
|
||
|
|
# "INDICE. Capitolo 1 Capitolo 2 ..." → rimossa
|
||
|
|
lines = text.split('\n')
|
||
|
|
new_lines = []
|
||
|
|
for line in lines:
|
||
|
|
if _is_toc_line(line):
|
||
|
|
stats["toc_rimosso"] = True
|
||
|
|
else:
|
||
|
|
new_lines.append(line)
|
||
|
|
text = '\n'.join(new_lines)
|
||
|
|
|
||
|
|
# ── 3. Converti righe ALL-CAPS standalone → ## header
|
||
|
|
# Una riga è "standalone" se è preceduta/seguita da riga vuota
|
||
|
|
# oppure si trova all'inizio/fine del documento.
|
||
|
|
blocks = text.split('\n\n')
|
||
|
|
new_blocks = []
|
||
|
|
for block in blocks:
|
||
|
|
stripped = block.strip()
|
||
|
|
# Blocco standalone = un'unica riga (nessun \n interno rilevante)
|
||
|
|
if '\n' not in stripped and _is_allcaps_line(stripped):
|
||
|
|
new_blocks.append(_allcaps_to_header(stripped))
|
||
|
|
stats["n_header_allcaps"] += 1
|
||
|
|
else:
|
||
|
|
# Controlla riga per riga per righe ALL-CAPS seguite da altri contenuti
|
||
|
|
sub_lines = block.split('\n')
|
||
|
|
converted = []
|
||
|
|
for ln in sub_lines:
|
||
|
|
if _is_allcaps_line(ln) and len(ln.strip()) > 3:
|
||
|
|
converted.append(_allcaps_to_header(ln))
|
||
|
|
stats["n_header_allcaps"] += 1
|
||
|
|
else:
|
||
|
|
converted.append(ln)
|
||
|
|
new_blocks.append('\n'.join(converted))
|
||
|
|
text = '\n\n'.join(new_blocks)
|
||
|
|
|
||
|
|
# ── 4. Converti sezioni numerate "N. testo" → "### N.\n\ntesto"
|
||
|
|
# Riconosce: "1. Testo", "42. Testo" (due o più spazi dopo il punto)
|
||
|
|
def _num_repl(m: re.Match) -> str:
|
||
|
|
num = m.group(1)
|
||
|
|
testo = m.group(2).strip()
|
||
|
|
stats["n_sezioni_numerate"] += 1
|
||
|
|
return f"### {num}.\n\n{testo}"
|
||
|
|
|
||
|
|
# Pattern standard: "1. testo" o "1. testo"
|
||
|
|
text = re.sub(
|
||
|
|
r'^(\d+)\.\s+(.+)$',
|
||
|
|
_num_repl,
|
||
|
|
text, flags=re.MULTILINE,
|
||
|
|
)
|
||
|
|
|
||
|
|
# Pattern con lettera-suffisso: "65 a. testo" o "65a. testo"
|
||
|
|
def _num_letter_repl(m: re.Match) -> str:
|
||
|
|
num = m.group(1) + m.group(2)
|
||
|
|
testo = m.group(3).strip()
|
||
|
|
stats["n_sezioni_numerate"] += 1
|
||
|
|
return f"### {num}.\n\n{testo}"
|
||
|
|
|
||
|
|
text = re.sub(
|
||
|
|
r'^(\d+)\s*([a-z])\.\s+(.+)$',
|
||
|
|
_num_letter_repl,
|
||
|
|
text, flags=re.MULTILINE,
|
||
|
|
)
|
||
|
|
|
||
|
|
# ── 5. Unisci paragrafi spezzati da salti pagina PDF
|
||
|
|
# Criterio: blocco A non finisce con punteggiatura di fine frase,
|
||
|
|
# blocco B non inizia con maiuscola "di sezione" né è un header.
|
||
|
|
# Unione sicura: mai attraverso confini ###/##.
|
||
|
|
_SENTENCE_END = set('.?!»)\'"')
|
||
|
|
blocks = text.split('\n\n')
|
||
|
|
merged = []
|
||
|
|
i = 0
|
||
|
|
while i < len(blocks):
|
||
|
|
b = blocks[i]
|
||
|
|
stripped = b.strip()
|
||
|
|
# Prova a unire con il successivo se la frase è spezzata
|
||
|
|
while (
|
||
|
|
i + 1 < len(blocks)
|
||
|
|
and stripped
|
||
|
|
and not stripped.startswith('#')
|
||
|
|
and stripped[-1] not in _SENTENCE_END
|
||
|
|
):
|
||
|
|
nxt = blocks[i + 1].strip()
|
||
|
|
# Non unire se il successivo è un header o è vuoto
|
||
|
|
if not nxt or nxt.startswith('#'):
|
||
|
|
break
|
||
|
|
# Non unire se il successivo inizia con una cifra seguita da punto
|
||
|
|
# (sarebbe l'inizio di un nuovo aforisma non ancora convertito)
|
||
|
|
if re.match(r'^\d+\.', nxt):
|
||
|
|
break
|
||
|
|
b = stripped + ' ' + nxt
|
||
|
|
stripped = b.strip()
|
||
|
|
stats["n_paragrafi_uniti"] += 1
|
||
|
|
i += 1
|
||
|
|
merged.append(b)
|
||
|
|
i += 1
|
||
|
|
text = '\n\n'.join(merged)
|
||
|
|
|
||
|
|
# ── 6. Normalizza whitespace multiplo interno alle righe
|
||
|
|
# "parola parola" → "parola parola" (inclusi gli header)
|
||
|
|
lines = text.split('\n')
|
||
|
|
normalized = []
|
||
|
|
for line in lines:
|
||
|
|
if not line.strip():
|
||
|
|
normalized.append(line)
|
||
|
|
else:
|
||
|
|
normalized.append(re.sub(r' +', ' ', line))
|
||
|
|
text = '\n'.join(normalized)
|
||
|
|
|
||
|
|
# ── 7. Riduci righe vuote multiple a doppie
|
||
|
|
text = re.sub(r'\n{3,}', '\n\n', text)
|
||
|
|
|
||
|
|
return text, stats
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Aggiornamento revision log ────────────────────────────────────────────────
|
||
|
|
|
||
|
|
def update_revision_log(
|
||
|
|
log_path: Path,
|
||
|
|
stem: str,
|
||
|
|
profile_before: dict,
|
||
|
|
profile_after: dict,
|
||
|
|
t_stats: dict,
|
||
|
|
) -> None:
|
||
|
|
header_exists = log_path.exists() and log_path.stat().st_size > 0
|
||
|
|
|
||
|
|
avv = profile_after.get("avvertenze", [])
|
||
|
|
avv_str = "; ".join(avv) if avv else "nessuna"
|
||
|
|
|
||
|
|
entry = f"""
|
||
|
|
## {stem} — {date.today().isoformat()}
|
||
|
|
|
||
|
|
**Trasformazioni automatiche:**
|
||
|
|
- Normalizzazione whitespace multiplo e righe vuote
|
||
|
|
- Blocco TOC rimosso: {'sì' if t_stats['toc_rimosso'] else 'no'}
|
||
|
|
- Righe ALL-CAPS → ## header: {t_stats['n_header_allcaps']}
|
||
|
|
- Sezioni numerate → ### header: {t_stats['n_sezioni_numerate']}
|
||
|
|
- Paragrafi uniti (salti pagina PDF): {t_stats['n_paragrafi_uniti']}
|
||
|
|
- Livello struttura: {profile_before.get('livello_struttura', '?')} → {profile_after.get('livello_struttura', '?')}
|
||
|
|
|
||
|
|
**Avvertenze residue:** {avv_str}
|
||
|
|
|
||
|
|
**Revisioni manuali pendenti:**
|
||
|
|
- [ ] Verificare conversioni ALL-CAPS errate
|
||
|
|
- [ ] Controllare sezioni troppo corte o troppo lunghe
|
||
|
|
"""
|
||
|
|
|
||
|
|
if not header_exists:
|
||
|
|
log_path.write_text("# Revision log\n" + entry, encoding="utf-8")
|
||
|
|
else:
|
||
|
|
existing = log_path.read_text(encoding="utf-8")
|
||
|
|
log_path.write_text(existing + entry, encoding="utf-8")
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Per-document processing ─────────────────────────────────────────────────
|
||
|
|
|
||
|
|
def process_stem(stem: str, project_root: Path, force: bool) -> bool:
|
||
|
|
src_dir = project_root / "step-3" / stem
|
||
|
|
out_dir = project_root / "step-4" / stem
|
||
|
|
raw_src = src_dir / "raw.md"
|
||
|
|
clean_src = src_dir / "clean.md"
|
||
|
|
profile_src = src_dir / "structure_profile.json"
|
||
|
|
clean_out = out_dir / "clean.md"
|
||
|
|
profile_out = out_dir / "structure_profile.json"
|
||
|
|
|
||
|
|
print(f"\nDocumento: {stem}")
|
||
|
|
|
||
|
|
if not clean_src.exists():
|
||
|
|
print(f" ✗ clean.md non trovato in step-3/{stem}/ — skip")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if clean_out.exists() and not force:
|
||
|
|
print(f" ⚠️ clean.md già presente — skip")
|
||
|
|
print(f" (usa --force per rieseguire)")
|
||
|
|
return True
|
||
|
|
|
||
|
|
out_dir.mkdir(parents=True, exist_ok=True)
|
||
|
|
|
||
|
|
# Copia raw.md immutabile (riferimento)
|
||
|
|
if raw_src.exists():
|
||
|
|
shutil.copy2(raw_src, out_dir / "raw.md")
|
||
|
|
print(f" Copiato raw.md da step-3/{stem}/")
|
||
|
|
|
||
|
|
# Leggi profilo step-3 (per confronto nel report)
|
||
|
|
profile_before: dict = {}
|
||
|
|
if profile_src.exists():
|
||
|
|
profile_before = json.loads(profile_src.read_text(encoding="utf-8"))
|
||
|
|
|
||
|
|
# Applica trasformazioni
|
||
|
|
print(f" Applicazione trasformazioni strutturali...")
|
||
|
|
text = clean_src.read_text(encoding="utf-8")
|
||
|
|
text_revised, t_stats = apply_transforms(text)
|
||
|
|
|
||
|
|
# Salva clean.md revisionato
|
||
|
|
clean_out.write_text(text_revised, encoding="utf-8")
|
||
|
|
|
||
|
|
# Ricalcola profilo sul nuovo clean.md
|
||
|
|
profile_after = analyze(clean_out)
|
||
|
|
profile_out.write_text(
|
||
|
|
json.dumps(profile_after, ensure_ascii=False, indent=2),
|
||
|
|
encoding="utf-8",
|
||
|
|
)
|
||
|
|
|
||
|
|
# Report
|
||
|
|
lv_b = profile_before.get("livello_struttura", "?")
|
||
|
|
lv_a = profile_after["livello_struttura"]
|
||
|
|
_STRAT = {3: "h3_aware", 2: "h2_paragraph_split", 1: "paragraph", 0: "sliding_window"}
|
||
|
|
print(f" ✅ Livello struttura: {lv_b} → {lv_a} ({_STRAT.get(lv_a, '?')})")
|
||
|
|
print(f" h2: {profile_before.get('n_h2','?')} → {profile_after['n_h2']}")
|
||
|
|
print(f" h3: {profile_before.get('n_h3','?')} → {profile_after['n_h3']}")
|
||
|
|
print(f" TOC rimosso: {'sì' if t_stats['toc_rimosso'] else 'no'}")
|
||
|
|
print(f" Righe ALL-CAPS → ##: {t_stats['n_header_allcaps']}")
|
||
|
|
print(f" Sezioni numerate → ###: {t_stats['n_sezioni_numerate']}")
|
||
|
|
print(f" Paragrafi uniti (salti pagina): {t_stats['n_paragrafi_uniti']}")
|
||
|
|
for w in profile_after["avvertenze"]:
|
||
|
|
print(f" ⚠️ {w}")
|
||
|
|
|
||
|
|
# Aggiorna revision log (direttamente in step-4/, non in sottocartella)
|
||
|
|
log_path = project_root / "step-4" / "revision_log.md"
|
||
|
|
update_revision_log(log_path, stem, profile_before, profile_after, t_stats)
|
||
|
|
print(f" ✅ step-4/revision_log.md aggiornato")
|
||
|
|
print(f" ✅ structure_profile.json salvato")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Entry point ─────────────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
if __name__ == "__main__":
|
||
|
|
project_root = Path(__file__).parent.parent
|
||
|
|
|
||
|
|
parser = argparse.ArgumentParser(description="Step 4 — Revisione automatica Markdown")
|
||
|
|
parser.add_argument("--stem", help="Nome del documento (sottocartella di step-3/)")
|
||
|
|
parser.add_argument("--force", action="store_true", help="Riesegui anche se già presente")
|
||
|
|
args = parser.parse_args()
|
||
|
|
|
||
|
|
if args.stem:
|
||
|
|
stems = [args.stem]
|
||
|
|
else:
|
||
|
|
step3_dir = project_root / "step-3"
|
||
|
|
if not step3_dir.exists():
|
||
|
|
print(f"Errore: cartella step-3/ non trovata in {project_root}")
|
||
|
|
sys.exit(1)
|
||
|
|
stems = sorted(p.name for p in step3_dir.iterdir() if p.is_dir())
|
||
|
|
if not stems:
|
||
|
|
print(f"Errore: nessun documento trovato in step-3/")
|
||
|
|
sys.exit(1)
|
||
|
|
|
||
|
|
results = [process_stem(s, project_root, args.force) for s in stems]
|
||
|
|
|
||
|
|
ok = sum(results)
|
||
|
|
total = len(results)
|
||
|
|
print(f"\n{'✅' if all(results) else '⚠️ '} {ok}/{total} documenti revisionati")
|
||
|
|
|
||
|
|
sys.exit(0 if all(results) else 1)
|