feat(ml): initialise le pipeline d'entrainement LightGBM (ADR 0005)

feat: ajout dependances dependabot

.github/dependabot.yml

@@ -0,0 +1,40 @@
+version: 2
+updates:
+  # Frontend — npm
+  - package-ecosystem: "npm"
+    directory: "/apps/frontend"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 5
+    groups:
+      frontend-dependencies:
+        patterns:
+          - "*"
+
+  # Backend — uv (lit pyproject.toml / uv.lock)
+  - package-ecosystem: "uv"
+    directory: "/apps/backend"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 5
+    groups:
+      backend-dependencies:
+        patterns:
+          - "*"
+
+  # Les workflows GitHub Actions eux-mêmes ont aussi des dépendances à jour
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  # Si un Dockerfile existe pour le backend
+  - package-ecosystem: "docker"
+    directory: "/apps/backend"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "docker"
+    directory: "/apps/frontend"
+    schedule:
+      interval: "weekly"

.github/workflows/ml.yml

@@ -0,0 +1,59 @@
+name: ML
+
+# Piège : la version de Python vient de ml/.python-version, et doit rester en 3.14 (cf.
+# .github/workflows/backend.yml, même contrainte).
+
+on:
+  push:
+    paths:
+      - "ml/**"
+      - ".github/workflows/ml.yml"
+  pull_request:
+    paths:
+      - "ml/**"
+      - ".github/workflows/ml.yml"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ml-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  verification:
+    name: Lint, typage et tests
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ml
+
+    steps:
+      - name: Récupère le dépôt
+        uses: actions/checkout@v4
+
+      - name: Installe uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          cache-dependency-glob: ml/uv.lock
+
+      - name: Installe l'interpréteur déclaré par .python-version
+        run: uv python install
+
+      - name: Synchronise les dépendances sans dévier du verrou
+        run: uv sync --all-groups --frozen
+
+      - name: Vérifie le formatage
+        run: uv run ruff format --check .
+
+      - name: Analyse statique
+        run: uv run ruff check --output-format=github .
+
+      - name: Typage
+        run: uv run mypy enervision_ml tests
+
+      # Aucun test ne touche PostgreSQL ni MLflow distant : tout tourne sur donnees
+      # synthetiques ou un magasin SQLite local jetable (cf. ml/tests/test_train.py).
+      - name: Tests
+        run: uv run pytest

.gitignore

