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

.github/workflows/frontend.yml

@@ -36,13 +36,13 @@ jobs:
           node-version: 24
           cache: npm
           cache-dependency-path: apps/frontend/package-lock.json
-      
-      - run: npm ci 
+
+      - run: npm ci
         working-directory: apps/frontend
       - run: npm run build
         working-directory: apps/frontend
 
-  test:  
+  test:
     needs: build
     runs-on: ubuntu-latest
     steps:
@@ -52,9 +52,9 @@ jobs:
           node-version: 24
           cache: npm
           cache-dependency-path: apps/frontend/package-lock.json
-      - run: npm ci 
+      - run: npm ci
         working-directory: apps/frontend
-      - run: npm test -- --watch=false
+      - run: npm test -- --watch=false --coverage
         working-directory: apps/frontend
 
   sonarqube:
@@ -70,7 +70,7 @@ jobs:
         env:
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
 
-    
+
   # deploy:
   #   runs-on: ubuntu-latest
   #   steps:

.github/workflows/ml.yml

@@ -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

.gitignore

@@ -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/

Makefile

@@ -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 \
-        ml-lint ml-typecheck ml-test ml-check ml-train
+        openapi docker-build db-up db-down db-reset db-logs db-psql migrate bootstrap-admin
 
 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)
 

README.md

@@ -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

docs/adr/0005-modele-prediction-lightgbm.md

@@ -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.

docs/architecture/00-vue-ensemble.md

@@ -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 |

ml/.python-version

@@ -1 +0,0 @@
-3.14

ml/README.md

@@ -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`.

ml/enervision_ml/baseline.py

@@ -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]

ml/enervision_ml/config.py

@@ -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)

ml/enervision_ml/data.py

@@ -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]

ml/enervision_ml/features.py

@@ -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)

ml/enervision_ml/metrics.py

@@ -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()),
-    }

ml/enervision_ml/train.py

@@ -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()

ml/pyproject.toml

@@ -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"]

ml/tests/test_baseline.py

@@ -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]

ml/tests/test_features.py

@@ -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

ml/tests/test_metrics.py

@@ -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

ml/tests/test_train.py

@@ -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"]