Upload 6 files

src/reporter/__init__.py

@@ -0,0 +1 @@
+"""BDC report generator package."""

src/reporter/docx_fill.py

@@ -0,0 +1,591 @@
+from __future__ import annotations
+
+import re
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Tuple
+
+import numpy as np
+import pandas as pd
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from docx import Document
+from docx.enum.table import WD_CELL_VERTICAL_ALIGNMENT, WD_TABLE_ALIGNMENT
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+from docx.shared import Cm, Pt
+
+SCORE_MAP: Dict[str, int] = {
+    "Absent": 1,
+    "Minimum": 2,
+    "Sufficient": 3,
+    "Good": 4,
+    "Excellent": 5,
+    "Top": 6,
+}
+
+
+def to_score(x) -> float:
+    if pd.isna(x):
+        return float("nan")
+    if isinstance(x, (int, float, np.integer, np.floating)):
+        return float(x)
+    s = str(x).strip()
+    return float(SCORE_MAP.get(s, np.nan))
+
+
+def label_color(label) -> str:
+    """Return hex fill for a verbal label (no '#')."""
+    if pd.isna(label):
+        return "FFFFFF"
+    s = str(label).strip()
+    if s in ("Top", "Excellent"):
+        return "C6EFCE"  # light green
+    if s in ("Good", "Sufficient"):
+        return "FFEB9C"  # light yellow
+    if s in ("Minimum", "Absent"):
+        return "FFC7CE"  # light red
+    return "FFFFFF"
+
+
+def extract_competence_blocks(columns: Iterable[str]) -> List[dict]:
+    """Infer competences from 'Commento qualitativo - ...' blocks.
+
+    For each competence, we assume exactly 4 indicator columns immediately
+    before the comment column.
+    """
+    cols = list(columns)
+    comment_cols = [
+        c
+        for c in cols
+        if isinstance(c, str) and c.strip().lower().startswith("commento qualitativo -")
+    ]
+    blocks = []
+    for c in comment_cols:
+        idx = cols.index(c)
+        indicator_cols = cols[idx - 4 : idx]
+        name = c.split("-", 1)[1].strip()
+        blocks.append({"name": name, "indicator_cols": indicator_cols, "comment_col": c})
+    return blocks
+
+
+def wrap_label(s: str, width: int = 14) -> str:
+    return "\n".join(textwrap.wrap(str(s), width=width, break_long_words=False))
+
+
+def radar_chart(names: List[str], auto_vals: List[float], valut_vals: List[float], out_png: Path) -> None:
+    """Radar con 2 sole serie (AUTO vs VALUT).
+
+    Nota estetica: niente aree piene (o riempimento quasi trasparente) per evitare l'effetto
+    "troppe aree" con 11 competenze; legenda grande e fuori dal grafico.
+    """
+
+    labels = [wrap_label(n, 18) for n in names]
+    n = len(labels)
+    angles = np.linspace(0, 2 * np.pi, n, endpoint=False).tolist()
+    angles += angles[:1]
+
+    a = list(auto_vals) + [auto_vals[0]]
+    v = list(valut_vals) + [valut_vals[0]]
+
+    # Figura più larga per ospitare la legenda fuori dal grafico
+    fig = plt.figure(figsize=(9.0, 7.2), dpi=220)
+    ax = plt.subplot(111, polar=True)
+
+    ax.set_theta_offset(np.pi / 2)
+    ax.set_theta_direction(-1)
+
+    ax.set_thetagrids(np.degrees(angles[:-1]), labels, fontsize=9)
+    ax.tick_params(axis='x', pad=28)
+    ax.set_ylim(0, 6)
+    ax.set_yticks([1, 2, 3, 4, 5, 6])
+    ax.set_yticklabels(["1", "2", "3", "4", "5", "6"], fontsize=8)
+
+    # Linee (niente riempimento) per una lettura più pulita
+    ax.plot(angles, v, linewidth=2.4, color="#1f77b4", label="Valutazione")
+    ax.plot(angles, a, linewidth=2.4, color="#ff7f0e", label="Autovalutazione")
+
+    # Griglia un filo più leggera
+    ax.grid(alpha=0.35)
+
+    # Legenda: grande e fuori, dentro la figura (a destra)
+    ax.legend(
+        loc="center left",
+        bbox_to_anchor=(1.04, 0.5),
+        frameon=False,
+        fontsize=12,
+    )
+
+    # Lascia spazio a destra per la legenda
+    fig.subplots_adjust(left=0.05, right=0.80, top=0.95, bottom=0.07)
+
+    fig.savefig(out_png, transparent=True, bbox_inches="tight", pad_inches=0.25)
+    plt.close(fig)
+
+
+def bar_chart(auto_mean: float, valut_mean: float, out_png: Path) -> None:
+    """Barre AUTO vs VALUT con legenda grande fuori dal grafico."""
+
+    fig = plt.figure(figsize=(7.2, 3.4), dpi=220)
+    ax = plt.gca()
+
+    ax.bar([0], [valut_mean], width=0.42, color="#1f77b4", label="Valutazione")
+    ax.bar([0.5], [auto_mean], width=0.42, color="#ff7f0e", label="Autovalutazione")
+
+    ax.set_ylim(0, 6)
+    ax.set_xticks([0.25])
+    ax.set_xticklabels([""], fontsize=10)
+    ax.set_yticks([1, 2, 3, 4, 5, 6])
+    ax.grid(axis="y", alpha=0.28)
+
+    for x, y in [(0, valut_mean), (0.5, auto_mean)]:
+        ax.text(x, y + 0.12, f"{y:.2f}", ha="center", va="bottom", fontsize=10)
+
+    # Legenda fuori (a destra), più grande
+    ax.legend(
+        loc="center left",
+        bbox_to_anchor=(1.01, 0.8),
+        frameon=False,
+        fontsize=11,
+    )
+
+    fig.subplots_adjust(left=0.08, right=0.80, top=0.92, bottom=0.18)
+    fig.savefig(out_png, transparent=True, bbox_inches="tight", pad_inches=0.18)
+    plt.close(fig)
+def _set_cell_shading(cell, fill: str) -> None:
+    tcPr = cell._tc.get_or_add_tcPr()
+    shd = OxmlElement("w:shd")
+    shd.set(qn("w:val"), "clear")
+    shd.set(qn("w:color"), "auto")
+    shd.set(qn("w:fill"), fill)
+    tcPr.append(shd)
+
+
+def _set_cell_text(cell, text, *, bold=False, align="left", font_size=9) -> None:
+    cell.text = ""
+    p = cell.paragraphs[0]
+    run = p.add_run(str(text) if text is not None else "")
+    run.bold = bold
+    run.font.size = Pt(font_size)
+    if align == "center":
+        p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    elif align == "right":
+        p.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+    else:
+        p.alignment = WD_ALIGN_PARAGRAPH.LEFT
+    cell.vertical_alignment = WD_CELL_VERTICAL_ALIGNMENT.CENTER
+
+
+def _insert_table_after(paragraph, rows: int, cols: int, width_cm: float = 17.0):
+    tbl = paragraph._parent.add_table(rows=rows, cols=cols, width=Cm(width_cm))
+    paragraph._p.addnext(tbl._tbl)
+    return tbl
+
+
+def _delete_paragraph(paragraph) -> None:
+    p = paragraph._element
+    p.getparent().remove(p)
+    paragraph._p = paragraph._element = None
+
+
+def _clear_paragraph(paragraph) -> None:
+    for r in paragraph.runs:
+        r.text = ""
+
+
+def _replace_paragraph_with_picture(paragraph, image_path: Path, *, width_cm: float) -> None:
+    _clear_paragraph(paragraph)
+    run = paragraph.add_run()
+    run.add_picture(str(image_path), width=Cm(width_cm))
+    paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+
+def _table_header(tbl, headers: List[str]) -> None:
+    for j, h in enumerate(headers):
+        c = tbl.cell(0, j)
+        _set_cell_text(c, h, bold=True, align="center", font_size=9)
+        _set_cell_shading(c, "D9D9D9")
+
+
+def _build_table_3_2(paragraph, comp_df: pd.DataFrame) -> None:
+    tbl = _insert_table_after(paragraph, rows=len(comp_df) + 1, cols=3)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+    _table_header(tbl, ["Competenza", "Autovalutazione", "Valutazione"])
+
+    for i, (_, row) in enumerate(comp_df.iterrows(), start=1):
+        _set_cell_text(tbl.cell(i, 0), row["competenza"], align="left", font_size=9)
+        _set_cell_text(tbl.cell(i, 1), f"{row['auto']:.2f}", align="center")
+        _set_cell_text(tbl.cell(i, 2), f"{row['valut']:.2f}", align="center")
+
+    tbl.columns[0].width = Cm(12.5)
+    tbl.columns[1].width = Cm(2.5)
+    tbl.columns[2].width = Cm(2.5)
+    _delete_paragraph(paragraph)
+
+
+def _build_table_gap_4_1(paragraph, df: pd.DataFrame) -> None:
+    tbl = _insert_table_after(paragraph, rows=len(df) + 1, cols=5)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+    _table_header(tbl, ["Competenza", "Autoval.", "Valut.", "Gap", "Trend"])
+
+    for i, (_, r) in enumerate(df.iterrows(), start=1):
+        _set_cell_text(tbl.cell(i, 0), r["competenza"], align="left", font_size=9)
+        _set_cell_text(tbl.cell(i, 1), f"{r['auto']:.2f}", align="center")
+        _set_cell_text(tbl.cell(i, 2), f"{r['valut']:.2f}", align="center")
+        _set_cell_text(tbl.cell(i, 3), f"{r['diff']:+.2f}", align="center")
+        _set_cell_text(tbl.cell(i, 4), r["trend"], align="center", font_size=11)
+
+    tbl.columns[0].width = Cm(10.8)
+    for j in range(1, 5):
+        tbl.columns[j].width = Cm(1.9)
+    _delete_paragraph(paragraph)
+
+
+def _build_table_gap_4_2(paragraph, df: pd.DataFrame) -> None:
+    tbl = _insert_table_after(paragraph, rows=len(df) + 1, cols=3)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+    _table_header(tbl, ["Competenza", "Valut.", "Gap da Top"])
+
+    for i, (_, r) in enumerate(df.iterrows(), start=1):
+        _set_cell_text(tbl.cell(i, 0), r["competenza"], align="left", font_size=9)
+        _set_cell_text(tbl.cell(i, 1), f"{r['valut']:.2f}", align="center")
+        _set_cell_text(tbl.cell(i, 2), f"{r['gap_top']:.2f}", align="center")
+
+    tbl.columns[0].width = Cm(12.5)
+    tbl.columns[1].width = Cm(2.5)
+    tbl.columns[2].width = Cm(2.5)
+    _delete_paragraph(paragraph)
+
+
+def _build_table_indicators(paragraph, indicators: List[dict]) -> None:
+    tbl = _insert_table_after(paragraph, rows=len(indicators) + 1, cols=3)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+    _table_header(tbl, ["Comportamento osservabile", "Autovalutazione", "Valutazione"])
+
+    for i, ind in enumerate(indicators, start=1):
+        _set_cell_text(tbl.cell(i, 0), ind["text"], align="left", font_size=8.5)
+
+        cA = tbl.cell(i, 1)
+        _set_cell_text(cA, ind["auto_label"], align="center")
+        _set_cell_shading(cA, label_color(ind["auto_label"]))
+
+        cV = tbl.cell(i, 2)
+        _set_cell_text(cV, ind["valut_label"], align="center")
+        _set_cell_shading(cV, label_color(ind["valut_label"]))
+
+    tbl.columns[0].width = Cm(12.0)
+    tbl.columns[1].width = Cm(2.6)
+    tbl.columns[2].width = Cm(2.6)
+    _delete_paragraph(paragraph)
+
+
+def _build_table_comments(paragraph, auto_comment, valut_comment) -> None:
+    tbl = _insert_table_after(paragraph, rows=3, cols=2)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+
+    _table_header(tbl, ["Fonte", "Commento qualitativo"])
+    _set_cell_text(tbl.cell(1, 0), "Autovalutazione", bold=True, align="left")
+    _set_cell_text(tbl.cell(1, 1), auto_comment if pd.notna(auto_comment) else "", align="left")
+    _set_cell_text(tbl.cell(2, 0), "Valutazione", bold=True, align="left")
+    _set_cell_text(tbl.cell(2, 1), valut_comment if pd.notna(valut_comment) else "", align="left")
+
+    tbl.columns[0].width = Cm(4.0)
+    tbl.columns[1].width = Cm(13.4)
+    _delete_paragraph(paragraph)
+
+
+def _build_table_behaviors(paragraph, rows: List[dict]) -> None:
+    tbl = _insert_table_after(paragraph, rows=len(rows) + 1, cols=3)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+    _table_header(tbl, ["Comportamento osservabile", "Competenza", "Valutazione"])
+
+    for i, r in enumerate(rows, start=1):
+        _set_cell_text(tbl.cell(i, 0), r["indicator"], align="left", font_size=8.5)
+        _set_cell_text(tbl.cell(i, 1), r["competenza"], align="left", font_size=8.5)
+        c = tbl.cell(i, 2)
+        _set_cell_text(c, r["label"], align="center")
+        _set_cell_shading(c, label_color(r["label"]))
+
+    tbl.columns[0].width = Cm(9.5)
+    tbl.columns[1].width = Cm(5.8)
+    tbl.columns[2].width = Cm(2.8)
+    _delete_paragraph(paragraph)
+
+
+def _build_table_tech(paragraph, auto_text, valut_text) -> None:
+    tbl = _insert_table_after(paragraph, rows=2, cols=2)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+
+    _table_header(tbl, ["Autovalutazione", "Valutazione manager"])
+    _set_cell_text(tbl.cell(1, 0), auto_text if pd.notna(auto_text) else "", align="left")
+    _set_cell_text(tbl.cell(1, 1), valut_text if pd.notna(valut_text) else "", align="left")
+
+    tbl.columns[0].width = Cm(8.6)
+    tbl.columns[1].width = Cm(8.6)
+    _delete_paragraph(paragraph)
+
+
+def _build_table_feedback(paragraph, qas: List[Tuple[str, str]]) -> None:
+    tbl = _insert_table_after(paragraph, rows=len(qas) + 1, cols=2)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+    _table_header(tbl, ["Domanda", "Risposta"])
+
+    for i, (q, a) in enumerate(qas, start=1):
+        _set_cell_text(tbl.cell(i, 0), q, align="left", font_size=8.5)
+        _set_cell_text(tbl.cell(i, 1), a if pd.notna(a) else "", align="left")
+
+    tbl.columns[0].width = Cm(6.5)
+    tbl.columns[1].width = Cm(10.7)
+    _delete_paragraph(paragraph)
+
+
+def _build_table_priority(paragraph, priorities: List[str], valut_by_comp: Dict[str, float]) -> None:
+    rows = []
+    for rank, comp in enumerate(priorities, start=1):
+        key = comp.lower()
+        if key in valut_by_comp:
+            rows.append((rank, comp, valut_by_comp[key]))
+
+    tbl = _insert_table_after(paragraph, rows=len(rows) + 1, cols=3)
+    tbl.alignment = WD_TABLE_ALIGNMENT.CENTER
+    tbl.style = "Table Grid"
+    _table_header(tbl, ["Priorità", "Competenza", "Valutazione"])
+
+    for i, (rank, comp, val) in enumerate(rows, start=1):
+        _set_cell_text(tbl.cell(i, 0), str(rank), align="center")
+        _set_cell_text(tbl.cell(i, 1), comp, align="left")
+        _set_cell_text(tbl.cell(i, 2), f"{val:.2f}", align="center")
+
+    tbl.columns[0].width = Cm(2.0)
+    tbl.columns[1].width = Cm(12.5)
+    tbl.columns[2].width = Cm(2.5)
+    _delete_paragraph(paragraph)
+
+
+@dataclass
+class PersonData:
+    name: str
+    comps: List[dict]
+    auto_row: pd.Series
+    valut_row: pd.Series
+
+
+def build_person_data(df_auto: pd.DataFrame, df_valut: pd.DataFrame, name: str) -> PersonData:
+    # Robust selection: if a row is missing in AUTO or VALUT, we keep NaN/empty values.
+    if "Nome e cognome" not in df_auto.columns:
+        raise ValueError("Colonna 'Nome e cognome' non trovata nel file AUTO.")
+    if "Nome e cognome" not in df_valut.columns:
+        raise ValueError("Colonna 'Nome e cognome' non trovata nel file VALUT.")
+
+    auto_match = df_auto[df_auto["Nome e cognome"] == name]
+    valut_match = df_valut[df_valut["Nome e cognome"] == name]
+
+    auto_row = auto_match.iloc[-1] if len(auto_match) else pd.Series({c: np.nan for c in df_auto.columns})
+    valut_row = valut_match.iloc[-1] if len(valut_match) else pd.Series({c: np.nan for c in df_valut.columns})
+
+    blocks = extract_competence_blocks(df_auto.columns)
+    comps = []
+
+    for b in blocks:
+        auto_labels = [auto_row[c] for c in b["indicator_cols"]]
+        valut_labels = [valut_row.get(c, np.nan) for c in b["indicator_cols"]]
+
+        auto_scores = [to_score(x) for x in auto_labels]
+        valut_scores = [to_score(x) for x in valut_labels]
+
+        comps.append(
+            {
+                "name": b["name"],
+                "indicator_texts": b["indicator_cols"],
+                "auto_labels": auto_labels,
+                "valut_labels": valut_labels,
+                "auto_scores": auto_scores,
+                "valut_scores": valut_scores,
+                "auto_mean": float(np.nanmean(auto_scores)),
+                "valut_mean": float(np.nanmean(valut_scores)),
+                "auto_comment": auto_row[b["comment_col"]],
+                "valut_comment": valut_row.get(b["comment_col"], np.nan),
+            }
+        )
+
+    return PersonData(name=name, comps=comps, auto_row=auto_row, valut_row=valut_row)
+
+
+def fill_template(
+    template_path: Path,
+    out_docx: Path,
+    df_auto: pd.DataFrame,
+    df_valut: pd.DataFrame,
+    person_name: str,
+    kind: str,
+    *,
+    workdir: Path,
+) -> Path:
+    """Fill a Word template replacing only placeholders (template formatting stays intact)."""
+
+    doc = Document(str(template_path))
+    pdata = build_person_data(df_auto, df_valut, person_name)
+    comps = pdata.comps
+
+    comp_df = pd.DataFrame(
+        [{"competenza": c["name"], "auto": c["auto_mean"], "valut": c["valut_mean"]} for c in comps]
+    )
+    comp_df_sorted = comp_df.sort_values("valut", ascending=False).reset_index(drop=True)
+
+    gap_df = comp_df.copy()
+    gap_df["diff"] = gap_df["valut"] - gap_df["auto"]
+
+    def trend(diff: float) -> str:
+        if -0.5 <= diff <= 0.5:
+            return "↔"
+        if diff < -0.5:
+            return "↑"
+        return "↓"
+
+    gap_df["trend"] = gap_df["diff"].apply(trend)
+    gap_df["abs"] = gap_df["diff"].abs()
+    gap_df = gap_df.sort_values(["abs", "diff"], ascending=[False, False]).drop(columns=["abs"]).reset_index(drop=True)
+
+    gtop = comp_df.copy()
+    gtop["gap_top"] = 6 - gtop["valut"]
+    gtop = gtop.sort_values("gap_top", ascending=False).reset_index(drop=True)
+
+    behaviors = []
+    for c in comps:
+        for txt, label, score in zip(c["indicator_texts"], c["valut_labels"], c["valut_scores"]):
+            if pd.notna(score):
+                behaviors.append({"indicator": txt, "competenza": c["name"], "label": label, "score": float(score)})
+    beh_df = pd.DataFrame(behaviors)
+    beh_top = beh_df.sort_values("score", ascending=False).head(10).to_dict("records")
+    beh_bot = beh_df.sort_values("score", ascending=True).head(10).to_dict("records")
+
+    # Charts
+    img_dir = workdir / re.sub(r"[^A-Za-z0-9_-]+", "_", person_name)
+    img_dir.mkdir(parents=True, exist_ok=True)
+
+    radar_png = img_dir / "radar.png"
+    radar_chart([c["name"] for c in comps], [c["auto_mean"] for c in comps], [c["valut_mean"] for c in comps], radar_png)
+
+    comp_bar: Dict[int, Path] = {}
+    for idx, c in enumerate(comps, start=1):
+        png = img_dir / f"bar_{idx}.png"
+        bar_chart(c["auto_mean"], c["valut_mean"], png)
+        comp_bar[idx] = png
+
+    # Qualitative
+    fb_qs = [
+        "Quale comportamento/atteggiamento dovrebbe continuare ad agire il mio responsabile?",
+        "Quale comportamento/atteggiamento dovrebbe iniziare ad agire?",
+        "Quale comportamento/atteggiamento suggerisco di smettere di agire?",
+    ]
+    qas = [(q, pdata.auto_row.get(q, "")) for q in fb_qs]
+
+    auto_tech = ""
+    val_tech = ""
+    if kind == "collaboratori":
+        auto_tech_q = [
+            c for c in df_auto.columns if isinstance(c, str) and c.strip().lower().startswith("indica 1 competenza tecnica")
+        ]
+        val_tech_q = [
+            c for c in df_valut.columns if isinstance(c, str) and c.strip().lower().startswith("indica 1 competenza tecnica")
+        ]
+        if auto_tech_q:
+            auto_tech = pdata.auto_row.get(auto_tech_q[0], "")
+        if val_tech_q:
+            val_tech = pdata.valut_row.get(val_tech_q[0], "")
+
+    priorities = [
+        "Attenzione alla qualità",
+        "Capacità di comunicazione efficace e ascolto attivo",
+        "Spirito di iniziativa e orientamento al risultato",
+        "Proporre decisioni e lavorare con senso di responsabilità",
+        "Orientamento al cliente (interno/esterno)",
+    ]
+    valut_by_comp = {c["name"].lower(): float(c["valut_mean"]) for c in comps}
+
+    # Replace placeholders
+    done_radar = False
+    for p in list(doc.paragraphs):
+        t = p.text.strip().replace("\t", "")
+
+        if t == "[@NomeCognome]":
+            # Mantieni lo stile del template: sostituisci solo il placeholder.
+            _clear_paragraph(p)
+            p.add_run(person_name)
+
+        elif t == "[@GraficoSezione3.2]":
+            if kind == "manager" and done_radar:
+                _delete_paragraph(p)
+            else:
+                _replace_paragraph_with_picture(p, radar_png, width_cm=16.2)
+                done_radar = True
+
+        elif t == "[@TabellaSezione3.2]":
+            _build_table_3_2(p, comp_df_sorted)
+
+        elif t == "[@TabellaSezione4.1]":
+            _build_table_gap_4_1(p, gap_df)
+
+        elif t == "[@TabellaSezione4.2]":
+            _build_table_gap_4_2(p, gtop)
+
+        else:
+            m = re.fullmatch(r"\[@GraficoSezione5\.(\d+)\]", t)
+            if m:
+                idx = int(m.group(1))
+                if idx in comp_bar:
+                    _replace_paragraph_with_picture(p, comp_bar[idx], width_cm=15.6)
+                continue
+
+            m = re.fullmatch(r"\[@Tabella1Sezione5\.(\d+)\]", t)
+            if m:
+                idx = int(m.group(1))
+                if 1 <= idx <= len(comps):
+                    c = comps[idx - 1]
+                    indicators = [
+                        {"text": txt, "auto_label": al, "valut_label": vl}
+                        for txt, al, vl in zip(c["indicator_texts"], c["auto_labels"], c["valut_labels"])
+                    ]
+                    _build_table_indicators(p, indicators)
+                continue
+
+            m = re.fullmatch(r"\[@Tabella2Sezione5\.(\d+)\]", t)
+            if m:
+                idx = int(m.group(1))
+                if 1 <= idx <= len(comps):
+                    c = comps[idx - 1]
+                    _build_table_comments(p, c["auto_comment"], c["valut_comment"])
+                continue
+
+            if t == "[@TabellaSezione6.1]":
+                _build_table_behaviors(p, beh_top)
+            elif t == "[@TabellaSezione6.2]":
+                _build_table_behaviors(p, beh_bot)
+            elif t == "[@TabellaSezione7.1]":
+                if kind == "collaboratori":
+                    _build_table_tech(p, auto_tech, val_tech)
+                else:
+                    _build_table_feedback(p, qas)
+            elif t == "[@TabellaSezione7.2]":
+                _build_table_feedback(p, qas)
+            elif t == "[@TabellaSezione8.1]":
+                if kind == "collaboratori":
+                    _build_table_priority(p, priorities, valut_by_comp)
+                else:
+                    _delete_paragraph(p)
+
+    doc.save(str(out_docx))
+    return out_docx

