Initial upload: CSV to PowerPoint generator with LFS for binary files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.pptx filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,75 @@
 ---
-title: Csv Powerpoint Generator
-emoji: 🐠
-colorFrom: yellow
-colorTo: blue
+title: CSV to PowerPoint Generator
+emoji: 🏭
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.34.2
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
 license: mit
+python_version: 3.10
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🏭 CSV to PowerPoint Generator
+
+Generate branded PowerPoint presentations from manufacturing CSV data with automated KPI calculations.
+
+## 🚀 Features
+
+- **CSV Upload**: Support for large manufacturing datasets (up to 200MB)
+- **Automated KPI Calculation**: Calculate efficiency metrics for Stampaggio, Stampaggio Surlyn, and Decorazioni departments
+- **PowerPoint Generation**: Create professional reports using branded templates
+- **User Authentication**: Secure access with username/password authentication
+- **Multi-language Support**: Italian interface optimized for manufacturing workflows
+
+## 🔐 Authentication
+
+This Space uses username/password authentication to control access. Users need valid credentials to access the application.
+
+## 📊 Supported Data
+
+The application processes manufacturing data with the following requirements:
+
+- **Format**: CSV files with UTF-8 or ISO-8859-1 encoding
+- **Departments**: ST (Stampaggio), MS (Stampaggio Surlyn), DC (Decorazioni)
+- **Data Structure**: Compatible with "Dati_Grezzi" export format
+- **KPIs Calculated**: EFF_REP, EFF_PRO, EFF_SC, EFF_E, OEE
+
+## 🛠️ How to Use
+
+1. Upload your CSV file containing manufacturing data
+2. Select the month and year for KPI calculation
+3. Click "Generate PowerPoint" to create the presentation
+4. Download the generated PowerPoint file
+
+## 📈 KPI Targets
+
+### Stampaggio (ST)
+- EFF_REP: > 91%
+- EFF_PRO: > 94%
+- EFF_SC: > 98.5%
+- EFF_E: > 93%
+- OEE: > 80%
+
+### Stampaggio Surlyn (MS)
+- EFF_REP: > 93%
+- EFF_PRO: > 95%
+- EFF_SC: > 96%
+- EFF_E: > 92%
+- OEE: > 85%
+
+### Decorazioni (DC)
+- EFF_REP: > 84%
+- EFF_PRO: > 87%
+- EFF_SC: > 96.5%
+- EFF_E: > 91%
+- OEE: > 80%
+
+## 🔧 Technical Details
+
+- **Framework**: Gradio 4.44.0
+- **Python**: 3.10
+- **Libraries**: pandas, python-pptx, gradio
+- **Template**: Uses `template.pptx` for branded presentations
+- **Security**: Environment-based authentication with HF Secrets

app.py

