chore(ci): ajoute la couverture de tests au job test du frontend

2026-09-17 13:55:17 +02:00
23 changed files with 9 additions and 3092 deletions
@@ -54,7 +54,7 @@ jobs:
          cache-dependency-path: apps/frontend/package-lock.json
      - run: npm ci
        working-directory: apps/frontend
-      - run: npm test -- --watch=false
+      - run: npm test -- --watch=false --coverage
        working-directory: apps/frontend
  sonarqube:
@@ -1,59 +0,0 @@
 name: ML
 # Piège : la version de Python vient de ml/.python-version, et doit rester en 3.14 (cf.
 # .github/workflows/backend.yml, même contrainte).
 on:
  push:
    paths:
      - "ml/**"
      - ".github/workflows/ml.yml"
  pull_request:
    paths:
      - "ml/**"
      - ".github/workflows/ml.yml"
 permissions:
  contents: read
 concurrency:
  group: ml-${{ github.ref }}
  cancel-in-progress: true
 jobs:
  verification:
    name: Lint, typage et tests
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: ml
    steps:
      - name: Récupère le dépôt
        uses: actions/checkout@v4
      - name: Installe uv
        uses: astral-sh/setup-uv@v5
        with:
          enable-cache: true
          cache-dependency-glob: ml/uv.lock
      - name: Installe l'interpréteur déclaré par .python-version
        run: uv python install
      - name: Synchronise les dépendances sans dévier du verrou
        run: uv sync --all-groups --frozen
      - name: Vérifie le formatage
        run: uv run ruff format --check .
      - name: Analyse statique
        run: uv run ruff check --output-format=github .
      - name: Typage
        run: uv run mypy enervision_ml tests
      # Aucun test ne touche PostgreSQL ni MLflow distant : tout tourne sur donnees
      # synthetiques ou un magasin SQLite local jetable (cf. ml/tests/test_train.py).
      - name: Tests
        run: uv run pytest
