Merge branch 'dev' into feat/pipeline-ci

.github/workflows/backend.yml

@@ -56,87 +56,3 @@ jobs:
       # Le marqueur `integration` est exclu par défaut, donc aucune base n'est nécessaire ici.
       - name: Tests et couverture
         run: uv run pytest --cov-fail-under=85
-
-  # Piège : l'image est celle de docker-compose.yml, pas une image `postgres` nue. La première
-  # migration (`5353c0e4f094`) échoue volontairement si l'extension TimescaleDB manque, et un
-  # écart d'image entre la CI et le poste rendrait ce job vert sur une base qui n'est pas la nôtre.
-  integration:
-    name: Tests exigeant une base
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: apps/backend
-
-    services:
-      db:
-        image: timescale/timescaledb-ha:pg17
-        env:
-          POSTGRES_USER: enervision
-          POSTGRES_PASSWORD: change_me
-          POSTGRES_DB: enervision_test
-        ports:
-          - "5433:5432"
-        options: >-
-          --health-cmd "pg_isready -U enervision -d enervision_test"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 12
-          --health-start-period 40s
-
-    env:
-      DATABASE_URL: postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_test
-      APP_SECRET_KEY: secret-de-test-assez-long-pour-le-validateur
-      PGPASSWORD: change_me
-
-    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: apps/backend/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
-
-      # Sur le poste, c'est db/init/110-test-database.sql qui pose l'extension. Ce fichier n'est
-      # pas monté ici, et sans lui `alembic upgrade head` s'arrête sur la garde de la révision 1.
-      - name: Active TimescaleDB sur la base de test
-        run: psql -h localhost -p 5433 -U enervision -d enervision_test -c "CREATE EXTENSION IF NOT EXISTS timescaledb"
-
-      - name: Applique les migrations
-        run: uv run alembic upgrade head
-
-      # `-m` en ligne de commande écrase celui d'`addopts`. La couverture est désactivée : ce job
-      # ne joue qu'une partie de la suite, son taux n'aurait aucun sens face au seuil de 85 %.
-      - name: Tests d'intégration
-        run: uv run pytest -m integration --no-cov
-
-  security-audit:
-    name: Audit des dépendances
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: apps/backend
-
-    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: apps/backend/uv.lock
-
-      # L'audit porte sur le verrou, pas sur l'environnement : sinon pip-audit auditerait
-      # aussi les paquets que son propre `--with` injecte, hors dépendances du projet.
-      - name: Audite les dépendances livrées
-        # Piège : sans `shell: bash`, un échec de `uv export` serait masqué par le pipe.
-        shell: bash
-        run: uv export --frozen --no-dev --no-emit-project --no-hashes | uvx pip-audit --requirement /dev/stdin --no-deps

.github/workflows/frontend.yml

@@ -1,4 +1,5 @@
 name: Frontend
+# Pipeline à choix multiple
 
 on:
   push:
@@ -9,9 +10,9 @@ on:
     paths:
       - "apps/frontend/**"
       - ".github/workflows/frontend.yml"
-
+      
-permissions:
+# Ordre de lancement des jobs
-  contents: read
+# build -> test -> sonarqube -> deploy
 
 jobs:
   build:
@@ -23,25 +24,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
 
-  security-audit:
+  test:  
-    name: Audit des dépendances
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-      # Seuil high : une vulnérabilité moderate de devDependency ne doit pas bloquer une livraison.
-      - run: npm audit --audit-level=high --package-lock-only
-        working-directory: apps/frontend
-
-  test:
     needs: build
     runs-on: ubuntu-latest
     steps:
@@ -51,14 +40,30 @@ jobs:
           node-version: 24
           cache: npm
           cache-dependency-path: apps/frontend/package-lock.json
-      - name : Installation des dépendances (Front)
+      - run: npm ci 
-        run: npm ci 
         working-directory: apps/frontend
-      - name : Lancement des tests et génénration du rapport de couverture (Front)
+      - run: npm test --watch=false --code-coverage --coverageReporters=lcov
-        run: npm test --watch=false --code-coverage --coverageReporters=lcov
         working-directory: apps/frontend
       - name: Upload coverage
         uses: actions/upload-artifact@v4
         with:
           name: frontend-coverage
           path: apps/frontend/coverage/frontend/lcov.info
+        
+  sonarqube:
+    needs: [build, test]
+    name: SonarQube
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Download coverage
+        uses: actions/download-artifact@v4
+        with:
+          name: frontend-coverage
+          path: apps/frontend/coverage/frontend
+      - name: SonarQube Scan
+        uses: SonarSource/sonarqube-scan-action@v8
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.github/workflows/sonarqube.yml

@@ -1,132 +0,0 @@
-name: SonarQube
-
-on:
-  push:
-    paths:
-      - "apps/frontend/**"
-      - "apps/backend/**"
-      - ".github/workflows/sonarqube.yml"
-  pull_request:
-    paths:
-      - "apps/frontend/**"
-      - "apps/backend/**"
-      - ".github/workflows/sonarqube.yml"
-
-
-# Build l'ensemble du projet, puis lance les tests
-# Génère les rapports de couverture, puis lance l'analyse SonarQube
-
-jobs:
-  build-front:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: npm
-          cache-dependency-path: apps/frontend/package-lock.json
-      
-      - run: npm ci 
-        working-directory: apps/frontend
-      - run: npm run build
-        working-directory: apps/frontend
-
-  test-front:  
-    needs: build-front
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: npm
-          cache-dependency-path: apps/frontend/package-lock.json
-
-      - name : Installation des dépendances (Front)
-        run: npm ci 
-        working-directory: apps/frontend
-
-      - name : Lancement des tests et génénration du rapport de couverture (Front)
-        run: npm test --watch=false --code-coverage --coverageReporters=lcov
-        working-directory: apps/frontend
-
-      - name: Upload coverage
-        uses: actions/upload-artifact@v4
-        with:
-          name: frontend-coverage
-          path: apps/frontend/coverage/frontend/lcov.info
-
-  build-back:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: apps/backend/uv.lock
-      - name: Installe l'interpréteur déclaré par .python-version
-        run: uv python install
-        working-directory: apps/backend
-
-      - name: Synchronise les dépendances sans dévier du verrou
-        run: uv sync --all-groups --frozen
-        working-directory: apps/backend
-
-      - name: Vérifie le formatage
-        run: uv run ruff format --check .
-        working-directory: apps/backend
-
-      - name: Analyse statique
-        run: uv run ruff check --output-format=github .
-        working-directory: apps/backend
-
-      - name: Typage
-        run: uv run mypy app
-        working-directory: apps/backend
-
-
-  test-back:
-    needs: build-back
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: apps/backend/uv.lock
-
-      - name : Lancement des tests et génénration du rapport de couverture (Back)
-        run: uv run pytest --cov-fail-under=85 --cov-report=xml
-        working-directory: apps/backend
-
-      - name: Upload coverage
-        uses: actions/upload-artifact@v4
-        with:
-          name: backend-coverage
-          path: apps/backend/coverage.xml
-
-  sonarqube:
-    needs: [build-front, build-back, test-front, test-back]
-    name: SonarQube
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-      - name: Téléchargement du rapport de couverture (Front)
-        uses: actions/download-artifact@v4
-        with:
-          name: frontend-coverage
-          path: apps/frontend/coverage/frontend
-      - name: Téléchargement du rapport de couverture (Back)
-        uses: actions/download-artifact@v4
-        with:
-          name: backend-coverage
-          path: apps/backend
-      - name: SonarQube Scan
-        uses: SonarSource/sonarqube-scan-action@v8
-        env:
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

Makefile

@@ -6,7 +6,7 @@ ML := ml
 .PHONY: help install install-backend install-frontend install-ml 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 ml-score
+        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}'
@@ -74,9 +74,6 @@ ml-check: ml-lint ml-typecheck ml-test ## Chaîne de vérification complète du
 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),)
 
-ml-score: ## Score le prochain pas horaire et l'ecrit dans `prediction`. CSV=chemin optionnel
-	cd $(ML) && uv run python -m enervision_ml.score $(if $(CSV),--csv $(CSV),)
-
 docker-build: ## Construit l'image du backend
 	docker build -t enervision-backend:local $(BACKEND)
 

apps/backend/TESTING.md

@@ -123,11 +123,6 @@ async def test_repository_reads_back_what_it_wrote(session: AsyncSession) -> Non
 defaut, ce qui garde `make check` jouable sans Docker. Tout autre marqueur doit etre
 declare dans `pyproject.toml` : `--strict-markers` refuse les marqueurs inconnus.
 
-Ces tests ne sont pas pour autant facultatifs : le job `integration` de
-`.github/workflows/backend.yml` monte un service TimescaleDB, applique les migrations et
-les joue a chaque poussee. Un test `integration` casse donc la CI comme un autre. En local,
-`make db-up` puis `make test-integration`.
-
 ## Couverture
 
 Les branches sont mesurees, pas seulement les lignes. Le seuil de 85 % ne s'applique