@@ -0,0 +1,651 @@
+"""
+Gradio Web Interface for Manufacturing KPI PowerPoint Generator
+
+This provides a user-friendly web interface for generating PowerPoint presentations
+from CSV manufacturing data without requiring command-line usage.
+
+Main features:
+- CSV file upload with validation
+- Month/year selection via dropdowns
+- One-click PowerPoint generation
+- Download functionality for generated presentations
+- Progress feedback and error handling
+- Authentication support via Hugging Face Secrets
+"""
+
+import os
+import tempfile
+import calendar
+from pathlib import Path
+from typing import Optional, Tuple
+
+import gradio as gr
+import pandas as pd
+
+from src.generator import make_ppt, validate_ppt_output, load_csv_with_encoding_fallback, validate_csv_schema
+
+
+# =============================================================================
+# 🔧 CONFIGURATION
+# =============================================================================
+
+# File size limit (200MB to handle large manufacturing datasets)
+MAX_FILE_SIZE_MB = 200
+MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024
+
+# Year range for dropdown (extended range for historical and future data)
+CURRENT_YEAR = 2024
+YEAR_RANGE = list(range(2020, 2041))  # 2020-2040
+
+# Month names for dropdown (Italian as per the system)
+MONTH_NAMES = [
+    "Gennaio", "Febbraio", "Marzo", "Aprile", "Maggio", "Giugno",
+    "Luglio", "Agosto", "Settembre", "Ottobre", "Novembre", "Dicembre"
+]
+
+# Create month choices for dropdown (display name -> month number)
+MONTH_CHOICES = [(f"{i}. {name}", i) for i, name in enumerate(MONTH_NAMES, 1)]
+
+
+# =============================================================================
+# 🔐 AUTHENTICATION
+# =============================================================================
+
+def get_auth_credentials() -> Optional[list]:
+    """
+    Get authentication credentials from Hugging Face Secrets.
+
+    Supports both single user (APP_USERNAME/APP_PASSWORD) and multiple users (HF_APP_USERS_JSON).
+
+    Returns:
+        List of (username, password) tuples if configured, None otherwise
+    """
+    try:
+        # Try to get multiple users from JSON first
+        users_json = os.getenv("HF_APP_USERS_JSON")
+        if users_json:
+            import json
+            try:
+                users_data = json.loads(users_json)
+                auth_list = []
+
+                # Support both dict format {"user1": "pass1", "user2": "pass2"}
+                # and list format [{"username": "user1", "password": "pass1"}, ...]
+                if isinstance(users_data, dict):
+                    auth_list = [(username, password) for username, password in users_data.items()]
+                elif isinstance(users_data, list):
+                    auth_list = [(user["username"], user["password"]) for user in users_data]
+                else:
+                    raise ValueError("HF_APP_USERS_JSON must be a dict or list")
+
+                if auth_list:
+                    print(f"🔐 Loaded {len(auth_list)} user(s) from HF_APP_USERS_JSON")
+                    return auth_list
+                else:
+                    print("⚠️ HF_APP_USERS_JSON is empty")
+
+            except json.JSONDecodeError as e:
+                print(f"❌ Invalid JSON in HF_APP_USERS_JSON: {e}")
+            except (KeyError, TypeError) as e:
+                print(f"❌ Invalid format in HF_APP_USERS_JSON: {e}")
+
+        # Fallback to single user credentials (backward compatibility)
+        username = os.getenv("APP_USERNAME")
+        password = os.getenv("APP_PASSWORD")
+
+        if username and password:
+            print("🔐 Loaded single user from APP_USERNAME/APP_PASSWORD")
+            return [(username, password)]
+
+        # No authentication configured
+        print("ℹ️ No authentication configured - app will be public")
+        print("ℹ️ To enable auth, set HF_APP_USERS_JSON or APP_USERNAME/APP_PASSWORD in HF Secrets")
+        return None
+
+    except Exception as e:
+        print(f"⚠️ Error loading auth credentials: {e}")
+        return None
+
+
+def validate_auth_setup() -> bool:
+    """
+    Validate that authentication is properly configured.
+
+    Returns:
+        True if auth is properly set up, False otherwise
+    """
+    auth_creds = get_auth_credentials()
+    if not auth_creds:
+        return False
+
+    # Validate each credential pair
+    for username, password in auth_creds:
+        if not username or not password:
+            print(f"❌ Invalid credential pair: username='{username}', password={'*' * len(password) if password else 'None'}")
+            return False
+        if len(username.strip()) == 0 or len(password.strip()) == 0:
+            print(f"❌ Empty username or password detected")
+            return False
+
+    return True
+
+
+# =============================================================================
+# 📁 FILE VALIDATION
+# =============================================================================
+
+def validate_uploaded_file(file_obj) -> Tuple[bool, str]:
+    """
+    Validate uploaded CSV file with enhanced error messages.
+
+    Args:
+        file_obj: Gradio file upload object
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    if file_obj is None:
+        return False, "⚠️ Nessun file caricato"
+
+    try:
+        # Get file info for better error messages
+        file_path = file_obj.name
+        file_name = os.path.basename(file_path)
+        file_extension = os.path.splitext(file_name)[1].lower()
+
+        # Enhanced file extension validation
+        if not file_extension:
+            return False, f"❌ File '{file_name}' non ha estensione. Richiesto: file .csv"
+
+        if file_extension != '.csv':
+            supported_types = ['.csv']
+            return False, (f"❌ Tipo file non supportato: '{file_extension}'\n"
+                          f"Tipi supportati: {', '.join(supported_types)}\n"
+                          f"Rinomina il file con estensione .csv")
+
+        # Check if file exists and get size
+        if not os.path.exists(file_path):
+            return False, f"❌ File '{file_name}' non trovato"
+
+        file_size = os.path.getsize(file_path)
+        file_size_mb = file_size / (1024 * 1024)
+
+        # Enhanced file size validation
+        if file_size == 0:
+            return False, f"❌ File '{file_name}' è vuoto (0 bytes)"
+
+        if file_size > MAX_FILE_SIZE_BYTES:
+            return False, (f"❌ File troppo grande: {file_size_mb:.1f}MB\n"
+                          f"Massimo consentito: {MAX_FILE_SIZE_MB}MB\n"
+                          f"Riduci le dimensioni del file e riprova")
+
+        # Try to load and validate CSV structure with enhanced error handling
+        try:
+            df = load_csv_with_encoding_fallback(file_path)
+        except Exception as load_error:
+            return False, (f"❌ Impossibile leggere il file CSV '{file_name}'\n"
+                          f"Verifica che sia un file CSV valido\n"
+                          f"Errore: {str(load_error)}")
+
+        try:
+            validate_csv_schema(df)
+        except Exception as schema_error:
+            return False, (f"❌ Struttura CSV non valida in '{file_name}'\n"
+                          f"Il file deve contenere le colonne richieste per i dati di produzione\n"
+                          f"Errore: {str(schema_error)}")
+
+        # Enhanced data validation
+        if len(df) == 0:
+            return False, f"❌ File '{file_name}' non contiene dati (solo intestazioni)"
+
+        # Enhanced department validation
+        available_repartos = df['REPARTO'].unique() if 'REPARTO' in df.columns else []
+        required_repartos = ['ST', 'MS', 'DC']  # As per generator.py
+        found_repartos = [r for r in required_repartos if r in available_repartos]
+
+        if not found_repartos:
+            available_list = ', '.join(available_repartos) if len(available_repartos) > 0 else 'nessuno'
+            return False, (f"❌ Nessun reparto valido trovato in '{file_name}'\n"
+                          f"Reparti richiesti: {', '.join(required_repartos)}\n"
+                          f"Reparti trovati: {available_list}")
+
+        # Success message with detailed info
+        print(f"✅ File CSV validato: {file_name} - {len(df):,} righe, reparti: {', '.join(found_repartos)}")
+        return True, (f"✅ File valido: '{file_name}'\n"
+                     f"📊 {len(df):,} righe di dati\n"
+                     f"🏭 Reparti: {', '.join(found_repartos)}\n"
+                     f"💾 Dimensione: {file_size_mb:.1f}MB")
+
+    except Exception as e:
+        return False, (f"❌ Errore imprevisto durante la validazione di '{file_name if 'file_name' in locals() else 'file'}'\n"
+                      f"Dettagli: {str(e)}\n"
+                      f"Contatta il supporto se il problema persiste")
+
+
+# =============================================================================
+# 🎯 MAIN PROCESSING FUNCTION
+# =============================================================================
+
+def generate_presentation(csv_file, month_choice, year_choice, progress=gr.Progress()) -> Tuple[str, str]:
+    """
+    Generate PowerPoint presentation from uploaded CSV.
+
+    Args:
+        csv_file: Gradio file upload object
+        month_choice: Selected month (1-12)
+        year_choice: Selected year
+        progress: Gradio progress tracker
+
+    Returns:
+        Tuple of (download_path, status_message)
+    """
+    try:
+        progress(0, desc="Validazione file in corso...")
+
+        # Validate inputs
+        if csv_file is None:
+            raise gr.Error("❌ Nessun file CSV caricato")
+
+        if month_choice is None or year_choice is None:
+            raise gr.Error("❌ Seleziona mese e anno")
+
+        # Validate file
+        is_valid, message = validate_uploaded_file(csv_file)
+        if not is_valid:
+            raise gr.Error(f"❌ {message}")
+
+        progress(20, desc="File validato, generazione PowerPoint in corso...")
+
+        # Generate PowerPoint using the existing function
+        try:
+            output_path = make_ppt(csv_file.name, month_choice, year_choice)
+            progress(80, desc="PowerPoint generato, validazione finale...")
+
+            # Validate generated file
+            if not validate_ppt_output(output_path):
+                raise gr.Error("❌ Errore durante la validazione del PowerPoint generato")
+
+            progress(100, desc="Completato!")
+
+            # Success message
+            month_name = MONTH_NAMES[month_choice - 1]
+            status_msg = f"✅ PowerPoint generato con successo per {month_name} {year_choice}!"
+
+            return output_path, status_msg
+
+        except Exception as e:
+            error_msg = str(e)
+            if "No data found for reparto" in error_msg:
+                raise gr.Error("❌ Nessun dato trovato per i reparti richiesti nel file CSV")
+            elif "Template not found" in error_msg:
+                raise gr.Error("❌ Template PowerPoint non trovato. Contatta l'amministratore.")
+            else:
+                raise gr.Error(f"❌ Errore durante la generazione: {error_msg}")
+
+    except gr.Error:
+        # Re-raise Gradio errors as-is
+        raise
+    except Exception as e:
+        # Catch any other unexpected errors
+        raise gr.Error(f"❌ Errore imprevisto: {str(e)}")
+
+
+# =============================================================================
+# 🎨 GRADIO INTERFACE
+# =============================================================================
+
+def create_interface() -> gr.Blocks:
+    """
+    Create and configure the Gradio interface.
+
+    Returns:
+        Configured Gradio Blocks interface
+    """
+
+    with gr.Blocks(
+        title="CSV → PowerPoint Generator",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 800px !important;
+            margin: auto !important;
+        }
+        .title-text {
+            text-align: center;
+            color: #2c3e50;
+            margin-bottom: 2rem;
+        }
+        .info-box {
+            background-color: #e8f4fd;
+            border: 1px solid #bee5eb;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+        }
+        .upload-box {
+            border: 2px dashed #007acc;
+            border-radius: 10px;
+            padding: 2rem;
+            text-align: center;
+            background-color: #f8f9fa;
+        }
+        """
+    ) as interface:
+
+        # Header
+        gr.HTML("""
+        <div class="title-text">
+            <h1>🏭 Generatore Report Operativo</h1>
+            <p>Carica un file CSV e genera automaticamente il PowerPoint con i KPI di produzione</p>
+        </div>
+        """)
+
+        # Instructions
+        with gr.Accordion("📋 Istruzioni d'uso", open=False):
+            gr.Markdown("""
+            ### Come utilizzare questo strumento:
+
+            1. **Carica il file CSV** con i dati di produzione (massimo 200MB)
+            2. **Seleziona il mese** fino al quale calcolare i KPI
+            3. **Seleziona l'anno** di riferimento
+            4. **Clicca "Genera PowerPoint"** e attendi il completamento
+            5. **Scarica il file** usando il pulsante di download
+
+            ### Formato file richiesto:
+            - File CSV con encoding UTF-8 o ISO-8859-1
+            - Deve contenere i dati dei reparti: ST (Stampaggio), MS (Stampaggio Surlyn), DC (Decorazioni)
+            - Struttura colonne compatibile con export "Dati_Grezzi"
+            """)
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                # File upload
+                csv_input = gr.File(
+                    label="📁 Carica File CSV",
+                    file_types=[".csv"],
+                    file_count="single",
+                    elem_classes="upload-box"
+                )
+
+                # File validation feedback
+                file_status = gr.Textbox(
+                    label="Stato File",
+                    interactive=False,
+                    visible=False
+                )
+
+            with gr.Column(scale=1):
+                # Month selection
+                month_input = gr.Dropdown(
+                    choices=MONTH_CHOICES,
+                    label="📅 Mese",
+                    info="Seleziona il mese fino al quale calcolare i KPI",
+                    value=None,
+                    interactive=True
+                )
+
+                # Year selection
+                year_input = gr.Dropdown(
+                    choices=YEAR_RANGE,
+                    label="📅 Anno",
+                    info="Anno di riferimento per il report (2020-2040)",
+                    value=CURRENT_YEAR,
+                    interactive=True
+                )
+
+        # Generate button
+        generate_btn = gr.Button(
+            "🚀 Genera PowerPoint",
+            variant="primary",
+            size="lg",
+            interactive=False
+        )
+
+        # Status and download section
+        with gr.Column():
+            status_output = gr.Textbox(
+                label="Stato Generazione",
+                interactive=False,
+                visible=False
+            )
+
+            download_file = gr.DownloadButton(
+                "💾 Scarica PowerPoint",
+                visible=False,
+                variant="secondary"
+            )
+
+        # =============================================================================
+        # 🔗 EVENT HANDLERS
+        # =============================================================================
+
+        def update_ui_state(csv_file, month, year):
+            """Update UI state based on inputs with enhanced validation feedback."""
+            # Initialize state variables
+            file_valid = False
+            file_msg = ""
+            button_interactive = False
+
+            # Validate file if uploaded
+            if csv_file is not None:
+                file_valid, file_msg = validate_uploaded_file(csv_file)
+            else:
+                file_msg = "⚠️ Carica un file CSV per iniziare"
+
+            # Check if all required inputs are provided
+            missing_inputs = []
+            if csv_file is None:
+                missing_inputs.append("file CSV")
+            if month is None:
+                missing_inputs.append("mese")
+            if year is None:
+                missing_inputs.append("anno")
+
+            # Only enable button if all inputs are valid
+            if csv_file is not None and month is not None and year is not None and file_valid:
+                button_interactive = True
+            else:
+                button_interactive = False
+
+            # Create helpful button tooltip based on what's missing
+            if not button_interactive:
+                if missing_inputs:
+                    button_title = f"Completa i campi mancanti: {', '.join(missing_inputs)}"
+                elif not file_valid:
+                    button_title = "Correggi gli errori del file prima di continuare"
+                else:
+                    button_title = "Completa tutti i campi richiesti"
+            else:
+                button_title = "Genera PowerPoint con i dati forniti"
+
+            return {
+                generate_btn: gr.update(
+                    interactive=button_interactive,
+                    variant="primary" if button_interactive else "secondary"
+                ),
+                file_status: gr.update(
+                    value=file_msg,
+                    visible=csv_file is not None or len(missing_inputs) > 0,
+                    label="✅ File Valido" if file_valid and csv_file is not None else
+                          "❌ Errore File" if csv_file is not None else
+                          "📋 Stato Validazione"
+                )
+            }
+
+        def on_generate_click(csv_file, month, year):
+            """Handle generate button click with enhanced error feedback."""
+            try:
+                # Final validation before generation
+                if csv_file is None:
+                    gr.Error("Carica un file CSV prima di generare il PowerPoint")
+                    return {
+                        status_output: gr.update(value="❌ Nessun file CSV caricato", visible=True),
+                        download_file: gr.update(visible=False)
+                    }
+
+                if month is None:
+                    gr.Error("Seleziona un mese prima di generare il PowerPoint")
+                    return {
+                        status_output: gr.update(value="❌ Seleziona un mese", visible=True),
+                        download_file: gr.update(visible=False)
+                    }
+
+                if year is None:
+                    gr.Error("Seleziona un anno prima di generare il PowerPoint")
+                    return {
+                        status_output: gr.update(value="❌ Seleziona un anno", visible=True),
+                        download_file: gr.update(visible=False)
+                    }
+
+                # Generate presentation
+                ppt_path, status_msg = generate_presentation(csv_file, month, year)
+
+                # Show success notification
+                gr.Info(f"PowerPoint generato con successo per {MONTH_NAMES[month-1]} {year}!")
+
+                return {
+                    status_output: gr.update(value=status_msg, visible=True),
+                    download_file: gr.update(visible=True, value=ppt_path)
+                }
+
+            except gr.Error as ge:
+                # Gradio errors are already properly formatted
+                error_msg = str(ge).replace("❌ ", "")  # Remove duplicate error prefix
+                return {
+                    status_output: gr.update(value=f"❌ {error_msg}", visible=True),
+                    download_file: gr.update(visible=False)
+                }
+            except Exception as e:
+                # Unexpected errors
+                error_msg = str(e)
+                gr.Error(f"Errore imprevisto: {error_msg}")
+                return {
+                    status_output: gr.update(value=f"❌ Errore imprevisto: {error_msg}", visible=True),
+                    download_file: gr.update(visible=False)
+                }
+
+        def handle_file_upload(file):
+            """Handle immediate file upload validation for better UX."""
+            if file is None:
+                return {
+                    file_status: gr.update(
+                        value="⚠️ Carica un file CSV per iniziare",
+                        visible=True,
+                        label="📋 Stato File"
+                    )
+                }
+
+            # Quick file type validation for immediate feedback
+            file_name = os.path.basename(file.name)
+            file_extension = os.path.splitext(file_name)[1].lower()
+
+            if file_extension != '.csv':
+                error_msg = (f"❌ Tipo file non supportato: '{file_extension}'\n"
+                           f"⚠️ Solo file .csv sono accettati\n"
+                           f"Seleziona un file CSV valido")
+
+                # Show error toast for unsupported file types
+                gr.Warning(f"Tipo file non supportato: {file_extension}. Solo file CSV (.csv) sono accettati.")
+
+                return {
+                    file_status: gr.update(
+                        value=error_msg,
+                        visible=True,
+                        label="❌ Errore File"
+                    )
+                }
+
+            # If CSV, proceed with full validation
+            is_valid, message = validate_uploaded_file(file)
+
+            if not is_valid:
+                # Show error toast for validation failures
+                gr.Warning(f"Errore file CSV: {message.split(chr(10))[0]}")  # First line of error
+
+            return {
+                file_status: gr.update(
+                    value=message,
+                    visible=True,
+                    label="✅ File Valido" if is_valid else "❌ Errore File"
+                )
+            }
+
+        # Wire up events with enhanced file handling
+        csv_input.upload(
+            fn=handle_file_upload,
+            inputs=[csv_input],
+            outputs=[file_status],
+            show_progress="hidden"  # Hide progress for instant feedback
+        )
+
+        for input_component in [csv_input, month_input, year_input]:
+            input_component.change(
+                fn=update_ui_state,
+                inputs=[csv_input, month_input, year_input],
+                outputs=[generate_btn, file_status]
+            )
+
+        generate_btn.click(
+            fn=on_generate_click,
+            inputs=[csv_input, month_input, year_input],
+            outputs=[status_output, download_file]
+        )
+
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; margin-top: 2rem; color: #6c757d; font-size: 0.9em;">
+            <p>🔒 Applicazione sicura per la generazione di report KPI di produzione</p>
+        </div>
+        """)
+
+    return interface
+
+
+# =============================================================================
+# 🚀 APPLICATION LAUNCH
+# =============================================================================
+
+def main():
+    """Launch the Gradio application."""
+    print("🚀 Avvio applicazione Gradio...")
+    print("=" * 60)
+
+    # Get and validate authentication credentials
+    auth_creds = get_auth_credentials()
+
+    # Create interface
+    app = create_interface()
+
+    # Launch configuration
+    launch_kwargs = {
+        "server_name": "0.0.0.0",  # Listen on all interfaces for HF Spaces
+        "server_port": 7860,       # Standard port for HF Spaces
+        "show_error": True,        # Show detailed errors
+        "share": False,            # Don't create public share link
+        "inbrowser": False,        # Don't auto-open browser (for deployment)
+    }
+
+    # Add authentication if configured
+    if auth_creds and validate_auth_setup():
+        launch_kwargs["auth"] = auth_creds
+        print(f"🔐 Autenticazione attivata per {len(auth_creds)} utente(i)")
+        print("📋 Utenti configurati:")
+        for i, (username, _) in enumerate(auth_creds, 1):
+            print(f"   {i}. {username}")
+    else:
+        print("🌍 Applicazione pubblica (nessuna autenticazione)")
+        print("⚠️  ATTENZIONE: L'app è accessibile a chiunque conosca l'URL")
+
+    print("=" * 60)
+
+    # Launch the app
+    try:
+        print("🌐 Avvio server Gradio...")
+        app.launch(**launch_kwargs)
+    except Exception as e:
+        print(f"❌ Errore durante l'avvio: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,16 @@
+# Core data processing and manipulation
+pandas>=1.5.0,<3.0.0
+numpy>=1.21.0,<2.0.0
+
+# Visualization and charting
+matplotlib>=3.5.0,<4.0.0
+seaborn>=0.11.0,<1.0.0
+
+# PowerPoint creation
+python-pptx>=0.6.21,<1.0.0
+
+# XML processing (used by python-pptx)
+lxml>=4.6.0,<6.0.0
+
+# Web interface
+gradio>=4.0.0,<5.0.0

src/generator.py

@@ -0,0 +1,1687 @@
+"""
+PowerPoint Generation Module for Manufacturing KPI Reports
+
+This module extracts the core logic from Briva_v6.ipynb notebook to generate
+PowerPoint presentations from CSV manufacturing data.
+
+Main function: make_ppt(csv_path, reparto_code) -> str (path to generated .pptx)
+"""
+
+import os
+import locale
+import tempfile
+import calendar
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Union
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from pptx import Presentation
+from pptx.util import Inches, Pt
+from pptx.enum.text import PP_ALIGN, MSO_VERTICAL_ANCHOR
+from pptx.enum.shapes import PP_PLACEHOLDER
+from pptx.dml.color import RGBColor
+from pptx.enum.dml import MSO_LINE_DASH_STYLE
+from lxml import etree
+from pptx.oxml.ns import qn
+
+# =============================================================================
+# 📋 CONSTANTS AND CONFIGURATION
+# =============================================================================
+
+# Expected CSV columns for validation
+EXPECTED_COLUMNS = [
+    'ANNO', 'MESE', 'MESE_DESCR', 'GIORNO', 'SETT', 'ORE_MESE', 'N_MACCH',
+    'DATA_DA_ORE6_A_6', 'TURNO', 'REPARTO', 'MACCHINA', 'BOLLA', 'FASE',
+    'H_SCHED', 'H_PROG', 'N_PZ', 'QTSCA', 'QTNC', 'H_LAV', 'CAU_FER',
+    'H_FER', 'CAU_ATT', 'OREATT', 'CAU_CAMP', 'ORECAMP', 'CONT_LAV',
+    'IMPRONTE_LAV', 'H_DISP', 'REPARTO_DESCR', 'CAU_F_DESCR', 'H_FER_PRO',
+    'C11FER', 'C20FER', 'ARTICOLO', 'DESCRIZIONE', 'STAMPO', 'IMPT', 'CT',
+    'H_ATT_T', 'H_CAMP_T', 'TLAVTEOR', 'BATTUTE', 'CICLOR', 'PGP',
+    'H_FER_T', 'H_FER_MICRO', 'H_PIAN', 'H_DISP_KPI', 'H_PROG_PIAN',
+    'NPZ_NODICH', 'DATA_AGG'
+]
+
+# Target KPI map per reparto (values in percentage)
+TARGET_KPI_MAP = {
+    'ST': {  # STAMPAGGIO
+        'EFF_REP': 91.0,
+        'EFF_PRO': 94.0,
+        'EFF_SC': 98.5,
+        'EFF_E': 93.0,
+        'OEE': 80.0
+    },
+    'MS': {  # STAMPAGGIO SURLYN
+        'EFF_REP': 93.0,
+        'EFF_PRO': 95.0,
+        'EFF_SC': 96.0,
+        'EFF_E': 92.0,
+        'OEE': 85.0
+    },
+    'DC': {  # DECORAZIONI
+        'EFF_REP': 84.0,
+        'EFF_PRO': 87.0,
+        'EFF_SC': 96.5,
+        'EFF_E': 91.0,
+        'OEE': 80.0
+    },
+    'AS': {  # ASSEMBLAGGIO
+        'EFF_REP': 91.0,
+        'EFF_PRO': 94.0,
+        'EFF_SC': 98.5,
+        'EFF_E': 93.0,
+        'OEE': 80.0
+    },
+    'IS': {  # INIEZIONE SOFFIAGGIO
+        'EFF_REP': 91.0,
+        'EFF_PRO': 94.0,
+        'EFF_SC': 98.5,
+        'EFF_E': 93.0,
+        'OEE': 80.0
+    },
+    'PS': {  # PRODUZIONE SCOVOLI
+        'EFF_REP': 91.0,
+        'EFF_PRO': 94.0,
+        'EFF_SC': 98.5,
+        'EFF_E': 93.0,
+        'OEE': 80.0
+    }
+}
+
+# Reparto descriptions
+REPARTO_DESCRIPTIONS = {
+    'AS': 'ASSEMBLAGGIO',
+    'DC': 'DECORAZIONI',
+    'IS': 'INIEZIONE SOFFIAGGIO',
+    'MS': 'STAMPAGGIO SURLYN',
+    'PS': 'PRODUZIONE SCOVOLI',
+    'ST': 'STAMPAGGIO'
+}
+
+# Corporate colors for charts
+CHART_COLORS = {
+    'previous_year': '#00AEEF',    # Corporate blue
+    'target': '#E6E2E0',          # Light taupe
+    'selected_year': '#4D4D4F'    # Dark grey
+}
+
+# Set Italian locale for month names (with fallback)
+try:
+    locale.setlocale(locale.LC_TIME, 'it_IT.UTF-8')
+except locale.Error:
+    try:
+        locale.setlocale(locale.LC_TIME, 'it_IT')
+    except locale.Error:
+        pass  # Use default locale
+
+
+# =============================================================================
+# 📊 DATA LOADING AND VALIDATION
+# =============================================================================
+
+def load_csv_with_encoding_fallback(csv_path: str) -> pd.DataFrame:
+    """
+    Load CSV with robust encoding detection and fallback.
+
+    Args:
+        csv_path: Path to the CSV file
+
+    Returns:
+        Loaded DataFrame
+
+    Raises:
+        ValueError: If CSV cannot be loaded with any encoding
+    """
+    encodings_to_try = ['utf-8', 'iso-8859-1', 'cp1252', 'latin1']
+
+    for encoding in encodings_to_try:
+        try:
+            df = pd.read_csv(csv_path, encoding=encoding)
+            print(f"✅ Successfully loaded CSV with encoding: {encoding}")
+            return df
+        except UnicodeDecodeError:
+            continue
+        except Exception as e:
+            print(f"❌ Error with {encoding}: {e}")
+            break
+
+    raise ValueError(f"❌ Failed to load CSV with any encoding: {csv_path}")
+
+
+def validate_csv_schema(df: pd.DataFrame) -> None:
+    """
+    Validate that the DataFrame has all expected columns.
+
+    Args:
+        df: DataFrame to validate
+
+    Raises:
+        ValueError: If required columns are missing
+    """
+    missing_cols = set(EXPECTED_COLUMNS) - set(df.columns)
+    if missing_cols:
+        raise ValueError(f"Missing required columns: {missing_cols}")
+
+    print(f"✅ All expected columns present. Shape: {df.shape}")
+
+
+def prepare_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Clean and prepare the DataFrame for KPI calculations.
+
+    Args:
+        df: Raw DataFrame
+
+    Returns:
+        Cleaned DataFrame
+    """
+    df = df.copy()
+
+    # Handle missing values and data type conversions
+    df['GIORNO'] = df['GIORNO'].fillna(0).astype(int)
+    df['SETT'] = df['SETT'].fillna(0).astype(int)
+    df['DATA_DA_ORE6_A_6'] = pd.to_datetime(df['DATA_DA_ORE6_A_6'], errors='coerce')
+    df['TURNO'] = df['TURNO'].fillna(0).astype(int)
+    df['BOLLA'] = df['BOLLA'].astype(object)
+    df['MESE_DESCR'] = df['MESE_DESCR'].str.strip()
+
+    print("✅ DataFrame prepared successfully")
+    return df
+
+
+# =============================================================================
+# 📈 KPI CALCULATION FUNCTIONS
+# =============================================================================
+
+def analyze_reparto_kpi(df: pd.DataFrame, reparto_code: str) -> pd.DataFrame:
+    """
+    Filter and analyze KPI data for a specific reparto.
+
+    Args:
+        df: Raw DataFrame
+        reparto_code: Department code (e.g., 'ST', 'MS', 'DC')
+
+    Returns:
+        Filtered DataFrame for the specified reparto
+
+    Raises:
+        ValueError: If no data found for the reparto
+    """
+    # Filter by reparto
+    df_filtered = df[df['REPARTO'] == reparto_code].copy()
+
+    if df_filtered.empty:
+        raise ValueError(f"No data found for reparto: {reparto_code}")
+
+    print(f"📊 Dati {REPARTO_DESCRIPTIONS.get(reparto_code, reparto_code)} ({reparto_code}): {len(df_filtered):,} righe")
+    print(f"📅 Range anni: {df_filtered['ANNO'].min()} - {df_filtered['ANNO'].max()}")
+    print(f"📅 Range mesi: {df_filtered['MESE'].min()} - {df_filtered['MESE'].max()}")
+    print(f"🏭 Macchine coinvolte: {df_filtered['MACCHINA'].nunique()}")
+    print(f"📋 Articoli prodotti: {df_filtered['ARTICOLO'].nunique()}")
+
+    return df_filtered
+
+
+def calcola_kpi(group: pd.DataFrame) -> pd.Series:
+    """
+    Calculate KPIs for a group of data according to official Brivaplast formulas.
+
+    Args:
+        group: DataFrame group (typically from groupby operation)
+
+    Returns:
+        Series with calculated KPIs
+    """
+    # Sum the necessary columns
+    h_disp = group['H_DISP'].sum()
+    h_sched = group['H_SCHED'].sum()
+    h_prog = group['H_PROG'].sum()
+    h_lav = group['H_LAV'].sum()
+    h_fer = group['H_FER'].sum()
+    oreatt = group['OREATT'].sum()  # Real setup hours
+    orecamp = group['ORECAMP'].sum()  # Real sampling hours
+    h_att_t = group['H_ATT_T'].sum()  # Theoretical setup hours
+    h_camp_t = group['H_CAMP_T'].sum()  # Theoretical sampling hours
+    n_pz = group['N_PZ'].sum()
+    qtsca = group['QTSCA'].sum()  # Scraps
+    qtnc = group['QTNC'].sum()  # Non-conformities
+    npz_nodich = group['NPZ_NODICH'].sum()  # Undeclared pieces
+    pgp = group['PGP'].sum()
+    c11fer = group['C11FER'].sum()
+    c20fer = group['C20FER'].sum()
+
+    # Calculate KPIs according to official formulas
+    sfrutt = h_sched / h_disp if h_disp > 0 else 0  # SFRUTT = H_SCHED / H_DISP
+    eff_rep = h_lav / (h_sched - oreatt - orecamp) if (h_sched - oreatt - orecamp) > 0 else 0
+    eff_pro = h_lav / (h_prog - (c11fer + c20fer)) if (h_prog - (c11fer + c20fer)) > 0 else 0
+    eff_sc = (n_pz - qtnc) / (n_pz + qtsca) if (n_pz + qtsca) > 0 else 0
+    eff_e = n_pz / pgp if pgp > 0 else 0
+    oee = ((h_lav / h_disp) * eff_sc * (n_pz + qtsca) / pgp) if h_disp > 0 and pgp > 0 else 0
+
+    # Calculate non-conformity percentage
+    perc_nc = (qtnc / n_pz) * 100 if n_pz > 0 else 0
+
+    return pd.Series({
+        # Hours
+        '_H_DISP': h_disp,
+        '_H_SCHED': h_sched,
+        '_H_PROG': h_prog,
+        '_H_LAV': h_lav,
+        '_H_FER': h_fer,
+        '_H_ATT_T': h_att_t,
+        '_H_ATTR': oreatt,
+        '_H_CAMP_T': h_camp_t,
+        '_H_CAMP': orecamp,
+
+        # Main KPIs
+        '_SFRUTT': sfrutt,
+        '_EFF_REP': eff_rep,
+        '_EFF_PRO': eff_pro,
+        '_EFF_SC': eff_sc,
+        '_EFF_E': eff_e,
+        'OEE': oee,
+
+        # Pieces
+        '_N_PZ': n_pz,
+        '_N_SC': qtsca,
+        '_PZ_ND': npz_nodich,
+        'N_NC': qtnc,
+        '_%NC': perc_nc,
+
+        # KPIs for compatibility with existing code
+        'H_SCHED': h_sched,
+        'N_PZ': n_pz,
+        'N_SC': qtsca,
+        'EFF_REP': eff_rep,
+        'EFF_PRO': eff_pro,
+        'EFF_SC': eff_sc,
+        'EFF_E': eff_e,
+        'N_pz_tot_h': (n_pz + qtsca) / h_sched if h_sched > 0 else 0,
+        'N_pz_ok_h': n_pz / h_sched if h_sched > 0 else 0
+    })
+
+
+def create_df_eff_reparto_ytd(df: pd.DataFrame, selected_month: int,
+                             selected_year: int, reparto_code: str) -> pd.DataFrame:
+    """
+    Creates df_eff_reparto_ytd with YTD metrics up to selected month
+    (matches notebook implementation exactly)
+
+    Args:
+        df: Raw data DataFrame
+        selected_month: Current month (1-12) - YTD will be calculated up to this month
+        selected_year: Current year
+        reparto_code: Department code (default 'ST' for STAMPAGGIO)
+
+    Returns:
+        DataFrame with YTD efficiency metrics for current and previous year + YoY deltas
+    """
+    # Filter data for selected reparto
+    df_reparto = df[df['REPARTO'] == reparto_code].copy()
+
+    # Calculate previous year
+    previous_year = selected_year - 1
+
+    # Calculate YTD metrics for both years
+    ytd_results = []
+
+    for year in [previous_year, selected_year]:
+        # Filter data for YTD period (January to selected_month)
+        df_ytd = df_reparto[
+            (df_reparto['ANNO'] == year) &
+            (df_reparto['MESE'] <= selected_month)
+        ].copy()
+
+        if not df_ytd.empty:
+            # Calculate YTD KPIs using the same calcola_kpi function
+            ytd_kpi = calcola_kpi(df_ytd)
+
+            # Create period identifier
+            period = pd.Period(f"{year}-{selected_month:02d}", freq='M')
+
+            ytd_results.append({
+                'Period': period,
+                'Year': int(year),
+                'YTD_Month': int(selected_month),
+                **ytd_kpi
+            })
+
+    # Create DataFrame with Period index
+    if not ytd_results:
+        return pd.DataFrame()
+
+    df_ytd_result = pd.DataFrame(ytd_results)
+    df_ytd_result.set_index('Period', inplace=True)
+
+    # Convert KPIs to percentages and round to 1 decimal
+    efficiency_cols = ['EFF_REP', 'EFF_PRO', 'EFF_SC', 'EFF_E', 'OEE']
+    for col in efficiency_cols:
+        if col in df_ytd_result.columns:
+            df_ytd_result[col] = round(df_ytd_result[col] * 100, 1)
+
+    # Initialize YoY delta columns
+    delta_cols = [f'{col}_YoY_Delta' for col in efficiency_cols]
+    for col in delta_cols:
+        df_ytd_result[col] = np.nan
+
+    # Calculate Year-over-Year deltas if we have both years
+    if len(df_ytd_result) == 2:
+        # Sort by year to ensure proper order
+        df_ytd_result = df_ytd_result.sort_values('Year')
+
+        # Get previous and current year data
+        prev_year_data = df_ytd_result.iloc[0]
+        curr_year_data = df_ytd_result.iloc[1]
+
+        # Calculate YoY deltas for each KPI
+        for col in efficiency_cols:
+            if col in df_ytd_result.columns:
+                prev_value = prev_year_data[col]
+                curr_value = curr_year_data[col]
+
+                if prev_value != 0:
+                    delta = ((curr_value - prev_value) / prev_value) * 100
+                    # Set delta only for current year row
+                    df_ytd_result.iloc[1, df_ytd_result.columns.get_loc(f'{col}_YoY_Delta')] = round(delta, 1)
+
+    # Add descriptive labels - fix the formatting issue (matches notebook exactly)
+    df_ytd_result['YTD_Label'] = df_ytd_result.apply(
+        lambda row: f"YTD {int(row['Year'])} (Gen-{int(row['YTD_Month']):02d})", axis=1
+    )
+
+    # Reorder columns: descriptive info first, then KPIs, then deltas
+    info_cols = ['Year', 'YTD_Month', 'YTD_Label']
+    column_order = info_cols + efficiency_cols + delta_cols
+    available_cols = [col for col in column_order if col in df_ytd_result.columns]
+    df_ytd_result = df_ytd_result[available_cols]
+
+    return df_ytd_result
+
+
+# =============================================================================
+# 📊 CHART BUILDING FUNCTIONS
+# =============================================================================
+
+def build_eff_chart(df: pd.DataFrame, selected_month: int, selected_year: int,
+                   reparto_code: str) -> plt.Figure:
+    """
+    Builds a seaborn bar chart comparing selected_year YTD KPIs with previous year and targets.
+    (matches notebook implementation exactly)
+
+    Args:
+        df: Raw data DataFrame (Dati_Grezzi)
+        selected_month: Month up to which to calculate YTD (1-12)
+        selected_year: Year for comparison
+        reparto_code: Department code (e.g., 'ST' for Stampaggio)
+
+    Returns:
+        matplotlib.figure.Figure: The created figure object
+    """
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    import pandas as pd
+    import numpy as np
+    from datetime import datetime
+    import locale
+
+    # Set Italian locale for month names (fallback to default if not available)
+    try:
+        locale.setlocale(locale.LC_TIME, 'it_IT.UTF-8')
+    except:
+        try:
+            locale.setlocale(locale.LC_TIME, 'it_IT')
+        except:
+            pass  # Use default locale
+
+    # Get target map from TARGET_KPI_MAP based on reparto_code
+    target_map = TARGET_KPI_MAP.get(reparto_code, {})
+    if not target_map:
+        print(f"⚠️  No target KPIs defined for reparto '{reparto_code}'. Using default values of 0.")
+        target_map = {
+            'EFF_REP': 0.0,
+            'EFF_PRO': 0.0,
+            'EFF_SC': 0.0,
+            'EFF_E': 0.0,
+            'OEE': 0.0
+        }
+
+    # Generate YTD data using the existing function
+    df_ytd_result = create_df_eff_reparto_ytd(df, selected_month, selected_year, reparto_code)
+
+    if df_ytd_result.empty:
+        print(f"❌ No YTD data available for {reparto_code} up to month {selected_month} of {selected_year}")
+        return None
+
+    # Corporate color palette (matches notebook COLORS exactly)
+    COLORS = {
+        'previous_year': '#00AEEF',    # Corporate blue
+        'target': '#E6E2E0',          # Light taupe
+        'selected_year': '#4D4D4F'    # Dark grey
+    }
+
+    # KPI order for x-axis
+    kpi_order = ['EFF_REP', 'EFF_PRO', 'EFF_SC', 'EFF_E', 'OEE']
+    kpi_labels = ['EFF_Rep', 'EFF_Pro', 'EFF_SC', 'EFF_E', 'OEE']
+
+    # Get department description
+    reparto_descriptions = {
+        'ST': 'Stampaggio',
+        'IS': 'Iniezione Soffiaggio',
+        'AS': 'Assemblaggio',
+        'PS': 'Produzione Scovoli',
+        'MS': 'Stampaggio Surlyn',
+        'DC': 'Decorazioni'
+    }
+    descrizione_reparto = reparto_descriptions.get(reparto_code, reparto_code)
+
+    # Prepare data for visualization
+    year_prev = selected_year - 1
+
+    # Extract KPI values from df_ytd_result
+    data_viz = []
+
+    for kpi in kpi_order:
+        # Get values for both years and target
+        try:
+            # Previous year
+            prev_year_row = df_ytd_result[df_ytd_result['Year'] == year_prev]
+            prev_year_val = prev_year_row[kpi].iloc[0] if len(prev_year_row) > 0 else 0
+        except (KeyError, IndexError):
+            prev_year_val = 0
+
+        try:
+            # Current year
+            curr_year_row = df_ytd_result[df_ytd_result['Year'] == selected_year]
+            curr_year_val = curr_year_row[kpi].iloc[0] if len(curr_year_row) > 0 else 0
+        except (KeyError, IndexError):
+            curr_year_val = 0
+
+        target_val = target_map.get(kpi, 0)
+
+        # Add data points for each bar
+        data_viz.extend([
+            {'KPI': kpi_labels[kpi_order.index(kpi)], 'Tipo': f'{year_prev}', 'Valore': prev_year_val, 'Color': 'previous_year'},
+            {'KPI': kpi_labels[kpi_order.index(kpi)], 'Tipo': 'Target', 'Valore': target_val, 'Color': 'target'},
+            {'KPI': kpi_labels[kpi_order.index(kpi)], 'Tipo': f'{selected_year}', 'Valore': curr_year_val, 'Color': 'selected_year'}
+        ])
+
+    df_viz = pd.DataFrame(data_viz)
+
+    # Create figure with exact dimensions (960x540 px at 100 DPI)
+    fig, ax = plt.subplots(figsize=(9.6, 5.4), dpi=100, facecolor='white')
+
+    # Create the bar plot
+    bar_plot = sns.barplot(
+        data=df_viz,
+        x='KPI',
+        y='Valore',
+        hue='Tipo',
+        order=kpi_labels,
+        hue_order=[f'{year_prev}', 'Target', f'{selected_year}'],
+        palette=[COLORS['previous_year'], COLORS['target'], COLORS['selected_year']],
+        ax=ax
+    )
+
+    # Customize the plot
+    # Title
+    mese_names = ['', 'Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio', 'Giugno',
+                  'Luglio', 'Agosto', 'Settembre', 'Ottobre', 'Novembre', 'Dicembre']
+    mese_nome = mese_names[selected_month] if selected_month <= 12 else f'Mese {selected_month}'
+
+    title = f"Efficienze {descrizione_reparto} Gennaio/{mese_nome} - {year_prev}/{selected_year}"
+    ax.set_title(title, fontsize=14, fontweight='bold', pad=20)
+
+    # Y-axis configuration
+    ax.set_ylim(0, 100)
+    ax.set_ylabel('Efficienza (%)', fontsize=12)
+    ax.set_xlabel('')
+
+    # Grid lines at 25% intervals
+    ax.set_yticks([0, 25, 50, 75, 100])
+    ax.grid(True, axis='y', alpha=0.3, linestyle='-', linewidth=0.5)
+    ax.set_axisbelow(True)
+
+    # Format y-axis labels as percentages
+    ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'{x:.0f}%'))
+
+    # Add data labels using helper function
+    _annotate_bars(ax, target_map, year_prev, selected_year, kpi_order)
+
+    # Legend configuration
+    legend = ax.legend(title='', loc='upper center', bbox_to_anchor=(0.5, -0.05),
+                      ncol=3, frameon=False, fontsize=10)
+
+    # Adjust layout to prevent clipping
+    plt.tight_layout()
+
+    # Set transparent background if needed
+    fig.patch.set_alpha(1.0)  # Change to 0.0 for transparent
+
+    return fig
+
+
+def _annotate_bars(ax, target_map, year_prev, year_curr, kpi_order):
+    """
+    Annotate the bar-chart produced by `build_eff_chart()`.
+
+    • Smart placement: puts the label above the bar unless it would overflow,
+      in which case it is drawn inside the bar.
+    • Colour logic:
+        – Target bar  → label always black
+        – Prev/Cur Yr → green if ≥ target, red otherwise
+    • Contrast: labels drawn inside bars have a white stroke for readability.
+    • Robustness: works even if the number of bars per KPI group ≠ 3.
+
+    Parameters:
+    -----------
+    ax : matplotlib.axes.Axes
+        The axes object containing the bar chart
+    target_map : dict
+        Dictionary mapping KPI names to target values
+    year_prev : int
+        Previous year for comparison
+    year_curr : int
+        Current year for comparison
+    kpi_order : list
+        List of KPI names in order
+
+    Returns:
+    --------
+    matplotlib.axes.Axes
+        The same axes, for possible chaining.
+    """
+    import matplotlib.patheffects as path_effects
+
+    # --- constants --------------------------------------------------------- #
+    GREEN = "#006100"
+    RED = "#C00000"
+
+    y_min, y_max = ax.get_ylim()
+    offset = max((y_max - y_min) * 0.015, 2.0)   # 1.5 % of range or ≥ 2 pt
+
+    # How many bars compose one KPI group?
+    bars_per_group = 0
+    if ax.containers:
+        bars_per_group = len(ax.containers)
+
+    if bars_per_group == 0:
+        return ax
+
+    # ----------------------------------------------------------------------- #
+    for idx, bar in enumerate(ax.patches):
+        height = bar.get_height()
+        if height <= 0:       # nothing to show
+            continue
+
+        # Identify KPI and bar type (prev-yr / target / curr-yr)
+        kpi_idx = idx % len(kpi_order)
+        tipo_idx = idx // len(kpi_order)
+
+        if kpi_idx >= len(kpi_order):            # safety net
+            continue
+
+        kpi_name   = kpi_order[kpi_idx]
+        target_val = target_map.get(kpi_name)
+
+        if target_val is None:
+             target_val = 0 # Default if no target
+
+        bar_type = ""
+        # Determine bar_type from hue order used in the plot
+        hue_order = [str(year_prev), 'Target', str(year_curr)]
+        if tipo_idx < len(hue_order):
+            bar_type = hue_order[tipo_idx]
+
+        # --- colour selection --------------------------------------------- #
+        label_colour = "black" # Default
+        if bar_type == "Target":
+            label_colour = "black"
+        elif bar_type in {str(year_prev), str(year_curr)}:
+            label_colour = GREEN if height >= target_val else RED
+
+        # --- label positioning and contrast effect ------------------------ #
+        bbox_props = None
+        if height > y_max - (y_max * 0.05): # Overflow if height > 95% of y_max
+            y_pos     = height - offset
+            va        = "top"
+            # Add a white box for contrast when inside the bar
+            bbox_props = dict(boxstyle="square,pad=0.2", fc="white", ec="none", alpha=0.7)
+        else:                                       # above the bar
+            y_pos     = height + offset
+            va        = "bottom"
+
+        ax.text(
+            bar.get_x() + bar.get_width() / 2.0,
+            y_pos,
+            f"{height:.1f}%",
+            ha="center",
+            va=va,
+            fontsize=9,
+            fontweight="bold",
+            color=label_colour,
+            bbox=bbox_props
+        )
+
+    return ax
+
+
+# =============================================================================
+# 🎨 POWERPOINT CREATION FUNCTIONS
+# =============================================================================
+
+def create_ops_review_presentation(template_path: str, selected_month: int,
+                                 selected_year: int, output_dir: str = '.') -> Tuple[str, Presentation]:
+    """
+    Build a two-slide Operations Review deck using template.
+
+    This adds intro slides to the template without removing any slides
+    to completely avoid XML corruption issues.
+
+    Args:
+        template_path: Path to PowerPoint template
+        selected_month: Month for the report
+        selected_year: Year for the report
+        output_dir: Directory to save the presentation
+
+    Returns:
+        Tuple of (output_path, presentation_object)
+    """
+    # I/O checks
+    if not os.path.exists(template_path):
+        raise FileNotFoundError(f"Template not found: {template_path}")
+    if not 1 <= selected_month <= 12:
+        raise ValueError("selected_month must be 1‒12")
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Load template and use it as-is
+    prs = Presentation(template_path)
+    original_slide_count = len(prs.slides)
+    print(f"✅ Loaded template with {original_slide_count} original slide(s)")
+
+    # Find TITLE_AND_BODY layout
+    layout = next(
+        (lyt for lyt in prs.slide_layouts if lyt.name.upper() == "TITLE_AND_BODY"),
+        None
+    )
+    if layout is None:
+        # Fallback: use the first available layout
+        layout = prs.slide_layouts[0] if len(prs.slide_layouts) > 0 else None
+        if layout is None:
+            raise RuntimeError("No slide layouts available in template")
+        print(f"⚠️ TITLE_AND_BODY layout not found, using layout: {layout.name}")
+
+    # Helper to add a styled title slide
+    def add_title_slide(text: str) -> None:
+        sld = prs.slides.add_slide(layout)
+        title_shape = sld.shapes.title
+        if title_shape is None:
+            for ph in sld.placeholders:
+                if ph.placeholder_format.type == PP_PLACEHOLDER.TITLE and ph.has_text_frame:
+                    title_shape = ph
+                    break
+        if title_shape is None:  # fallback textbox
+            w, h = Inches(8), Inches(2.5)
+            left = (prs.slide_width - w) // 2
+            top = (prs.slide_height - h) // 2
+            title_shape = sld.shapes.add_textbox(left, top, w, h)
+
+        title_shape.text_frame.clear()
+        p = title_shape.text_frame.paragraphs[0]
+        p.text = text
+        p.alignment = PP_ALIGN.CENTER
+        f = p.font
+        f.name = "Arial"
+        f.size = Pt(60)
+        f.bold = True
+        f.color.rgb = RGBColor(0, 112, 192)
+        p.line_spacing = 1.15
+
+    # Add intro slides - they will be at the end, but that's fine
+    month_name = calendar.month_name[selected_month].upper()
+    add_title_slide(f"Monthly Operations review\n{month_name} {selected_year}")
+    add_title_slide("Production KPIs")
+
+    print(f"✅ Added 2 intro slides (total slides: {len(prs.slides)})")
+    print(f"📝 Note: Intro slides are at positions {len(prs.slides)-1} and {len(prs.slides)}")
+
+    # Save file
+    fname = f"Operations monthly review {selected_month:02d}-{selected_year}.pptx"
+    out_path = os.path.join(output_dir, fname)
+    prs.save(out_path)
+    print(f"💾 Saved → {out_path}   (slides: {len(prs.slides)})")
+
+    return out_path, prs
+
+
+def create_df_eff_reparto(df: pd.DataFrame, selected_month: int,
+                         selected_year: int, reparto_code: str) -> pd.DataFrame:
+    """
+    Creates df_eff_reparto with parametric month and reparto selection
+    (matches notebook implementation exactly)
+
+    Args:
+        df: Raw data DataFrame
+        selected_month: Current month (1-12)
+        selected_year: Current year
+        reparto_code: Department code (default 'ST' for STAMPAGGIO)
+
+    Returns:
+        DataFrame with Period[M] index and efficiency metrics + individual deltas
+    """
+    # Filter data for selected reparto
+    df_reparto = df[df['REPARTO'] == reparto_code].copy()
+
+    # Calculate previous year
+    previous_year = selected_year - 1
+
+    # Filter data for the two-year period and selected months
+    df_filtered = df_reparto[
+        ((df_reparto['ANNO'] == previous_year) & (df_reparto['MESE'] <= selected_month)) |
+        ((df_reparto['ANNO'] == selected_year) & (df_reparto['MESE'] <= selected_month))
+    ].copy()
+
+    # Calculate KPIs grouped by year and month
+    kpi_monthly = df_filtered.groupby(['ANNO', 'MESE', 'MESE_DESCR']).apply(calcola_kpi).reset_index()
+
+    # Create complete date range
+    periods = []
+    for year in [previous_year, selected_year]:
+        for month in range(1, selected_month + 1):
+            periods.append(pd.Period(f"{year}-{month:02d}", freq='M'))
+
+    # Create base dataframe with Period index
+    df_eff_reparto = pd.DataFrame(index=periods)
+    df_eff_reparto.index.name = 'Period'
+
+    # Initialize columns with NaN
+    efficiency_cols = ['EFF_REP', 'EFF_PRO', 'EFF_SC', 'EFF_E', 'OEE']
+    delta_cols = [f'{col}_Delta' for col in efficiency_cols]
+
+    # Initialize all columns
+    for col in efficiency_cols + delta_cols:
+        df_eff_reparto[col] = np.nan
+
+    # Fill in the actual KPI values
+    for _, row in kpi_monthly.iterrows():
+        period = pd.Period(f"{row['ANNO']}-{row['MESE']:02d}", freq='M')
+        if period in df_eff_reparto.index:
+            for col in efficiency_cols:
+                # Convert to percentage and round to 1 decimal
+                df_eff_reparto.loc[period, col] = round(row[col] * 100, 1)
+
+    # Fill missing values with forward fill for continuity
+    for col in efficiency_cols:
+        df_eff_reparto[col] = df_eff_reparto[col].ffill().fillna(0)
+
+    # Calculate % Delta vs previous month for each KPI
+    for i, period in enumerate(df_eff_reparto.index):
+        if i == 0:
+            # First row: no previous month to compare
+            for col in efficiency_cols:
+                df_eff_reparto.loc[period, f'{col}_Delta'] = np.nan
+        else:
+            # Calculate delta for each individual KPI
+            for col in efficiency_cols:
+                prev_value = df_eff_reparto.iloc[i-1][col]
+                curr_value = df_eff_reparto.iloc[i][col]
+
+                if prev_value != 0:
+                    delta = ((curr_value - prev_value) / prev_value) * 100
+                    df_eff_reparto.loc[period, f'{col}_Delta'] = round(delta, 1)
+                else:
+                    df_eff_reparto.loc[period, f'{col}_Delta'] = 0.0
+
+    # Ensure all values are rounded to 1 decimal place
+    for col in efficiency_cols:
+        df_eff_reparto[col] = df_eff_reparto[col].round(1)
+
+    # Reorder columns: KPIs first, then all deltas at the end
+    column_order = efficiency_cols + delta_cols
+    df_eff_reparto = df_eff_reparto[column_order]
+
+    return df_eff_reparto
+
+
+def prepare_comparison_data(df: pd.DataFrame, selected_month: int,
+                          selected_year: int, reparto_code: str) -> Tuple[pd.DataFrame, Dict]:
+    """
+    Prepares a wide-format DataFrame for the efficiency comparison table with delta calculations.
+
+    Processes data to create a DataFrame where rows are months and columns are KPIs.
+    Each cell contains a dictionary with values for the selected year and the previous year.
+    Additionally calculates deltas for the selected month vs its previous month.
+
+    Args:
+        df (pd.DataFrame): The raw 'Dati Grezzi' DataFrame.
+        selected_month (int): The month to report up to.
+        selected_year (int): The main year for the report.
+        reparto_code (str): The department code (e.g., 'ST').
+
+    Returns:
+        tuple: (pd.DataFrame, dict) - The comparison DataFrame and delta calculations.
+    """
+    previous_year = selected_year - 1
+    kpis = ['EFF_REP', 'EFF_PRO', 'EFF_SC', 'EFF_E', 'OEE']
+
+    # Use the existing function to get monthly KPI data (use 12 to get all months for both years)
+    df_eff = create_df_eff_reparto(df, 12, selected_year, reparto_code)
+
+    # Filter for the relevant years and up to the selected month for the current year
+    df_eff = df_eff[df_eff.index.year.isin([previous_year, selected_year])]
+
+    # Italian month names, uppercase
+    month_names = [pd.Timestamp(f'2024-{m}-01').strftime('%B').upper() for m in range(1, 13)]
+
+    # Pivot the data to get years as columns
+    df_pivot = df_eff.reset_index().pivot_table(
+        index=df_eff.index.month,
+        columns=df_eff.index.year,
+        values=kpis
+    )
+    df_pivot.columns = [f'{kpi}_{year}' for kpi, year in df_pivot.columns]
+
+    # Create the final structure
+    output_df = pd.DataFrame(index=month_names, columns=kpis, dtype=object)
+
+    # Calculate deltas for selected month vs previous month
+    deltas = {}
+    if selected_month > 1:
+        for kpi in kpis:
+            try:
+                curr_month_val = df_pivot.loc[selected_month, f'{kpi}_{selected_year}']
+                prev_month_val = df_pivot.loc[selected_month - 1, f'{kpi}_{selected_year}']
+                if pd.notna(curr_month_val) and pd.notna(prev_month_val):
+                    deltas[kpi] = curr_month_val - prev_month_val
+                else:
+                    deltas[kpi] = np.nan
+            except KeyError:
+                deltas[kpi] = np.nan
+
+    for month_num, month_name in enumerate(month_names, 1):
+        for kpi in kpis:
+            try:
+                prev_val = df_pivot.loc[month_num, f'{kpi}_{previous_year}']
+                curr_val = df_pivot.loc[month_num, f'{kpi}_{selected_year}']
+                # Only include data up to the selected month for the current year
+                if month_num > selected_month:
+                    curr_val = np.nan
+            except KeyError:
+                prev_val, curr_val = np.nan, np.nan
+
+            # Use 'at' instead of 'loc' for dictionary assignment
+            output_df.at[month_name, kpi] = {'prev': prev_val, 'curr': curr_val}
+
+    return output_df, deltas
+
+
+def set_table_black_borders(table):
+    """
+    Remove any table style (so PPT won't override) and then
+    set all borders to a solid 1 pt black line on every cell.
+    """
+    from lxml import etree
+    from pptx.oxml.ns import qn
+
+    NS_A = "http://schemas.openxmlformats.org/drawingml/2006/main"
+
+    # 1) strip out the <a:tblStyle> so our borders aren't overridden
+    #    table._tbl is the low-level CT_Table object under the covers
+    tbl = table._tbl
+    tblPr = tbl.tblPr
+    tblStyle = tblPr.find(qn('a:tblStyle'))
+    if tblStyle is not None:
+        tblPr.remove(tblStyle)
+
+    # 2) now inject our own <a:lnL>, <a:lnR>, <a:lnT>, <a:lnB> on every cell
+    for row in table.rows:
+        for cell in row.cells:
+            # cell._tc is the CT_Tc element; get or create its <a:tcPr>
+            tc = cell._tc
+            tcPr = tc.get_or_add_tcPr()
+
+            for border_dir in ('lnL', 'lnR', 'lnT', 'lnB'):
+                # remove any existing
+                for elem in tcPr.findall(f'a:{border_dir}', namespaces={'a': NS_A}):
+                    tcPr.remove(elem)
+
+                # build <a:lnX> with width=12700 EMU (1 pt), flat cap, solid compound
+                ln = etree.SubElement(
+                    tcPr, f'{{{NS_A}}}{border_dir}',
+                    {
+                        'w': '12700',    # 1pt
+                        'cap': 'flat',
+                        'cmpd': 'sng',
+                        'algn': 'ctr'
+                    }
+                )
+                # add <a:solidFill><a:srgbClr val="000000"/></a:solidFill>
+                solidFill = etree.SubElement(ln, f'{{{NS_A}}}solidFill')
+                etree.SubElement(solidFill, f'{{{NS_A}}}srgbClr', val='000000')
+                # ensure it's truly solid
+                etree.SubElement(ln, f'{{{NS_A}}}prstDash', val='solid')
+
+
+def add_eff_comparison_table_slide(prs: Presentation, df: pd.DataFrame, selected_year: int,
+                                  selected_month: int, reparto_code: str, template_path: str = None,
+                                  output_dir: str = '.') -> Presentation:
+    """
+    Adds a new slide with a styled efficiency comparison table to a presentation.
+
+    If `prs` is None, a new presentation is created using `create_ops_review_presentation`.
+    The function adds one slide for the specified department, showing a month-by-month
+    KPI comparison for the selected year vs. the previous year.
+
+    Args:
+        prs (pptx.Presentation or None): The presentation object. If None, a new one is created.
+        df (pd.DataFrame): The raw 'Dati Grezzi' DataFrame.
+        selected_year (int): The primary year for comparison.
+        selected_month (int): The month to report up to.
+        reparto_code (str): The department code (e.g., 'ST', 'MS').
+        template_path (str, optional): Path to the PowerPoint template. Required if prs is None.
+        output_dir (str): Directory where the presentation will be saved.
+
+    Returns:
+        prs (pptx.Presentation): The presentation object with the new slide added.
+    """
+    if prs is None:
+        if template_path is None:
+            raise ValueError("A template_path must be provided if prs is None.")
+        print(f"✨ Creating new presentation using template")
+        _, prs = create_ops_review_presentation(template_path, selected_month, selected_year, output_dir)
+    else:
+        print(f"📂 Using provided presentation object")
+
+    # --- Data and Metadata Preparation ---
+    previous_year = selected_year - 1
+    reparto_descr = REPARTO_DESCRIPTIONS.get(reparto_code, reparto_code)
+    kpi_targets = TARGET_KPI_MAP.get(reparto_code, {})
+    kpis_to_show = ['EFF_REP', 'EFF_PRO', 'EFF_SC', 'EFF_E', 'OEE']
+
+    # Prepare data using the helper function (now returns deltas too)
+    df_comparison, deltas = prepare_comparison_data(df, selected_month, selected_year, reparto_code)
+
+    # --- Slide Creation ---
+    # Try different layouts to find one with a title, starting with index 0
+    slide_layout = None
+    for layout_idx in range(len(prs.slide_layouts)):
+        test_slide = prs.slides.add_slide(prs.slide_layouts[layout_idx])
+        if test_slide.shapes.title is not None:
+            # Found a layout with title, remove the test slide and use this layout
+            prs.slides._sldIdLst.remove(prs.slides._sldIdLst[-1])
+            slide_layout = prs.slide_layouts[layout_idx]
+            break
+        else:
+            # Remove the test slide
+            prs.slides._sldIdLst.remove(prs.slides._sldIdLst[-1])
+
+    # If no layout with title found, use layout 1 and create title manually
+    if slide_layout is None:
+        slide_layout = prs.slide_layouts[1]
+
+    slide = prs.slides.add_slide(slide_layout)
+
+    # Set Title - LEFT ALIGNED and positioned ABOVE the table
+    title_text = f"CONFRONTO EFFICIENZE {previous_year}/{selected_year} – {reparto_descr.upper()}"
+
+    if slide.shapes.title is not None:
+        # Title placeholder exists
+        slide.shapes.title.text = title_text
+        slide.shapes.title.text_frame.paragraphs[0].font.size = Pt(32)
+        slide.shapes.title.text_frame.paragraphs[0].alignment = PP_ALIGN.LEFT  # LEFT ALIGN
+    else:
+        # Create title manually - LEFT ALIGNED and positioned ABOVE table
+        title_box = slide.shapes.add_textbox(Inches(0.3), Inches(0.3), Inches(12.3), Inches(1.0))
+        title_frame = title_box.text_frame
+        title_frame.text = title_text
+        title_para = title_frame.paragraphs[0]
+        title_para.font.size = Pt(32)
+        title_para.font.bold = True
+        title_para.alignment = PP_ALIGN.LEFT  # LEFT ALIGN
+
+    # --- Table Creation and Positioning ---
+    rows, cols = 14, 6  # 1 header row + 12 months + 1 delta row, 6 columns (month + 5 KPIs)
+    table_shape = slide.shapes.add_table(rows, cols, Inches(0.3), Inches(1.6), Inches(12.4), Inches(7.0))
+    table = table_shape.table
+
+    # --- Header Styling ---
+    # Italian month names, uppercase
+    month_names = [pd.Timestamp(f'2024-{m}-01').strftime('%B').upper() for m in range(1, 13)]
+
+    # Month column header - RED BACKGROUND with years styled differently
+    cell_month_header = table.cell(0, 0)
+    cell_month_header.fill.solid()
+    cell_month_header.fill.fore_color.rgb = RGBColor(0xB4, 0x45, 0x57)  # RED BACKGROUND like in image
+
+    tf = cell_month_header.text_frame
+    tf.clear()
+
+    # Previous year paragraph - GRAY TEXT
+    p1 = tf.paragraphs[0]
+    p1.text = str(previous_year)
+    p1.font.color.rgb = RGBColor(0x80, 0x80, 0x80)  # GRAY
+    p1.font.bold = True
+    p1.font.size = Pt(20)  # BIGGER FONT
+    p1.alignment = PP_ALIGN.CENTER
+
+    # Current year paragraph - WHITE TEXT
+    p2 = tf.add_paragraph()
+    p2.text = str(selected_year)
+    p2.font.color.rgb = RGBColor(0xFF, 0xFF, 0xFF)  # WHITE
+    p2.font.bold = True
+    p2.font.size = Pt(20)  # BIGGER FONT
+    p2.alignment = PP_ALIGN.CENTER
+
+    cell_month_header.vertical_anchor = MSO_VERTICAL_ANCHOR.MIDDLE
+
+    # KPI Headers (merged with targets)
+    for i, kpi in enumerate(kpis_to_show, 1):
+        cell_kpi = table.cell(0, i)
+        target_val = kpi_targets.get(kpi, 0)
+
+        # Clear existing text and create two paragraphs
+        tf = cell_kpi.text_frame
+        tf.clear()
+
+        # KPI name paragraph
+        p1 = tf.paragraphs[0]
+        p1.text = kpi
+        p1.font.color.rgb = RGBColor(0xFF, 0xFF, 0xFF)
+        p1.font.bold = True
+        p1.font.size = Pt(20)  # BIGGER FONT
+        p1.alignment = PP_ALIGN.CENTER
+
+        # Target paragraph
+        p2 = tf.add_paragraph()
+        p2.text = f">{target_val}%"
+        p2.font.color.rgb = RGBColor(0xFF, 0xFF, 0xFF)
+        p2.font.size = Pt(20)  # BIGGER FONT
+        p2.alignment = PP_ALIGN.CENTER
+
+        # Set background color based on column
+        cell_kpi.fill.solid()
+        if kpi == 'OEE':  # OEE column should be GRAY
+            cell_kpi.fill.fore_color.rgb = RGBColor(0x80, 0x80, 0x80)  # GRAY for OEE column
+        else:
+            cell_kpi.fill.fore_color.rgb = RGBColor(0x3F, 0x3F, 0x3F)  # Dark gray for other columns
+
+        cell_kpi.vertical_anchor = MSO_VERTICAL_ANCHOR.MIDDLE
+
+    # --- Body Styling ---
+    delta_row_inserted = False
+    current_row = 1
+
+    for month_idx, month_name in enumerate(month_names):
+        # Month Name Column
+        cell_month = table.cell(current_row, 0)
+        cell_month.text = month_name
+        cell_month.fill.solid()
+        cell_month.fill.fore_color.rgb = RGBColor(0xF2, 0xF2, 0xF2)  # Very light grey
+        p = cell_month.text_frame.paragraphs[0]
+        p.font.bold = True
+        p.font.color.rgb = RGBColor(0x00, 0x00, 0x00)  # Black text
+        p.font.size = Pt(18)  # BIGGER FONT
+        p.alignment = PP_ALIGN.CENTER
+        cell_month.vertical_anchor = MSO_VERTICAL_ANCHOR.MIDDLE
+
+        # KPI Value Cells
+        for c, kpi in enumerate(kpis_to_show, 1):
+            cell = table.cell(current_row, c)
+            values = df_comparison.loc[month_name, kpi]
+            prev_val = values.get('prev')
+            curr_val = values.get('curr')
+
+            tf = cell.text_frame
+            tf.clear()
+
+            # Previous year value
+            p1 = tf.paragraphs[0]
+            p1.text = f"{prev_val:.1f}%".replace('.',',') if pd.notna(prev_val) else ""
+            p1.font.color.rgb = RGBColor(0x80, 0x80, 0x80)  # Grey
+            p1.font.size = Pt(18)  # BIGGER FONT
+            p1.alignment = PP_ALIGN.CENTER
+
+            # Current year value
+            p2 = tf.add_paragraph()
+            p2.text = f"{curr_val:.1f}%".replace('.',',') if pd.notna(curr_val) else ""
+            p2.font.bold = True
+            p2.font.size = Pt(18)  # BIGGER FONT
+            p2.alignment = PP_ALIGN.CENTER
+
+            # Color logic for current year value
+            if pd.notna(curr_val):
+                target = kpi_targets.get(kpi, 0)
+                if curr_val >= target:
+                    p2.font.color.rgb = RGBColor(0x00, 0xB0, 0x50)  # Green
+                else:
+                    p2.font.color.rgb = RGBColor(0xC0, 0x00, 0x00)  # Red
+
+            # Set background color for OEE column
+            cell.fill.solid()
+            if kpi == 'OEE':  # OEE column cells should be GRAY
+                cell.fill.fore_color.rgb = RGBColor(0xE5, 0xE5, 0xE5)  # Light gray for OEE data cells
+            else:
+                cell.fill.fore_color.rgb = RGBColor(0xFF, 0xFF, 0xFF)  # White for other columns
+
+            cell.vertical_anchor = MSO_VERTICAL_ANCHOR.MIDDLE
+
+        current_row += 1
+
+        # Insert delta row after selected month
+        if month_idx + 1 == selected_month and not delta_row_inserted and selected_month > 1:
+            # Delta month label
+            cell_delta = table.cell(current_row, 0)
+            cell_delta.text = "Δ vs prev"
+            cell_delta.fill.solid()
+            cell_delta.fill.fore_color.rgb = RGBColor(0xF2, 0xF2, 0xF2)  # Very light grey
+            p = cell_delta.text_frame.paragraphs[0]
+            p.font.size = Pt(15)  # BIGGER FONT
+            p.font.italic = True
+            p.alignment = PP_ALIGN.CENTER
+            cell_delta.vertical_anchor = MSO_VERTICAL_ANCHOR.MIDDLE
+
+            # Delta values
+            for c, kpi in enumerate(kpis_to_show, 1):
+                cell = table.cell(current_row, c)
+                delta_val = deltas.get(kpi)
+
+                tf = cell.text_frame
+                tf.clear()
+
+                p = tf.paragraphs[0]
+                if pd.notna(delta_val):
+                    sign = "+" if delta_val >= 0 else ""
+                    p.text = f"{sign}{delta_val:.1f}%".replace('.',',')
+                    # Color based on delta direction
+                    if delta_val >= 0:
+                        p.font.color.rgb = RGBColor(0x00, 0xB0, 0x50)  # Green for positive
+                    else:
+                        p.font.color.rgb = RGBColor(0xC0, 0x00, 0x00)  # Red for negative
+                else:
+                    p.text = ""
+
+                p.font.size = Pt(12)  # BIGGER FONT
+                p.font.italic = True
+                p.alignment = PP_ALIGN.CENTER
+
+                # Set background color for OEE column
+                cell.fill.solid()
+                if kpi == 'OEE':  # OEE column cells should be GRAY
+                    cell.fill.fore_color.rgb = RGBColor(0xE5, 0xE5, 0xE5)  # Light gray for OEE delta cells
+                else:
+                    cell.fill.fore_color.rgb = RGBColor(0xFF, 0xFF, 0xFF)  # White for other columns
+
+                cell.vertical_anchor = MSO_VERTICAL_ANCHOR.MIDDLE
+
+            current_row += 1
+            delta_row_inserted = True
+
+    # --- Table Border Styling (BLACK borders) ---
+    set_table_black_borders(table)
+
+    # --- Final Table Adjustments ---
+    # Set column widths - distribute evenly across slide width
+    total_width = 23
+    col_width = total_width / cols
+    for i in range(cols):
+        table.columns[i].width = Inches(col_width)
+
+    # Set row heights - need to account for delta row position
+    delta_row_position = selected_month + 1 if selected_month > 1 else None  # Delta row position
+
+    for r in range(rows):
+        if r == 0:  # Header row
+            table.rows[r].height = Inches(1)
+        elif r == delta_row_position:  # Delta row (positioned after selected_month)
+            table.rows[r].height = Inches(0.45)
+        else:  # Month rows
+            table.rows[r].height = Inches(0.8)
+
+    print(f"✅ Slide 'CONFRONTO EFFICIENZE' for {reparto_descr} added successfully.")
+
+    # --- Unit Test Checks (as print statements) ---
+    print("\n--- Running Checks ---")
+    print(f"Table has {len(table.rows)} rows (expected 14)")
+    print(f"Table has {len(table.columns)} columns (expected 6)")
+
+    # Check if delta row was inserted
+    if delta_row_inserted:
+        print(f"✅ Delta row inserted after month {selected_month}")
+    else:
+        print(f"⚠️ Delta row not inserted (selected_month: {selected_month})")
+
+    # Check a value format
+    try:
+        val_check = table.cell(1,1).text_frame.paragraphs[1].text
+        if '%' in val_check and ',' in val_check:
+             print(f"✅ Cell format check passed (e.g., '{val_check}')")
+        else:
+             print(f"⚠️ Cell format check failed (e.g., '{val_check}')")
+    except IndexError:
+        print("⚠️ Could not check cell format.")
+
+    return prs
+
+
+def add_eff_chart_slide(prs: Presentation, df: pd.DataFrame, reparto_code: str,
+                       selected_year: int, selected_month: int) -> Presentation:
+    """
+    Creates a new slide with efficiency chart for a specific department.
+
+    Parameters:
+    -----------
+    prs : pptx.presentation.Presentation
+        PowerPoint presentation object
+    df : pandas.DataFrame
+        Raw data DataFrame (Dati_Grezzi)
+    reparto_code : str
+        Department code (e.g., 'ST', 'MS', 'DC')
+    selected_year : int
+        Year for comparison
+    selected_month : int
+        Month up to which to calculate YTD (1-12)
+
+    Returns:
+    --------
+    pptx.presentation.Presentation
+        Updated presentation object with new chart slide
+    """
+    # Store initial slide count for unit testing
+    initial_slide_count = len(prs.slides)
+
+    # Generate the chart using build_eff_chart
+    fig = build_eff_chart(df, selected_month, selected_year, reparto_code)
+
+    # Extract title from the chart BEFORE removing it and convert to UPPERCASE
+    chart_title = fig.axes[0].get_title().upper()  # Convert to uppercase
+
+    # Remove the chart title and y-axis label to avoid duplication and clean up the chart
+    fig.axes[0].set_title('')
+    fig.axes[0].set_ylabel('')  # Remove y-axis label
+
+    # Save chart as temporary image
+    temp_img_path = None
+    try:
+        with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp_file:
+            temp_img_path = tmp_file.name
+            # Save with exact dimensions (build_eff_chart already sets figsize correctly)
+            fig.savefig(temp_img_path, dpi=96, bbox_inches='tight',
+                       facecolor='white', edgecolor='none')
+
+        # Try to use layout 1 ("B"), otherwise find suitable layout
+        slide_layout = None
+        if len(prs.slide_layouts) > 1:
+            # Try layout index 1 ("B")
+            slide_layout = prs.slide_layouts[1]
+        else:
+            # Fallback: find first layout with title and content placeholders
+            for layout in prs.slide_layouts:
+                placeholders = layout.placeholders
+                has_title = any(p.placeholder_format.type == 1 for p in placeholders)  # Title placeholder
+                has_content = any(p.placeholder_format.type == 7 for p in placeholders)  # Content placeholder
+                if has_title and has_content:
+                    slide_layout = layout
+                    break
+
+            # If still no suitable layout found, use the first available
+            if slide_layout is None:
+                slide_layout = prs.slide_layouts[0]
+
+        # Create new slide
+        slide = prs.slides.add_slide(slide_layout)
+
+        # Set slide title - LEFT ALIGNED and UPPERCASE to match table slide
+        title_placeholder = None
+        for placeholder in slide.placeholders:
+            if placeholder.placeholder_format.type == 1:  # Title placeholder
+                title_placeholder = placeholder
+                break
+
+        if title_placeholder:
+            title_placeholder.text = chart_title  # Already uppercase
+            # Format title: 32pt, bold, LEFT aligned, black (matching table slide)
+            title_frame = title_placeholder.text_frame
+            title_paragraph = title_frame.paragraphs[0]
+            title_paragraph.alignment = PP_ALIGN.LEFT  # Changed from CENTER to LEFT
+            title_run = title_paragraph.runs[0]
+            title_run.font.size = Pt(32)
+            title_run.font.bold = True
+            title_run.font.color.rgb = RGBColor(0, 0, 0)  # Black
+        else:
+            # Create title manually if no placeholder - LEFT ALIGNED and positioned to match table
+            title_box = slide.shapes.add_textbox(Inches(0.3), Inches(0.3), Inches(12.3), Inches(1.0))
+            title_frame = title_box.text_frame
+            title_frame.text = chart_title  # Already uppercase
+            title_para = title_frame.paragraphs[0]
+            title_para.font.size = Pt(32)
+            title_para.font.bold = True
+            title_para.alignment = PP_ALIGN.LEFT  # LEFT ALIGN to match table
+            title_para.font.color.rgb = RGBColor(0, 0, 0)  # Black
+
+        # Insert chart image with double dimensions (2x original: 10" × 5.625" → 20" × 11.25")
+        content_placeholder = None
+        for placeholder in slide.placeholders:
+            if placeholder.placeholder_format.type == 7:  # Content placeholder
+                content_placeholder = placeholder
+                break
+
+        # Define target dimensions: Double the original chart size
+        target_width = Inches(20.0)   # Double of original 10"
+        target_height = Inches(11.25)  # Double of original 5.625"
+
+        if content_placeholder:
+            # Remove the placeholder
+            content_placeholder._element.getparent().remove(content_placeholder._element)
+
+        # Position image - moved right for better centering
+        # Standard slide width is ~13.33", so we move it right to center better
+        slide_width = Inches(13.33)  # Standard slide width
+
+        # Calculate center position and then add offset to move right
+        center_left = (slide_width - target_width) / 2
+        # Move right by 1.5 inches for better visual centering
+        left = center_left + Inches(1.5) if target_width < slide_width else Inches(1.8)
+        top = Inches(1.6)    # Match table top position
+
+        slide.shapes.add_picture(temp_img_path, left, top, target_width, target_height)
+
+        # Unit test checks
+        final_slide_count = len(prs.slides)
+        print(f"✅ Chart slide added for {reparto_code}")
+        print(f"📊 Slide count: {initial_slide_count} → {final_slide_count}")
+        print(f"📋 Slide title (UPPERCASE): '{chart_title}'")
+        print(f"🎯 Chart title and y-axis label removed from image")
+
+        # Verify image dimensions (double size: 20" x 11.25")
+        added_shape = slide.shapes[-1]  # Last added shape should be our image
+        expected_width_emu = int(20.0 * 914400)  # 20" in EMU
+        expected_height_emu = int(11.25 * 914400)  # 11.25" in EMU
+        tolerance = 0.01  # 1% tolerance
+
+        width_ok = abs(added_shape.width - expected_width_emu) / expected_width_emu <= tolerance
+        height_ok = abs(added_shape.height - expected_height_emu) / expected_height_emu <= tolerance
+
+        if width_ok and height_ok:
+            print(f"✅ Image dimensions verified: {added_shape.width} x {added_shape.height} EMU")
+        else:
+            print(f"⚠️ Image dimensions: {added_shape.width} x {added_shape.height} EMU (expected ~{expected_width_emu} x {expected_height_emu})")
+
+        print(f"📐 Image positioned at: Left={added_shape.left/914400:.1f}\", Top={added_shape.top/914400:.1f}\"")
+
+        # Warning about size
+        if target_width > slide_width:
+            print(f"⚠️ Warning: Image width ({target_width/914400:.1f}\") exceeds standard slide width ({slide_width/914400:.1f}\")")
+
+        # Unit test assertions
+        assert final_slide_count == initial_slide_count + 1, f"Expected {initial_slide_count + 1} slides, got {final_slide_count}"
+
+    finally:
+        # Clean up temporary file
+        if temp_img_path and os.path.exists(temp_img_path):
+            os.unlink(temp_img_path)
+
+        # Close the matplotlib figure to free memory
+        plt.close(fig)
+
+    return prs
+
+
+# =============================================================================
+# 🎯 MAIN ENTRY POINT
+# =============================================================================
+
+def make_ppt(csv_path: str, selected_month: int, selected_year: int) -> str:
+    """
+    Main function to generate PowerPoint presentation from CSV data.
+
+    This follows the exact notebook pattern:
+    1. First department (ST) creates the presentation via add_eff_comparison_table_slide with prs=None
+    2. Subsequent departments (MS, DC) add their slides to the existing presentation
+
+    Args:
+        csv_path: Path to the CSV file containing manufacturing data
+        selected_month: Month for the report (1-12)
+        selected_year: Year for the report
+
+    Returns:
+        str: Path to the generated PowerPoint file
+
+    Raises:
+        ValueError: If CSV is invalid or parameters are out of range
+        FileNotFoundError: If CSV file or template is not found
+    """
+    # Validate inputs
+    if not os.path.exists(csv_path):
+        raise FileNotFoundError(f"CSV file not found: {csv_path}")
+
+    if not 1 <= selected_month <= 12:
+        raise ValueError("selected_month must be between 1 and 12")
+
+    if not 2020 <= selected_year <= 2030:
+        raise ValueError("selected_year must be between 2020 and 2030")
+
+    print(f"🚀 Starting PowerPoint generation for all departments")
+    print(f"📂 Input CSV: {csv_path}")
+    print(f"📅 Report period: Up to {calendar.month_name[selected_month]} {selected_year}")
+
+    # Load and validate data
+    df = load_csv_with_encoding_fallback(csv_path)
+    validate_csv_schema(df)
+    df = prepare_dataframe(df)
+
+    # Template path (relative to the module)
+    template_path = Path(__file__).parent.parent / "PPT Assets" / "Single Slide Template Operations monthly review 04-25.pptx"
+    if not template_path.exists():
+        raise FileNotFoundError(f"Template not found: {template_path}")
+
+    # Create output directory in temp
+    output_dir = tempfile.mkdtemp(prefix="briva_ppt_")
+
+    # Departments to process - ST first (creates base), then MS and DC
+    repartos = ['ST', 'MS', 'DC']
+    prs = None
+    final_path = None
+
+    try:
+        # Process departments following exact notebook pattern
+        for reparto_code in repartos:
+            print(f"\n--- Generating slides for {REPARTO_DESCRIPTIONS[reparto_code]} ({reparto_code}) ---")
+
+            # Check if data exists for this reparto
+            reparto_data = df[df['REPARTO'] == reparto_code]
+            if reparto_data.empty:
+                print(f"⚠️ No data found for {reparto_code}, skipping...")
+                continue
+
+            # For the first department, create new presentation via add_eff_comparison_table_slide
+            if reparto_code == repartos[0]:
+                print(f"🏗️ Creating new presentation for first department {reparto_code}")
+
+                # Create new presentation for the first department (follows notebook pattern exactly)
+                prs = add_eff_comparison_table_slide(
+                    prs=None,  # This triggers creation of intro slides
+                    df=df,
+                    selected_year=selected_year,
+                    selected_month=selected_month,
+                    reparto_code=reparto_code,
+                    template_path=str(template_path),
+                    output_dir=output_dir
+                )
+
+                # Set the final path based on the created presentation
+                final_path = os.path.join(output_dir, f"Operations monthly review {selected_month:02d}-{selected_year}.pptx")
+
+                print(f"✅ Base presentation created with {len(prs.slides)} slides")
+
+            else:  # Subsequent departments - add to existing presentation
+                print(f"📄 Adding {reparto_code} slides to existing presentation")
+
+                # Add table slide for subsequent departments
+                prs = add_eff_comparison_table_slide(
+                    prs=prs,
+                    df=df,
+                    selected_year=selected_year,
+                    selected_month=selected_month,
+                    reparto_code=reparto_code
+                )
+
+            # Add chart slide immediately after the table slide for this department
+            print(f"📊 Adding chart slide for {reparto_code}...")
+            prs = add_eff_chart_slide(
+                prs=prs,
+                df=df,
+                reparto_code=reparto_code,
+                selected_year=selected_year,
+                selected_month=selected_month
+            )
+
+            print(f"✅ {reparto_code} slides added. Total slides: {len(prs.slides)}")
+
+        if prs is None:
+            raise ValueError("No valid departments found in the data")
+
+        # Remove the first empty slide (template slide) at the very end to avoid XML corruption
+        # This is done after all slides have been created to minimize disruption
+        if len(prs.slides) > 8:  # We expect 8 slides (2 intro + 6 department slides)
+            print(f"\n🗑️ Removing original template slide (slide 1) at end of process...")
+            try:
+                # Get the first slide (index 0) - this should be the empty template slide
+                first_slide = prs.slides[0]
+
+                # Check if it's actually empty/template slide by looking for minimal content
+                is_empty_template = True
+                for shape in first_slide.shapes:
+                    if hasattr(shape, 'text_frame') and shape.text_frame:
+                        try:
+                            text_content = shape.text_frame.text.strip()
+                            if text_content and len(text_content) > 10:  # More than just placeholder text
+                                is_empty_template = False
+                                break
+                        except:
+                            pass
+
+                if is_empty_template:
+                    # Use the simplest possible approach - remove from slide ID list only
+                    # This avoids relationship manipulation issues
+                    sldIdLst = prs.slides._sldIdLst
+                    if len(sldIdLst) > 0:
+                        # Remove the first slide ID (index 0)
+                        removed_slide = sldIdLst[0]
+                        sldIdLst.remove(removed_slide)
+
+                        print(f"✅ Successfully removed empty template slide")
+                        print(f"📊 Final slide count: {len(prs.slides)} slides")
+                    else:
+                        print(f"⚠️ Slide ID list is empty")
+                else:
+                    print(f"⚠️ First slide appears to have content, not removing")
+
+            except Exception as e:
+                print(f"⚠️ Could not remove template slide: {e}")
+                print(f"📊 Keeping all {len(prs.slides)} slides")
+
+        # Save final presentation
+        if final_path:
+            prs.save(final_path)
+            print(f"\n✅ Final PowerPoint saved: {final_path}")
+            print(f"📊 Total slides: {len(prs.slides)}")
+            print(f"🏭 Departments included: {', '.join(repartos)}")
+
+            # Verify "Production KPIs" slide is present
+            production_kpis_found = False
+            for i, slide in enumerate(prs.slides):
+                for shape in slide.shapes:
+                    if hasattr(shape, 'text_frame') and shape.text_frame:
+                        try:
+                            text_content = shape.text_frame.text.strip()
+                            if 'Production KPIs' in text_content:
+                                production_kpis_found = True
+                                print(f"✅ 'Production KPIs' slide verified in position {i+1}")
+                                break
+                        except:
+                            pass
+                if production_kpis_found:
+                    break
+
+            if not production_kpis_found:
+                print("⚠️ Warning: 'Production KPIs' slide not found in final presentation")
+
+            return final_path
+        else:
+            raise RuntimeError("Failed to create presentation")
+
+    except Exception as e:
+        print(f"❌ Error creating PowerPoint: {str(e)}")
+        raise
+
+
+# =============================================================================
+# 🧪 TESTING AND VALIDATION
+# =============================================================================
+
+def validate_ppt_output(ppt_path: str) -> bool:
+    """
+    Validate that the generated PowerPoint file is valid.
+
+    Args:
+        ppt_path: Path to the PowerPoint file
+
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    try:
+        if not os.path.exists(ppt_path):
+            print(f"❌ File does not exist: {ppt_path}")
+            return False
+
+        # Try to load the file
+        prs = Presentation(ppt_path)
+
+        # Check that it has at least 1 slide
+        if len(prs.slides) < 1:
+            print(f"❌ Presentation has no slides")
+            return False
+
+        file_size = os.path.getsize(ppt_path)
+        print(f"✅ PowerPoint validation passed:")
+        print(f"   📁 File size: {file_size:,} bytes")
+        print(f"   📊 Slides: {len(prs.slides)}")
+        print(f"   📐 Dimensions: {prs.slide_width} x {prs.slide_height}")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ PowerPoint validation failed: {str(e)}")
+        return False
+
+
+if __name__ == "__main__":
+    # Example usage for testing
+    import sys
+
+    if len(sys.argv) < 4:
+        print("Usage: python generator.py <csv_path> <selected_month> <selected_year>")
+        print("Example: python generator.py data.csv 5 2024")
+        print("This will create a report for May 2024 covering all departments (ST, MS, DC)")
+        sys.exit(1)
+
+    csv_file = sys.argv[1]
+    try:
+        selected_month = int(sys.argv[2])
+        selected_year = int(sys.argv[3])
+    except ValueError:
+        print("❌ Error: selected_month and selected_year must be integers")
+        print("Example: python generator.py data.csv 5 2024")
+        sys.exit(1)
+
+    try:
+        output_path = make_ppt(csv_file, selected_month, selected_year)
+        if validate_ppt_output(output_path):
+            print(f"🎉 Success! PowerPoint created at: {output_path}")
+        else:
+            print("❌ PowerPoint validation failed")
+            sys.exit(1)
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        sys.exit(1)

template.pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:794dd2583c70a3685de6a6f5c700921a6dfb425c52589f4844244287a30ca477
+size 288052