@@ -58,14 +58,6 @@ data/raw/*
 monitoring/grafana/data/
 monitoring/prometheus/data/
 # ML : jeu de donnees, modeles entraines et suivi MLflow local, tous generes/volumineux
 ml/data/
 ml/models/*
 !ml/models/.gitkeep
 ml/mlruns/
 ml/mlartifacts/
 ml/mlflow.db
 # IDE et OS
 .idea/
 .vscode/
@@ -1,17 +1,15 @@
 BACKEND := apps/backend
 FRONTEND := apps/frontend
 ML := ml
 .DEFAULT_GOAL := help
-.PHONY: help install install-backend install-frontend install-ml dev dev-backend dev-frontend \
+.PHONY: help install install-backend install-frontend dev dev-backend dev-frontend \
        lint format typecheck test test-cov test-integration check \
-        openapi docker-build db-up db-down db-reset db-logs db-psql migrate bootstrap-admin \
+        openapi docker-build db-up db-down db-reset db-logs db-psql migrate bootstrap-admin
        ml-lint ml-typecheck ml-test ml-check ml-train
 help: ## Liste les cibles disponibles
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'
-install: install-backend install-frontend install-ml ## Installe les dépendances backend, frontend et ML
+install: install-backend install-frontend ## Installe les dépendances backend et frontend
 install-backend: ## Installe les dépendances du backend
 	cd $(BACKEND) && uv sync --all-groups
@@ -19,9 +17,6 @@ install-backend: ## Installe les dépendances du backend
 install-frontend: ## Installe les dépendances du frontend
 	cd $(FRONTEND) && npm ci
 install-ml: ## Installe les dépendances du pipeline ML
 	cd $(ML) && uv sync --all-groups
 dev: ## Lance toute la stack (backend + frontend) en rechargement à chaud
 	@trap 'kill 0' EXIT INT TERM; \
 	$(MAKE) --no-print-directory dev-backend & \
@@ -60,20 +55,6 @@ check: lint typecheck test ## Chaîne de vérification complète
 openapi: ## Régénère apps/backend/openapi.json depuis les routes déclarées
 	cd $(BACKEND) && uv run python -m app.cli export-openapi
 ml-lint: ## Analyse statique du pipeline ML
 	cd $(ML) && uv run ruff check .
 ml-typecheck: ## Vérifie le typage du pipeline ML
 	cd $(ML) && uv run mypy enervision_ml tests
 ml-test: ## Exécute les tests du pipeline ML (donnees synthetiques, sans base ni serveur MLflow)
 	cd $(ML) && uv run pytest
 ml-check: ml-lint ml-typecheck ml-test ## Chaîne de vérification complète du pipeline ML
 ml-train: ## Entraine le modele LightGBM. CSV=chemin optionnel, sinon lit ML_DATABASE_URL
 	cd $(ML) && uv run python -m enervision_ml.train $(if $(CSV),--csv $(CSV),)
 docker-build: ## Construit l'image du backend
 	docker build -t enervision-backend:local $(BACKEND)
@@ -25,7 +25,6 @@ Ce que la documentation apporte à chacun : [docs/architecture/00-vue-ensemble.m
 | Infra      | Terraform (k3s single-node)         | `infra/terraform`   | Initialise    |
 | CI/CD      | GitHub Actions                      | `.github/workflows` | Backend en place |
 | Monitoring | Prometheus, Grafana, Alertmanager   | `monitoring`        | A initialiser |
 | ML         | LightGBM, MLflow                    | `ml`                | Entrainement initialise |
 Le backend, la base et l'infrastructure (Terraform/k3s) sont initialises a ce stade. Le frontend
 sert un tableau de bord sur `/dashboard`, dont les données proviennent de fixtures : les endpoints
@@ -54,7 +53,6 @@ L'etat detaille de chaque brique et les vues d'architecture sont dans
 ├── infra/terraform/
 │   ├── modules/        Modules reutilisables
 │   └── environments/   Racines Terraform, une par environnement
 ├── ml/                 Pipeline d'entrainement LightGBM, suivi MLflow
 ├── monitoring/
 │   ├── prometheus/     Collecte et regles d'alerte
 │   ├── grafana/        Provisioning et dashboards
@@ -1,101 +0,0 @@
 # 0005 - Modèle de prédiction de consommation : LightGBM
 - Statut : accepté
 - Date : 2026-09-17
 ## Contexte
 Le schéma `prediction` contraint déjà la forme de la solution (deux cibles de régression,
 `consumption_kw` instantané et `consumption_kwh` sur `period_minutes`, un statut
 `insufficient_data` à détecter explicitement), mais aucun modèle n'était choisi. Trois
 contraintes non négociables cadrent le choix, discutées dans l'issue #89 :
 1. **EC06** (grille de notation individuelle) exige un modèle **entraîné, versionné avec
   MLflow**, exposé via un endpoint fonctionnel, avec **surveillance du drift** en production.
 2. **Aucun GPU dédié** : l'infra tourne on-premise sur une VM à 4 CPU / 8 Gio RAM (ou
   `Standard_B2s`/`B2ms` côté Azure, 2 vCPU max) — Azure Machine Learning est de toute façon
   bloqué par la politique Azure du projet.
 3. **Délai serré** : le jalon J3 arrive à échéance le lendemain de la décision, J4 concentre déjà
   26 issues sur 4 jours. Un modèle long à mettre en œuvre retarde la chaîne complète (service de
   scoring #37, moteur de recommandations #38, tests ML #44/#45, tous bloqués par ce choix).
 Le jeu de données est déjà disponible (`all_sites_combined.csv`, fourni par le formateur) : 7
 sites, 2 ans au pas horaire (~17 500 lignes/site), avec `temperature_celsius`,
 `humidity_percent`, `solar_irradiance_wm2` en régresseurs exogènes et des features calendaires
 déjà dérivées.
 ## Options comparées
 | Critère | Prophet | LightGBM/XGBoost | NeuralProphet | SARIMA | Holt-Winters | Mistral (LLM) |
 |---|---|---|---|---|---|---|
 | Saisonnalités multiples (jour/semaine/an) | Oui, nativement | Oui, via features engineered | Oui, nativement, + autorégression | Une seule, lourd à régler (SARIMAX) | Une seule, aucune | Non conçu pour ça |
 | Régresseurs exogènes | Oui, mais doivent être connus dans le futur au moment de la prédiction | Oui, via lags/moyennes glissantes sur le passé | Oui, natif | Difficile en multivarié | Aucun support | Contexte de prompt seulement, non appris |
 | Coût de calcul (VM sans GPU) | Faible | Faible | Élevé (deep learning) | Faible | Faible | Élevé à prohibitif |
 | Versionnable MLflow | Oui, nativement | Oui, nativement | Pas de support direct | Oui, générique | Pas de support direct | Rien à versionner (pas un modèle entraîné) |
 | Granularité | Un modèle par site (ou par site × métrique) | Un seul modèle global sur tous les sites | Un par site | Un par site | Un par site | — |
 | Effort avant l'échéance | Faible | Moyen (feature engineering) | Élevé | Moyen à élevé | Faible en soi | Élevé, ou factice |
 ## Décision
 **LightGBM, un seul modèle global** couvrant tous les sites, plutôt qu'un modèle par site
 (Prophet) ou par famille de site. Cible : `consumption_kwh`, avec `period_minutes` comme feature
 d'entrée plutôt que comme étape d'agrégation post-prédiction. Suivi et versioning via **MLflow**
 (tracking + registre de modèles), sur le magasin local par défaut dans un premier temps —
 l'hébergement sur l'infra k3s reste une question ouverte, non bloquante pour démarrer.
 Raisons retenues, au-delà du tableau ci-dessus :
 - **Un modèle global plutôt qu'un modèle par site** évite la fragilité des sites les moins
  fournis en historique : ils bénéficient de ce qu'apprennent les autres sites, ce qu'un Prophet
  par site ne permet pas.
 - **Aucune dépendance à une prévision météo future.** Prophet exige que ses régresseurs
  (`add_regressor`) soient connus au moment prédit ; `temperature_celsius`,
  `humidity_percent` et `solar_irradiance_wm2` sont des mesures passées, pas des prévisions, et
  aucune source de prévision météo n'existe dans le projet. LightGBM s'en sort avec des features
  de lag/moyenne glissante calculées sur l'historique déjà présent dans `reading`, cf.
  `ml/enervision_ml/features.py` — un choix qui vaut aussi bien à l'entraînement qu'au futur
  scoring.
 - **Apprentissage direct sur `consumption_kwh`** avec `period_minutes` en feature, sans étape
  d'agrégation intermédiaire que la sortie continue de Prophet aurait demandée.
 - **Coût de calcul compatible avec l'infra on-premise sans GPU.**
 Débat complet, comparatif détaillé et décision finale : issue #89 (Johan, phyri0s,
 ValentinDeFaria), actée en réunion d'équipe du 2026-09-17 et validée par l'ensemble de l'équipe.
 ## Conséquences
 - Le pipeline d'entraînement (`ml/`, ce commit) lit `reading` + `site` par connexion PostgreSQL
  directe et construit ses features par lags/moyennes glissantes plutôt que par régresseurs
  contemporains, cf. `docs/ML-START.md`.
 - Le rôle PostgreSQL dédié `enervision_ml` (lecture seule sur `reading`/`site`) n'est pas encore
  provisionné : dette déjà assumée par l'ADR 0003 pour les comptes ETL/ML, `ML_DATABASE_URL`
  pointe pour l'instant vers la même base que le backend applicatif en développement.
 - Le service de scoring (#37), le moteur de recommandations (#38) et les tests de dérive
  (#44/#45) restent à construire ; ils consommeront le même module `enervision_ml.features`, qui
  doit rester strictement identique entre entraînement et scoring pour éviter un train/serve skew
  silencieux.
 - La surveillance de drift exigée par EC06 n'est pas encore implémentée : ce ticket ne livre que
  l'entraînement et son suivi MLflow (paramètres, métriques, artefact modèle), pas le monitoring
  en production.
 - L'hébergement de MLflow sur l'infra k3s reste une question ouverte ; le magasin SQLite local
  (`ml/mlflow.db`, ignoré par git) suffit pour l'instant à comparer des runs sur un poste.
 ## Alternatives écartées
 - **Prophet** : proposition initiale, écartée après débat pour les raisons ci-dessus (modèle par
  site, dépendance à une météo future indisponible, agrégation kWh en post-traitement). Reste un
  candidat solide si un jour le projet doit produire une décomposition tendance/saisonnalité
  explicable pour un usage différent.
 - **Mistral (LLM)** : aucun produit dédié aux séries temporelles ; interroger un LLM généraliste
  ne constitue pas un modèle entraîné et versionnable au sens MLflow, et le fine-tuning est hors
  budget de calcul et hors délai.
 - **SARIMA** : ne gère pas nativement plusieurs régresseurs exogènes ; réglage (p,d,q,P,D,Q) plus
  long que le délai disponible.
 - **NeuralProphet** : fait tout ce que fait Prophet et apprend en plus des motifs autorégressifs,
  mais coûte plus cher en calcul (pas de GPU disponible) et n'a pas d'outil MLflow direct — piste
  d'évolution possible, non engageante à ce stade.
 - **Holt-Winters** : écarté d'entrée, pas seulement différé — aucun support de régresseurs
  exogènes, alors que la météo et l'irradiance sont nécessaires ici.
 - **CatBoost** : même famille que LightGBM, gère nativement les colonnes catégorielles (comme
  `site_type`) sans encodage manuel. Non rejeté, différé : candidat à comparer si LightGBM
  plafonne en précision.
@@ -77,7 +77,6 @@ collecteur ne vient le lire.
 | Backend | FastAPI, Python 3.14 | `apps/backend` | `En cours` | Factory, configuration, journalisation, 2 sondes de santé, `/metrics`, contrat OpenAPI versionné, routes `sites`, `alerts`, `recommendations`, `stats/summary` et `readings` en lecture (endpoints → services → repositories → models) |
 | Frontend | Angular 22, Node 24 | `apps/frontend` | `En cours` | Tableau de bord sur route `/dashboard`, deux services HTTP, graphiques Chart.js, données servies par des fixtures |
 | Base | PostgreSQL 17 + TimescaleDB | `db` | `Fait` | Bootstrap de l'extension, base de test, chaîne Alembic. Schéma applicatif créé (`site`, `dataset`, `reading` en hypertable, `prediction`, `alert`, `recommendation`) |
 | ML | LightGBM, MLflow | `ml` | `En cours` | Pipeline d'entraînement (features par lags/moyennes glissantes, baseline de persistance saisonnière, suivi MLflow local), voir [ADR 0005](../adr/0005-modele-prediction-lightgbm.md) et [ML-START.md](../../ML-START.md). Scoring, endpoint et surveillance de dérive pas encore construits |
 | Infra | Terraform, k3s single-node | `infra/terraform` | `En cours` | Module d'installation du cluster. Jamais appliqué, aucune ressource Kubernetes déclarée |
 | Monitoring | Prometheus, Grafana, Alertmanager | `monitoring` | `Cible` | Rien, hors le `/metrics` exposé par l'API |
 | ETL | Apache Airflow | `etl/airflow` | `Cible` | Rien |
@@ -1 +0,0 @@
 3.14
@@ -1,88 +0,0 @@
 # ML EnerVision
 Pipeline d'entrainement du modele de prevision de consommation energetique. Contexte complet :
 [ADR 0005](../docs/adr/0005-modele-prediction-lightgbm.md) (choix du modele) et
 [ML-START.md](../ML-START.md) (mecanisme d'acces aux donnees).
 | Element      | Choix                                        |
 |--------------|-----------------------------------------------|
 | Python       | 3.14                                          |
 | Gestionnaire | uv (`uv.lock` fait foi)                       |
 | Modele       | LightGBM (regression, un seul modele global)  |
 | Suivi        | MLflow (parametres, metriques, artefact)      |
 | Lint/format  | ruff                                          |
 | Typage       | mypy en mode strict                           |
 | Tests        | pytest, donnees synthetiques uniquement       |
 Projet Python independant de `apps/backend` : le service FastAPI n'a aucune raison d'embarquer
 LightGBM/MLflow en dependance de production juste pour un script d'entrainement lance a la main.
 ## Installation
 ```bash
 uv sync --all-groups
 ```
 ## Donnees
 Deux sources, qui produisent le meme schema en sortie de `enervision_ml.data` (voir le module
 pour le detail) :
 - **CSV** (`--csv`), chemin de demarrage : lit directement `ml/data/all_sites_combined.csv`, le
  jeu de donnees fourni pour le jalon J3. Ce dossier est ignore par git (gros fichier, local a
  chaque poste) : recuperer le CSV et `dataset_metadata.json` aupres de l'equipe et les placer
  dans `ml/data/` avant d'entrainer sur cette source.
 - **PostgreSQL** (par defaut, sans `--csv`) : connexion directe a `reading` + `site` via
  `ML_DATABASE_URL`, le chemin cible decrit dans `ML-START.md`. Le role PostgreSQL dedie
  `enervision_ml` (lecture seule) n'est pas encore provisionne (dette assumee, cf. ADR 0003 et
  ADR 0005) ; en attendant, pointer `ML_DATABASE_URL` vers la meme base que le backend suffit en
  developpement.
 ## Entrainement
 ```bash
 uv run python -m enervision_ml.train --csv data/all_sites_combined.csv
 # ou, une fois la base peuplee et ML_DATABASE_URL positionnee :
 uv run python -m enervision_ml.train
 ```
 Ecrit le modele entraine dans `models/lightgbm-consumption.txt` (`Booster.save_model()`, dossier
 ignore par git) et journalise la run dans MLflow : parametres, MAE/RMSE/MAPE du modele **et** de
 la baseline de persistance saisonniere (consommation de la meme heure, une semaine avant), et
 l'artefact modele. Sans `MLFLOW_TRACKING_URI`, MLflow ecrit dans un magasin SQLite local
 (`./mlflow.db`, ignore par git) : `uv run mlflow ui` pour le consulter.
 `--test-fraction` (0.15 par defaut) fixe la part la plus recente de l'historique reservee a la
 validation. La coupure est **chronologique**, jamais un tirage aleatoire de lignes : un tirage
 aleatoire laisserait des lignes de validation "voir" des lignes d'entrainement via leurs
 lags/moyennes glissantes, une fuite qui masquerait un surapprentissage.
 ## Commandes
 ```bash
 uv run ruff check .                       # lint
 uv run ruff format .                      # format
 uv run mypy enervision_ml tests           # typage strict
 uv run pytest                             # tests
 ```
 Depuis la racine du monorepo, via le `Makefile` : `make install-ml`, `make ml-lint`,
 `make ml-typecheck`, `make ml-test`, `make ml-check`, `make ml-train` (`CSV=chemin` optionnel).
 ## Ou ecrire les tests
 Aucun test ne touche PostgreSQL ni un serveur MLflow distant : `enervision_ml.data.load_from_csv`
 et le chargement CSV de test suffisent a exercer `build_features` sur des donnees reelles ou
 synthetiques, et `enervision_ml.train.train()` accepte un `tracking_uri` SQLite isole (`tmp_path`
 pytest) pour un test de bout en bout sans effet de bord. `enervision_ml.data.load_from_database`
 n'est pas encore couvert : il n'existe aucune base PostgreSQL a interroger en CI ni dans cet
 environnement de developpement pour le moment.
 ## Piege a connaitre
 `enervision_ml.features.build_features` est **le seul endroit** qui doit construire les features
 du modele, a l'entrainement comme au futur scoring (service #37, pas encore construit). Si les
 deux divergent meme legerement (une fenetre de moyenne glissante calculee differemment, par
 exemple), le modele recoit en production des features qui ne ressemblent plus a ce qu'il a
 appris, et ses predictions deviennent silencieusement mauvaises sans qu'aucune erreur ne se
 declenche. Ne jamais reecrire cette logique ailleurs : importer `enervision_ml.features`.
@@ -1,16 +0,0 @@
 """Baseline de persistance saisonniere, la barre a depasser pour justifier LightGBM.
 Predit la consommation de l'heure cible par celle de la meme heure, une semaine avant
 (`consumption_kwh_lag_168h`) : une consommation energetique horaire est dominee par le cycle
 hebdomadaire (jours ouvres contre week-end), donc ce naif-la est deja un concurrent serieux.
 """
 import pandas as pd
 from enervision_ml.features import TARGET_COLUMN
 SEASONAL_LAG_COLUMN = f"{TARGET_COLUMN}_lag_168h"
 def seasonal_persistence_predictions(features: pd.DataFrame) -> pd.Series:
    return features[SEASONAL_LAG_COLUMN]
@@ -1,38 +0,0 @@
 """Configuration minimale du pipeline, lue depuis l'environnement.
 Pas de `BaseSettings` Pydantic ici : contrairement a `apps/backend`, ce n'est pas un service qui
 tourne en continu mais un script CLI lance a la main (cf. `docs/ML-START.md`), donc pas de
 surface de configuration a valider au demarrage d'un processus long.
 """
 import os
 # Piege : ce n'est pas `DATABASE_URL` (celui du backend applicatif, proprietaire du schema).
 # `docs/ML-START.md` et l'ADR 0003 designent un role PostgreSQL dedie et restreint en lecture,
 # `enervision_ml`, non encore provisionne (dette assumee). Reutiliser `DATABASE_URL` par defaut
 # ferait tourner l'entrainement avec les droits d'ecriture complets de l'application, en
 # silence.
 ML_DATABASE_URL_ENV = "ML_DATABASE_URL"
 MLFLOW_EXPERIMENT_NAME = "consumption-forecast"
 MLFLOW_TRACKING_URI_ENV = "MLFLOW_TRACKING_URI"
 def database_url() -> str:
    valeur = os.environ.get(ML_DATABASE_URL_ENV)
    if not valeur:
        raise RuntimeError(
            f"{ML_DATABASE_URL_ENV} n'est pas defini. Elle doit pointer vers un role "
            "PostgreSQL en lecture seule sur `reading`/`site` (voir docs/ML-START.md)."
        )
    return valeur
 def mlflow_tracking_uri() -> str | None:
    """`None` laisse MLflow choisir son magasin local par defaut.
    Piege : ce n'est plus `./mlruns` en clair depuis MLflow 3 (magasin fichier "maintenance
    mode", refuse une URI `file:` explicite sauf `MLFLOW_ALLOW_FILE_STORE=true`), mais une base
    SQLite locale (`./mlflow.db`).
    """
    return os.environ.get(MLFLOW_TRACKING_URI_ENV)
@@ -1,68 +0,0 @@
 """Chargement des donnees d'entrainement.
 Deux chemins, qui doivent produire le meme schema de sortie (colonnes `site_id`, `timestamp`,
 `consumption_kwh`, `temperature_celsius`, `humidity_percent`, `solar_irradiance_wm2`,
 `is_working_hours`, `site_type`, `capacity_kw`), consomme ensuite par `enervision_ml.features` :
 - `load_from_database` : le chemin cible decrit dans `docs/ML-START.md`, connexion PostgreSQL
  directe (`reading` + `site`), pas par l'API. C'est celui qu'utilisera le pipeline en
  production, une fois le role PostgreSQL dedie `enervision_ml` provisionne (dette assumee,
  documentee dans `CLAUDE.md` et l'ADR 0003 : pour l'instant, la meme chaine de connexion que le
  backend applicatif convient en developpement).
 - `load_from_csv` : chemin de demarrage, tant que la base locale n'est pas peuplee. Lit
  directement `ml/data/all_sites_combined.csv` (jeu de donnees fourni pour le jalon J3, cf.
  issue #89), le meme fichier que celui consomme par
  `apps/backend/app/etl/historical_import.py`. `capacity_kw` n'existe pas dans ce CSV : la
  colonne est renvoyee a `NaN`, que LightGBM gere nativement comme valeur manquante.
 """
 from pathlib import Path
 import pandas as pd
 from sqlalchemy import text
 from sqlalchemy.engine import Connectable
 OUTPUT_COLUMNS = [
    "site_id",
    "timestamp",
    "consumption_kwh",
    "temperature_celsius",
    "humidity_percent",
    "solar_irradiance_wm2",
    "is_working_hours",
    "site_type",
    "capacity_kw",
 ]
 _READING_QUERY = text(
    """
    SELECT
        r.site_id,
        r.timestamp,
        r.consumption_kwh,
        r.temperature_celsius,
        r.humidity_percent,
        r.solar_irradiance_wm2,
        r.is_working_hours,
        s.site_type,
        s.capacity_kw
    FROM reading r
    JOIN site s ON s.site_id = r.site_id
    ORDER BY r.site_id, r.timestamp
    """
 )
 def load_from_database(connection: Connectable) -> pd.DataFrame:
    """Lit l'historique complet `reading` + `site` depuis PostgreSQL."""
    frame = pd.read_sql(_READING_QUERY, connection)
    return frame[OUTPUT_COLUMNS]
 def load_from_csv(csv_path: Path) -> pd.DataFrame:
    """Lit le jeu de donnees CSV historique (chemin de demarrage, hors base)."""
    frame = pd.read_csv(csv_path, parse_dates=["timestamp"])
    frame["capacity_kw"] = float("nan")
    frame["is_working_hours"] = frame["is_working_hours"].astype(bool)
    return frame[OUTPUT_COLUMNS]
@@ -1,129 +0,0 @@
 """Construction des features pour le modele de consommation.
 Module partage entre l'entrainement et le futur scoring (cf. `docs/ML-START.md`) : la fonction
 qui construit les features doit rester strictement identique des deux cotes, sous peine de
 "train/serve skew" silencieux (le modele recoit en production des features qui ne ressemblent
 plus a ce qu'il a appris).
 """
 from collections.abc import Sequence
 import pandas as pd
 # Cible de l'entrainement : consommation en kWh, jamais consumption_kw (absent des lectures
 # historiques CSV, cf. `apps/backend/app/etl/historical_import.py`).
 TARGET_COLUMN = "consumption_kwh"
 # Decalages horaires utilises pour les lags et moyennes glissantes : une heure avant, un jour
 # avant (meme heure), une semaine avant (meme heure, meme jour) - saisonnalites usuelles d'une
 # consommation energetique horaire.
 LAG_HOURS: Sequence[int] = (1, 24, 168)
 ROLLING_WINDOWS_HOURS: Sequence[int] = (24, 168)
 STATIC_FEATURE_COLUMNS: Sequence[str] = ("site_type", "capacity_kw")
 CALENDAR_FEATURE_COLUMNS: Sequence[str] = (
    "hour",
    "day_of_week",
    "month",
    "is_weekend",
    "is_working_hours",
 )
 WEATHER_COLUMNS: Sequence[str] = (
    "temperature_celsius",
    "humidity_percent",
    "solar_irradiance_wm2",
 )
 def build_features(frame: pd.DataFrame) -> pd.DataFrame:
    """Construit la matrice de features a partir de lectures brutes triees par site.
    `frame` doit porter au minimum : `site_id`, `timestamp`, `consumption_kwh`,
    `is_working_hours`, les trois colonnes meteo, et les colonnes statiques de site
    (`site_type`, `capacity_kw`). Une ligne par `(site_id, timestamp)`, sans doublon.
    Piege : la meteo n'entre dans les features que decalee (lag/moyenne glissante), jamais a
    l'instant cible. A l'entrainement comme au scoring, la meteo au moment predit n'est pas une
    mesure mais une prevision que le projet n'a pas — l'utiliser telle quelle romprait le
    contrat entre entrainement et usage reel (la feature ne serait tout simplement plus
    disponible en production). Cf. debat d'architecture dans l'issue #89.
    """
    travail = frame.sort_values(["site_id", "timestamp"]).reset_index(drop=True)
    calendrier = _calendar_features(travail["timestamp"])
    decalees = _lagged_features(travail)
    features = pd.concat(
        [
            travail[["site_id", "timestamp"]],
            travail[list(STATIC_FEATURE_COLUMNS)],
            calendrier,
            travail[["is_working_hours"]],
            decalees,
            travail[[TARGET_COLUMN]],
        ],
        axis=1,
    )
    # `period_minutes` : resolution temporelle de la cible. Les lectures historiques sont toutes
    # au pas horaire (cf. `dataset_metadata.json`, `frequency: "1h""), donc une constante pour
    # l'instant. Exposee comme feature plutot que supposee implicitement, pour que le modele
    # puisse un jour apprendre sur d'autres resolutions sans reentrainement de zero.
    features["period_minutes"] = 60
    return features
 def feature_columns() -> list[str]:
    """Liste ordonnee des colonnes d'entree du modele (hors identifiants et cible)."""
    lag_columns = [f"consumption_kwh_lag_{h}h" for h in LAG_HOURS]
    rolling_columns = [
        f"{colonne}_rolling_mean_{fenetre}h"
        for colonne in (TARGET_COLUMN, *WEATHER_COLUMNS)
        for fenetre in ROLLING_WINDOWS_HOURS
    ]
    weather_lag_columns = [f"{colonne}_lag_1h" for colonne in WEATHER_COLUMNS]
    return [
        *STATIC_FEATURE_COLUMNS,
        *CALENDAR_FEATURE_COLUMNS,
        "period_minutes",
        *lag_columns,
        *rolling_columns,
        *weather_lag_columns,
    ]
 def _calendar_features(timestamps: pd.Series) -> pd.DataFrame:
    instants = pd.to_datetime(timestamps)
    return pd.DataFrame(
        {
            "hour": instants.dt.hour,
            "day_of_week": instants.dt.dayofweek,
            "month": instants.dt.month,
            "is_weekend": instants.dt.dayofweek.isin([5, 6]).astype(int),
        }
    )
 def _lagged_features(travail: pd.DataFrame) -> pd.DataFrame:
    par_site = travail.groupby("site_id", sort=False)
    colonnes: dict[str, pd.Series] = {}
    for decalage in LAG_HOURS:
        colonnes[f"{TARGET_COLUMN}_lag_{decalage}h"] = par_site[TARGET_COLUMN].shift(decalage)
    for colonne in (TARGET_COLUMN, *WEATHER_COLUMNS):
        decale = par_site[colonne].shift(1)
        for fenetre in ROLLING_WINDOWS_HOURS:
            colonnes[f"{colonne}_rolling_mean_{fenetre}h"] = decale.groupby(
                travail["site_id"]
            ).transform(lambda serie, fenetre=fenetre: serie.rolling(fenetre, min_periods=1).mean())
    for colonne in WEATHER_COLUMNS:
        colonnes[f"{colonne}_lag_1h"] = par_site[colonne].shift(1)
    return pd.DataFrame(colonnes, index=travail.index)
@@ -1,24 +0,0 @@
 """Metriques de regression partagees entre le modele et la baseline."""
 import numpy as np
 import pandas as pd
 from sklearn.metrics import mean_absolute_error, root_mean_squared_error
 def regression_metrics(y_true: pd.Series, y_pred: pd.Series) -> dict[str, float]:
    """MAE, RMSE et MAPE (en %), sur les paires non nulles des deux series."""
    valides = y_true.notna() & y_pred.notna()
    reel = y_true[valides]
    predit = y_pred[valides]
    # MAPE diverge a consommation nulle : les mesures a zero (site a l'arret) sont exclues de ce
    # seul ratio, pas des autres metriques.
    non_nul = reel != 0
    mape = float(np.mean(np.abs((reel[non_nul] - predit[non_nul]) / reel[non_nul])) * 100)
    return {
        "mae": float(mean_absolute_error(reel, predit)),
        "rmse": float(root_mean_squared_error(reel, predit)),
        "mape": mape,
        "n_observations": int(valides.sum()),
    }
@@ -1,245 +0,0 @@
 """Entrainement du modele LightGBM de prevision de consommation energetique.
 CLI autonome, sur le meme gabarit que `apps/backend/app/etl/historical_import.py`
 (argparse, connexion directe a la base). Cf. `docs/ML-START.md`, section 1.
    uv run python -m enervision_ml.train --csv ../ml/data/all_sites_combined.csv
    uv run python -m enervision_ml.train  # lit ML_DATABASE_URL
 Le modele entraine est ecrit en fichier (`Booster.save_model()`) et suivi par MLflow (parametres,
 metriques, artefact). La base ne stocke jamais le modele lui-meme, seulement une reference vers
 lui (`prediction.model_reference`, pose par le futur service de scoring - hors perimetre ici).
 """
 import argparse
 from pathlib import Path
 from typing import Any
 import lightgbm as lgb
 import mlflow
 import mlflow.lightgbm
 import pandas as pd
 from sqlalchemy import create_engine
 from enervision_ml import config
 from enervision_ml.baseline import seasonal_persistence_predictions
 from enervision_ml.data import load_from_csv, load_from_database
 from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
 from enervision_ml.metrics import regression_metrics
 CATEGORICAL_FEATURES = ["site_type"]
 LIGHTGBM_PARAMS: dict[str, Any] = {
    "objective": "regression",
    "metric": "mae",
    "learning_rate": 0.05,
    "num_leaves": 63,
    "min_data_in_leaf": 50,
    "feature_fraction": 0.8,
    "bagging_fraction": 0.8,
    "bagging_freq": 1,
    "verbosity": -1,
 }
 NUM_BOOST_ROUND = 1000
 EARLY_STOPPING_ROUNDS = 50
 DEFAULT_TEST_FRACTION = 0.15
 def load_raw_frame(csv_path: Path | None) -> pd.DataFrame:
    """Lit les lectures brutes, depuis le CSV de demarrage ou depuis PostgreSQL."""
    if csv_path is not None:
        return load_from_csv(csv_path)
    engine = create_engine(config.database_url())
    try:
        return load_from_database(engine)
    finally:
        engine.dispose()
 def chronological_split(
    features: pd.DataFrame, test_fraction: float
 ) -> tuple[pd.DataFrame, pd.DataFrame]:
    """Coupe par date de coupure, jamais par tirage aleatoire de lignes.
    Une coupure aleatoire laisserait des lignes d'apres la coupure "voir" des lignes d'avant via
    leurs lags/moyennes glissantes, une fuite qui masquerait un surapprentissage a l'evaluation.
    """
    coupure = features["timestamp"].quantile(1 - test_fraction)
    entrainement = features[features["timestamp"] < coupure]
    validation = features[features["timestamp"] >= coupure]
    return entrainement, validation
 def prepare_dataset(frame: pd.DataFrame, columns: list[str]) -> tuple[pd.DataFrame, pd.Series]:
    typee = frame.copy()
    typee["site_type"] = typee["site_type"].astype("category")
    return typee[columns], typee[TARGET_COLUMN]
 def train(
    *,
    csv_path: Path | None,
    model_output: Path,
    test_fraction: float = DEFAULT_TEST_FRACTION,
    tracking_uri: str | None = None,
 ) -> tuple[dict[str, float], dict[str, float]]:
    """Execute le pipeline complet et rend (metriques du modele, metriques de la baseline)."""
    raw = load_raw_frame(csv_path)
    features = build_features(raw)
    columns = feature_columns()
    # Les premieres 168h par site n'ont pas de lag hebdomadaire complet : ni entrainables, ni
    # comparables a la baseline saisonniere qui en depend.
    utilisable = features.dropna(subset=[TARGET_COLUMN, f"{TARGET_COLUMN}_lag_168h"])
    entrainement, validation = chronological_split(utilisable, test_fraction)
    if entrainement.empty or validation.empty:
        raise ValueError(
            "Fenetre d'entrainement ou de validation vide : jeu de donnees trop court pour "
            f"test_fraction={test_fraction}."
        )
    X_train, y_train = prepare_dataset(entrainement, columns)
    X_valid, y_valid = prepare_dataset(validation, columns)
    train_set = lgb.Dataset(
        X_train,
        label=y_train,
        categorical_feature=CATEGORICAL_FEATURES,
        free_raw_data=False,
    )
    valid_set = lgb.Dataset(
        X_valid,
        label=y_valid,
        reference=train_set,
        categorical_feature=CATEGORICAL_FEATURES,
        free_raw_data=False,
    )
    booster = lgb.train(
        LIGHTGBM_PARAMS,
        train_set,
        num_boost_round=NUM_BOOST_ROUND,
        valid_sets=[valid_set],
        callbacks=[
            lgb.early_stopping(EARLY_STOPPING_ROUNDS, verbose=False),
            lgb.log_evaluation(period=0),
        ],
    )
    predictions = pd.Series(
        booster.predict(X_valid, num_iteration=booster.best_iteration),
        index=X_valid.index,
    )
    model_metrics = regression_metrics(y_valid, predictions)
    baseline_metrics = regression_metrics(y_valid, seasonal_persistence_predictions(validation))
    model_output.parent.mkdir(parents=True, exist_ok=True)
    booster.save_model(str(model_output))
    _log_to_mlflow(
        tracking_uri=tracking_uri,
        booster=booster,
        model_metrics=model_metrics,
        baseline_metrics=baseline_metrics,
        n_train=len(X_train),
        n_valid=len(X_valid),
        test_fraction=test_fraction,
        model_output=model_output,
    )
    return model_metrics, baseline_metrics
 def _log_to_mlflow(
    *,
    tracking_uri: str | None,
    booster: lgb.Booster,
    model_metrics: dict[str, float],
    baseline_metrics: dict[str, float],
    n_train: int,
    n_valid: int,
    test_fraction: float,
    model_output: Path,
 ) -> None:
    uri = tracking_uri or config.mlflow_tracking_uri()
    if uri is not None:
        mlflow.set_tracking_uri(uri)
    mlflow.set_experiment(config.MLFLOW_EXPERIMENT_NAME)
    with mlflow.start_run():
        mlflow.log_params(
            {
                **LIGHTGBM_PARAMS,
                "num_boost_round": booster.best_iteration or NUM_BOOST_ROUND,
                "test_fraction": test_fraction,
                "n_train": n_train,
                "n_valid": n_valid,
            }
        )
        mlflow.log_metrics({f"model_{cle}": valeur for cle, valeur in model_metrics.items()})
        mlflow.log_metrics({f"baseline_{cle}": valeur for cle, valeur in baseline_metrics.items()})
        mlflow.lightgbm.log_model(booster, name="model")
        mlflow.log_artifact(str(model_output))
 def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Entrainement du modele LightGBM EnerVision")
    parser.add_argument(
        "--csv",
        type=Path,
        default=None,
        help=(
            "Chemin vers le CSV historique (chemin de demarrage). Omis, lit ML_DATABASE_URL "
            "et se connecte directement a PostgreSQL (reading + site)."
        ),
    )
    parser.add_argument(
        "--model-output",
        type=Path,
        default=Path("models/lightgbm-consumption.txt"),
        help="Chemin d'ecriture du modele entraine. Defaut : models/lightgbm-consumption.txt.",
    )
    parser.add_argument(
        "--test-fraction",
        type=float,
        default=DEFAULT_TEST_FRACTION,
        help=(
            "Part la plus recente de l'historique reservee a la validation. "
            f"Defaut : {DEFAULT_TEST_FRACTION}."
        ),
    )
    parser.add_argument(
        "--mlflow-tracking-uri",
        default=None,
        help="Surcharge MLFLOW_TRACKING_URI. Omis, magasin SQLite local (./mlflow.db).",
    )
    return parser.parse_args()
 def main() -> None:
    args = parse_args()
    model_metrics, baseline_metrics = train(
        csv_path=args.csv,
        model_output=args.model_output,
        test_fraction=args.test_fraction,
        tracking_uri=args.mlflow_tracking_uri,
    )
    print("Modele LightGBM :", model_metrics)
    print("Baseline saisonniere (t-168h) :", baseline_metrics)
    if model_metrics["mae"] < baseline_metrics["mae"]:
        gain = (1 - model_metrics["mae"] / baseline_metrics["mae"]) * 100
        print(f"LightGBM bat la baseline de {gain:.1f}% de MAE.")
    else:
        print("LightGBM ne bat pas la baseline saisonniere sur ce decoupage.")
 if __name__ == "__main__":
    main()
@@ -1,79 +0,0 @@
 [project]
 name = "enervision-ml"
 version = "0.1.0"
 description = "Pipeline d'entrainement et de scoring du modele de prediction EnerVision (LightGBM)"
 requires-python = ">=3.14,<3.15"
 dependencies = [
    "pandas>=3.0.5",
    "sqlalchemy>=2.0.52",
    "psycopg[binary]>=3.2",
    "lightgbm>=4.6",
    "scikit-learn>=1.7",
    "mlflow>=3.0",
 ]
 [dependency-groups]
 dev = [
    "ruff>=0.16.7",
    "mypy>=2.3.1",
    "pytest>=9.1.1",
    "pandas-stubs>=3.0.5.260914",
 ]
 [build-system]
 requires = ["hatchling>=1.32.0"]
 build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["enervision_ml"]
 [tool.ruff]
 line-length = 100
 target-version = "py314"
 src = ["enervision_ml", "tests"]
 [tool.ruff.lint]
 select = [
    "E", "W",
    "F",
    "I",
    "N",
    "UP",
    "B",
    "C4",
    "SIM",
    "TID",
    "RUF",
    "S",
    "PT",
 ]
 # N806 : `X`/`y` (donnees/cible) est la convention scikit-learn/LightGBM, pas une variable mal
 # nommee.
 ignore = ["B008", "N806"]
 [tool.ruff.lint.per-file-ignores]
 "tests/**/*.py" = ["S101"]
 [tool.ruff.lint.isort]
 known-first-party = ["enervision_ml"]
 [tool.ruff.format]
 quote-style = "double"
 [tool.mypy]
 python_version = "3.14"
 strict = true
 warn_unreachable = true
 [[tool.mypy.overrides]]
 module = ["tests.*"]
 disallow_untyped_defs = false
 [[tool.mypy.overrides]]
 module = ["lightgbm.*", "mlflow.*", "sklearn.*"]
 ignore_missing_imports = true
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-q --strict-markers -m 'not integration'"
 markers = ["integration: requiert une base PostgreSQL joignable"]