@@ -147,27 +142,14 @@ uv run pytest tests/api/test_health.py           # un seul fichier
 uv run pytest -k readiness                       # par motif de nom
 ```
 
-## Quatre fichiers à connaître avant de toucher à l'authentification
+## Trois fichiers à connaître avant de toucher à l'authentification
-
-`tests/api/acces.py` porte la classification des routes du contrat, en quatre ensembles :
-`ROUTES_PUBLIQUES`, `ROUTE_COOKIE`, `ROUTES_SANS_ROLE` et la table `ROLE_MINIMUM`. Ce n'est pas
-un fichier de test, c'est la référence que les trois autres confrontent au comportement observé.
-**Toute route ajoutée doit y être classée** : `test_every_declared_route_is_classified` échoue
-sinon, et échoue aussi sur une entrée qui ne correspond plus à aucune route.
 
 `tests/api/test_route_protection.py` interroge réellement chaque route sans identifiant et
 échoue si l'une d'elles répond autre chose qu'un 401 ou un 403. Il n'inspecte pas l'arbre de
 dépendances : celui-ci n'est accessible que par l'API privée de FastAPI, et surtout une route
 peut porter la bonne dépendance tout en répondant quand même. **Rendre une route publique impose
-donc de modifier `ROUTES_PUBLIQUES` dans `acces.py`**, ce qui apparaît en clair dans la diff
+donc de modifier la liste `ROUTES_PUBLIQUES` de ce fichier**, ce qui apparaît en clair dans la
-d'une pull request.
+diff d'une pull request.
-
-`tests/api/test_matrice_acces.py` croise chaque route gardée avec chacun des trois rôles, dans
-les deux sens : un rôle insuffisant reçoit un 403 `Droits insuffisants`, un rôle suffisant ne le
-reçoit jamais. Le second sens est ce qui rend visible une garde posée trop haut, par exemple
-`AdminDep` sur une route de lecture. La même matrice est rejouée sous `integration` avec de vrais
-jetons, donc en traversant le décodage du JWT et la relecture du compte en base, que
-`dependency_overrides` court-circuite.
 
 `tests/services/test_auth.py` donne au faux hacheur un **compteur d'appels**. C'est ce qui rend
 possibles les deux assertions qui prouvent la conception, et qu'aucune autre forme de test

apps/backend/app/api/deps.py

@@ -27,7 +27,6 @@ from app.repositories.audit_log import AuditLogRepository
 from app.repositories.login_attempt import LoginAttemptRepository
 from app.repositories.password_reset_attempt import PasswordResetAttemptRepository
 from app.repositories.password_reset_token import PasswordResetTokenRepository
-from app.repositories.prediction import PredictionRepository
 from app.repositories.reading import ReadingRepository
 from app.repositories.recommendation import RecommendationRepository
 from app.repositories.refresh_token import RefreshTokenRepository
@@ -35,7 +34,6 @@ from app.repositories.site import SiteRepository
 from app.repositories.user import UserRepository
 from app.services.alert import AlertService
 from app.services.auth import AuthService, LoginPolicy, PasswordResetPolicy
-from app.services.prediction import PredictionService
 from app.services.reading import ReadingService
 from app.services.recommendation import RecommendationService
 from app.services.sensor import SensorService
@@ -180,12 +178,7 @@ SiteServiceDep = Annotated[SiteService, Depends(get_site_service)]
 
 
 def get_alert_service(session: SessionDep) -> AlertService:
-    return AlertService(
+    return AlertService(alerts=AlertRepository(session))
-        alerts=AlertRepository(session),
-        readings=ReadingRepository(session),
-        predictions=PredictionRepository(session),
-        sites=SiteRepository(session),
-    )
 
 
 AlertServiceDep = Annotated[AlertService, Depends(get_alert_service)]
@@ -219,15 +212,6 @@ def get_sensor_service(session: SessionDep) -> SensorService:
 SensorServiceDep = Annotated[SensorService, Depends(get_sensor_service)]
 
 
-def get_prediction_service(session: SessionDep) -> PredictionService:
-    return PredictionService(
-        sites=SiteRepository(session), predictions=PredictionRepository(session)
-    )
-
-
-PredictionServiceDep = Annotated[PredictionService, Depends(get_prediction_service)]
-
-
 async def get_current_principal(
     credentials: CredentialsDep,
     session: SessionDep,

apps/backend/app/api/openapi.py

@@ -83,13 +83,6 @@ TAGS: Final[list[dict[str, Any]]] = [
         "name": "sensors",
         "description": "État de santé des capteurs par site. Réservé au rôle `admin`.",
     },
-    {
-        "name": "predictions",
-        "description": (
-            "Dernière prévision de consommation par site, calculée hors ligne par le pipeline "
-            "de scoring (`ml/`) et simplement lue ici. Accessible à partir du rôle `lecteur`."
-        ),
-    },
 ]
 
 cookie_de_rafraichissement = APIKeyCookie(

apps/backend/app/api/v1/endpoints/predictions.py

@@ -1,18 +0,0 @@
-from fastapi import APIRouter
-
-from app.api.deps import LecteurDep, PredictionServiceDep
-from app.schemas.prediction import PredictionSummaryResponse
-
-router = APIRouter()
-
-
-@router.get(
-    "",
-    response_model=PredictionSummaryResponse,
-    summary="Dernière prédiction de consommation par site",
-)
-async def get_predictions(
-    _: LecteurDep, service: PredictionServiceDep
-) -> PredictionSummaryResponse:
-    resume = await service.summary()
-    return PredictionSummaryResponse.model_validate(resume)

apps/backend/app/api/v1/router.py

@@ -5,7 +5,6 @@ from app.api.v1.endpoints import (
     alerts,
     auth,
     health,
-    predictions,
     readings,
     recommendations,
     sensors,
@@ -35,6 +34,3 @@ api_router.include_router(
 api_router.include_router(
     sensors.router, prefix="/sensors", tags=["sensors"], responses=REPONSES_ADMIN
 )
-api_router.include_router(
-    predictions.router, prefix="/predictions", tags=["predictions"], responses=REPONSES_LECTEUR
-)

apps/backend/app/detection/internal_alerts.py

@@ -1,68 +0,0 @@
-# Détection d'alertes internes EnerVision (issue #104) : script lancé à la main pour l'instant,
-# comme `enervision_ml.score` côté ML, sans automatisation Airflow pour l'ordonnancer.
-
-from __future__ import annotations
-
-import argparse
-import asyncio
-import sys
-from datetime import UTC, datetime
-
-from app.core.config import get_settings
-from app.db.session import get_session_factory
-from app.repositories.alert import AlertRepository
-from app.repositories.prediction import PredictionRepository
-from app.repositories.reading import ReadingRepository
-from app.repositories.site import SiteRepository
-from app.services.alert import AlertService
-
-
-async def run_detection(*, now: datetime | None = None, site_id: str | None = None) -> int:
-    """Exécute les cinq règles de détection et enregistre les nouvelles alertes. Rend le nombre de
-    lignes effectivement insérées (les doublons de `source_alert_id` sont silencieusement
-    ignorés)."""
-    async with get_session_factory()() as session:
-        service = AlertService(
-            alerts=AlertRepository(session),
-            readings=ReadingRepository(session),
-            predictions=PredictionRepository(session),
-            sites=SiteRepository(session),
-        )
-        nouvelles = await service.detect(now=now, site_id=site_id)
-        await session.commit()
-    return len(nouvelles)
-
-
-def _parse_instant(valeur: str) -> datetime:
-    instant = datetime.fromisoformat(valeur)
-    return instant if instant.tzinfo is not None else instant.replace(tzinfo=UTC)
-
-
-def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        prog="python -m app.detection.internal_alerts",
-        description="Détection d'alertes internes EnerVision",
-    )
-    parser.add_argument("--site-id", default=None, help="Limite la détection à un seul site.")
-    parser.add_argument(
-        "--now",
-        type=_parse_instant,
-        default=None,
-        help=(
-            "Instant de référence (ISO 8601, UTC si le fuseau est omis). Défaut : l'heure courante."
-        ),
-    )
-    return parser.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv)
-    # Échoue tôt si `APP_SECRET_KEY`/`DATABASE_URL` manquent, avant toute requête à la base.
-    get_settings()
-    nombre = asyncio.run(run_detection(now=args.now, site_id=args.site_id))
-    print(f"{nombre} nouvelle(s) alerte(s) enregistrée(s).")
-    return 0
-
-
-if __name__ == "__main__":  # pragma: no cover
-    sys.exit(main())

apps/backend/app/repositories/alert.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 
 from sqlalchemy import select
-from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.energy import Alert
@@ -20,36 +19,3 @@ class AlertRepository:
         if severity is not None:
             requete = requete.where(Alert.severity == severity)
         return (await self._session.scalars(requete)).all()
-
-    async def create_many(self, alerts: Sequence[Alert]) -> Sequence[Alert]:
-        # `ON CONFLICT DO NOTHING` sur `uq_alert_source_reference` : rejouer la détection sur une
-        # fenêtre qui recouvre une exécution précédente ne doit pas dupliquer une alerte déjà
-        # enregistrée. `RETURNING` ne renvoie donc que les lignes effectivement insérées.
-        if not alerts:
-            return []
-        valeurs = [
-            {
-                "source_alert_id": alerte.source_alert_id,
-                "site_id": alerte.site_id,
-                "source": alerte.source,
-                "timestamp": alerte.timestamp,
-                "type": alerte.type,
-                "severity": alerte.severity,
-                "message": alerte.message,
-                "value": alerte.value,
-                "threshold": alerte.threshold,
-                "metric": alerte.metric,
-                "prediction_id": alerte.prediction_id,
-                "raw_data": alerte.raw_data,
-            }
-            for alerte in alerts
-        ]
-        requete = (
-            insert(Alert)
-            .values(valeurs)
-            .on_conflict_do_nothing(constraint="uq_alert_source_reference")
-            .returning(Alert)
-        )
-        resultat = await self._session.execute(requete)
-        await self._session.flush()
-        return resultat.scalars().all()

apps/backend/app/repositories/prediction.py

@@ -1,49 +0,0 @@
-from collections.abc import Sequence
-from datetime import datetime
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.models.energy import Prediction
-
-
-class PredictionRepository:
-    def __init__(self, session: AsyncSession) -> None:
-        self._session = session
-
-    async def list_since(
-        self, *, since: datetime, site_id: str | None = None
-    ) -> Sequence[Prediction]:
-        # Restreint à `available` : une prévision `insufficient_data`/`error` n'a pas de
-        # `predicted_value` à comparer à une lecture réelle (détection d'anomalie).
-        # Piège : `prediction` n'a pas d'unicité sur `(site_id, target_at)` (cf.
-        # `enervision_ml.score`, qui insère toujours une nouvelle ligne plutôt que d'écraser la
-        # précédente). `prediction_id` en dernier départage donc les égalités de `target_at` par
-        # ordre croissant : `_detect_anomaly` construit un dict qui garde le dernier rencontré,
-        # c'est-à-dire le run le plus récent plutôt qu'une ligne choisie au hasard par le plan
-        # d'exécution.
-        requete = (
-            select(Prediction)
-            .where(Prediction.target_at >= since, Prediction.status == "available")
-            .order_by(Prediction.site_id, Prediction.target_at, Prediction.prediction_id)
-        )
-        if site_id is not None:
-            requete = requete.where(Prediction.site_id == site_id)
-        return (await self._session.scalars(requete)).all()
-
-    async def latest_by_site(self) -> Sequence[Prediction]:
-        # `.distinct(site_id)` compile en `DISTINCT ON (site_id)` sous PostgreSQL : une seule
-        # ligne par site, la plus récente grâce à l'ordre composite qui suit. Même mécanisme que
-        # `ReadingRepository.latest_by_site`. Trié sur `target_at` (couvert par
-        # `ix_prediction_site_target`) plutôt que `created_at` : c'est la prévision la plus
-        # récente qui compte pour un tableau de bord, pas forcément le dernier run de scoring.
-        requete = (
-            select(Prediction)
-            .distinct(Prediction.site_id)
-            .order_by(
-                Prediction.site_id,
-                Prediction.target_at.desc(),
-                Prediction.prediction_id.desc(),
-            )
-        )
-        return (await self._session.scalars(requete)).all()

apps/backend/app/repositories/reading.py

@@ -34,21 +34,6 @@ class ReadingRepository:
         lecture: Reading | None = await self._session.scalar(requete)
         return lecture
 
-    async def list_since(self, *, since: datetime, site_id: str | None = None) -> Sequence[Reading]:
-        # Trié par site puis par heure croissante : la détection d'alertes (spike) a besoin de
-        # comparer chaque lecture à celle qui la précède immédiatement pour le même site.
-        # `reading_id` en dernier départage : `uq_reading_source` autorise deux lignes au même
-        # `site_id`+`timestamp` quand la `source` diffère (même piège que `latest_for_site`), sans
-        # quoi l'ordre entre elles ne serait pas garanti d'un appel à l'autre.
-        requete = (
-            select(Reading)
-            .where(Reading.timestamp >= since)
-            .order_by(Reading.site_id, Reading.timestamp, Reading.reading_id)
-        )
-        if site_id is not None:
-            requete = requete.where(Reading.site_id == site_id)
-        return (await self._session.scalars(requete)).all()
-
     async def list_history(
         self,
         *,

apps/backend/app/schemas/prediction.py

@@ -1,43 +0,0 @@
-from datetime import datetime
-from enum import StrEnum
-
-from pydantic import BaseModel, ConfigDict
-
-
-class PredictionTargetMetric(StrEnum):
-    CONSUMPTION_KWH = "consumption_kwh"
-    CONSUMPTION_KW = "consumption_kw"
-
-
-class PredictionStatus(StrEnum):
-    AVAILABLE = "available"
-    INSUFFICIENT_DATA = "insufficient_data"
-    ERROR = "error"
-
-
-class SitePredictionResponse(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    target_at: datetime
-    target_metric: PredictionTargetMetric
-    period_minutes: int | None
-    predicted_value: float | None
-    status: PredictionStatus
-    failure_reason: str | None
-    model_reference: str
-    created_at: datetime
-
-
-class SitePredictionSummaryResponse(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    site_id: str
-    site_name: str
-    prediction: SitePredictionResponse | None
-
-
-class PredictionSummaryResponse(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    timestamp: datetime
-    sites: list[SitePredictionSummaryResponse]

apps/backend/app/services/alert.py

@@ -1,323 +1,14 @@
 from collections.abc import Sequence
-from datetime import UTC, datetime, timedelta
 
-from app.models.energy import Alert, Prediction, Reading, Site
+from app.models.energy import Alert
 from app.repositories.alert import AlertRepository
-from app.repositories.prediction import PredictionRepository
-from app.repositories.reading import ReadingRepository
-from app.repositories.site import SiteRepository
-
-# Fenêtre de lectures/prédictions analysée à chaque exécution : assez large pour couvrir une paire
-# de lectures consécutives (spike) et une coupure prolongée (outage), sans réanalyser tout
-# l'historique à chaque lancement manuel du script de détection.
-LOOKBACK = timedelta(hours=48)
-
-# Cadence nominale d'une lecture : le CSV historique comme l'API Mock livrent un pas horaire.
-EXPECTED_INTERVAL = timedelta(hours=1)
-# Au-delà de trois pas manqués, on parle de coupure plutôt que d'un simple retard d'ingestion.
-OUTAGE_THRESHOLD = EXPECTED_INTERVAL * 3
-
-# +/-50% entre deux lectures consécutives du même site.
-SPIKE_RELATIVE_THRESHOLD = 0.5
-# 30% d'écart entre la consommation réelle et la prévision du même site/instant.
-ANOMALY_RELATIVE_THRESHOLD = 0.3
-# Une prévision quasi nulle rend l'écart relatif ininterprétable ; on l'ignore plutôt.
-ANOMALY_MINIMUM_PREDICTED_VALUE = 1e-6
-
-THRESHOLD_METRIC = "consumption_kw"
-ANOMALY_METRIC = "consumption_kwh"
-# `data_quality` -> sévérité du capteur défaillant. `good` est volontairement absent : il ne
-# déclenche jamais d'alerte.
-QUALITE_VERS_SEVERITE: dict[str, str] = {
-    "partial": "low",
-    "degraded": "medium",
-    "critical": "critical",
-}
 
 
 class AlertService:
-    def __init__(
+    def __init__(self, *, alerts: AlertRepository) -> None:
-        self,
-        *,
-        alerts: AlertRepository,
-        readings: ReadingRepository,
-        predictions: PredictionRepository,
-        sites: SiteRepository,
-    ) -> None:
         self._alerts = alerts
-        self._readings = readings
-        self._predictions = predictions
-        self._sites = sites
 
     async def list_all(
         self, *, site_id: str | None = None, severity: str | None = None
     ) -> Sequence[Alert]:
         return await self._alerts.list_all(site_id=site_id, severity=severity)
-
-    async def detect(
-        self, *, now: datetime | None = None, site_id: str | None = None
-    ) -> Sequence[Alert]:
-        """Compare les lectures/prévisions récentes aux cinq règles internes et enregistre les
-        alertes déclenchées (`source='enervision'`). Idempotent grâce à `source_alert_id` :
-        rejouer sur une fenêtre déjà analysée ne recrée pas les mêmes lignes."""
-        instant = now or datetime.now(UTC)
-        depuis = instant - LOOKBACK
-
-        sites = await self._sites.list_all()
-        if site_id is not None:
-            sites = [site for site in sites if site.site_id == site_id]
-        sites_par_id = {site.site_id: site for site in sites}
-        if not sites_par_id:
-            return []
-
-        lectures = [
-            lecture
-            for lecture in await self._readings.list_since(since=depuis, site_id=site_id)
-            if lecture.site_id in sites_par_id
-        ]
-        predictions = [
-            prediction
-            for prediction in await self._predictions.list_since(since=depuis, site_id=site_id)
-            if prediction.site_id in sites_par_id
-        ]
-        dernieres_lectures = {
-            lecture.site_id: lecture
-            for lecture in await self._readings.latest_by_site()
-            if lecture.site_id in sites_par_id
-        }
-
-        candidates = [
-            *_detect_threshold(lectures, sites_par_id),
-            *_detect_spike(lectures),
-            *_detect_anomaly(lectures, predictions),
-            *_detect_outage(sites, dernieres_lectures, instant),
-            *_detect_sensor(lectures),
-        ]
-        if not candidates:
-            return []
-        return await self._alerts.create_many(candidates)
-
-
-def _severity_from_ratio(ratio: float) -> str:
-    if ratio >= 2.0:
-        return "critical"
-    if ratio >= 1.5:
-        return "high"
-    if ratio >= 1.2:
-        return "medium"
-    return "low"
-
-
-def _detect_threshold(lectures: Sequence[Reading], sites_par_id: dict[str, Site]) -> list[Alert]:
-    # Seuil fixe = la capacité déclarée du site : dépasser `capacity_kw` est un dépassement
-    # matériel, pas une simple variation, et évite un seuil arbitraire non fourni par le domaine.
-    alertes = []
-    for lecture in lectures:
-        site = sites_par_id[lecture.site_id]
-        valeur = lecture.consumption_kw
-        if site.capacity_kw is None or site.capacity_kw <= 0 or valeur is None:
-            continue
-        if valeur <= site.capacity_kw:
-            continue
-        alertes.append(
-            Alert(
-                source_alert_id=f"threshold:{THRESHOLD_METRIC}:{lecture.timestamp.isoformat()}",
-                site_id=lecture.site_id,
-                source="enervision",
-                timestamp=lecture.timestamp,
-                type="threshold",
-                severity=_severity_from_ratio(valeur / site.capacity_kw),
-                message=(
-                    f"Puissance appelée {valeur:.1f} kW au-dessus de la capacité du site "
-                    f"({site.capacity_kw:.1f} kW)"
-                ),
-                value=valeur,
-                threshold=site.capacity_kw,
-                metric=THRESHOLD_METRIC,
-                prediction_id=None,
-                raw_data={},
-            )
-        )
-    return alertes
-
-
-def _detect_spike(lectures: Sequence[Reading]) -> list[Alert]:
-    # `lectures` est triée par site, heure puis `reading_id` (cf. `ReadingRepository.list_since`) :
-    # deux lignes consécutives du même site sont donc deux mesures consécutives dans le temps,
-    # sauf lorsqu'elles partagent le même horodatage (deux `source` différentes pour le même
-    # instant, permises par `uq_reading_source`) : ce n'est alors pas une variation réelle, on
-    # l'ignore plutôt que de générer une fausse alerte figée par son `source_alert_id`.
-    alertes = []
-    precedente: Reading | None = None
-    for lecture in lectures:
-        if (
-            precedente is None
-            or precedente.site_id != lecture.site_id
-            or precedente.timestamp == lecture.timestamp
-        ):
-            precedente = lecture
-            continue
-        avant, apres = precedente.consumption_kw, lecture.consumption_kw
-        precedente = lecture
-        if avant is None or apres is None:
-            continue
-        if avant == 0:
-            # Une variation relative n'a pas de sens depuis zéro, mais un redémarrage direct à
-            # une consommation positive reste le signal le plus alarmant du lot : `critical`
-            # plutôt qu'un ratio indéfini.
-            if apres > 0:
-                alertes.append(_spike_alert(lecture, avant, apres, severity="critical"))
-            continue
-        variation = abs(apres - avant) / abs(avant)
-        if variation < SPIKE_RELATIVE_THRESHOLD:
-            continue
-        alertes.append(
-            _spike_alert(
-                lecture,
-                avant,
-                apres,
-                severity=_severity_from_ratio(variation / SPIKE_RELATIVE_THRESHOLD),
-            )
-        )
-    return alertes
-
-
-def _spike_alert(lecture: Reading, avant: float, apres: float, *, severity: str) -> Alert:
-    return Alert(
-        source_alert_id=f"spike:{THRESHOLD_METRIC}:{lecture.timestamp.isoformat()}",
-        site_id=lecture.site_id,
-        source="enervision",
-        timestamp=lecture.timestamp,
-        type="spike",
-        severity=severity,
-        message=(
-            f"Variation brutale entre deux lectures consécutives ({avant:.1f} kW -> {apres:.1f} kW)"
-        ),
-        value=apres,
-        threshold=avant,
-        metric=THRESHOLD_METRIC,
-        prediction_id=None,
-        raw_data={},
-    )
-
-
-def _detect_anomaly(lectures: Sequence[Reading], predictions: Sequence[Prediction]) -> list[Alert]:
-    # Alignement strict (site_id, target_at == timestamp) : `enervision_ml.score` produit une
-    # cible à l'heure pile suivant la dernière lecture, sur la même grille horaire que `reading`.
-    predictions_par_cle = {
-        (prediction.site_id, prediction.target_at): prediction
-        for prediction in predictions
-        if prediction.target_metric == ANOMALY_METRIC
-    }
-    alertes = []
-    for lecture in lectures:
-        prediction = predictions_par_cle.get((lecture.site_id, lecture.timestamp))
-        reel = lecture.consumption_kwh
-        if prediction is None or reel is None or prediction.predicted_value is None:
-            continue
-        predite = prediction.predicted_value
-        if abs(predite) < ANOMALY_MINIMUM_PREDICTED_VALUE:
-            continue
-        ecart = abs(reel - predite) / abs(predite)
-        if ecart < ANOMALY_RELATIVE_THRESHOLD:
-            continue
-        alertes.append(
-            Alert(
-                source_alert_id=f"anomaly:{ANOMALY_METRIC}:{lecture.timestamp.isoformat()}",
-                site_id=lecture.site_id,
-                source="enervision",
-                timestamp=lecture.timestamp,
-                type="anomaly",
-                severity=_severity_from_ratio(ecart / ANOMALY_RELATIVE_THRESHOLD),
-                message=(
-                    f"Écart de {ecart * 100:.0f}% entre la consommation mesurée ({reel:.1f} kWh) "
-                    f"et la prévision ({predite:.1f} kWh)"
-                ),
-                value=reel,
-                threshold=predite,
-                metric=ANOMALY_METRIC,
-                prediction_id=prediction.prediction_id,
-                raw_data={},
-            )
-        )
-    return alertes
-
-
-def _detect_outage(
-    sites: Sequence[Site], dernieres_lectures: dict[str, Reading], now: datetime
-) -> list[Alert]:
-    alertes = []
-    for site in sites:
-        derniere = dernieres_lectures.get(site.site_id)
-        if derniere is None:
-            alertes.append(
-                _outage_alert(
-                    site.site_id,
-                    now,
-                    reference=None,
-                    message="Aucune lecture n'a jamais été reçue pour ce site",
-                    severity="critical",
-                )
-            )
-            continue
-        absence = now - derniere.timestamp
-        if absence < OUTAGE_THRESHOLD:
-            continue
-        alertes.append(
-            _outage_alert(
-                site.site_id,
-                now,
-                reference=derniere.timestamp,
-                message=(
-                    f"Aucune lecture depuis {absence} (dernière lecture : "
-                    f"{derniere.timestamp.isoformat()})"
-                ),
-                severity=_severity_from_ratio(absence / OUTAGE_THRESHOLD),
-            )
-        )
-    return alertes
-
-
-def _outage_alert(
-    site_id: str, now: datetime, *, reference: datetime | None, message: str, severity: str
-) -> Alert:
-    return Alert(
-        source_alert_id=f"outage:{reference.isoformat() if reference is not None else 'jamais'}",
-        site_id=site_id,
-        source="enervision",
-        timestamp=now,
-        type="outage",
-        severity=severity,
-        message=message,
-        value=None,
-        threshold=None,
-        metric=None,
-        prediction_id=None,
-        raw_data={},
-    )
-
-
-def _detect_sensor(lectures: Sequence[Reading]) -> list[Alert]:
-    alertes = []
-    for lecture in lectures:
-        severite = QUALITE_VERS_SEVERITE.get(lecture.data_quality or "")
-        if severite is None:
-            continue
-        raisons = ", ".join(lecture.null_reasons or []) or "raison non précisée"
-        alertes.append(
-            Alert(
-                source_alert_id=f"sensor:{lecture.timestamp.isoformat()}",
-                site_id=lecture.site_id,
-                source="enervision",
-                timestamp=lecture.timestamp,
-                type="sensor",
-                severity=severite,
-                message=f"Qualité de mesure {lecture.data_quality} ({raisons})",
-                value=None,
-                threshold=None,
-                metric=None,
-                prediction_id=None,
-                raw_data={},
-            )
-        )
-    return alertes

apps/backend/app/services/prediction.py

@@ -1,68 +0,0 @@
-from dataclasses import dataclass
-from datetime import UTC, datetime
-
-from app.models.energy import Prediction, Site
-from app.repositories.prediction import PredictionRepository
-from app.repositories.site import SiteRepository
-
-
-@dataclass(frozen=True, slots=True)
-class SitePrediction:
-    target_at: datetime
-    target_metric: str
-    period_minutes: int | None
-    predicted_value: float | None
-    status: str
-    failure_reason: str | None
-    model_reference: str
-    created_at: datetime
-
-
-@dataclass(frozen=True, slots=True)
-class SitePredictionSummary:
-    site_id: str
-    site_name: str
-    prediction: SitePrediction | None
-
-
-@dataclass(frozen=True, slots=True)
-class PredictionSummary:
-    timestamp: datetime
-    sites: list[SitePredictionSummary]
-
-
-class PredictionService:
-    def __init__(self, sites: SiteRepository, predictions: PredictionRepository) -> None:
-        self._sites = sites
-        self._predictions = predictions
-
-    async def summary(self) -> PredictionSummary:
-        sites = await self._sites.list_all()
-        dernieres = {p.site_id: p for p in await self._predictions.latest_by_site()}
-
-        return PredictionSummary(
-            timestamp=datetime.now(UTC),
-            sites=[_resume_site(site, dernieres.get(site.site_id)) for site in sites],
-        )
-
-
-def _resume_site(site: Site, derniere: Prediction | None) -> SitePredictionSummary:
-    # Piège : l'absence de ligne signifie « jamais scoré », pas une valeur pseudo-statut, qui
-    # n'existe pas dans la contrainte de la table. `prediction` reste `None` plutôt que de
-    # fabriquer un statut absent du domaine `available`/`insufficient_data`/`error`.
-    prediction = None
-    if derniere is not None:
-        prediction = SitePrediction(
-            target_at=derniere.target_at,
-            target_metric=derniere.target_metric,
-            period_minutes=derniere.period_minutes,
-            predicted_value=derniere.predicted_value,
-            status=derniere.status,
-            failure_reason=derniere.failure_reason,
-            model_reference=derniere.model_reference,
-            created_at=derniere.created_at,
-        )
-
-    return SitePredictionSummary(
-        site_id=site.site_id, site_name=site.site_name, prediction=prediction
-    )

apps/backend/openapi.json

@@ -1719,62 +1719,6 @@
           }
         ]
       }
-    },
-    "/api/v1/predictions": {
-      "get": {
-        "tags": [
-          "predictions"
-        ],
-        "summary": "Dernière prédiction de consommation par site",
-        "operationId": "get_predictions_api_v1_predictions_get",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/PredictionSummaryResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Erreur interne. `correlation` identifie la trace côté serveur, qui n'est pas renvoyée au client.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InternalErrorResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "Jeton absent, illisible, périmé, ou rendu caduc par un changement de rôle ou une désactivation. L'en-tête `WWW-Authenticate` porte la cause dans `error=`.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          },
-          "403": {
-            "description": "Mot de passe provisoire à changer (`detail` vaut `password_change_required`).",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          }
-        },
-        "security": [
-          {
-            "Jeton d'accès": []
-          }
-        ]
-      }
     }
   },
   "components": {
@@ -2028,45 +1972,6 @@
         ],
         "title": "PasswordChangeRequest"
       },
-      "PredictionStatus": {
-        "type": "string",
-        "enum": [
-          "available",
-          "insufficient_data",
-          "error"
-        ],
-        "title": "PredictionStatus"
-      },
-      "PredictionSummaryResponse": {
-        "properties": {
-          "timestamp": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Timestamp"
-          },
-          "sites": {
-            "items": {
-              "$ref": "#/components/schemas/SitePredictionSummaryResponse"
-            },
-            "type": "array",
-            "title": "Sites"
-          }
-        },
-        "type": "object",
-        "required": [
-          "timestamp",
-          "sites"
-        ],
-        "title": "PredictionSummaryResponse"
-      },
-      "PredictionTargetMetric": {
-        "type": "string",
-        "enum": [
-          "consumption_kwh",
-          "consumption_kw"
-        ],
-        "title": "PredictionTargetMetric"
-      },
       "PrincipalResponse": {
         "properties": {
           "id": {
@@ -2613,104 +2518,6 @@
         ],
         "title": "SiteCurrentResponse"
       },
-      "SitePredictionResponse": {
-        "properties": {
-          "target_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Target At"
-          },
-          "target_metric": {
-            "$ref": "#/components/schemas/PredictionTargetMetric"
-          },
-          "period_minutes": {
-            "anyOf": [
-              {
-                "type": "integer"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Period Minutes"
-          },
-          "predicted_value": {
-            "anyOf": [
-              {
-                "type": "number"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Predicted Value"
-          },
-          "status": {
-            "$ref": "#/components/schemas/PredictionStatus"
-          },
-          "failure_reason": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Failure Reason"
-          },
-          "model_reference": {
-            "type": "string",
-            "title": "Model Reference"
-          },
-          "created_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Created At"
-          }
-        },
-        "type": "object",
-        "required": [
-          "target_at",
-          "target_metric",
-          "period_minutes",
-          "predicted_value",
-          "status",
-          "failure_reason",
-          "model_reference",
-          "created_at"
-        ],
-        "title": "SitePredictionResponse"
-      },
-      "SitePredictionSummaryResponse": {
-        "properties": {
-          "site_id": {
-            "type": "string",
-            "title": "Site Id"
-          },
-          "site_name": {
-            "type": "string",
-            "title": "Site Name"
-          },
-          "prediction": {
-            "anyOf": [
-              {
-                "$ref": "#/components/schemas/SitePredictionResponse"
-              },
-              {
-                "type": "null"
-              }
-            ]
-          }
-        },
-        "type": "object",
-        "required": [
-          "site_id",
-          "site_name",
-          "prediction"
-        ],
-        "title": "SitePredictionSummaryResponse"
-      },
       "SiteResponse": {
         "properties": {
           "site_id": {
@@ -3166,10 +2973,6 @@
     {
       "name": "sensors",
       "description": "État de santé des capteurs par site. Réservé au rôle `admin`."
-    },
-    {
-      "name": "predictions",
-      "description": "Dernière prévision de consommation par site, calculée hors ligne par le pipeline de scoring (`ml/`) et simplement lue ici. Accessible à partir du rôle `lecteur`."
     }
   ]
 }

apps/backend/tests/api/acces.py

@@ -1,87 +0,0 @@
-# Pourquoi : classification unique des routes du contrat, lue par test_route_protection.py,
-# test_openapi.py et test_matrice_acces.py. Trois listes séparées dérivaient auparavant chacune
-# de leur côté, et deux entrées de ROUTES_A_ROLE ne correspondaient plus à aucune route sans que
-# rien ne le signale.
-# Piège : les trois ensembles doivent rester disjoints et couvrir tout le schéma. C'est
-# `test_every_declared_route_is_classified` qui le vérifie, pas la relecture.
-
-from typing import Final
-
-from app.core.roles import Role
-
-Route = tuple[str, str]
-
-ROUTES_PUBLIQUES: Final[frozenset[Route]] = frozenset(
-    {
-        ("GET", "/api/v1/health/live"),
-        ("GET", "/api/v1/health/ready"),
-        ("POST", "/api/v1/auth/login"),
-        # Sans cookie, la déconnexion ne fait rien et répond 204 : elle est idempotente.
-        ("POST", "/api/v1/auth/logout"),
-        ("POST", "/api/v1/auth/forgot-password"),
-        # Protégée par le jeton dans le corps de la requête, pas par un `Principal` : aucune
-        # authentification préalable ne s'applique, c'est la validité du jeton qui tranche.
-        ("POST", "/api/v1/auth/reset-password"),
-        # Même raison : lecture seule, protégée par le jeton passé en paramètre, pas par un
-        # `Principal`. Le jeton est un secret de 256 bits, non brute-forçable.
-        ("GET", "/api/v1/auth/reset-password/validate"),
-        ("GET", "/metrics"),
-    }
-)
-
-# Le cookie opaque porte seul l'autorisation : sans lui la route rend 401, mais aucun `Principal`
-# n'est construit et `require_role` n'entre jamais en jeu.
-ROUTE_COOKIE: Final[frozenset[Route]] = frozenset({("POST", "/api/v1/auth/refresh")})
-
-# Authentifiées par `CurrentPrincipalDep` nu, donc hors de `require_role` et, avec lui, hors du
-# refus `password_change_required`. Volontaire pour `/auth/password`, qui est la sortie de l'état
-# provisoire ; subi pour `/auth/logout-all`, cf. test_matrice_acces.py.
-ROUTES_SANS_ROLE: Final[frozenset[Route]] = frozenset(
-    {
-        ("GET", "/api/v1/auth/me"),
-        ("POST", "/api/v1/auth/password"),
-        ("POST", "/api/v1/auth/logout-all"),
-    }
-)
-
-ROLE_MINIMUM: Final[dict[Route, Role]] = {
-    ("GET", "/api/v1/sites"): Role.LECTEUR,
-    ("GET", "/api/v1/sites/{site_id}"): Role.LECTEUR,
-    ("GET", "/api/v1/sites/{site_id}/current"): Role.LECTEUR,
-    ("GET", "/api/v1/alerts"): Role.LECTEUR,
-    ("GET", "/api/v1/recommendations"): Role.LECTEUR,
-    ("GET", "/api/v1/recommendations/{recommendation_id}"): Role.LECTEUR,
-    ("GET", "/api/v1/stats/summary"): Role.LECTEUR,
-    ("GET", "/api/v1/readings"): Role.LECTEUR,
-    ("GET", "/api/v1/predictions"): Role.LECTEUR,
-    ("GET", "/api/v1/sensors/status"): Role.ADMIN,
-    ("GET", "/api/v1/users"): Role.ADMIN,
-    ("POST", "/api/v1/users"): Role.ADMIN,
-    ("PATCH", "/api/v1/users/{user_id}"): Role.ADMIN,
-    ("POST", "/api/v1/users/{user_id}/password-reset"): Role.ADMIN,
-}
-
-# Piège : `{recommendation_id}` est typé `int` et `{user_id}` est un UUID. Une substitution
-# uniforme par une chaîne quelconque rendrait 422 avant d'atteindre la garde de rôle, et le test
-# passerait en prouvant autre chose que ce qu'il annonce.
-SUBSTITUTIONS: Final[dict[str, str]] = {
-    "{user_id}": "00000000-0000-0000-0000-000000000000",
-    "{site_id}": "site-absent-du-jeu-de-donnees",
-    "{recommendation_id}": "999999999",
-}
-
-
-def chemin_concret(chemin: str) -> str:
-    for gabarit, valeur in SUBSTITUTIONS.items():
-        chemin = chemin.replace(gabarit, valeur)
-    return chemin
-
-
-def routes_du_schema(schema: dict[str, object]) -> list[Route]:
-    chemins: dict[str, dict[str, object]] = schema["paths"]  # type: ignore[assignment]
-    return [
-        (methode.upper(), chemin)
-        for chemin, operations in chemins.items()
-        for methode in operations
-        if methode.upper() in {"GET", "POST", "PATCH", "PUT", "DELETE"}
-    ]

apps/backend/tests/api/test_matrice_acces.py

@@ -1,279 +0,0 @@
-# Pourquoi : la matrice rôle x route sur les routes réelles. `test_authorization.py` la joue déjà,
-# mais contre une route jetable montée par une fixture, ce qui ne dit rien du niveau effectivement
-# posé sur `/sites` ou `/users`. `ROLE_MINIMUM` (tests/api/acces.py) est la référence, et ce
-# fichier est ce qui la confronte au comportement observé.
-# Piège : l'assertion porte sur le refus de la garde, pas sur un 200. Un rôle suffisant peut
-# légitimement recevoir 404 ou 422 selon les données ; ce qui compte est qu'il ne reçoive pas le
-# 403 `Droits insuffisants`. Sans cette nuance, le test dépendrait du contenu de la base.
-# Les tests `integration` en fin de fichier rejouent la même matrice avec de vrais jetons, donc en
-# traversant le décodage du JWT et la relecture du compte, ce que l'override court-circuite.
-
-import uuid
-from collections.abc import AsyncIterator, Callable, Iterator
-
-import pytest
-from fastapi import FastAPI
-from httpx import AsyncClient, Response
-from sqlalchemy import text
-
-from app.api.deps import get_current_principal
-from app.core.hashing import build_hasher
-from app.core.principal import Principal
-from app.core.roles import AccountKind, Role, has_at_least
-from app.db.session import get_session, get_session_factory
-from app.repositories.user import UserRepository
-from tests.api.acces import ROLE_MINIMUM, chemin_concret
-
-ROLES = [Role.LECTEUR, Role.OPERATEUR, Role.ADMIN]
-IDS_DE_ROLE = ["lecteur", "operateur", "admin"]
-REFUS_DE_DROITS = "Droits insuffisants"
-REFUS_DE_MOT_DE_PASSE = "password_change_required"
-MOT_DE_PASSE = "un-mot-de-passe-de-recette"
-
-
-# `FakeSession` de tests/factories.py rend un unique objet pour les trois formes d'appel, ce qui
-# suffit à un test d'endpoint ciblé mais pas à balayer 13 routes qui interrogent chacune la base
-# à sa façon. Ce double rend un résultat vide quelle que soit la forme demandée, pour que la
-# réponse observée vienne de la garde de rôle et jamais d'un double mal ajusté.
-class ResultatVide:
-    def scalars(self) -> ResultatVide:
-        return self
-
-    def all(self) -> list[object]:
-        return []
-
-    def first(self) -> None:
-        return None
-
-    def one_or_none(self) -> None:
-        return None
-
-    def scalar_one_or_none(self) -> None:
-        return None
-
-    def mappings(self) -> ResultatVide:
-        return self
-
-    def __iter__(self) -> Iterator[object]:
-        return iter(())
-
-
-class SessionMuette:
-    async def scalar(self, *_: object, **__: object) -> None:
-        return None
-
-    async def execute(self, *_: object, **__: object) -> ResultatVide:
-        return ResultatVide()
-
-    async def scalars(self, *_: object, **__: object) -> ResultatVide:
-        return ResultatVide()
-
-    async def get(self, *_: object, **__: object) -> None:
-        return None
-
-    async def flush(self) -> None:
-        return None
-
-    async def commit(self) -> None:
-        return None
-
-    async def rollback(self) -> None:
-        return None
-
-    def add(self, *_: object, **__: object) -> None:
-        return None
-
-
-@pytest.fixture
-def base_muette(app: FastAPI) -> None:
-    async def override() -> AsyncIterator[SessionMuette]:
-        yield SessionMuette()
-
-    app.dependency_overrides[get_session] = override
-
-
-def principal(role: Role, *, must_change_password: bool = False) -> Principal:
-    return Principal(
-        id=uuid.uuid4(),
-        email=f"matrice-{role.value}@enervision.fr",
-        role=role,
-        kind=AccountKind.HUMAIN,
-        must_change_password=must_change_password,
-    )
-
-
-@pytest.fixture
-def connecte(app: FastAPI) -> Iterator[Callable[[Principal], None]]:
-    def installe(acteur: Principal) -> None:
-        app.dependency_overrides[get_current_principal] = lambda: acteur
-
-    yield installe
-    app.dependency_overrides.pop(get_current_principal, None)
-
-
-async def appelle(client: AsyncClient, methode: str, chemin: str, **kwargs: object) -> Response:
-    return await client.request(methode, chemin_concret(chemin), json={}, **kwargs)  # type: ignore[arg-type]
-
-
-def motif_du_refus(response: Response) -> str | None:
-    if response.status_code != 403:
-        return None
-    detail = response.json().get("detail")
-    return detail if isinstance(detail, str) else None
-
-
-@pytest.mark.parametrize("role", ROLES, ids=IDS_DE_ROLE)
-async def test_a_role_below_the_minimum_is_refused_on_every_guarded_route(
-    connecte: Callable[[Principal], None],
-    client: AsyncClient,
-    base_muette: None,
-    role: Role,
-) -> None:
-    connecte(principal(role))
-    laissees_passer: list[tuple[str, str, int]] = []
-
-    for (methode, chemin), minimum in ROLE_MINIMUM.items():
-        if has_at_least(role, minimum):
-            continue
-        response = await appelle(client, methode, chemin)
-        if motif_du_refus(response) != REFUS_DE_DROITS:
-            laissees_passer.append((methode, chemin, response.status_code))
-
-    assert laissees_passer == []
-
-
-# Le pendant du test précédent : sans lui, une garde posée trop haut, par exemple `AdminDep` sur
-# `/sites`, ne ferait échouer aucun test du dépôt.
-@pytest.mark.parametrize("role", ROLES, ids=IDS_DE_ROLE)
-async def test_a_role_at_or_above_the_minimum_is_never_refused_by_the_guard(
-    connecte: Callable[[Principal], None],
-    client: AsyncClient,
-    base_muette: None,
-    role: Role,
-) -> None:
-    connecte(principal(role))
-    refusees: list[tuple[str, str]] = []
-
-    for (methode, chemin), minimum in ROLE_MINIMUM.items():
-        if not has_at_least(role, minimum):
-            continue
-        response = await appelle(client, methode, chemin)
-        if motif_du_refus(response) == REFUS_DE_DROITS:
-            refusees.append((methode, chemin))
-
-    assert refusees == []
-
-
-async def test_a_pending_password_change_is_refused_on_every_guarded_route(
-    connecte: Callable[[Principal], None],
-    client: AsyncClient,
-    base_muette: None,
-) -> None:
-    connecte(principal(Role.ADMIN, must_change_password=True))
-    laissees_passer: list[tuple[str, str, int]] = []
-
-    for methode, chemin in ROLE_MINIMUM:
-        response = await appelle(client, methode, chemin)
-        if motif_du_refus(response) != REFUS_DE_MOT_DE_PASSE:
-            laissees_passer.append((methode, chemin, response.status_code))
-
-    assert laissees_passer == []
-
-
-@pytest.fixture
-async def comptes_par_role() -> AsyncIterator[dict[Role, str]]:
-    marque = uuid.uuid4().hex[:12]
-    hacheur = build_hasher(time_cost=1, memory_cost_kib=8192, parallelism=1, max_concurrency=2)
-    empreinte = await hacheur.hash(MOT_DE_PASSE)
-    adresses = {role: f"matrice-{marque}-{role.value}@enervision.fr" for role in ROLES}
-
-    async with get_session_factory()() as session:
-        depot = UserRepository(session)
-        for role, email in adresses.items():
-            await depot.create(email=email, password_hash=empreinte, role=role)
-        await session.commit()
-
-    yield adresses
-
-    async with get_session_factory()() as session:
-        await session.execute(
-            text("delete from app_user where email like :motif"), {"motif": f"matrice-{marque}-%"}
-        )
-        await session.commit()
-
-
-async def authentifie(client: AsyncClient, email: str) -> dict[str, str]:
-    reponse = await client.post(
-        "/api/v1/auth/login", json={"email": email, "password": MOT_DE_PASSE}
-    )
-    assert reponse.status_code == 200, reponse.text
-    return {"Authorization": f"Bearer {reponse.json()['access_token']}"}
-
-
-@pytest.mark.integration
-@pytest.mark.parametrize("role", ROLES, ids=IDS_DE_ROLE)
-async def test_a_real_token_reaches_exactly_the_routes_of_its_rank(
-    comptes_par_role: dict[Role, str], client: AsyncClient, role: Role
-) -> None:
-    entetes = await authentifie(client, comptes_par_role[role])
-    ecarts: list[tuple[str, str, int, str]] = []
-
-    for (methode, chemin), minimum in ROLE_MINIMUM.items():
-        response = await appelle(client, methode, chemin, headers=entetes)
-        refuse = motif_du_refus(response) == REFUS_DE_DROITS
-        if refuse is has_at_least(role, minimum):
-            ecarts.append((methode, chemin, response.status_code, response.text[:120]))
-
-    assert ecarts == []
-
-
-# Contrainte : `operateur` n'ouvre aujourd'hui aucune route de plus que `lecteur`, faute d'écriture
-# métier dans l'API. Figer l'égalité rend la régression visible le jour où une route d'opérateur
-# arrive sans que `ROLE_MINIMUM` soit mis à jour.
-@pytest.mark.integration
-async def test_the_operator_rank_opens_nothing_more_than_the_reader_rank(
-    comptes_par_role: dict[Role, str], client: AsyncClient
-) -> None:
-    lecteur = await authentifie(client, comptes_par_role[Role.LECTEUR])
-    operateur = await authentifie(client, comptes_par_role[Role.OPERATEUR])
-    divergences: list[tuple[str, str]] = []
-
-    for methode, chemin in ROLE_MINIMUM:
-        cote_lecteur = await appelle(client, methode, chemin, headers=lecteur)
-        cote_operateur = await appelle(client, methode, chemin, headers=operateur)
-        if cote_lecteur.status_code != cote_operateur.status_code:
-            divergences.append((methode, chemin))
-
-    assert divergences == []
-
-
-# Piège : `/auth/logout-all` prend un `CurrentPrincipalDep` nu, donc elle échappe au gate
-# `must_change_password` que seul `require_role` applique. Comportement figé ici, pas corrigé.
-@pytest.mark.integration
-async def test_a_temporary_password_blocks_the_business_routes_but_not_logout_all(
-    client: AsyncClient,
-) -> None:
-    marque = uuid.uuid4().hex[:12]
-    email = f"matrice-{marque}-provisoire@enervision.fr"
-    hacheur = build_hasher(time_cost=1, memory_cost_kib=8192, parallelism=1, max_concurrency=2)
-    empreinte = await hacheur.hash(MOT_DE_PASSE)
-
-    async with get_session_factory()() as session:
-        await UserRepository(session).create(
-            email=email, password_hash=empreinte, role=Role.ADMIN, must_change_password=True
-        )
-        await session.commit()
-
-    try:
-        entetes = await authentifie(client, email)
-        sites = await client.get("/api/v1/sites", headers=entetes)
-        identite = await client.get("/api/v1/auth/me", headers=entetes)
-        fermeture = await client.post("/api/v1/auth/logout-all", headers=entetes)
-
-        assert motif_du_refus(sites) == REFUS_DE_MOT_DE_PASSE
-        assert identite.status_code == 200
-        assert fermeture.status_code == 204
-    finally:
-        async with get_session_factory()() as session:
-            await session.execute(text("delete from app_user where email = :e"), {"e": email})
-            await session.commit()

apps/backend/tests/api/test_openapi.py

@@ -8,7 +8,6 @@ from typing import Any
 import pytest
 
 from app import cli
-from tests.api.acces import ROLE_MINIMUM
 
 METHODES = {"get", "post", "patch", "put", "delete"}
 
@@ -25,11 +24,21 @@ ORIGINE_VERIFIEE = {
 
 # Toute route derrière `require_role` (LecteurDep, OperateurDep, AdminDep) peut rendre 403 pour
 # `password_change_required`, pas seulement les routes `admin`.
-# Piège : cette liste était recopiée ici, et deux de ses entrées portaient `{id}` là où le contrat
+ROUTES_A_ROLE = {
-# expose `{user_id}`. Elles ne correspondaient donc à aucune opération, et le test ci-dessous
+    ("GET", "/api/v1/users"),
-# passait au vert sans rien vérifier sur ces deux routes. Elle est maintenant dérivée, et
+    ("POST", "/api/v1/users"),
-# `test_every_declared_route_is_classified` interdit l'entrée morte.
+    ("PATCH", "/api/v1/users/{id}"),
-ROUTES_A_ROLE = frozenset(ROLE_MINIMUM)
+    ("POST", "/api/v1/users/{id}/password-reset"),
+    ("GET", "/api/v1/sites"),
+    ("GET", "/api/v1/sites/{site_id}"),
+    ("GET", "/api/v1/sites/{site_id}/current"),
+    ("GET", "/api/v1/alerts"),
+    ("GET", "/api/v1/recommendations"),
+    ("GET", "/api/v1/recommendations/{recommendation_id}"),
+    ("GET", "/api/v1/stats/summary"),
+    ("GET", "/api/v1/readings"),
+    ("GET", "/api/v1/sensors/status"),
+}
 
 
 @pytest.fixture(scope="module")

apps/backend/tests/api/test_predictions.py

@@ -1,85 +0,0 @@
-from collections.abc import Callable, Iterator
-from datetime import UTC, datetime
-from uuid import uuid4
-
-import pytest
-from fastapi import FastAPI
-from httpx import AsyncClient
-
-from app.api.deps import get_current_principal, get_prediction_service
-from app.core.principal import Principal
-from app.core.roles import AccountKind, Role
-from app.services.prediction import PredictionSummary, SitePrediction, SitePredictionSummary
-
-TARGET_AT = datetime(2026, 9, 16, 13, 0, tzinfo=UTC)
-CREATED_AT = datetime(2026, 9, 16, 12, 0, tzinfo=UTC)
-
-
-def lecteur() -> Principal:
-    # Le garde-fou de rôle (`lecteur` minimum) est déjà couvert par l'ensemble `ROUTES_A_ROLE`
-    # de `tests/api/test_openapi.py` : pas besoin ici d'un paramètre de rôle jamais appelé avec
-    # autre chose que sa valeur par défaut.
-    return Principal(
-        id=uuid4(),
-        email="lecteur@enervision.fr",
-        role=Role.LECTEUR,
-        kind=AccountKind.HUMAIN,
-        must_change_password=False,
-    )
-
-
-class FauxService:
-    def __init__(self) -> None:
-        self.resume = PredictionSummary(
-            timestamp=datetime.now(UTC),
-            sites=[
-                SitePredictionSummary(
-                    site_id="SITE001",
-                    site_name="Bureau Paris La Défense",
-                    prediction=SitePrediction(
-                        target_at=TARGET_AT,
-                        target_metric="consumption_kwh",
-                        period_minutes=60,
-                        predicted_value=812.5,
-                        status="available",
-                        failure_reason=None,
-                        model_reference="lightgbm-abc123",
-                        created_at=CREATED_AT,
-                    ),
-                ),
-                SitePredictionSummary(site_id="SITE002", site_name="Usine Lyon", prediction=None),
-            ],
-        )
-
-    async def summary(self) -> PredictionSummary:
-        return self.resume
-
-
-@pytest.fixture
-def servi(app: FastAPI) -> Iterator[Callable[[], FauxService]]:
-    def installe() -> FauxService:
-        service = FauxService()
-        app.dependency_overrides[get_prediction_service] = lambda: service
-        app.dependency_overrides[get_current_principal] = lambda: lecteur()
-        return service
-
-    yield installe
-    app.dependency_overrides.pop(get_prediction_service, None)
-    app.dependency_overrides.pop(get_current_principal, None)
-
-
-async def test_get_predictions_returns_the_service_result(
-    servi: Callable[[], FauxService], client: AsyncClient
-) -> None:
-    servi()
-
-    response = await client.get("/api/v1/predictions")
-
-    assert response.status_code == 200
-    corps = response.json()
-    premier, second = corps["sites"]
-    assert premier["site_id"] == "SITE001"
-    assert premier["prediction"]["predicted_value"] == 812.5
-    assert premier["prediction"]["status"] == "available"
-    assert second["site_id"] == "SITE002"
-    assert second["prediction"] is None

apps/backend/tests/api/test_route_protection.py

@@ -1,6 +1,6 @@
 # Ce test est le garde-fou de l'autorisation : rendre une route publique oblige à modifier
-# `ROUTES_PUBLIQUES` dans `tests/api/acces.py`, ce qui apparaît en clair dans la diff d'une pull
+# `ROUTES_PUBLIQUES` ci-dessous, ce qui apparaît en clair dans la diff d'une pull request et
-# request et demande une justification au relecteur.
+# demande une justification au relecteur.
 # Pourquoi : il interroge réellement chaque route sans jeton au lieu d'inspecter l'arbre de
 # dépendances. L'arbre n'est accessible que par l'API privée de FastAPI, et surtout une route
 # peut porter la bonne dépendance tout en répondant quand même.
@@ -11,64 +11,58 @@ import pytest
 from fastapi import FastAPI
 from httpx import AsyncClient
 
-from tests.api.acces import (
+ROUTES_PUBLIQUES = frozenset(
-    ROLE_MINIMUM,
+    {
-    ROUTE_COOKIE,
+        ("GET", "/api/v1/health/live"),
-    ROUTES_PUBLIQUES,
+        ("GET", "/api/v1/health/ready"),
-    ROUTES_SANS_ROLE,
+        ("POST", "/api/v1/auth/login"),
-    Route,
+        # Sans cookie, la déconnexion ne fait rien et répond 204 : elle est idempotente.
-    chemin_concret,
+        ("POST", "/api/v1/auth/logout"),
-    routes_du_schema,
+        ("POST", "/api/v1/auth/forgot-password"),
+        # Protégée par le jeton dans le corps de la requête, pas par un `Principal` : aucune
+        # authentification préalable ne s'applique, c'est la validité du jeton qui tranche.
+        ("POST", "/api/v1/auth/reset-password"),
+        # Même raison : lecture seule, protégée par le jeton passé en paramètre, pas par un
+        # `Principal`. Le jeton est un secret de 256 bits, non brute-forçable.
+        ("GET", "/api/v1/auth/reset-password/validate"),
+        ("GET", "/metrics"),
+    }
 )
 
+VALEURS_DE_SUBSTITUTION = "00000000-0000-0000-0000-000000000000"
 STATUTS_DE_REFUS = {401, 403}
-HORS_SCHEMA = {("GET", "/metrics")}
 
 
-def routes_declarees(app: FastAPI) -> list[Route]:
+def routes_declarees(app: FastAPI) -> list[tuple[str, str]]:
     schema: dict[str, Any] = app.openapi()
-    return routes_du_schema(schema)
+    return [
+        (methode.upper(), chemin)
+        for chemin, operations in schema["paths"].items()
+        for methode in operations
+        if methode.upper() in {"GET", "POST", "PATCH", "PUT", "DELETE"}
+    ]
 
 
-def routes_protegees(app: FastAPI) -> list[Route]:
+def routes_protegees(app: FastAPI) -> list[tuple[str, str]]:
     return [route for route in routes_declarees(app) if route not in ROUTES_PUBLIQUES]
 
 
 def test_the_public_allow_list_has_no_stale_entry(app: FastAPI) -> None:
-    declarees = set(routes_declarees(app)) | HORS_SCHEMA
+    declarees = set(routes_declarees(app)) | {("GET", "/metrics")}
 
     inconnues = ROUTES_PUBLIQUES - declarees
 
     assert inconnues == set()
 
 
-# Sans lui, une route ajoutée sans être classée n'est vue par aucun test de rôle : elle hérite
-# du seul contrôle anonyme, et une garde posée au mauvais niveau passe inaperçue.
-def test_every_declared_route_is_classified(app: FastAPI) -> None:
-    classees = ROUTES_PUBLIQUES | ROUTE_COOKIE | ROUTES_SANS_ROLE | set(ROLE_MINIMUM)
-
-    non_classees = set(routes_declarees(app)) - classees
-    fantomes = classees - set(routes_declarees(app)) - HORS_SCHEMA
-
-    assert non_classees == set(), "classer la route dans tests/api/acces.py"
-    assert fantomes == set(), "entrée morte : la route n'existe plus sous ce chemin"
-
-
-def test_the_four_classes_of_routes_stay_disjoint() -> None:
-    classes = [ROUTES_PUBLIQUES, ROUTE_COOKIE, ROUTES_SANS_ROLE, frozenset(ROLE_MINIMUM)]
-
-    for rang, classe in enumerate(classes):
-        for autre in classes[rang + 1 :]:
-            assert classe & autre == frozenset()
-
-
 async def test_every_route_rejects_an_anonymous_caller_unless_explicitly_public(
     app: FastAPI, client: AsyncClient
 ) -> None:
     ouvertes: list[tuple[str, str, int]] = []
 
     for methode, chemin in routes_protegees(app):
-        response = await client.request(methode, chemin_concret(chemin), json={})
+        concret = chemin.replace("{user_id}", VALEURS_DE_SUBSTITUTION)
+        response = await client.request(methode, concret, json={})
         if response.status_code not in STATUTS_DE_REFUS:
             ouvertes.append((methode, chemin, response.status_code))
 
@@ -101,5 +95,4 @@ async def test_the_documentation_routes_are_public_by_design(
     app: FastAPI, client: AsyncClient, chemin: str
 ) -> None:
     response = await client.get(chemin)
-
     assert response.status_code == 200

apps/backend/tests/repositories/test_alert.py

@@ -89,60 +89,3 @@ async def test_list_all_returns_an_empty_list_when_there_is_nothing(
     alertes = await depot.list_all(site_id=identifiant_site())
 
     assert list(alertes) == []
-
-
-def _alerte_a_inserer(*, site_id: str, source_alert_id: str) -> Alert:
-    return Alert(
-        source_alert_id=source_alert_id,
-        site_id=site_id,
-        source="enervision",
-        timestamp=datetime(2026, 9, 16, tzinfo=UTC),
-        type="threshold",
-        severity="high",
-        message="Dépassement du seuil configuré",
-        value=812.5,
-        threshold=720.0,
-        metric="consumption_kw",
-        prediction_id=None,
-        raw_data={},
-    )
-
-
-async def test_create_many_inserts_every_alert(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = AlertRepository(session)
-
-    creees = await depot.create_many(
-        [
-            _alerte_a_inserer(site_id=site.site_id, source_alert_id="threshold:a"),
-            _alerte_a_inserer(site_id=site.site_id, source_alert_id="threshold:b"),
-        ]
-    )
-    identifiants = [a.alert_id for a in creees]
-    await session.rollback()
-
-    assert len(identifiants) == 2
-    assert all(identifiant is not None for identifiant in identifiants)
-
-
-async def test_create_many_skips_a_duplicate_source_alert_id(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = AlertRepository(session)
-    await depot.create_many(
-        [_alerte_a_inserer(site_id=site.site_id, source_alert_id="threshold:rejouee")]
-    )
-
-    rejouees = await depot.create_many(
-        [_alerte_a_inserer(site_id=site.site_id, source_alert_id="threshold:rejouee")]
-    )
-    await session.rollback()
-
-    assert rejouees == []
-
-
-async def test_create_many_does_nothing_for_an_empty_list(session: AsyncSession) -> None:
-    depot = AlertRepository(session)
-
-    creees = await depot.create_many([])
-
-    assert creees == []

apps/backend/tests/repositories/test_prediction.py

@@ -1,171 +0,0 @@
-from datetime import UTC, datetime
-
-import pytest
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.models.energy import Prediction
-from app.repositories.prediction import PredictionRepository
-from tests.repositories.test_site import creer as creer_site
-from tests.repositories.test_site import identifiant as identifiant_site
-
-pytestmark = pytest.mark.integration
-
-
-async def creer_prediction(
-    session: AsyncSession, *, site_id: str, **overrides: object
-) -> Prediction:
-    prediction = Prediction(
-        site_id=site_id,
-        target_at=overrides.get("target_at", datetime(2026, 9, 16, tzinfo=UTC)),
-        target_metric=overrides.get("target_metric", "consumption_kwh"),
-        period_minutes=overrides.get("period_minutes", 60),
-        predicted_value=overrides.get("predicted_value", 42.0),
-        model_reference=overrides.get("model_reference", "lightgbm-test"),
-        status=overrides.get("status", "available"),
-        failure_reason=overrides.get("failure_reason"),
-    )
-    session.add(prediction)
-    await session.flush()
-    return prediction
-
-
-async def test_list_since_excludes_predictions_before_the_cutoff(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    dedans = await creer_prediction(
-        session, site_id=site.site_id, target_at=datetime(2026, 9, 16, tzinfo=UTC)
-    )
-    await creer_prediction(
-        session, site_id=site.site_id, target_at=datetime(2026, 9, 1, tzinfo=UTC)
-    )
-
-    resultats = await depot.list_since(
-        since=datetime(2026, 9, 10, tzinfo=UTC), site_id=site.site_id
-    )
-    identifiants = [p.prediction_id for p in resultats]
-    await session.rollback()
-
-    assert identifiants == [dedans.prediction_id]
-
-
-async def test_list_since_excludes_predictions_that_are_not_available(
-    session: AsyncSession,
-) -> None:
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    await creer_prediction(
-        session,
-        site_id=site.site_id,
-        target_at=datetime(2026, 9, 16, tzinfo=UTC),
-        status="insufficient_data",
-        predicted_value=None,
-        failure_reason="pas assez d'historique",
-    )
-
-    resultats = await depot.list_since(since=datetime(2026, 9, 1, tzinfo=UTC), site_id=site.site_id)
-    await session.rollback()
-
-    assert list(resultats) == []
-
-
-async def test_list_since_breaks_a_target_at_tie_by_ascending_prediction_id(
-    session: AsyncSession,
-) -> None:
-    # `prediction` n'a pas d'unicité sur `(site_id, target_at)` : deux runs de scoring sans
-    # nouvelle lecture entre-temps produisent deux lignes `available` à la même cible. Sans ce
-    # départage, `_detect_anomaly` retiendrait une ligne au hasard plutôt que le run le plus
-    # récent.
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    cible = datetime(2026, 9, 16, tzinfo=UTC)
-    premier_run = await creer_prediction(
-        session, site_id=site.site_id, target_at=cible, predicted_value=10.0
-    )
-    second_run = await creer_prediction(
-        session, site_id=site.site_id, target_at=cible, predicted_value=20.0
-    )
-
-    resultats = await depot.list_since(since=datetime(2026, 9, 1, tzinfo=UTC), site_id=site.site_id)
-    identifiants = [p.prediction_id for p in resultats]
-    await session.rollback()
-
-    assert identifiants == [premier_run.prediction_id, second_run.prediction_id]
-
-
-async def test_list_since_filters_by_site_id(session: AsyncSession) -> None:
-    premier = await creer_site(session)
-    second = await creer_site(session)
-    depot = PredictionRepository(session)
-    voulue = await creer_prediction(session, site_id=premier.site_id)
-    await creer_prediction(session, site_id=second.site_id)
-
-    resultats = await depot.list_since(
-        since=datetime(2026, 8, 1, tzinfo=UTC), site_id=premier.site_id
-    )
-    identifiants = [p.prediction_id for p in resultats]
-    await session.rollback()
-
-    assert identifiants == [voulue.prediction_id]
-
-
-async def test_latest_by_site_keeps_only_the_most_recent_target(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    ancienne = await creer_prediction(
-        session, site_id=site.site_id, target_at=datetime(2026, 9, 1, tzinfo=UTC)
-    )
-    recente = await creer_prediction(
-        session, site_id=site.site_id, target_at=datetime(2026, 9, 15, tzinfo=UTC)
-    )
-
-    resultats = await depot.latest_by_site()
-    identifiants = [
-        p.prediction_id
-        for p in resultats
-        if p.prediction_id in (ancienne.prediction_id, recente.prediction_id)
-    ]
-    await session.rollback()
-
-    assert identifiants == [recente.prediction_id]
-
-
-async def test_latest_by_site_returns_one_row_per_site(session: AsyncSession) -> None:
-    premier = await creer_site(session)
-    second = await creer_site(session)
-    depot = PredictionRepository(session)
-    voulue_premier = await creer_prediction(session, site_id=premier.site_id)
-    voulue_second = await creer_prediction(session, site_id=second.site_id)
-
-    resultats = await depot.latest_by_site()
-    identifiants = {p.site_id for p in resultats if p.site_id in (premier.site_id, second.site_id)}
-    await session.rollback()
-
-    assert identifiants == {voulue_premier.site_id, voulue_second.site_id}
-
-
-async def test_latest_by_site_keeps_an_insufficient_data_prediction(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    voulue = await creer_prediction(
-        session,
-        site_id=site.site_id,
-        status="insufficient_data",
-        predicted_value=None,
-        failure_reason="pas assez d'historique",
-    )
-
-    resultats = await depot.latest_by_site()
-    identifiants = [p.prediction_id for p in resultats if p.site_id == site.site_id]
-    await session.rollback()
-
-    assert identifiants == [voulue.prediction_id]
-
-
-async def test_latest_by_site_returns_an_empty_list_when_there_is_nothing(
-    session: AsyncSession,
-) -> None:
-    depot = PredictionRepository(session)
-
-    resultats = [p for p in await depot.latest_by_site() if p.site_id == identifiant_site()]
-
-    assert resultats == []

apps/backend/tests/repositories/test_reading.py

@@ -155,79 +155,6 @@ async def test_latest_for_site_ignores_the_readings_of_the_other_sites(
     assert trouvee is None
 
 
-async def test_list_since_orders_by_site_then_by_time_ascending(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = ReadingRepository(session)
-    plus_recente = await creer_lecture(
-        session, site_id=site.site_id, timestamp=datetime(2026, 9, 16, tzinfo=UTC)
-    )
-    plus_ancienne = await creer_lecture(
-        session, site_id=site.site_id, timestamp=datetime(2026, 9, 15, tzinfo=UTC)
-    )
-
-    resultats = await depot.list_since(since=datetime(2026, 9, 1, tzinfo=UTC), site_id=site.site_id)
-    identifiants = [r.reading_id for r in resultats]
-    await session.rollback()
-
-    assert identifiants == [plus_ancienne.reading_id, plus_recente.reading_id]
-
-
-async def test_list_since_excludes_readings_before_the_cutoff(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = ReadingRepository(session)
-    dedans = await creer_lecture(
-        session, site_id=site.site_id, timestamp=datetime(2026, 9, 16, tzinfo=UTC)
-    )
-    await creer_lecture(session, site_id=site.site_id, timestamp=datetime(2026, 9, 1, tzinfo=UTC))
-
-    resultats = await depot.list_since(
-        since=datetime(2026, 9, 10, tzinfo=UTC), site_id=site.site_id
-    )
-    identifiants = [r.reading_id for r in resultats]
-    await session.rollback()
-
-    assert identifiants == [dedans.reading_id]
-
-
-async def test_list_since_breaks_a_timestamp_tie_by_ascending_reading_id(
-    session: AsyncSession,
-) -> None:
-    # `uq_reading_source` autorise deux lignes au même `site_id`+`timestamp` quand la `source`
-    # diffère (même piège que `latest_for_site`). Sans ce départage, `_detect_spike` traiterait
-    # cette paire comme une variation réelle selon un ordre non garanti par le plan d'exécution.
-    site = await creer_site(session)
-    depot = ReadingRepository(session)
-    horodatage = datetime(2026, 9, 16, tzinfo=UTC)
-    premiere = await creer_lecture(
-        session, site_id=site.site_id, timestamp=horodatage, source="api_history", consumption_kw=10
-    )
-    seconde = await creer_lecture(
-        session, site_id=site.site_id, timestamp=horodatage, source="api_current", consumption_kw=42
-    )
-
-    resultats = await depot.list_since(since=datetime(2026, 9, 1, tzinfo=UTC), site_id=site.site_id)
-    identifiants = [r.reading_id for r in resultats]
-    await session.rollback()
-
-    assert identifiants == [premiere.reading_id, seconde.reading_id]
-
-
-async def test_list_since_filters_by_site_id(session: AsyncSession) -> None:
-    premier = await creer_site(session)
-    second = await creer_site(session)
-    depot = ReadingRepository(session)
-    voulue = await creer_lecture(session, site_id=premier.site_id)
-    await creer_lecture(session, site_id=second.site_id)
-
-    resultats = await depot.list_since(
-        since=datetime(2026, 8, 1, tzinfo=UTC), site_id=premier.site_id
-    )
-    identifiants = [r.reading_id for r in resultats]
-    await session.rollback()
-
-    assert identifiants == [voulue.reading_id]
-
-
 async def test_list_history_orders_the_readings_by_timestamp_descending(
     session: AsyncSession,
 ) -> None:

apps/backend/tests/services/test_alert.py

@@ -1,10 +1,7 @@
-from dataclasses import dataclass, field
+from datetime import UTC, datetime
-from datetime import UTC, datetime, timedelta
 
 from app.models.energy import Alert
-from app.services.alert import OUTAGE_THRESHOLD, AlertService, _severity_from_ratio
+from app.services.alert import AlertService
-
-NOW = datetime(2026, 9, 16, 12, 0, tzinfo=UTC)
 
 
 def alert(
@@ -29,36 +26,10 @@ def alert(
     )
 
 
-@dataclass
-class FauxSite:
-    site_id: str
-    capacity_kw: float | None = None
-
-
-@dataclass
-class FauxLecture:
-    site_id: str
-    timestamp: datetime
-    consumption_kw: float | None = None
-    consumption_kwh: float | None = None
-    data_quality: str | None = None
-    null_reasons: list[str] | None = None
-
-
-@dataclass
-class FauxPrediction:
-    site_id: str
-    target_at: datetime
-    predicted_value: float | None
-    target_metric: str = "consumption_kwh"
-    prediction_id: int = 1
-
-
 class FakeRepository:
     def __init__(self, alerts: list[Alert]) -> None:
         self._alerts = alerts
         self.appels: list[tuple[str | None, str | None]] = []
-        self.crees: list[Alert] = []
 
     async def list_all(
         self, *, site_id: str | None = None, severity: str | None = None
@@ -66,392 +37,19 @@ class FakeRepository:
         self.appels.append((site_id, severity))
         return self._alerts
 
-    async def create_many(self, alerts: list[Alert]) -> list[Alert]:
-        self.crees = list(alerts)
-        return self.crees
-
-
-@dataclass
-class FauxDepotLectures:
-    depuis: list[FauxLecture] = field(default_factory=list)
-    dernieres: list[FauxLecture] = field(default_factory=list)
-
-    async def list_since(self, *, since: datetime, site_id: str | None = None) -> list[FauxLecture]:
-        return [lecture for lecture in self.depuis if site_id is None or lecture.site_id == site_id]
-
-    async def latest_by_site(self) -> list[FauxLecture]:
-        return self.dernieres
-
-
-@dataclass
-class FauxDepotPredictions:
-    predictions: list[FauxPrediction] = field(default_factory=list)
-
-    async def list_since(
-        self, *, since: datetime, site_id: str | None = None
-    ) -> list[FauxPrediction]:
-        return [p for p in self.predictions if site_id is None or p.site_id == site_id]
-
-
-@dataclass
-class FauxDepotSites:
-    sites: list[FauxSite]
-
-    async def list_all(self) -> list[FauxSite]:
-        return self.sites
-
-
-def service(
-    *,
-    sites: list[FauxSite],
-    lectures: list[FauxLecture] | None = None,
-    dernieres: list[FauxLecture] | None = None,
-    predictions: list[FauxPrediction] | None = None,
-    alerts: FakeRepository | None = None,
-) -> tuple[AlertService, FakeRepository]:
-    depot_alertes = alerts or FakeRepository([])
-    dernieres_lectures = dernieres if dernieres is not None else (lectures or [])
-    return (
-        AlertService(
-            alerts=depot_alertes,  # type: ignore[arg-type]
-            readings=FauxDepotLectures(depuis=lectures or [], dernieres=dernieres_lectures),  # type: ignore[arg-type]
-            predictions=FauxDepotPredictions(predictions or []),  # type: ignore[arg-type]
-            sites=FauxDepotSites(sites),  # type: ignore[arg-type]
-        ),
-        depot_alertes,
-    )
-
 
 async def test_list_all_returns_the_repository_alerts() -> None:
-    svc, _ = service(sites=[], alerts=FakeRepository([alert(1), alert(2)]))
+    service = AlertService(alerts=FakeRepository([alert(1), alert(2)]))
 
-    alertes = await svc.list_all()
+    alertes = await service.list_all()
 
     assert [a.alert_id for a in alertes] == [1, 2]
 
 
 async def test_list_all_relays_the_filters_to_the_repository() -> None:
     depot = FakeRepository([])
-    svc, _ = service(sites=[], alerts=depot)
+    service = AlertService(alerts=depot)
 
-    await svc.list_all(site_id="site-1", severity="critical")
+    await service.list_all(site_id="site-1", severity="critical")
 
     assert depot.appels == [("site-1", "critical")]
-
-
-async def test_detect_raises_a_threshold_alert_above_site_capacity() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=100.0)],
-        lectures=[FauxLecture("A", NOW, consumption_kw=150.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = depot.crees
-    assert candidate.type == "threshold"
-    assert candidate.severity == "high"
-    assert candidate.value == 150.0
-    assert candidate.threshold == 100.0
-    assert candidate.metric == "consumption_kw"
-
-
-async def test_detect_ignores_a_reading_within_capacity() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=100.0)],
-        lectures=[FauxLecture("A", NOW, consumption_kw=80.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert depot.crees == []
-
-
-async def test_detect_ignores_threshold_when_the_site_has_no_declared_capacity() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=None)],
-        lectures=[FauxLecture("A", NOW, consumption_kw=9999.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert depot.crees == []
-
-
-async def test_detect_raises_a_spike_alert_on_a_brutal_consecutive_variation() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=100.0),
-            FauxLecture("A", NOW, consumption_kw=160.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "spike"]
-    assert candidate.value == 160.0
-    assert candidate.threshold == 100.0
-    assert candidate.timestamp == NOW
-
-
-async def test_detect_ignores_a_moderate_consecutive_variation() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=100.0),
-            FauxLecture("A", NOW, consumption_kw=110.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_never_compares_consecutive_readings_across_two_sites() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A"), FauxSite("B")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=10.0),
-            FauxLecture("B", NOW, consumption_kw=1000.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_raises_an_anomaly_alert_far_from_the_matching_prediction() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=100.0)],
-        predictions=[FauxPrediction("A", target_at=NOW, predicted_value=70.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "anomaly"]
-    assert candidate.value == 100.0
-    assert candidate.threshold == 70.0
-    assert candidate.metric == "consumption_kwh"
-    assert candidate.prediction_id == 1
-
-
-async def test_detect_ignores_a_reading_close_to_its_prediction() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=100.0)],
-        predictions=[FauxPrediction("A", target_at=NOW, predicted_value=95.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "anomaly"] == []
-
-
-async def test_detect_ignores_a_prediction_whose_target_at_does_not_match_the_reading() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=100.0)],
-        predictions=[FauxPrediction("A", target_at=NOW - timedelta(hours=1), predicted_value=1.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "anomaly"] == []
-
-
-async def test_detect_keeps_the_most_recent_run_when_two_predictions_share_the_same_target() -> (
-    None
-):
-    # `PredictionRepository.list_since` départage les égalités de `target_at` par `prediction_id`
-    # croissant : le repository fait donc déjà passer le run le plus récent en dernier dans la
-    # liste, et c'est ce dernier que le dict de `_detect_anomaly` doit retenir.
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=100.0)],
-        predictions=[
-            FauxPrediction("A", target_at=NOW, predicted_value=100.0, prediction_id=1),
-            FauxPrediction("A", target_at=NOW, predicted_value=70.0, prediction_id=2),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "anomaly"]
-    assert candidate.threshold == 70.0
-    assert candidate.prediction_id == 2
-
-
-async def test_detect_raises_an_outage_alert_past_the_threshold() -> None:
-    derniere = NOW - OUTAGE_THRESHOLD - timedelta(minutes=1)
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[],
-        dernieres=[FauxLecture("A", derniere)],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "outage"]
-    assert candidate.severity in {"low", "medium", "high", "critical"}
-
-
-async def test_detect_ignores_a_site_still_within_the_outage_threshold() -> None:
-    derniere = NOW - OUTAGE_THRESHOLD + timedelta(minutes=1)
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[],
-        dernieres=[FauxLecture("A", derniere)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "outage"] == []
-
-
-async def test_detect_raises_a_critical_outage_alert_for_a_site_never_read() -> None:
-    svc, depot = service(sites=[FauxSite("A")], lectures=[], dernieres=[])
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "outage"]
-    assert candidate.severity == "critical"
-    assert candidate.source_alert_id == "outage:jamais"
-
-
-async def test_detect_raises_a_sensor_alert_on_a_degraded_reading() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, data_quality="critical", null_reasons=["missing:x"])],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "sensor"]
-    assert candidate.severity == "critical"
-
-
-async def test_detect_ignores_a_good_quality_reading_for_the_sensor_rule() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, data_quality="good")],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "sensor"] == []
-
-
-async def test_detect_scopes_to_a_single_site_when_asked() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=100.0), FauxSite("B", capacity_kw=100.0)],
-        lectures=[
-            FauxLecture("A", NOW, consumption_kw=150.0),
-            FauxLecture("B", NOW, consumption_kw=150.0),
-        ],
-    )
-
-    await svc.detect(now=NOW, site_id="A")
-
-    assert {a.site_id for a in depot.crees} == {"A"}
-
-
-async def test_detect_returns_early_when_there_is_no_site() -> None:
-    svc, depot = service(sites=[])
-
-    resultat = await svc.detect(now=NOW)
-
-    assert resultat == []
-    assert depot.crees == []
-
-
-async def test_detect_ignores_a_spike_pair_with_a_missing_measurement() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=None),
-            FauxLecture("A", NOW, consumption_kw=160.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_ignores_a_reading_still_at_zero_after_a_previous_zero() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=0.0),
-            FauxLecture("A", NOW, consumption_kw=0.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_raises_a_critical_spike_when_a_site_restarts_from_zero() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=0.0),
-            FauxLecture("A", NOW, consumption_kw=50.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "spike"]
-    assert candidate.severity == "critical"
-    assert candidate.value == 50.0
-    assert candidate.threshold == 0.0
-
-
-async def test_detect_ignores_a_spike_pair_sharing_the_same_timestamp() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW, consumption_kw=100.0),
-            FauxLecture("A", NOW, consumption_kw=160.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_ignores_an_anomaly_when_the_prediction_is_near_zero() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=5.0)],
-        predictions=[FauxPrediction("A", target_at=NOW, predicted_value=0.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "anomaly"] == []
-
-
-def test_severity_from_ratio_covers_every_band() -> None:
-    assert _severity_from_ratio(1.0) == "low"
-    assert _severity_from_ratio(1.2) == "medium"
-    assert _severity_from_ratio(1.5) == "high"
-    assert _severity_from_ratio(2.0) == "critical"
-
-
-async def test_detect_does_not_call_create_many_when_nothing_triggers() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=100.0)],
-        lectures=[FauxLecture("A", NOW, consumption_kw=10.0, data_quality="good")],
-    )
-
-    resultat = await svc.detect(now=NOW)
-
-    assert resultat == []
-    assert depot.crees == []

apps/backend/tests/services/test_prediction.py

@@ -1,121 +0,0 @@
-from dataclasses import dataclass
-from datetime import UTC, datetime
-
-from app.services.prediction import PredictionService
-
-TARGET_AT = datetime(2026, 9, 16, 13, 0, tzinfo=UTC)
-CREATED_AT = datetime(2026, 9, 16, 12, 0, tzinfo=UTC)
-
-
-@dataclass
-class FauxSite:
-    site_id: str
-    site_name: str
-
-
-@dataclass
-class FauxPrediction:
-    site_id: str
-    target_at: datetime
-    target_metric: str
-    period_minutes: int | None
-    predicted_value: float | None
-    status: str
-    failure_reason: str | None
-    model_reference: str
-    created_at: datetime
-
-
-class FauxDepotSites:
-    def __init__(self, sites: list[FauxSite]) -> None:
-        self._sites = sites
-
-    async def list_all(self) -> list[FauxSite]:
-        return self._sites
-
-
-class FauxDepotPredictions:
-    def __init__(self, predictions: list[FauxPrediction]) -> None:
-        self._predictions = predictions
-
-    async def latest_by_site(self) -> list[FauxPrediction]:
-        return self._predictions
-
-
-def prediction_disponible(site_id: str = "A") -> FauxPrediction:
-    return FauxPrediction(
-        site_id=site_id,
-        target_at=TARGET_AT,
-        target_metric="consumption_kwh",
-        period_minutes=60,
-        predicted_value=812.5,
-        status="available",
-        failure_reason=None,
-        model_reference="lightgbm-abc123",
-        created_at=CREATED_AT,
-    )
-
-
-async def test_summary_attaches_the_latest_prediction_to_its_site() -> None:
-    service = PredictionService(
-        sites=FauxDepotSites([FauxSite("A", "Site A")]),  # type: ignore[arg-type]
-        predictions=FauxDepotPredictions([prediction_disponible("A")]),  # type: ignore[arg-type]
-    )
-
-    resume = await service.summary()
-
-    site = resume.sites[0]
-    assert site.site_id == "A"
-    assert site.prediction is not None
-    assert site.prediction.predicted_value == 812.5
-    assert site.prediction.status == "available"
-
-
-async def test_summary_leaves_prediction_none_for_a_site_never_scored() -> None:
-    service = PredictionService(
-        sites=FauxDepotSites([FauxSite("A", "Site A")]),  # type: ignore[arg-type]
-        predictions=FauxDepotPredictions([]),  # type: ignore[arg-type]
-    )
-
-    resume = await service.summary()
-
-    assert resume.sites[0].prediction is None
-
-
-async def test_summary_carries_an_insufficient_data_prediction_without_a_value() -> None:
-    insuffisante = FauxPrediction(
-        site_id="A",
-        target_at=TARGET_AT,
-        target_metric="consumption_kwh",
-        period_minutes=60,
-        predicted_value=None,
-        status="insufficient_data",
-        failure_reason="pas assez d'historique",
-        model_reference="lightgbm-abc123",
-        created_at=CREATED_AT,
-    )
-    service = PredictionService(
-        sites=FauxDepotSites([FauxSite("A", "Site A")]),  # type: ignore[arg-type]
-        predictions=FauxDepotPredictions([insuffisante]),  # type: ignore[arg-type]
-    )
-
-    resume = await service.summary()
-
-    site = resume.sites[0]
-    assert site.prediction is not None
-    assert site.prediction.status == "insufficient_data"
-    assert site.prediction.predicted_value is None
-    assert site.prediction.failure_reason == "pas assez d'historique"
-
-
-async def test_summary_covers_every_site_even_with_a_single_prediction_in_the_repository() -> None:
-    service = PredictionService(
-        sites=FauxDepotSites([FauxSite("A", "Site A"), FauxSite("B", "Site B")]),  # type: ignore[arg-type]
-        predictions=FauxDepotPredictions([prediction_disponible("A")]),  # type: ignore[arg-type]
-    )
-
-    resume = await service.summary()
-
-    par_site = {site.site_id: site for site in resume.sites}
-    assert par_site["A"].prediction is not None
-    assert par_site["B"].prediction is None

apps/backend/tests/test_internal_alerts.py

@@ -1,87 +0,0 @@
-from datetime import UTC, datetime
-
-import pytest
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.session import get_session_factory
-from app.detection import internal_alerts
-from app.repositories.alert import AlertRepository
-from tests.repositories.test_reading import creer_lecture
-from tests.repositories.test_site import creer as creer_site
-
-
-def test_parse_args_defaults_to_no_site_and_no_instant() -> None:
-    arguments = internal_alerts.parse_args([])
-
-    assert arguments.site_id is None
-    assert arguments.now is None
-
-
-def test_parse_args_reads_the_site_id() -> None:
-    arguments = internal_alerts.parse_args(["--site-id", "site-1"])
-
-    assert arguments.site_id == "site-1"
-
-
-def test_parse_args_parses_the_instant_option() -> None:
-    arguments = internal_alerts.parse_args(["--now", "2026-09-16T12:00:00+00:00"])
-
-    assert arguments.now == datetime(2026, 9, 16, 12, tzinfo=UTC)
-
-
-def test_parse_instant_treats_a_naive_datetime_as_utc() -> None:
-    assert internal_alerts._parse_instant("2026-09-16T12:00:00") == datetime(
-        2026, 9, 16, 12, tzinfo=UTC
-    )
-
-
-def test_main_prints_how_many_alerts_were_recorded(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    async def fausse_execution(*, now: datetime | None, site_id: str | None) -> int:
-        return 3
-
-    monkeypatch.setattr(internal_alerts, "run_detection", fausse_execution)
-
-    code = internal_alerts.main([])
-
-    assert code == 0
-    assert "3 nouvelle" in capsys.readouterr().out
-
-
-@pytest.mark.integration
-async def test_run_detection_writes_a_threshold_alert_end_to_end(session: AsyncSession) -> None:
-    # `run_detection` ouvre sa propre session et commite : `session.rollback()` seul ne défait
-    # rien ici (contrairement au reste de la suite), d'où le nettoyage explicite ci-dessous, sur
-    # le modèle de `tests/api/test_matrice_acces.py`.
-    site = await creer_site(session, capacity_kw=100.0)
-    site_id = site.site_id
-    instant = datetime(2026, 9, 16, 12, tzinfo=UTC)
-    await creer_lecture(session, site_id=site_id, timestamp=instant, consumption_kw=150.0)
-    await session.commit()
-
-    try:
-        nombre = await internal_alerts.run_detection(now=instant, site_id=site_id)
-
-        alertes = await AlertRepository(session).list_all(site_id=site_id)
-        types = [a.type for a in alertes]
-        await session.rollback()
-
-        assert nombre == 1
-        assert types == ["threshold"]
-    finally:
-        # `site.site_id` n'est plus sûr après `session.rollback()` : le rollback expire tous les
-        # objets de la session (indépendamment d'`expire_on_commit`), et y accéder ici relance une
-        # requête hors contexte async. D'où `site_id`, capturé avant.
-        async with get_session_factory()() as nettoyage:
-            await nettoyage.execute(
-                text("delete from alert where site_id = :site_id"), {"site_id": site_id}
-            )
-            await nettoyage.execute(
-                text("delete from reading where site_id = :site_id"), {"site_id": site_id}
-            )
-            await nettoyage.execute(
-                text("delete from site where site_id = :site_id"), {"site_id": site_id}
-            )
-            await nettoyage.commit()

apps/frontend/sonar-project.properties

@@ -1,18 +0,0 @@
-sonar.projectKey=ProjetPiscine_EnerVision
-sonar.organization=groupe3-ener-vision
-sonar.sourceEncoding=UTF-8
-
-#  Dossier contenant le code source
-sonar.sources=apps/frontend/src,apps/backend/app
-sonar.tests=apps/backend/tests
-
-#  Liste des fichiers et dossiers à exclure de l'analyse
-#  Liste des fichiers et dossiers à exclure de l'analyse
-sonar.exclusions=**/node_modules/**,**/dist/**,**/*.spec.js,**/*.test.js,github,db,ml,docker-compose.yml,**/**/Dockerfile,**/**/proxy.conf.json,**/**/package.json,**/**/angular.json
-
-#  Chemin vers le rapport de couverture de code
-#  Fichier généré par Vitest
-#  Chemin vers le rapport de couverture de code
-#  Fichier généré par Vitest
-sonar.javascript.lcov.reportPaths=apps/frontend/coverage/frontend/lcov.info
-sonar.python.coverage.reportPaths=apps/backend/cov.info

apps/frontend/src/app/app.routes.ts

@@ -21,6 +21,8 @@ export const routes: Routes = [
     path: 'sites/:siteId',
     canActivate: [authGuard],
     loadComponent: () =>
-      import('./features/sites/site-detail/site-detail').then((m) => m.SiteDetail),
+      import('./features/sites/site-detail-placeholder/site-detail-placeholder').then(
+        (m) => m.SiteDetailPlaceholder,
+      ),
   },
 ];

apps/frontend/src/app/core/interceptors/mock-api-interceptor.spec.ts

@@ -64,13 +64,4 @@ describe('mockApiInterceptor', () => {
     httpMock.expectNone(`${environment.apiUrl}/alerts`);
     expect((result as unknown[]).length).toBeGreaterThan(0);
   });
-
-  it('laisse toujours passer /predictions vers le réseau, même avec useMockFixtures activé', () => {
-    environment.useMockFixtures = true;
-
-    http.get(`${environment.apiUrl}/predictions`).subscribe();
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/predictions`);
-    req.flush({ timestamp: '2026-09-18T09:00:00Z', sites: [] });
-  });
 });

