batch_runner.py

"""
Batch runner per l'esecuzione sequenziale di esperimenti multipli.

Carica una serie di file YAML di configurazione e li esegue uno dopo
l'altro tramite ExperimentPipeline, senza intervento manuale.
Ogni esperimento è isolato: un fallimento viene loggato e il runner
prosegue con il successivo.

Uso:
    # Modalità A — file espliciti:
    python batch_runner.py config/exp_xgboost.yaml config/exp_malconv2.yaml

    # Modalità B — cartella di configurazioni:
    python batch_runner.py --config-dir config/batch/

    # Combinabile con dry-run per verifica:
    python batch_runner.py --config-dir config/batch/ --dry-run

Functions:
    collect_config_paths: Risolve la lista ordinata di file YAML da eseguire.
    run_single_experiment: Esegue un singolo esperimento e restituisce il risultato.
    print_summary: Stampa il riepilogo della sessione batch.
    main: Entry point del batch runner.
"""

import argparse
import os
import sys
import time
from datetime import datetime
from pathlib import Path

import yaml

from src.pipeline.experiment_pipeline import ExperimentPipeline


def collect_config_paths(args: argparse.Namespace) -> list[str]:
    """Risolve la lista ordinata di file YAML da eseguire.

    Supporta due modalità mutuamente esclusive:
      - ``--config-dir``: scansiona una cartella e raccoglie tutti i
        ``.yaml`` / ``.yml`` in ordine alfabetico.
      - argomenti posizionali: lista esplicita di percorsi forniti
        dall'utente sulla riga di comando.

    Args:
        args (argparse.Namespace): Namespace prodotto da
            ``argparse.ArgumentParser.parse_args()``.  Deve contenere
            gli attributi ``config_dir`` (``str | None``) e ``configs``
            (``list[str]``).

    Returns:
        list[str]: Lista ordinata di percorsi assoluti ai file YAML.

    Raises:
        SystemExit: Se nessun file viene trovato, se la cartella
            indicata da ``--config-dir`` non esiste, oppure se uno
            dei percorsi posizionali non corrisponde a un file.
    """
    paths: list[str] = []

    if args.config_dir:
        config_dir = Path(args.config_dir)
        if not config_dir.is_dir():
            print(f"[ERRORE] La cartella non esiste: {config_dir}")
            sys.exit(1)

        for ext in ("*.yaml", "*.yml"):
            paths.extend(str(p) for p in config_dir.glob(ext))

        paths.sort()

    elif args.configs:
        for p in args.configs:
            if not os.path.isfile(p):
                print(f"[ERRORE] File non trovato: {p}")
                sys.exit(1)
            paths.append(p)

    if not paths:
        print("[ERRORE] Nessun file di configurazione trovato.")
        print("Uso: python batch_runner.py file1.yaml file2.yaml ...")
        print("     python batch_runner.py --config-dir config/batch/")
        sys.exit(1)

    return paths

def run_single_experiment(config_path: str, index: int, total: int) -> dict:
    """Esegue un singolo esperimento e restituisce il risultato.

    Carica il file YAML indicato da ``config_path``, istanzia una
    ``ExperimentPipeline`` e ne invoca il metodo ``run()``.  In caso di
    eccezione l'errore viene catturato, loggato e incluso nel dizionario
    di ritorno senza interrompere il batch.

    Args:
        config_path (str): Percorso al file YAML di configurazione
            dell'esperimento.
        index (int): Numero progressivo (1-based) dell'esperimento
            all'interno della coda del batch.
        total (int): Numero totale di esperimenti nella coda.

    Returns:
        dict: Dizionario con le informazioni sull'esecuzione contenente
            le seguenti chiavi:

            - **config** (*str*) — percorso del file YAML.
            - **experiment_name** (*str*) — nome dell'esperimento letto
              dal config, oppure ``"senza_nome"`` se assente.
            - **status** (*str*) — ``"OK"`` se completato con successo,
              ``"FALLITO"`` altrimenti.
            - **duration_s** (*float*) — durata dell'esecuzione in secondi.
            - **error** (*str | None*) — messaggio di errore (solo se
              fallito, altrimenti ``None``).
    """
    print("\n" + "#" * 65)
    print(f"# BATCH [{index}/{total}] — {config_path}")
    print("#" * 65)

    result = {
        "config": config_path,
        "experiment_name": "?",
        "status": "OK",
        "duration_s": 0.0,
        "error": None,
    }

    start = time.time()

    try:
        with open(config_path, "r") as f:
            config = yaml.safe_load(f)

        result["experiment_name"] = config.get("experiment_name", "senza_nome")

        pipeline = ExperimentPipeline(config)
        pipeline.run()

    except Exception as e:
        result["status"] = "FALLITO"
        result["error"] = str(e)
        print(f"\n[ERRORE] Esperimento fallito: {e}")

    result["duration_s"] = round(time.time() - start, 1)
    return result


