221 lines
9.3 KiB
Python
221 lines
9.3 KiB
Python
|
"""Orchestrazione della pipeline PDF → Markdown a 9 stadi."""
|
||
|
|
import json
|
||
|
|
import sys
|
||
|
|
import threading
|
||
|
|
import time
|
||
|
|
from pathlib import Path
|
||
|
|
|
||
|
|
from .extract import validate_pdf, extract_metadata
|
||
|
|
from .stage1_metadata import extract_raw_data_with_pdfplumber_fallback as extract_raw_data
|
||
|
|
from .stage2_layout import analyze_layout
|
||
|
|
from .stage3_font import build_font_profile
|
||
|
|
from .stage4_headers import classify_blocks
|
||
|
|
from .stage5_hierarchy import infer_hierarchy
|
||
|
|
from .stage6_tree import build_tree
|
||
|
|
from .stage7_markdown import serialize_tree
|
||
|
|
from .stage8_normalize import normalize_hierarchy
|
||
|
|
from .stage9_validate import validate_markdown
|
||
|
|
from .structure import analyze
|
||
|
|
from .report import build_report
|
||
|
|
from .validator import _score, _grade
|
||
|
|
|
||
|
|
|
||
|
|
_LIVELLO_DESC = {3: "ricca (h3)", 2: "parziale (h2)", 1: "paragrafi", 0: "testo piatto"}
|
||
|
|
_SPIN_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
|
||
|
|
|
||
|
|
|
||
|
|
def _build_frontmatter(meta: dict) -> str:
|
||
|
|
lines = ["---", f"source: {meta['source']}"]
|
||
|
|
if meta.get("title"):
|
||
|
|
lines.append(f'title: "{meta["title"]}"')
|
||
|
|
if meta.get("author"):
|
||
|
|
lines.append(f'author: "{meta["author"]}"')
|
||
|
|
if meta.get("year"):
|
||
|
|
lines.append(f"year: {meta['year']}")
|
||
|
|
if meta.get("pages"):
|
||
|
|
lines.append(f"pages: {meta['pages']}")
|
||
|
|
lines += ["---", ""]
|
||
|
|
return "\n".join(lines) + "\n"
|
||
|
|
|
||
|
|
|
||
|
|
class _Spinner:
|
||
|
|
def __init__(self, prefix: str):
|
||
|
|
self._prefix = prefix
|
||
|
|
self._stop = threading.Event()
|
||
|
|
self._thread = threading.Thread(target=self._run, daemon=True)
|
||
|
|
self._t0 = 0.0
|
||
|
|
|
||
|
|
def __enter__(self):
|
||
|
|
self._t0 = time.perf_counter()
|
||
|
|
self._thread.start()
|
||
|
|
return self
|
||
|
|
|
||
|
|
def __exit__(self, *_):
|
||
|
|
self._stop.set()
|
||
|
|
self._thread.join()
|
||
|
|
sys.stdout.write("\r" + " " * 72 + "\r")
|
||
|
|
sys.stdout.flush()
|
||
|
|
|
||
|
|
def _run(self):
|
||
|
|
i = 0
|
||
|
|
while not self._stop.wait(0.1):
|
||
|
|
elapsed = time.perf_counter() - self._t0
|
||
|
|
frame = _SPIN_FRAMES[i % len(_SPIN_FRAMES)]
|
||
|
|
sys.stdout.write(f"\r {frame} {self._prefix} {elapsed:.0f}s")
|
||
|
|
sys.stdout.flush()
|
||
|
|
i += 1
|
||
|
|
|
||
|
|
|
||
|
|
def run(stem: str, project_root: Path, force: bool) -> bool:
|
||
|
|
pdf_path = project_root / "sources" / f"{stem}.pdf"
|
||
|
|
out_dir = project_root / "conversione" / stem
|
||
|
|
raw_out = out_dir / "raw.md"
|
||
|
|
clean_out = out_dir / "clean.md"
|
||
|
|
|
||
|
|
print(f"\n{'─' * 52}")
|
||
|
|
print(f" {stem}")
|
||
|
|
print(f"{'─' * 52}")
|
||
|
|
|
||
|
|
if clean_out.exists() and not force:
|
||
|
|
print(f" ⚠️ conversione/{stem}/clean.md già presente — skip")
|
||
|
|
print(f" (usa --force per rieseguire)")
|
||
|
|
return True
|
||
|
|
|
||
|
|
# ── [1] Validazione PDF ───────────────────────────────────────────────────
|
||
|
|
print(" [1/9] Validazione PDF...")
|
||
|
|
pdf_mb = pdf_path.stat().st_size / (1024 * 1024) if pdf_path.exists() else 0
|
||
|
|
print(f" File: {pdf_path.name} ({pdf_mb:.1f} MB)")
|
||
|
|
|
||
|
|
ok, msg = validate_pdf(pdf_path)
|
||
|
|
if not ok:
|
||
|
|
print(f" ✗ {msg}")
|
||
|
|
return False
|
||
|
|
print(f" ✅ {msg}")
|
||
|
|
|
||
|
|
meta = extract_metadata(pdf_path)
|
||
|
|
meta["source"] = pdf_path.name
|
||
|
|
if meta.get("title"):
|
||
|
|
print(f" Titolo: {meta['title']}")
|
||
|
|
if meta.get("author"):
|
||
|
|
print(f" Autore: {meta['author']}")
|
||
|
|
|
||
|
|
# ── [2] Stage 1: estrazione span ──────────────────────────────────────────
|
||
|
|
print(" [2/9] Stage 1: Estrazione span PyMuPDF...")
|
||
|
|
with _Spinner("Lettura PDF con PyMuPDF..."):
|
||
|
|
try:
|
||
|
|
raw_blocks, doc_meta = extract_raw_data(pdf_path)
|
||
|
|
except Exception as e:
|
||
|
|
print(f" ✗ Estrazione fallita: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print(f" ✅ {len(raw_blocks)} span estratti da {doc_meta['page_count']} pagine")
|
||
|
|
toc_entries = len(doc_meta.get("toc", []))
|
||
|
|
if toc_entries:
|
||
|
|
print(f" TOC: {toc_entries} voci")
|
||
|
|
|
||
|
|
# ── [3] Stage 2: layout ───────────────────────────────────────────────────
|
||
|
|
print(" [3/9] Stage 2: Analisi layout e reading order...")
|
||
|
|
with _Spinner("Analisi layout..."):
|
||
|
|
blocks = analyze_layout(raw_blocks, doc_meta)
|
||
|
|
print(f" ✅ {len(blocks)} blocchi dopo layout analysis")
|
||
|
|
|
||
|
|
# ── [4] Stage 3: font analysis ────────────────────────────────────────────
|
||
|
|
print(" [4/9] Stage 3: Font analysis...")
|
||
|
|
profile = build_font_profile(blocks)
|
||
|
|
print(f" ✅ Body size: {profile.body_size}pt "
|
||
|
|
f"Header sizes: {profile.header_sizes}")
|
||
|
|
|
||
|
|
# ── [5] Stage 4: header detection ─────────────────────────────────────────
|
||
|
|
print(" [5/9] Stage 4: Header detection...")
|
||
|
|
blocks = classify_blocks(blocks, profile)
|
||
|
|
n_candidates = sum(1 for b in blocks if b.block_type == "header_candidate")
|
||
|
|
print(f" ✅ {n_candidates} header candidate rilevati")
|
||
|
|
|
||
|
|
# ── [6] Stage 5: hierarchy inference ─────────────────────────────────────
|
||
|
|
print(" [6/9] Stage 5: Hierarchy inference...")
|
||
|
|
blocks = infer_hierarchy(blocks, profile, doc_meta.get("toc", []))
|
||
|
|
from collections import Counter
|
||
|
|
level_dist = Counter(b.level for b in blocks if b.block_type == "header_candidate")
|
||
|
|
print(f" ✅ H1={level_dist.get(1,0)} H2={level_dist.get(2,0)} H3={level_dist.get(3,0)}")
|
||
|
|
|
||
|
|
# ── [7] Stage 6: document tree ────────────────────────────────────────────
|
||
|
|
print(" [7/9] Stage 6: Document tree reconstruction...")
|
||
|
|
tree = build_tree(blocks)
|
||
|
|
print(f" ✅ {len(tree)} sezioni radice")
|
||
|
|
|
||
|
|
# ── [8] Stage 7: markdown generation ─────────────────────────────────────
|
||
|
|
print(" [8/9] Stage 7: Markdown generation...")
|
||
|
|
with _Spinner("Serializzazione albero..."):
|
||
|
|
raw_md = serialize_tree(tree, meta, pdf_path=pdf_path)
|
||
|
|
|
||
|
|
size_kb = len(raw_md.encode()) // 1024
|
||
|
|
n_lines = raw_md.count("\n")
|
||
|
|
print(f" ✅ raw.md: {size_kb} KB, {n_lines} righe")
|
||
|
|
|
||
|
|
# Scrittura raw.md (IMMUTABILE)
|
||
|
|
try:
|
||
|
|
out_dir.mkdir(parents=True, exist_ok=True)
|
||
|
|
if not raw_out.exists() or force:
|
||
|
|
raw_out.write_text(raw_md, encoding="utf-8")
|
||
|
|
except PermissionError as e:
|
||
|
|
print(f" ✗ Permesso negato durante la scrittura: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
# ── [9] Stage 8+9: normalizzazione + validazione ──────────────────────────
|
||
|
|
print(" [9/9] Stage 8-9: Normalize + validate...")
|
||
|
|
clean_md, norm_stats = normalize_hierarchy(raw_md)
|
||
|
|
validation = validate_markdown(clean_md, meta.get("pages", 0))
|
||
|
|
|
||
|
|
if norm_stats["n_level_jumps_repaired"]:
|
||
|
|
print(f" Salti livello riparati: {norm_stats['n_level_jumps_repaired']}")
|
||
|
|
if norm_stats["n_empty_headers_removed"]:
|
||
|
|
print(f" Header vuoti rimossi: {norm_stats['n_empty_headers_removed']}")
|
||
|
|
if norm_stats["n_duplicate_headers_removed"]:
|
||
|
|
print(f" Header duplicati rimossi: {norm_stats['n_duplicate_headers_removed']}")
|
||
|
|
|
||
|
|
for w in validation.warnings:
|
||
|
|
print(f" ⚠️ {w}")
|
||
|
|
for e in validation.errors:
|
||
|
|
print(f" ✗ {e}")
|
||
|
|
|
||
|
|
# Aggiungi frontmatter a clean.md
|
||
|
|
frontmatter = _build_frontmatter(meta)
|
||
|
|
full_clean = frontmatter + clean_md
|
||
|
|
|
||
|
|
try:
|
||
|
|
clean_out.write_text(full_clean, encoding="utf-8")
|
||
|
|
except PermissionError as e:
|
||
|
|
print(f" ✗ Permesso negato durante la scrittura di clean.md: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print(f" ✅ clean.md scritto")
|
||
|
|
|
||
|
|
# ── Analisi struttura + report + score ────────────────────────────────────
|
||
|
|
profile_struct = analyze(clean_out)
|
||
|
|
(out_dir / "structure_profile.json").write_text(
|
||
|
|
json.dumps(profile_struct, ensure_ascii=False, indent=2), encoding="utf-8"
|
||
|
|
)
|
||
|
|
|
||
|
|
print(f" Struttura: livello {profile_struct['livello_struttura']} — "
|
||
|
|
f"{_LIVELLO_DESC[profile_struct['livello_struttura']]}")
|
||
|
|
print(f" h1={profile_struct['n_h1']} h2={profile_struct['n_h2']} "
|
||
|
|
f"h3={profile_struct['n_h3']} paragrafi={profile_struct['n_paragrafi']}")
|
||
|
|
print(f" Strategia chunking: {profile_struct['strategia_chunking']}")
|
||
|
|
print(f" Lingua rilevata: {profile_struct['lingua_rilevata']}")
|
||
|
|
for w in profile_struct["avvertenze"]:
|
||
|
|
print(f" ⚠️ {w}")
|
||
|
|
|
||
|
|
t_stats = {
|
||
|
|
**norm_stats,
|
||
|
|
"validation": validation.to_dict(),
|
||
|
|
}
|
||
|
|
reduction = 100.0 * (1 - len(clean_md) / len(raw_md)) if raw_md else 0.0
|
||
|
|
report_path = build_report(stem, out_dir, full_clean, t_stats, profile_struct, reduction)
|
||
|
|
report_data = json.loads(report_path.read_text(encoding="utf-8"))
|
||
|
|
score, _ = _score(report_data)
|
||
|
|
|
||
|
|
print(f"\n Output → conversione/{stem}/")
|
||
|
|
print(f" raw.md (immutabile) clean.md report.json")
|
||
|
|
print(f" Punteggio qualità: {score}/100 {_grade(score)}")
|
||
|
|
return True
|