apps/frontend/src/app/core/interceptors/mock-api-interceptor.ts

@@ -26,7 +26,5 @@ export const mockApiInterceptor: HttpInterceptorFn = (req, next) => {
   if (req.url.endsWith(`${environment.apiUrl}/alerts`)) {
     return of(new HttpResponse({ status: 200, body: ALERTS_FIXTURE }));
   }
-  // Volontairement jamais mocké, contrairement à `stats`/`alerts` : les prévisions sont servies
-  // par l'API réelle dès maintenant (au même titre que `/auth/*`, déjà toujours réel).
   return next(req);
 };

apps/frontend/src/app/core/services/predictions.service.spec.ts

@@ -1,35 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { provideHttpClient } from '@angular/common/http';
-import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
-import { PredictionsService } from './predictions.service';
-import { environment } from '../../../environments/environment';
-
-describe('PredictionsService', () => {
-  let service: PredictionsService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideHttpClient(), provideHttpClientTesting()],
-    });
-    service = TestBed.inject(PredictionsService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => httpMock.verify());
-
-  it('appelle le bon endpoint et retourne un résumé de prévisions', () => {
-    let result: unknown;
-    service.getPredictions().subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/predictions`);
-    expect(req.request.method).toBe('GET');
-
-    req.flush({
-      timestamp: '2026-09-18T09:00:00Z',
-      sites: [{ site_id: 'SITE001', site_name: 'Test', prediction: null }],
-    });
-
-    expect((result as { sites: unknown[] }).sites.length).toBe(1);
-  });
-});

apps/frontend/src/app/core/services/predictions.service.ts

@@ -1,13 +0,0 @@
-import { Service, inject } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { environment } from '../../../environments/environment';
-import { PredictionSummary } from '../../shared/models/prediction.model';
-
-@Service()
-export class PredictionsService {
-  private http = inject(HttpClient);
-
-  getPredictions() {
-    return this.http.get<PredictionSummary>(`${environment.apiUrl}/predictions`);
-  }
-}

apps/frontend/src/app/core/services/readings.service.spec.ts

@@ -1,50 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { provideHttpClient } from '@angular/common/http';
-import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
-import { ReadingsService } from './readings.service';
-import { environment } from '../../../environments/environment';
-
-describe('ReadingsService', () => {
-  let service: ReadingsService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideHttpClient(), provideHttpClientTesting()],
-    });
-    service = TestBed.inject(ReadingsService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => httpMock.verify());
-
-  it("demande l'historique du site avec la fenêtre temporelle donnée", () => {
-    let result: unknown;
-    service
-      .getHistory('SITE001', '2026-09-16T00:00:00Z', '2026-09-17T00:00:00Z')
-      .subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(
-      (r) => r.url === `${environment.apiUrl}/readings` && r.method === 'GET',
-    );
-    expect(req.request.params.get('site_id')).toBe('SITE001');
-    expect(req.request.params.get('start')).toBe('2026-09-16T00:00:00Z');
-    expect(req.request.params.get('end')).toBe('2026-09-17T00:00:00Z');
-
-    req.flush([{ reading_id: 1, site_id: 'SITE001', consumption_kw: 12.5 }]);
-
-    expect((result as unknown[]).length).toBe(1);
-  });
-
-  it('ne pose pas de paramètres start/end quand ils sont omis', () => {
-    service.getHistory('SITE001').subscribe();
-
-    const req = httpMock.expectOne(
-      (r) => r.url === `${environment.apiUrl}/readings` && r.method === 'GET',
-    );
-    expect(req.request.params.has('start')).toBe(false);
-    expect(req.request.params.has('end')).toBe(false);
-
-    req.flush([]);
-  });
-});

apps/frontend/src/app/core/services/readings.service.ts

@@ -1,20 +0,0 @@
-import { Service, inject } from '@angular/core';
-import { HttpClient, HttpParams } from '@angular/common/http';
-import { environment } from '../../../environments/environment';
-import { Reading } from '../../shared/models/reading.model';
-
-@Service()
-export class ReadingsService {
-  private http = inject(HttpClient);
-
-  getHistory(siteId: string, start?: string, end?: string) {
-    let params = new HttpParams().set('site_id', siteId);
-    if (start) {
-      params = params.set('start', start);
-    }
-    if (end) {
-      params = params.set('end', end);
-    }
-    return this.http.get<Reading[]>(`${environment.apiUrl}/readings`, { params });
-  }
-}

apps/frontend/src/app/core/services/sites.service.spec.ts

@@ -38,50 +38,4 @@ describe('SitesService', () => {
 
     expect((result as { site_id: string }[])[0].site_id).toBe('SITE001');
   });
-
-  it('appelle le bon endpoint et retourne un site', () => {
-    let result: unknown;
-    service.getSite('SITE001').subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/sites/SITE001`);
-    expect(req.request.method).toBe('GET');
-
-    req.flush({
-      site_id: 'SITE001',
-      site_name: 'Site 1',
-      site_type: 'industriel',
-      location: 'Nantes',
-      capacity_kw: 500,
-      status: 'actif',
-    });
-
-    expect((result as { site_id: string }).site_id).toBe('SITE001');
-  });
-
-  it('appelle le bon endpoint et retourne la mesure courante du site', () => {
-    let result: unknown;
-    service.getCurrent('SITE001').subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/sites/SITE001/current`);
-    expect(req.request.method).toBe('GET');
-
-    req.flush({
-      timestamp: '2026-09-17T10:00:00Z',
-      site_id: 'SITE001',
-      site_type: 'industriel',
-      consumption_kw: 120,
-      consumption_kwh: null,
-      voltage_v: null,
-      current_a: null,
-      power_factor: null,
-      temperature_celsius: 22,
-      humidity_percent: 55,
-      null_reasons: ['electrical_sensor_failure'],
-      data_quality: 'partial',
-    });
-
-    expect((result as { null_reasons: string[] }).null_reasons).toEqual([
-      'electrical_sensor_failure',
-    ]);
-  });
 });

apps/frontend/src/app/core/services/sites.service.ts

@@ -2,7 +2,6 @@ import { Service, inject } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { environment } from '../../../environments/environment';
 import { Site } from '../../shared/models/site.model';
-import { SiteCurrent } from '../../shared/models/site-current.model';
 
 @Service()
 export class SitesService {
@@ -11,12 +10,4 @@ export class SitesService {
   getSites() {
     return this.http.get<Site[]>(`${environment.apiUrl}/sites`);
   }
-
-  getSite(siteId: string) {
-    return this.http.get<Site>(`${environment.apiUrl}/sites/${siteId}`);
-  }
-
-  getCurrent(siteId: string) {
-    return this.http.get<SiteCurrent>(`${environment.apiUrl}/sites/${siteId}/current`);
-  }
 }

apps/frontend/src/app/features/dashboard/dashboard.html

@@ -21,13 +21,7 @@
     </div>
   </header>
 
-  @if (statsError(); as message) {
+  @if (error(); as message) {
-    <ev-alert severity="danger" class="banner-error">{{ message }}</ev-alert>
-  }
-  @if (alertsError(); as message) {
-    <ev-alert severity="danger" class="banner-error">{{ message }}</ev-alert>
-  }
-  @if (predictionsError(); as message) {
     <ev-alert severity="danger" class="banner-error">{{ message }}</ev-alert>
   }
 
@@ -78,33 +72,4 @@
       </ul>
     </section>
   }
-
-  @if (predictions().length > 0) {
-    <section class="predictions-section">
-      <h2>Prévisions de consommation</h2>
-      <ul class="predictions-list">
-        @for (site of predictions(); track site.site_id) {
-          <li class="prediction-item">
-            <span class="prediction-item__site">{{ site.site_name }}</span>
-            @if (site.prediction; as prediction) {
-              @if (prediction.status === 'available') {
-                <span class="prediction-item__value">
-                  {{ prediction.predicted_value | number: '1.0-1' }} kWh
-                  <span class="prediction-item__target"
-                    >{{ prediction.target_at | date: "dd/MM 'à' HH:mm" }}</span
-                  >
-                </span>
-              } @else {
-                <ev-badge [tone]="badgeToneForPredictionStatus(prediction.status)">{{
-                  prediction.status === 'insufficient_data' ? 'Historique insuffisant' : 'Erreur'
-                }}</ev-badge>
-              }
-            } @else {
-              <ev-badge tone="neutral">Pas encore de prévision</ev-badge>
-            }
-          </li>
-        }
-      </ul>
-    </section>
-  }
 </div>

apps/frontend/src/app/features/dashboard/dashboard.scss

@@ -121,40 +121,3 @@ h2 {
 .alert-item__message {
   font-size: 0.9rem;
 }
-
-.predictions-list {
-  list-style: none;
-  margin: 0;
-  padding: 0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
-
-.prediction-item {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 0.75rem;
-  padding: 0.7rem 1rem;
-  border-radius: var(--radius-md);
-  background: var(--color-surface);
-  border: 1px solid var(--color-border-light);
-}
-
-.prediction-item__site {
-  font-size: 0.9rem;
-  font-weight: 600;
-}
-
-.prediction-item__value {
-  font-size: 0.9rem;
-  font-weight: 600;
-}
-
-.prediction-item__target {
-  margin-left: 0.35rem;
-  font-size: 0.8rem;
-  font-weight: 400;
-  color: var(--color-text-muted);
-}

apps/frontend/src/app/features/dashboard/dashboard.spec.ts

@@ -4,7 +4,6 @@ import { of, throwError } from 'rxjs';
 import { Dashboard } from './dashboard';
 import { StatsService } from '../../core/services/stats.service';
 import { AlertsService } from '../../core/services/alerts.service';
-import { PredictionsService } from '../../core/services/predictions.service';
 import {AuthService} from '../../core/services/auth.service';
 import {Router, provideRouter} from '@angular/router';
 
@@ -18,24 +17,18 @@ vi.mock('chart.js', () => {
   return { Chart: ChartMock, registerables: [] };
 });
 
-function predictionsMock(sites: unknown[] = []) {
-  return { getPredictions: vi.fn().mockReturnValue(of({ timestamp: '2026-09-18T09:00:00Z', sites })) };
-}
-
 describe('Dashboard', () => {
   afterEach(() => vi.useRealTimers());
 
-  it('charge les stats, les alertes et les prévisions au démarrage', async () => {
+  it('charge les stats et les alertes au démarrage', async () => {
     const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
     const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([{ alert_id: 'A1' }])) };
-    const predictions = predictionsMock([{ site_id: 'SITE001', site_name: 'Test', prediction: null }]);
 
     TestBed.configureTestingModule({
       imports: [Dashboard],
       providers: [
         { provide: StatsService, useValue: statsMock },
         { provide: AlertsService, useValue: alertsMock },
-        { provide: PredictionsService, useValue: predictions },
         provideRouter([]),
       ],
     });
@@ -49,12 +42,8 @@ describe('Dashboard', () => {
 
     expect(statsMock.getSummary).toHaveBeenCalled();
     expect(alertsMock.getAlerts).toHaveBeenCalled();
-    expect(predictions.getPredictions).toHaveBeenCalled();
     expect(fixture.componentInstance.alerts().length).toBe(1);
-    expect(fixture.componentInstance.predictions().length).toBe(1);
+    expect(fixture.componentInstance.error()).toBeNull();
-    expect(fixture.componentInstance.statsError()).toBeNull();
-    expect(fixture.componentInstance.alertsError()).toBeNull();
-    expect(fixture.componentInstance.predictionsError()).toBeNull();
   });
 
   it("signale l'indisponibilité puis repart au rafraîchissement suivant", () => {
@@ -72,7 +61,6 @@ describe('Dashboard', () => {
       providers: [
         { provide: StatsService, useValue: statsMock },
         { provide: AlertsService, useValue: alertsMock },
-        { provide: PredictionsService, useValue: predictionsMock() },
         provideRouter([]),
       ],
     });
@@ -82,13 +70,13 @@ describe('Dashboard', () => {
 
     vi.advanceTimersByTime(1);
     expect(statsMock.getSummary).toHaveBeenCalledTimes(1);
-    expect(fixture.componentInstance.statsError()).not.toBeNull();
+    expect(fixture.componentInstance.error()).not.toBeNull();
     expect(fixture.componentInstance.stats()).toBeNull();
 
     vi.advanceTimersByTime(10000);
     expect(statsMock.getSummary).toHaveBeenCalledTimes(2);
     expect(fixture.componentInstance.stats()).not.toBeNull();
-    expect(fixture.componentInstance.statsError()).toBeNull();
+    expect(fixture.componentInstance.error()).toBeNull();
   });
 
   it("n'interrompt pas la page quand le chargement des alertes échoue", () => {
@@ -100,7 +88,6 @@ describe('Dashboard', () => {
       providers: [
         { provide: StatsService, useValue: statsMock },
         { provide: AlertsService, useValue: alertsMock },
-        { provide: PredictionsService, useValue: predictionsMock() },
         provideRouter([]),
       ],
     });
@@ -109,62 +96,6 @@ describe('Dashboard', () => {
     fixture.detectChanges();
 
     expect(fixture.componentInstance.alerts().length).toBe(0);
-    expect(fixture.componentInstance.alertsError()).not.toBeNull();
-  });
-
-  it("n'interrompt pas la page quand le chargement des prévisions échoue", () => {
-    const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
-    const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([])) };
-    const predictions = {
-      getPredictions: vi.fn().mockReturnValue(throwError(() => new Error('nope'))),
-    };
-
-    TestBed.configureTestingModule({
-      imports: [Dashboard],
-      providers: [
-        { provide: StatsService, useValue: statsMock },
-        { provide: AlertsService, useValue: alertsMock },
-        { provide: PredictionsService, useValue: predictions },
-        provideRouter([]),
-      ],
-    });
-
-    const fixture = TestBed.createComponent(Dashboard);
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.predictions().length).toBe(0);
-    expect(fixture.componentInstance.predictionsError()).not.toBeNull();
-  });
-
-  it("un rafraîchissement de stats n'efface pas une erreur de prévisions en attente", () => {
-    vi.useFakeTimers();
-    const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
-    const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([])) };
-    const predictions = {
-      getPredictions: vi.fn().mockReturnValue(throwError(() => new Error('nope'))),
-    };
-
-    TestBed.configureTestingModule({
-      imports: [Dashboard],
-      providers: [
-        { provide: StatsService, useValue: statsMock },
-        { provide: AlertsService, useValue: alertsMock },
-        { provide: PredictionsService, useValue: predictions },
-        provideRouter([]),
-      ],
-    });
-
-    const fixture = TestBed.createComponent(Dashboard);
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.predictionsError()).not.toBeNull();
-
-    // Plusieurs cycles de `timer(0, 10_000)` (stats) plus tard, l'erreur des prévisions doit
-    // toujours être visible : rien ne vient la rafraîchir tant que la section n'est pas rechargée.
-    vi.advanceTimersByTime(30000);
-
-    expect(fixture.componentInstance.predictionsError()).not.toBeNull();
-    expect(fixture.componentInstance.statsError()).toBeNull();
   });
 
   it('appelle logout et redirige vers /login au clic sur le bouton de déconnexion', () => {
@@ -177,7 +108,6 @@ describe('Dashboard', () => {
     providers: [
       { provide: StatsService, useValue: statsMock },
       { provide: AlertsService, useValue: alertsMock },
-      { provide: PredictionsService, useValue: predictionsMock() },
       { provide: AuthService, useValue: authMock },
       provideRouter([]),
     ],
@@ -207,7 +137,6 @@ describe('Dashboard', () => {
     providers: [
       { provide: StatsService, useValue: statsMock },
       { provide: AlertsService, useValue: alertsMock },
-      { provide: PredictionsService, useValue: predictionsMock() },
       { provide: AuthService, useValue: authMock },
       provideRouter([]),
     ],
@@ -235,7 +164,6 @@ describe('Dashboard', () => {
       providers: [
         { provide: StatsService, useValue: statsMock },
         { provide: AlertsService, useValue: alertsMock },
-        { provide: PredictionsService, useValue: predictionsMock() },
         provideRouter([]),
       ],
     });
@@ -251,26 +179,4 @@ describe('Dashboard', () => {
       dashboard.badgeToneForSeverity('critical'),
     );
   });
-
-  it('distingue le ton des statuts de prévision', () => {
-    const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
-    const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([])) };
-
-    TestBed.configureTestingModule({
-      imports: [Dashboard],
-      providers: [
-        { provide: StatsService, useValue: statsMock },
-        { provide: AlertsService, useValue: alertsMock },
-        { provide: PredictionsService, useValue: predictionsMock() },
-        provideRouter([]),
-      ],
-    });
-
-    const fixture = TestBed.createComponent(Dashboard);
-    const dashboard = fixture.componentInstance;
-
-    expect(dashboard.badgeToneForPredictionStatus('available')).toBe('success');
-    expect(dashboard.badgeToneForPredictionStatus('insufficient_data')).toBe('warning');
-    expect(dashboard.badgeToneForPredictionStatus('error')).toBe('danger');
-  });
 });

apps/frontend/src/app/features/dashboard/dashboard.ts

@@ -1,17 +1,15 @@
-import { Component, OnInit, inject, signal, DestroyRef, WritableSignal } from '@angular/core';
+import { Component, OnInit, inject, signal, DestroyRef } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { timer, switchMap, catchError, EMPTY, Observable } from 'rxjs';
-import { DecimalPipe, DatePipe } from '@angular/common';
+import { DecimalPipe } from '@angular/common';
 import { Router, RouterLink } from '@angular/router';
 import { StatsService } from '../../core/services/stats.service';
 import { ConsumptionGauge } from '../../shared/components/consumption-gauge/consumption-gauge';
 import { SiteLoadChart } from '../../shared/components/site-load-chart/site-load-chart';
 import { AlertsService } from '../../core/services/alerts.service';
-import { PredictionsService } from '../../core/services/predictions.service';
 import { AuthService } from '../../core/services/auth.service';
 import { StatsSummary } from '../../shared/models/stats.model';
 import { Alert, AlertSeverity } from '../../shared/models/alert.model';
-import { PredictionStatus, SitePredictionSummary } from '../../shared/models/prediction.model';
 import { Card } from '../../shared/components/ui/card/card';
 import { Alert as EvAlert } from '../../shared/components/ui/alert/alert';
 import { Badge, BadgeTone } from '../../shared/components/ui/badge/badge';
@@ -29,21 +27,11 @@ const TON_PAR_SEVERITE: Record<AlertSeverity, BadgeTone> = {
   critical: 'critical',
 };
 
-// `error` n'a pas de précédent dans les fixtures ou l'API à ce jour, mais figure dans le
-// domaine du schéma backend (`ck_prediction_status`) : mieux vaut une couleur définie que
-// tomber sur `undefined` si ce statut apparaît un jour.
-const TON_PAR_STATUT_PREDICTION: Record<PredictionStatus, BadgeTone> = {
-  available: 'success',
-  insufficient_data: 'warning',
-  error: 'danger',
-};
-
 @Component({
   selector: 'app-dashboard',
   standalone: true,
   imports: [
     DecimalPipe,
-    DatePipe,
     RouterLink,
     ConsumptionGauge,
     SiteLoadChart,
@@ -59,52 +47,31 @@ const TON_PAR_STATUT_PREDICTION: Record<PredictionStatus, BadgeTone> = {
 export class Dashboard implements OnInit {
   private statsService = inject(StatsService);
   private alertsService = inject(AlertsService);
-  private predictionsService = inject(PredictionsService);
   private auth = inject(AuthService);
   private router = inject(Router);
   private destroyRef = inject(DestroyRef);
 
   stats = signal<StatsSummary | null>(null);
   alerts = signal<Alert[]>([]);
-  predictions = signal<SitePredictionSummary[]>([]);
+  error = signal<string | null>(null);
-
-  // Un signal par flux, pas un seul `error` partagé : sinon le tick suivant de `timer` (stats)
-  // efface silencieusement un message d'échec des prévisions ou des alertes après 10s au plus,
-  // sans retry ni indication pour l'utilisateur que la section correspondante est restée vide.
-  statsError = signal<string | null>(null);
-  alertsError = signal<string | null>(null);
-  predictionsError = signal<string | null>(null);
 
   ngOnInit(): void {
     this.alertsService
       .getAlerts()
-      .pipe(catchError(() => this.reportUnavailable(this.alertsError)))
+      .pipe(catchError(() => this.reportUnavailable()))
-      .subscribe((alerts) => {
+      .subscribe((alerts) => this.alerts.set(alerts));
-        this.alertsError.set(null);
-        this.alerts.set(alerts);
-      });
-
-    // Les prévisions viennent d'un scoring hors ligne, pas d'un calcul à la demande : un seul
-    // chargement au démarrage suffit, pas besoin du rafraîchissement périodique de `stats`.
-    this.predictionsService
-      .getPredictions()
-      .pipe(catchError(() => this.reportUnavailable(this.predictionsError)))
-      .subscribe((summary) => {
-        this.predictionsError.set(null);
-        this.predictions.set(summary.sites);
-      });
 
     // Piège : le catchError porte sur l'observable interne. Sur le flux externe il
     // terminerait le timer, et le rafraîchissement ne repartirait jamais.
     timer(0, REFRESH_INTERVAL_MS)
       .pipe(
         switchMap(() =>
-          this.statsService.getSummary().pipe(catchError(() => this.reportUnavailable(this.statsError))),
+          this.statsService.getSummary().pipe(catchError(() => this.reportUnavailable())),
         ),
         takeUntilDestroyed(this.destroyRef),
       )
       .subscribe((stats) => {
-        this.statsError.set(null);
+        this.error.set(null);
         this.stats.set(stats);
       });
   }
@@ -113,10 +80,6 @@ export class Dashboard implements OnInit {
     return TON_PAR_SEVERITE[severity];
   }
 
-  badgeToneForPredictionStatus(status: PredictionStatus): BadgeTone {
-    return TON_PAR_STATUT_PREDICTION[status];
-  }
-
   onLogout(): void {
     this.auth.logout().subscribe({
       next: () => this.router.navigate(['/login']),
@@ -128,8 +91,8 @@ export class Dashboard implements OnInit {
     });
   }
 
-  private reportUnavailable(target: WritableSignal<string | null>): Observable<never> {
+  private reportUnavailable(): Observable<never> {
-    target.set(UNAVAILABLE_MESSAGE);
+    this.error.set(UNAVAILABLE_MESSAGE);
     return EMPTY;
   }
 }

apps/frontend/src/app/features/sites/site-detail-placeholder/site-detail-placeholder.html

@@ -0,0 +1,19 @@
+<div class="site-detail-placeholder">
+  <nav class="ev-breadcrumb">
+    <a routerLink="/dashboard">Tableau de bord</a>
+    <span>/</span>
+    <a routerLink="/sites">Sites</a>
+  </nav>
+
+  <header class="site-detail-placeholder__header">
+    <a routerLink="/dashboard" class="ev-brand-link">
+      <ev-brand class="site-detail-placeholder__logo" />
+    </a>
+    <h1>Site {{ siteId() }}</h1>
+  </header>
+
+  <ev-card>
+    <p>Le détail de ce site est à venir (voir issue #51).</p>
+    <a routerLink="/sites" class="ev-link">Retour aux sites</a>
+  </ev-card>
+</div>

apps/frontend/src/app/features/sites/site-detail-placeholder/site-detail-placeholder.scss

@@ -0,0 +1,28 @@
+:host {
+  display: block;
+  color: var(--color-text);
+  padding: 2.5rem 2rem;
+  max-width: 640px;
+  margin: 0 auto;
+}
+
+.site-detail-placeholder__header {
+  display: flex;
+  align-items: center;
+  gap: 0.85rem;
+  margin-bottom: 1.5rem;
+
+  h1 {
+    margin: 0;
+    font-size: 1.5rem;
+    font-weight: 700;
+  }
+}
+
+.site-detail-placeholder__logo {
+  font-size: 1.3rem;
+}
+
+ev-card p {
+  margin: 0 0 0.75rem;
+}

apps/frontend/src/app/features/sites/site-detail-placeholder/site-detail-placeholder.spec.ts

@@ -0,0 +1,42 @@
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute, convertToParamMap, provideRouter } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import { SiteDetailPlaceholder } from './site-detail-placeholder';
+
+describe('SiteDetailPlaceholder', () => {
+  it("affiche l'identifiant du site depuis la route", () => {
+    const paramMap = new BehaviorSubject(convertToParamMap({ siteId: 'SITE001' }));
+    TestBed.configureTestingModule({
+      imports: [SiteDetailPlaceholder],
+      providers: [
+        provideRouter([]),
+        { provide: ActivatedRoute, useValue: { paramMap } },
+      ],
+    });
+
+    const fixture = TestBed.createComponent(SiteDetailPlaceholder);
+    fixture.detectChanges();
+
+    expect(fixture.nativeElement.textContent).toContain('SITE001');
+  });
+
+  it('met à jour l\'affichage quand le paramètre change sans recréer le composant', () => {
+    const paramMap = new BehaviorSubject(convertToParamMap({ siteId: 'SITE001' }));
+    TestBed.configureTestingModule({
+      imports: [SiteDetailPlaceholder],
+      providers: [
+        provideRouter([]),
+        { provide: ActivatedRoute, useValue: { paramMap } },
+      ],
+    });
+
+    const fixture = TestBed.createComponent(SiteDetailPlaceholder);
+    fixture.detectChanges();
+
+    paramMap.next(convertToParamMap({ siteId: 'SITE002' }));
+    fixture.detectChanges();
+
+    expect(fixture.nativeElement.textContent).toContain('SITE002');
+    expect(fixture.nativeElement.textContent).not.toContain('SITE001');
+  });
+});

apps/frontend/src/app/features/sites/site-detail-placeholder/site-detail-placeholder.ts

@@ -0,0 +1,19 @@
+import { Component, inject } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { ActivatedRoute, RouterLink } from '@angular/router';
+import { map } from 'rxjs';
+import { Card } from '../../../shared/components/ui/card/card';
+import { Brand } from '../../../shared/components/ui/brand/brand';
+
+@Component({
+  selector: 'app-site-detail-placeholder',
+  standalone: true,
+  imports: [RouterLink, Card, Brand],
+  templateUrl: './site-detail-placeholder.html',
+  styleUrl: './site-detail-placeholder.scss',
+})
+export class SiteDetailPlaceholder {
+  private route = inject(ActivatedRoute);
+
+  siteId = toSignal(this.route.paramMap.pipe(map((params) => params.get('siteId'))));
+}

apps/frontend/src/app/features/sites/site-detail/site-detail.html

@@ -1,85 +0,0 @@
-<div class="site-detail">
-  <nav class="ev-breadcrumb">
-    <a routerLink="/dashboard">Tableau de bord</a>
-    <span>/</span>
-    <a routerLink="/sites">Sites</a>
-  </nav>
-
-  <header class="site-detail__header">
-    <a routerLink="/dashboard" class="ev-brand-link">
-      <ev-brand class="site-detail__logo" />
-    </a>
-    <div>
-      <h1>{{ site()?.site_name ?? siteId() }}</h1>
-      @if (site(); as s) {
-        <p class="site-detail__subtitle">
-          {{ s.site_type }} · {{ s.location || 'Localisation inconnue' }}
-        </p>
-      }
-    </div>
-    <div class="site-detail__badges">
-      @if (site(); as s) {
-        <ev-badge [tone]="badgeToneForStatus(s.status)">{{ s.status ?? '-' }}</ev-badge>
-      }
-      @if (hasMeasurement() && qualityLabel(); as label) {
-        <ev-badge [tone]="qualityTone()">{{ label }}</ev-badge>
-      }
-    </div>
-  </header>
-
-  @if (error(); as message) {
-    <ev-alert severity="danger" class="banner-error">{{ message }}</ev-alert>
-  }
-
-  @if (site(); as s) {
-    @if (hasMeasurement()) {
-      <section class="overview">
-        <ev-card class="card card--gauge">
-          <span class="card__label">Consommation vs capacité</span>
-          @let consumption = consumptionKw();
-          @if (consumption !== null) {
-            <app-consumption-gauge [consumption]="consumption" [capacity]="s.capacity_kw ?? 0" />
-            <span class="card__value">
-              {{ consumptionLabel() }} / {{ s.capacity_kw ?? '-' }} kW
-            </span>
-          } @else {
-            <p class="card__unavailable">
-              Consommation indisponible
-              <span class="metric__reason">({{ consumptionReason() }})</span>
-            </p>
-          }
-        </ev-card>
-
-        <ev-card class="metrics-card">
-          <span class="card__label">Mesure instantanée</span>
-          <dl class="metrics-grid">
-            @for (metric of metrics(); track metric.key) {
-              <div class="metric">
-                <dt>{{ metric.label }}</dt>
-                @if (metric.value !== null) {
-                  <dd>{{ metric.value }}</dd>
-                } @else {
-                  <dd class="metric__unavailable">
-                    Indisponible
-                    <span class="metric__reason">({{ metric.reason }})</span>
-                  </dd>
-                }
-              </div>
-            }
-          </dl>
-        </ev-card>
-      </section>
-
-      @if (history().length > 0) {
-        <section class="chart-section">
-          <h2>Historique de consommation</h2>
-          <app-reading-history-chart [readings]="history()" />
-        </section>
-      }
-    } @else {
-      <ev-alert severity="warning" class="banner-empty">{{ noMeasurementMessage }}</ev-alert>
-    }
-  }
-
-  <a routerLink="/sites" class="ev-link">Retour aux sites</a>
-</div>

apps/frontend/src/app/features/sites/site-detail/site-detail.scss

@@ -1,119 +0,0 @@
-:host {
-  display: block;
-  color: var(--color-text);
-  padding: 2.5rem 2rem;
-  max-width: 1100px;
-  margin: 0 auto;
-}
-
-.site-detail__header {
-  display: flex;
-  align-items: center;
-  gap: 0.85rem;
-  margin-bottom: 2rem;
-
-  h1 {
-    margin: 0;
-    font-size: 1.75rem;
-    font-weight: 700;
-  }
-}
-
-.site-detail__logo {
-  font-size: 1.3rem;
-}
-
-.site-detail__subtitle {
-  margin: 0.25rem 0 0;
-  color: var(--color-text-muted);
-}
-
-.site-detail__badges {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  margin-left: auto;
-}
-
-.banner-error {
-  display: block;
-  margin: 0 0 1.5rem;
-}
-
-.banner-empty {
-  display: block;
-  margin: 0 0 1.5rem;
-}
-
-.overview {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
-  gap: 1rem;
-  margin-bottom: 2.5rem;
-}
-
-.card {
-  padding: 1.25rem;
-  gap: 0.35rem;
-}
-
-.card--gauge {
-  align-items: center;
-  text-align: center;
-}
-
-.card__label {
-  font-size: 0.8rem;
-  color: var(--color-text-muted);
-  text-transform: uppercase;
-  letter-spacing: 0.02em;
-}
-
-.card__value {
-  font-size: 1.6rem;
-  font-weight: 700;
-}
-
-.card__unavailable {
-  color: var(--color-text-muted);
-  margin: 0;
-}
-
-.metrics-grid {
-  display: grid;
-  grid-template-columns: repeat(2, 1fr);
-  gap: 0.75rem 1.5rem;
-  margin: 0.5rem 0 0;
-}
-
-.metric {
-  dt {
-    font-size: 0.75rem;
-    color: var(--color-text-muted);
-  }
-
-  dd {
-    margin: 0;
-    font-size: 1.05rem;
-    font-weight: 600;
-  }
-}
-
-.metric__unavailable {
-  color: var(--color-text-muted);
-  font-weight: 400;
-}
-
-.metric__reason {
-  font-size: 0.8rem;
-}
-
-h2 {
-  font-size: 1.1rem;
-  font-weight: 600;
-  margin: 0 0 1rem;
-}
-
-.chart-section {
-  margin-bottom: 2rem;
-}

apps/frontend/src/app/features/sites/site-detail/site-detail.spec.ts

@@ -1,281 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { ActivatedRoute, convertToParamMap, provideRouter } from '@angular/router';
-import { vi } from 'vitest';
-import { BehaviorSubject, of, throwError } from 'rxjs';
-import { SiteDetail } from './site-detail';
-import { SitesService } from '../../../core/services/sites.service';
-import { ReadingsService } from '../../../core/services/readings.service';
-
-const SITE = {
-  site_id: 'SITE001',
-  site_name: 'Site 1',
-  site_type: 'industriel',
-  location: 'Nantes',
-  capacity_kw: 500,
-  status: 'actif',
-};
-
-const CURRENT_COMPLET = {
-  timestamp: '2026-09-17T10:00:00Z',
-  site_id: 'SITE001',
-  site_type: 'industriel',
-  consumption_kw: 120,
-  consumption_kwh: null,
-  voltage_v: 230,
-  current_a: 12,
-  power_factor: 0.95,
-  temperature_celsius: 22,
-  humidity_percent: 55,
-  null_reasons: [] as string[],
-  data_quality: 'good' as const,
-};
-
-const SANS_MESURE = {
-  ...CURRENT_COMPLET,
-  timestamp: null,
-  consumption_kw: null,
-  voltage_v: null,
-  current_a: null,
-  power_factor: null,
-  temperature_celsius: null,
-  humidity_percent: null,
-  data_quality: 'critical' as const,
-};
-
-const LECTURE = {
-  reading_id: 1,
-  site_id: 'SITE001',
-  timestamp: '2026-09-17T09:00:00Z',
-  source: 'api_history' as const,
-  consumption_kw: 118,
-  consumption_kwh: null,
-  consumption_euros: null,
-  voltage_v: 230,
-  current_a: 12,
-  power_factor: 0.95,
-  temperature_celsius: 22,
-  humidity_percent: 55,
-  solar_irradiance_wm2: null,
-  is_working_hours: true,
-  data_quality: 'good' as const,
-  null_reasons: null,
-  imputed_values: null,
-  imputation_method: null,
-};
-
-function setup(
-  siteId: string,
-  sitesMock: Partial<SitesService>,
-  readingsMock: Partial<ReadingsService>,
-) {
-  const paramMap = new BehaviorSubject(convertToParamMap({ siteId }));
-  TestBed.configureTestingModule({
-    imports: [SiteDetail],
-    providers: [
-      provideRouter([]),
-      { provide: ActivatedRoute, useValue: { paramMap } },
-      { provide: SitesService, useValue: sitesMock },
-      { provide: ReadingsService, useValue: readingsMock },
-    ],
-  });
-  return { fixture: TestBed.createComponent(SiteDetail), paramMap };
-}
-
-describe('SiteDetail', () => {
-  it('charge le site, la mesure courante et son historique au démarrage', () => {
-    const { fixture } = setup(
-      'SITE001',
-      {
-        getSite: vi.fn().mockReturnValue(of(SITE)),
-        getCurrent: vi.fn().mockReturnValue(of(CURRENT_COMPLET)),
-      },
-      { getHistory: vi.fn().mockReturnValue(of([LECTURE])) },
-    );
-
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.site()?.site_id).toBe('SITE001');
-    expect(fixture.componentInstance.current()?.consumption_kw).toBe(120);
-    expect(fixture.componentInstance.history().length).toBe(1);
-    expect(fixture.componentInstance.error()).toBeNull();
-  });
-
-  it("signale l'indisponibilité quand un des appels échoue", () => {
-    const { fixture } = setup(
-      'SITE001',
-      {
-        getSite: vi.fn().mockReturnValue(throwError(() => new Error('nope'))),
-        getCurrent: vi.fn().mockReturnValue(of(CURRENT_COMPLET)),
-      },
-      { getHistory: vi.fn().mockReturnValue(of([])) },
-    );
-
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.error()).not.toBeNull();
-    expect(fixture.componentInstance.site()).toBeNull();
-  });
-
-  it('efface les données du site précédent quand le chargement du suivant échoue', () => {
-    const getSite = vi
-      .fn()
-      .mockReturnValueOnce(of(SITE))
-      .mockReturnValueOnce(throwError(() => new Error('404')));
-    const { fixture, paramMap } = setup(
-      'SITE001',
-      { getSite, getCurrent: vi.fn().mockReturnValue(of(CURRENT_COMPLET)) },
-      { getHistory: vi.fn().mockReturnValue(of([LECTURE])) },
-    );
-
-    fixture.detectChanges();
-    expect(fixture.componentInstance.site()?.site_id).toBe('SITE001');
-
-    paramMap.next(convertToParamMap({ siteId: 'SITE002' }));
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.error()).not.toBeNull();
-    expect(fixture.componentInstance.site()).toBeNull();
-    expect(fixture.componentInstance.current()).toBeNull();
-    expect(fixture.componentInstance.history()).toEqual([]);
-    expect(fixture.nativeElement.textContent).not.toContain('Site 1');
-  });
-
-  it('interroge le site et sa mesure courante en parallèle', () => {
-    const getSite = vi.fn().mockReturnValue(of(SITE));
-    const getCurrent = vi.fn().mockReturnValue(of(CURRENT_COMPLET));
-    const { fixture } = setup(
-      'SITE001',
-      { getSite, getCurrent },
-      { getHistory: vi.fn().mockReturnValue(of([])) },
-    );
-
-    fixture.detectChanges();
-
-    expect(getSite).toHaveBeenCalledWith('SITE001');
-    expect(getCurrent).toHaveBeenCalledWith('SITE001');
-  });
-
-  it('signale la panne du capteur de consommation au lieu de tracer une jauge à zéro', () => {
-    const sansConsommation = {
-      ...CURRENT_COMPLET,
-      consumption_kw: null,
-      null_reasons: ['consumption_sensor_failure'],
-      data_quality: 'partial' as const,
-    };
-    const { fixture } = setup(
-      'SITE001',
-      {
-        getSite: vi.fn().mockReturnValue(of(SITE)),
-        getCurrent: vi.fn().mockReturnValue(of(sansConsommation)),
-      },
-      { getHistory: vi.fn().mockReturnValue(of([LECTURE])) },
-    );
-
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.consumptionKw()).toBeNull();
-    expect(fixture.componentInstance.consumptionReason()).toBe('capteur de consommation en panne');
-    expect(fixture.nativeElement.querySelector('app-consumption-gauge')).toBeNull();
-    expect(fixture.nativeElement.textContent).toContain('Consommation indisponible');
-  });
-
-  it('trace la jauge pour une consommation nulle réellement mesurée', () => {
-    const { fixture } = setup(
-      'SITE001',
-      {
-        getSite: vi.fn().mockReturnValue(of(SITE)),
-        getCurrent: vi.fn().mockReturnValue(of({ ...CURRENT_COMPLET, consumption_kw: 0 })),
-      },
-      { getHistory: vi.fn().mockReturnValue(of([LECTURE])) },
-    );
-
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.consumptionLabel()).toBe('0.0 kW');
-    expect(fixture.nativeElement.querySelector('app-consumption-gauge')).not.toBeNull();
-    expect(fixture.nativeElement.textContent).not.toContain('Consommation indisponible');
-  });
-
-  it('affiche explicitement les champs null avec leur raison plutôt que de les masquer', () => {
-    const partielle = {
-      ...CURRENT_COMPLET,
-      voltage_v: null,
-      current_a: null,
-      power_factor: null,
-      null_reasons: ['electrical_sensor_failure'],
-      data_quality: 'partial' as const,
-    };
-    const { fixture } = setup(
-      'SITE001',
-      {
-        getSite: vi.fn().mockReturnValue(of(SITE)),
-        getCurrent: vi.fn().mockReturnValue(of(partielle)),
-      },
-      { getHistory: vi.fn().mockReturnValue(of([LECTURE])) },
-    );
-
-    fixture.detectChanges();
-
-    const tension = fixture.componentInstance.metrics().find((m) => m.key === 'voltage_v');
-    expect(tension?.value).toBeNull();
-    expect(tension?.reason).toBe('capteur électrique en panne');
-
-    const texte = fixture.nativeElement.textContent;
-    expect(texte).toContain('Indisponible');
-    expect(texte).toContain('capteur électrique en panne');
-    expect(texte).toContain('Données partielles');
-  });
-
-  it('recharge les données quand le paramètre de route siteId change', () => {
-    const getSite = vi.fn().mockReturnValue(of(SITE));
-    const { fixture, paramMap } = setup(
-      'SITE001',
-      { getSite, getCurrent: vi.fn().mockReturnValue(of(CURRENT_COMPLET)) },
-      { getHistory: vi.fn().mockReturnValue(of([])) },
-    );
-
-    fixture.detectChanges();
-    paramMap.next(convertToParamMap({ siteId: 'SITE002' }));
-    fixture.detectChanges();
-
-    expect(getSite).toHaveBeenCalledWith('SITE002');
-  });
-
-  it("ancre la fenêtre d'historique sur la dernière mesure connue plutôt que sur l'horloge", () => {
-    const getHistory = vi.fn().mockReturnValue(of([]));
-    const { fixture } = setup(
-      'SITE001',
-      {
-        getSite: vi.fn().mockReturnValue(of(SITE)),
-        getCurrent: vi.fn().mockReturnValue(of(CURRENT_COMPLET)),
-      },
-      { getHistory },
-    );
-
-    fixture.detectChanges();
-
-    expect(getHistory).toHaveBeenCalledWith(
-      'SITE001',
-      '2026-09-16T10:00:00.000Z',
-      '2026-09-17T10:00:00Z',
-    );
-  });
-
-  it("annonce l'absence de mesure sans interroger l'historique quand timestamp est null", () => {
-    const getHistory = vi.fn().mockReturnValue(of([]));
-    const { fixture } = setup(
-      'SITE001',
-      {
-        getSite: vi.fn().mockReturnValue(of(SITE)),
-        getCurrent: vi.fn().mockReturnValue(of(SANS_MESURE)),
-      },
-      { getHistory },
-    );
-
-    fixture.detectChanges();
-
-    expect(getHistory).not.toHaveBeenCalled();
-    expect(fixture.componentInstance.hasMeasurement()).toBe(false);
-    expect(fixture.nativeElement.textContent).toContain('Aucune mesure remontée pour ce site.');
-  });
-});

apps/frontend/src/app/features/sites/site-detail/site-detail.ts

@@ -1,213 +0,0 @@
-import { Component, DestroyRef, computed, inject, signal } from '@angular/core';
-import { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';
-import { ActivatedRoute, RouterLink } from '@angular/router';
-import { catchError, EMPTY, filter, forkJoin, map, Observable, of, switchMap } from 'rxjs';
-import { SitesService } from '../../../core/services/sites.service';
-import { ReadingsService } from '../../../core/services/readings.service';
-import { Site } from '../../../shared/models/site.model';
-import { Reading, ReadingDataQuality } from '../../../shared/models/reading.model';
-import { SiteCurrent } from '../../../shared/models/site-current.model';
-import { Card } from '../../../shared/components/ui/card/card';
-import { Alert } from '../../../shared/components/ui/alert/alert';
-import { Badge, BadgeTone } from '../../../shared/components/ui/badge/badge';
-import { Brand } from '../../../shared/components/ui/brand/brand';
-import { ConsumptionGauge } from '../../../shared/components/consumption-gauge/consumption-gauge';
-import { ReadingHistoryChart } from '../../../shared/components/reading-history-chart/reading-history-chart';
-
-const UNAVAILABLE_MESSAGE = 'Détail du site indisponible, réessayez plus tard.';
-const NO_MEASUREMENT_MESSAGE = 'Aucune mesure remontée pour ce site.';
-const HISTORY_WINDOW_MS = 24 * 60 * 60 * 1000;
-
-const TON_PAR_STATUT: Record<string, BadgeTone> = {
-  actif: 'success',
-  maintenance: 'warning',
-  hors_service: 'danger',
-};
-
-const TON_PAR_QUALITE: Record<ReadingDataQuality, BadgeTone> = {
-  good: 'success',
-  partial: 'warning',
-  degraded: 'danger',
-  critical: 'critical',
-};
-
-const LIBELLE_PAR_QUALITE: Record<ReadingDataQuality, string> = {
-  good: 'Données complètes',
-  partial: 'Données partielles',
-  degraded: 'Données dégradées',
-  critical: 'Données critiques',
-};
-
-type MetricKey =
-  | 'consumption_kw'
-  | 'voltage_v'
-  | 'current_a'
-  | 'power_factor'
-  | 'temperature_celsius'
-  | 'humidity_percent';
-
-interface MetricDef {
-  key: MetricKey;
-  label: string;
-  format: (value: number) => string;
-}
-
-const CONSUMPTION_DEF: MetricDef = {
-  key: 'consumption_kw',
-  label: 'Consommation',
-  format: (v) => `${v.toFixed(1)} kW`,
-};
-
-const METRIC_DEFS: MetricDef[] = [
-  CONSUMPTION_DEF,
-  { key: 'voltage_v', label: 'Tension', format: (v) => `${v.toFixed(1)} V` },
-  { key: 'current_a', label: 'Courant', format: (v) => `${v.toFixed(1)} A` },
-  { key: 'power_factor', label: 'Cos φ', format: (v) => v.toFixed(2) },
-  { key: 'temperature_celsius', label: 'Température', format: (v) => `${v.toFixed(1)} °C` },
-  { key: 'humidity_percent', label: 'Humidité', format: (v) => `${v.toFixed(0)} %` },
-];
-
-// Contrainte : miroir de RAISON_VERS_CAPTEUR et CHAMPS_PAR_CAPTEUR (backend, services/sensor.py) ;
-// `null_reasons` porte le code de panne du capteur, jamais le nom du champ resté vide.
-const RAISONS_PAR_CHAMP: Record<MetricKey, string[]> = {
-  consumption_kw: ['consumption_sensor_failure', 'network_loss'],
-  voltage_v: ['electrical_sensor_failure', 'network_loss'],
-  current_a: ['electrical_sensor_failure', 'network_loss'],
-  power_factor: ['electrical_sensor_failure', 'network_loss'],
-  temperature_celsius: ['temperature_sensor_failure', 'network_loss'],
-  humidity_percent: ['humidity_sensor_failure', 'network_loss'],
-};
-
-const LIBELLE_PAR_RAISON: Record<string, string> = {
-  consumption_sensor_failure: 'capteur de consommation en panne',
-  electrical_sensor_failure: 'capteur électrique en panne',
-  temperature_sensor_failure: 'capteur de température en panne',
-  humidity_sensor_failure: "capteur d'humidité en panne",
-  network_loss: 'perte réseau',
-};
-
-export interface MetricView {
-  key: MetricKey;
-  label: string;
-  value: string | null;
-  reason: string;
-}
-
-@Component({
-  selector: 'app-site-detail',
-  standalone: true,
-  imports: [RouterLink, Card, Alert, Badge, Brand, ConsumptionGauge, ReadingHistoryChart],
-  templateUrl: './site-detail.html',
-  styleUrl: './site-detail.scss',
-})
-export class SiteDetail {
-  private route = inject(ActivatedRoute);
-  private sitesService = inject(SitesService);
-  private readingsService = inject(ReadingsService);
-  private destroyRef = inject(DestroyRef);
-
-  readonly noMeasurementMessage = NO_MEASUREMENT_MESSAGE;
-
-  siteId = toSignal(this.route.paramMap.pipe(map((params) => params.get('siteId') ?? '')));
-
-  site = signal<Site | null>(null);
-  current = signal<SiteCurrent | null>(null);
-  history = signal<Reading[]>([]);
-  error = signal<string | null>(null);
-
-  hasMeasurement = computed(() => this.current()?.timestamp != null);
-
-  consumptionKw = computed(() => this.current()?.consumption_kw ?? null);
-
-  consumptionLabel = computed(() => {
-    const kw = this.consumptionKw();
-    return kw != null ? CONSUMPTION_DEF.format(kw) : null;
-  });
-
-  consumptionReason = computed(() => this.reasonFor('consumption_kw', this.current()));
-
-  qualityLabel = computed(() => {
-    const quality = this.current()?.data_quality;
-    return quality ? LIBELLE_PAR_QUALITE[quality] : null;
-  });
-
-  qualityTone = computed<BadgeTone>(() => {
-    const quality = this.current()?.data_quality;
-    return quality ? TON_PAR_QUALITE[quality] : 'neutral';
-  });
-
-  metrics = computed<MetricView[]>(() => {
-    const current = this.current();
-    return METRIC_DEFS.map((def) => {
-      const valeur = current ? current[def.key] : null;
-      return {
-        key: def.key,
-        label: def.label,
-        value: valeur != null ? def.format(valeur) : null,
-        reason: valeur == null ? this.reasonFor(def.key, current) : '',
-      };
-    });
-  });
-
-  constructor() {
-    toObservable(this.siteId)
-      .pipe(
-        filter((siteId): siteId is string => !!siteId),
-        // Piège : switchMap sur le flux externe annule le chargement en cours dès qu'un
-        // nouveau siteId arrive, sinon une réponse en retard peut écraser le site affiché.
-        switchMap((siteId) => this.load(siteId)),
-        takeUntilDestroyed(this.destroyRef),
-      )
-      .subscribe((result) => {
-        this.error.set(null);
-        this.site.set(result.site);
-        this.current.set(result.current);
-        this.history.set(result.history);
-      });
-  }
-
-  badgeToneForStatus(status: string | null): BadgeTone {
-    return status ? (TON_PAR_STATUT[status] ?? 'neutral') : 'neutral';
-  }
-
-  private load(siteId: string) {
-    return forkJoin({
-      site: this.sitesService.getSite(siteId),
-      current: this.sitesService.getCurrent(siteId),
-    }).pipe(
-      switchMap(({ site, current }) =>
-        this.loadHistory(siteId, current).pipe(map((history) => ({ site, current, history }))),
-      ),
-      catchError(() => this.reportUnavailable()),
-    );
-  }
-
-  private loadHistory(siteId: string, current: SiteCurrent): Observable<Reading[]> {
-    // Piège : le jeu de données s'arrête bien avant « maintenant » ; ancrer la fenêtre sur la
-    // dernière mesure connue plutôt que sur l'horloge évite un historique systématiquement vide.
-    const end = current.timestamp;
-    if (end === null) {
-      return of([]);
-    }
-    const start = new Date(new Date(end).getTime() - HISTORY_WINDOW_MS).toISOString();
-    return this.readingsService.getHistory(siteId, start, end);
-  }
-
-  private reasonFor(field: MetricKey, current: SiteCurrent | null): string {
-    const raisons = RAISONS_PAR_CHAMP[field];
-    const trouvees = (current?.null_reasons ?? [])
-      .filter((raison) => raisons.includes(raison))
-      .map((raison) => LIBELLE_PAR_RAISON[raison] ?? raison);
-    return trouvees.length > 0 ? trouvees.join(', ') : 'cause inconnue';
-  }
-
-  // Piège : vider les signaux avec l'erreur, sinon la page garde le site précédemment chargé
-  // sous le bandeau et laisse lire les chiffres de A en croyant regarder B.
-  private reportUnavailable(): Observable<never> {
-    this.error.set(UNAVAILABLE_MESSAGE);
-    this.site.set(null);
-    this.current.set(null);
-    this.history.set([]);
-    return EMPTY;
-  }
-}

apps/frontend/src/app/shared/components/reading-history-chart/reading-history-chart.html

@@ -1 +0,0 @@
-<canvas #canvas></canvas>

apps/frontend/src/app/shared/components/reading-history-chart/reading-history-chart.scss

@@ -1,4 +0,0 @@
-:host {
-  display: block;
-  height: 260px;
-}

apps/frontend/src/app/shared/components/reading-history-chart/reading-history-chart.spec.ts

@@ -1,101 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { vi } from 'vitest';
-import { Chart } from 'chart.js';
-import { ReadingHistoryChart } from './reading-history-chart';
-
-vi.mock('chart.js', () => {
-  class ChartMock {
-    static instances: ChartMock[] = [];
-    static register = vi.fn();
-    update = vi.fn();
-    destroy = vi.fn();
-    data: { labels?: unknown[]; datasets: Record<string, unknown>[] } = { datasets: [{}] };
-    constructor(_canvas: unknown, config?: { data?: ChartMock['data'] }) {
-      if (config?.data) {
-        this.data = config.data;
-      }
-      ChartMock.instances.push(this);
-    }
-  }
-  return { Chart: ChartMock, registerables: [] };
-});
-
-type ChartDouble = {
-  destroy: ReturnType<typeof vi.fn>;
-  data: { labels?: unknown[]; datasets: Record<string, unknown>[] };
-};
-
-function lastChart(): ChartDouble | undefined {
-  return (Chart as unknown as { instances: ChartDouble[] }).instances.at(-1);
-}
-
-const READING = {
-  reading_id: 1,
-  site_id: 'S1',
-  timestamp: '2026-09-17T10:00:00Z',
-  source: 'api_history' as const,
-  consumption_kw: 42,
-  consumption_kwh: null,
-  consumption_euros: null,
-  voltage_v: null,
-  current_a: null,
-  power_factor: null,
-  temperature_celsius: null,
-  humidity_percent: null,
-  solar_irradiance_wm2: null,
-  is_working_hours: null,
-  data_quality: 'good' as const,
-  null_reasons: null,
-  imputed_values: null,
-  imputation_method: null,
-};
-
-describe('ReadingHistoryChart', () => {
-  it('se crée sans erreur avec une liste de lectures valide', () => {
-    TestBed.configureTestingModule({ imports: [ReadingHistoryChart] });
-    const fixture = TestBed.createComponent(ReadingHistoryChart);
-    fixture.componentRef.setInput('readings', [READING]);
-    expect(() => fixture.detectChanges()).not.toThrow();
-  });
-
-  it('met à jour le graphique quand les lectures changent après initialisation', () => {
-    TestBed.configureTestingModule({ imports: [ReadingHistoryChart] });
-    const fixture = TestBed.createComponent(ReadingHistoryChart);
-    fixture.componentRef.setInput('readings', [READING]);
-    fixture.detectChanges();
-
-    fixture.componentRef.setInput('readings', [
-      { ...READING, reading_id: 2, consumption_kw: 60, data_quality: 'critical' as const },
-    ]);
-    fixture.detectChanges();
-
-    expect(() => fixture.detectChanges()).not.toThrow();
-  });
-
-  it("trace du plus ancien au plus récent, quel que soit l'ordre reçu de l'API", () => {
-    TestBed.configureTestingModule({ imports: [ReadingHistoryChart] });
-    const fixture = TestBed.createComponent(ReadingHistoryChart);
-    // L'API trie en timestamp décroissant : le composant doit rétablir la chronologie.
-    fixture.componentRef.setInput('readings', [
-      { ...READING, reading_id: 2, timestamp: '2026-09-17T11:00:00Z', consumption_kw: 60 },
-      { ...READING, reading_id: 1, timestamp: '2026-09-17T10:00:00Z', consumption_kw: 42 },
-    ]);
-    fixture.detectChanges();
-
-    const chart = lastChart();
-    expect(chart?.data.labels).toEqual(['2026-09-17T10:00:00Z', '2026-09-17T11:00:00Z']);
-    expect(chart?.data.datasets[0]['data']).toEqual([42, 60]);
-  });
-
-  it('détruit le graphique quand le composant est détruit', () => {
-    TestBed.configureTestingModule({ imports: [ReadingHistoryChart] });
-    const fixture = TestBed.createComponent(ReadingHistoryChart);
-    fixture.componentRef.setInput('readings', [READING]);
-    fixture.detectChanges();
-
-    const chart = lastChart();
-    fixture.destroy();
-
-    expect(chart?.destroy).toHaveBeenCalledTimes(1);
-  });
-});

apps/frontend/src/app/shared/components/reading-history-chart/reading-history-chart.ts

@@ -1,95 +0,0 @@
-import {
-  Component,
-  ElementRef,
-  ViewChild,
-  input,
-  effect,
-  AfterViewInit,
-  OnDestroy,
-} from '@angular/core';
-import { Chart, registerables } from 'chart.js';
-import { Reading, ReadingDataQuality } from '../../models/reading.model';
-
-Chart.register(...registerables);
-
-const QUALITY_COLORS: Record<ReadingDataQuality, string> = {
-  good: '#3b82f6',
-  partial: '#f9a825',
-  degraded: '#ef6c00',
-  critical: '#c62828',
-};
-const UNKNOWN_QUALITY_COLOR = '#9ca3af';
-
-interface ChartSeries {
-  labels: string[];
-  values: number[];
-  colors: string[];
-}
-
-// Piège : l'API renvoie les lectures du plus récent au plus ancien (ReadingRepository.list_history
-// trie en timestamp desc) ; sans ce tri l'axe des abscisses se lirait à rebours.
-function toSeries(readings: Reading[]): ChartSeries {
-  const ordered = [...readings].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
-  return {
-    labels: ordered.map((r) => r.timestamp),
-    values: ordered.map((r) => r.consumption_kw ?? 0),
-    colors: ordered.map((r) =>
-      r.data_quality ? QUALITY_COLORS[r.data_quality] : UNKNOWN_QUALITY_COLOR,
-    ),
-  };
-}
-
-@Component({
-  selector: 'app-reading-history-chart',
-  standalone: true,
-  templateUrl: './reading-history-chart.html',
-  styleUrl: './reading-history-chart.scss',
-})
-export class ReadingHistoryChart implements AfterViewInit, OnDestroy {
-  readings = input.required<Reading[]>();
-
-  @ViewChild('canvas') private canvasRef!: ElementRef<HTMLCanvasElement>;
-  private chart?: Chart<'line'>;
-
-  constructor() {
-    effect(() => {
-      const series = toSeries(this.readings());
-      if (this.chart) {
-        this.chart.data.labels = series.labels;
-        this.chart.data.datasets[0].data = series.values;
-        this.chart.data.datasets[0].pointBackgroundColor = series.colors;
-        this.chart.update('none');
-      }
-    });
-  }
-
-  ngAfterViewInit(): void {
-    const series = toSeries(this.readings());
-    this.chart = new Chart(this.canvasRef.nativeElement, {
-      type: 'line',
-      data: {
-        labels: series.labels,
-        datasets: [
-          {
-            data: series.values,
-            borderColor: '#3b82f6',
-            pointBackgroundColor: series.colors,
-            tension: 0.25,
-          },
-        ],
-      },
-      options: {
-        responsive: true,
-        maintainAspectRatio: false,
-        plugins: { legend: { display: false } },
-        scales: {
-          y: { beginAtZero: true, title: { display: true, text: 'Consommation (kW)' } },
-        },
-      },
-    });
-  }
-
-  ngOnDestroy(): void {
-    this.chart?.destroy();
-  }
-}

apps/frontend/src/app/shared/models/prediction.model.ts

@@ -1,24 +0,0 @@
-export type PredictionStatus = 'available' | 'insufficient_data' | 'error';
-export type PredictionTargetMetric = 'consumption_kwh' | 'consumption_kw';
-
-export interface SitePrediction {
-  target_at: string;
-  target_metric: PredictionTargetMetric;
-  period_minutes: number | null;
-  predicted_value: number | null;
-  status: PredictionStatus;
-  failure_reason: string | null;
-  model_reference: string;
-  created_at: string;
-}
-
-export interface SitePredictionSummary {
-  site_id: string;
-  site_name: string;
-  prediction: SitePrediction | null;
-}
-
-export interface PredictionSummary {
-  timestamp: string;
-  sites: SitePredictionSummary[];
-}

apps/frontend/src/app/shared/models/reading.model.ts

@@ -1,23 +0,0 @@
-export type ReadingSource = 'csv' | 'api_current' | 'api_history';
-export type ReadingDataQuality = 'good' | 'partial' | 'degraded' | 'critical';
-
-export interface Reading {
-  reading_id: number;
-  site_id: string;
-  timestamp: string;
-  source: ReadingSource;
-  consumption_kw: number | null;
-  consumption_kwh: number | null;
-  consumption_euros: string | null;
-  voltage_v: number | null;
-  current_a: number | null;
-  power_factor: number | null;
-  temperature_celsius: number | null;
-  humidity_percent: number | null;
-  solar_irradiance_wm2: number | null;
-  is_working_hours: boolean | null;
-  data_quality: ReadingDataQuality | null;
-  null_reasons: string[] | null;
-  imputed_values: Record<string, unknown> | null;
-  imputation_method: string | null;
-}

apps/frontend/src/app/shared/models/site-current.model.ts

@@ -1,16 +0,0 @@
-import { ReadingDataQuality } from './reading.model';
-
-export interface SiteCurrent {
-  timestamp: string | null;
-  site_id: string;
-  site_type: string;
-  consumption_kw: number | null;
-  consumption_kwh: number | null;
-  voltage_v: number | null;
-  current_a: number | null;
-  power_factor: number | null;
-  temperature_celsius: number | null;
-  humidity_percent: number | null;
-  null_reasons: string[];
-  data_quality: ReadingDataQuality;
-}

apps/frontend/src/environments/environment.development.ts

@@ -1,5 +1,5 @@
 export const environment = {
   production: false,
   apiUrl: '/api/v1',
-  useMockFixtures: false,
+  useMockFixtures: true, // a passer a false une fois le backend prêt
 };

docs/architecture/00-vue-ensemble.md

@@ -74,10 +74,10 @@ collecteur ne vient le lire.
 
 | Domaine | Technologie | Emplacement | Statut | Ce qui existe réellement |
 |---|---|---|---|---|
-| 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`, `readings`, `sensors/status` et `predictions` en lecture (endpoints → services → repositories → models) |
+| 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`, authentification complète (garde de route, intercepteur de jeton), cinq services HTTP, graphiques Chart.js. `stats`/`alerts` sur fixtures, `predictions` branché sur l'API réelle |
+| 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 et de scoring (`enervision_ml.train`/`.score`, features par lags/moyennes glissantes partagées entre les deux, baseline de persistance saisonnière, suivi MLflow local), exposé en lecture via `GET /predictions`. Voir [ADR 0005](../adr/0005-modele-prediction-lightgbm.md) et [ML-START.md](../../ML-START.md). Automatisation (Airflow) et surveillance de dérive (EC06, #44/#45) pas encore construites |
+| 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 |

docs/architecture/20-backend.md

@@ -12,10 +12,10 @@ Les quatre couches existent désormais, portées par l'authentification.
 
 ```mermaid
 flowchart TB
-  ep["endpoints<br/>health, auth, users, sites, alerts,<br/>recommendations, stats, readings, sensors, predictions"]
+  ep["endpoints<br/>health, auth, users, sites, alerts,<br/>recommendations, stats, sensors"]
   sc["schemas<br/>Pydantic"]
-  sv["services<br/>AuthService, UserService,<br/>SiteService, AlertService, RecommendationService,<br/>StatsService, ReadingService, SensorService, PredictionService"]
+  sv["services<br/>AuthService, UserService,<br/>SiteService, AlertService, RecommendationService,<br/>StatsService, SensorService"]
-  rp["repositories<br/>user, refresh_token,<br/>login_attempt, audit_log,<br/>site, alert, recommendation, reading, prediction"]
+  rp["repositories<br/>user, refresh_token,<br/>login_attempt, audit_log,<br/>site, alert, recommendation, reading"]
   md["models<br/>10 tables"]
   db[("PostgreSQL")]
 
@@ -149,22 +149,19 @@ Deux fichiers d'environnement, deux usages : `.env` à la racine alimente `docke
 | GET | `/api/v1/stats/summary` | Résume la consommation instantanée du parc. `lecteur` | 401, 403, 500 |
 | GET | `/api/v1/readings` | Historique des lectures, filtrable par `site_id`, fenêtre `start`/`end` (24h par défaut, 90 jours maximum) et paginé par `limit`/`offset`. `lecteur` | 400, 401, 403, 422, 500 |
 | GET | `/api/v1/sensors/status` | État de santé des capteurs par site, dérivé de la dernière lecture. `admin` | 401, 403, 500 |
-| GET | `/api/v1/predictions` | Dernière prévision de consommation par site, calculée hors ligne par le pipeline de scoring (`ml/`). `lecteur` | 401, 403, 500 |
 | GET | `/metrics` | Format Prometheus, hors du schéma. Jeton requis si `APP_METRICS_TOKEN` est posé | |
 | GET | `/docs`, `/redoc`, `/openapi.json` | Hors du schéma. Fermés en `staging` et en `prod` | |
 
 Les codes de la dernière colonne sont ceux que le schéma **déclare**, et le fichier
 `openapi.json` versionné interdit qu'ils divergent de ce que les routes rendent.
 
-**Sept routes du contrat sont publiques** : les deux sondes, `/auth/login`, `/auth/logout`,
+**Quatre routes seulement sont publiques** : les deux sondes, `/auth/login` et `/auth/logout`.
-`/auth/forgot-password` et les deux routes de réinitialisation, qui portent leur autorisation dans
-le jeton à usage unique plutôt que dans un `Principal`.
 `tests/api/test_route_protection.py` interroge réellement chaque autre route sans identifiant et
 échoue si l'une d'elles répond autre chose qu'un 401 ou un 403. Rendre une route publique impose
-donc de modifier `ROUTES_PUBLIQUES` dans `tests/api/acces.py`.
+donc de modifier la liste dans ce fichier de test.
 
 `GET /sites` et `GET /sites/{site_id}` sont la première route métier, et le gabarit repris pour
-`GET /alerts` puis pour les suivantes (`dataset`) : les quatre couches
+`GET /alerts` puis pour les suivantes (`dataset`, `prediction`) : les quatre couches
 `endpoints → services → repositories → models` y sont toutes présentes, sur des tables déjà créées
 par la révision Alembic `e6d2026091501`. Elles n'exigent que le rôle `lecteur`, contrairement aux
 routes d'administration qui exigent `admin`. `SiteRepository` lit par `AsyncSession.scalar()` (une
@@ -182,18 +179,6 @@ dernière `Reading` du site : un site connu sans lecture rend `200` avec tous le
 détaillé pour le frontend est dans
 [31-contrat-authentification.md](31-contrat-authentification.md).
 
-`GET /predictions` reprend ce même sous-gabarit « dernière valeur par site » (`SiteRepository` +
-`PredictionRepository`, un `SitePredictionSummaryResponse` par site plutôt qu'une table brute).
-Différence avec `stats`/`sensors` : `prediction` est une vraie table accumulée par un processus
-externe (`enervision_ml.score`, cf. `ml/README.md`), pas une valeur recalculée à la volée depuis
-`reading` à chaque appel. `PredictionRepository.latest_by_site()` isole donc un `DISTINCT ON
-(site_id)` ordonné par `target_at DESC` (couvert par l'index `ix_prediction_site_target`), le même
-mécanisme que `ReadingRepository.latest_by_site()`. Un site jamais scoré rend `prediction: null`
-plutôt qu'un statut inventé : le domaine `available`/`insufficient_data`/`error` de la contrainte
-`ck_prediction_status` n'a pas de valeur pour « pas encore de ligne ». L'API ne lance jamais
-LightGBM elle-même ; elle lit ce que le pipeline de scoring a déjà écrit, cf.
-[ML-START.md](../../ML-START.md) section 3.
-
 `GET /readings` reprend le même gabarit mais s'en écarte sur un point : `reading` est l'hypertable,
 donc la seule table métier pouvant porter des années d'historique, ce que `docs/architecture/
 owasp-traceabilite.md` documentait comme un risque ouvert (API4, aucune pagination plafonnée ni
@@ -207,46 +192,6 @@ par exemple `limit` hors bornes). Un datetime sans fuseau dans `start`/`end` est
 l'UTC plutôt que rejeté : le comparer tel quel à `reading.timestamp` (`timestamptz`) échouerait
 côté pilote, en `500` plutôt qu'un refus propre.
 
-### Détection d'alertes internes
-
-`AlertService` n'est plus lecture seule : `AlertService.detect()` compare les `reading` (et, pour
-le type `anomaly`, les `prediction`) des dernières 48h (`LOOKBACK`) à cinq règles et enregistre une
-ligne `alert` par déclenchement, avec `source="enervision"`. `metric`/`value`/`threshold` gardent
-leur sens dans chaque règle plutôt que d'être laissés à `null` par commodité :
-
-| `type` | Règle | `value` / `threshold` |
-|---|---|---|
-| `threshold` | `reading.consumption_kw` dépasse `site.capacity_kw` (site sans capacité déclarée : ignoré) | mesure / capacité du site |
-| `spike` | Variation relative ≥ 50% (`SPIKE_RELATIVE_THRESHOLD`) entre deux lectures consécutives du même site, ou redémarrage direct à une valeur positive depuis zéro (`critical`) | mesure actuelle / mesure précédente |
-| `anomaly` | Écart relatif ≥ 30% (`ANOMALY_RELATIVE_THRESHOLD`) entre `reading.consumption_kwh` et la `prediction` du même site dont `target_at == timestamp` | mesure réelle / valeur prédite |
-| `outage` | Aucune lecture depuis plus de 3h (`OUTAGE_THRESHOLD`, 3x la cadence horaire nominale), ou site jamais lu | `null` / `null` |
-| `sensor` | `reading.data_quality` ∈ `partial`/`degraded`/`critical` | `null` / `null` |
-
-La sévérité de chaque alerte (hors `sensor`, dérivée directement de `data_quality`) suit le même
-barème par ratio observé/seuil : `low` sous 1.2, `medium` sous 1.5, `high` sous 2.0, `critical`
-au-delà. `AlertRepository.create_many()` insère par lot avec `ON CONFLICT DO NOTHING` sur
-`uq_alert_source_reference`, et `source_alert_id` est construit de façon déterministe (règle +
-horodatage) : rejouer la détection sur une fenêtre déjà analysée ne duplique donc jamais une
-alerte.
-
-**Pièges de tri corrigés en revue** : `reading`/`prediction` n'ont pas d'unicité sur leur couple
-métier (`uq_reading_source` autorise deux `source` différentes au même `site_id`+`timestamp`,
-`prediction` n'a aucune contrainte sur `(site_id, target_at)`, chaque run de scoring gardant sa
-propre ligne). `ReadingRepository.list_since()`/`PredictionRepository.list_since()` départagent
-donc les égalités par `reading_id`/`prediction_id` croissant, comme le font déjà
-`latest_by_site()`/`latest_for_site()` sur les mêmes tables ; sans ce départage, l'ordre entre
-lignes à égalité n'est pas garanti d'un appel à l'autre, et `_detect_spike`/`_detect_anomaly`
-auraient pu comparer des lectures/choisir une prévision au hasard. `_detect_spike` ignore en plus
-explicitement les paires de lectures qui partagent le même horodatage (deux `source` pour un seul
-instant réel, pas une variation).
-
-Comme `enervision_ml.score`, la détection est un script lancé à la main, pas encore ordonnancé par
-Airflow : `uv run python -m app.detection.internal_alerts [--site-id ...] [--now ...]`, dans
-`apps/backend` puisque les règles s'appuient sur les repositories ORM de l'API plutôt que sur une
-connexion SQL directe (contrairement à `app/etl/historical_import.py`). Cette issue (#104)
-débloquait #38 (moteur de règles pour recommandations), dont la FK `alert_id` `NOT NULL` n'avait
-jusqu'ici rien à référencer côté `source="enervision"`.
-
 ### `/health/ready`
 
 Cette sonde porte une garde décrite dans l'[ADR 0001](../adr/0001-postgresql-timescaledb.md) : un
@@ -322,22 +267,17 @@ Les modèles de `app/schemas/errors.py` décrivent ce que les gestionnaires renv
 ### Ajouter une route métier
 
 Checklist pour toute nouvelle route sur le gabarit `sites`/`alerts`/`recommendations`/`stats`/
-`readings`/`sensors`/`predictions` (`dataset`) :
+`readings`/`sensors` (`dataset`, `prediction`) :
 
 1. Composer ses `responses=` depuis `app/api/openapi.py` : `REPONSES_LECTEUR`/`REPONSES_ADMIN`
    au niveau de l'`include_router()` du routeur, `REPONSE_VALIDATION` et les codes locaux
    (404, 409, ...) directement sur l'endpoint qui les rend.
 2. Décrire son tag dans `TAGS`.
-3. **La classer dans `tests/api/acces.py`** : `ROLE_MINIMUM` avec son rôle minimum si elle passe
+3. Si elle passe par `require_role` (`LecteurDep`/`OperateurDep`/`AdminDep`), l'ajouter à
-   par `require_role` (`LecteurDep`/`OperateurDep`/`AdminDep`), `ROUTES_SANS_ROLE` si elle se
+   `ROUTES_A_ROLE` dans `tests/api/test_openapi.py`. Si elle passe par `require_trusted_origin`,
-   contente de `CurrentPrincipalDep`, `ROUTES_PUBLIQUES` si elle est ouverte. L'oubli n'est plus
+   l'ajouter à `ORIGINE_VERIFIEE`. **Ces deux listes sont maintenues à la main, pas dérivées** :
-   silencieux : `test_every_declared_route_is_classified` échoue sur une route non classée comme
+   une route oubliée n'y est pas détectée automatiquement.
-   sur une entrée qui ne correspond plus à aucune route. `ROUTES_A_ROLE` de `test_openapi.py` en
+4. `make openapi`, puis `uv run pytest tests/api/test_openapi.py`.
-   est dérivée, et `test_matrice_acces.py` vérifie le niveau réellement monté.
-4. Si elle passe par `require_trusted_origin`, l'ajouter à `ORIGINE_VERIFIEE` dans
-   `tests/api/test_openapi.py`. **Cette liste-là reste maintenue à la main.**
-5. `make openapi`, puis `uv run pytest tests/api/test_openapi.py tests/api/test_route_protection.py
-   tests/api/test_matrice_acces.py`.
 
 ## Sécurité
 
@@ -388,14 +328,9 @@ Le reste, par ordre de surface :
 
 Conventions, gabarits et arborescence : [`apps/backend/TESTING.md`](../../apps/backend/TESTING.md).
 
-Quatre fichiers méritent d'être connus avant de toucher à l'authentification :
+Trois fichiers méritent d'être connus avant de toucher à l'authentification :
 
-- `tests/api/acces.py` : la classification des routes, `ROUTES_PUBLIQUES` et `ROLE_MINIMUM` en
-  tête. Ce n'est pas un test, c'est la référence que les deux suivants confrontent au
-  comportement observé.
 - `tests/api/test_route_protection.py` : le garde-fou de l'autorisation, décrit plus haut.
-- `tests/api/test_matrice_acces.py` : chaque route gardée croisée avec chacun des trois rôles,
-  dans les deux sens, puis rejouée sous `integration` avec de vrais jetons.
 - `tests/services/test_auth.py` : le faux hacheur y porte un compteur d'appels, ce qui permet les
   deux assertions qui prouvent le design, à savoir un appel quand l'adresse est inconnue et zéro
   appel quand la limite est atteinte.

docs/architecture/30-frontend.md

@@ -13,29 +13,24 @@ Ce qui est en place :
 - `app.config.ts` fournit `provideBrowserGlobalErrorListeners()`, `provideRouter(routes)` et
   `provideHttpClient(withInterceptors([mockApiInterceptor]))`.
 - Une route `/dashboard` en composant différé, et une redirection depuis la racine.
-- `core/services` porte `StatsService`, `AlertsService`, `PredictionsService`, `SitesService` et
+- `core/services` porte `StatsService` et `AlertsService`, `core/interceptors` l'intercepteur de
-  `AuthService`, `core/interceptors` l'intercepteur de fixtures et l'intercepteur d'authentification
+  fixtures, `features/dashboard` la page, `shared/components` la jauge de consommation et le
-  (jeton porteur, rafraîchissement sur 401), `core/guards` la garde de route `authGuard`,
-  `features/dashboard` la page principale, `shared/components` la jauge de consommation et le
   graphique de charge par site, tous deux construits sur Chart.js.
-- Une authentification complète côté interface : connexion, mot de passe oublié/réinitialisation,
-  changement de mot de passe, garde de route sur `/dashboard` et `/sites`. Détail :
-  [31-contrat-authentification.md](31-contrat-authentification.md).
 - Un système de design partagé (`shared/components/ui/` : `ev-button`, `ev-card`, `ev-alert`,
   `ev-badge`, `ev-brand`, tokens CSS dans `styles/_tokens.scss`) que toute nouvelle page doit
   réutiliser plutôt que redéfinir ses propres styles. Détail :
   [32-design-systeme-frontend.md](32-design-systeme-frontend.md).
 - L'état vit dans des signaux, sans bibliothèque dédiée.
-- Vitest via le builder `@angular/build:unit-test`, couverture activée.
+- Vitest via le builder `@angular/build:unit-test`, couverture activée, sept fichiers de test.
 - Prettier configuré, parser `angular` pour les gabarits HTML.
 
 Ce qui n'existe pas encore :
 
-- **`stats`/`alerts` restent sur fixtures.** `GET /api/v1/stats/summary` et `GET /api/v1/alerts`
+- **Aucun endpoint réel derrière l'écran.** `GET /api/v1/stats/summary` et `GET /api/v1/alerts`
-  sont servis par l'intercepteur de fixtures ; l'API expose bien ces routes désormais, mais rien
+  sont servis par l'intercepteur ; l'API expose `/health`, `/auth` et `/users`, rien d'autre.
-  ne bascule `useMockFixtures` à `false` en développement pour les consommer réellement.
+- Aucune authentification côté interface : ni garde de route, ni intercepteur de jeton, alors que
-  `GET /api/v1/predictions` fait exception : jamais mocké, branché sur l'API réelle depuis cette
+  les routes métier de l'API en exigent un. Voir
-  PR (voir plus bas).
+  [31-contrat-authentification.md](31-contrat-authentification.md).
 - Aucun état de chargement : tant que la première réponse n'est pas arrivée, la page reste vide.
 - Aucun lint : ESLint n'est pas installé.
 
@@ -89,19 +84,19 @@ sequenceDiagram
 `mockApiInterceptor` n'intercepte que `/stats/summary` et `/alerts`, et seulement si
 `environment.useMockFixtures` est vrai. Le drapeau est à `true` en développement, à `false` en
 production : toute autre requête, et toutes les requêtes en production, suivent le chemin réel.
-`/predictions` est volontairement exclu de cette liste (contrairement à `stats`/`alerts`) : il
-suit toujours le chemin réel, comme `/auth/*` - en développement, ça veut dire qu'un jeton valide
-et un backend joignable sont nécessaires pour que la section prévisions du dashboard s'affiche.
 
 En développement, `proxy.conf.json` redirige tout `/api` vers `http://localhost:8000`. C'est ce
 qui évite le CORS sur le poste, et c'est pourquoi `environment.development.ts` se contente d'un
 `apiUrl` relatif, `/api/v1`.
 
-En production, il n'y a pas de proxy, mais `environment.ts` porte lui aussi un `apiUrl` relatif
+En production, il n'y a pas de proxy : `environment.ts` porte une URL absolue. Angular substitue
-(`/api/v1`) plutôt qu'une URL absolue : la dette qui pointait en dur sur
+le fichier via `fileReplacements`, et la configuration `production` est celle par défaut.
-`http://localhost:8000/api/v1` a été corrigée. Un build de production sert donc l'appel `/api/v1/...`
+
-sur son propre origin, ce qui suppose qu'un ingress ou un reverse proxy route `/api` vers le
+**Dette connue.** `src/environments/environment.ts`, qui est la configuration de production,
-backend une fois déployé — question toujours ouverte dans [10-infra.md](10-infra.md).
+pointe `http://localhost:8000/api/v1` en dur. La valeur est celle du poste de développement :
+telle quelle, un build de production ne joindra jamais l'API. À corriger avant le premier
+déploiement, en même temps que sera tranchée la question de l'ingress dans
+[10-infra.md](10-infra.md).
 
 ## Exécution
 
@@ -129,10 +124,9 @@ avec un service statique, il reste à écrire.
 ## Sécurité
 
 - Le frontend ne détient aucun secret : `environment.ts` ne porte qu'une URL.
-- L'authentification existe des deux côtés désormais : `authGuard` protège `/dashboard` et
+- L'authentification existe côté API mais pas côté interface : aucune garde de route, aucun
-  `/sites`, `authInterceptor` pose le jeton porteur sur les requêtes sortantes et déclenche le
+  intercepteur de jeton. `core/guards` reste à créer, `core/interceptors` n'héberge aujourd'hui
-  rafraîchissement sur 401. Détail complet dans
+  que les fixtures.
-  [31-contrat-authentification.md](31-contrat-authentification.md).
 
 ## Tests
 

ml/README.md

@@ -57,46 +57,6 @@ validation. La coupure est **chronologique**, jamais un tirage aleatoire de lign
 aleatoire laisserait des lignes de validation "voir" des lignes d'entrainement via leurs
 lags/moyennes glissantes, une fuite qui masquerait un surapprentissage.
 
-## Scoring
-
-```bash
-uv run python -m enervision_ml.score --csv data/all_sites_combined.csv
-# ou, une fois la base peuplee et ML_DATABASE_URL positionnee :
-uv run python -m enervision_ml.score
-```
-
-Calcule, pour chaque site (ou un seul avec `--site-id`), la consommation prevue de l'heure suivant
-sa derniere lecture connue, et ecrit une ligne dans `prediction`. Etapes, cf. `ML-START.md`
-section 2 :
-
-1. Lit une fenetre recente de `reading`+`site` (21 jours par defaut, une marge au-dessus des 168h
-   necessaires au lag hebdomadaire) plutot que tout l'historique -- le meme piege que celui deja
-   corrige sur `GET /readings` (fenetre non plafonnee sur une hypertable).
-2. Ajoute une ligne "future" par site (l'heure suivante) et calcule ses features avec
-   `enervision_ml.features.build_features`, **exactement** la meme fonction qu'a l'entrainement.
-3. Si le lag de 168h est absent (moins d'une semaine d'historique pour ce site) : ecrit
-   `status="insufficient_data"` directement, sans jamais appeler LightGBM.
-4. Sinon : appelle `booster.predict(...)` et ecrit `status="available"` avec la valeur predite.
-
-`--model` pointe vers le fichier entraine (`models/lightgbm-consumption.txt` par defaut).
-`model_reference` en base est le hache SHA-256 (tronque) du fichier modele, pas son nom de
-fichier : `train.py` reecrit toujours le meme chemin a chaque entrainement, donc le nom seul ne
-distinguerait pas deux versions du modele.
-
-En mode `--csv`, rien n'est ecrit en base : c'est un instantane historique fige (l'heure "future"
-calculee a partir de la fin du CSV n'existe dans aucune base reelle), utile pour valider le
-pipeline sans base joignable.
-
-**Limite assumee** : la feature `is_working_hours` de la ligne future est recopiee depuis la
-derniere lecture reelle, pas recalculee -- il n'existe aucune regle horaire ouvrable dans ce
-depot (elle vit dans le generateur du jeu de donnees d'origine). L'approximation n'est fausse
-qu'aux heures de bascule ouverture/fermeture, sur une seule feature parmi une dizaine, pour une
-prevision a un seul pas.
-
-`prediction` n'a pas de contrainte d'unicite sur `(site_id, target_at)` : chaque run de scoring
-insere une nouvelle ligne plutot que d'ecraser la precedente, pour garder une trace de chaque
-prevision (utile plus tard pour comparer prevision et realise, surveillance de derive #44/#45).
-
 ## Commandes
 
 ```bash
@@ -121,14 +81,8 @@ 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 scoring (`enervision_ml.score`). Si les deux divergent meme
+du modele, a l'entrainement comme au futur scoring (service #37, pas encore construit). Si les
-legerement (une fenetre de moyenne glissante calculee differemment, par exemple), le modele
+deux divergent meme legerement (une fenetre de moyenne glissante calculee differemment, par
-recoit en production des features qui ne ressemblent plus a ce qu'il a appris, et ses predictions
+exemple), le modele recoit en production des features qui ne ressemblent plus a ce qu'il a
-deviennent silencieusement mauvaises sans qu'aucune erreur ne se declenche. Ne jamais reecrire
+appris, et ses predictions deviennent silencieusement mauvaises sans qu'aucune erreur ne se
-cette logique ailleurs : importer `enervision_ml.features`.
+declenche. Ne jamais reecrire cette logique ailleurs : importer `enervision_ml.features`.
-
-## Et cote API ?
-
-`GET /api/v1/predictions` (backend, `apps/backend`) lit ce que `enervision_ml.score` a ecrit dans
-`prediction` -- la derniere prevision par site, jamais un recalcul a la volee. FastAPI ne fait
-jamais tourner LightGBM lui-meme, cf. `ML-START.md` section 3.

ml/enervision_ml/data.py

@@ -16,7 +16,6 @@ Deux chemins, qui doivent produire le meme schema de sortie (colonnes `site_id`,
   colonne est renvoyee a `NaN`, que LightGBM gere nativement comme valeur manquante.
 """
 
-from datetime import datetime
 from pathlib import Path
 
 import pandas as pd
@@ -35,14 +34,6 @@ OUTPUT_COLUMNS = [
     "capacity_kw",
 ]
 
-NUMERIC_COLUMNS = [
-    "consumption_kwh",
-    "temperature_celsius",
-    "humidity_percent",
-    "solar_irradiance_wm2",
-    "capacity_kw",
-]
-
 _READING_QUERY = text(
     """
     SELECT
@@ -62,43 +53,10 @@ _READING_QUERY = text(
 )
 
 
-_RECENT_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
-    WHERE r.timestamp >= :since
-    ORDER BY r.site_id, r.timestamp
-    """
-)
-
-
 def load_from_database(connection: Connectable) -> pd.DataFrame:
-    """Lit l'historique complet `reading` + `site` depuis PostgreSQL. Entrainement seulement :
+    """Lit l'historique complet `reading` + `site` depuis PostgreSQL."""
-    le scoring n'a besoin que d'une fenetre recente, cf. `load_recent_from_database`.
-    """
     frame = pd.read_sql(_READING_QUERY, connection)
-    return _typer(frame[OUTPUT_COLUMNS])
+    return frame[OUTPUT_COLUMNS]
-
-
-def load_recent_from_database(connection: Connectable, *, since: datetime) -> pd.DataFrame:
-    """Lit `reading` + `site` depuis `since` seulement, pour le scoring.
-
-    Piege evite : un `SELECT` sans borne sur l'hypertable complete juste pour scorer le prochain
-    pas horaire serait la meme erreur que celle corrigee sur `GET /readings` (fenetre non
-    plafonnee sur une table pouvant porter des annees d'historique).
-    """
-    frame = pd.read_sql(_RECENT_READING_QUERY, connection, params={"since": since})
-    return _typer(frame[OUTPUT_COLUMNS])
 
 
 def load_from_csv(csv_path: Path) -> pd.DataFrame:
@@ -107,25 +65,4 @@ def load_from_csv(csv_path: Path) -> pd.DataFrame:
     frame["capacity_kw"] = float("nan")
     frame["is_working_hours"] = frame["is_working_hours"].astype(bool)
 
-    return _typer(frame[OUTPUT_COLUMNS])
+    return frame[OUTPUT_COLUMNS]
-
-
-def _typer(frame: pd.DataFrame) -> pd.DataFrame:
-    """Force le typage numerique attendu par LightGBM.
-
-    Piege reel, pas theorique : `site.capacity_kw` n'est peuple par aucun pipeline d'ingestion
-    aujourd'hui (`historical_import.py` ne pose que `site_type`/`site_name`). Une colonne
-    entierement `NULL` revient de `pd.read_sql` en dtype `object` plutot que `float64`, ce que
-    LightGBM refuse ("pandas dtypes must be int, float or bool"). `pd.to_numeric` corrige aussi
-    n'importe quelle autre colonne mesuree entierement absente sur une fenetre de scoring, pas
-    seulement `capacity_kw`.
-
-    Piege additionnel : `NUMERIC_COLUMNS` inclut `consumption_kwh`, la cible du modele, pas
-    seulement des variables explicatives. Une valeur non numerique y devient donc silencieusement
-    `NaN` aussi bien a l'entrainement (ou `train.py` l'exclura ensuite via son `dropna`) qu'au
-    scoring -- ce n'est pas un effet de bord limite aux colonnes mesurees.
-    """
-    typee = frame.copy()
-    for colonne in NUMERIC_COLUMNS:
-        typee[colonne] = pd.to_numeric(typee[colonne], errors="coerce")
-    return typee

ml/enervision_ml/score.py

@@ -1,318 +0,0 @@
-"""Scoring du modele LightGBM : calcule et enregistre la consommation prevue du prochain pas
-horaire, par site.
-
-CLI autonome, sur le meme gabarit que `enervision_ml.train` et
-`apps/backend/app/etl/historical_import.py`. Cf. `docs/ML-START.md`, section 2.
-
-    uv run python -m enervision_ml.score --csv ../ml/data/all_sites_combined.csv
-    uv run python -m enervision_ml.score  # lit ML_DATABASE_URL, ecrit dans `prediction`
-
-Reutilise `enervision_ml.features.build_features` tel quel (jamais reecrit) : c'est la garantie
-contre le train/serve skew documentee dans ce module.
-"""
-
-import argparse
-import hashlib
-from dataclasses import dataclass
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
-from typing import Any, cast
-
-import lightgbm as lgb
-import pandas as pd
-from sqlalchemy import create_engine, text
-from sqlalchemy.engine import Connection
-
-from enervision_ml import config
-from enervision_ml.data import load_from_csv, load_recent_from_database
-from enervision_ml.features import TARGET_COLUMN, WEATHER_COLUMNS, build_features, feature_columns
-
-# Marge au-dessus des 168h necessaires au lag hebdomadaire, pour absorber les trous de mesure.
-LOOKBACK = timedelta(days=21)
-
-# Au-dela de ce seuil, la derniere lecture d'un site est trop vieille pour que "l'heure
-# suivante" ait un sens operationnel : ce n'est plus une prevision a un pas, c'est un site dont
-# l'ingestion s'est probablement arretee. Sans cette borne, `build_scoring_frame` produirait
-# quand meme un `target_at` (derniere lecture + 1h), et rien en aval (ni l'API, ni le dashboard)
-# ne distingue une prevision fraiche d'une prevision vieille de plusieurs jours.
-MAX_STALENESS = timedelta(hours=24)
-
-TARGET_METRIC = "consumption_kwh"
-PERIOD_MINUTES = 60
-LAG_168H_COLUMN = f"{TARGET_COLUMN}_lag_168h"
-INSUFFICIENT_DATA_REASON = (
-    "Historique insuffisant : moins de 168h de consumption_kwh disponibles pour ce site."
-)
-
-
-def _stale_reason(age: pd.Timedelta) -> str:
-    return (
-        f"Dernière lecture vieille de {age.total_seconds() / 3600:.0f}h "
-        f"(seuil {MAX_STALENESS.total_seconds() / 3600:.0f}h) : ingestion probablement "
-        "arrêtée pour ce site."
-    )
-
-
-@dataclass(frozen=True, slots=True)
-class ScoredSite:
-    site_id: str
-    target_at: datetime
-    status: str
-    predicted_value: float | None
-    failure_reason: str | None
-
-
-def model_reference(model_path: Path) -> str:
-    """Identifiant stable du modele utilise, insensible au fait que `train.py` reecrive
-    toujours le meme nom de fichier a chaque entrainement (pas de versioning par nom, cf.
-    `ml/README.md`)."""
-    empreinte = hashlib.sha256(model_path.read_bytes()).hexdigest()
-    return f"lightgbm-{empreinte[:12]}"
-
-
-def build_scoring_frame(recent: pd.DataFrame, *, site_id: str | None = None) -> pd.DataFrame:
-    """Ajoute une ligne future (l'heure suivant la derniere lecture connue) par site, et calcule
-    ses features par `build_features` -- exactement comme a l'entrainement, seule la cible de
-    cette ligne est inconnue.
-
-    Piege assume : `is_working_hours` de la ligne future est copie de la derniere lecture reelle,
-    pas recalcule. Il n'existe aucune regle horaire ouvrable dans ce depot (elle vit dans le
-    generateur du jeu de donnees d'origine, hors de ce code) ; l'approximation n'est fausse
-    qu'aux heures de bascule (ouverture/fermeture), sur une seule feature parmi une dizaine, pour
-    une prevision a un pas seulement.
-    """
-    travail = recent if site_id is None else recent[recent["site_id"] == site_id]
-    if travail.empty:
-        return build_features(travail)
-
-    dernieres = (
-        travail.sort_values("timestamp").groupby("site_id", as_index=False, sort=False).tail(1)
-    ).copy()
-    dernieres["timestamp"] = dernieres["timestamp"] + pd.Timedelta(hours=1)
-    dernieres[TARGET_COLUMN] = float("nan")
-    # Meteo future inconnue (cf. piege documente dans `enervision_ml.features.build_features`) :
-    # laisser `NaN` ici n'a aucun effet sur les features utilisees, qui ne prennent la meteo que
-    # decalee.
-    for colonne in WEATHER_COLUMNS:
-        dernieres[colonne] = float("nan")
-
-    etendu = pd.concat([travail, dernieres], ignore_index=True)
-    features = build_features(etendu)
-    return features.groupby("site_id", as_index=False, sort=False).tail(1).reset_index(drop=True)
-
-
-def score(
-    booster: lgb.Booster, scoring_frame: pd.DataFrame, *, instant: datetime
-) -> list[ScoredSite]:
-    resultats: list[ScoredSite] = []
-
-    # `timestamp` de la ligne de scoring vaut derniere lecture + 1h (cf. `build_scoring_frame`) :
-    # on en deduit l'age de cette derniere lecture par rapport a `instant`.
-    travail = scoring_frame.copy()
-    travail["_age"] = instant - (travail["timestamp"] - pd.Timedelta(hours=1))
-
-    perimes = travail[travail["_age"] > MAX_STALENESS]
-    for enregistrement in _records(perimes):
-        resultats.append(
-            ScoredSite(
-                site_id=enregistrement["site_id"],
-                target_at=enregistrement["timestamp"].to_pydatetime(),
-                status="insufficient_data",
-                predicted_value=None,
-                failure_reason=_stale_reason(enregistrement["_age"]),
-            )
-        )
-
-    a_jour = travail[travail["_age"] <= MAX_STALENESS]
-
-    insuffisants = a_jour[a_jour[LAG_168H_COLUMN].isna()]
-    for enregistrement in _records(insuffisants):
-        resultats.append(
-            ScoredSite(
-                site_id=enregistrement["site_id"],
-                target_at=enregistrement["timestamp"].to_pydatetime(),
-                status="insufficient_data",
-                predicted_value=None,
-                failure_reason=INSUFFICIENT_DATA_REASON,
-            )
-        )
-
-    suffisants = a_jour[a_jour[LAG_168H_COLUMN].notna()]
-    if not suffisants.empty:
-        typee = suffisants.copy()
-        typee["site_type"] = typee["site_type"].astype("category")
-        predictions = booster.predict(typee[feature_columns()])
-        for enregistrement, valeur in zip(_records(suffisants), predictions, strict=True):
-            resultats.append(
-                ScoredSite(
-                    site_id=enregistrement["site_id"],
-                    target_at=enregistrement["timestamp"].to_pydatetime(),
-                    status="available",
-                    predicted_value=float(valeur),
-                    failure_reason=None,
-                )
-            )
-
-    return resultats
-
-
-def _records(frame: pd.DataFrame) -> list[dict[str, Any]]:
-    return cast(list[dict[str, Any]], frame.to_dict(orient="records"))
-
-
-_INSERT_PREDICTION = text(
-    """
-    INSERT INTO prediction (
-        site_id, target_at, target_metric, period_minutes,
-        predicted_value, model_reference, status, failure_reason
-    ) VALUES (
-        :site_id, :target_at, :target_metric, :period_minutes,
-        :predicted_value, :model_reference, :status, :failure_reason
-    )
-    """
-)
-
-
-def write_predictions(
-    connection: Connection, resultats: list[ScoredSite], *, reference: str
-) -> None:
-    """Ecrit une ligne par site score. Insertion seule, jamais de mise a jour : `prediction`
-    n'a pas de contrainte d'unicite sur `(site_id, target_at)`, chaque run garde sa propre trace
-    plutot que d'ecraser la precedente -- utile plus tard pour comparer prevision et realise
-    (surveillance de derive, #44/#45)."""
-    if not resultats:
-        return
-
-    lignes = [
-        {
-            "site_id": r.site_id,
-            "target_at": r.target_at,
-            "target_metric": TARGET_METRIC,
-            "period_minutes": PERIOD_MINUTES,
-            "predicted_value": r.predicted_value,
-            "model_reference": reference,
-            "status": r.status,
-            "failure_reason": r.failure_reason,
-        }
-        for r in resultats
-    ]
-    connection.execute(_INSERT_PREDICTION, lignes)
-
-
-def _load_recent_from_csv(csv_path: Path, *, now: datetime | None) -> tuple[pd.DataFrame, datetime]:
-    brute = load_from_csv(csv_path)
-    instant = now or (
-        brute["timestamp"].max().to_pydatetime() if not brute.empty else datetime.now(UTC)
-    )
-    return brute[brute["timestamp"] >= instant - LOOKBACK], instant
-
-
-def _score_frame(
-    recent: pd.DataFrame, *, model_path: Path, site_id: str | None, instant: datetime
-) -> list[ScoredSite]:
-    scoring_frame = build_scoring_frame(recent, site_id=site_id)
-    if scoring_frame.empty:
-        return []
-
-    booster = lgb.Booster(model_file=str(model_path))
-    return score(booster, scoring_frame, instant=instant)
-
-
-def run_scoring(
-    *,
-    model_path: Path,
-    csv_path: Path | None = None,
-    site_id: str | None = None,
-    now: datetime | None = None,
-) -> list[ScoredSite]:
-    """Score le prochain pas horaire par site et l'ecrit dans `prediction`.
-
-    En mode `--csv`, rien n'est ecrit : c'est un instantane historique fige (l'heure "future"
-    calculee n'existe dans aucune base reelle), utile pour valider le pipeline sans base
-    joignable, cf. `ml/README.md`. `site_id` n'est filtre qu'une fois, dans
-    `build_scoring_frame` : le filtrer aussi ici serait redondant.
-    """
-    if csv_path is not None:
-        recent, instant = _load_recent_from_csv(csv_path, now=now)
-        return _score_frame(recent, model_path=model_path, site_id=site_id, instant=instant)
-
-    # Un seul engine pour la lecture et l'ecriture de ce run, plutot qu'un par etape.
-    engine = create_engine(config.database_url())
-    try:
-        instant = now or datetime.now(UTC)
-        recent = load_recent_from_database(engine, since=instant - LOOKBACK)
-        resultats = _score_frame(recent, model_path=model_path, site_id=site_id, instant=instant)
-
-        reference = model_reference(model_path)
-        with engine.begin() as connection:
-            write_predictions(connection, resultats, reference=reference)
-
-        return resultats
-    finally:
-        engine.dispose()
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Scoring du modele LightGBM EnerVision")
-
-    parser.add_argument(
-        "--model",
-        type=Path,
-        default=Path("models/lightgbm-consumption.txt"),
-        help="Chemin du modele entraine. Defaut : models/lightgbm-consumption.txt.",
-    )
-    parser.add_argument(
-        "--csv",
-        type=Path,
-        default=None,
-        help=(
-            "Instantane historique de demarrage/demo, rien n'est ecrit en base. Omis, lit "
-            "ML_DATABASE_URL, se connecte a PostgreSQL et ecrit dans `prediction`."
-        ),
-    )
-    parser.add_argument(
-        "--site-id",
-        default=None,
-        help="Ne score que ce site. Omis, tous les sites presents dans la fenetre recente.",
-    )
-    parser.add_argument(
-        "--now",
-        type=_parse_instant,
-        default=None,
-        help=(
-            "Instant de reference (ISO 8601), pour tester ou demontrer le scoring cote base sur "
-            "des donnees anciennes (ex. le jeu de donnees historique, qui s'arrete fin 2024). "
-            "Omis, horloge systeme reelle."
-        ),
-    )
-
-    return parser.parse_args()
-
-
-def _parse_instant(valeur: str) -> datetime:
-    instant = datetime.fromisoformat(valeur)
-    return instant if instant.tzinfo is not None else instant.replace(tzinfo=UTC)
-
-
-def main() -> None:
-    args = parse_args()
-    resultats = run_scoring(
-        model_path=args.model, csv_path=args.csv, site_id=args.site_id, now=args.now
-    )
-
-    if not resultats:
-        print("Aucun site a scorer (aucune lecture recente dans la fenetre).")
-        return
-
-    for r in resultats:
-        if r.status == "available":
-            print(f"{r.site_id} @ {r.target_at} : {r.predicted_value:.2f} kWh")
-        else:
-            print(f"{r.site_id} @ {r.target_at} : {r.status} ({r.failure_reason})")
-
-    if args.csv is not None:
-        print("\nMode --csv : instantane historique, rien ecrit en base.")
-
-
-if __name__ == "__main__":
-    main()

ml/pyproject.toml

@@ -47,9 +47,9 @@ select = [
     "S",
     "PT",
 ]
-# N806/N803 : `X`/`y` (donnees/cible) est la convention scikit-learn/LightGBM, pas une variable
+# N806 : `X`/`y` (donnees/cible) est la convention scikit-learn/LightGBM, pas une variable mal
-# ou un argument mal nomme.
+# nommee.
-ignore = ["B008", "N806", "N803"]
+ignore = ["B008", "N806"]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**/*.py" = ["S101"]

ml/tests/test_data.py

@@ -1,55 +0,0 @@
-from pathlib import Path
-
-import pandas as pd
-
-from enervision_ml.data import NUMERIC_COLUMNS, load_from_csv
-
-_CSV_HEADER = (
-    "site_id,timestamp,consumption_kwh,temperature_celsius,humidity_percent,"
-    "solar_irradiance_wm2,is_working_hours,site_type"
-)
-
-
-def write_csv(tmp_path: Path, *lignes: str) -> Path:
-    csv_path = tmp_path / "recent.csv"
-    csv_path.write_text("\n".join([_CSV_HEADER, *lignes]) + "\n")
-    return csv_path
-
-
-def test_load_from_csv_types_every_numeric_column_as_float(tmp_path: Path) -> None:
-    csv_path = write_csv(tmp_path, "SITE001,2026-01-01T00:00:00,10.5,15.0,50.0,0.0,True,office")
-
-    frame = load_from_csv(csv_path)
-
-    for colonne in NUMERIC_COLUMNS:
-        assert frame[colonne].dtype == "float64"
-
-
-def test_load_from_csv_coerces_a_corrupted_measurement_to_nan(tmp_path: Path) -> None:
-    # Reproduit une valeur de capteur corrompue plutot que vraiment manquante : `pandas` type
-    # alors la colonne entiere en `object`, pas en `float64` rempli de `NaN` -- le meme genre de
-    # divergence de typage que celle que `pd.read_sql` produit sur une colonne SQL entierement
-    # `NULL` (cf. `site.capacity_kw`, jamais peuplee par aucun pipeline d'ingestion aujourd'hui).
-    csv_path = write_csv(
-        tmp_path,
-        "SITE001,2026-01-01T00:00:00,10.5,15.0,50.0,0.0,True,office",
-        "SITE001,2026-01-01T01:00:00,capteur_hs,15.2,50.5,0.0,True,office",
-    )
-
-    frame = load_from_csv(csv_path)
-
-    assert frame["consumption_kwh"].dtype == "float64"
-    assert frame["consumption_kwh"].iloc[0] == 10.5
-    assert pd.isna(frame["consumption_kwh"].iloc[1])
-
-
-def test_load_from_csv_always_types_capacity_kw_as_float(tmp_path: Path) -> None:
-    # `capacity_kw` n'existe pas dans ce CSV : `load_from_csv` la pose elle-meme a `NaN`. Cette
-    # affectation directe est deja un `float`, contrairement au cas `pd.read_sql` -- ce test
-    # garde le contrat visible malgre tout, au cas ou l'implementation changerait.
-    csv_path = write_csv(tmp_path, "SITE001,2026-01-01T00:00:00,10.5,15.0,50.0,0.0,True,office")
-
-    frame = load_from_csv(csv_path)
-
-    assert frame["capacity_kw"].dtype == "float64"
-    assert pd.isna(frame["capacity_kw"].iloc[0])

ml/tests/test_score.py

@@ -1,277 +0,0 @@
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
-from typing import Any
-
-import pandas as pd
-import pytest
-
-from enervision_ml.features import TARGET_COLUMN
-from enervision_ml.score import (
-    LAG_168H_COLUMN,
-    MAX_STALENESS,
-    ScoredSite,
-    build_scoring_frame,
-    model_reference,
-    run_scoring,
-    score,
-    write_predictions,
-)
-
-
-def make_recent(
-    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,
-            "humidity_percent": 50.0,
-            "solar_irradiance_wm2": 0.0,
-            "is_working_hours": True,
-            "site_type": "office",
-            "capacity_kw": 100.0,
-        }
-    )
-
-
-class FakeBooster:
-    def __init__(self, valeur: float = 42.0) -> None:
-        self.valeur = valeur
-        self.appels: list[int] = []
-
-    def predict(self, X: Any) -> list[float]:
-        self.appels.append(len(X))
-        return [self.valeur] * len(X)
-
-
-class FakeConnection:
-    def __init__(self) -> None:
-        self.appels: list[tuple[Any, Any]] = []
-
-    def execute(self, statement: Any, parameters: Any = None) -> None:
-        self.appels.append((statement, parameters))
-
-
-def test_build_scoring_frame_adds_one_row_per_site_one_hour_after_the_last_reading() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    recent = pd.concat(
-        [
-            make_recent("site-a", heures=200, depart=depart),
-            make_recent("site-b", heures=200, depart=depart),
-        ],
-        ignore_index=True,
-    )
-
-    scoring_frame = build_scoring_frame(recent)
-
-    assert set(scoring_frame["site_id"]) == {"site-a", "site-b"}
-    derniere_lecture = depart + timedelta(hours=199)
-    assert (scoring_frame["timestamp"] == derniere_lecture + timedelta(hours=1)).all()
-
-
-def test_build_scoring_frame_computes_lags_from_real_history() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    recent = make_recent("site-a", heures=200, depart=depart)
-
-    scoring_frame = build_scoring_frame(recent)
-
-    ligne = scoring_frame.iloc[0]
-    # La cible future n'existe pas : le lag d'1h doit valoir la toute derniere valeur reelle.
-    assert ligne[f"{TARGET_COLUMN}_lag_1h"] == recent[TARGET_COLUMN].iloc[-1]
-
-
-def test_build_scoring_frame_flags_insufficient_history_under_168_hours() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    recent = make_recent("site-a", heures=100, depart=depart)
-
-    scoring_frame = build_scoring_frame(recent)
-
-    assert pd.isna(scoring_frame.iloc[0][LAG_168H_COLUMN])
-
-
-def test_build_scoring_frame_accepts_a_full_week_of_history() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    recent = make_recent("site-a", heures=169, depart=depart)
-
-    scoring_frame = build_scoring_frame(recent)
-
-    assert not pd.isna(scoring_frame.iloc[0][LAG_168H_COLUMN])
-
-
-def test_build_scoring_frame_filters_to_a_single_site() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    recent = pd.concat(
-        [
-            make_recent("site-a", heures=200, depart=depart),
-            make_recent("site-b", heures=200, depart=depart),
-        ],
-        ignore_index=True,
-    )
-
-    scoring_frame = build_scoring_frame(recent, site_id="site-a")
-
-    assert scoring_frame["site_id"].tolist() == ["site-a"]
-
-
-def test_build_scoring_frame_returns_empty_when_there_is_no_recent_reading() -> None:
-    recent = make_recent("site-a", heures=0, depart=datetime(2026, 1, 1, tzinfo=UTC))
-
-    scoring_frame = build_scoring_frame(recent)
-
-    assert scoring_frame.empty
-
-
-def target_at_for(depart: datetime, heures: int) -> datetime:
-    """`target_at` que produira `build_scoring_frame` pour ce jeu synthetique (derniere lecture
-    + 1h) : l'utiliser comme `instant` donne un age d'1h, largement sous le seuil de peremption,
-    pour les tests qui ne visent pas ce filtre."""
-    return depart + timedelta(hours=heures)
-
-
-def test_score_marks_insufficient_history_without_calling_the_model() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    scoring_frame = build_scoring_frame(make_recent("site-a", heures=100, depart=depart))
-    booster = FakeBooster()
-
-    resultats = score(
-        booster,  # type: ignore[arg-type]
-        scoring_frame,
-        instant=target_at_for(depart, 100),
-    )
-
-    assert resultats == [
-        ScoredSite(
-            site_id="site-a",
-            target_at=resultats[0].target_at,
-            status="insufficient_data",
-            predicted_value=None,
-            failure_reason=resultats[0].failure_reason,
-        )
-    ]
-    assert booster.appels == []
-
-
-def test_score_predicts_when_history_is_sufficient() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    scoring_frame = build_scoring_frame(make_recent("site-a", heures=200, depart=depart))
-    booster = FakeBooster(valeur=99.5)
-
-    resultats = score(
-        booster,  # type: ignore[arg-type]
-        scoring_frame,
-        instant=target_at_for(depart, 200),
-    )
-
-    assert len(resultats) == 1
-    assert resultats[0].status == "available"
-    assert resultats[0].predicted_value == 99.5
-    assert resultats[0].failure_reason is None
-    assert booster.appels == [1]
-
-
-def test_score_marks_a_stale_site_as_insufficient_data_without_calling_the_model() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    # Historique largement suffisant (168h+), mais l'instant de reference est loin apres la
-    # derniere lecture : la fraicheur doit primer sur la disponibilite de l'historique.
-    scoring_frame = build_scoring_frame(make_recent("site-a", heures=200, depart=depart))
-    instant = target_at_for(depart, 200) + MAX_STALENESS + timedelta(hours=1)
-    booster = FakeBooster()
-
-    resultats = score(booster, scoring_frame, instant=instant)  # type: ignore[arg-type]
-
-    assert len(resultats) == 1
-    assert resultats[0].status == "insufficient_data"
-    assert resultats[0].predicted_value is None
-    assert "vieille" in (resultats[0].failure_reason or "")
-    assert booster.appels == []
-
-
-def test_score_accepts_a_reading_exactly_at_the_staleness_threshold() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    scoring_frame = build_scoring_frame(make_recent("site-a", heures=200, depart=depart))
-    # `target_at_for(...)` donne deja un age d'1h (cf. sa docstring) : retrancher cette heure
-    # pour retomber exactement sur le seuil, ni en dessous ni au dessus.
-    instant = target_at_for(depart, 200) + MAX_STALENESS - timedelta(hours=1)
-    booster = FakeBooster(valeur=12.0)
-
-    resultats = score(booster, scoring_frame, instant=instant)  # type: ignore[arg-type]
-
-    assert resultats[0].status == "available"
-    assert booster.appels == [1]
-
-
-def test_write_predictions_does_nothing_when_there_is_nothing_to_write() -> None:
-    connection = FakeConnection()
-
-    write_predictions(connection, [], reference="lightgbm-test")  # type: ignore[arg-type]
-
-    assert connection.appels == []
-
-
-def test_write_predictions_sends_one_row_per_result() -> None:
-    connection = FakeConnection()
-    resultats = [
-        ScoredSite("site-a", datetime(2026, 1, 1, tzinfo=UTC), "available", 42.0, None),
-        ScoredSite(
-            "site-b",
-            datetime(2026, 1, 1, tzinfo=UTC),
-            "insufficient_data",
-            None,
-            "pas assez d'historique",
-        ),
-    ]
-
-    write_predictions(connection, resultats, reference="lightgbm-test")  # type: ignore[arg-type]
-
-    assert len(connection.appels) == 1
-    _, lignes = connection.appels[0]
-    assert len(lignes) == 2
-    assert lignes[0]["model_reference"] == "lightgbm-test"
-    assert lignes[0]["target_metric"] == "consumption_kwh"
-    assert lignes[0]["period_minutes"] == 60
-
-
-def test_model_reference_is_stable_for_the_same_file_content(tmp_path: Path) -> None:
-    model_path = tmp_path / "model.txt"
-    model_path.write_bytes(b"contenu-du-modele")
-
-    assert model_reference(model_path) == model_reference(model_path)
-
-
-def test_model_reference_changes_with_the_file_content(tmp_path: Path) -> None:
-    premier = tmp_path / "model-a.txt"
-    premier.write_bytes(b"version-1")
-    second = tmp_path / "model-b.txt"
-    second.write_bytes(b"version-2")
-
-    assert model_reference(premier) != model_reference(second)
-
-
-def test_run_scoring_in_csv_mode_scores_without_touching_a_database(tmp_path: Path) -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    frame = pd.concat(
-        [
-            make_recent("site-a", heures=400, depart=depart),
-            make_recent("site-b", heures=400, depart=depart),
-        ],
-        ignore_index=True,
-    )
-    csv_path = tmp_path / "recent.csv"
-    frame.to_csv(csv_path, index=False)
-
-    model_path = tmp_path / "model.txt"
-    model_path.write_bytes(b"peu importe le contenu pour ce test")
-
-    with pytest.MonkeyPatch.context() as monkeypatch:
-        monkeypatch.setattr(
-            "enervision_ml.score.lgb.Booster", lambda model_file: FakeBooster(valeur=7.0)
-        )
-
-        resultats = run_scoring(model_path=model_path, csv_path=csv_path)
-
-    assert {r.site_id for r in resultats} == {"site-a", "site-b"}
-    assert all(r.status == "available" for r in resultats)
-    assert all(r.predicted_value == 7.0 for r in resultats)

sonar-project.properties

@@ -2,16 +2,8 @@ sonar.projectKey=ProjetPiscine_EnerVision
 sonar.organization=groupe3-ener-vision
 sonar.sourceEncoding=UTF-8
 
-#  Dossier contenant le code source
+sonar.sources=apps/frontend/src,apps/backend/app
-sonar.sources=apps/frontend/src,apps/backend
-#  Dossier contenant les tests
-sonar.tests=apps/frontend/src,apps/backend/tests
-sonar.test.inclusions=**/*.spec.ts,**/*.test.ts,**/*test_*.py,**/*test.py
 
-#  Liste des fichiers et dossiers à exclure de l'analyse
+sonar.exclusions=**/node_modules/**,**/dist/**,**/*.spec.js,**/*.test.js,github,db,ml,docker-compose.yml,**/**/Dockerfile,**/**/proxy.conf.json,**/**/package.json,**/**/angular.json
-sonar.exclusions=.pytest_cache,.venv,alembic,tests,**/*/node_modules/**,**/*/dist/**,**/*/build/**,**/*.spec.ts,**/*.test.ts,**/*test_*.py,**/*test.py
 
-#  Chemin vers le rapport de couverture de code
-#  Fichier généré par Pytest
-sonar.python.coverage.reportPaths=apps/backend/coverage.xml
 sonar.javascript.lcov.reportPaths=apps/frontend/coverage/frontend/lcov.info