@@ -1,11 +0,0 @@
 import pandas as pd
 from enervision_ml.baseline import SEASONAL_LAG_COLUMN, seasonal_persistence_predictions
 def test_seasonal_persistence_predictions_returns_the_168h_lag_column() -> None:
    features = pd.DataFrame({SEASONAL_LAG_COLUMN: [1.0, 2.0, 3.0], "autre_colonne": [9, 9, 9]})
    predictions = seasonal_persistence_predictions(features)
    assert predictions.tolist() == [1.0, 2.0, 3.0]
@@ -1,96 +0,0 @@
 from datetime import UTC, datetime, timedelta
 from typing import cast
 import pandas as pd
 from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
 def make_site_reading(
    site_id: str, *, heures: int, depart: datetime, valeur: float = 10.0
 ) -> pd.DataFrame:
    instants = [depart + timedelta(hours=h) for h in range(heures)]
    return pd.DataFrame(
        {
            "site_id": site_id,
            "timestamp": instants,
            TARGET_COLUMN: [valeur + h for h in range(heures)],
            "temperature_celsius": [15.0] * heures,
            "humidity_percent": [50.0] * heures,
            "solar_irradiance_wm2": [0.0] * heures,
            "is_working_hours": [True] * heures,
            "site_type": "office",
            "capacity_kw": 100.0,
        }
    )
 def two_site_frame(heures: int = 200) -> pd.DataFrame:
    depart = datetime(2026, 1, 1, tzinfo=UTC)
    return pd.concat(
        [
            make_site_reading("site-a", heures=heures, depart=depart, valeur=10.0),
            make_site_reading("site-b", heures=heures, depart=depart, valeur=1000.0),
        ],
        ignore_index=True,
    )
 def test_build_features_returns_every_declared_feature_column() -> None:
    features = build_features(two_site_frame())
    manquantes = set(feature_columns()) - set(features.columns)
    assert manquantes == set()
 def test_build_features_sets_a_constant_period_minutes() -> None:
    features = build_features(two_site_frame())
    assert (features["period_minutes"] == 60).all()
 def test_build_features_lag_1h_matches_the_previous_hour_of_the_same_site() -> None:
    features = build_features(two_site_frame(heures=200))
    site_a = features[features["site_id"] == "site-a"].reset_index(drop=True)
    assert site_a.loc[10, f"{TARGET_COLUMN}_lag_1h"] == site_a.loc[9, TARGET_COLUMN]
 def test_build_features_lag_168h_is_nan_before_a_full_week_of_history() -> None:
    features = build_features(two_site_frame(heures=200))
    site_a = features[features["site_id"] == "site-a"].reset_index(drop=True)
    assert pd.isna(site_a.loc[100, f"{TARGET_COLUMN}_lag_168h"])
    assert not pd.isna(site_a.loc[168, f"{TARGET_COLUMN}_lag_168h"])
 def test_build_features_never_leaks_lags_across_sites() -> None:
    # site-b demarre a 1000 : si un lag de site-a s'y glissait, la valeur sortirait de son
    # echelle (10, 11, 12, ...).
    features = build_features(two_site_frame(heures=200))
    site_b = features[features["site_id"] == "site-b"].reset_index(drop=True)
    assert cast(float, site_b.loc[5, f"{TARGET_COLUMN}_lag_1h"]) >= 1000.0
 def test_build_features_rolling_mean_excludes_the_current_hour() -> None:
    # Valeurs constantes sauf la derniere ligne : si la moyenne glissante incluait l'heure
    # courante, la constante ne resterait pas stable jusqu'au bout.
    depart = datetime(2026, 1, 1, tzinfo=UTC)
    frame = make_site_reading("site-a", heures=200, depart=depart, valeur=10.0)
    frame[TARGET_COLUMN] = 10.0
    frame.loc[frame.index[-1], TARGET_COLUMN] = 10_000.0
    features = build_features(frame).reset_index(drop=True)
    assert features.loc[len(features) - 1, f"{TARGET_COLUMN}_rolling_mean_24h"] == 10.0
 def test_build_features_computes_calendar_fields_from_the_timestamp() -> None:
    depart = datetime(2026, 1, 3, 6, tzinfo=UTC)  # un samedi, 6h
    features = build_features(make_site_reading("site-a", heures=1, depart=depart))
    assert features.loc[0, "hour"] == 6
    assert features.loc[0, "day_of_week"] == 5
    assert features.loc[0, "is_weekend"] == 1