src/reporter/generate.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, List, Optional, Tuple, Dict
+
+import pandas as pd
+
+from .docx_fill import fill_template
+from .io import load_pair
+
+
+@dataclass
+class GeneratedArtifact:
+    kind: str  # "collaboratori" | "manager"
+    person: str
+    docx_path: Path
+    pdf_path: Optional[Path] = None
+    notes: str = ""
+
+
+@dataclass
+class GenerateResult:
+    produced: List[GeneratedArtifact]
+    warnings: List[str]
+
+
+def _safe_filename(name: str) -> str:
+    name = str(name).strip()
+    name = re.sub(r"\s+", " ", name)
+    name = re.sub(r"[^A-Za-z0-9 _-]+", "", name)
+    return name.replace(" ", "_")
+
+
+def list_people(auto_path: Path, valut_path: Path) -> List[str]:
+    """Return UNION of names found in AUTO and VALUT (dedup)."""
+    df_auto, df_val = load_pair(auto_path, valut_path)
+    a = set(df_auto.get("Nome e cognome", []))
+    b = set(df_val.get("Nome e cognome", []))
+    names = sorted({x for x in a.union(b) if isinstance(x, str) and x.strip()})
+    return names
+
+
+def _generate_one(
+    *,
+    kind: str,
+    person_name: str,
+    df_auto: pd.DataFrame,
+    df_val: pd.DataFrame,
+    template_path: Path,
+    output_dir: Path,
+    workdir: Path,
+    make_pdf: bool,
+) -> GeneratedArtifact:
+    base = f"REPORT_{kind}_{_safe_filename(person_name)}"
+    out_docx = output_dir / f"{base}.docx"
+    out_pdf = output_dir / f"{base}.pdf"
+
+    notes = ""
+    # Fill template
+    fill_template(
+        template_path=template_path,
+        out_docx=out_docx,
+        df_auto=df_auto,
+        df_valut=df_val,
+        person_name=person_name,
+        kind=kind,
+        workdir=workdir,
+    )
+
+    pdf_path: Optional[Path] = None
+    if make_pdf:
+        from .pdf_convert import docx_to_pdf
+
+        try:
+            docx_to_pdf(out_docx, out_pdf)
+            pdf_path = out_pdf
+        except Exception as e:
+            notes = f"PDF non generato: {e}"
+            pdf_path = None
+
+    return GeneratedArtifact(kind=kind, person=person_name, docx_path=out_docx, pdf_path=pdf_path, notes=notes)
+
+
+def generate_selected(
+    *,
+    collab_auto: Optional[Path],
+    collab_valut: Optional[Path],
+    collab_template: Optional[Path],
+    manager_auto: Optional[Path],
+    manager_valut: Optional[Path],
+    manager_template: Optional[Path],
+    selected_collaboratori: Iterable[str],
+    selected_manager: Iterable[str],
+    output_dir: Path,
+    make_pdf: bool,
+) -> GenerateResult:
+    produced: List[GeneratedArtifact] = []
+    warnings: List[str] = []
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    workdir = output_dir / "_work"
+    workdir.mkdir(parents=True, exist_ok=True)
+
+    if collab_auto and collab_valut and collab_template:
+        df_auto, df_val = load_pair(collab_auto, collab_valut)
+        for person in selected_collaboratori:
+            try:
+                produced.append(
+                    _generate_one(
+                        kind="collaboratori",
+                        person_name=person,
+                        df_auto=df_auto,
+                        df_val=df_val,
+                        template_path=collab_template,
+                        output_dir=output_dir,
+                        workdir=workdir / "collaboratori",
+                        make_pdf=make_pdf,
+                    )
+                )
+            except Exception as e:
+                warnings.append(f"[Collaboratori] {person}: errore generazione ({e})")
+    else:
+        if any([collab_auto, collab_valut, collab_template]):
+            warnings.append("Collaboratori: mancano uno o più file (AUTO/VALUT/TEMPLATE).")
+
+    if manager_auto and manager_valut and manager_template:
+        df_auto, df_val = load_pair(manager_auto, manager_valut)
+        for person in selected_manager:
+            try:
+                produced.append(
+                    _generate_one(
+                        kind="manager",
+                        person_name=person,
+                        df_auto=df_auto,
+                        df_val=df_val,
+                        template_path=manager_template,
+                        output_dir=output_dir,
+                        workdir=workdir / "manager",
+                        make_pdf=make_pdf,
+                    )
+                )
+            except Exception as e:
+                warnings.append(f"[Manager] {person}: errore generazione ({e})")
+    else:
+        if any([manager_auto, manager_valut, manager_template]):
+            warnings.append("Manager: mancano uno o più file (AUTO/VALUT/TEMPLATE).")
+
+    return GenerateResult(produced=produced, warnings=warnings)