def print_summary(results: list[dict], total_time: float) -> None:
    """Stampa il riepilogo della sessione batch su standard output.

    Visualizza una tabella con stato, nome dell'esperimento, durata e,
    in caso di fallimento, il messaggio di errore (troncato a 80 caratteri).
    In coda riporta il conteggio totale di esperimenti riusciti/falliti e
    il tempo complessivo.

    Args:
        results (list[dict]): Lista di dizionari prodotti da
            :func:`run_single_experiment`, uno per ogni esperimento
            eseguito.
        total_time (float): Tempo totale trascorso dall'inizio alla
            fine dell'intera sessione batch, in secondi.
    """
    n_ok = sum(1 for r in results if r["status"] == "OK")
    n_fail = len(results) - n_ok

    print("\n" + "=" * 65)
    print("RIEPILOGO BATCH".center(65))
    print("=" * 65)

    for i, r in enumerate(results, 1):
        status_icon = "✓" if r["status"] == "OK" else "✗"
        line = (
            f"  {status_icon} [{i}] {r['experiment_name']:<25s} "
            f"{r['status']:<8s} {r['duration_s']:>8.1f}s"
        )
        print(line)
        if r["error"]:
            print(f"        Errore: {r['error'][:80]}")

    print("-" * 65)
    print(f"  Totale: {len(results)} esperimenti — {n_ok} OK, {n_fail} falliti")
    print(f"  Tempo totale: {total_time:.1f}s ({total_time / 60:.1f} min)")
    print("=" * 65 + "\n")


def main() -> None:
    """Entry point del batch runner.

    Configura l'argument parser, raccoglie i file YAML tramite
    :func:`collect_config_paths`, e — salvo il flag ``--dry-run`` —
    esegue ogni esperimento in sequenza tramite
    :func:`run_single_experiment`.  Al termine stampa il riepilogo
    con :func:`print_summary` e termina con exit code 1 se almeno un
    esperimento è fallito.
    """
    parser = argparse.ArgumentParser(
        description="Esegue sequenzialmente N esperimenti da file YAML distinti.",
        epilog=(
            "Esempi:\n"
            "  python batch_runner.py config/exp1.yaml config/exp2.yaml\n"
            "  python batch_runner.py --config-dir config/batch/\n"
            "  python batch_runner.py --config-dir config/batch/ --dry-run"
        ),
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )

    parser.add_argument(
        "configs",
        nargs="*",
        help="Percorsi ai file YAML di configurazione (modalità esplicita).",
    )
    parser.add_argument(
        "--config-dir",
        type=str,
        default=None,
        help="Cartella contenente i file .yaml/.yml da eseguire in ordine alfabetico.",
    )
    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Mostra la coda degli esperimenti senza eseguirli.",
    )

    args = parser.parse_args()
    config_paths = collect_config_paths(args)

    print("\n" + "=" * 65)
    print("BATCH RUNNER — Malware Detection Pipeline".center(65))
    print(f"Avvio: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}".center(65))
    print(f"Esperimenti in coda: {len(config_paths)}".center(65))
    print("=" * 65)

    for i, path in enumerate(config_paths, 1):
        print(f"  [{i}] {path}")

    if args.dry_run:
        print("\n[DRY-RUN] Nessun esperimento eseguito.\n")
        return

    batch_start = time.time()
    results: list[dict] = []

    for i, config_path in enumerate(config_paths, 1):
        result = run_single_experiment(config_path, i, len(config_paths))
        results.append(result)

    total_time = time.time() - batch_start
    print_summary(results, total_time)

    if any(r["status"] == "FALLITO" for r in results):
        sys.exit(1)


if __name__ == "__main__":
    main()