@@ -1,45 +0,0 @@
 import pandas as pd
 import pytest
 from enervision_ml.metrics import regression_metrics
 def test_regression_metrics_computes_mae_and_rmse_on_known_values() -> None:
    y_true = pd.Series([10.0, 20.0, 30.0])
    y_pred = pd.Series([12.0, 18.0, 33.0])
    resultat = regression_metrics(y_true, y_pred)
    assert resultat["mae"] == pytest.approx(7 / 3)
    assert resultat["n_observations"] == 3
 def test_regression_metrics_ignores_rows_with_a_missing_value() -> None:
    y_true = pd.Series([10.0, None, 30.0])
    y_pred = pd.Series([12.0, 18.0, None])
    resultat = regression_metrics(y_true, y_pred)
    assert resultat["n_observations"] == 1
    assert resultat["mae"] == 2.0
 def test_regression_metrics_excludes_zero_actuals_from_mape_only() -> None:
    y_true = pd.Series([0.0, 10.0])
    y_pred = pd.Series([5.0, 12.0])
    resultat = regression_metrics(y_true, y_pred)
    assert resultat["n_observations"] == 2
    assert resultat["mape"] == pytest.approx(20.0)
 def test_metrics_are_zero_for_a_perfect_prediction() -> None:
    y_true = pd.Series([10.0, 20.0])
    y_pred = pd.Series([10.0, 20.0])
    resultat = regression_metrics(y_true, y_pred)
    assert resultat["mae"] == 0.0
    assert resultat["rmse"] == 0.0
    assert resultat["mape"] == 0.0