src/reporter/io.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Tuple
+
+import pandas as pd
+
+
+def _parse_ts(df: pd.DataFrame) -> pd.DataFrame:
+    # Google Forms export uses this column name
+    if "Informazioni cronologiche" in df.columns:
+        df = df.copy()
+        df["_ts"] = pd.to_datetime(df["Informazioni cronologiche"], errors="coerce")
+        df = df.sort_values("_ts")
+    else:
+        df = df.copy()
+        df["_ts"] = pd.NaT
+    return df
+
+
+def load_and_dedup(excel_path: Path) -> pd.DataFrame:
+    df = pd.read_excel(excel_path, sheet_name=0)
+    df = _parse_ts(df)
+    if "Nome e cognome" in df.columns:
+        df = df.drop_duplicates(subset=["Nome e cognome"], keep="last")
+    return df.reset_index(drop=True)
+
+
+def load_pair(auto_path: Path, valut_path: Path) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    auto_df = load_and_dedup(auto_path)
+    valut_df = load_and_dedup(valut_path)
+    return auto_df, valut_df

src/reporter/pdf_convert.py

@@ -0,0 +1,137 @@
+"""DOCX -> PDF conversion (no Aspose).
+
+Obiettivo: ottenere un PDF *fedele* al template Word (grafica, tabelle, immagini, header/footer).
+
+Scelta converter:
+1) LibreOffice headless (consigliato su Linux / HF Spaces)  ✅ alta fedeltà
+2) docx2pdf (solo Windows/macOS con MS Word)
+3) fallback PyMuPDF (bassa fedeltà: solo come ultima spiaggia)
+
+Su HuggingFace Spaces puoi installare LibreOffice con `packages.txt`:
+- libreoffice
+- libreoffice-writer
+- fonts-dejavu-core (o altri font richiesti dal template)
+
+Questo non richiede Aspose.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import fitz  # PyMuPDF
+
+
+@dataclass
+class PdfConvertResult:
+    backend: str
+    removed_blank_pages: int = 0
+
+
+def _loffice_available() -> Optional[str]:
+    return shutil.which("soffice") or shutil.which("libreoffice")
+
+
+def _convert_with_libreoffice(docx_path: Path, pdf_path: Path) -> None:
+    """Convert using LibreOffice headless."""
+    docx_path = Path(docx_path)
+    pdf_path = Path(pdf_path)
+    outdir = pdf_path.parent
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    cmd = [
+        _loffice_available(),
+        "--headless",
+        "--nologo",
+        "--nofirststartwizard",
+        "--convert-to",
+        "pdf",
+        "--outdir",
+        str(outdir),
+        str(docx_path),
+    ]
+    # Run
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    produced = outdir / (docx_path.stem + ".pdf")
+    if not produced.exists():
+        # LibreOffice sometimes produces .PDF
+        produced = outdir / (docx_path.stem + ".PDF")
+    if not produced.exists():
+        raise RuntimeError("LibreOffice non ha prodotto il PDF atteso.")
+    if produced != pdf_path:
+        produced.replace(pdf_path)
+
+
+def _convert_with_docx2pdf(docx_path: Path, pdf_path: Path) -> None:
+    from docx2pdf import convert  # type: ignore
+
+    pdf_path.parent.mkdir(parents=True, exist_ok=True)
+    convert(str(docx_path), str(pdf_path))
+
+
+def _convert_with_pymupdf(docx_path: Path, pdf_path: Path) -> None:
+    doc = fitz.open(str(docx_path))
+    pdf_bytes = doc.convert_to_pdf()
+    pdf = fitz.open("pdf", pdf_bytes)
+    pdf.save(str(pdf_path))
+    pdf.close()
+    doc.close()
+
+
+def _drop_blank_pages(pdf_path: Path) -> int:
+    """Remove visually blank pages (rare, but can happen with complex templates)."""
+    pdf = fitz.open(str(pdf_path))
+    blanks = []
+    for i in range(pdf.page_count):
+        page = pdf.load_page(i)
+        pix = page.get_pixmap(matrix=fitz.Matrix(0.5, 0.5), alpha=False)
+        samples = pix.samples
+        nonwhite = 0
+        total = len(samples) // 3
+        for j in range(0, len(samples), 3):
+            if samples[j] < 245 or samples[j + 1] < 245 or samples[j + 2] < 245:
+                nonwhite += 1
+        if total and (nonwhite / total) < 0.002:
+            blanks.append(i)
+    for i in reversed(blanks):
+        pdf.delete_page(i)
+    removed = len(blanks)
+    if removed:
+        tmp = pdf_path.with_suffix(".tmp.pdf")
+        pdf.save(str(tmp))
+        pdf.close()
+        tmp.replace(pdf_path)
+    else:
+        pdf.close()
+    return removed
+
+
+def docx_to_pdf(docx_path: Path, pdf_path: Path, *, drop_blank_pages: bool = True) -> PdfConvertResult:
+    docx_path = Path(docx_path)
+    pdf_path = Path(pdf_path)
+
+    backend = ""
+    if _loffice_available():
+        backend = "libreoffice"
+        _convert_with_libreoffice(docx_path, pdf_path)
+    else:
+        # docx2pdf works only with MS Word
+        try:
+            backend = "docx2pdf"
+            _convert_with_docx2pdf(docx_path, pdf_path)
+        except Exception:
+            backend = "pymupdf_fallback"
+            _convert_with_pymupdf(docx_path, pdf_path)
+
+    removed = 0
+    if drop_blank_pages:
+        try:
+            removed = _drop_blank_pages(pdf_path)
+        except Exception:
+            removed = 0
+
+    return PdfConvertResult(backend=backend, removed_blank_pages=removed)

src/reporter/pdf_post.py

@@ -0,0 +1,75 @@
+"""Post-processing PDF (pip-only).
+
+Obiettivo:
+- rimuovere pagine *visivamente* vuote (tipicamente solo footer/logo e numero pagina)
+  che possono comparire in template DOCX complessi dopo la conversione.
+
+Implementazione:
+- usa PyMuPDF (fitz) per rasterizzare ogni pagina a bassa risoluzione
+- calcola la frazione di pixel "quasi bianchi" e il numero di pixel non bianchi
+- se la pagina è "troppo bianca" e con pochissimi pixel scuri => considerata vuota
+- crea un nuovo PDF senza quelle pagine.
+
+Nota:
+La soglia è tarata per il caso tipico "pagina bianca con solo numero pagina".
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+
+def remove_blank_pages_pdf(
+    pdf_path: Path,
+    *,
+    zoom: float = 0.35,
+    white_thr: int = 245,
+    white_frac_thr: float = 0.995,
+    max_nonwhite_pixels: int = 3500,
+) -> int:
+    """Rimuove pagine visivamente vuote da un PDF.
+
+    Ritorna il numero di pagine rimosse.
+    """
+
+    import fitz  # PyMuPDF
+    import numpy as np
+
+    pdf_path = Path(pdf_path)
+    doc = fitz.open(str(pdf_path))
+    if doc.page_count == 0:
+        return 0
+
+    keep: List[int] = []
+    for i in range(doc.page_count):
+        page = doc.load_page(i)
+        pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom), alpha=False)
+        img = np.frombuffer(pix.samples, dtype=np.uint8).reshape(pix.height, pix.width, 3)
+        white = np.all(img >= white_thr, axis=2)
+        white_frac = float(white.mean())
+        nonwhite = int((~white).sum())
+
+        # Se è molto bianca e con pochissimi pixel non bianchi => pagina vuota
+        if not (white_frac >= white_frac_thr and nonwhite <= max_nonwhite_pixels):
+            keep.append(i)
+
+    removed = doc.page_count - len(keep)
+    if removed <= 0:
+        doc.close()
+        return 0
+
+    new_doc = fitz.open()
+    new_doc.insert_pdf(doc, from_page=min(keep), to_page=max(keep), start_at=0)
+    # insert_pdf sopra copia range continuo: per keep non contiguo bisogna copiare singole pagine
+    if len(keep) != (max(keep) - min(keep) + 1):
+        new_doc = fitz.open()
+        for i in keep:
+            new_doc.insert_pdf(doc, from_page=i, to_page=i)
+
+    doc.close()
+    tmp = pdf_path.with_suffix(".tmp.pdf")
+    new_doc.save(str(tmp))
+    new_doc.close()
+    tmp.replace(pdf_path)
+    return removed