@@ -58,6 +58,14 @@ data/raw/*
 monitoring/grafana/data/
 monitoring/prometheus/data/
 
+# ML : jeu de donnees, modeles entraines et suivi MLflow local, tous generes/volumineux
+ml/data/
+ml/models/*
+!ml/models/.gitkeep
+ml/mlruns/
+ml/mlartifacts/
+ml/mlflow.db
+
 # IDE et OS
 .idea/
 .vscode/

Makefile

@@ -1,15 +1,17 @@
 BACKEND := apps/backend
 FRONTEND := apps/frontend
+ML := ml
 
 .DEFAULT_GOAL := help
-.PHONY: help install install-backend install-frontend dev dev-backend dev-frontend \
+.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
+        openapi docker-build db-up db-down db-reset db-logs db-psql migrate bootstrap-admin \
+        ml-lint ml-typecheck ml-test ml-check ml-train
 
 help: ## Liste les cibles disponibles
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'
 
-install: install-backend install-frontend ## Installe les dépendances backend et frontend
+install: install-backend install-frontend install-ml ## Installe les dépendances backend, frontend et ML
 
 install-backend: ## Installe les dépendances du backend
 	cd $(BACKEND) && uv sync --all-groups
@@ -17,6 +19,9 @@ install-backend: ## Installe les dépendances du backend
 install-frontend: ## Installe les dépendances du frontend
 	cd $(FRONTEND) && npm ci
 
+install-ml: ## Installe les dépendances du pipeline ML
+	cd $(ML) && uv sync --all-groups
+
 dev: ## Lance toute la stack (backend + frontend) en rechargement à chaud
 	@trap 'kill 0' EXIT INT TERM; \
 	$(MAKE) --no-print-directory dev-backend & \
@@ -55,6 +60,20 @@ check: lint typecheck test ## Chaîne de vérification complète
 openapi: ## Régénère apps/backend/openapi.json depuis les routes déclarées
 	cd $(BACKEND) && uv run python -m app.cli export-openapi
 
+ml-lint: ## Analyse statique du pipeline ML
+	cd $(ML) && uv run ruff check .
+
+ml-typecheck: ## Vérifie le typage du pipeline ML
+	cd $(ML) && uv run mypy enervision_ml tests
+
+ml-test: ## Exécute les tests du pipeline ML (donnees synthetiques, sans base ni serveur MLflow)
+	cd $(ML) && uv run pytest
+
+ml-check: ml-lint ml-typecheck ml-test ## Chaîne de vérification complète du pipeline ML
+
+ml-train: ## Entraine le modele LightGBM. CSV=chemin optionnel, sinon lit ML_DATABASE_URL
+	cd $(ML) && uv run python -m enervision_ml.train $(if $(CSV),--csv $(CSV),)
+
 docker-build: ## Construit l'image du backend
 	docker build -t enervision-backend:local $(BACKEND)
 

README.md

@@ -25,6 +25,7 @@ Ce que la documentation apporte à chacun : [docs/architecture/00-vue-ensemble.m
 | Infra      | Terraform (k3s single-node)         | `infra/terraform`   | Initialise    |
 | CI/CD      | GitHub Actions                      | `.github/workflows` | Backend en place |
 | Monitoring | Prometheus, Grafana, Alertmanager   | `monitoring`        | A initialiser |
+| ML         | LightGBM, MLflow                    | `ml`                | Entrainement initialise |
 
 Le backend, la base et l'infrastructure (Terraform/k3s) sont initialises a ce stade. Le frontend
 sert un tableau de bord sur `/dashboard`, dont les données proviennent de fixtures : les endpoints
@@ -53,6 +54,7 @@ L'etat detaille de chaque brique et les vues d'architecture sont dans
 ├── infra/terraform/
 │   ├── modules/        Modules reutilisables
 │   └── environments/   Racines Terraform, une par environnement
+├── ml/                 Pipeline d'entrainement LightGBM, suivi MLflow
 ├── monitoring/
 │   ├── prometheus/     Collecte et regles d'alerte
 │   ├── grafana/        Provisioning et dashboards

apps/backend/.env.example

@@ -8,13 +8,3 @@ APP_SECRET_KEY=change_me
 
 APP_CORS_ORIGINS=http://localhost:4200
 DATABASE_URL=postgresql+asyncpg://enervision:change_me@localhost:5433/enervision
-
-# Mot de passe oublié : lien à usage unique valable 15 minutes par défaut.
-APP_FRONTEND_RESET_PASSWORD_URL=http://localhost:4200/reset-password
-
-# SMTP local de dev (Mailpit, cf. docker-compose.yml) : aucune authentification, aucun TLS.
-# À remplacer par un vrai relais en staging/prod.
-APP_SMTP_HOST=localhost
-APP_SMTP_PORT=1025
-APP_SMTP_USE_TLS=false
-APP_SMTP_FROM_ADDRESS=no-reply@enervision.fr

apps/backend/README.md

@@ -103,8 +103,6 @@ Le sens de dependance est unique : `endpoints` vers `services` vers `repositorie
 | `/api/v1/auth/logout` | Ferme la session courante | cookie, idempotente |
 | `/api/v1/auth/logout-all` | Ferme toutes les sessions du compte | jeton |
 | `/api/v1/auth/password` | Change son propre mot de passe | jeton |
-| `/api/v1/auth/forgot-password` | Demande un lien de réinitialisation par email | public |
-| `/api/v1/auth/reset-password` | Choisit un nouveau mot de passe depuis ce lien | public |
 | `/api/v1/auth/me` | Décrit le compte connecté | jeton |
 | `/api/v1/users` | Liste et crée des comptes | `admin` |
 | `/api/v1/users/{id}` | Change le rôle ou l'activation | `admin` |

apps/backend/alembic/versions/c0adab96238c_jetons_de_reinitialisation.py

@@ -1,96 +0,0 @@
-"""jetons et tentatives de reinitialisation de mot de passe
-
-Revision ID: c0adab96238c
-Revises: e6d2026091501
-Create Date: 2026-09-17 10:37:12.571314
-
-Meme schema que `refresh_token` pour `password_reset_token` : seule l'empreinte SHA-256 du
-jeton est stockee, jamais le jeton lui-meme, pour la meme raison (revocation en cascade,
-aucune session utilisable dans un pg_dump qui fuiterait).
-
-`password_reset_attempt` vit hors de `audit_log`, comme `login_attempt`, car son volume est
-pilote par l'attaquant : une campagne de demandes y ecrirait des lignes que l'audit, en ajout
-seul, ne devrait jamais purger.
-"""
-
-from collections.abc import Sequence
-
-import sqlalchemy as sa
-from alembic import op
-from sqlalchemy.dialects import postgresql
-
-revision: str = "c0adab96238c"
-down_revision: str | Sequence[str] | None = "e6d2026091501"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-JETONS_VIVANTS = "consumed_at is null"
-
-
-def upgrade() -> None:
-    op.create_table(
-        "password_reset_attempt",
-        sa.Column("id", sa.BigInteger(), sa.Identity(always=True), nullable=False),
-        sa.Column(
-            "occurred_at",
-            sa.DateTime(timezone=True),
-            server_default=sa.text("now()"),
-            nullable=False,
-        ),
-        sa.Column("email_tried", sa.String(length=320), nullable=False),
-        sa.Column("client_ip", postgresql.INET(), nullable=True),
-        sa.PrimaryKeyConstraint("id", name="pk_password_reset_attempt"),
-    )
-    op.create_index(
-        "ix_password_reset_attempt_email_date",
-        "password_reset_attempt",
-        ["email_tried", "occurred_at"],
-    )
-    op.create_index(
-        "ix_password_reset_attempt_ip_date", "password_reset_attempt", ["client_ip", "occurred_at"]
-    )
-
-    op.create_table(
-        "password_reset_token",
-        sa.Column("id", sa.UUID(), server_default=sa.text("gen_random_uuid()"), nullable=False),
-        sa.Column("user_id", sa.UUID(), nullable=False),
-        sa.Column("token_hash", sa.LargeBinary(), nullable=False),
-        sa.Column(
-            "issued_at",
-            sa.DateTime(timezone=True),
-            server_default=sa.text("now()"),
-            nullable=False,
-        ),
-        sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
-        sa.Column("consumed_at", sa.DateTime(timezone=True), nullable=True),
-        sa.Column("client_ip", postgresql.INET(), nullable=True),
-        sa.Column("user_agent", sa.Text(), nullable=True),
-        sa.ForeignKeyConstraint(
-            ["user_id"],
-            ["app_user.id"],
-            name="fk_password_reset_token_user",
-            ondelete="CASCADE",
-        ),
-        sa.PrimaryKeyConstraint("id", name="pk_password_reset_token"),
-        sa.UniqueConstraint("token_hash", name="uq_password_reset_token_hash"),
-    )
-    op.create_index("ix_password_reset_token_user", "password_reset_token", ["user_id"])
-    op.create_index(
-        "ix_password_reset_token_vivants",
-        "password_reset_token",
-        ["user_id"],
-        postgresql_where=JETONS_VIVANTS,
-    )
-
-
-def downgrade() -> None:
-    op.drop_index(
-        "ix_password_reset_token_vivants",
-        table_name="password_reset_token",
-        postgresql_where=JETONS_VIVANTS,
-    )
-    op.drop_index("ix_password_reset_token_user", table_name="password_reset_token")
-    op.drop_table("password_reset_token")
-    op.drop_index("ix_password_reset_attempt_ip_date", table_name="password_reset_attempt")
-    op.drop_index("ix_password_reset_attempt_email_date", table_name="password_reset_attempt")
-    op.drop_table("password_reset_attempt")

apps/backend/app/api/deps.py

@@ -16,7 +16,6 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.config import Settings, get_settings
 from app.core.hashing import Argon2Hasher, build_hasher
-from app.core.mailer import Mailer, SmtpConfig
 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role, has_at_least
 from app.core.security import TokenExpiredError, TokenInvalidError, TokenPolicy
@@ -25,15 +24,13 @@ from app.db.session import get_session
 from app.repositories.alert import AlertRepository
 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.reading import ReadingRepository
 from app.repositories.recommendation import RecommendationRepository
 from app.repositories.refresh_token import RefreshTokenRepository
 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.auth import AuthService, LoginPolicy
 from app.services.reading import ReadingService
 from app.services.recommendation import RecommendationService
 from app.services.sensor import SensorService
@@ -101,27 +98,11 @@ def get_client_ip(request: Request, settings: SettingsDep) -> str | None:
     return request.client.host if request.client else None
 
 
-def get_mailer(settings: SettingsDep) -> Mailer:
-    return Mailer(
-        SmtpConfig(
-            host=settings.smtp_host,
-            port=settings.smtp_port,
-            username=settings.smtp_username,
-            password=(
-                settings.smtp_password.get_secret_value() if settings.smtp_password else None
-            ),
-            use_tls=settings.smtp_use_tls,
-            from_address=settings.smtp_from_address,
-        )
-    )
-
-
 def get_auth_service(
     session: SessionDep,
     settings: SettingsDep,
     hasher: Annotated[Argon2Hasher, Depends(get_hasher)],
     token_policy: Annotated[TokenPolicy, Depends(get_token_policy)],
-    mailer: Annotated[Mailer, Depends(get_mailer)],
 ) -> AuthService:
     return AuthService(
         users=UserRepository(session),
@@ -138,16 +119,6 @@ def get_auth_service(
             max_failures_per_identifier=settings.login_max_failures_per_identifier,
         ),
         refresh_ttl=timedelta(seconds=settings.refresh_token_ttl_seconds),
-        reset_tokens=PasswordResetTokenRepository(session),
-        reset_attempts=PasswordResetAttemptRepository(session),
-        reset_policy=PasswordResetPolicy(
-            window_seconds=settings.password_reset_window_seconds,
-            max_requests_per_identifier=settings.password_reset_max_requests_per_identifier,
-            max_requests_per_ip=settings.password_reset_max_requests_per_ip,
-            token_ttl=timedelta(seconds=settings.password_reset_ttl_seconds),
-            frontend_reset_url=settings.frontend_reset_password_url,
-        ),
-        mailer=mailer,
     )
 
 

apps/backend/app/api/openapi.py

@@ -164,16 +164,3 @@ REPONSE_ORIGINE_REFUSEE: Final[Reponses] = {
         "description": "Origine non autorisée (protection CSRF de `require_trusted_origin`).",
     },
 }
-
-REPONSE_LIMITE: Final[Reponses] = {
-    429: {
-        "model": ErrorResponse,
-        "description": "Trop de demandes sur cette fenêtre glissante.",
-        "headers": {
-            "Retry-After": {
-                "description": "Secondes à attendre avant une nouvelle tentative.",
-                "schema": {"type": "integer"},
-            }
-        },
-    },
-}

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

@@ -2,7 +2,7 @@
 # d'accès ne va jamais dans un cookie. C'est ce qui réduit la surface CSRF aux trois routes de
 # ce module : partout ailleurs, le navigateur n'attache rien de lui-même.
 
-from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Request, Response, status
+from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
 
 from app.api.deps import (
     AuthServiceDep,
@@ -12,7 +12,6 @@ from app.api.deps import (
     require_trusted_origin,
 )
 from app.api.openapi import (
-    REPONSE_LIMITE,
     REPONSE_ORIGINE_REFUSEE,
     REPONSE_VALIDATION,
     REPONSES_AUTHENTIFIEES,
@@ -22,19 +21,15 @@ from app.api.openapi import (
 from app.core.cookies import RefreshCookie, cookie_name
 from app.core.logging import get_logger
 from app.schemas.auth import (
-    ForgotPasswordRequest,
     LoginRequest,
     PasswordChangeRequest,
     PrincipalResponse,
-    ResetPasswordRequest,
-    ResetTokenValidationResponse,
     TokenResponse,
 )
 from app.schemas.errors import ErrorResponse
 from app.services.auth import (
     AuthenticatedSession,
     InvalidCredentialsError,
-    InvalidOrExpiredResetTokenError,
     RateLimitedError,
     SessionRejectedError,
 )
@@ -44,7 +39,6 @@ logger = get_logger(__name__)
 
 DETAIL_IDENTIFIANTS = "Identifiants invalides"
 DETAIL_SESSION = "Session invalide"
-DETAIL_LIEN_RESET = "Lien invalide ou expiré"
 
 REPONSES_LOGIN: Reponses = {
     **REPONSE_VALIDATION,
@@ -91,20 +85,6 @@ REPONSES_MOT_DE_PASSE: Reponses = {
     },
 }
 
-REPONSES_FORGOT_PASSWORD: Reponses = {
-    **REPONSE_VALIDATION,
-    **REPONSE_LIMITE,
-}
-
-REPONSES_RESET_PASSWORD: Reponses = {
-    **REPONSE_VALIDATION,
-    **REPONSE_ORIGINE_REFUSEE,
-    400: {
-        "model": ErrorResponse,
-        "description": "Lien invalide, déjà utilisé, ou expiré (durée de vie : 15 minutes).",
-    },
-}
-
 
 def repond(
     response: Response, settings: SettingsDep, session: AuthenticatedSession
@@ -287,79 +267,3 @@ async def change_password(
 
     logger.info("auth.password_changed user_id=%s", principal.id)
     return repond(response, settings, session)
-
-
-@router.post(
-    "/forgot-password",
-    status_code=status.HTTP_202_ACCEPTED,
-    summary="Demande un lien de réinitialisation par email",
-    responses=REPONSES_FORGOT_PASSWORD,
-)
-async def forgot_password(
-    payload: ForgotPasswordRequest,
-    request: Request,
-    response: Response,
-    service: AuthServiceDep,
-    background_tasks: BackgroundTasks,
-    client_ip: str | None = Depends(get_client_ip),
-) -> None:
-    response.headers["Cache-Control"] = "no-store"
-
-    try:
-        await service.request_password_reset(
-            email=payload.email,
-            client_ip=client_ip,
-            user_agent=request.headers.get("user-agent"),
-            background_tasks=background_tasks,
-        )
-    except RateLimitedError as erreur:
-        logger.warning("auth.password_reset.rate_limited ip=%s", client_ip)
-        raise HTTPException(
-            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-            detail="Trop de demandes, réessayez plus tard",
-            headers={"Retry-After": str(erreur.retry_after)},
-        ) from erreur
-
-
-@router.get(
-    "/reset-password/validate",
-    response_model=ResetTokenValidationResponse,
-    summary="Vérifie sans le consommer si un lien de réinitialisation est encore valide",
-    responses=REPONSE_VALIDATION,
-)
-async def validate_reset_token(token: str, service: AuthServiceDep) -> ResetTokenValidationResponse:
-    return ResetTokenValidationResponse(valid=await service.is_reset_token_valid(token=token))
-
-
-@router.post(
-    "/reset-password",
-    response_model=TokenResponse,
-    summary="Choisit un nouveau mot de passe depuis un lien reçu par email",
-    dependencies=[Depends(require_trusted_origin)],
-    responses=REPONSES_RESET_PASSWORD,
-)
-async def reset_password(
-    payload: ResetPasswordRequest,
-    request: Request,
-    response: Response,
-    settings: SettingsDep,
-    service: AuthServiceDep,
-    client_ip: str | None = Depends(get_client_ip),
-) -> TokenResponse:
-    response.headers["Cache-Control"] = "no-store"
-
-    try:
-        session = await service.confirm_password_reset(
-            token=payload.token,
-            new_password=payload.new_password,
-            client_ip=client_ip,
-            user_agent=request.headers.get("user-agent"),
-        )
-    except InvalidOrExpiredResetTokenError as erreur:
-        logger.warning("auth.password_reset.invalid_token ip=%s", client_ip)
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST, detail=DETAIL_LIEN_RESET
-        ) from erreur
-
-    logger.info("auth.password_reset.success user_id=%s", session.principal.id)
-    return repond(response, settings, session)

apps/backend/app/cli.py

@@ -9,7 +9,6 @@ import argparse
 import asyncio
 import json
 import secrets
-import string
 import sys
 from getpass import getpass
 from pathlib import Path
@@ -23,9 +22,9 @@ from app.core.roles import Role
 from app.db.session import get_session_factory
 from app.main import create_app
 from app.repositories.user import UserRepository
-from app.schemas.auth import PASSWORD_MIN_LENGTH, SPECIAL_CHARACTERS, valide_complexite
 
 LONGUEUR_MOT_DE_PASSE_GENERE = 24
+LONGUEUR_MINIMALE = 12
 CHEMIN_CONTRAT = Path(__file__).resolve().parent.parent / "openapi.json"
 
 
@@ -112,34 +111,15 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def genere_mot_de_passe() -> str:
-    tirage = secrets.SystemRandom()
-    classes = [
-        string.ascii_uppercase,
-        string.ascii_lowercase,
-        string.digits,
-        SPECIAL_CHARACTERS,
-    ]
-    reste = LONGUEUR_MOT_DE_PASSE_GENERE - len(classes)
-    caracteres = [tirage.choice(classe) for classe in classes]
-    caracteres += [tirage.choice("".join(classes)) for _ in range(reste)]
-    tirage.shuffle(caracteres)
-    return "".join(caracteres)
-
-
 def read_password(*, generate: bool) -> str:
     if generate:
-        mot_de_passe = genere_mot_de_passe()
+        mot_de_passe = secrets.token_urlsafe(LONGUEUR_MOT_DE_PASSE_GENERE)
         print(f"Mot de passe généré, il ne sera plus affiché : {mot_de_passe}")
         return mot_de_passe
 
     mot_de_passe = getpass("Mot de passe : ")
-    if len(mot_de_passe) < PASSWORD_MIN_LENGTH:
-        raise SystemExit(f"Le mot de passe doit faire au moins {PASSWORD_MIN_LENGTH} caractères")
-    try:
-        valide_complexite(mot_de_passe)
-    except ValueError as erreur:
-        raise SystemExit(str(erreur)) from erreur
+    if len(mot_de_passe) < LONGUEUR_MINIMALE:
+        raise SystemExit(f"Le mot de passe doit faire au moins {LONGUEUR_MINIMALE} caractères")
     if mot_de_passe != getpass("Confirmation : "):
         raise SystemExit("Les deux saisies diffèrent")
     return mot_de_passe

apps/backend/app/core/config.py

@@ -54,19 +54,6 @@ class Settings(BaseSettings):
     login_max_failures_per_ip: int = Field(default=20, ge=1)
     login_max_failures_per_identifier: int = Field(default=50, ge=1)
 
-    password_reset_ttl_seconds: int = Field(default=900, ge=60, le=3600)
-    password_reset_window_seconds: int = Field(default=900, ge=60)
-    password_reset_max_requests_per_identifier: int = Field(default=3, ge=1)
-    password_reset_max_requests_per_ip: int = Field(default=10, ge=1)
-
-    smtp_host: str = "localhost"
-    smtp_port: int = Field(default=587, ge=1, le=65535)
-    smtp_username: str | None = None
-    smtp_password: SecretStr | None = None
-    smtp_use_tls: bool = False
-    smtp_from_address: str = "no-reply@enervision.fr"
-    frontend_reset_password_url: str = "http://localhost:4200/reset-password"  # noqa: S105
-
     trust_proxy_headers: bool = False
     expose_api_docs: bool | None = None
     metrics_token: SecretStr | None = None

apps/backend/app/core/mailer.py

@@ -1,48 +0,0 @@
-# Piège : l'URL de réinitialisation porte le jeton en clair. Ne jamais la journaliser :
-# `send_password_reset_email()` ne logue que le destinataire, jamais `reset_url`.
-
-from dataclasses import dataclass
-from email.message import EmailMessage
-
-import aiosmtplib
-
-from app.core.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-@dataclass(frozen=True, slots=True)
-class SmtpConfig:
-    host: str
-    port: int
-    username: str | None
-    password: str | None
-    use_tls: bool
-    from_address: str
-
-
-class Mailer:
-    def __init__(self, config: SmtpConfig) -> None:
-        self._config = config
-
-    async def send_password_reset_email(self, *, to: str, reset_url: str) -> None:
-        message = EmailMessage()
-        message["From"] = self._config.from_address
-        message["To"] = to
-        message["Subject"] = "Réinitialisation de votre mot de passe EnerVision"
-        message.set_content(
-            "Une réinitialisation de mot de passe a été demandée pour ce compte.\n\n"
-            f"Ouvrez ce lien dans les 15 minutes pour choisir un nouveau mot de passe : "
-            f"{reset_url}\n\n"
-            "Si vous n'êtes pas à l'origine de cette demande, ignorez cet email."
-        )
-
-        _, message_recu = await aiosmtplib.send(
-            message,
-            hostname=self._config.host,
-            port=self._config.port,
-            username=self._config.username,
-            password=self._config.password,
-            use_tls=self._config.use_tls,
-        )
-        logger.info("mailer.password_reset_sent to=%s smtp_response=%s", to, message_recu)

apps/backend/app/models/__init__.py

@@ -4,8 +4,6 @@
 from app.models.audit_log import AuditLog
 from app.models.energy import Alert, Dataset, Prediction, Reading, Recommendation, Site
 from app.models.login_attempt import LoginAttempt
-from app.models.password_reset_attempt import PasswordResetAttempt
-from app.models.password_reset_token import PasswordResetToken
 from app.models.refresh_token import RefreshToken
 from app.models.user import AppUser
 
@@ -15,8 +13,6 @@ __all__ = [
     "AuditLog",
     "Dataset",
     "LoginAttempt",
-    "PasswordResetAttempt",
-    "PasswordResetToken",
     "Prediction",
     "Reading",
     "Recommendation",

apps/backend/app/models/audit_log.py

@@ -29,8 +29,6 @@ class AuditAction(StrEnum):
     COMPTE_ACTIVE = "user.enabled"
     COMPTE_MOT_DE_PASSE_REINITIALISE = "user.password_reset_by_admin"
     COMPTE_MOT_DE_PASSE_CHANGE = "user.password_changed"
-    MOT_DE_PASSE_OUBLIE_DEMANDE = "auth.password_reset_requested"
-    MOT_DE_PASSE_REINITIALISE_PAR_SOI = "auth.password_reset_self_service"
     REFRESH_REUTILISE = "auth.refresh_reuse_detected"
     SESSIONS_REVOQUEES = "auth.all_sessions_revoked"
     LIMITE_PAR_IDENTIFIANT = "auth.identifier_throttled"

apps/backend/app/models/password_reset_attempt.py

@@ -1,27 +0,0 @@
-# Pourquoi : même séparation que `login_attempt` par rapport à `audit_log` : ce compteur est
-# piloté par l'attaquant (une campagne de demandes) et se purge, l'audit log est en ajout seul.
-# Piège : la tentative est enregistrée même quand l'email est inconnu, sinon le 429 apprendrait
-# qu'un compte existe.
-
-from datetime import datetime
-
-from sqlalchemy import BigInteger, DateTime, Identity, Index, String, func
-from sqlalchemy.dialects.postgresql import INET
-from sqlalchemy.orm import Mapped, mapped_column
-
-from app.db.base import Base
-
-
-class PasswordResetAttempt(Base):
-    __tablename__ = "password_reset_attempt"
-    __table_args__ = (
-        Index("ix_password_reset_attempt_email_date", "email_tried", "occurred_at"),
-        Index("ix_password_reset_attempt_ip_date", "client_ip", "occurred_at"),
-    )
-
-    id: Mapped[int] = mapped_column(BigInteger, Identity(always=True), primary_key=True)
-    occurred_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    email_tried: Mapped[str] = mapped_column(String(320), nullable=False)
-    client_ip: Mapped[str | None] = mapped_column(INET, nullable=True)

apps/backend/app/models/password_reset_token.py

@@ -1,40 +0,0 @@
-# Pourquoi : même schéma que `refresh_token` (chaîne opaque, jamais un JWT) pour la même
-# raison : un jeton de réinitialisation doit être révocable d'un coup, et un JWT ne figure
-# dans aucune ligne à invalider.
-
-import uuid
-from datetime import datetime
-
-from sqlalchemy import DateTime, ForeignKey, Index, LargeBinary, Text, func
-from sqlalchemy.dialects.postgresql import INET
-from sqlalchemy.dialects.postgresql import UUID as PG_UUID
-from sqlalchemy.orm import Mapped, mapped_column
-
-from app.db.base import Base
-
-
-class PasswordResetToken(Base):
-    __tablename__ = "password_reset_token"
-    __table_args__ = (
-        Index("ix_password_reset_token_user", "user_id"),
-        Index(
-            "ix_password_reset_token_vivants",
-            "user_id",
-            postgresql_where="consumed_at is null",
-        ),
-    )
-
-    id: Mapped[uuid.UUID] = mapped_column(
-        PG_UUID(as_uuid=True), primary_key=True, server_default=func.gen_random_uuid()
-    )
-    user_id: Mapped[uuid.UUID] = mapped_column(
-        PG_UUID(as_uuid=True), ForeignKey("app_user.id", ondelete="CASCADE"), nullable=False
-    )
-    token_hash: Mapped[bytes] = mapped_column(LargeBinary, nullable=False, unique=True)
-    issued_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now()
-    )
-    expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
-    consumed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
-    client_ip: Mapped[str | None] = mapped_column(INET, nullable=True)
-    user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)

apps/backend/app/repositories/password_reset_attempt.py

@@ -1,42 +0,0 @@
-from dataclasses import dataclass
-from datetime import UTC, datetime, timedelta
-
-from sqlalchemy import func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.models.password_reset_attempt import PasswordResetAttempt
-
-
-@dataclass(frozen=True, slots=True)
-class ResetRequestCounts:
-    per_identifier: int
-    per_ip: int
-
-
-class PasswordResetAttemptRepository:
-    def __init__(self, session: AsyncSession) -> None:
-        self._session = session
-
-    async def record(self, *, email: str, client_ip: str | None) -> None:
-        self._session.add(
-            PasswordResetAttempt(email_tried=email.strip().lower(), client_ip=client_ip)
-        )
-
-    async def count_recent(
-        self, *, email: str, client_ip: str | None, window_seconds: int
-    ) -> ResetRequestCounts:
-        identifiant = email.strip().lower()
-        meme_email = PasswordResetAttempt.email_tried == identifiant
-        meme_ip = PasswordResetAttempt.client_ip == client_ip
-
-        requete = select(
-            func.count().filter(meme_email),
-            func.count().filter(meme_ip),
-        ).where(
-            PasswordResetAttempt.occurred_at
-            > datetime.now(UTC) - timedelta(seconds=window_seconds),
-            meme_email | meme_ip,
-        )
-
-        par_identifiant, par_ip = (await self._session.execute(requete)).one()
-        return ResetRequestCounts(per_identifier=par_identifiant, per_ip=par_ip)

apps/backend/app/repositories/password_reset_token.py

@@ -1,78 +0,0 @@
-# Piège : `consume()` est une seule instruction, sur le modèle de `claim_for_rotation()` du
-# jeton de rafraîchissement. Un SELECT puis un UPDATE laisseraient une fenêtre où deux
-# soumissions concurrentes du même lien réussiraient toutes les deux.
-
-from dataclasses import dataclass
-from datetime import datetime
-from uuid import UUID
-
-from sqlalchemy import func, select, update
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.models.password_reset_token import PasswordResetToken
-
-
-@dataclass(frozen=True, slots=True)
-class ConsumedResetToken:
-    id: UUID
-    user_id: UUID
-
-
-class PasswordResetTokenRepository:
-    def __init__(self, session: AsyncSession) -> None:
-        self._session = session
-
-    async def create(
-        self,
-        *,
-        user_id: UUID,
-        token_hash: bytes,
-        expires_at: datetime,
-        client_ip: str | None,
-        user_agent: str | None,
-    ) -> PasswordResetToken:
-        jeton = PasswordResetToken(
-            user_id=user_id,
-            token_hash=token_hash,
-            expires_at=expires_at,
-            client_ip=client_ip,
-            user_agent=user_agent,
-        )
-        self._session.add(jeton)
-        await self._session.flush()
-        return jeton
-
-    async def consume(self, token_hash: bytes) -> ConsumedResetToken | None:
-        requete = (
-            update(PasswordResetToken)
-            .where(
-                PasswordResetToken.token_hash == token_hash,
-                PasswordResetToken.consumed_at.is_(None),
-                PasswordResetToken.expires_at > func.clock_timestamp(),
-            )
-            .values(consumed_at=func.clock_timestamp())
-            .returning(PasswordResetToken.id, PasswordResetToken.user_id)
-        )
-        ligne = (await self._session.execute(requete)).one_or_none()
-        if ligne is None:
-            return None
-        return ConsumedResetToken(id=ligne.id, user_id=ligne.user_id)
-
-    # Piège : simple SELECT, volontairement pas atomique avec la consommation. Sert seulement
-    # au feedback UX (jeton encore valide ?) ; `consume()` reste la seule source de vérité.
-    async def exists_valid(self, token_hash: bytes) -> bool:
-        requete = select(PasswordResetToken.id).where(
-            PasswordResetToken.token_hash == token_hash,
-            PasswordResetToken.consumed_at.is_(None),
-            PasswordResetToken.expires_at > func.clock_timestamp(),
-        )
-        return (await self._session.execute(requete)).first() is not None
-
-    async def invalidate_all_for_user(self, user_id: UUID) -> int:
-        resultat = await self._session.execute(
-            update(PasswordResetToken)
-            .where(PasswordResetToken.user_id == user_id, PasswordResetToken.consumed_at.is_(None))
-            .values(consumed_at=func.clock_timestamp())
-            .returning(PasswordResetToken.id)
-        )
-        return len(resultat.all())

apps/backend/app/schemas/auth.py

@@ -1,45 +1,17 @@
 # Contrainte : le mot de passe est borné à 128 caractères. Sans plafond, une chaîne de dix
 # mégaoctets ferait travailler Argon2 gratuitement, à la charge du serveur.
-# Contrainte : `SPECIAL_CHARACTERS` doit rester identique à `password.validator.ts` côté
-# frontend. `\w`/`\d` divergent entre Python (Unicode) et JavaScript (ASCII) : une classe
-# explicite, plutôt qu'une négation, évite qu'un mot de passe soit accepté d'un côté et
-# rejeté de l'autre (ex. "Sécurité1", où "é" comptait comme "spécial" pour Python seul).
 
-import re
 from typing import Literal, Self
 from uuid import UUID
 
-from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
+from pydantic import BaseModel, ConfigDict, EmailStr, Field
 
 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role
 
-PASSWORD_MIN_LENGTH = 8
+PASSWORD_MIN_LENGTH = 12
 PASSWORD_MAX_LENGTH = 128
 
-SPECIAL_CHARACTERS = "!@#$%^&*()-_=+[]{};:,.?"
-
-_MAJUSCULE = re.compile(r"[A-ZÀ-ÖØ-Þ]")
-_MINUSCULE = re.compile(r"[a-zà-öø-þ]")
-_CHIFFRE = re.compile(r"[0-9]")
-_SPECIAL = re.compile(r"[" + re.escape(SPECIAL_CHARACTERS) + r"]")
-
-
-def valide_complexite(mot_de_passe: str) -> str:
-    manquants = [
-        nom
-        for nom, motif in (
-            ("une majuscule", _MAJUSCULE),
-            ("une minuscule", _MINUSCULE),
-            ("un chiffre", _CHIFFRE),
-            ("un caractère spécial", _SPECIAL),
-        )
-        if not motif.search(mot_de_passe)
-    ]
-    if manquants:
-        raise ValueError(f"Le mot de passe doit contenir au moins {', '.join(manquants)}")
-    return mot_de_passe
-
 
 class LoginRequest(BaseModel):
     email: EmailStr
@@ -50,25 +22,6 @@ class PasswordChangeRequest(BaseModel):
     current_password: str = Field(min_length=1, max_length=PASSWORD_MAX_LENGTH)
     new_password: str = Field(min_length=PASSWORD_MIN_LENGTH, max_length=PASSWORD_MAX_LENGTH)
 
-    @field_validator("new_password")
-    @classmethod
-    def _new_password_est_complexe(cls, valeur: str) -> str:
-        return valide_complexite(valeur)
-
-
-class ForgotPasswordRequest(BaseModel):
-    email: EmailStr
-
-
-class ResetPasswordRequest(BaseModel):
-    token: str = Field(min_length=1)
-    new_password: str = Field(min_length=PASSWORD_MIN_LENGTH, max_length=PASSWORD_MAX_LENGTH)
-
-    @field_validator("new_password")
-    @classmethod
-    def _new_password_est_complexe(cls, valeur: str) -> str:
-        return valide_complexite(valeur)
-
 
 class PrincipalResponse(BaseModel):
     model_config = ConfigDict(from_attributes=True)
@@ -84,10 +37,6 @@ class PrincipalResponse(BaseModel):
         return cls.model_validate(principal)
 
 
-class ResetTokenValidationResponse(BaseModel):
-    valid: bool
-
-
 class TokenResponse(BaseModel):
     access_token: str
     token_type: Literal["bearer"] = "bearer"  # noqa: S105

apps/backend/app/services/auth.py

@@ -14,11 +14,7 @@ from datetime import UTC, datetime, timedelta
 from typing import NoReturn, Protocol
 from uuid import UUID, uuid4
 
-from fastapi import BackgroundTasks
-
 from app.core.hashing import Argon2Hasher
-from app.core.logging import get_logger
-from app.core.mailer import Mailer
 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role
 from app.core.security import (
@@ -32,13 +28,9 @@ from app.models.login_attempt import LoginOutcome
 from app.models.refresh_token import RevocationReason
 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.refresh_token import RefreshTokenRepository
 from app.repositories.user import UserRepository
 
-logger = get_logger(__name__)
-
 
 class Transaction(Protocol):
     async def commit(self) -> None: ...
@@ -62,10 +54,6 @@ class RateLimitedError(AuthError):
         self.retry_after = retry_after
 
 
-class InvalidOrExpiredResetTokenError(AuthError):
-    pass
-
-
 @dataclass(frozen=True, slots=True)
 class LoginPolicy:
     window_seconds: int
@@ -74,15 +62,6 @@ class LoginPolicy:
     max_failures_per_identifier: int
 
 
-@dataclass(frozen=True, slots=True)
-class PasswordResetPolicy:
-    window_seconds: int
-    max_requests_per_identifier: int
-    max_requests_per_ip: int
-    token_ttl: timedelta
-    frontend_reset_url: str
-
-
 @dataclass(frozen=True, slots=True)
 class AuthenticatedSession:
     principal: Principal
@@ -104,10 +83,6 @@ class AuthService:
         token_policy: TokenPolicy,
         login_policy: LoginPolicy,
         refresh_ttl: timedelta,
-        reset_tokens: PasswordResetTokenRepository,
-        reset_attempts: PasswordResetAttemptRepository,
-        reset_policy: PasswordResetPolicy,
-        mailer: Mailer,
     ) -> None:
         self._users = users
         self._attempts = attempts
@@ -118,10 +93,6 @@ class AuthService:
         self._token_policy = token_policy
         self._login_policy = login_policy
         self._refresh_ttl = refresh_ttl
-        self._reset_tokens = reset_tokens
-        self._reset_attempts = reset_attempts
-        self._reset_policy = reset_policy
-        self._mailer = mailer
 
     async def authenticate(
         self, *, email: str, password: str, client_ip: str | None, user_agent: str | None
@@ -229,102 +200,6 @@ class AuthService:
         rafraichi = await self._users.get_by_id(principal.id)
         return self._session(self._en_principal(rafraichi or compte), secret)
 
-    async def request_password_reset(
-        self,
-        *,
-        email: str,
-        client_ip: str | None,
-        user_agent: str | None,
-        background_tasks: BackgroundTasks,
-    ) -> None:
-        await self._refuse_si_limite_reset(email=email, client_ip=client_ip)
-
-        compte = await self._users.get_by_email(email)
-        # Piège : le hachage factice équilibre le temps de réponse sur un compte inconnu, comme
-        # `authenticate()`. La réponse et sa forme restent identiques dans tous les cas : compte
-        # inconnu, compte inactif, ou email envoyé avec succès. L'envoi SMTP lui-même est différé
-        # en tâche de fond : le laisser dans le chemin de réponse rouvrirait le même oracle par le
-        # temps (aller-retour réseau) et par la forme (500 si le relais SMTP échoue, contre 202).
-        if compte is None or not compte.is_active or compte.kind != AccountKind.HUMAIN.value:
-            await self._hasher.verify_dummy()
-            await self._reset_attempts.record(email=email, client_ip=client_ip)
-            await self._transaction.commit()
-            return
-
-        await self._reset_tokens.invalidate_all_for_user(compte.id)
-        secret = generate_refresh_secret()
-        await self._reset_tokens.create(
-            user_id=compte.id,
-            token_hash=fingerprint_refresh(secret),
-            expires_at=datetime.now(UTC) + self._reset_policy.token_ttl,
-            client_ip=client_ip,
-            user_agent=user_agent,
-        )
-        await self._reset_attempts.record(email=email, client_ip=client_ip)
-        await self._audit.record(
-            action=AuditAction.MOT_DE_PASSE_OUBLIE_DEMANDE,
-            actor_label=compte.email,
-            target_type="app_user",
-            target_id=str(compte.id),
-            client_ip=client_ip,
-            user_agent=user_agent,
-        )
-        await self._transaction.commit()
-
-        lien = f"{self._reset_policy.frontend_reset_url}?token={secret}"
-        background_tasks.add_task(self._envoie_email_reset, compte.email, lien)
-
-    async def _envoie_email_reset(self, email: str, reset_url: str) -> None:
-        try:
-            await self._mailer.send_password_reset_email(to=email, reset_url=reset_url)
-        except Exception:
-            logger.exception("auth.password_reset.mail_failed")
-
-    # Piège : lecture seule, pas d'appel à `consume()`. Aucune limitation de débit n'est
-    # nécessaire ici : le jeton est un secret de 256 bits (`generate_refresh_secret`), donc
-    # non brute-forçable, et cette route n'apprend rien sur l'existence d'un compte ou d'un
-    # email, seulement si le lien déjà en main du visiteur est encore valide.
-    async def is_reset_token_valid(self, token: str) -> bool:
-        return await self._reset_tokens.exists_valid(fingerprint_refresh(token))
-
-    async def confirm_password_reset(
-        self, *, token: str, new_password: str, client_ip: str | None, user_agent: str | None
-    ) -> AuthenticatedSession:
-        revendique = await self._reset_tokens.consume(fingerprint_refresh(token))
-        if revendique is None:
-            raise InvalidOrExpiredResetTokenError("Lien invalide ou expiré")
-
-        # Piège : le jeton peut avoir été émis avant une désactivation du compte. Sans cette
-        # relecture, un lien encore valide (15 min) changerait quand même le mot de passe d'un
-        # compte désactivé, réutilisable dès sa réactivation.
-        compte = await self._users.get_by_id(revendique.user_id)
-        if compte is None or not compte.is_active or compte.kind != AccountKind.HUMAIN.value:
-            raise InvalidOrExpiredResetTokenError("Lien invalide ou expiré")
-
-        await self._users.update_password(
-            revendique.user_id, await self._hasher.hash(new_password), must_change_password=False
-        )
-        revoquees = await self._refresh.revoke_all_for_user(
-            revendique.user_id, RevocationReason.CHANGEMENT_MOT_DE_PASSE
-        )
-        secret = await self._ouvre_une_famille(
-            user_id=revendique.user_id, client_ip=client_ip, user_agent=user_agent
-        )
-        await self._audit.record(
-            action=AuditAction.MOT_DE_PASSE_REINITIALISE_PAR_SOI,
-            target_type="app_user",
-            target_id=str(revendique.user_id),
-            client_ip=client_ip,
-            user_agent=user_agent,
-            detail={"sessions_revoquees": revoquees},
-        )
-        await self._transaction.commit()
-
-        compte = await self._users.get_by_id(revendique.user_id)
-        if compte is None:
-            raise SessionRejectedError("Compte introuvable")
-        return self._session(self._en_principal(compte), secret)
-
     async def logout_all(self, principal: Principal) -> int:
         revoquees = await self._refresh.revoke_all_for_user(
             principal.id, RevocationReason.DECONNEXION
@@ -432,23 +307,6 @@ class AuthService:
         await self._transaction.commit()
         raise RateLimitedError(politique.window_seconds)
 
-    async def _refuse_si_limite_reset(self, *, email: str, client_ip: str | None) -> None:
-        politique = self._reset_policy
-        compteurs = await self._reset_attempts.count_recent(
-            email=email, client_ip=client_ip, window_seconds=politique.window_seconds
-        )
-
-        depasse = (
-            compteurs.per_identifier >= politique.max_requests_per_identifier
-            or compteurs.per_ip >= politique.max_requests_per_ip
-        )
-        if not depasse:
-            return
-
-        await self._reset_attempts.record(email=email, client_ip=client_ip)
-        await self._transaction.commit()
-        raise RateLimitedError(politique.window_seconds)
-
     async def _echoue(
         self,
         email: str,

apps/backend/openapi.json

@@ -424,196 +424,6 @@
         ]
       }
     },
-    "/api/v1/auth/forgot-password": {
-      "post": {
-        "tags": [
-          "auth"
-        ],
-        "summary": "Demande un lien de réinitialisation par email",
-        "operationId": "forgot_password_api_v1_auth_forgot_password_post",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ForgotPasswordRequest"
-              }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "202": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {}
-              }
-            }
-          },
-          "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"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Corps invalide. Le détail nomme le champ fautif et le type d'erreur, jamais la valeur envoyée.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ValidationErrorResponse"
-                }
-              }
-            }
-          },
-          "429": {
-            "description": "Trop de demandes sur cette fenêtre glissante.",
-            "headers": {
-              "Retry-After": {
-                "description": "Secondes à attendre avant une nouvelle tentative.",
-                "schema": {
-                  "type": "integer"
-                }
-              }
-            },
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/v1/auth/reset-password/validate": {
-      "get": {
-        "tags": [
-          "auth"
-        ],
-        "summary": "Vérifie sans le consommer si un lien de réinitialisation est encore valide",
-        "operationId": "validate_reset_token_api_v1_auth_reset_password_validate_get",
-        "parameters": [
-          {
-            "name": "token",
-            "in": "query",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "title": "Token"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ResetTokenValidationResponse"
-                }
-              }
-            }
-          },
-          "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"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Corps invalide. Le détail nomme le champ fautif et le type d'erreur, jamais la valeur envoyée.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ValidationErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/v1/auth/reset-password": {
-      "post": {
-        "tags": [
-          "auth"
-        ],
-        "summary": "Choisit un nouveau mot de passe depuis un lien reçu par email",
-        "operationId": "reset_password_api_v1_auth_reset_password_post",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ResetPasswordRequest"
-              }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/TokenResponse"
-                }
-              }
-            }
-          },
-          "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"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Corps invalide. Le détail nomme le champ fautif et le type d'erreur, jamais la valeur envoyée.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ValidationErrorResponse"
-                }
-              }
-            }
-          },
-          "403": {
-            "description": "Origine non autorisée (protection CSRF de `require_trusted_origin`).",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Lien invalide, déjà utilisé, ou expiré (durée de vie : 15 minutes).",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
     "/api/v1/users": {
       "get": {
         "tags": [
@@ -1777,20 +1587,6 @@
         ],
         "title": "FieldError"
       },
-      "ForgotPasswordRequest": {
-        "properties": {
-          "email": {
-            "type": "string",
-            "format": "email",
-            "title": "Email"
-          }
-        },
-        "type": "object",
-        "required": [
-          "email"
-        ],
-        "title": "ForgotPasswordRequest"
-      },
       "InternalErrorResponse": {
         "properties": {
           "detail": {
@@ -1870,7 +1666,7 @@
           "new_password": {
             "type": "string",
             "maxLength": 128,
-            "minLength": 8,
+            "minLength": 12,
             "title": "New Password"
           }
         },
@@ -2197,40 +1993,6 @@
         ],
         "title": "RecommendationResponse"
       },
-      "ResetPasswordRequest": {
-        "properties": {
-          "token": {
-            "type": "string",
-            "minLength": 1,
-            "title": "Token"
-          },
-          "new_password": {
-            "type": "string",
-            "maxLength": 128,
-            "minLength": 8,
-            "title": "New Password"
-          }
-        },
-        "type": "object",
-        "required": [
-          "token",
-          "new_password"
-        ],
-        "title": "ResetPasswordRequest"
-      },
-      "ResetTokenValidationResponse": {
-        "properties": {
-          "valid": {
-            "type": "boolean",
-            "title": "Valid"
-          }
-        },
-        "type": "object",
-        "required": [
-          "valid"
-        ],
-        "title": "ResetTokenValidationResponse"
-      },
       "Role": {
         "type": "string",
         "enum": [

apps/backend/pyproject.toml

@@ -16,7 +16,6 @@ dependencies = [
     "pyjwt>=2.10",
     "argon2-cffi>=23.1",
     "anyio>=4.0",
-    "aiosmtplib>=5.1.3",
     "pandas>=3.0.5",
 ]
 

apps/backend/tests/api/test_auth.py

@@ -11,7 +11,6 @@ from app.core.roles import AccountKind, Role
 from app.services.auth import (
     AuthenticatedSession,
     InvalidCredentialsError,
-    InvalidOrExpiredResetTokenError,
     RateLimitedError,
     SessionRejectedError,
 )
@@ -28,27 +27,15 @@ PRINCIPAL = Principal(
 
 
 class FauxService:
-    def __init__(self, erreur: Exception | None = None, *, jeton_valide: bool = True) -> None:
+    def __init__(self, erreur: Exception | None = None) -> None:
         self._erreur = erreur
-        self._jeton_valide = jeton_valide
 
     async def refresh(self, **_: object) -> AuthenticatedSession:
         return await self.authenticate()
 
-    async def is_reset_token_valid(self, **_: object) -> bool:
-        return self._jeton_valide
-
     async def logout(self, **_: object) -> None:
         return None
 
-    async def request_password_reset(self, **_: object) -> None:
-        if self._erreur is not None:
-            raise self._erreur
-        return None
-
-    async def confirm_password_reset(self, **_: object) -> AuthenticatedSession:
-        return await self.authenticate()
-
     async def authenticate(self, **_: object) -> AuthenticatedSession:
         if self._erreur is not None:
             raise self._erreur
@@ -219,126 +206,3 @@ async def test_a_cookie_bearing_route_accepts_a_request_without_origin(
     response = await client.post("/api/v1/auth/logout")
 
     assert response.status_code != 403
-
-
-async def test_forgot_password_answers_202_when_the_account_exists(
-    fake_auth_service: list[Exception | None], client: AsyncClient
-) -> None:
-    response = await client.post(
-        "/api/v1/auth/forgot-password", json={"email": "operateur@enervision.fr"}
-    )
-
-    assert response.status_code == 202
-    assert response.headers["cache-control"] == "no-store"
-
-
-async def test_forgot_password_answers_202_identically_when_the_account_is_unknown(
-    fake_auth_service: list[Exception | None], client: AsyncClient
-) -> None:
-    response = await client.post(
-        "/api/v1/auth/forgot-password", json={"email": "inconnu@enervision.fr"}
-    )
-
-    assert response.status_code == 202
-
-
-async def test_forgot_password_returns_429_with_a_retry_after_when_the_rate_limit_is_reached(
-    fake_auth_service: list[Exception | None], client: AsyncClient
-) -> None:
-    fake_auth_service[0] = RateLimitedError(900)
-
-    response = await client.post(
-        "/api/v1/auth/forgot-password", json={"email": "operateur@enervision.fr"}
-    )
-
-    assert response.status_code == 429
-    assert response.headers["retry-after"] == "900"
-
-
-async def test_forgot_password_rejects_a_malformed_email(
-    fake_auth_service: list[Exception | None], client: AsyncClient
-) -> None:
-    response = await client.post("/api/v1/auth/forgot-password", json={"email": "pas-un-email"})
-
-    assert response.status_code == 422
-
-
-@pytest.fixture
-def fake_auth_service_reset_validity(app: FastAPI) -> Iterator[list[bool]]:
-    programme = [True]
-    app.dependency_overrides[get_auth_service] = lambda: FauxService(jeton_valide=programme[0])
-    yield programme
-    app.dependency_overrides.pop(get_auth_service, None)
-
-
-async def test_validate_reset_token_reports_a_living_token(
-    fake_auth_service_reset_validity: list[bool], client: AsyncClient
-) -> None:
-    response = await client.get(
-        "/api/v1/auth/reset-password/validate", params={"token": "un-secret-opaque"}
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"valid": True}
-
-
-async def test_validate_reset_token_reports_an_invalid_or_expired_token(
-    fake_auth_service_reset_validity: list[bool], client: AsyncClient
-) -> None:
-    fake_auth_service_reset_validity[0] = False
-
-    response = await client.get(
-        "/api/v1/auth/reset-password/validate", params={"token": "un-secret-perime"}
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"valid": False}
-
-
-async def test_reset_password_returns_the_token_and_the_cookie_on_success(
-    fake_auth_service: list[Exception | None], client: AsyncClient
-) -> None:
-    response = await client.post(
-        "/api/v1/auth/reset-password",
-        json={"token": "un-secret-opaque", "new_password": "Un-nouveau-mot-de-passe1!"},
-    )
-
-    assert response.status_code == 200
-    assert response.cookies.get("ev_refresh") is not None
-    assert "refresh_secret" not in response.text
-
-
-async def test_reset_password_rejects_an_invalid_or_expired_token(
-    fake_auth_service: list[Exception | None], client: AsyncClient
-) -> None:
-    fake_auth_service[0] = InvalidOrExpiredResetTokenError("Lien invalide ou expiré")
-
-    response = await client.post(
-        "/api/v1/auth/reset-password",
-        json={"token": "un-secret-perime", "new_password": "Un-nouveau-mot-de-passe1!"},
-    )
-
-    assert response.status_code == 400
-
-
-async def test_reset_password_rejects_a_weak_password(
-    fake_auth_service: list[Exception | None], client: AsyncClient
-) -> None:
-    response = await client.post(
-        "/api/v1/auth/reset-password",
-        json={"token": "un-secret-opaque", "new_password": "trop-simple"},
-    )
-
-    assert response.status_code == 422
-
-
-async def test_reset_password_refuses_a_foreign_origin(
-    fake_auth_service: list[Exception | None], client: AsyncClient
-) -> None:
-    response = await client.post(
-        "/api/v1/auth/reset-password",
-        json={"token": "un-secret-opaque", "new_password": "Un-nouveau-mot-de-passe1!"},
-        headers={"Origin": "https://malveillant.example"},
-    )
-
-    assert response.status_code == 403

apps/backend/tests/api/test_route_protection.py

@@ -18,13 +18,6 @@ ROUTES_PUBLIQUES = frozenset(
         ("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"),
     }
 )

apps/backend/tests/repositories/test_password_reset_token.py

@@ -1,142 +0,0 @@
-# Le premier test démontre l'atomicité de `consume()` : sur un double, deux soumissions
-# concurrentes du même lien réussiraient toutes les deux.
-
-import uuid
-from datetime import UTC, datetime, timedelta
-
-import pytest
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.core.roles import Role
-from app.core.security import fingerprint_refresh, generate_refresh_secret
-from app.repositories.password_reset_token import PasswordResetTokenRepository
-from app.repositories.user import UserRepository
-
-pytestmark = pytest.mark.integration
-
-DUREE = timedelta(minutes=15)
-
-
-async def un_compte(session: AsyncSession) -> uuid.UUID:
-    compte = await UserRepository(session).create(
-        email=f"reset-{uuid.uuid4().hex[:12]}@enervision.fr",
-        password_hash="$argon2id$x",
-        role=Role.LECTEUR,
-    )
-    return compte.id
-
-
-async def un_jeton(
-    depot: PasswordResetTokenRepository, user_id: uuid.UUID, *, duree: timedelta = DUREE
-) -> str:
-    secret = generate_refresh_secret()
-    await depot.create(
-        user_id=user_id,
-        token_hash=fingerprint_refresh(secret),
-        expires_at=datetime.now(UTC) + duree,
-        client_ip="203.0.113.10",
-        user_agent="pytest",
-    )
-    return secret
-
-
-async def test_consume_only_succeeds_once(session: AsyncSession) -> None:
-    depot = PasswordResetTokenRepository(session)
-    secret = await un_jeton(depot, await un_compte(session))
-
-    premier = await depot.consume(fingerprint_refresh(secret))
-    second = await depot.consume(fingerprint_refresh(secret))
-    await session.rollback()
-
-    assert premier is not None
-    assert second is None
-
-
-async def test_consume_refuses_an_expired_token(session: AsyncSession) -> None:
-    depot = PasswordResetTokenRepository(session)
-    secret = await un_jeton(depot, await un_compte(session), duree=-timedelta(minutes=1))
-
-    revendique = await depot.consume(fingerprint_refresh(secret))
-    await session.rollback()
-
-    assert revendique is None
-
-
-async def test_consume_returns_nothing_for_an_unknown_fingerprint(
-    session: AsyncSession,
-) -> None:
-    revendique = await PasswordResetTokenRepository(session).consume(
-        fingerprint_refresh(generate_refresh_secret())
-    )
-
-    assert revendique is None
-
-
-async def test_invalidate_all_for_user_only_touches_living_tokens(
-    session: AsyncSession,
-) -> None:
-    depot = PasswordResetTokenRepository(session)
-    compte = await un_compte(session)
-    await un_jeton(depot, compte)
-    await un_jeton(depot, compte)
-
-    invalides = await depot.invalidate_all_for_user(compte)
-    second_passage = await depot.invalidate_all_for_user(compte)
-    await session.rollback()
-
-    assert invalides == 2
-    assert second_passage == 0
-
-
-async def test_exists_valid_is_true_for_a_living_token(session: AsyncSession) -> None:
-    depot = PasswordResetTokenRepository(session)
-    secret = await un_jeton(depot, await un_compte(session))
-
-    assert await depot.exists_valid(fingerprint_refresh(secret)) is True
-
-
-async def test_exists_valid_is_false_for_an_expired_token(session: AsyncSession) -> None:
-    depot = PasswordResetTokenRepository(session)
-    secret = await un_jeton(depot, await un_compte(session), duree=-timedelta(minutes=1))
-
-    assert await depot.exists_valid(fingerprint_refresh(secret)) is False
-
-
-async def test_exists_valid_is_false_once_the_token_is_consumed(session: AsyncSession) -> None:
-    depot = PasswordResetTokenRepository(session)
-    secret = await un_jeton(depot, await un_compte(session))
-    await depot.consume(fingerprint_refresh(secret))
-
-    assert await depot.exists_valid(fingerprint_refresh(secret)) is False
-
-
-async def test_exists_valid_is_false_for_an_unknown_fingerprint(session: AsyncSession) -> None:
-    depot = PasswordResetTokenRepository(session)
-
-    assert await depot.exists_valid(fingerprint_refresh(generate_refresh_secret())) is False
-
-
-async def test_the_database_refuses_two_tokens_sharing_a_fingerprint(
-    session: AsyncSession,
-) -> None:
-    depot = PasswordResetTokenRepository(session)
-    compte = await un_compte(session)
-    secret = generate_refresh_secret()
-    await depot.create(
-        user_id=compte,
-        token_hash=fingerprint_refresh(secret),
-        expires_at=datetime.now(UTC) + DUREE,
-        client_ip=None,
-        user_agent=None,
-    )
-
-    with pytest.raises(IntegrityError):
-        await depot.create(
-            user_id=compte,
-            token_hash=fingerprint_refresh(secret),
-            expires_at=datetime.now(UTC) + DUREE,
-            client_ip=None,
-            user_agent=None,
-        )
-    await session.rollback()

apps/backend/tests/schemas/test_auth.py

@@ -1,61 +0,0 @@
-import pytest
-from pydantic import ValidationError
-
-from app.schemas.auth import PasswordChangeRequest, valide_complexite
-
-MOT_DE_PASSE_VALIDE = "Un-mot-de-passe1!"
-
-
-def test_password_change_request_accepts_a_password_covering_the_four_classes() -> None:
-    requete = PasswordChangeRequest(
-        current_password="peu-importe", new_password=MOT_DE_PASSE_VALIDE
-    )
-
-    assert requete.new_password == MOT_DE_PASSE_VALIDE
-
-
-@pytest.mark.parametrize(
-    "new_password",
-    [
-        "un-mot-de-passe1!",
-        "UN-MOT-DE-PASSE1!",
-        "Un-mot-de-passe!",
-        "Un mot de passe 1",
-    ],
-    ids=["sans_majuscule", "sans_minuscule", "sans_chiffre", "sans_caractere_special"],
-)
-def test_password_change_request_rejects_a_password_missing_a_character_class(
-    new_password: str,
-) -> None:
-    with pytest.raises(ValidationError):
-        PasswordChangeRequest(current_password="peu-importe", new_password=new_password)
-
-
-def test_password_change_request_rejects_a_password_below_the_minimum_length() -> None:
-    with pytest.raises(ValidationError):
-        PasswordChangeRequest(current_password="peu-importe", new_password="Ab1!")
-
-
-def test_valide_complexite_names_every_missing_class_in_the_error() -> None:
-    with pytest.raises(ValueError, match=r"majuscule.*chiffre|chiffre.*majuscule"):
-        valide_complexite("minuscules-seulement")
-
-
-def test_valide_complexite_accepts_an_accented_password() -> None:
-    assert valide_complexite("Sécurité1!") == "Sécurité1!"
-
-
-@pytest.mark.parametrize("mot_de_passe", ["abcdefg1×", "abcdefg1÷"])  # noqa: RUF001
-def test_valide_complexite_rejects_a_password_without_uppercase_despite_times_or_divide(
-    mot_de_passe: str,
-) -> None:
-    with pytest.raises(ValueError, match="majuscule"):
-        valide_complexite(mot_de_passe)
-
-
-@pytest.mark.parametrize("mot_de_passe", ["ABCDEFG1×", "ABCDEFG1÷"])  # noqa: RUF001
-def test_valide_complexite_rejects_a_password_without_lowercase_despite_times_or_divide(
-    mot_de_passe: str,
-) -> None:
-    with pytest.raises(ValueError, match="minuscule"):
-        valide_complexite(mot_de_passe)

apps/backend/tests/services/test_auth.py

@@ -5,7 +5,6 @@ from typing import Any
 from uuid import UUID, uuid4
 
 import pytest
-from fastapi import BackgroundTasks
 
 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role
@@ -17,15 +16,11 @@ from app.core.security import (
 from app.models.login_attempt import LoginOutcome
 from app.models.refresh_token import RevocationReason
 from app.repositories.login_attempt import FailureCounts
-from app.repositories.password_reset_attempt import ResetRequestCounts
-from app.repositories.password_reset_token import ConsumedResetToken
 from app.repositories.refresh_token import ClaimedToken
 from app.services.auth import (
     AuthService,
     InvalidCredentialsError,
-    InvalidOrExpiredResetTokenError,
     LoginPolicy,
-    PasswordResetPolicy,
     RateLimitedError,
     SessionRejectedError,
 )
@@ -42,13 +37,6 @@ POLITIQUE_CONNEXION = LoginPolicy(
     max_failures_per_ip=20,
     max_failures_per_identifier=50,
 )
-POLITIQUE_RESET = PasswordResetPolicy(
-    window_seconds=900,
-    max_requests_per_identifier=3,
-    max_requests_per_ip=10,
-    token_ttl=timedelta(minutes=15),
-    frontend_reset_url="http://localhost:4200/reset-password",
-)
 
 
 @dataclass
@@ -180,49 +168,6 @@ class FausseTransaction:
         self.validations += 1
 
 
-class FauxDepotJetonsReset:
-    def __init__(
-        self, revendique: ConsumedResetToken | None = None, *, valide: bool = False
-    ) -> None:
-        self.revendique = revendique
-        self.valide = valide
-        self.crees: list[UUID] = []
-        self.invalidations: list[UUID] = []
-
-    async def create(self, *, user_id: UUID, **_: object) -> None:
-        self.crees.append(user_id)
-
-    async def consume(self, token_hash: bytes) -> ConsumedResetToken | None:
-        return self.revendique
-
-    async def exists_valid(self, token_hash: bytes) -> bool:
-        return self.valide
-
-    async def invalidate_all_for_user(self, user_id: UUID) -> int:
-        self.invalidations.append(user_id)
-        return len(self.invalidations)
-
-
-class FauxDepotTentativesReset:
-    def __init__(self, compteurs: ResetRequestCounts | None = None) -> None:
-        self.compteurs = compteurs or ResetRequestCounts(0, 0)
-        self.enregistrees: list[str] = []
-
-    async def count_recent(self, **_: object) -> ResetRequestCounts:
-        return self.compteurs
-
-    async def record(self, *, email: str, **_: object) -> None:
-        self.enregistrees.append(email)
-
-
-class FauxMailer:
-    def __init__(self) -> None:
-        self.envois: list[tuple[str, str]] = []
-
-    async def send_password_reset_email(self, *, to: str, reset_url: str) -> None:
-        self.envois.append((to, reset_url))
-
-
 @dataclass
 class Attirail:
     service: AuthService
@@ -231,9 +176,6 @@ class Attirail:
     jetons: FauxDepotJetons
     audit: FauxDepotAudit
     hacheur: FauxHacheur
-    jetons_reset: FauxDepotJetonsReset
-    tentatives_reset: FauxDepotTentativesReset
-    mailer: FauxMailer
 
 
 def fabrique_service(
@@ -242,17 +184,12 @@ def fabrique_service(
     compteurs: FailureCounts | None = None,
     hacheur: FauxHacheur | None = None,
     jetons: FauxDepotJetons | None = None,
-    jetons_reset: FauxDepotJetonsReset | None = None,
-    compteurs_reset: ResetRequestCounts | None = None,
 ) -> Attirail:
     comptes = FauxDepotComptes(compte)
     tentatives = FauxDepotTentatives(compteurs)
     depot_jetons = jetons or FauxDepotJetons()
     audit = FauxDepotAudit()
     hacheur = hacheur or FauxHacheur()
-    depot_jetons_reset = jetons_reset or FauxDepotJetonsReset()
-    tentatives_reset = FauxDepotTentativesReset(compteurs_reset)
-    mailer = FauxMailer()
     service = AuthService(
         users=comptes,  # type: ignore[arg-type]
         attempts=tentatives,  # type: ignore[arg-type]
@@ -263,22 +200,8 @@ def fabrique_service(
         token_policy=POLITIQUE_JETON,
         login_policy=POLITIQUE_CONNEXION,
         refresh_ttl=timedelta(days=7),
-        reset_tokens=depot_jetons_reset,  # type: ignore[arg-type]
-        reset_attempts=tentatives_reset,  # type: ignore[arg-type]
-        reset_policy=POLITIQUE_RESET,
-        mailer=mailer,  # type: ignore[arg-type]
-    )
-    return Attirail(
-        service,
-        comptes,
-        tentatives,
-        depot_jetons,
-        audit,
-        hacheur,
-        depot_jetons_reset,
-        tentatives_reset,
-        mailer,
     )
+    return Attirail(service, comptes, tentatives, depot_jetons, audit, hacheur)
 
 
 async def connecte(service: AuthService, mot_de_passe: str = "un-mot-de-passe-valide") -> object:
@@ -570,148 +493,3 @@ async def test_change_password_refuses_a_wrong_current_password() -> None:
 
     assert attirail.jetons.revocations_par_compte == []
     assert attirail.jetons.crees == []
-
-
-async def test_request_password_reset_emails_a_link_when_the_account_exists() -> None:
-    compte = FauxCompte()
-    attirail = fabrique_service(compte=compte)
-    taches = BackgroundTasks()
-
-    await attirail.service.request_password_reset(
-        email=compte.email, client_ip="203.0.113.10", user_agent="pytest", background_tasks=taches
-    )
-
-    assert attirail.jetons_reset.invalidations == [compte.id]
-    assert attirail.jetons_reset.crees == [compte.id]
-    assert attirail.mailer.envois == [], "l'envoi doit être différé, pas fait dans la réponse"
-    await taches()
-    assert len(attirail.mailer.envois) == 1
-    assert attirail.mailer.envois[0][0] == compte.email
-    assert "auth.password_reset_requested" in attirail.audit.lignes[0][0]
-
-
-async def test_request_password_reset_stays_silent_when_the_account_is_unknown() -> None:
-    attirail = fabrique_service(compte=None)
-    taches = BackgroundTasks()
-
-    await attirail.service.request_password_reset(
-        email="inconnu@enervision.fr",
-        client_ip="203.0.113.10",
-        user_agent="pytest",
-        background_tasks=taches,
-    )
-    await taches()
-
-    assert attirail.jetons_reset.crees == []
-    assert attirail.mailer.envois == []
-    assert attirail.hacheur.verifications == 1, "le hachage factice doit tout de même tourner"
-
-
-async def test_request_password_reset_stays_silent_when_the_account_is_inactive() -> None:
-    compte = FauxCompte(is_active=False)
-    attirail = fabrique_service(compte=compte)
-    taches = BackgroundTasks()
-
-    await attirail.service.request_password_reset(
-        email=compte.email, client_ip="203.0.113.10", user_agent="pytest", background_tasks=taches
-    )
-    await taches()
-
-    assert attirail.jetons_reset.crees == []
-    assert attirail.mailer.envois == []
-
-
-async def test_request_password_reset_raises_when_the_rate_limit_is_reached() -> None:
-    attirail = fabrique_service(compteurs_reset=ResetRequestCounts(per_identifier=3, per_ip=0))
-    taches = BackgroundTasks()
-
-    with pytest.raises(RateLimitedError):
-        await attirail.service.request_password_reset(
-            email="operateur@enervision.fr",
-            client_ip="203.0.113.10",
-            user_agent="pytest",
-            background_tasks=taches,
-        )
-
-    await taches()
-    assert attirail.mailer.envois == []
-
-
-async def test_request_password_reset_logs_instead_of_raising_when_the_mailer_fails() -> None:
-    compte = FauxCompte()
-    attirail = fabrique_service(compte=compte)
-    taches = BackgroundTasks()
-
-    async def echoue(*, to: str, reset_url: str) -> None:
-        raise RuntimeError("relais SMTP indisponible")
-
-    attirail.mailer.send_password_reset_email = echoue  # type: ignore[method-assign]
-
-    await attirail.service.request_password_reset(
-        email=compte.email, client_ip="203.0.113.10", user_agent="pytest", background_tasks=taches
-    )
-
-    await taches()
-
-
-async def test_confirm_password_reset_revokes_every_session_then_reopens_the_current_one() -> None:
-    compte = FauxCompte()
-    jetons_reset = FauxDepotJetonsReset(
-        revendique=ConsumedResetToken(id=uuid4(), user_id=compte.id)
-    )
-    attirail = fabrique_service(compte=compte, jetons_reset=jetons_reset)
-
-    session = await attirail.service.confirm_password_reset(
-        token="un-secret-opaque",
-        new_password="Un-nouveau-mot-de-passe1!",
-        client_ip="203.0.113.10",
-        user_agent="pytest",
-    )
-
-    assert attirail.jetons.revocations_par_compte == [
-        (compte.id, RevocationReason.CHANGEMENT_MOT_DE_PASSE.value)
-    ]
-    assert len(attirail.jetons.crees) == 1
-    assert session.refresh_secret
-    assert "auth.password_reset_self_service" in attirail.audit.lignes[0][0]
-
-
-async def test_is_reset_token_valid_reflects_the_repository() -> None:
-    attirail_valide = fabrique_service(jetons_reset=FauxDepotJetonsReset(valide=True))
-    attirail_invalide = fabrique_service(jetons_reset=FauxDepotJetonsReset(valide=False))
-
-    assert await attirail_valide.service.is_reset_token_valid("un-secret-opaque") is True
-    assert await attirail_invalide.service.is_reset_token_valid("un-secret-opaque") is False
-
-
-async def test_confirm_password_reset_rejects_a_token_for_an_account_disabled_since() -> None:
-    compte = FauxCompte(is_active=False)
-    jetons_reset = FauxDepotJetonsReset(
-        revendique=ConsumedResetToken(id=uuid4(), user_id=compte.id)
-    )
-    attirail = fabrique_service(compte=compte, jetons_reset=jetons_reset)
-
-    with pytest.raises(InvalidOrExpiredResetTokenError):
-        await attirail.service.confirm_password_reset(
-            token="un-secret-opaque",
-            new_password="Un-nouveau-mot-de-passe1!",
-            client_ip="203.0.113.10",
-            user_agent="pytest",
-        )
-
-    assert attirail.comptes.mots_de_passe_changes == 0
-    assert attirail.jetons.revocations_par_compte == []
-
-
-async def test_confirm_password_reset_rejects_an_invalid_or_expired_token() -> None:
-    attirail = fabrique_service(jetons_reset=FauxDepotJetonsReset(revendique=None))
-
-    with pytest.raises(InvalidOrExpiredResetTokenError):
-        await attirail.service.confirm_password_reset(
-            token="un-secret-invalide",
-            new_password="Un-nouveau-mot-de-passe1!",
-            client_ip=None,
-            user_agent=None,
-        )
-
-    assert attirail.jetons.revocations_par_compte == []

apps/backend/tests/test_cli.py

@@ -4,7 +4,6 @@ from pathlib import Path
 import pytest
 
 from app import cli
-from app.schemas.auth import valide_complexite
 
 
 def test_build_parser_reads_the_create_admin_arguments() -> None:
@@ -35,36 +34,26 @@ def test_read_password_generates_a_long_secret_when_asked(
 
     assert len(mot_de_passe) >= cli.LONGUEUR_MOT_DE_PASSE_GENERE
     assert mot_de_passe in capsys.readouterr().out
-    valide_complexite(mot_de_passe)
 
 
 def test_read_password_accepts_two_matching_entries(monkeypatch: pytest.MonkeyPatch) -> None:
-    saisies = iter(["Un-mot-de-passe-valide1", "Un-mot-de-passe-valide1"])
+    saisies = iter(["un-mot-de-passe-valide", "un-mot-de-passe-valide"])
     monkeypatch.setattr(cli, "getpass", lambda _: next(saisies))
 
-    assert cli.read_password(generate=False) == "Un-mot-de-passe-valide1"
+    assert cli.read_password(generate=False) == "un-mot-de-passe-valide"
 
 
 def test_read_password_refuses_a_password_below_the_minimum_length(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    monkeypatch.setattr(cli, "getpass", lambda _: "Court1!")
-
-    with pytest.raises(SystemExit):
-        cli.read_password(generate=False)
-
-
-def test_read_password_refuses_a_password_missing_a_character_class(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(cli, "getpass", lambda _: "un-mot-de-passe-sans-majuscule-ni-chiffre")
+    monkeypatch.setattr(cli, "getpass", lambda _: "court")
 
     with pytest.raises(SystemExit):
         cli.read_password(generate=False)
 
 
 def test_read_password_refuses_two_different_entries(monkeypatch: pytest.MonkeyPatch) -> None:
-    saisies = iter(["Un-mot-de-passe-valide1", "Un-autre-mot-de-passe2"])
+    saisies = iter(["un-mot-de-passe-valide", "un-autre-mot-de-passe"])
     monkeypatch.setattr(cli, "getpass", lambda _: next(saisies))
 
     with pytest.raises(SystemExit):

apps/backend/uv.lock

@@ -7,15 +7,6 @@ resolution-markers = [
     "sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 
-[[package]]
-name = "aiosmtplib"
-version = "5.1.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9b/5c/9cabc5db6d607616e81ba6d8f1f231cd5a75955807a308c1090a59072d6d/aiosmtplib-5.1.3.tar.gz", hash = "sha256:ac2b418d3260ba62d9cfd0fe7359726e9dc009a4e8e8d9909fdfae332f522a7c", size = 77010, upload-time = "2026-09-08T02:11:20.532Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9c/0a/b56ab8163d54960337fdca475d3dfd56c8badf6172e79cf2ad00d5335dc1/aiosmtplib-5.1.3-py3-none-any.whl", hash = "sha256:f7d76ce3d4995a65a178c1f11e1bd1607706b921d00cb768e7a2c7f7ef5517a8", size = 30116, upload-time = "2026-09-08T02:11:19.352Z" },
-]
-
 [[package]]
 name = "alembic"
 version = "1.20.0"
@@ -320,7 +311,6 @@ name = "enervision-backend"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
-    { name = "aiosmtplib" },
     { name = "alembic" },
     { name = "anyio" },
     { name = "argon2-cffi" },
@@ -349,7 +339,6 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "aiosmtplib", specifier = ">=5.1.3" },
     { name = "alembic", specifier = ">=1.20.0" },
     { name = "anyio", specifier = ">=4.0" },
     { name = "argon2-cffi", specifier = ">=23.1" },

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

@@ -5,8 +5,6 @@ export const routes: Routes = [
   { path: '', redirectTo: 'dashboard', pathMatch: 'full' },
   { path: 'login', loadComponent: () => import('./features/auth/login/login').then(m => m.Login) },
   { path: 'change-password', loadComponent: () => import('./features/auth/change-password/change-password').then(m => m.ChangePassword) },
-  { path: 'forgot-password', loadComponent: () => import('./features/auth/forgot-password/forgot-password').then(m => m.ForgotPassword) },
-  { path: 'reset-password', loadComponent: () => import('./features/auth/reset-password/reset-password').then(m => m.ResetPassword) },
   {
     path: 'dashboard',
     canActivate: [authGuard],

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

@@ -41,10 +41,7 @@ describe('authInterceptor', () => {
     httpMock = TestBed.inject(HttpTestingController);
   });
 
-  afterEach(() => {
-    httpMock.verify();
-    vi.restoreAllMocks();
-  });
+  afterEach(() => httpMock.verify());
 
   it('ajoute le header Authorization quand un token est disponible', () => {
     http.get('/api/v1/stats/summary').subscribe();
@@ -100,19 +97,6 @@ describe('authInterceptor', () => {
     expect(routerMock.navigate).toHaveBeenCalledWith(['/login']);
   });
 
-  it("ne redirige pas vers /login sur un 401 de /auth/refresh si on est déjà sur /reset-password", () => {
-    vi.spyOn(window, 'location', 'get').mockReturnValue({
-      pathname: '/reset-password',
-    } as Location);
-
-    http.post('/api/v1/auth/refresh', {}).subscribe({ error: () => {} });
-    const req = httpMock.expectOne('/api/v1/auth/refresh');
-    req.flush({}, { status: 401, statusText: 'Unauthorized' });
-
-    expect(authMock.clearSession).toHaveBeenCalled();
-    expect(routerMock.navigate).not.toHaveBeenCalled();
-  });
-
   it('rafraîchit puis rejoue la requête sur un 401 avec error="expired"', () => {
     authMock.refreshShared.mockReturnValue(of({ access_token: 'new-token' }));
     authMock.getAccessToken.mockReturnValueOnce('old-token').mockReturnValue('new-token');

apps/frontend/src/app/core/interceptors/auth-interceptor.ts

@@ -11,16 +11,6 @@ function parseAuthError(response: HttpErrorResponse): string | null {
   return match ? match[1] : null;
 }
 
-const ROUTES_INVITEES = ['/login', '/forgot-password', '/reset-password'];
-
-// Piège : le rafraîchissement de session lancé au démarrage de l'app (provideAppInitializer)
-// échoue silencieusement sans cookie valide. `window.location.pathname` (pas `router.url`,
-// pas encore fiable à ce stade) évite qu'un 401 de fond écrase la navigation vers le lien de
-// reset reçu par email.
-function surRouteInvitee(): boolean {
-  return ROUTES_INVITEES.some((chemin) => window.location.pathname.startsWith(chemin));
-}
-
 export const authInterceptor: HttpInterceptorFn = (req, next) => {
   const auth = inject(AuthService);
   const router = inject(Router);
@@ -53,9 +43,7 @@ export const authInterceptor: HttpInterceptorFn = (req, next) => {
 
       if (req.url.endsWith('/auth/refresh')) {
         auth.clearSession();
-        if (!surRouteInvitee()) {
-          router.navigate(['/login']);
-        }
+        router.navigate(['/login']);
         return throwError(() => error);
       }
 
@@ -63,9 +51,7 @@ export const authInterceptor: HttpInterceptorFn = (req, next) => {
 
       if (kind === 'invalid_token') {
         auth.clearSession();
-        if (!surRouteInvitee()) {
-          router.navigate(['/login']);
-        }
+        router.navigate(['/login']);
         return throwError(() => error);
       }
 
@@ -79,9 +65,7 @@ export const authInterceptor: HttpInterceptorFn = (req, next) => {
           }),
           catchError((refreshError) => {
             auth.clearSession();
-            if (!surRouteInvitee()) {
-              router.navigate(['/login']);
-            }
+            router.navigate(['/login']);
             return throwError(() => refreshError);
           })
         );

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

@@ -83,17 +83,4 @@ describe('AuthService', () => {
 
   expect(result).toEqual(tokenResponse.principal);
 });
-
-  it('vérifie la validité du jeton de reset via GET /auth/reset-password/validate', () => {
-    let result: { valid: boolean } | undefined;
-    service.validateResetToken('un-secret-opaque').subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(
-      `${environment.apiUrl}/auth/reset-password/validate?token=un-secret-opaque`
-    );
-    expect(req.request.method).toBe('GET');
-    req.flush({ valid: true });
-
-    expect(result).toEqual({ valid: true });
-  });
 });

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

@@ -1,14 +1,7 @@
 import { Service, signal, computed, inject } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { Observable, tap, finalize, shareReplay } from 'rxjs';
-import {
-  ForgotPasswordRequest,
-  LoginRequest,
-  PasswordChangeRequest,
-  Principal,
-  ResetPasswordRequest,
-  TokenResponse,
-} from '../../shared/models/auth.model';
+import { LoginRequest, PasswordChangeRequest, Principal, TokenResponse } from '../../shared/models/auth.model';
 import { environment } from '../../../environments/environment';
 
 @Service()
@@ -73,20 +66,4 @@ export class AuthService {
   me(): Observable<Principal> {
     return this.http.get<Principal>(`${environment.apiUrl}/auth/me`);
   }
-
-  forgotPassword(payload: ForgotPasswordRequest): Observable<void> {
-    return this.http.post<void>(`${environment.apiUrl}/auth/forgot-password`, payload);
-  }
-
-  resetPassword(payload: ResetPasswordRequest): Observable<TokenResponse> {
-    return this.http
-      .post<TokenResponse>(`${environment.apiUrl}/auth/reset-password`, payload, { withCredentials: true })
-      .pipe(tap((response) => this.setSession(response)));
-  }
-
-  validateResetToken(token: string): Observable<{ valid: boolean }> {
-    return this.http.get<{ valid: boolean }>(`${environment.apiUrl}/auth/reset-password/validate`, {
-      params: { token },
-    });
-  }
 }

apps/frontend/src/app/features/auth/change-password/change-password.html

@@ -18,7 +18,7 @@
       formControlName="new_password"
       autocomplete="new-password"
     />
-    <span class="auth-hint">{{ passwordHint }}</span>
+    <span class="auth-hint">12 à 128 caractères</span>
 
     @if (errorMessage()) {
       <p class="auth-error">{{ errorMessage() }}</p>

apps/frontend/src/app/features/auth/change-password/change-password.spec.ts

@@ -32,19 +32,10 @@ describe('ChangePassword', () => {
     expect(authMock.changePassword).not.toHaveBeenCalled();
   });
 
-  it('ne soumet pas si le mot de passe ne couvre pas les 4 classes de caractères', () => {
-    const fixture = TestBed.createComponent(ChangePassword);
-    const component = fixture.componentInstance;
-    component.form.setValue({ current_password: 'old', new_password: 'longueur-suffisante-sans-majuscule-ni-chiffre' });
-
-    component.onSubmit();
-    expect(authMock.changePassword).not.toHaveBeenCalled();
-  });
-
   it('redirige vers /dashboard après un changement réussi', () => {
     const fixture = TestBed.createComponent(ChangePassword);
     const component = fixture.componentInstance;
-    component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: 'Un-nouveau-mot-de-passe1!' });
+    component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: 'un-nouveau-mot-de-passe-valide' });
 
     authMock.changePassword.mockReturnValue(of({ principal: { role: 'admin' } }));
 
@@ -55,7 +46,7 @@ describe('ChangePassword', () => {
   it("affiche un message d'erreur si le mot de passe actuel est incorrect", () => {
   const fixture = TestBed.createComponent(ChangePassword);
   const component = fixture.componentInstance;
-  component.form.setValue({ current_password: 'mauvais-mot-de-passe', new_password: 'Un-nouveau-mot-de-passe1!' });
+  component.form.setValue({ current_password: 'mauvais-mot-de-passe', new_password: 'un-nouveau-mot-de-passe-valide' });
 
   authMock.changePassword.mockReturnValue(throwError(() => new Error('401')));
 
@@ -79,7 +70,7 @@ describe('ChangePassword', () => {
   it('déclenche onSubmit via la soumission réelle du formulaire (ngSubmit)', () => {
   const fixture = TestBed.createComponent(ChangePassword);
   const component = fixture.componentInstance;
-  component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: 'Un-nouveau-mot-de-passe1!' });
+  component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: 'un-nouveau-mot-de-passe-valide' });
   fixture.detectChanges();
 
   authMock.changePassword.mockReturnValue(of({ principal: { role: 'admin' } }));
@@ -90,7 +81,7 @@ describe('ChangePassword', () => {
 
   expect(authMock.changePassword).toHaveBeenCalledWith({
     current_password: 'ancien-mot-de-passe',
-    new_password: 'Un-nouveau-mot-de-passe1!',
+    new_password: 'un-nouveau-mot-de-passe-valide',
   });
 });
 

apps/frontend/src/app/features/auth/change-password/change-password.ts

@@ -2,7 +2,6 @@ import { Component, inject, signal } from '@angular/core';
 import { ReactiveFormsModule, FormBuilder, Validators } from '@angular/forms';
 import { Router } from '@angular/router';
 import { AuthService } from '../../../core/services/auth.service';
-import { passwordValidators, PASSWORD_HINT } from '../../../shared/validators/password.validator';
 
 @Component({
   selector: 'app-change-password',
@@ -18,11 +17,10 @@ export class ChangePassword {
 
   errorMessage = signal<string | null>(null);
   isLoading = signal(false);
-  passwordHint = PASSWORD_HINT;
 
   form = this.fb.nonNullable.group({
     current_password: ['', Validators.required],
-    new_password: ['', passwordValidators],
+    new_password: ['', [Validators.required, Validators.minLength(12), Validators.maxLength(128)]],
   });
 
   onSubmit(): void {
@@ -36,7 +34,7 @@ export class ChangePassword {
       },
       error: () => {
         this.isLoading.set(false);
-        this.errorMessage.set(`Mot de passe actuel incorrect, ou nouveau mot de passe invalide (${this.passwordHint}).`);
+        this.errorMessage.set('Mot de passe actuel incorrect, ou nouveau mot de passe invalide (12 à 128 caractères).');
       },
     });
   }

apps/frontend/src/app/features/auth/forgot-password/forgot-password.html

@@ -1,37 +0,0 @@
-<div class="auth-page">
-  <form class="auth-card" [formGroup]="form" (ngSubmit)="onSubmit()">
-    <h1>Mot de passe oublié</h1>
-    <p class="auth-subtitle">Recevez un lien de réinitialisation par email</p>
-
-    @if (submitted()) {
-      <p class="auth-success">
-        Si un compte existe pour cet email, un lien de réinitialisation vient d'être envoyé.
-        Il expire dans 15 minutes.
-      </p>
-    } @else {
-      <label for="email">Email</label>
-      <input
-        id="email"
-        type="email"
-        formControlName="email"
-        autocomplete="username"
-        placeholder="vous@enervision.fr"
-      />
-
-      @if (errorMessage()) {
-        <p class="auth-error">
-          {{ errorMessage() }}
-          @if (retryAfterSeconds(); as seconds) {
-            (réessayez dans {{ seconds }}s)
-          }
-        </p>
-      }
-
-      <button type="submit" [disabled]="form.invalid || isLoading()">
-        {{ isLoading() ? 'Envoi...' : 'Envoyer le lien' }}
-      </button>
-    }
-
-    <p class="auth-link"><a routerLink="/login">Retour à la connexion</a></p>
-  </form>
-</div>

apps/frontend/src/app/features/auth/forgot-password/forgot-password.scss

@@ -1,104 +0,0 @@
-:host {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 100vh;
-  background: #f3f4f6;
-  font-family: 'Segoe UI', system-ui, sans-serif;
-}
-
-.auth-card {
-  background: #ffffff;
-  border: 1px solid #e5e7eb;
-  border-radius: 12px;
-  padding: 2.5rem;
-  width: 100%;
-  max-width: 360px;
-  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.06);
-  display: flex;
-  flex-direction: column;
-
-  h1 {
-    margin: 0;
-    font-size: 1.5rem;
-    font-weight: 700;
-    color: #1f2937;
-  }
-
-  .auth-subtitle {
-    margin: 0.25rem 0 1.5rem;
-    color: #6b7280;
-    font-size: 0.9rem;
-    line-height: 1.4;
-  }
-
-  label {
-    font-size: 0.85rem;
-    font-weight: 600;
-    color: #374151;
-    margin-bottom: 0.35rem;
-    margin-top: 1rem;
-  }
-
-  input {
-    padding: 0.6rem 0.75rem;
-    border: 1px solid #d1d5db;
-    border-radius: 8px;
-    font-size: 0.95rem;
-
-    &:focus {
-      outline: none;
-      border-color: #3b82f6;
-      box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.15);
-    }
-  }
-
-  button {
-    margin-top: 1.5rem;
-    padding: 0.7rem;
-    background: #3b82f6;
-    color: #fff;
-    border: none;
-    border-radius: 8px;
-    font-size: 0.95rem;
-    font-weight: 600;
-    cursor: pointer;
-
-    &:disabled {
-      background: #9ca3af;
-      cursor: not-allowed;
-    }
-
-    &:not(:disabled):hover {
-      background: #2563eb;
-    }
-  }
-}
-
-.auth-hint {
-  font-size: 0.75rem;
-  color: #9ca3af;
-  margin-top: 0.25rem;
-}
-
-.auth-error {
-  margin: 0.75rem 0 0;
-  color: #dc2626;
-  font-size: 0.85rem;
-}
-
-.auth-success {
-  margin: 0.75rem 0 0;
-  color: #16a34a;
-  font-size: 0.85rem;
-}
-
-.auth-link {
-  margin-top: 1rem;
-  font-size: 0.85rem;
-  text-align: center;
-
-  a {
-    color: #3b82f6;
-  }
-}

apps/frontend/src/app/features/auth/forgot-password/forgot-password.spec.ts

@@ -1,75 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { ReactiveFormsModule } from '@angular/forms';
-import { ActivatedRoute, Router } from '@angular/router';
-import { HttpErrorResponse, HttpHeaders } from '@angular/common/http';
-import { of, throwError } from 'rxjs';
-import { vi } from 'vitest';
-import { ForgotPassword } from './forgot-password';
-import { AuthService } from '../../../core/services/auth.service';
-
-describe('ForgotPassword', () => {
-  let authMock: { forgotPassword: ReturnType<typeof vi.fn> };
-  let routerMock: { navigate: ReturnType<typeof vi.fn> };
-
-  beforeEach(async () => {
-    authMock = { forgotPassword: vi.fn() };
-    routerMock = { navigate: vi.fn() };
-
-    await TestBed.configureTestingModule({
-      imports: [ForgotPassword, ReactiveFormsModule],
-      providers: [
-        { provide: AuthService, useValue: authMock },
-        { provide: Router, useValue: routerMock },
-        { provide: ActivatedRoute, useValue: {} },
-      ],
-    }).compileComponents();
-  });
-
-  it('ne soumet pas si le formulaire est invalide', () => {
-    const fixture = TestBed.createComponent(ForgotPassword);
-    fixture.componentInstance.onSubmit();
-    expect(authMock.forgotPassword).not.toHaveBeenCalled();
-  });
-
-  it('affiche le message générique après une soumission réussie', () => {
-    const fixture = TestBed.createComponent(ForgotPassword);
-    const component = fixture.componentInstance;
-    component.form.setValue({ email: 'operateur@enervision.fr' });
-    authMock.forgotPassword.mockReturnValue(of(undefined));
-
-    component.onSubmit();
-
-    expect(component.submitted()).toBe(true);
-  });
-
-  it('affiche le même message générique même quand le serveur répond une erreur autre que 429', () => {
-    const fixture = TestBed.createComponent(ForgotPassword);
-    const component = fixture.componentInstance;
-    component.form.setValue({ email: 'inconnu@enervision.fr' });
-    authMock.forgotPassword.mockReturnValue(throwError(() => new HttpErrorResponse({ status: 500 })));
-
-    component.onSubmit();
-
-    expect(component.submitted()).toBe(true);
-  });
-
-  it('affiche le délai à respecter quand le taux limite est atteint', () => {
-    const fixture = TestBed.createComponent(ForgotPassword);
-    const component = fixture.componentInstance;
-    component.form.setValue({ email: 'operateur@enervision.fr' });
-    authMock.forgotPassword.mockReturnValue(
-      throwError(
-        () =>
-          new HttpErrorResponse({
-            status: 429,
-            headers: new HttpHeaders({ 'Retry-After': '900' }),
-          })
-      )
-    );
-
-    component.onSubmit();
-
-    expect(component.submitted()).toBe(false);
-    expect(component.retryAfterSeconds()).toBe(900);
-  });
-});

apps/frontend/src/app/features/auth/forgot-password/forgot-password.ts

@@ -1,53 +0,0 @@
-import { Component, inject, signal } from '@angular/core';
-import { ReactiveFormsModule, FormBuilder, Validators } from '@angular/forms';
-import { RouterLink } from '@angular/router';
-import { HttpErrorResponse } from '@angular/common/http';
-import { AuthService } from '../../../core/services/auth.service';
-
-@Component({
-  selector: 'app-forgot-password',
-  standalone: true,
-  imports: [ReactiveFormsModule, RouterLink],
-  templateUrl: './forgot-password.html',
-  styleUrl: './forgot-password.scss',
-})
-export class ForgotPassword {
-  private fb = inject(FormBuilder);
-  private auth = inject(AuthService);
-
-  errorMessage = signal<string | null>(null);
-  retryAfterSeconds = signal<number | null>(null);
-  submitted = signal(false);
-  isLoading = signal(false);
-
-  form = this.fb.nonNullable.group({
-    email: ['', [Validators.required, Validators.email]],
-  });
-
-  onSubmit(): void {
-    if (this.form.invalid) return;
-
-    this.isLoading.set(true);
-    this.errorMessage.set(null);
-    this.retryAfterSeconds.set(null);
-
-    this.auth.forgotPassword(this.form.getRawValue()).subscribe({
-      // Le message affiché ne dépend jamais du fait que le compte existe ou non : la réponse
-      // du serveur est déjà générique, l'écran doit l'être aussi.
-      next: () => {
-        this.isLoading.set(false);
-        this.submitted.set(true);
-      },
-      error: (error: HttpErrorResponse) => {
-        this.isLoading.set(false);
-        if (error.status === 429) {
-          const retryAfter = error.headers.get('Retry-After');
-          this.retryAfterSeconds.set(retryAfter ? Number(retryAfter) : null);
-          this.errorMessage.set('Trop de demandes, réessayez plus tard.');
-          return;
-        }
-        this.submitted.set(true);
-      },
-    });
-  }
-}

apps/frontend/src/app/features/auth/login/login.html

@@ -32,7 +32,5 @@
     <button type="submit" [disabled]="form.invalid || isLoading()">
       {{ isLoading() ? 'Connexion...' : 'Se connecter' }}
     </button>
-
-    <p class="auth-link"><a routerLink="/forgot-password">Mot de passe oublié ?</a></p>
   </form>
 </div>

apps/frontend/src/app/features/auth/login/login.scss

@@ -79,13 +79,3 @@
   color: #dc2626;
   font-size: 0.85rem;
 }
-
-.auth-link {
-  margin-top: 1rem;
-  font-size: 0.85rem;
-  text-align: center;
-
-  a {
-    color: #3b82f6;
-  }
-}

apps/frontend/src/app/features/auth/login/login.spec.ts

@@ -1,43 +1,27 @@
 import { TestBed } from '@angular/core/testing';
 import { ReactiveFormsModule } from '@angular/forms';
-import { ActivatedRoute, convertToParamMap, Router } from '@angular/router';
+import { Router } from '@angular/router';
 import { HttpErrorResponse, HttpHeaders } from '@angular/common/http';
 import { of, throwError } from 'rxjs';
 import { vi } from 'vitest';
 import { Login } from './login';
 import { AuthService } from '../../../core/services/auth.service';
-import { MOTIF_LIEN_RESET_INVALIDE } from '../../../shared/models/auth-redirect-reason';
-
-function configure(queryParams: Record<string, string> = {}) {
-  const authMock = { login: vi.fn() };
-  const routerMock = { navigate: vi.fn() };
-
-  return {
-    authMock,
-    routerMock,
-    testBed: TestBed.configureTestingModule({
-      imports: [Login, ReactiveFormsModule],
-      providers: [
-        { provide: AuthService, useValue: authMock },
-        { provide: Router, useValue: routerMock },
-        {
-          provide: ActivatedRoute,
-          useValue: { snapshot: { queryParamMap: convertToParamMap(queryParams) } },
-        },
-      ],
-    }),
-  };
-}
 
 describe('Login', () => {
   let authMock: { login: ReturnType<typeof vi.fn> };
   let routerMock: { navigate: ReturnType<typeof vi.fn> };
 
   beforeEach(async () => {
-    const attirail = configure();
-    authMock = attirail.authMock;
-    routerMock = attirail.routerMock;
-    await attirail.testBed.compileComponents();
+    authMock = { login: vi.fn() };
+    routerMock = { navigate: vi.fn() };
+
+    await TestBed.configureTestingModule({
+      imports: [Login, ReactiveFormsModule],
+      providers: [
+        { provide: AuthService, useValue: authMock },
+        { provide: Router, useValue: routerMock },
+      ],
+    }).compileComponents();
   });
 
   it('ne soumet pas si le formulaire est invalide', () => {
@@ -100,14 +84,6 @@ describe('Login', () => {
     expect(errorEl?.textContent).toContain('30s');
   });
 
-  it('affiche le message standard quand on arrive avec ?motif=lien-expire', async () => {
-    const attirail = configure({ motif: MOTIF_LIEN_RESET_INVALIDE });
-    await attirail.testBed.compileComponents();
-    const fixture = TestBed.createComponent(Login);
-
-    expect(fixture.componentInstance.errorMessage()).toContain('expiré');
-  });
-
   it('désactive le bouton tant que le formulaire est invalide', () => {
     const fixture = TestBed.createComponent(Login);
     fixture.detectChanges();

apps/frontend/src/app/features/auth/login/login.ts

@@ -1,14 +1,13 @@
 import { Component, inject, signal } from '@angular/core';
 import { ReactiveFormsModule, FormBuilder, Validators } from '@angular/forms';
-import { ActivatedRoute, Router, RouterLink } from '@angular/router';
+import { Router } from '@angular/router';
 import { HttpErrorResponse } from '@angular/common/http';
 import { AuthService } from '../../../core/services/auth.service';
-import { MESSAGE_LIEN_RESET_INVALIDE, MOTIF_LIEN_RESET_INVALIDE } from '../../../shared/models/auth-redirect-reason';
 
 @Component({
   selector: 'app-login',
   standalone: true,
-  imports: [ReactiveFormsModule, RouterLink],
+  imports: [ReactiveFormsModule],
   templateUrl: './login.html',
   styleUrl: './login.scss',
 })
@@ -16,13 +15,8 @@ export class Login {
   private fb = inject(FormBuilder);
   private auth = inject(AuthService);
   private router = inject(Router);
-  private route = inject(ActivatedRoute);
 
-  errorMessage = signal<string | null>(
-    this.route.snapshot.queryParamMap.get('motif') === MOTIF_LIEN_RESET_INVALIDE
-      ? MESSAGE_LIEN_RESET_INVALIDE
-      : null,
-  );
+  errorMessage = signal<string | null>(null);
   retryAfterSeconds = signal<number | null>(null);
   isLoading = signal(false);
 

apps/frontend/src/app/features/auth/reset-password/reset-password.html

@@ -1,32 +0,0 @@
-<div class="auth-page">
-  <form class="auth-card" [formGroup]="form" (ngSubmit)="onSubmit()">
-    <h1>Nouveau mot de passe</h1>
-
-    @if (hasToken && !isCheckingToken()) {
-      <p class="auth-subtitle">Choisissez votre nouveau mot de passe</p>
-
-      <label for="new_password">Nouveau mot de passe</label>
-      <input
-        id="new_password"
-        type="password"
-        formControlName="new_password"
-        autocomplete="new-password"
-      />
-      <app-password-requirements [password]="password()" />
-
-      @if (errorMessage()) {
-        <p class="auth-error">{{ errorMessage() }}</p>
-      }
-
-      <button type="submit" [disabled]="form.invalid || isLoading()">
-        {{ isLoading() ? 'Modification...' : 'Valider' }}
-      </button>
-    }
-
-    @if (hasToken && isCheckingToken()) {
-      <p class="auth-subtitle">Vérification du lien...</p>
-    }
-
-    <p class="auth-link"><a routerLink="/forgot-password">Redemander un lien</a></p>
-  </form>
-</div>

apps/frontend/src/app/features/auth/reset-password/reset-password.scss

@@ -1,104 +0,0 @@
-:host {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 100vh;
-  background: #f3f4f6;
-  font-family: 'Segoe UI', system-ui, sans-serif;
-}
-
-.auth-card {
-  background: #ffffff;
-  border: 1px solid #e5e7eb;
-  border-radius: 12px;
-  padding: 2.5rem;
-  width: 100%;
-  max-width: 360px;
-  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.06);
-  display: flex;
-  flex-direction: column;
-
-  h1 {
-    margin: 0;
-    font-size: 1.5rem;
-    font-weight: 700;
-    color: #1f2937;
-  }
-
-  .auth-subtitle {
-    margin: 0.25rem 0 1.5rem;
-    color: #6b7280;
-    font-size: 0.9rem;
-    line-height: 1.4;
-  }
-
-  label {
-    font-size: 0.85rem;
-    font-weight: 600;
-    color: #374151;
-    margin-bottom: 0.35rem;
-    margin-top: 1rem;
-  }
-
-  input {
-    padding: 0.6rem 0.75rem;
-    border: 1px solid #d1d5db;
-    border-radius: 8px;
-    font-size: 0.95rem;
-
-    &:focus {
-      outline: none;
-      border-color: #3b82f6;
-      box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.15);
-    }
-  }
-
-  button {
-    margin-top: 1.5rem;
-    padding: 0.7rem;
-    background: #3b82f6;
-    color: #fff;
-    border: none;
-    border-radius: 8px;
-    font-size: 0.95rem;
-    font-weight: 600;
-    cursor: pointer;
-
-    &:disabled {
-      background: #9ca3af;
-      cursor: not-allowed;
-    }
-
-    &:not(:disabled):hover {
-      background: #2563eb;
-    }
-  }
-}
-
-.auth-hint {
-  font-size: 0.75rem;
-  color: #9ca3af;
-  margin-top: 0.25rem;
-}
-
-.auth-error {
-  margin: 0.75rem 0 0;
-  color: #dc2626;
-  font-size: 0.85rem;
-}
-
-.auth-success {
-  margin: 0.75rem 0 0;
-  color: #16a34a;
-  font-size: 0.85rem;
-}
-
-.auth-link {
-  margin-top: 1rem;
-  font-size: 0.85rem;
-  text-align: center;
-
-  a {
-    color: #3b82f6;
-  }
-}

apps/frontend/src/app/features/auth/reset-password/reset-password.spec.ts

@@ -1,129 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { ReactiveFormsModule } from '@angular/forms';
-import { ActivatedRoute, convertToParamMap, Router } from '@angular/router';
-import { HttpErrorResponse } from '@angular/common/http';
-import { of, throwError } from 'rxjs';
-import { vi } from 'vitest';
-import { ResetPassword } from './reset-password';
-import { AuthService } from '../../../core/services/auth.service';
-import { MOTIF_LIEN_RESET_INVALIDE } from '../../../shared/models/auth-redirect-reason';
-
-function configure(token: string | null) {
-  return TestBed.configureTestingModule({
-    imports: [ResetPassword, ReactiveFormsModule],
-    providers: [
-      {
-        provide: AuthService,
-        useValue: {
-          resetPassword: vi.fn(),
-          validateResetToken: vi.fn().mockReturnValue(of({ valid: true })),
-        },
-      },
-      { provide: Router, useValue: { navigate: vi.fn() } },
-      {
-        provide: ActivatedRoute,
-        useValue: { snapshot: { queryParamMap: convertToParamMap(token ? { token } : {}) } },
-      },
-    ],
-  }).compileComponents();
-}
-
-describe('ResetPassword', () => {
-  it("redirige vers /login avec le motif standard quand le jeton est absent de l'URL", async () => {
-    await configure(null);
-    const fixture = TestBed.createComponent(ResetPassword);
-    const router = TestBed.inject(Router) as unknown as { navigate: ReturnType<typeof vi.fn> };
-
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.hasToken).toBe(false);
-    expect(router.navigate).toHaveBeenCalledWith(['/login'], {
-      queryParams: { motif: MOTIF_LIEN_RESET_INVALIDE },
-    });
-  });
-
-  it('vérifie le jeton sans le consommer dès le chargement de la page', async () => {
-    await configure('un-secret-opaque');
-    const fixture = TestBed.createComponent(ResetPassword);
-    const auth = TestBed.inject(AuthService) as unknown as { validateResetToken: ReturnType<typeof vi.fn> };
-
-    fixture.detectChanges();
-
-    expect(auth.validateResetToken).toHaveBeenCalledWith('un-secret-opaque');
-    expect(fixture.componentInstance.isCheckingToken()).toBe(false);
-  });
-
-  it('redirige immédiatement vers /login si la vérification signale un jeton invalide', async () => {
-    await configure('un-secret-perime');
-    TestBed.overrideProvider(AuthService, {
-      useValue: { resetPassword: vi.fn(), validateResetToken: vi.fn().mockReturnValue(of({ valid: false })) },
-    });
-    const fixture = TestBed.createComponent(ResetPassword);
-    const router = TestBed.inject(Router) as unknown as { navigate: ReturnType<typeof vi.fn> };
-
-    fixture.detectChanges();
-
-    expect(router.navigate).toHaveBeenCalledWith(['/login'], {
-      queryParams: { motif: MOTIF_LIEN_RESET_INVALIDE },
-    });
-  });
-
-  it('ne soumet pas si le mot de passe ne respecte pas la politique de complexité', async () => {
-    await configure('un-secret-opaque');
-    const fixture = TestBed.createComponent(ResetPassword);
-    const component = fixture.componentInstance;
-    const auth = TestBed.inject(AuthService) as unknown as { resetPassword: ReturnType<typeof vi.fn> };
-    component.form.setValue({ new_password: 'trop-simple' });
-
-    component.onSubmit();
-
-    expect(auth.resetPassword).not.toHaveBeenCalled();
-  });
-
-  it('redirige vers /dashboard après une réinitialisation réussie', async () => {
-    await configure('un-secret-opaque');
-    const fixture = TestBed.createComponent(ResetPassword);
-    const component = fixture.componentInstance;
-    const auth = TestBed.inject(AuthService) as unknown as { resetPassword: ReturnType<typeof vi.fn> };
-    const router = TestBed.inject(Router) as unknown as { navigate: ReturnType<typeof vi.fn> };
-    component.form.setValue({ new_password: 'Un-nouveau-mot-de-passe1!' });
-    auth.resetPassword.mockReturnValue(of({ principal: { role: 'operateur' } }));
-
-    component.onSubmit();
-
-    expect(auth.resetPassword).toHaveBeenCalledWith({
-      token: 'un-secret-opaque',
-      new_password: 'Un-nouveau-mot-de-passe1!',
-    });
-    expect(router.navigate).toHaveBeenCalledWith(['/dashboard']);
-  });
-
-  it('redirige vers /login avec le motif standard quand le lien est invalide ou expiré', async () => {
-    await configure('un-secret-perime');
-    const fixture = TestBed.createComponent(ResetPassword);
-    const component = fixture.componentInstance;
-    const auth = TestBed.inject(AuthService) as unknown as { resetPassword: ReturnType<typeof vi.fn> };
-    const router = TestBed.inject(Router) as unknown as { navigate: ReturnType<typeof vi.fn> };
-    component.form.setValue({ new_password: 'Un-nouveau-mot-de-passe1!' });
-    auth.resetPassword.mockReturnValue(throwError(() => new HttpErrorResponse({ status: 400 })));
-
-    component.onSubmit();
-
-    expect(router.navigate).toHaveBeenCalledWith(['/login'], {
-      queryParams: { motif: MOTIF_LIEN_RESET_INVALIDE },
-    });
-  });
-
-  it('affiche un message générique sur une erreur inattendue (pas 400)', async () => {
-    await configure('un-secret-opaque');
-    const fixture = TestBed.createComponent(ResetPassword);
-    const component = fixture.componentInstance;
-    const auth = TestBed.inject(AuthService) as unknown as { resetPassword: ReturnType<typeof vi.fn> };
-    component.form.setValue({ new_password: 'Un-nouveau-mot-de-passe1!' });
-    auth.resetPassword.mockReturnValue(throwError(() => new HttpErrorResponse({ status: 500 })));
-
-    component.onSubmit();
-
-    expect(component.errorMessage()).toContain('invalide');
-  });
-});

apps/frontend/src/app/features/auth/reset-password/reset-password.ts

@@ -1,79 +0,0 @@
-import { Component, OnInit, inject, signal } from '@angular/core';
-import { toSignal } from '@angular/core/rxjs-interop';
-import { ReactiveFormsModule, FormBuilder } from '@angular/forms';
-import { ActivatedRoute, Router, RouterLink } from '@angular/router';
-import { HttpErrorResponse } from '@angular/common/http';
-import { AuthService } from '../../../core/services/auth.service';
-import { passwordValidators, PASSWORD_HINT } from '../../../shared/validators/password.validator';
-import { PasswordRequirementsChecklist } from '../../../shared/components/password-requirements/password-requirements';
-import { MOTIF_LIEN_RESET_INVALIDE } from '../../../shared/models/auth-redirect-reason';
-
-@Component({
-  selector: 'app-reset-password',
-  standalone: true,
-  imports: [ReactiveFormsModule, RouterLink, PasswordRequirementsChecklist],
-  templateUrl: './reset-password.html',
-  styleUrl: './reset-password.scss',
-})
-export class ResetPassword implements OnInit {
-  private fb = inject(FormBuilder);
-  private auth = inject(AuthService);
-  private router = inject(Router);
-  private route = inject(ActivatedRoute);
-
-  private token = this.route.snapshot.queryParamMap.get('token') ?? '';
-
-  errorMessage = signal<string | null>(null);
-  isLoading = signal(false);
-  passwordHint = PASSWORD_HINT;
-  hasToken = this.token.length > 0;
-
-  form = this.fb.nonNullable.group({
-    new_password: ['', passwordValidators],
-  });
-
-  password = toSignal(this.form.controls.new_password.valueChanges, { initialValue: '' });
-  isCheckingToken = signal(this.hasToken);
-
-  ngOnInit(): void {
-    if (!this.hasToken) {
-      this.redirigeVersLoginLienInvalide();
-      return;
-    }
-
-    this.auth.validateResetToken(this.token).subscribe({
-      next: ({ valid }) => {
-        this.isCheckingToken.set(false);
-        if (!valid) {
-          this.redirigeVersLoginLienInvalide();
-        }
-      },
-      error: () => this.isCheckingToken.set(false),
-    });
-  }
-
-  onSubmit(): void {
-    if (this.form.invalid || !this.hasToken) return;
-
-    this.isLoading.set(true);
-    this.errorMessage.set(null);
-
-    this.auth.resetPassword({ token: this.token, new_password: this.form.getRawValue().new_password }).subscribe({
-      next: () => {
-        this.router.navigate(['/dashboard']);
-      },
-      error: (error: HttpErrorResponse) => {
-        this.isLoading.set(false);
-        if (error.status === 400) {
-          this.redirigeVersLoginLienInvalide();
-          return;
-        }
-        this.errorMessage.set(`Nouveau mot de passe invalide (${this.passwordHint}).`);
-      },
-    });
-  }
-
-  private redirigeVersLoginLienInvalide(): void {
-    this.router.navigate(['/login'], { queryParams: { motif: MOTIF_LIEN_RESET_INVALIDE } });
-  }
-}

apps/frontend/src/app/shared/components/password-requirements/password-requirements.html

@@ -1,8 +0,0 @@
-<ul class="password-requirements">
-  @for (requirement of requirements(); track requirement.label) {
-    <li [class.met]="requirement.met" [class.unmet]="!requirement.met">
-      <span class="password-requirements-icon">{{ requirement.met ? '✓' : '○' }}</span>
-      {{ requirement.label }}
-    </li>
-  }
-</ul>

apps/frontend/src/app/shared/components/password-requirements/password-requirements.scss

@@ -1,29 +0,0 @@
-:host {
-  display: block;
-}
-
-.password-requirements {
-  list-style: none;
-  margin: 0.25rem 0 0;
-  padding: 0;
-  font-size: 0.8rem;
-  line-height: 1.5;
-
-  li {
-    display: flex;
-    align-items: center;
-    gap: 0.4rem;
-  }
-
-  .password-requirements-icon {
-    font-weight: 700;
-  }
-
-  .unmet {
-    color: #9ca3af;
-  }
-
-  .met {
-    color: #16a34a;
-  }
-}

apps/frontend/src/app/shared/components/password-requirements/password-requirements.spec.ts

@@ -1,39 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { PasswordRequirementsChecklist } from './password-requirements';
-
-describe('PasswordRequirementsChecklist', () => {
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [PasswordRequirementsChecklist],
-    }).compileComponents();
-  });
-
-  it('ne coche aucune règle pour un mot de passe vide', () => {
-    const fixture = TestBed.createComponent(PasswordRequirementsChecklist);
-    fixture.componentRef.setInput('password', '');
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.requirements().every((r) => !r.met)).toBe(true);
-  });
-
-  it('ne coche que les règles satisfaites pour un mot de passe partiel', () => {
-    const fixture = TestBed.createComponent(PasswordRequirementsChecklist);
-    fixture.componentRef.setInput('password', 'abcdefgh');
-    fixture.detectChanges();
-
-    const parLabel = new Map(fixture.componentInstance.requirements().map((r) => [r.label, r.met]));
-    expect(parLabel.get('8 caractères minimum')).toBe(true);
-    expect(parLabel.get('1 minuscule')).toBe(true);
-    expect(parLabel.get('1 majuscule')).toBe(false);
-    expect(parLabel.get('1 chiffre')).toBe(false);
-    expect(parLabel.get('1 caractère spécial')).toBe(false);
-  });
-
-  it('coche toutes les règles pour un mot de passe conforme', () => {
-    const fixture = TestBed.createComponent(PasswordRequirementsChecklist);
-    fixture.componentRef.setInput('password', 'Un-nouveau-mot-de-passe1!');
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.requirements().every((r) => r.met)).toBe(true);
-  });
-});

apps/frontend/src/app/shared/components/password-requirements/password-requirements.ts

@@ -1,19 +0,0 @@
-import { Component, computed, input } from '@angular/core';
-import { PASSWORD_REQUIREMENTS } from '../../validators/password.validator';
-
-@Component({
-  selector: 'app-password-requirements',
-  standalone: true,
-  templateUrl: './password-requirements.html',
-  styleUrl: './password-requirements.scss',
-})
-export class PasswordRequirementsChecklist {
-  password = input('');
-
-  requirements = computed(() =>
-    PASSWORD_REQUIREMENTS.map((requirement) => ({
-      label: requirement.label,
-      met: requirement.test(this.password()),
-    })),
-  );
-}

apps/frontend/src/app/shared/models/auth-redirect-reason.ts

@@ -1,3 +0,0 @@
-export const MOTIF_LIEN_RESET_INVALIDE = 'lien-expire';
-export const MESSAGE_LIEN_RESET_INVALIDE =
-  'Ce lien de réinitialisation est invalide ou a expiré. Connectez-vous ou redemandez-en un.';

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

@@ -10,15 +10,6 @@ export interface PasswordChangeRequest {
   new_password: string;
 }
 
-export interface ForgotPasswordRequest {
-  email: string;
-}
-
-export interface ResetPasswordRequest {
-  token: string;
-  new_password: string;
-}
-
 export interface Principal {
   id: string;
   email: string;

apps/frontend/src/app/shared/validators/password.validator.spec.ts

@@ -1,26 +0,0 @@
-import { FormControl } from '@angular/forms';
-import { passwordValidators } from './password.validator';
-
-function estValide(motDePasse: string): boolean {
-  return new FormControl(motDePasse, passwordValidators).valid;
-}
-
-describe('passwordValidators', () => {
-  it('accepte un mot de passe couvrant les quatre classes', () => {
-    expect(estValide('Un-mot-de-passe1!')).toBe(true);
-  });
-
-  it('accepte un mot de passe accentué (alignement avec le backend, ex: "Sécurité1")', () => {
-    expect(estValide('Sécurité1!')).toBe(true);
-  });
-
-  it('refuse un mot de passe sans majuscule même avec un "×" ou un "÷"', () => {
-    expect(estValide('abcdefg1×')).toBe(false);
-    expect(estValide('abcdefg1÷')).toBe(false);
-  });
-
-  it('refuse un mot de passe sans minuscule même avec un "×" ou un "÷"', () => {
-    expect(estValide('ABCDEFG1×')).toBe(false);
-    expect(estValide('ABCDEFG1÷')).toBe(false);
-  });
-});

apps/frontend/src/app/shared/validators/password.validator.ts

@@ -1,40 +0,0 @@
-// Contrainte : `PASSWORD_PATTERN` doit rester identique au validateur Pydantic de
-// `app/schemas/auth.py` côté backend (mêmes plages de majuscules/minuscules, excluant
-// × et ÷, mêmes chiffres 0-9, même jeu de caractères spéciaux). `\w`/`\d` divergent entre
-// JavaScript (ASCII) et Python (Unicode) : une négation aurait accepté ou rejeté un même
-// mot de passe différemment d'un côté à l'autre (ex. "Sécurité1").
-
-import { Validators } from '@angular/forms';
-
-export const PASSWORD_MIN_LENGTH = 8;
-export const PASSWORD_MAX_LENGTH = 128;
-export const PASSWORD_HINT =
-  '8 à 128 caractères, avec au moins 1 majuscule, 1 minuscule, 1 chiffre et 1 caractère spécial';
-
-const SPECIAL_CHARACTERS = '!@#$%^&*()\\-_=+[\\]{};:,.?';
-const PASSWORD_PATTERN = new RegExp(
-  `^(?=.*[A-ZÀ-ÖØ-Þ])(?=.*[a-zà-öø-þ])` +
-    `(?=.*[0-9])(?=.*[${SPECIAL_CHARACTERS}]).*$`,
-);
-
-export const passwordValidators = [
-  Validators.required,
-  Validators.minLength(PASSWORD_MIN_LENGTH),
-  Validators.maxLength(PASSWORD_MAX_LENGTH),
-  Validators.pattern(PASSWORD_PATTERN),
-];
-
-export interface PasswordRequirement {
-  label: string;
-  test: (value: string) => boolean;
-}
-
-const SPECIAL_REGEX = new RegExp(`[${SPECIAL_CHARACTERS}]`);
-
-export const PASSWORD_REQUIREMENTS: PasswordRequirement[] = [
-  { label: `${PASSWORD_MIN_LENGTH} caractères minimum`, test: (v) => v.length >= PASSWORD_MIN_LENGTH },
-  { label: '1 majuscule', test: (v) => /[A-ZÀ-ÖØ-Þ]/.test(v) },
-  { label: '1 minuscule', test: (v) => /[a-zà-öø-þ]/.test(v) },
-  { label: '1 chiffre', test: (v) => /[0-9]/.test(v) },
-  { label: '1 caractère spécial', test: (v) => SPECIAL_REGEX.test(v) },
-];

docker-compose.yml

@@ -27,22 +27,11 @@ services:
       start_period: 40s
     restart: unless-stopped
 
-  # Piege : Mailpit ne relaie rien vers l'exterieur, il capture tout email envoye par le
-  # backend. Aucun acces reseau sortant n'est requis ; l'UI web (8025) sert a lire les emails.
-  mailpit:
-    image: axllent/mailpit
-    ports:
-      - "${MAILPIT_SMTP_PORT:-1025}:1025"
-      - "${MAILPIT_UI_PORT:-8025}:8025"
-    restart: unless-stopped
-
   backend:
     build: ./apps/backend
     depends_on:
       db:
         condition: service_healthy
-      mailpit:
-        condition: service_started
     environment:
       APP_ENV: ${APP_ENV:-local}
       APP_DEBUG: ${APP_DEBUG:-false}
@@ -50,11 +39,6 @@ services:
       APP_SECRET_KEY: ${APP_SECRET_KEY:?}
       APP_CORS_ORIGINS: ${APP_CORS_ORIGINS:-http://localhost:4200}
       DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
-      APP_FRONTEND_RESET_PASSWORD_URL: ${APP_FRONTEND_RESET_PASSWORD_URL:-http://localhost:4200/reset-password}
-      APP_SMTP_HOST: mailpit
-      APP_SMTP_PORT: "1025"
-      APP_SMTP_USE_TLS: "false"
-      APP_SMTP_FROM_ADDRESS: ${APP_SMTP_FROM_ADDRESS:-no-reply@enervision.fr}
     ports:
       - "${BACKEND_PORT:-8000}:8000"
     restart: unless-stopped

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

@@ -0,0 +1,101 @@
+# 0005 - Modèle de prédiction de consommation : LightGBM
+
+- Statut : accepté
+- Date : 2026-09-17
+
+## Contexte
+
+Le schéma `prediction` contraint déjà la forme de la solution (deux cibles de régression,
+`consumption_kw` instantané et `consumption_kwh` sur `period_minutes`, un statut
+`insufficient_data` à détecter explicitement), mais aucun modèle n'était choisi. Trois
+contraintes non négociables cadrent le choix, discutées dans l'issue #89 :
+
+1. **EC06** (grille de notation individuelle) exige un modèle **entraîné, versionné avec
+   MLflow**, exposé via un endpoint fonctionnel, avec **surveillance du drift** en production.
+2. **Aucun GPU dédié** : l'infra tourne on-premise sur une VM à 4 CPU / 8 Gio RAM (ou
+   `Standard_B2s`/`B2ms` côté Azure, 2 vCPU max) — Azure Machine Learning est de toute façon
+   bloqué par la politique Azure du projet.
+3. **Délai serré** : le jalon J3 arrive à échéance le lendemain de la décision, J4 concentre déjà
+   26 issues sur 4 jours. Un modèle long à mettre en œuvre retarde la chaîne complète (service de
+   scoring #37, moteur de recommandations #38, tests ML #44/#45, tous bloqués par ce choix).
+
+Le jeu de données est déjà disponible (`all_sites_combined.csv`, fourni par le formateur) : 7
+sites, 2 ans au pas horaire (~17 500 lignes/site), avec `temperature_celsius`,
+`humidity_percent`, `solar_irradiance_wm2` en régresseurs exogènes et des features calendaires
+déjà dérivées.
+
+## Options comparées
+
+| Critère | Prophet | LightGBM/XGBoost | NeuralProphet | SARIMA | Holt-Winters | Mistral (LLM) |
+|---|---|---|---|---|---|---|
+| Saisonnalités multiples (jour/semaine/an) | Oui, nativement | Oui, via features engineered | Oui, nativement, + autorégression | Une seule, lourd à régler (SARIMAX) | Une seule, aucune | Non conçu pour ça |
+| Régresseurs exogènes | Oui, mais doivent être connus dans le futur au moment de la prédiction | Oui, via lags/moyennes glissantes sur le passé | Oui, natif | Difficile en multivarié | Aucun support | Contexte de prompt seulement, non appris |
+| Coût de calcul (VM sans GPU) | Faible | Faible | Élevé (deep learning) | Faible | Faible | Élevé à prohibitif |
+| Versionnable MLflow | Oui, nativement | Oui, nativement | Pas de support direct | Oui, générique | Pas de support direct | Rien à versionner (pas un modèle entraîné) |
+| Granularité | Un modèle par site (ou par site × métrique) | Un seul modèle global sur tous les sites | Un par site | Un par site | Un par site | — |
+| Effort avant l'échéance | Faible | Moyen (feature engineering) | Élevé | Moyen à élevé | Faible en soi | Élevé, ou factice |
+
+## Décision
+
+**LightGBM, un seul modèle global** couvrant tous les sites, plutôt qu'un modèle par site
+(Prophet) ou par famille de site. Cible : `consumption_kwh`, avec `period_minutes` comme feature
+d'entrée plutôt que comme étape d'agrégation post-prédiction. Suivi et versioning via **MLflow**
+(tracking + registre de modèles), sur le magasin local par défaut dans un premier temps —
+l'hébergement sur l'infra k3s reste une question ouverte, non bloquante pour démarrer.
+
+Raisons retenues, au-delà du tableau ci-dessus :
+
+- **Un modèle global plutôt qu'un modèle par site** évite la fragilité des sites les moins
+  fournis en historique : ils bénéficient de ce qu'apprennent les autres sites, ce qu'un Prophet
+  par site ne permet pas.
+- **Aucune dépendance à une prévision météo future.** Prophet exige que ses régresseurs
+  (`add_regressor`) soient connus au moment prédit ; `temperature_celsius`,
+  `humidity_percent` et `solar_irradiance_wm2` sont des mesures passées, pas des prévisions, et
+  aucune source de prévision météo n'existe dans le projet. LightGBM s'en sort avec des features
+  de lag/moyenne glissante calculées sur l'historique déjà présent dans `reading`, cf.
+  `ml/enervision_ml/features.py` — un choix qui vaut aussi bien à l'entraînement qu'au futur
+  scoring.
+- **Apprentissage direct sur `consumption_kwh`** avec `period_minutes` en feature, sans étape
+  d'agrégation intermédiaire que la sortie continue de Prophet aurait demandée.
+- **Coût de calcul compatible avec l'infra on-premise sans GPU.**
+
+Débat complet, comparatif détaillé et décision finale : issue #89 (Johan, phyri0s,
+ValentinDeFaria), actée en réunion d'équipe du 2026-09-17 et validée par l'ensemble de l'équipe.
+
+## Conséquences
+
+- Le pipeline d'entraînement (`ml/`, ce commit) lit `reading` + `site` par connexion PostgreSQL
+  directe et construit ses features par lags/moyennes glissantes plutôt que par régresseurs
+  contemporains, cf. `docs/ML-START.md`.
+- Le rôle PostgreSQL dédié `enervision_ml` (lecture seule sur `reading`/`site`) n'est pas encore
+  provisionné : dette déjà assumée par l'ADR 0003 pour les comptes ETL/ML, `ML_DATABASE_URL`
+  pointe pour l'instant vers la même base que le backend applicatif en développement.
+- Le service de scoring (#37), le moteur de recommandations (#38) et les tests de dérive
+  (#44/#45) restent à construire ; ils consommeront le même module `enervision_ml.features`, qui
+  doit rester strictement identique entre entraînement et scoring pour éviter un train/serve skew
+  silencieux.
+- La surveillance de drift exigée par EC06 n'est pas encore implémentée : ce ticket ne livre que
+  l'entraînement et son suivi MLflow (paramètres, métriques, artefact modèle), pas le monitoring
+  en production.
+- L'hébergement de MLflow sur l'infra k3s reste une question ouverte ; le magasin SQLite local
+  (`ml/mlflow.db`, ignoré par git) suffit pour l'instant à comparer des runs sur un poste.
+
+## Alternatives écartées
+
+- **Prophet** : proposition initiale, écartée après débat pour les raisons ci-dessus (modèle par
+  site, dépendance à une météo future indisponible, agrégation kWh en post-traitement). Reste un
+  candidat solide si un jour le projet doit produire une décomposition tendance/saisonnalité
+  explicable pour un usage différent.
+- **Mistral (LLM)** : aucun produit dédié aux séries temporelles ; interroger un LLM généraliste
+  ne constitue pas un modèle entraîné et versionnable au sens MLflow, et le fine-tuning est hors
+  budget de calcul et hors délai.
+- **SARIMA** : ne gère pas nativement plusieurs régresseurs exogènes ; réglage (p,d,q,P,D,Q) plus
+  long que le délai disponible.
+- **NeuralProphet** : fait tout ce que fait Prophet et apprend en plus des motifs autorégressifs,
+  mais coûte plus cher en calcul (pas de GPU disponible) et n'a pas d'outil MLflow direct — piste
+  d'évolution possible, non engageante à ce stade.
+- **Holt-Winters** : écarté d'entrée, pas seulement différé — aucun support de régresseurs
+  exogènes, alors que la météo et l'irradiance sont nécessaires ici.
+- **CatBoost** : même famille que LightGBM, gère nativement les colonnes catégorielles (comme
+  `site_type`) sans encodage manuel. Non rejeté, différé : candidat à comparer si LightGBM
+  plafonne en précision.

docs/architecture/00-vue-ensemble.md

@@ -77,6 +77,7 @@ collecteur ne vient le lire.
 | Backend | FastAPI, Python 3.14 | `apps/backend` | `En cours` | Factory, configuration, journalisation, 2 sondes de santé, `/metrics`, contrat OpenAPI versionné, routes `sites`, `alerts`, `recommendations`, `stats/summary` et `readings` en lecture (endpoints → services → repositories → models) |
 | Frontend | Angular 22, Node 24 | `apps/frontend` | `En cours` | Tableau de bord sur route `/dashboard`, deux services HTTP, graphiques Chart.js, données servies par des fixtures |
 | Base | PostgreSQL 17 + TimescaleDB | `db` | `Fait` | Bootstrap de l'extension, base de test, chaîne Alembic. Schéma applicatif créé (`site`, `dataset`, `reading` en hypertable, `prediction`, `alert`, `recommendation`) |
+| ML | LightGBM, MLflow | `ml` | `En cours` | Pipeline d'entraînement (features par lags/moyennes glissantes, baseline de persistance saisonnière, suivi MLflow local), voir [ADR 0005](../adr/0005-modele-prediction-lightgbm.md) et [ML-START.md](../../ML-START.md). Scoring, endpoint et surveillance de dérive pas encore construits |
 | Infra | Terraform, k3s single-node | `infra/terraform` | `En cours` | Module d'installation du cluster. Jamais appliqué, aucune ressource Kubernetes déclarée |
 | Monitoring | Prometheus, Grafana, Alertmanager | `monitoring` | `Cible` | Rien, hors le `/metrics` exposé par l'API |
 | ETL | Apache Airflow | `etl/airflow` | `Cible` | Rien |

docs/architecture/31-contrat-authentification.md

@@ -20,8 +20,6 @@ gérer : il suffit d'envoyer les requêtes avec `withCredentials`.
 | POST | `/api/v1/auth/logout` | cookie | `204` |
 | POST | `/api/v1/auth/logout-all` | jeton d'accès | `204` |
 | POST | `/api/v1/auth/password` | jeton d'accès | `200` `TokenResponse` |
-| POST | `/api/v1/auth/forgot-password` | aucune | `202` (toujours, que le compte existe ou non) |
-| POST | `/api/v1/auth/reset-password` | aucune (jeton dans le corps) | `200` `TokenResponse` |
 | GET | `/api/v1/auth/me` | jeton d'accès | `200` `PrincipalResponse` |
 | GET | `/api/v1/users` | jeton d'accès, `admin` | `200` `UserResponse[]` |
 | POST | `/api/v1/users` | jeton d'accès, `admin` | `201` `TemporaryPasswordResponse` |
@@ -53,17 +51,7 @@ codes d'erreur ci-dessous reste la référence de comportement, le schéma celle
 }
 
 // POST /auth/password
-{ "current_password": "...", "new_password": "..." }   // 8 à 128 caractères, au moins 1 majuscule, 1 minuscule, 1 chiffre, 1 caractère spécial
-
-// POST /auth/forgot-password
-{ "email": "operateur@enervision.fr" }
-// Répond toujours 202, sans corps, que le compte existe, soit inactif, ou soit inconnu.
-
-// POST /auth/reset-password
-{ "token": "...", "new_password": "..." }   // même règle de complexité que /auth/password
-// Le jeton vient du lien reçu par email, valable 15 minutes, à usage unique. Répond
-// TokenResponse au succès (l'appareil qui pose le nouveau mot de passe reste connecté), ou 400
-// si le jeton est invalide, déjà utilisé, ou expiré.
+{ "current_password": "...", "new_password": "..." }   // 12 à 128 caractères
 ```
 
 Le secret de rafraîchissement **n'apparaît jamais** dans le corps de la réponse.
@@ -82,9 +70,6 @@ Le secret de rafraîchissement **n'apparaît jamais** dans le corps de la répon
 | `403` avec `detail: "Droits insuffisants"` | rôle trop bas | masquer ou griser l'action, ne pas déconnecter |
 | `403` sur `/auth/refresh`, `/logout`, `/logout-all`, `/password` | origine hors liste autorisée (voir « Origines autorisées ») | erreur de configuration réseau, pas un cas à gérer par l'utilisateur |
 | `422` | corps invalide | le détail donne `champ` et `type`, jamais la valeur envoyée |
-| `429` sur `/auth/forgot-password` | trop de demandes | afficher l'attente, l'en-tête `Retry-After` donne les secondes |
-| `400` sur `/auth/reset-password` | lien invalide, déjà utilisé, ou expiré | inviter à redemander un lien depuis `/forgot-password` |
-| `403` sur `/auth/reset-password` | origine hors liste autorisée | erreur de configuration réseau, pas un cas à gérer par l'utilisateur |
 
 ## Les quatre règles qui comptent
 

ml/.python-version

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

ml/README.md

@@ -0,0 +1,88 @@
+# ML EnerVision
+
+Pipeline d'entrainement du modele de prevision de consommation energetique. Contexte complet :
+[ADR 0005](../docs/adr/0005-modele-prediction-lightgbm.md) (choix du modele) et
+[ML-START.md](../ML-START.md) (mecanisme d'acces aux donnees).
+
+| Element      | Choix                                        |
+|--------------|-----------------------------------------------|
+| Python       | 3.14                                          |
+| Gestionnaire | uv (`uv.lock` fait foi)                       |
+| Modele       | LightGBM (regression, un seul modele global)  |
+| Suivi        | MLflow (parametres, metriques, artefact)      |
+| Lint/format  | ruff                                          |
+| Typage       | mypy en mode strict                           |
+| Tests        | pytest, donnees synthetiques uniquement       |
+
+Projet Python independant de `apps/backend` : le service FastAPI n'a aucune raison d'embarquer
+LightGBM/MLflow en dependance de production juste pour un script d'entrainement lance a la main.
+
+## Installation
+
+```bash
+uv sync --all-groups
+```
+
+## Donnees
+
+Deux sources, qui produisent le meme schema en sortie de `enervision_ml.data` (voir le module
+pour le detail) :
+
+- **CSV** (`--csv`), chemin de demarrage : lit directement `ml/data/all_sites_combined.csv`, le
+  jeu de donnees fourni pour le jalon J3. Ce dossier est ignore par git (gros fichier, local a
+  chaque poste) : recuperer le CSV et `dataset_metadata.json` aupres de l'equipe et les placer
+  dans `ml/data/` avant d'entrainer sur cette source.
+- **PostgreSQL** (par defaut, sans `--csv`) : connexion directe a `reading` + `site` via
+  `ML_DATABASE_URL`, le chemin cible decrit dans `ML-START.md`. Le role PostgreSQL dedie
+  `enervision_ml` (lecture seule) n'est pas encore provisionne (dette assumee, cf. ADR 0003 et
+  ADR 0005) ; en attendant, pointer `ML_DATABASE_URL` vers la meme base que le backend suffit en
+  developpement.
+
+## Entrainement
+
+```bash
+uv run python -m enervision_ml.train --csv data/all_sites_combined.csv
+# ou, une fois la base peuplee et ML_DATABASE_URL positionnee :
+uv run python -m enervision_ml.train
+```
+
+Ecrit le modele entraine dans `models/lightgbm-consumption.txt` (`Booster.save_model()`, dossier
+ignore par git) et journalise la run dans MLflow : parametres, MAE/RMSE/MAPE du modele **et** de
+la baseline de persistance saisonniere (consommation de la meme heure, une semaine avant), et
+l'artefact modele. Sans `MLFLOW_TRACKING_URI`, MLflow ecrit dans un magasin SQLite local
+(`./mlflow.db`, ignore par git) : `uv run mlflow ui` pour le consulter.
+
+`--test-fraction` (0.15 par defaut) fixe la part la plus recente de l'historique reservee a la
+validation. La coupure est **chronologique**, jamais un tirage aleatoire de lignes : un tirage
+aleatoire laisserait des lignes de validation "voir" des lignes d'entrainement via leurs
+lags/moyennes glissantes, une fuite qui masquerait un surapprentissage.
+
+## Commandes
+
+```bash
+uv run ruff check .                       # lint
+uv run ruff format .                      # format
+uv run mypy enervision_ml tests           # typage strict
+uv run pytest                             # tests
+```
+
+Depuis la racine du monorepo, via le `Makefile` : `make install-ml`, `make ml-lint`,
+`make ml-typecheck`, `make ml-test`, `make ml-check`, `make ml-train` (`CSV=chemin` optionnel).
+
+## Ou ecrire les tests
+
+Aucun test ne touche PostgreSQL ni un serveur MLflow distant : `enervision_ml.data.load_from_csv`
+et le chargement CSV de test suffisent a exercer `build_features` sur des donnees reelles ou
+synthetiques, et `enervision_ml.train.train()` accepte un `tracking_uri` SQLite isole (`tmp_path`
+pytest) pour un test de bout en bout sans effet de bord. `enervision_ml.data.load_from_database`
+n'est pas encore couvert : il n'existe aucune base PostgreSQL a interroger en CI ni dans cet
+environnement de developpement pour le moment.
+
+## Piege a connaitre
+
+`enervision_ml.features.build_features` est **le seul endroit** qui doit construire les features
+du modele, a l'entrainement comme au futur scoring (service #37, pas encore construit). Si les
+deux divergent meme legerement (une fenetre de moyenne glissante calculee differemment, par
+exemple), le modele recoit en production des features qui ne ressemblent plus a ce qu'il a
+appris, et ses predictions deviennent silencieusement mauvaises sans qu'aucune erreur ne se
+declenche. Ne jamais reecrire cette logique ailleurs : importer `enervision_ml.features`.

ml/enervision_ml/baseline.py

@@ -0,0 +1,16 @@
+"""Baseline de persistance saisonniere, la barre a depasser pour justifier LightGBM.
+
+Predit la consommation de l'heure cible par celle de la meme heure, une semaine avant
+(`consumption_kwh_lag_168h`) : une consommation energetique horaire est dominee par le cycle
+hebdomadaire (jours ouvres contre week-end), donc ce naif-la est deja un concurrent serieux.
+"""
+
+import pandas as pd
+
+from enervision_ml.features import TARGET_COLUMN
+
+SEASONAL_LAG_COLUMN = f"{TARGET_COLUMN}_lag_168h"
+
+
+def seasonal_persistence_predictions(features: pd.DataFrame) -> pd.Series:
+    return features[SEASONAL_LAG_COLUMN]

ml/enervision_ml/config.py

@@ -0,0 +1,38 @@
+"""Configuration minimale du pipeline, lue depuis l'environnement.
+
+Pas de `BaseSettings` Pydantic ici : contrairement a `apps/backend`, ce n'est pas un service qui
+tourne en continu mais un script CLI lance a la main (cf. `docs/ML-START.md`), donc pas de
+surface de configuration a valider au demarrage d'un processus long.
+"""
+
+import os
+
+# Piege : ce n'est pas `DATABASE_URL` (celui du backend applicatif, proprietaire du schema).
+# `docs/ML-START.md` et l'ADR 0003 designent un role PostgreSQL dedie et restreint en lecture,
+# `enervision_ml`, non encore provisionne (dette assumee). Reutiliser `DATABASE_URL` par defaut
+# ferait tourner l'entrainement avec les droits d'ecriture complets de l'application, en
+# silence.
+ML_DATABASE_URL_ENV = "ML_DATABASE_URL"
+
+MLFLOW_EXPERIMENT_NAME = "consumption-forecast"
+MLFLOW_TRACKING_URI_ENV = "MLFLOW_TRACKING_URI"
+
+
+def database_url() -> str:
+    valeur = os.environ.get(ML_DATABASE_URL_ENV)
+    if not valeur:
+        raise RuntimeError(
+            f"{ML_DATABASE_URL_ENV} n'est pas defini. Elle doit pointer vers un role "
+            "PostgreSQL en lecture seule sur `reading`/`site` (voir docs/ML-START.md)."
+        )
+    return valeur
+
+
+def mlflow_tracking_uri() -> str | None:
+    """`None` laisse MLflow choisir son magasin local par defaut.
+
+    Piege : ce n'est plus `./mlruns` en clair depuis MLflow 3 (magasin fichier "maintenance
+    mode", refuse une URI `file:` explicite sauf `MLFLOW_ALLOW_FILE_STORE=true`), mais une base
+    SQLite locale (`./mlflow.db`).
+    """
+    return os.environ.get(MLFLOW_TRACKING_URI_ENV)

ml/enervision_ml/data.py

@@ -0,0 +1,68 @@
+"""Chargement des donnees d'entrainement.
+
+Deux chemins, qui doivent produire le meme schema de sortie (colonnes `site_id`, `timestamp`,
+`consumption_kwh`, `temperature_celsius`, `humidity_percent`, `solar_irradiance_wm2`,
+`is_working_hours`, `site_type`, `capacity_kw`), consomme ensuite par `enervision_ml.features` :
+
+- `load_from_database` : le chemin cible decrit dans `docs/ML-START.md`, connexion PostgreSQL
+  directe (`reading` + `site`), pas par l'API. C'est celui qu'utilisera le pipeline en
+  production, une fois le role PostgreSQL dedie `enervision_ml` provisionne (dette assumee,
+  documentee dans `CLAUDE.md` et l'ADR 0003 : pour l'instant, la meme chaine de connexion que le
+  backend applicatif convient en developpement).
+- `load_from_csv` : chemin de demarrage, tant que la base locale n'est pas peuplee. Lit
+  directement `ml/data/all_sites_combined.csv` (jeu de donnees fourni pour le jalon J3, cf.
+  issue #89), le meme fichier que celui consomme par
+  `apps/backend/app/etl/historical_import.py`. `capacity_kw` n'existe pas dans ce CSV : la
+  colonne est renvoyee a `NaN`, que LightGBM gere nativement comme valeur manquante.
+"""
+
+from pathlib import Path
+
+import pandas as pd
+from sqlalchemy import text
+from sqlalchemy.engine import Connectable
+
+OUTPUT_COLUMNS = [
+    "site_id",
+    "timestamp",
+    "consumption_kwh",
+    "temperature_celsius",
+    "humidity_percent",
+    "solar_irradiance_wm2",
+    "is_working_hours",
+    "site_type",
+    "capacity_kw",
+]
+
+_READING_QUERY = text(
+    """
+    SELECT
+        r.site_id,
+        r.timestamp,
+        r.consumption_kwh,
+        r.temperature_celsius,
+        r.humidity_percent,
+        r.solar_irradiance_wm2,
+        r.is_working_hours,
+        s.site_type,
+        s.capacity_kw
+    FROM reading r
+    JOIN site s ON s.site_id = r.site_id
+    ORDER BY r.site_id, r.timestamp
+    """
+)
+
+
+def load_from_database(connection: Connectable) -> pd.DataFrame:
+    """Lit l'historique complet `reading` + `site` depuis PostgreSQL."""
+    frame = pd.read_sql(_READING_QUERY, connection)
+    return frame[OUTPUT_COLUMNS]
+
+
+def load_from_csv(csv_path: Path) -> pd.DataFrame:
+    """Lit le jeu de donnees CSV historique (chemin de demarrage, hors base)."""
+    frame = pd.read_csv(csv_path, parse_dates=["timestamp"])
+    frame["capacity_kw"] = float("nan")
+    frame["is_working_hours"] = frame["is_working_hours"].astype(bool)
+
+    return frame[OUTPUT_COLUMNS]

ml/enervision_ml/features.py

@@ -0,0 +1,129 @@
+"""Construction des features pour le modele de consommation.
+
+Module partage entre l'entrainement et le futur scoring (cf. `docs/ML-START.md`) : la fonction
+qui construit les features doit rester strictement identique des deux cotes, sous peine de
+"train/serve skew" silencieux (le modele recoit en production des features qui ne ressemblent
+plus a ce qu'il a appris).
+"""
+
+from collections.abc import Sequence
+
+import pandas as pd
+
+# Cible de l'entrainement : consommation en kWh, jamais consumption_kw (absent des lectures
+# historiques CSV, cf. `apps/backend/app/etl/historical_import.py`).
+TARGET_COLUMN = "consumption_kwh"
+
+# Decalages horaires utilises pour les lags et moyennes glissantes : une heure avant, un jour
+# avant (meme heure), une semaine avant (meme heure, meme jour) - saisonnalites usuelles d'une
+# consommation energetique horaire.
+LAG_HOURS: Sequence[int] = (1, 24, 168)
+ROLLING_WINDOWS_HOURS: Sequence[int] = (24, 168)
+
+STATIC_FEATURE_COLUMNS: Sequence[str] = ("site_type", "capacity_kw")
+
+CALENDAR_FEATURE_COLUMNS: Sequence[str] = (
+    "hour",
+    "day_of_week",
+    "month",
+    "is_weekend",
+    "is_working_hours",
+)
+
+WEATHER_COLUMNS: Sequence[str] = (
+    "temperature_celsius",
+    "humidity_percent",
+    "solar_irradiance_wm2",
+)
+
+
+def build_features(frame: pd.DataFrame) -> pd.DataFrame:
+    """Construit la matrice de features a partir de lectures brutes triees par site.
+
+    `frame` doit porter au minimum : `site_id`, `timestamp`, `consumption_kwh`,
+    `is_working_hours`, les trois colonnes meteo, et les colonnes statiques de site
+    (`site_type`, `capacity_kw`). Une ligne par `(site_id, timestamp)`, sans doublon.
+
+    Piege : la meteo n'entre dans les features que decalee (lag/moyenne glissante), jamais a
+    l'instant cible. A l'entrainement comme au scoring, la meteo au moment predit n'est pas une
+    mesure mais une prevision que le projet n'a pas — l'utiliser telle quelle romprait le
+    contrat entre entrainement et usage reel (la feature ne serait tout simplement plus
+    disponible en production). Cf. debat d'architecture dans l'issue #89.
+    """
+    travail = frame.sort_values(["site_id", "timestamp"]).reset_index(drop=True)
+
+    calendrier = _calendar_features(travail["timestamp"])
+    decalees = _lagged_features(travail)
+
+    features = pd.concat(
+        [
+            travail[["site_id", "timestamp"]],
+            travail[list(STATIC_FEATURE_COLUMNS)],
+            calendrier,
+            travail[["is_working_hours"]],
+            decalees,
+            travail[[TARGET_COLUMN]],
+        ],
+        axis=1,
+    )
+
+    # `period_minutes` : resolution temporelle de la cible. Les lectures historiques sont toutes
+    # au pas horaire (cf. `dataset_metadata.json`, `frequency: "1h""), donc une constante pour
+    # l'instant. Exposee comme feature plutot que supposee implicitement, pour que le modele
+    # puisse un jour apprendre sur d'autres resolutions sans reentrainement de zero.
+    features["period_minutes"] = 60
+
+    return features
+
+
+def feature_columns() -> list[str]:
+    """Liste ordonnee des colonnes d'entree du modele (hors identifiants et cible)."""
+    lag_columns = [f"consumption_kwh_lag_{h}h" for h in LAG_HOURS]
+    rolling_columns = [
+        f"{colonne}_rolling_mean_{fenetre}h"
+        for colonne in (TARGET_COLUMN, *WEATHER_COLUMNS)
+        for fenetre in ROLLING_WINDOWS_HOURS
+    ]
+    weather_lag_columns = [f"{colonne}_lag_1h" for colonne in WEATHER_COLUMNS]
+
+    return [
+        *STATIC_FEATURE_COLUMNS,
+        *CALENDAR_FEATURE_COLUMNS,
+        "period_minutes",
+        *lag_columns,
+        *rolling_columns,
+        *weather_lag_columns,
+    ]
+
+
+def _calendar_features(timestamps: pd.Series) -> pd.DataFrame:
+    instants = pd.to_datetime(timestamps)
+
+    return pd.DataFrame(
+        {
+            "hour": instants.dt.hour,
+            "day_of_week": instants.dt.dayofweek,
+            "month": instants.dt.month,
+            "is_weekend": instants.dt.dayofweek.isin([5, 6]).astype(int),
+        }
+    )
+
+
+def _lagged_features(travail: pd.DataFrame) -> pd.DataFrame:
+    par_site = travail.groupby("site_id", sort=False)
+    colonnes: dict[str, pd.Series] = {}
+
+    for decalage in LAG_HOURS:
+        colonnes[f"{TARGET_COLUMN}_lag_{decalage}h"] = par_site[TARGET_COLUMN].shift(decalage)
+
+    for colonne in (TARGET_COLUMN, *WEATHER_COLUMNS):
+        decale = par_site[colonne].shift(1)
+        for fenetre in ROLLING_WINDOWS_HOURS:
+            colonnes[f"{colonne}_rolling_mean_{fenetre}h"] = decale.groupby(
+                travail["site_id"]
+            ).transform(lambda serie, fenetre=fenetre: serie.rolling(fenetre, min_periods=1).mean())
+
+    for colonne in WEATHER_COLUMNS:
+        colonnes[f"{colonne}_lag_1h"] = par_site[colonne].shift(1)
+
+    return pd.DataFrame(colonnes, index=travail.index)

ml/enervision_ml/metrics.py

@@ -0,0 +1,24 @@
+"""Metriques de regression partagees entre le modele et la baseline."""
+
+import numpy as np
+import pandas as pd
+from sklearn.metrics import mean_absolute_error, root_mean_squared_error
+
+
+def regression_metrics(y_true: pd.Series, y_pred: pd.Series) -> dict[str, float]:
+    """MAE, RMSE et MAPE (en %), sur les paires non nulles des deux series."""
+    valides = y_true.notna() & y_pred.notna()
+    reel = y_true[valides]
+    predit = y_pred[valides]
+
+    # MAPE diverge a consommation nulle : les mesures a zero (site a l'arret) sont exclues de ce
+    # seul ratio, pas des autres metriques.
+    non_nul = reel != 0
+    mape = float(np.mean(np.abs((reel[non_nul] - predit[non_nul]) / reel[non_nul])) * 100)
+
+    return {
+        "mae": float(mean_absolute_error(reel, predit)),
+        "rmse": float(root_mean_squared_error(reel, predit)),
+        "mape": mape,
+        "n_observations": int(valides.sum()),
+    }

ml/enervision_ml/train.py

@@ -0,0 +1,245 @@
+"""Entrainement du modele LightGBM de prevision de consommation energetique.
+
+CLI autonome, sur le meme gabarit que `apps/backend/app/etl/historical_import.py`
+(argparse, connexion directe a la base). Cf. `docs/ML-START.md`, section 1.
+
+    uv run python -m enervision_ml.train --csv ../ml/data/all_sites_combined.csv
+    uv run python -m enervision_ml.train  # lit ML_DATABASE_URL
+
+Le modele entraine est ecrit en fichier (`Booster.save_model()`) et suivi par MLflow (parametres,
+metriques, artefact). La base ne stocke jamais le modele lui-meme, seulement une reference vers
+lui (`prediction.model_reference`, pose par le futur service de scoring - hors perimetre ici).
+"""
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+import lightgbm as lgb
+import mlflow
+import mlflow.lightgbm
+import pandas as pd
+from sqlalchemy import create_engine
+
+from enervision_ml import config
+from enervision_ml.baseline import seasonal_persistence_predictions
+from enervision_ml.data import load_from_csv, load_from_database
+from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
+from enervision_ml.metrics import regression_metrics
+
+CATEGORICAL_FEATURES = ["site_type"]
+
+LIGHTGBM_PARAMS: dict[str, Any] = {
+    "objective": "regression",
+    "metric": "mae",
+    "learning_rate": 0.05,
+    "num_leaves": 63,
+    "min_data_in_leaf": 50,
+    "feature_fraction": 0.8,
+    "bagging_fraction": 0.8,
+    "bagging_freq": 1,
+    "verbosity": -1,
+}
+
+NUM_BOOST_ROUND = 1000
+EARLY_STOPPING_ROUNDS = 50
+DEFAULT_TEST_FRACTION = 0.15
+
+
+def load_raw_frame(csv_path: Path | None) -> pd.DataFrame:
+    """Lit les lectures brutes, depuis le CSV de demarrage ou depuis PostgreSQL."""
+    if csv_path is not None:
+        return load_from_csv(csv_path)
+
+    engine = create_engine(config.database_url())
+    try:
+        return load_from_database(engine)
+    finally:
+        engine.dispose()
+
+
+def chronological_split(
+    features: pd.DataFrame, test_fraction: float
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Coupe par date de coupure, jamais par tirage aleatoire de lignes.
+
+    Une coupure aleatoire laisserait des lignes d'apres la coupure "voir" des lignes d'avant via
+    leurs lags/moyennes glissantes, une fuite qui masquerait un surapprentissage a l'evaluation.
+    """
+    coupure = features["timestamp"].quantile(1 - test_fraction)
+    entrainement = features[features["timestamp"] < coupure]
+    validation = features[features["timestamp"] >= coupure]
+    return entrainement, validation
+
+
+def prepare_dataset(frame: pd.DataFrame, columns: list[str]) -> tuple[pd.DataFrame, pd.Series]:
+    typee = frame.copy()
+    typee["site_type"] = typee["site_type"].astype("category")
+    return typee[columns], typee[TARGET_COLUMN]
+
+
+def train(
+    *,
+    csv_path: Path | None,
+    model_output: Path,
+    test_fraction: float = DEFAULT_TEST_FRACTION,
+    tracking_uri: str | None = None,
+) -> tuple[dict[str, float], dict[str, float]]:
+    """Execute le pipeline complet et rend (metriques du modele, metriques de la baseline)."""
+    raw = load_raw_frame(csv_path)
+    features = build_features(raw)
+    columns = feature_columns()
+
+    # Les premieres 168h par site n'ont pas de lag hebdomadaire complet : ni entrainables, ni
+    # comparables a la baseline saisonniere qui en depend.
+    utilisable = features.dropna(subset=[TARGET_COLUMN, f"{TARGET_COLUMN}_lag_168h"])
+
+    entrainement, validation = chronological_split(utilisable, test_fraction)
+    if entrainement.empty or validation.empty:
+        raise ValueError(
+            "Fenetre d'entrainement ou de validation vide : jeu de donnees trop court pour "
+            f"test_fraction={test_fraction}."
+        )
+
+    X_train, y_train = prepare_dataset(entrainement, columns)
+    X_valid, y_valid = prepare_dataset(validation, columns)
+
+    train_set = lgb.Dataset(
+        X_train,
+        label=y_train,
+        categorical_feature=CATEGORICAL_FEATURES,
+        free_raw_data=False,
+    )
+    valid_set = lgb.Dataset(
+        X_valid,
+        label=y_valid,
+        reference=train_set,
+        categorical_feature=CATEGORICAL_FEATURES,
+        free_raw_data=False,
+    )
+
+    booster = lgb.train(
+        LIGHTGBM_PARAMS,
+        train_set,
+        num_boost_round=NUM_BOOST_ROUND,
+        valid_sets=[valid_set],
+        callbacks=[
+            lgb.early_stopping(EARLY_STOPPING_ROUNDS, verbose=False),
+            lgb.log_evaluation(period=0),
+        ],
+    )
+
+    predictions = pd.Series(
+        booster.predict(X_valid, num_iteration=booster.best_iteration),
+        index=X_valid.index,
+    )
+    model_metrics = regression_metrics(y_valid, predictions)
+    baseline_metrics = regression_metrics(y_valid, seasonal_persistence_predictions(validation))
+
+    model_output.parent.mkdir(parents=True, exist_ok=True)
+    booster.save_model(str(model_output))
+
+    _log_to_mlflow(
+        tracking_uri=tracking_uri,
+        booster=booster,
+        model_metrics=model_metrics,
+        baseline_metrics=baseline_metrics,
+        n_train=len(X_train),
+        n_valid=len(X_valid),
+        test_fraction=test_fraction,
+        model_output=model_output,
+    )
+
+    return model_metrics, baseline_metrics
+
+
+def _log_to_mlflow(
+    *,
+    tracking_uri: str | None,
+    booster: lgb.Booster,
+    model_metrics: dict[str, float],
+    baseline_metrics: dict[str, float],
+    n_train: int,
+    n_valid: int,
+    test_fraction: float,
+    model_output: Path,
+) -> None:
+    uri = tracking_uri or config.mlflow_tracking_uri()
+    if uri is not None:
+        mlflow.set_tracking_uri(uri)
+    mlflow.set_experiment(config.MLFLOW_EXPERIMENT_NAME)
+
+    with mlflow.start_run():
+        mlflow.log_params(
+            {
+                **LIGHTGBM_PARAMS,
+                "num_boost_round": booster.best_iteration or NUM_BOOST_ROUND,
+                "test_fraction": test_fraction,
+                "n_train": n_train,
+                "n_valid": n_valid,
+            }
+        )
+        mlflow.log_metrics({f"model_{cle}": valeur for cle, valeur in model_metrics.items()})
+        mlflow.log_metrics({f"baseline_{cle}": valeur for cle, valeur in baseline_metrics.items()})
+        mlflow.lightgbm.log_model(booster, name="model")
+        mlflow.log_artifact(str(model_output))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Entrainement du modele LightGBM EnerVision")
+
+    parser.add_argument(
+        "--csv",
+        type=Path,
+        default=None,
+        help=(
+            "Chemin vers le CSV historique (chemin de demarrage). Omis, lit ML_DATABASE_URL "
+            "et se connecte directement a PostgreSQL (reading + site)."
+        ),
+    )
+    parser.add_argument(
+        "--model-output",
+        type=Path,
+        default=Path("models/lightgbm-consumption.txt"),
+        help="Chemin d'ecriture du modele entraine. Defaut : models/lightgbm-consumption.txt.",
+    )
+    parser.add_argument(
+        "--test-fraction",
+        type=float,
+        default=DEFAULT_TEST_FRACTION,
+        help=(
+            "Part la plus recente de l'historique reservee a la validation. "
+            f"Defaut : {DEFAULT_TEST_FRACTION}."
+        ),
+    )
+    parser.add_argument(
+        "--mlflow-tracking-uri",
+        default=None,
+        help="Surcharge MLFLOW_TRACKING_URI. Omis, magasin SQLite local (./mlflow.db).",
+    )
+
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    model_metrics, baseline_metrics = train(
+        csv_path=args.csv,
+        model_output=args.model_output,
+        test_fraction=args.test_fraction,
+        tracking_uri=args.mlflow_tracking_uri,
+    )
+
+    print("Modele LightGBM :", model_metrics)
+    print("Baseline saisonniere (t-168h) :", baseline_metrics)
+
+    if model_metrics["mae"] < baseline_metrics["mae"]:
+        gain = (1 - model_metrics["mae"] / baseline_metrics["mae"]) * 100
+        print(f"LightGBM bat la baseline de {gain:.1f}% de MAE.")
+    else:
+        print("LightGBM ne bat pas la baseline saisonniere sur ce decoupage.")
+
+
+if __name__ == "__main__":
+    main()

ml/pyproject.toml

@@ -0,0 +1,79 @@
+[project]
+name = "enervision-ml"
+version = "0.1.0"
+description = "Pipeline d'entrainement et de scoring du modele de prediction EnerVision (LightGBM)"
+requires-python = ">=3.14,<3.15"
+dependencies = [
+    "pandas>=3.0.5",
+    "sqlalchemy>=2.0.52",
+    "psycopg[binary]>=3.2",
+    "lightgbm>=4.6",
+    "scikit-learn>=1.7",
+    "mlflow>=3.0",
+]
+
+[dependency-groups]
+dev = [
+    "ruff>=0.16.7",
+    "mypy>=2.3.1",
+    "pytest>=9.1.1",
+    "pandas-stubs>=3.0.5.260914",
+]
+
+[build-system]
+requires = ["hatchling>=1.32.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["enervision_ml"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py314"
+src = ["enervision_ml", "tests"]
+
+[tool.ruff.lint]
+select = [
+    "E", "W",
+    "F",
+    "I",
+    "N",
+    "UP",
+    "B",
+    "C4",
+    "SIM",
+    "TID",
+    "RUF",
+    "S",
+    "PT",
+]
+# N806 : `X`/`y` (donnees/cible) est la convention scikit-learn/LightGBM, pas une variable mal
+# nommee.
+ignore = ["B008", "N806"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["enervision_ml"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.mypy]
+python_version = "3.14"
+strict = true
+warn_unreachable = true
+
+[[tool.mypy.overrides]]
+module = ["tests.*"]
+disallow_untyped_defs = false
+
+[[tool.mypy.overrides]]
+module = ["lightgbm.*", "mlflow.*", "sklearn.*"]
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q --strict-markers -m 'not integration'"
+markers = ["integration: requiert une base PostgreSQL joignable"]

ml/tests/test_baseline.py

@@ -0,0 +1,11 @@
+import pandas as pd
+
+from enervision_ml.baseline import SEASONAL_LAG_COLUMN, seasonal_persistence_predictions
+
+
+def test_seasonal_persistence_predictions_returns_the_168h_lag_column() -> None:
+    features = pd.DataFrame({SEASONAL_LAG_COLUMN: [1.0, 2.0, 3.0], "autre_colonne": [9, 9, 9]})
+
+    predictions = seasonal_persistence_predictions(features)
+
+    assert predictions.tolist() == [1.0, 2.0, 3.0]

ml/tests/test_features.py

@@ -0,0 +1,96 @@
+from datetime import UTC, datetime, timedelta
+from typing import cast
+
+import pandas as pd
+
+from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
+
+
+def make_site_reading(
+    site_id: str, *, heures: int, depart: datetime, valeur: float = 10.0
+) -> pd.DataFrame:
+    instants = [depart + timedelta(hours=h) for h in range(heures)]
+    return pd.DataFrame(
+        {
+            "site_id": site_id,
+            "timestamp": instants,
+            TARGET_COLUMN: [valeur + h for h in range(heures)],
+            "temperature_celsius": [15.0] * heures,
+            "humidity_percent": [50.0] * heures,
+            "solar_irradiance_wm2": [0.0] * heures,
+            "is_working_hours": [True] * heures,
+            "site_type": "office",
+            "capacity_kw": 100.0,
+        }
+    )
+
+
+def two_site_frame(heures: int = 200) -> pd.DataFrame:
+    depart = datetime(2026, 1, 1, tzinfo=UTC)
+    return pd.concat(
+        [
+            make_site_reading("site-a", heures=heures, depart=depart, valeur=10.0),
+            make_site_reading("site-b", heures=heures, depart=depart, valeur=1000.0),
+        ],
+        ignore_index=True,
+    )
+
+
+def test_build_features_returns_every_declared_feature_column() -> None:
+    features = build_features(two_site_frame())
+
+    manquantes = set(feature_columns()) - set(features.columns)
+
+    assert manquantes == set()
+
+
+def test_build_features_sets_a_constant_period_minutes() -> None:
+    features = build_features(two_site_frame())
+
+    assert (features["period_minutes"] == 60).all()
+
+
+def test_build_features_lag_1h_matches_the_previous_hour_of_the_same_site() -> None:
+    features = build_features(two_site_frame(heures=200))
+    site_a = features[features["site_id"] == "site-a"].reset_index(drop=True)
+
+    assert site_a.loc[10, f"{TARGET_COLUMN}_lag_1h"] == site_a.loc[9, TARGET_COLUMN]
+
+
+def test_build_features_lag_168h_is_nan_before_a_full_week_of_history() -> None:
+    features = build_features(two_site_frame(heures=200))
+    site_a = features[features["site_id"] == "site-a"].reset_index(drop=True)
+
+    assert pd.isna(site_a.loc[100, f"{TARGET_COLUMN}_lag_168h"])
+    assert not pd.isna(site_a.loc[168, f"{TARGET_COLUMN}_lag_168h"])
+
+
+def test_build_features_never_leaks_lags_across_sites() -> None:
+    # site-b demarre a 1000 : si un lag de site-a s'y glissait, la valeur sortirait de son
+    # echelle (10, 11, 12, ...).
+    features = build_features(two_site_frame(heures=200))
+    site_b = features[features["site_id"] == "site-b"].reset_index(drop=True)
+
+    assert cast(float, site_b.loc[5, f"{TARGET_COLUMN}_lag_1h"]) >= 1000.0
+
+
+def test_build_features_rolling_mean_excludes_the_current_hour() -> None:
+    # Valeurs constantes sauf la derniere ligne : si la moyenne glissante incluait l'heure
+    # courante, la constante ne resterait pas stable jusqu'au bout.
+    depart = datetime(2026, 1, 1, tzinfo=UTC)
+    frame = make_site_reading("site-a", heures=200, depart=depart, valeur=10.0)
+    frame[TARGET_COLUMN] = 10.0
+    frame.loc[frame.index[-1], TARGET_COLUMN] = 10_000.0
+
+    features = build_features(frame).reset_index(drop=True)
+
+    assert features.loc[len(features) - 1, f"{TARGET_COLUMN}_rolling_mean_24h"] == 10.0
+
+
+def test_build_features_computes_calendar_fields_from_the_timestamp() -> None:
+    depart = datetime(2026, 1, 3, 6, tzinfo=UTC)  # un samedi, 6h
+    features = build_features(make_site_reading("site-a", heures=1, depart=depart))
+
+    assert features.loc[0, "hour"] == 6
+    assert features.loc[0, "day_of_week"] == 5
+    assert features.loc[0, "is_weekend"] == 1

ml/tests/test_metrics.py

@@ -0,0 +1,45 @@
+import pandas as pd
+import pytest
+
+from enervision_ml.metrics import regression_metrics
+
+
+def test_regression_metrics_computes_mae_and_rmse_on_known_values() -> None:
+    y_true = pd.Series([10.0, 20.0, 30.0])
+    y_pred = pd.Series([12.0, 18.0, 33.0])
+
+    resultat = regression_metrics(y_true, y_pred)
+
+    assert resultat["mae"] == pytest.approx(7 / 3)
+    assert resultat["n_observations"] == 3
+
+
+def test_regression_metrics_ignores_rows_with_a_missing_value() -> None:
+    y_true = pd.Series([10.0, None, 30.0])
+    y_pred = pd.Series([12.0, 18.0, None])
+
+    resultat = regression_metrics(y_true, y_pred)
+
+    assert resultat["n_observations"] == 1
+    assert resultat["mae"] == 2.0
+
+
+def test_regression_metrics_excludes_zero_actuals_from_mape_only() -> None:
+    y_true = pd.Series([0.0, 10.0])
+    y_pred = pd.Series([5.0, 12.0])
+
+    resultat = regression_metrics(y_true, y_pred)
+
+    assert resultat["n_observations"] == 2
+    assert resultat["mape"] == pytest.approx(20.0)
+
+
+def test_metrics_are_zero_for_a_perfect_prediction() -> None:
+    y_true = pd.Series([10.0, 20.0])
+    y_pred = pd.Series([10.0, 20.0])
+
+    resultat = regression_metrics(y_true, y_pred)
+
+    assert resultat["mae"] == 0.0
+    assert resultat["rmse"] == 0.0
+    assert resultat["mape"] == 0.0

ml/tests/test_train.py

@@ -0,0 +1,76 @@
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
+from enervision_ml.train import chronological_split, prepare_dataset, train
+
+
+def make_frame(site_id: str, *, heures: int, depart: datetime) -> pd.DataFrame:
+    instants = [depart + timedelta(hours=h) for h in range(heures)]
+    rng = np.random.default_rng(42)
+
+    return pd.DataFrame(
+        {
+            "site_id": site_id,
+            "timestamp": instants,
+            TARGET_COLUMN: 100.0 + 10.0 * np.sin(np.arange(heures) / 24) + rng.normal(0, 1, heures),
+            "temperature_celsius": 15.0,
+            "humidity_percent": 50.0,
+            "solar_irradiance_wm2": 0.0,
+            "is_working_hours": True,
+            "site_type": "office",
+            "capacity_kw": 100.0,
+        }
+    )
+
+
+def test_chronological_split_puts_the_most_recent_rows_in_validation() -> None:
+    depart = datetime(2026, 1, 1, tzinfo=UTC)
+    features = make_frame("site-a", heures=200, depart=depart)
+
+    entrainement, validation = chronological_split(features, test_fraction=0.2)
+
+    assert entrainement["timestamp"].max() < validation["timestamp"].min()
+    # La coupure vient d'un quantile sur les dates : une approximation du taux demande, pas un
+    # decompte exact de lignes.
+    assert abs(len(validation) - 0.2 * len(features)) <= 2
+
+
+def test_prepare_dataset_types_site_type_as_a_pandas_category() -> None:
+    depart = datetime(2026, 1, 1, tzinfo=UTC)
+    features = build_features(make_frame("site-a", heures=200, depart=depart))
+
+    X, y = prepare_dataset(features, feature_columns())
+
+    assert X["site_type"].dtype.name == "category"
+    assert y.name == TARGET_COLUMN
+
+
+def test_train_runs_end_to_end_on_synthetic_data_and_beats_a_dummy_baseline(
+    tmp_path: Path,
+) -> None:
+    depart = datetime(2026, 1, 1, tzinfo=UTC)
+    frame = pd.concat(
+        [
+            make_frame("site-a", heures=400, depart=depart),
+            make_frame("site-b", heures=400, depart=depart),
+        ],
+        ignore_index=True,
+    )
+    csv_path = tmp_path / "synthetic.csv"
+    frame.to_csv(csv_path, index=False)
+
+    model_metrics, baseline_metrics = train(
+        csv_path=csv_path,
+        model_output=tmp_path / "model.txt",
+        test_fraction=0.2,
+        tracking_uri=f"sqlite:///{tmp_path / 'mlflow.db'}",
+    )
+
+    assert (tmp_path / "model.txt").exists()
+    assert model_metrics["n_observations"] > 0
+    assert model_metrics["mae"] >= 0
+    assert baseline_metrics["n_observations"] == model_metrics["n_observations"]