@@ -1,76 +0,0 @@
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 import numpy as np
 import pandas as pd
 from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
 from enervision_ml.train import chronological_split, prepare_dataset, train
 def make_frame(site_id: str, *, heures: int, depart: datetime) -> pd.DataFrame:
    instants = [depart + timedelta(hours=h) for h in range(heures)]
    rng = np.random.default_rng(42)
    return pd.DataFrame(
        {
            "site_id": site_id,
            "timestamp": instants,
            TARGET_COLUMN: 100.0 + 10.0 * np.sin(np.arange(heures) / 24) + rng.normal(0, 1, heures),
            "temperature_celsius": 15.0,
            "humidity_percent": 50.0,
            "solar_irradiance_wm2": 0.0,
            "is_working_hours": True,
            "site_type": "office",
            "capacity_kw": 100.0,
        }
    )
 def test_chronological_split_puts_the_most_recent_rows_in_validation() -> None:
    depart = datetime(2026, 1, 1, tzinfo=UTC)
    features = make_frame("site-a", heures=200, depart=depart)
    entrainement, validation = chronological_split(features, test_fraction=0.2)
    assert entrainement["timestamp"].max() < validation["timestamp"].min()
    # La coupure vient d'un quantile sur les dates : une approximation du taux demande, pas un
    # decompte exact de lignes.
    assert abs(len(validation) - 0.2 * len(features)) <= 2
 def test_prepare_dataset_types_site_type_as_a_pandas_category() -> None:
    depart = datetime(2026, 1, 1, tzinfo=UTC)
    features = build_features(make_frame("site-a", heures=200, depart=depart))
    X, y = prepare_dataset(features, feature_columns())
    assert X["site_type"].dtype.name == "category"
    assert y.name == TARGET_COLUMN
 def test_train_runs_end_to_end_on_synthetic_data_and_beats_a_dummy_baseline(
    tmp_path: Path,
 ) -> None:
    depart = datetime(2026, 1, 1, tzinfo=UTC)
    frame = pd.concat(
        [
            make_frame("site-a", heures=400, depart=depart),
            make_frame("site-b", heures=400, depart=depart),
        ],
        ignore_index=True,
    )
    csv_path = tmp_path / "synthetic.csv"
    frame.to_csv(csv_path, index=False)
    model_metrics, baseline_metrics = train(
        csv_path=csv_path,
        model_output=tmp_path / "model.txt",
        test_fraction=0.2,
        tracking_uri=f"sqlite:///{tmp_path / 'mlflow.db'}",
    )
    assert (tmp_path / "model.txt").exists()
    assert model_metrics["n_observations"] > 0
    assert model_metrics["mae"] >= 0
    assert baseline_metrics["n_observations"] == model_metrics["n_observations"]