Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 ineszang
|
b8b8ca7163 | ||
|
ineszang
|
8efa034f9c | ||
|
ineszang
|
39b1daea51 |
@@ -1,27 +0,0 @@
|
||||
# Dépendances (réinstallées dans l'image)
|
||||
node_modules/
|
||||
vendor/
|
||||
__pycache__/
|
||||
*.pyc
|
||||
|
||||
# Git et IDE
|
||||
.git/
|
||||
.gitignore
|
||||
.vscode/
|
||||
.idea/
|
||||
*.swp
|
||||
|
||||
# Fichiers de build locaux
|
||||
dist/
|
||||
build/
|
||||
*.log
|
||||
|
||||
# Secrets et config locale (CRITIQUE : risque d'exfiltration)
|
||||
.env
|
||||
.env.local
|
||||
*.pem
|
||||
*.key
|
||||
secrets/
|
||||
.npmrc
|
||||
.pypirc
|
||||
kubeconfig
|
||||
+5
-107
@@ -1,119 +1,17 @@
|
||||
# Variables lues par docker-compose.yml à la racine.
|
||||
# Le backend lancé hors conteneur (`make dev`) lit apps/backend/.env, pas ce fichier.
|
||||
# Variables lues par docker-compose.yml a la racine.
|
||||
# Le backend lance hors conteneur (`make dev`) lit apps/backend/.env, pas ce fichier.
|
||||
|
||||
POSTGRES_USER=enervision
|
||||
POSTGRES_PASSWORD=change_me
|
||||
POSTGRES_DB=enervision
|
||||
# 5432 est souvent déjà pris par une autre base du poste.
|
||||
# 5432 est souvent deja pris par une autre base du poste.
|
||||
POSTGRES_PORT=5433
|
||||
# `basic` renvoie des statistiques d'usage à Timescale.
|
||||
# `basic` renvoie des statistiques d'usage a Timescale.
|
||||
TIMESCALEDB_TELEMETRY=off
|
||||
|
||||
APP_ENV=local
|
||||
APP_DEBUG=false
|
||||
APP_DEBUG=true
|
||||
APP_LOG_LEVEL=INFO
|
||||
# L'API refuse de démarrer tant que cette valeur reste un exemple ou fait moins de
|
||||
# 32 caractères. Générer la vôtre : python -c "import secrets; print(secrets.token_urlsafe(48))"
|
||||
APP_SECRET_KEY=change_me
|
||||
APP_CORS_ORIGINS=http://localhost:4200
|
||||
BACKEND_PORT=8000
|
||||
FRONTEND_PORT=3000
|
||||
|
||||
# Mailpit capture les courriels du backend, rien ne sort vers l'extérieur.
|
||||
MAILPIT_SMTP_PORT=1025
|
||||
MAILPIT_UI_PORT=8025
|
||||
|
||||
# API Mock EnerVision
|
||||
APP_MOCK_API_BASE_URL=https://api-mock.charlieandre.fr
|
||||
APP_MOCK_API_USERNAME=change_me
|
||||
APP_MOCK_API_PASSWORD=change_me
|
||||
APP_MOCK_API_TIMEOUT_SECONDS=10
|
||||
|
||||
# Airflow (api-server + scheduler + dag-processor, LocalExecutor). Base de métadonnées dédiée `airflow` dans le
|
||||
# même conteneur `db` (cf. db/init/120-airflow-database.sql), pas un conteneur de plus.
|
||||
AIRFLOW_PORT=8080
|
||||
# Chiffre les connexions/variables stockées par Airflow. Générer la vôtre :
|
||||
# python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
|
||||
AIRFLOW_FERNET_KEY=change_me
|
||||
# Clé de session de l'api-server Airflow, distincte de la précédente. Générer la
|
||||
# vôtre : python -c "import secrets; print(secrets.token_urlsafe(48))"
|
||||
AIRFLOW_API_SECRET_KEY=change_me
|
||||
# Secret des jetons JWT entre scheduler, tâches et api-server (conteneurs distincts, le secret
|
||||
# doit être partagé). Même générateur que ci-dessus.
|
||||
AIRFLOW_JWT_SECRET=change_me
|
||||
AIRFLOW_ADMIN_USERNAME=admin
|
||||
# Compte Airflow créé au premier démarrage (service `airflow-init`), sans rapport avec les
|
||||
# comptes `app_user` d'EnerVision.
|
||||
AIRFLOW_ADMIN_PASSWORD=change_me
|
||||
AIRFLOW_ADMIN_EMAIL=admin@enervision.fr
|
||||
# `APP_SECRET_KEY` du backend, que le DAG `alertes` lance en sous-processus. Distincte de
|
||||
# celle de l'API : la détection ne signe aucun jeton, et Airflow exécute du code depuis son
|
||||
# interface (cf. ADR 0008). Générer la vôtre :
|
||||
# python -c "import secrets; print(secrets.token_urlsafe(48))"
|
||||
AIRFLOW_APP_SECRET_KEY=change_me
|
||||
|
||||
# Garage, stockage objet S3 par environnement (ADR 0019) : un conteneur par projet Compose, publié
|
||||
# sur 127.0.0.1 seulement. Les six secrets ci-dessous sont exigés par `make services-up` et
|
||||
# `make stack-up` ; scripts/provision-host.sh les génère sur la VM.
|
||||
# 32 octets en hexadécimal, rien d'autre n'est accepté : openssl rand -hex 32
|
||||
GARAGE_RPC_SECRET=change_me
|
||||
# Jetons de l'API d'administration et de /metrics (port 3903). Même générateur qu'APP_SECRET_KEY.
|
||||
GARAGE_ADMIN_TOKEN=change_me
|
||||
GARAGE_METRICS_TOKEN=change_me
|
||||
# Clé S3 créée au premier démarrage (`--default-bucket`). Identifiant : echo "GK$(openssl rand -hex 12)"
|
||||
# Secret : openssl rand -hex 32. Ne plus le changer ensuite, Garage refuserait de démarrer.
|
||||
GARAGE_ACCESS_KEY=change_me
|
||||
GARAGE_SECRET_KEY=change_me
|
||||
GARAGE_BUCKET=enervision-archives
|
||||
# Ports S3 et admin sur 127.0.0.1. Recette : 3910 et 3913, dev : 3920 et 3923.
|
||||
GARAGE_S3_PORT=3900
|
||||
GARAGE_ADMIN_PORT=3903
|
||||
|
||||
# Rétention des mesures (ADR 0019, 0020) : le DAG `retention` exporte chaque nuit vers Garage les
|
||||
# chunks de `reading` plus vieux que cette borne, puis les supprime. L'historique de démonstration
|
||||
# s'arrête fin 2024 : sous 21 mois, la démo disparaîtrait.
|
||||
READING_RETENTION_DAYS=1095
|
||||
# Clé SSE-C des archives, 32 octets en base64 : openssl rand -base64 32. La perdre rend les
|
||||
# archives illisibles ; la sauvegarder hors de la VM.
|
||||
GARAGE_SSE_KEY=change_me
|
||||
|
||||
# Stack complète derrière le reverse proxy (docker-compose.prod.yml).
|
||||
# PUBLIC_HOST alimente l'origine CORS, le lien de réinitialisation et le certificat.
|
||||
PUBLIC_HOST=enervision.local
|
||||
ACME_EMAIL=
|
||||
|
||||
# Trois environnements sur la même machine (ADR 0009, 0017) : un dossier, un `.env` et un projet
|
||||
# Compose chacun. Le nom de projet préfixe volumes, réseau et conteneurs et l'emporte sur `name:`.
|
||||
# Vide sur un poste de développement : le projet reste `enervision`.
|
||||
COMPOSE_PROJECT_NAME=
|
||||
# Origine publique, avec le port si le proxy HTTPS n'écoute pas 443. Vide : https://PUBLIC_HOST.
|
||||
# Sur la VM, provision-host.sh pose https://<nom de l'environnement>, sans port (frontal SNI).
|
||||
PUBLIC_ORIGIN=
|
||||
# Ports publiés par le proxy. Vides : 80 et 443. Sur la VM, provision-host.sh les pose sur 127.0.0.1,
|
||||
# derrière le frontal SNI, et décale aussi base, Mailpit et Airflow par environnement.
|
||||
PROXY_HTTP_PORT=
|
||||
PROXY_HTTPS_PORT=
|
||||
# Écouteur PROXY protocol du proxy, que seul le frontal de la VM joint (infra/front, ADR 0018).
|
||||
# Vide : port aléatoire sur 127.0.0.1. VM : 127.0.0.1:10444 en prod, 8444 en recette, 9444 en dev.
|
||||
PROXY_FRONT_PORT=
|
||||
# Réglages mémoire de la stack déployée. Sans eux, timescaledb-tune réserve 25 % de la RAM de la
|
||||
# machine à chaque base au premier démarrage. L'api-server Airflow 3 n'a rien à régler ici : son
|
||||
# nombre de workers vaut 1 par défaut, contre 4 pour le webserver d'Airflow 2.
|
||||
TS_TUNE_MEMORY=2GB
|
||||
TS_TUNE_NUM_CPUS=2
|
||||
|
||||
# Supervision (ADR 0016) : `monitoring` la démarre avec `make stack-up`, réglage de la prod.
|
||||
# Vide ailleurs, où `make monitoring-up` la lance à la demande.
|
||||
COMPOSE_PROFILES=
|
||||
# Jeton présenté par Prometheus sur `/metrics`, exigé par l'API dès qu'il est posé. Requis dès
|
||||
# que la supervision tourne ; même générateur que APP_SECRET_KEY.
|
||||
APP_METRICS_TOKEN=change_me
|
||||
# Compte `admin` de Grafana. Sans lui, le conteneur refuse de démarrer.
|
||||
GRAFANA_ADMIN_PASSWORD=change_me
|
||||
# Rôle PostgreSQL `supervision`, en lecture seule, de Grafana et de postgres-exporter
|
||||
# (db/roles/supervision.sql, posé par `make db-ensure-supervision`).
|
||||
SUPERVISION_DB_PASSWORD=change_me
|
||||
# Interfaces publiées sur 127.0.0.1 seulement, par tunnel SSH. 3000 est pris par le frontend.
|
||||
GRAFANA_PORT=3001
|
||||
PROMETHEUS_PORT=9090
|
||||
ALERTMANAGER_PORT=9093
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
self-hosted-runner:
|
||||
labels:
|
||||
- eni-g3
|
||||
@@ -1,66 +0,0 @@
|
||||
version: 2
|
||||
updates:
|
||||
# Frontend — npm
|
||||
- package-ecosystem: "npm"
|
||||
directory: "/apps/frontend"
|
||||
schedule:
|
||||
interval: "weekly"
|
||||
open-pull-requests-limit: 5
|
||||
groups:
|
||||
frontend-dependencies:
|
||||
patterns:
|
||||
- "*"
|
||||
ignore:
|
||||
# Pourquoi : @angular/build épingle typescript (>=6.0 <6.1) et vitest (^4). Une majeure
|
||||
# de l'un ou l'autre casse `npm ci` tant qu'Angular ne suit pas.
|
||||
- dependency-name: "typescript"
|
||||
update-types: ["version-update:semver-major"]
|
||||
- dependency-name: "vitest"
|
||||
update-types: ["version-update:semver-major"]
|
||||
- dependency-name: "@vitest/coverage-v8"
|
||||
update-types: ["version-update:semver-major"]
|
||||
|
||||
# Tests de bout en bout, paquet npm distinct du frontend
|
||||
- package-ecosystem: "npm"
|
||||
directory: "/tests/e2e"
|
||||
schedule:
|
||||
interval: "weekly"
|
||||
open-pull-requests-limit: 2
|
||||
groups:
|
||||
e2e-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"
|
||||
|
||||
# Images du reverse proxy et du compagnon ACME, épinglées dans les fichiers Compose
|
||||
- package-ecosystem: "docker-compose"
|
||||
directory: "/"
|
||||
schedule:
|
||||
interval: "weekly"
|
||||
@@ -1,85 +0,0 @@
|
||||
name: Airflow
|
||||
|
||||
# Piège : la version de Python vient de etl/airflow/.python-version. C'est 3.12 et non 3.14
|
||||
# (contrairement à backend.yml et ml.yml) : celui de l'image apache/airflow retenue, et les tests
|
||||
# doivent tourner sur le même interpréteur qu'elle. Le 3.14 de ml/ ne vit que dans l'image
|
||||
# Docker, dans son propre environnement (cf. etl/airflow/Dockerfile).
|
||||
#
|
||||
# Piège : l'image COPY les fichiers de dépendances et le code de ml/ et de apps/backend/. Une
|
||||
# modification de l'un ou de l'autre peut donc casser sa construction : le filtre `airflow` de
|
||||
# ci.yml, qui appelle ce workflow, inclut ces chemins alors qu'il ne teste ni le modèle ni l'API.
|
||||
|
||||
on:
|
||||
workflow_call:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
verification:
|
||||
name: Lint et intégrité des DAGs
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
defaults:
|
||||
run:
|
||||
working-directory: etl/airflow
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
# Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: true
|
||||
cache-dependency-glob: etl/airflow/uv.lock
|
||||
prune-cache: false
|
||||
|
||||
- name: Installe l'interpréteur déclaré par .python-version
|
||||
run: uv python install
|
||||
|
||||
- name: Synchronise les dépendances sur le verrou
|
||||
run: uv sync --all-groups --locked
|
||||
|
||||
- name: Vérifie le formatage
|
||||
run: uv run ruff format --check .
|
||||
|
||||
- name: Analyse statique
|
||||
run: uv run ruff check --output-format=github .
|
||||
|
||||
# Aucun test ne lance de tâche ni de scheduler : DagBag charge les fichiers de dags/ et
|
||||
# vérifie import, planification, plafonds d'exécution et commande de chaque tâche.
|
||||
- name: Tests d'intégrité des DAGs
|
||||
run: uv run pytest
|
||||
|
||||
image:
|
||||
name: Construction de l'image
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 25
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
- name: Construit l'image (contexte à la racine, elle COPY ml/ et apps/backend/)
|
||||
run: docker build -f etl/airflow/Dockerfile -t enervision-airflow:ci .
|
||||
|
||||
# Vérifie ce qui ne casse qu'à l'exécution, pas à la construction : libgomp1 absent
|
||||
# (`OSError: libgomp.so.1` au premier import) ou environnement ml/ non figé.
|
||||
- name: Vérifie que le pipeline ML s'importe sans réseau
|
||||
run: >
|
||||
docker run --rm --network none enervision-airflow:ci
|
||||
bash -c "cd /opt/ml && env -u VIRTUAL_ENV uv run --no-sync python -m enervision_ml.train --help"
|
||||
|
||||
# `--help` sort par argparse avant `get_settings()` : ni base ni secret requis, et
|
||||
# l'import des modules prouve que l'environnement /opt/backend est complet.
|
||||
- name: Vérifie que les cinq commandes backend s'importent sans réseau
|
||||
run: >
|
||||
docker run --rm --network none enervision-airflow:ci
|
||||
bash -c "cd /opt/backend
|
||||
&& env -u VIRTUAL_ENV uv run --no-sync python -m app.detection.internal_alerts --help
|
||||
&& env -u VIRTUAL_ENV uv run --no-sync python -m app.cli generate-recommendations --help
|
||||
&& env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.historical_import --help
|
||||
&& env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.mock_api_import --help
|
||||
&& env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.reading_retention --help"
|
||||
@@ -1,176 +0,0 @@
|
||||
name: Backend
|
||||
|
||||
# Piège : la version de Python vient de apps/backend/.python-version, et elle doit rester
|
||||
# en 3.14. Le code utilise le PEP 758, qu'un interpréteur 3.13 refuse de compiler.
|
||||
# Pourquoi : aucun déclencheur propre. ci.yml appelle ce workflow quand le backend change, et
|
||||
# Sonar y reprend la couverture versée par le job `verification` (ADR 0014).
|
||||
|
||||
on:
|
||||
workflow_call:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
verification:
|
||||
name: Lint, typage et tests
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
defaults:
|
||||
run:
|
||||
working-directory: apps/backend
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
# Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: true
|
||||
cache-dependency-glob: apps/backend/uv.lock
|
||||
prune-cache: false
|
||||
|
||||
- name: Installe l'interpréteur déclaré par .python-version
|
||||
run: uv python install
|
||||
|
||||
# `--locked` et non `--frozen` : un verrou qui ne suit plus pyproject.toml doit casser ici.
|
||||
- name: Synchronise les dépendances sur le verrou
|
||||
run: uv sync --all-groups --locked
|
||||
|
||||
- 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 app
|
||||
|
||||
# Le marqueur `integration` est exclu par défaut, donc aucune base n'est nécessaire ici.
|
||||
- name: Tests et couverture
|
||||
run: uv run pytest --cov-fail-under=85 --cov-report=xml
|
||||
|
||||
- name: Verse la couverture pour Sonar
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: backend-coverage
|
||||
path: apps/backend/coverage.xml
|
||||
if-no-files-found: error
|
||||
|
||||
# Piège : même image que docker-compose.yml, pas un `postgres` nu. La première migration refuse
|
||||
# de s'appliquer sans TimescaleDB, et une autre image testerait une base qui n'est pas la nôtre.
|
||||
integration:
|
||||
name: Tests exigeant une base
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
defaults:
|
||||
run:
|
||||
working-directory: apps/backend
|
||||
|
||||
services:
|
||||
db:
|
||||
image: timescale/timescaledb-ha:pg17
|
||||
env:
|
||||
POSTGRES_USER: enervision
|
||||
POSTGRES_PASSWORD: change_me
|
||||
POSTGRES_DB: enervision_test
|
||||
ports:
|
||||
- "5433:5432"
|
||||
options: >-
|
||||
--health-cmd "pg_isready -U enervision -d enervision_test"
|
||||
--health-interval 10s
|
||||
--health-timeout 5s
|
||||
--health-retries 12
|
||||
--health-start-period 40s
|
||||
|
||||
env:
|
||||
DATABASE_URL: postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_test
|
||||
APP_SECRET_KEY: secret-de-test-assez-long-pour-le-validateur
|
||||
PGPASSWORD: change_me
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: true
|
||||
cache-dependency-glob: apps/backend/uv.lock
|
||||
prune-cache: false
|
||||
|
||||
- name: Installe l'interpréteur déclaré par .python-version
|
||||
run: uv python install
|
||||
|
||||
- name: Synchronise les dépendances sur le verrou
|
||||
run: uv sync --all-groups --locked
|
||||
|
||||
# Sur le poste, c'est db/init/110-test-database.sql qui pose l'extension. Ce fichier n'est
|
||||
# pas monté ici, et sans lui `alembic upgrade head` s'arrête sur la garde de la révision 1.
|
||||
- name: Active TimescaleDB sur la base de test
|
||||
run: psql -h localhost -p 5433 -U enervision -d enervision_test -c "CREATE EXTENSION IF NOT EXISTS timescaledb"
|
||||
|
||||
- name: Applique les migrations
|
||||
run: uv run alembic upgrade head
|
||||
|
||||
# Couverture désactivée : ce job ne joue qu'une partie de la suite, son taux n'aurait
|
||||
# aucun sens face au seuil de 85 %.
|
||||
- name: Tests d'intégration
|
||||
run: uv run pytest -m integration --no-cov
|
||||
|
||||
security-audit:
|
||||
name: Audit des dépendances
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 10
|
||||
defaults:
|
||||
run:
|
||||
working-directory: apps/backend
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: true
|
||||
cache-dependency-glob: apps/backend/uv.lock
|
||||
prune-cache: false
|
||||
|
||||
# L'audit porte sur le verrou, pas sur l'environnement : sinon pip-audit auditerait
|
||||
# aussi les paquets que son propre `--with` injecte, hors dépendances du projet.
|
||||
- name: Audite les dépendances livrées
|
||||
# Piège : sans `shell: bash`, un échec de `uv export` serait masqué par le pipe.
|
||||
shell: bash
|
||||
run: uv export --locked --no-dev --no-emit-project --no-hashes | uvx pip-audit --requirement /dev/stdin --no-deps
|
||||
|
||||
sast:
|
||||
name: Analyse statique de sécurité
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 10
|
||||
defaults:
|
||||
run:
|
||||
working-directory: apps/backend
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
# Pourquoi : pas de cache ici. uvx n'installe pas le projet, le verrou n'alimente donc
|
||||
# aucune clé de cache ; la seule roue téléchargée est celle de Bandit.
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: false
|
||||
|
||||
# Pourquoi : le périmètre est `app`, le code livré. Les tests emploient légitimement des
|
||||
# secrets factices et des `assert` que Bandit signalerait sans qu'aucun n'atteigne la prod.
|
||||
- name: Analyse le code livré (bloquant à partir de MEDIUM)
|
||||
run: uvx bandit==1.9.4 --recursive app --severity-level medium --confidence-level medium
|
||||
|
||||
# Piège : sans cette seconde passe, un constat LOW disparaîtrait du journal sans trace.
|
||||
- name: Rapport complet, tous niveaux
|
||||
continue-on-error: true
|
||||
run: uvx bandit==1.9.4 --recursive app
|
||||
@@ -1,227 +0,0 @@
|
||||
# Pourquoi : un seul point d'entrée pour toute la CI (ADR 0014) - workflow CI. Chaque composant
|
||||
# ne tourne que si ses fichiers changent, Sonar reprend les couvertures déjà produites au lieu de
|
||||
# tout rejouer, et le déploiement ne part que d'un commit dont la CI est verte.
|
||||
# Piège : le seul check à exiger dans les règles de branche est « CI ok ». Un job sauté par son
|
||||
# filtre ne publie pas les checks de son workflow, qui resteraient en attente s'ils étaient exigés.
|
||||
# Piège : sur un push vers dev ou main, tous les filtres valent vrai. paths-filter comparerait
|
||||
# sinon à la base de fusion avec main, et Sonar n'analyserait qu'une partie de la branche.
|
||||
# Piège : pas d'annulation des runs de push. Un run coupé en plein `make stack-up` laisserait la
|
||||
# stack à moitié redémarrée ; le groupe par SHA évite aussi de mettre `dev` en file derrière lui.
|
||||
|
||||
name: CI
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches: [dev, main]
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
concurrency:
|
||||
group: ci-${{ github.event_name == 'pull_request' && github.ref || github.sha }}
|
||||
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
|
||||
|
||||
jobs:
|
||||
changes:
|
||||
name: Périmètre modifié
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
permissions:
|
||||
contents: read
|
||||
pull-requests: read
|
||||
outputs:
|
||||
backend: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.backend == 'true' }}
|
||||
frontend: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.frontend == 'true' }}
|
||||
ml: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.ml == 'true' }}
|
||||
airflow: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.airflow == 'true' }}
|
||||
terraform: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.terraform == 'true' }}
|
||||
compose: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.compose == 'true' }}
|
||||
workflows: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.workflows == 'true' }}
|
||||
e2e: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.e2e == 'true' }}
|
||||
sonar: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.sonar == 'true' }}
|
||||
|
||||
steps:
|
||||
# Sur une PR, la liste des fichiers vient de l'API : ni checkout ni historique requis.
|
||||
- name: Calcule le périmètre de la PR
|
||||
id: filtre
|
||||
if: github.event_name == 'pull_request'
|
||||
uses: dorny/paths-filter@ceb8a2b8f2d89434be7ff52d3de7ec3738c5cc9d # v4.0.3
|
||||
with:
|
||||
filters: |
|
||||
ci:
|
||||
- ".github/workflows/ci.yml"
|
||||
backend:
|
||||
- "apps/backend/**"
|
||||
- ".github/workflows/backend.yml"
|
||||
frontend:
|
||||
- "apps/frontend/**"
|
||||
- ".github/workflows/frontend.yml"
|
||||
ml:
|
||||
- "ml/**"
|
||||
- "apps/backend/alembic/**"
|
||||
- "apps/backend/app/models/**"
|
||||
- "apps/backend/tests/test_chaine_ml_api.py"
|
||||
- "apps/backend/pyproject.toml"
|
||||
- "apps/backend/uv.lock"
|
||||
- ".github/workflows/ml.yml"
|
||||
airflow:
|
||||
- "etl/airflow/**"
|
||||
- "ml/pyproject.toml"
|
||||
- "ml/uv.lock"
|
||||
- "ml/enervision_ml/**"
|
||||
- "apps/backend/pyproject.toml"
|
||||
- "apps/backend/uv.lock"
|
||||
- "apps/backend/app/**"
|
||||
- ".github/workflows/airflow.yml"
|
||||
terraform:
|
||||
- "infra/terraform/**"
|
||||
- ".github/workflows/infra.yml"
|
||||
compose:
|
||||
- "docker-compose*.yml"
|
||||
- ".env.example"
|
||||
- "infra/front/**"
|
||||
- "infra/garage/**"
|
||||
- "tests/garage/**"
|
||||
- "monitoring/**"
|
||||
- ".github/workflows/infra.yml"
|
||||
workflows:
|
||||
- ".github/**"
|
||||
e2e:
|
||||
- "apps/frontend/**"
|
||||
- "apps/backend/app/**"
|
||||
- "apps/backend/alembic/**"
|
||||
- "apps/backend/Dockerfile"
|
||||
- "apps/backend/pyproject.toml"
|
||||
- "apps/backend/uv.lock"
|
||||
- "infra/proxy/**"
|
||||
- "docker-compose*.yml"
|
||||
- "db/**"
|
||||
- "tests/**"
|
||||
- "scripts/comptes-test.sh"
|
||||
- "scripts/tls-selfsigned.sh"
|
||||
- "Makefile"
|
||||
- ".env.example"
|
||||
- ".github/workflows/e2e.yml"
|
||||
sonar:
|
||||
- "apps/backend/**"
|
||||
- "apps/frontend/**"
|
||||
- "ml/**"
|
||||
- "etl/airflow/**"
|
||||
- "sonar-project.properties"
|
||||
|
||||
backend:
|
||||
name: Backend
|
||||
needs: changes
|
||||
if: needs.changes.outputs.backend == 'true'
|
||||
uses: ./.github/workflows/backend.yml
|
||||
|
||||
frontend:
|
||||
name: Frontend
|
||||
needs: changes
|
||||
if: needs.changes.outputs.frontend == 'true'
|
||||
uses: ./.github/workflows/frontend.yml
|
||||
|
||||
ml:
|
||||
name: ML
|
||||
needs: changes
|
||||
if: needs.changes.outputs.ml == 'true'
|
||||
uses: ./.github/workflows/ml.yml
|
||||
|
||||
airflow:
|
||||
name: Airflow
|
||||
needs: changes
|
||||
if: needs.changes.outputs.airflow == 'true'
|
||||
uses: ./.github/workflows/airflow.yml
|
||||
|
||||
infra:
|
||||
name: Infra
|
||||
needs: changes
|
||||
if: >-
|
||||
needs.changes.outputs.terraform == 'true'
|
||||
|| needs.changes.outputs.compose == 'true'
|
||||
|| needs.changes.outputs.workflows == 'true'
|
||||
uses: ./.github/workflows/infra.yml
|
||||
with:
|
||||
terraform: ${{ needs.changes.outputs.terraform == 'true' }}
|
||||
compose: ${{ needs.changes.outputs.compose == 'true' }}
|
||||
workflows: ${{ needs.changes.outputs.workflows == 'true' }}
|
||||
|
||||
e2e:
|
||||
name: E2E
|
||||
needs: changes
|
||||
if: needs.changes.outputs.e2e == 'true'
|
||||
uses: ./.github/workflows/e2e.yml
|
||||
|
||||
# Ni dependabot[bot] ni une PR de fork ne reçoivent SONAR_TOKEN : le scan échouerait sans rien
|
||||
# analyser. Tests et couverture restent joués par leurs jobs.
|
||||
sonar:
|
||||
name: SonarQube
|
||||
needs: [changes, backend, frontend, ml]
|
||||
if: >-
|
||||
always() && !cancelled()
|
||||
&& !contains(needs.*.result, 'failure')
|
||||
&& needs.changes.outputs.sonar == 'true'
|
||||
&& github.actor != 'dependabot[bot]'
|
||||
&& (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository)
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
with:
|
||||
fetch-depth: 0
|
||||
|
||||
# Un téléchargement par rapport : backend et ML nomment tous deux le leur `coverage.xml`.
|
||||
- name: Couverture du backend
|
||||
if: needs.backend.result == 'success'
|
||||
uses: actions/download-artifact@v8
|
||||
with:
|
||||
name: backend-coverage
|
||||
path: apps/backend
|
||||
|
||||
- name: Couverture du pipeline ML
|
||||
if: needs.ml.result == 'success'
|
||||
uses: actions/download-artifact@v8
|
||||
with:
|
||||
name: ml-coverage
|
||||
path: ml
|
||||
|
||||
- name: Couverture du frontend
|
||||
if: needs.frontend.result == 'success'
|
||||
uses: actions/download-artifact@v8
|
||||
with:
|
||||
name: frontend-coverage
|
||||
path: apps/frontend/coverage/frontend
|
||||
|
||||
# Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
|
||||
- name: Analyse SonarQube
|
||||
uses: SonarSource/sonarqube-scan-action@ba9859eae8dd6bd29e412f25ddbbef3d032000f4 # v8.2.2
|
||||
env:
|
||||
SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
|
||||
|
||||
ci-ok:
|
||||
name: CI ok
|
||||
needs: [changes, backend, frontend, ml, airflow, infra, e2e, sonar]
|
||||
if: always()
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
|
||||
steps:
|
||||
- name: Refuse si un job a échoué ou a été annulé
|
||||
env:
|
||||
RESULTATS: ${{ toJSON(needs.*.result) }}
|
||||
run: |
|
||||
echo "$RESULTATS"
|
||||
if grep -qE '"(failure|cancelled)"' <<<"$RESULTATS"; then
|
||||
echo "::error::Au moins un job de la CI a échoué ou a été annulé."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
deploy:
|
||||
name: Déploiement
|
||||
needs: ci-ok
|
||||
if: ${{ !cancelled() && needs.ci-ok.result == 'success' && github.event_name == 'push' }}
|
||||
uses: ./.github/workflows/deploy.yml
|
||||
@@ -1,316 +0,0 @@
|
||||
name: DAST
|
||||
|
||||
# Scan dynamique OWASP ZAP de l'API (issue #41). Il attaque une API qui tourne : le job démarre
|
||||
# la base et le backend sur le runner, sème le jeu de démonstration (sans ça le scan ne frappe que
|
||||
# des gestionnaires d'erreur), crée des comptes jetables (scripts/dast-token.sh), puis lance ZAP
|
||||
# sur le contrat OpenAPI avec le jeton du `lecteur`.
|
||||
#
|
||||
# Non bloquant pour l'instant sur les alertes (`continue-on-error` sur la seule étape du scan) :
|
||||
# le volume d'un premier passage trié est inconnu. Deux étapes suivantes, elles, bloquent si le
|
||||
# scan n'a rien testé (import du contrat, absence de toute réponse de succès) : un job vert doit
|
||||
# vouloir dire qu'un scan a eu lieu.
|
||||
#
|
||||
# Piège : ce scan tape la configuration par défaut du backend (`APP_ENV=local`, pas de TLS, pas
|
||||
# de reverse proxy). Il ne dit rien des en-têtes ni du TLS posés par le proxy en production, et
|
||||
# remontera des alertes (HSTS absent...) qui n'existent pas derrière lui.
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
schedule:
|
||||
# Un scan actif est long : hebdomadaire plutôt qu'à chaque PR.
|
||||
- cron: "0 3 * * 1"
|
||||
pull_request:
|
||||
# Ne se lance sur une PR que si le scan lui-même change.
|
||||
paths:
|
||||
- ".github/workflows/dast.yml"
|
||||
- "scripts/dast-token.sh"
|
||||
- "scripts/comptes-test.sh"
|
||||
- "db/seeds/**"
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
concurrency:
|
||||
group: dast-${{ github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
jobs:
|
||||
zap:
|
||||
name: Scan OWASP ZAP de l'API
|
||||
runs-on: ubuntu-latest
|
||||
# Généreux face aux ~2 minutes observées de bout en bout : le vrai plafond est
|
||||
# `scanner.maxScanDurationInMins` (étape Scan ZAP), sous le TTL du jeton. Une annulation par
|
||||
# ce timeout-ci n'exécute pas les étapes `always()` : mieux vaut ne jamais l'atteindre.
|
||||
timeout-minutes: 30
|
||||
|
||||
# Même image que docker-compose.yml : la première migration refuse de s'appliquer sans
|
||||
# l'extension TimescaleDB (cf. backend.yml).
|
||||
services:
|
||||
db:
|
||||
image: timescale/timescaledb-ha:pg17
|
||||
env:
|
||||
POSTGRES_USER: enervision
|
||||
POSTGRES_PASSWORD: change_me
|
||||
POSTGRES_DB: enervision_dast
|
||||
ports:
|
||||
- "5433:5432"
|
||||
options: >-
|
||||
--health-cmd "pg_isready -U enervision -d enervision_dast"
|
||||
--health-interval 10s
|
||||
--health-timeout 5s
|
||||
--health-retries 12
|
||||
--health-start-period 40s
|
||||
|
||||
env:
|
||||
# Base jetable : ZAP y écrira et le script y crée deux comptes.
|
||||
DATABASE_URL: postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_dast
|
||||
APP_SECRET_KEY: secret-de-scan-assez-long-pour-le-validateur
|
||||
APP_ENV: local
|
||||
# Le jeton du lecteur doit survivre à toute la durée du scan (15 minutes par défaut).
|
||||
# 3600 est le plafond accepté par la configuration ; `scanner.maxScanDurationInMins`
|
||||
# (étape Scan ZAP) reste très en dessous, marge comprise pour les étapes qui l'entourent.
|
||||
APP_ACCESS_TOKEN_TTL_SECONDS: "3600"
|
||||
PGPASSWORD: change_me
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
- name: Installe uv
|
||||
# Épinglé sur le commit du tag v7 (règle Sonar githubactions:S7637 : dépendance tierce,
|
||||
# contrairement à actions/checkout ou actions/upload-artifact, premières parties).
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: true
|
||||
cache-dependency-glob: apps/backend/uv.lock
|
||||
# `prune-cache` vaut `true` par défaut (encore sur ce commit) : l'étape de post-job
|
||||
# « Pruning cache » est restée bloquée 5 minutes avant d'échouer (exit code 2) sur un
|
||||
# run où les 16 étapes précédentes passaient, sans lien avec le scan. Le prune n'est
|
||||
# qu'une optimisation de taille de cache entre deux runs, pas une garantie : le
|
||||
# désactiver retire le blocage sans rien changer au comportement du job.
|
||||
prune-cache: false
|
||||
|
||||
- name: Installe l'interpréteur déclaré par .python-version
|
||||
run: uv python install
|
||||
working-directory: apps/backend
|
||||
|
||||
# `--no-build` : aucune dépendance n'est construite depuis ses sources, donc aucun script de
|
||||
# build exécuté (règle Sonar S8541). Le projet lui-même n'est pas installé : il tourne depuis
|
||||
# `apps/backend`, comme dans son Dockerfile. Les `uv run` suivants portent `--frozen
|
||||
# --no-sync` pour ne rien résoudre ni reconstruire (règle S8544).
|
||||
- name: Synchronise les dépendances sans dévier du verrou
|
||||
run: uv sync --locked --no-dev --no-install-project --no-build
|
||||
working-directory: apps/backend
|
||||
|
||||
- name: Active TimescaleDB sur la base du scan
|
||||
run: psql -h localhost -p 5433 -U enervision -d enervision_dast -c "CREATE EXTENSION IF NOT EXISTS timescaledb"
|
||||
|
||||
- name: Applique les migrations
|
||||
run: uv run --frozen --no-sync --no-build alembic upgrade head
|
||||
working-directory: apps/backend
|
||||
|
||||
# Sans données, `GET /sites` rend `[]`, chaque `/{site_id}` rend 404 et le scan actif ne
|
||||
# frappe que des gestionnaires d'erreur plutôt que la logique métier.
|
||||
- name: Sème le jeu de démonstration
|
||||
run: psql -h localhost -p 5433 -U enervision -d enervision_dast -v ON_ERROR_STOP=1 -f db/seeds/demo.sql
|
||||
|
||||
- name: Démarre l'API
|
||||
run: |
|
||||
nohup uv run --frozen --no-sync --no-build uvicorn app.main:create_app --factory \
|
||||
--host 0.0.0.0 --port 8000 > "$RUNNER_TEMP/api.log" 2>&1 &
|
||||
for _ in $(seq 1 30); do
|
||||
curl -fsS http://localhost:8000/api/v1/health/ready >/dev/null 2>&1 && exit 0
|
||||
sleep 2
|
||||
done
|
||||
echo "L'API ne répond pas sur /health/ready" >&2
|
||||
cat "$RUNNER_TEMP/api.log" >&2
|
||||
exit 1
|
||||
working-directory: apps/backend
|
||||
|
||||
- name: Crée le compte lecteur du scan
|
||||
id: jeton
|
||||
run: |
|
||||
jeton="$(../../scripts/dast-token.sh)"
|
||||
echo "::add-mask::$jeton"
|
||||
echo "jeton=$jeton" >> "$GITHUB_OUTPUT"
|
||||
working-directory: apps/backend
|
||||
|
||||
# Étape distincte du scan lui-même, et sans `continue-on-error` : un `curl` qui échoue ici
|
||||
# (API tombée juste après la sonde de readiness, par exemple) doit rester un échec visible,
|
||||
# pas se travestir en « ZAP n'a importé aucune URL » à l'étape de garde suivante.
|
||||
- name: Prépare le contrat pour ZAP
|
||||
run: |
|
||||
mkdir -p zap-out zap-logs
|
||||
curl -fsS http://localhost:8000/openapi.json -o zap-out/openapi.json
|
||||
# Le dossier passe à l'uid 1000 (utilisateur du conteneur ZAP) : le runner n'y écrit
|
||||
# plus après ce chown, d'où `zap-logs/` (uid du runner) pour les journaux ci-dessous.
|
||||
# Pas de `chmod 777` (règle Sonar S2612).
|
||||
sudo chown -R 1000:1000 zap-out
|
||||
|
||||
# `--network host` : ZAP atteint l'API sur le localhost du runner.
|
||||
#
|
||||
# Piège vécu : la clé du nom d'en-tête est `matchstr`, pas `matchstring`. ZAP accepte
|
||||
# n'importe quelle clé `-config` sans erreur ; avec la mauvaise, il ajoutait à TOUTES les
|
||||
# requêtes un en-tête au nom vide (`: Bearer <jeton>`), qu'uvicorn refuse par un 400
|
||||
# (« Invalid HTTP request received »), y compris sur les routes publiques.
|
||||
#
|
||||
# Le jeton ne passe ni par `${{ }}` dans ce script (il finirait en clair dans le fichier de
|
||||
# commande que GitHub écrit sur le disque du runner pour toute la durée de l'étape), ni par
|
||||
# l'argv de `docker run` (visible par `ps aux` et par `docker inspect zap` tant que le
|
||||
# conteneur existe) : il est écrit dans un fichier de configuration ZAP séparé, monté en
|
||||
# lecture seule hors de `/zap/wrk` pour ne jamais atterrir dans l'artefact publié.
|
||||
#
|
||||
# Les routes d'authentification qui changent l'état du compte du scan sont exclues : un
|
||||
# scan actif y déclencherait la limitation de débit du login, la réinitialisation de mots de
|
||||
# passe et la fermeture des sessions, sans rien apprendre de plus.
|
||||
#
|
||||
# `scanner.maxScanDurationInMins`/`maxRuleDurationInMins` bornent le scan actif, que `-T` ne
|
||||
# couvre pas (il ne borne que le démarrage et le scan passif) : sans ça, une règle qui
|
||||
# traîne peut dépasser le TTL du jeton (401 muets en fin de scan) ou le timeout du job (qui
|
||||
# annule sans exécuter les étapes `always()`, rapport et journaux perdus).
|
||||
- name: Scan ZAP
|
||||
id: zap
|
||||
continue-on-error: true
|
||||
env:
|
||||
JETON: ${{ steps.jeton.outputs.jeton }}
|
||||
run: |
|
||||
set -o pipefail
|
||||
printf 'replacer.full_list(0).description=auth\nreplacer.full_list(0).enabled=true\nreplacer.full_list(0).matchtype=REQ_HEADER\nreplacer.full_list(0).matchstr=Authorization\nreplacer.full_list(0).regex=false\nreplacer.full_list(0).replacement=Bearer %s\n' "$JETON" > "$RUNNER_TEMP/zap-auth.conf"
|
||||
# Piège vécu : `chmod 600` seul rend le fichier illisible pour le conteneur, qui lit un
|
||||
# montage bind avec son propre uid (1000), distinct de celui du runner qui l'a écrit.
|
||||
# ZAP échoue alors dès le lancement (« File not readable: /zap/auth.conf »), et
|
||||
# `zap-api-scan.py` attend `-T` minutes complètes avant d'abandonner : dix minutes qui
|
||||
# ressemblent à un scan actif, pour un daemon mort depuis le début.
|
||||
#
|
||||
# Piège vécu (numéro deux) : une fois le fichier passé à l'uid 1000 par `sudo chown`,
|
||||
# l'utilisateur du runner n'en est plus propriétaire et un `chmod` sans `sudo` échoue
|
||||
# (« Operation not permitted »). Avec le `-e` implicite de bash sur les étapes GitHub
|
||||
# Actions, cette erreur arrêtait toute l'étape avant même `docker run` : scan « réussi »
|
||||
# en une fraction de seconde, sans le moindre journal ni rapport produit.
|
||||
sudo chown 1000:1000 "$RUNNER_TEMP/zap-auth.conf"
|
||||
sudo chmod 644 "$RUNNER_TEMP/zap-auth.conf"
|
||||
docker run --name zap --network host \
|
||||
-v "$PWD/zap-out:/zap/wrk:rw" \
|
||||
-v "$RUNNER_TEMP/zap-auth.conf:/zap/auth.conf:ro" \
|
||||
ghcr.io/zaproxy/zaproxy:stable zap-api-scan.py \
|
||||
-t /zap/wrk/openapi.json -f openapi -O http://localhost:8000 \
|
||||
-T 10 \
|
||||
-r zap-report.html -J zap-report.json -w zap-report.md \
|
||||
-z "-configfile /zap/auth.conf \
|
||||
-config globalexcludeurl.url_list.url(0).description=auth-etat \
|
||||
-config globalexcludeurl.url_list.url(0).enabled=true \
|
||||
-config globalexcludeurl.url_list.url(0).regex='.*/api/v1/auth/(login|password|logout-all|forgot-password|reset-password).*' \
|
||||
-config scanner.maxScanDurationInMins=15 \
|
||||
-config scanner.maxRuleDurationInMins=5" \
|
||||
2>&1 | tee "$RUNNER_TEMP/zap-stdout.log"
|
||||
|
||||
- name: Récupère les journaux de ZAP
|
||||
if: always()
|
||||
run: |
|
||||
mkdir -p zap-logs
|
||||
# ZAP journalise la valeur de chaque `-config`/`-configfile` chargé, y compris le jeton,
|
||||
# à un niveau visible sans `-d` : les copies publiées en artefact sont donc caviardées,
|
||||
# même si `::add-mask::` (posé à la création du jeton) protège déjà le journal du job.
|
||||
masque() { sed -E 's/(Bearer )[A-Za-z0-9._-]+/\1[MASQUE]/Ig'; }
|
||||
[ -f "$RUNNER_TEMP/zap-stdout.log" ] && masque < "$RUNNER_TEMP/zap-stdout.log" > zap-logs/zap-stdout.log
|
||||
docker cp zap:/home/zap/.ZAP/zap.log "$RUNNER_TEMP/zap-internal.log" 2>/dev/null || true
|
||||
[ -f "$RUNNER_TEMP/zap-internal.log" ] && masque < "$RUNNER_TEMP/zap-internal.log" > zap-logs/zap.log
|
||||
[ -f "$RUNNER_TEMP/api.log" ] && masque < "$RUNNER_TEMP/api.log" > zap-logs/api.log
|
||||
rm -f "$RUNNER_TEMP/zap-auth.conf"
|
||||
docker rm -f zap >/dev/null 2>&1 || true
|
||||
|
||||
# `continue-on-error` sur le scan ne doit pas faire passer pour vert un scan qui n'a rien
|
||||
# testé. Constaté une première fois : 2 URL importées sur 26 opérations, ZAP n'avait envoyé
|
||||
# que des requêtes vouées au 404. Le seuil est dérivé du contrat plutôt que d'un nombre fixe
|
||||
# : un contrat qui grossit ne doit pas rendre la garde plus permissive qu'elle ne l'était.
|
||||
- name: Vérifie que le contrat a bien été importé
|
||||
run: |
|
||||
attendu="$(python3 -c "
|
||||
import json
|
||||
d = json.load(open('zap-out/openapi.json'))
|
||||
methodes = ('get', 'post', 'put', 'patch', 'delete', 'head', 'options')
|
||||
print(sum(1 for chemin in d['paths'].values() for m in chemin if m in methodes))
|
||||
")"
|
||||
minimum=$((attendu * 80 / 100))
|
||||
importees="$(sed -n 's/.*Number of Imported URLs: \([0-9]*\).*/\1/p' "$RUNNER_TEMP/zap-stdout.log" | tail -1)"
|
||||
echo "URL importées depuis le contrat OpenAPI : ${importees:-aucune} (contrat : $attendu opérations, minimum accepté : $minimum)"
|
||||
if [ "${importees:-0}" -lt "$minimum" ]; then
|
||||
echo "::error::ZAP n'a importé que ${importees:-0} URL sur $attendu opérations du contrat OpenAPI (minimum attendu : $minimum, soit 80%). Le scan n'a pas testé l'API, voir zap-logs/zap.log dans l'artefact zap-report."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Deuxième garde-fou : le contrat peut être importé et ZAP n'obtenir que des erreurs
|
||||
# (constaté : base sans données, toutes les routes de site répondaient 404).
|
||||
#
|
||||
# Piège de conception, trouvé en répétant ce job en local avant de l'écrire ici : borner le
|
||||
# pourcentage de 4xx ne marche pas. Un scan actif fuzze délibérément un grand nombre
|
||||
# d'entrées invalides (identifiants inventés, méthodes non supportées...), donc même un scan
|
||||
# sain, contre l'API seedée juste au-dessus, reste à 98% de 4xx avec seulement 1% de 2xx :
|
||||
# c'est la forme normale d'un scan actif, pas un signe d'échec. Le signal qui distingue
|
||||
# vraiment un scan cassé (0% de 2xx, `insight.code.2xx` absent du rapport dans le premier
|
||||
# incident) d'un scan sain (2xx non nul, aussi faible soit-il) est donc l'absence de succès,
|
||||
# pas la part d'échecs. Dérivé de `zap-report.json` (champ structuré `insights[]`) plutôt
|
||||
# que du texte libre du rapport Markdown, qui aurait le même défaut de conception en plus
|
||||
# d'être fragile au format.
|
||||
- name: Vérifie que le scan a obtenu au moins une réponse de succès
|
||||
run: |
|
||||
python3 - <<'PY'
|
||||
import json
|
||||
import sys
|
||||
|
||||
try:
|
||||
rapport = json.load(open("zap-out/zap-report.json"))
|
||||
except FileNotFoundError:
|
||||
print("::error::Aucun rapport ZAP produit : le scan n'a rien testé.")
|
||||
sys.exit(1)
|
||||
|
||||
pourcentage_2xx = 0.0
|
||||
for insight in rapport.get("insights", []):
|
||||
if insight.get("key") == "insight.code.2xx":
|
||||
pourcentage_2xx = float(insight.get("statistic", 0))
|
||||
break
|
||||
|
||||
print(f"Pourcentage de réponses 2xx : {pourcentage_2xx}%")
|
||||
if pourcentage_2xx <= 0:
|
||||
print(
|
||||
"::error::Aucune réponse 2xx (succès) reçue : le scan n'a atteint aucune route "
|
||||
"réelle de l'API. Voir zap-logs/api.log et zap-logs/zap.log dans l'artefact "
|
||||
"zap-report."
|
||||
)
|
||||
sys.exit(1)
|
||||
PY
|
||||
|
||||
# Uniquement la synthèse (jusqu'à « Alert Detail » exclu) : `$GITHUB_STEP_SUMMARY` est
|
||||
# limité à 1 Mio, et cette étape tourne sous `always()` - son échec ferait échouer le job
|
||||
# après le passage des deux garde-fous, pour une simple raison de mise en forme. Le rapport
|
||||
# complet reste dans l'artefact `zap-report`.
|
||||
- name: Publie le résumé
|
||||
if: always()
|
||||
run: |
|
||||
if [ -f zap-out/zap-report.md ]; then
|
||||
{
|
||||
awk '/^## Alert Detail/{exit} {print}' zap-out/zap-report.md
|
||||
echo ""
|
||||
echo "Rapport complet (HTML/JSON/Markdown) dans l'artefact \`zap-report\`."
|
||||
} >> "$GITHUB_STEP_SUMMARY"
|
||||
else
|
||||
echo "Aucun rapport ZAP produit, voir le journal du job." >> "$GITHUB_STEP_SUMMARY"
|
||||
fi
|
||||
|
||||
- name: Publie les rapports
|
||||
if: always()
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: zap-report
|
||||
path: |
|
||||
zap-out/
|
||||
zap-logs/
|
||||
if-no-files-found: warn
|
||||
|
||||
# Diagnostic de dernier recours : les journaux de l'API sont déjà dans l'artefact
|
||||
# (zap-logs/api.log) via l'étape « Récupère les journaux de ZAP » (always()), mais les
|
||||
# afficher directement dans le journal du job évite d'avoir à le télécharger pour un échec
|
||||
# évident (l'API n'a jamais démarré, par exemple).
|
||||
- name: Journal de l'API en cas d'échec
|
||||
if: failure() || steps.zap.outcome == 'failure'
|
||||
run: cat "$RUNNER_TEMP/api.log" || true
|
||||
@@ -1,75 +0,0 @@
|
||||
# Pourquoi : le runner tourne sur la VM ENI, adresse privée que les runners hébergés par GitHub
|
||||
# ne joignent pas, et travaille dans un dossier stable par environnement plutôt que dans son
|
||||
# espace de travail : `.env`, certificats et volumes y survivent d'un déploiement à l'autre.
|
||||
# Pourquoi : appelé par ci.yml une fois « CI ok » vert, jamais directement par un push, et il
|
||||
# déploie `GITHUB_SHA`, le commit testé, pas la pointe de branche du moment (ADR 0014).
|
||||
# Pourquoi : `main` va en prod, `dev` en recette, et toute autre branche lancée à la main
|
||||
# (workflow_dispatch) va dans `dev`, la vitrine d'une branche de travail (ADR 0017).
|
||||
# Piège : jamais de déclencheur `pull_request` ici. Sur un dépôt public, une PR de fork
|
||||
# exécuterait son code sur la machine de production (ADR 0009) - job deploy.
|
||||
# Piège : les CI de deux push finissent parfois dans le désordre. Un commit qui précède celui déjà
|
||||
# déployé depuis la même branche est ignoré, et le verrou est un `flock` sur le dossier de
|
||||
# l'environnement plutôt qu'un groupe `concurrency` : GitHub n'y garde qu'un job en attente, et
|
||||
# le suivant l'évince sans bruit.
|
||||
|
||||
name: Déploiement
|
||||
|
||||
on:
|
||||
workflow_call:
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
deploy:
|
||||
name: Déploie sur la VM
|
||||
runs-on: [self-hosted, linux, eni-g3]
|
||||
timeout-minutes: 30
|
||||
environment:
|
||||
name: ${{ github.ref_name == 'main' && 'prod' || github.ref_name == 'dev' && 'rec' || 'dev' }}
|
||||
url: ${{ github.ref_name == 'main' && 'https://prod.enervision-g3.dynv6.net' || github.ref_name == 'dev' && 'https://rec.enervision-g3.dynv6.net' || 'https://dev.enervision-g3.dynv6.net' }}
|
||||
env:
|
||||
ENVIRONNEMENT: ${{ github.ref_name == 'main' && 'prod' || github.ref_name == 'dev' && 'rec' || 'dev' }}
|
||||
PORT_HTTPS: ${{ github.ref_name == 'main' && '10443' || github.ref_name == 'dev' && '8443' || '9443' }}
|
||||
steps:
|
||||
# Un seul step : le verrou tombe avec le shell qui l'a posé.
|
||||
- name: Déploie le commit testé, sans jamais reculer
|
||||
run: |
|
||||
cd "/srv/enervision/${ENVIRONNEMENT}"
|
||||
exec 9>"$(git rev-parse --git-dir)/verrou-deploiement"
|
||||
flock 9
|
||||
|
||||
echo "::group::Aligne le dossier de l'environnement sur le commit testé"
|
||||
git fetch --quiet origin "${GITHUB_REF_NAME}"
|
||||
deploye="$(git rev-parse HEAD)"
|
||||
if [ "$(git branch --show-current)" = "$GITHUB_REF_NAME" ] && [ "$deploye" != "$GITHUB_SHA" ] \
|
||||
&& git merge-base --is-ancestor "$GITHUB_SHA" "$deploye"; then
|
||||
echo "::notice::${GITHUB_SHA:0:7} précède le commit déjà déployé (${deploye:0:7}) : rien à déployer."
|
||||
exit 0
|
||||
fi
|
||||
git checkout --quiet "${GITHUB_REF_NAME}"
|
||||
git reset --quiet --hard "${GITHUB_SHA}"
|
||||
git log -1 --format='%h %s'
|
||||
echo "::endgroup::"
|
||||
|
||||
echo "::group::Reconstruit et redémarre la stack"
|
||||
# Un `.env` pas encore réaligné par provision-host.sh porte encore un nom en `.local`.
|
||||
if [ -r ../dns.token ] && ! grep -q '^PUBLIC_HOST=.*\.local$' .env; then make tls-dns01; fi
|
||||
make stack-up
|
||||
if [ "${ENVIRONNEMENT}" = prod ]; then make front-up; fi
|
||||
echo "::endgroup::"
|
||||
|
||||
echo "::group::Attend que l'API réponde derrière le proxy"
|
||||
for _ in $(seq 1 36); do
|
||||
if curl --fail --silent --insecure "https://localhost:${PORT_HTTPS}/api/v1/health/ready"; then
|
||||
exit 0
|
||||
fi
|
||||
sleep 5
|
||||
done
|
||||
echo "::endgroup::"
|
||||
echo "L'API ne répond pas après 3 minutes" >&2
|
||||
compose="docker compose -f docker-compose.yml -f docker-compose.prod.yml"
|
||||
$compose ps
|
||||
$compose logs --tail=50 backend proxy
|
||||
exit 1
|
||||
@@ -1,135 +0,0 @@
|
||||
name: E2E
|
||||
|
||||
# Pourquoi : les parcours tournent contre la stack telle qu'elle est déployée, derrière le proxy
|
||||
# TLS (cookie `__Secure-`, CSP, limitation de débit), pas contre `ng serve` - job parcours. Il
|
||||
# construit aussi les images backend et frontend, que rien d'autre ne construit avant le
|
||||
# déploiement (ADR 0015).
|
||||
# Piège : pas d'Airflow ici. `up` nomme ses services : sans eux, la construction de l'image
|
||||
# Airflow doublerait la durée du job sans rien tester de plus.
|
||||
|
||||
on:
|
||||
workflow_call:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
parcours:
|
||||
name: Parcours Playwright et tirs k6
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 30
|
||||
env:
|
||||
COMPOSE_FILE: docker-compose.yml:docker-compose.prod.yml
|
||||
PUBLIC_HOST: localhost
|
||||
E2E_BASE_URL: https://localhost
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
- name: Prépare le .env de la stack
|
||||
run: |
|
||||
secret() { openssl rand -hex 32; }
|
||||
sed -e "s|^POSTGRES_PASSWORD=.*|POSTGRES_PASSWORD=$(secret)|" \
|
||||
-e "s|^APP_SECRET_KEY=.*|APP_SECRET_KEY=$(secret)|" \
|
||||
-e "s|^PUBLIC_HOST=.*|PUBLIC_HOST=localhost|" \
|
||||
.env.example > .env
|
||||
|
||||
- name: Génère le certificat de démonstration
|
||||
run: ./scripts/tls-selfsigned.sh
|
||||
|
||||
- name: Construit et démarre la stack derrière le proxy
|
||||
run: docker compose up --detach --build --wait --wait-timeout 300 db mailpit backend frontend proxy
|
||||
|
||||
- name: Applique les migrations
|
||||
run: docker compose exec -T backend alembic upgrade head
|
||||
|
||||
# Même cible que `make stack-up` en prod : les droits du rôle portent sur le schéma réel.
|
||||
- name: Pose le rôle de supervision en lecture seule
|
||||
run: make db-ensure-supervision
|
||||
|
||||
- name: Sème le jeu de démonstration
|
||||
run: docker compose exec -T db psql -U enervision -d enervision -v ON_ERROR_STOP=1 < db/seeds/demo.sql
|
||||
|
||||
- name: Crée les comptes de test
|
||||
env:
|
||||
BASE_URL: https://localhost
|
||||
APP_CLI: docker compose exec -T backend python -m app.cli
|
||||
COMPTES_FICHIER: ${{ runner.temp }}/comptes.json
|
||||
run: ./scripts/comptes-test.sh
|
||||
|
||||
- name: Installe Node
|
||||
uses: actions/setup-node@v7
|
||||
with:
|
||||
node-version: 26
|
||||
cache: npm
|
||||
cache-dependency-path: tests/e2e/package-lock.json
|
||||
|
||||
- name: Installe Playwright
|
||||
working-directory: tests/e2e
|
||||
run: npm ci
|
||||
|
||||
- name: Restaure les navigateurs de Playwright
|
||||
uses: actions/cache@v6
|
||||
with:
|
||||
path: ~/.cache/ms-playwright
|
||||
key: playwright-${{ runner.os }}-${{ hashFiles('tests/e2e/package-lock.json') }}
|
||||
|
||||
# `--with-deps` tourne même quand le cache a servi : il pose aussi les bibliothèques système.
|
||||
- name: Installe Chromium
|
||||
working-directory: tests/e2e
|
||||
run: npx playwright install --with-deps chromium
|
||||
|
||||
- name: Joue les parcours
|
||||
working-directory: tests/e2e
|
||||
env:
|
||||
E2E_COMPTES: ${{ runner.temp }}/comptes.json
|
||||
run: npx playwright test
|
||||
|
||||
# Direct sur `backend:8000` : ce tir mesure l'API, pas la limitation de nginx.
|
||||
- name: Tir k6 de fumée sur l'API
|
||||
env:
|
||||
K6_RESUME: /results/resume-smoke.md
|
||||
run: |
|
||||
K6_EMAIL="$(jq -r .lecteur.email "$RUNNER_TEMP/comptes.json")"
|
||||
K6_PASSWORD="$(jq -r .lecteur.password "$RUNNER_TEMP/comptes.json")"
|
||||
echo "::add-mask::$K6_PASSWORD"
|
||||
export K6_EMAIL K6_PASSWORD
|
||||
make load-smoke
|
||||
|
||||
- name: Vérifie par k6 que le proxy limite le débit
|
||||
env:
|
||||
K6_RESUME: /results/resume-limitation.md
|
||||
run: make load-limits
|
||||
|
||||
- name: Publie la synthèse k6
|
||||
if: ${{ !cancelled() }}
|
||||
run: cat tests/load/results/resume-*.md >> "$GITHUB_STEP_SUMMARY" 2>/dev/null || true
|
||||
|
||||
- name: Publie les rapports k6
|
||||
if: ${{ !cancelled() }}
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: k6-rapports
|
||||
path: tests/load/results/
|
||||
if-no-files-found: ignore
|
||||
retention-days: 14
|
||||
|
||||
- name: Publie le rapport Playwright
|
||||
if: ${{ !cancelled() }}
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: playwright-report
|
||||
path: |
|
||||
tests/e2e/playwright-report/
|
||||
tests/e2e/test-results/
|
||||
if-no-files-found: ignore
|
||||
retention-days: 14
|
||||
|
||||
- name: Journaux de la stack en cas d'échec
|
||||
if: failure()
|
||||
run: docker compose logs --tail=200 backend proxy frontend
|
||||
|
||||
- name: Arrête la stack
|
||||
if: always()
|
||||
run: docker compose down --volumes
|
||||
@@ -1,70 +0,0 @@
|
||||
name: Frontend
|
||||
|
||||
# Pourquoi : aucun déclencheur propre. ci.yml appelle ce workflow quand le frontend change, et
|
||||
# Sonar y reprend la couverture versée par le job `verification` (ADR 0014).
|
||||
|
||||
on:
|
||||
workflow_call:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
# Un seul `npm ci` pour la construction et les tests : un job de plus ne ferait que le rejouer.
|
||||
verification:
|
||||
name: Construction et tests
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
defaults:
|
||||
run:
|
||||
working-directory: apps/frontend
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
- name: Installe Node
|
||||
uses: actions/setup-node@v7
|
||||
with:
|
||||
node-version: 26
|
||||
cache: npm
|
||||
cache-dependency-path: apps/frontend/package-lock.json
|
||||
|
||||
- name: Installe les dépendances
|
||||
run: npm ci
|
||||
|
||||
- name: Construit l'application
|
||||
run: npm run build
|
||||
|
||||
# Piège : `npm test --watch=false` garde l'option pour npm, `ng test` ne la reçoit jamais.
|
||||
# La couverture lcov vient d'angular.json (`coverage: true`).
|
||||
- name: Tests et couverture
|
||||
run: npm run test:ci
|
||||
|
||||
- name: Verse la couverture pour Sonar
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: frontend-coverage
|
||||
path: apps/frontend/coverage/frontend/lcov.info
|
||||
if-no-files-found: error
|
||||
|
||||
security-audit:
|
||||
name: Audit des dépendances
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 10
|
||||
defaults:
|
||||
run:
|
||||
working-directory: apps/frontend
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
- name: Installe Node
|
||||
uses: actions/setup-node@v7
|
||||
with:
|
||||
node-version: 26
|
||||
|
||||
# Seuil high : une vulnérabilité moderate de devDependency ne doit pas bloquer une livraison.
|
||||
- name: Audite le verrou
|
||||
run: npm audit --audit-level=high --package-lock-only
|
||||
@@ -1,140 +0,0 @@
|
||||
name: Infra
|
||||
|
||||
# Pourquoi : rien de ce qui décrit l'infrastructure ne s'exécute avant le déploiement. Terraform est
|
||||
# resté cassé sans que rien ne le dise, faute de job qui le joue : ce workflow n'applique rien, il
|
||||
# vérifie le Terraform, les fichiers Compose et les workflows eux-mêmes - jobs terraform, compose,
|
||||
# workflows. ci.yml choisit par ses entrées ceux qui tournent (ADR 0014).
|
||||
# Piège : la boucle Terraform parcourt `environments/*`, pour qu'une racine ajoutée soit couverte
|
||||
# sans toucher à ce fichier.
|
||||
|
||||
on:
|
||||
workflow_call:
|
||||
inputs:
|
||||
terraform:
|
||||
type: boolean
|
||||
default: false
|
||||
compose:
|
||||
type: boolean
|
||||
default: false
|
||||
workflows:
|
||||
type: boolean
|
||||
default: false
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
terraform:
|
||||
name: Formatage et validation Terraform
|
||||
if: inputs.terraform
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 10
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
# Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
|
||||
- name: Installe Terraform
|
||||
uses: hashicorp/setup-terraform@dfe3c3f87815947d99a8997f908cb6525fc44e9e # v4.0.1
|
||||
with:
|
||||
terraform_version: 1.16.3
|
||||
terraform_wrapper: false
|
||||
|
||||
- name: Vérifie le formatage
|
||||
run: terraform fmt -check -recursive infra/terraform
|
||||
|
||||
- name: Valide chaque racine
|
||||
run: |
|
||||
for racine in infra/terraform/environments/*/; do
|
||||
echo "::group::${racine}"
|
||||
terraform -chdir="${racine}" init -backend=false -input=false
|
||||
terraform -chdir="${racine}" validate
|
||||
echo "::endgroup::"
|
||||
done
|
||||
|
||||
compose:
|
||||
name: Validation des fichiers Compose et de la supervision
|
||||
if: inputs.compose
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 10
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
# Compose interpole tout le fichier : les `:?` exigent une valeur, pas un vrai secret.
|
||||
- name: Prépare un .env d'exemple
|
||||
run: cp .env.example .env
|
||||
|
||||
# Garage refuse un rpc_secret qui n'est pas 32 octets hexadécimaux : `change_me` ne suffit pas.
|
||||
- name: Génère les secrets Garage du .env
|
||||
run: |
|
||||
sed -i -e "s|^GARAGE_RPC_SECRET=.*|GARAGE_RPC_SECRET=$(openssl rand -hex 32)|" \
|
||||
-e "s|^GARAGE_ADMIN_TOKEN=.*|GARAGE_ADMIN_TOKEN=$(openssl rand -hex 32)|" \
|
||||
-e "s|^GARAGE_METRICS_TOKEN=.*|GARAGE_METRICS_TOKEN=$(openssl rand -hex 32)|" \
|
||||
-e "s|^GARAGE_ACCESS_KEY=.*|GARAGE_ACCESS_KEY=GK$(openssl rand -hex 12)|" \
|
||||
-e "s|^GARAGE_SECRET_KEY=.*|GARAGE_SECRET_KEY=$(openssl rand -hex 32)|" \
|
||||
-e "s|^GARAGE_SSE_KEY=.*|GARAGE_SSE_KEY=$(openssl rand -base64 32)|" .env
|
||||
|
||||
- name: Valide la stack de développement
|
||||
run: docker compose config --quiet
|
||||
|
||||
- name: Valide la stack déployée, profils compris
|
||||
run: docker compose -f docker-compose.yml -f docker-compose.prod.yml --profile acme --profile monitoring --profile load config --quiet
|
||||
|
||||
- name: Valide le frontal SNI de la VM
|
||||
run: |
|
||||
docker compose -f infra/front/compose.yml config --quiet
|
||||
docker run --rm -v "$PWD/infra/front/nginx.conf:/etc/nginx/nginx.conf:ro" nginx:1.31-alpine nginx -t
|
||||
|
||||
# Mêmes commandes que `make monitoring-check` : images et montages viennent du fichier Compose.
|
||||
- name: Valide la configuration de Prometheus et ses règles
|
||||
run: docker compose --profile monitoring run --rm --no-deps --entrypoint promtool prometheus check config /etc/prometheus/prometheus.yml
|
||||
|
||||
- name: Joue les tests unitaires des règles d'alerte
|
||||
run: docker compose --profile monitoring run --rm --no-deps --entrypoint promtool prometheus test rules /etc/prometheus/tests/enervision.test.yml
|
||||
|
||||
- name: Valide la configuration d'Alertmanager
|
||||
run: docker compose --profile monitoring run --rm --no-deps --entrypoint amtool alertmanager check-config /etc/alertmanager/alertmanager.yml
|
||||
|
||||
- name: Valide les tableaux de bord Grafana
|
||||
run: for tableau in monitoring/grafana/dashboards/*.json; do jq empty "$tableau"; done
|
||||
|
||||
# Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: false
|
||||
|
||||
# Même image et même healthcheck qu'en prod : `--wait` ne rend la main qu'une fois le S3 prêt.
|
||||
- name: Démarre Garage
|
||||
run: docker compose up -d --wait --wait-timeout 120 garage
|
||||
|
||||
- name: Fumée S3 sur Garage, SSE-C compris
|
||||
run: |
|
||||
set -a; . ./.env; set +a
|
||||
uvx --no-build --with boto3==1.43.101 pytest==9.1.1 tests/garage -q
|
||||
|
||||
- name: Journaux de Garage en cas d'échec
|
||||
if: failure()
|
||||
run: docker compose logs --tail=100 garage
|
||||
|
||||
- name: Arrête Garage
|
||||
if: always()
|
||||
run: docker compose down --volumes
|
||||
|
||||
workflows:
|
||||
name: Analyse des workflows
|
||||
if: inputs.workflows
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 10
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
# Image épinglée par tag, comme les images des fichiers Compose. Elle embarque shellcheck,
|
||||
# qui analyse aussi les blocs `run:`.
|
||||
- name: actionlint
|
||||
run: docker run --rm -v "$PWD:/repo" --workdir /repo rhysd/actionlint:1.7.12 -color
|
||||
@@ -1,167 +0,0 @@
|
||||
name: ML
|
||||
|
||||
# Piège : la version de Python vient de ml/.python-version, et doit rester en 3.14 (cf.
|
||||
# .github/workflows/backend.yml, même contrainte).
|
||||
# Pourquoi : aucun déclencheur propre. ci.yml l'appelle aussi quand les migrations ou les modèles
|
||||
# du backend changent, dont dépend le job `integration` (ADR 0014).
|
||||
|
||||
on:
|
||||
workflow_call:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
verification:
|
||||
name: Lint, typage et tests
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ml
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
# Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: true
|
||||
cache-dependency-glob: ml/uv.lock
|
||||
prune-cache: false
|
||||
|
||||
- name: Installe l'interpréteur déclaré par .python-version
|
||||
run: uv python install
|
||||
|
||||
- name: Synchronise les dépendances sur le verrou
|
||||
run: uv sync --all-groups --locked
|
||||
|
||||
- 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
|
||||
|
||||
# Les tests exigeant une base portent le marqueur `integration`, écarté par défaut et
|
||||
# joué par le job `integration` ci-dessous.
|
||||
- name: Tests et couverture
|
||||
run: uv run pytest --cov-report=xml
|
||||
|
||||
- name: Verse la couverture pour Sonar
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: ml-coverage
|
||||
path: ml/coverage.xml
|
||||
if-no-files-found: error
|
||||
|
||||
# Piège : le schéma de la base ML est celui du backend (apps/backend/alembic, propriétaire du
|
||||
# schéma). Le reconstruire ici à la main rendrait ce job vert sur une base qui n'est pas la nôtre.
|
||||
integration:
|
||||
name: ML - DB et chaîne ML - DB - API
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 20
|
||||
|
||||
services:
|
||||
db:
|
||||
image: timescale/timescaledb-ha:pg17
|
||||
env:
|
||||
POSTGRES_USER: enervision
|
||||
POSTGRES_PASSWORD: change_me
|
||||
POSTGRES_DB: enervision_test
|
||||
ports:
|
||||
- "5433:5432"
|
||||
options: >-
|
||||
--health-cmd "pg_isready -U enervision -d enervision_test"
|
||||
--health-interval 10s
|
||||
--health-timeout 5s
|
||||
--health-retries 12
|
||||
--health-start-period 40s
|
||||
|
||||
env:
|
||||
# Deux variables, deux dialectes : Alembic et l'API parlent asyncpg, le pipeline ML parle
|
||||
# psycopg en synchrone. Cf. docs/ML-START.md, section 1.
|
||||
DATABASE_URL: postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_test
|
||||
ML_DATABASE_URL: postgresql+psycopg://enervision:change_me@localhost:5433/enervision_test
|
||||
APP_SECRET_KEY: secret-de-test-assez-long-pour-le-validateur
|
||||
PGPASSWORD: change_me
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: true
|
||||
cache-dependency-glob: |
|
||||
ml/uv.lock
|
||||
apps/backend/uv.lock
|
||||
prune-cache: false
|
||||
|
||||
- name: Installe l'interpréteur déclaré par .python-version
|
||||
working-directory: ml
|
||||
run: uv python install
|
||||
|
||||
- name: Synchronise le pipeline ML sur le verrou
|
||||
working-directory: ml
|
||||
run: uv sync --all-groups --locked
|
||||
|
||||
# Le backend est installé ici parce qu'il porte les migrations, seule source du schéma, et
|
||||
# le test de chaîne, qui interroge l'API.
|
||||
- name: Synchronise le backend sur le verrou
|
||||
working-directory: apps/backend
|
||||
run: uv sync --all-groups --locked
|
||||
|
||||
# db/init/110-test-database.sql n'est pas monté ici, et sans l'extension la première
|
||||
# révision Alembic refuse de s'appliquer.
|
||||
- name: Active TimescaleDB sur la base de test
|
||||
run: psql -h localhost -p 5433 -U enervision -d enervision_test -c "CREATE EXTENSION IF NOT EXISTS timescaledb"
|
||||
|
||||
- name: Applique les migrations du backend, propriétaire du schéma
|
||||
working-directory: apps/backend
|
||||
run: uv run alembic upgrade head
|
||||
|
||||
# Couverture désactivée : ce job ne joue qu'une partie de la suite, son taux n'aurait pas
|
||||
# de sens (même raison que backend.yml).
|
||||
- name: Tests ML exigeant une base
|
||||
working-directory: ml
|
||||
run: uv run pytest -m integration --no-cov
|
||||
|
||||
# Lance les vrais binaires enervision_ml.train et .score en sous-processus, comme les DAGs
|
||||
# ml_train et ml_score, puis relit le résultat par GET /api/v1/predictions.
|
||||
- name: Chaîne complète ML vers DB vers API
|
||||
working-directory: apps/backend
|
||||
env:
|
||||
ML_PYTHON: ${{ github.workspace }}/ml/.venv/bin/python
|
||||
run: uv run pytest -m chaine --no-cov
|
||||
|
||||
sast:
|
||||
name: Analyse statique de sécurité
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 10
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ml
|
||||
|
||||
steps:
|
||||
- name: Récupère le dépôt
|
||||
uses: actions/checkout@v7
|
||||
|
||||
# Pourquoi : pas de cache ici. uvx n'installe pas le projet, le verrou n'alimente donc
|
||||
# aucune clé de cache ; la seule roue téléchargée est celle de Bandit.
|
||||
- name: Installe uv
|
||||
uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
|
||||
with:
|
||||
enable-cache: false
|
||||
|
||||
- name: Analyse le code livré (bloquant à partir de MEDIUM)
|
||||
run: uvx bandit==1.9.4 --recursive enervision_ml --severity-level medium --confidence-level medium
|
||||
|
||||
- name: Rapport complet, tous niveaux
|
||||
continue-on-error: true
|
||||
run: uvx bandit==1.9.4 --recursive enervision_ml
|
||||
+4
-24
@@ -22,12 +22,6 @@ apps/frontend/.angular/
|
||||
npm-debug.log*
|
||||
yarn-error.log*
|
||||
|
||||
# Tests de bout en bout et de charge : rapports générés et identifiants des comptes de test
|
||||
playwright-report/
|
||||
blob-report/
|
||||
tests/e2e/.comptes.json
|
||||
tests/load/results/
|
||||
|
||||
# Terraform
|
||||
.terraform/
|
||||
# .terraform.lock.hcl est versionne (pas ignore) pour figer les versions de provider entre contributeurs/CI
|
||||
@@ -46,6 +40,7 @@ kubeconfig
|
||||
# Airflow
|
||||
etl/airflow/logs/
|
||||
airflow.db
|
||||
airflow-webserver.pid
|
||||
standalone_admin_password.txt
|
||||
|
||||
# Environnement et secrets
|
||||
@@ -57,25 +52,10 @@ standalone_admin_password.txt
|
||||
secrets/
|
||||
|
||||
# Donnees locales
|
||||
data/raw/*
|
||||
!data/raw/.gitkeep
|
||||
data/
|
||||
*.sqlite3
|
||||
|
||||
# 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*
|
||||
ml/.env
|
||||
|
||||
# Airflow : base sqlite locale generee par les tests d'integrite des DAGs (etl/airflow/tests)
|
||||
etl/airflow/tests/.airflow_home/
|
||||
|
||||
# TLS : certificats du reverse proxy, générés par script ou par certbot
|
||||
infra/proxy/tls/*.pem
|
||||
infra/proxy/acme/
|
||||
monitoring/grafana/data/
|
||||
monitoring/prometheus/data/
|
||||
|
||||
# IDE et OS
|
||||
.idea/
|
||||
|
||||
@@ -1,333 +1,49 @@
|
||||
BACKEND := apps/backend
|
||||
FRONTEND := apps/frontend
|
||||
ML := ml
|
||||
AIRFLOW := etl/airflow
|
||||
E2E := tests/e2e
|
||||
COMPOSE_PROD := docker compose -f docker-compose.yml -f docker-compose.prod.yml
|
||||
|
||||
# Piège : sans `export`, une valeur passée en ligne de commande n'atteindrait pas docker compose.
|
||||
# PUBLIC_HOST retombe sur le `.env`, que make ne lit pas, puis sur la valeur de `.env.example`.
|
||||
PUBLIC_HOST ?= $(shell sed -n 's/^PUBLIC_HOST=//p' .env 2>/dev/null | tail -1)
|
||||
PUBLIC_HOST := $(or $(strip $(PUBLIC_HOST)),enervision.local)
|
||||
export PUBLIC_HOST
|
||||
ifdef ACME_EMAIL
|
||||
export ACME_EMAIL
|
||||
endif
|
||||
|
||||
# Piege : make ne lit pas `.env`, que seul docker compose interpole. Les cibles hors conteneur
|
||||
# (ml-*, demo-data, db-wait) joignent la base par le port publie et ont besoin de ces valeurs.
|
||||
env-val = $(shell sed -n 's/^$(1)=//p' .env 2>/dev/null | tail -1)
|
||||
PG_USER := $(or $(strip $(call env-val,POSTGRES_USER)),enervision)
|
||||
PG_PASSWORD := $(or $(strip $(call env-val,POSTGRES_PASSWORD)),change_me)
|
||||
PG_DB := $(or $(strip $(call env-val,POSTGRES_DB)),enervision)
|
||||
PG_PORT := $(or $(strip $(call env-val,POSTGRES_PORT)),5433)
|
||||
ml-env-val = $(shell sed -n 's/^$(1)=//p' ml/.env 2>/dev/null | tail -1)
|
||||
ML_ENV_DB_PASSWORD := $(call ml-env-val,MLFLOW_DB_PASSWORD)
|
||||
AIRFLOW_PORT := $(or $(strip $(call env-val,AIRFLOW_PORT)),8080)
|
||||
MAILPIT_UI_PORT := $(or $(strip $(call env-val,MAILPIT_UI_PORT)),8025)
|
||||
ML_DATABASE_URL ?= postgresql+psycopg://$(PG_USER):$(PG_PASSWORD)@localhost:$(PG_PORT)/$(PG_DB)
|
||||
export ML_DATABASE_URL
|
||||
|
||||
# Piege : la base des tests d'integration n'est pas la base de developpement. Ces tests ecrivent
|
||||
# et suppriment des lignes, et leurs fixtures refusent de demarrer ailleurs que sur
|
||||
# `enervision_test` (garde sur le nom, cf. ml/tests/conftest.py).
|
||||
PG_TEST_DB ?= enervision_test
|
||||
TEST_DATABASE_URL ?= postgresql+asyncpg://$(PG_USER):$(PG_PASSWORD)@localhost:$(PG_PORT)/$(PG_TEST_DB)
|
||||
ML_TEST_DATABASE_URL ?= postgresql+psycopg://$(PG_USER):$(PG_PASSWORD)@localhost:$(PG_PORT)/$(PG_TEST_DB)
|
||||
|
||||
# Piege : ni make ni ces cibles ne lisent `.env` pour COMPOSE_PROFILES, que docker compose y lit
|
||||
# seul. `stack-up` le relit ici pour savoir s'il doit poser le role `supervision` apres migration.
|
||||
SUPERVISION := $(findstring monitoring,$(COMPOSE_PROFILES) $(call env-val,COMPOSE_PROFILES))
|
||||
SERVICES_SUPERVISION := prometheus alertmanager grafana postgres-exporter node-exporter cadvisor
|
||||
GRAFANA_PORT := $(or $(strip $(call env-val,GRAFANA_PORT)),3001)
|
||||
PROMETHEUS_PORT := $(or $(strip $(call env-val,PROMETHEUS_PORT)),9090)
|
||||
supervision-garde = for cle in APP_METRICS_TOKEN GRAFANA_ADMIN_PASSWORD SUPERVISION_DB_PASSWORD GARAGE_METRICS_TOKEN; do \
|
||||
sed -n "s/^$$cle=//p" .env 2>/dev/null | tail -1 | grep -q . \
|
||||
|| { echo "$$cle manquant dans .env, requis par la supervision (cf. .env.example)"; exit 1; }; \
|
||||
done
|
||||
MONITORING := docker compose --profile monitoring
|
||||
|
||||
# Piege : l'image Garage n'a pas de shell, elle ne peut pas porter sa garde comme grafana ou
|
||||
# airflow-init. Un secret vide ou laisse a change_me la ferait redemarrer en boucle (ADR 0019).
|
||||
CLES_GARAGE := GARAGE_RPC_SECRET GARAGE_ADMIN_TOKEN GARAGE_METRICS_TOKEN GARAGE_ACCESS_KEY GARAGE_SECRET_KEY GARAGE_SSE_KEY
|
||||
garage-garde = for cle in $(CLES_GARAGE); do \
|
||||
sed -n "s/^$$cle=//p" .env 2>/dev/null | tail -1 | grep -qv '^change_me$$' \
|
||||
|| { echo "$$cle manquant ou laisse a change_me dans .env, requis par Garage (cf. .env.example)"; exit 1; }; \
|
||||
done
|
||||
PROMTOOL := $(MONITORING) run --rm --no-deps --entrypoint promtool prometheus
|
||||
|
||||
# Piege : `e2e-prepare` ajoute trois sites `demo-*` et des comptes `test-*` a la base visee. Elle
|
||||
# vise la base de `make dev` ; ne jamais la lancer contre la recette ou la prod.
|
||||
E2E_COMPTES ?= $(CURDIR)/$(E2E)/.comptes.json
|
||||
E2E_API ?= http://localhost:$(or $(strip $(call env-val,BACKEND_PORT)),8000)
|
||||
|
||||
# Piege : `run` ne demarre que k6, la stack doit deja tourner. `--user` fait ecrire les rapports
|
||||
# de tests/load/results avec l'uid du poste, pas celui de l'image (12345), qui n'y a pas acces.
|
||||
k6-run = mkdir -p tests/load/results && $(COMPOSE_PROD) --profile load run --rm \
|
||||
--user "$$(id -u):$$(id -g)" -e K6_WEB_DASHBOARD=true \
|
||||
-e K6_WEB_DASHBOARD_EXPORT=/results/$(1)-$$(date +%Y%m%dT%H%M%S).html \
|
||||
k6 run /scripts/$(1).js
|
||||
|
||||
# Le jeu historique s'arrete au 31/12/2024 : score et detection ancres a l'horloge reelle ne
|
||||
# verraient qu'un parc muet depuis des mois. Cf. `--now` de enervision_ml.score.
|
||||
DEMO_NOW ?= 2024-12-31T00:00:00Z
|
||||
|
||||
.DEFAULT_GOAL := help
|
||||
.PHONY: help install install-backend install-frontend install-ml install-airflow \
|
||||
dev dev-backend dev-frontend \
|
||||
lint format typecheck test test-cov test-integration ml-test-integration \
|
||||
test-chaine check \
|
||||
openapi docker-build db-up db-down db-reset db-logs db-psql db-wait db-ensure-airflow \
|
||||
migrate migrate-test bootstrap-admin services-up demo-data demo-data-force \
|
||||
ml-lint ml-typecheck ml-test ml-check ml-train ml-score mlflow-up detect-alerts recommendations \
|
||||
airflow-lint airflow-test airflow-check airflow-up airflow-down airflow-logs \
|
||||
tls-selfsigned tls-acme tls-renew tls-dns01 front-up stack-up stack-down stack-logs \
|
||||
e2e-install e2e-prepare e2e load-smoke load-test load-stress load-limits \
|
||||
db-ensure-supervision monitoring-up monitoring-down monitoring-logs monitoring-check
|
||||
.PHONY: help install dev lint format typecheck test test-cov test-integration check \
|
||||
docker-build db-up db-down db-reset db-logs db-psql migrate
|
||||
|
||||
help: ## Liste les cibles disponibles
|
||||
@grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf " \033[36m%-16s\033[0m %s\n", $$1, $$2}'
|
||||
@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf " \033[36m%-16s\033[0m %s\n", $$1, $$2}'
|
||||
|
||||
install: install-backend install-frontend install-ml install-airflow ## Installe les dépendances backend, frontend, ML et Airflow
|
||||
|
||||
install-backend: ## Installe les dépendances du backend
|
||||
install: ## Installe les dependances du backend
|
||||
cd $(BACKEND) && uv sync --all-groups
|
||||
|
||||
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
|
||||
|
||||
install-airflow: ## Installe les dépendances de lint/test des DAGs Airflow
|
||||
cd $(AIRFLOW) && uv sync --all-groups
|
||||
|
||||
dev: services-up migrate demo-data ## Lance toute la stack : base, Mailpit, Airflow, puis backend et frontend
|
||||
@echo "airflow -> http://localhost:$(AIRFLOW_PORT) mailpit -> http://localhost:$(MAILPIT_UI_PORT)"
|
||||
@trap 'kill 0' EXIT INT TERM; \
|
||||
$(MAKE) --no-print-directory dev-backend & \
|
||||
$(MAKE) --no-print-directory dev-frontend & \
|
||||
wait
|
||||
|
||||
services-up: ## Démarre les services conteneurisés dont `make dev` dépend (base, Mailpit, Garage, Airflow)
|
||||
@$(garage-garde)
|
||||
docker compose up -d db mailpit garage
|
||||
@$(MAKE) --no-print-directory db-wait
|
||||
@$(MAKE) --no-print-directory db-ensure-airflow
|
||||
docker compose up -d airflow-init airflow-apiserver airflow-scheduler airflow-dag-processor
|
||||
|
||||
dev-backend: ## Lance l'API seule en rechargement à chaud
|
||||
@echo "backend -> http://localhost:8000 (docs sur /docs)"
|
||||
dev: ## Lance l'API en rechargement a chaud
|
||||
cd $(BACKEND) && uv run uvicorn app.main:create_app --factory --reload --host 0.0.0.0 --port 8000
|
||||
|
||||
dev-frontend: ## Lance le frontend seul en rechargement à chaud
|
||||
@echo "frontend -> http://localhost:4200"
|
||||
cd $(FRONTEND) && npm start
|
||||
|
||||
lint: ## Analyse statique du backend
|
||||
cd $(BACKEND) && uv run ruff check .
|
||||
|
||||
format: ## Formate et corrige le backend
|
||||
cd $(BACKEND) && uv run ruff format . && uv run ruff check --fix .
|
||||
|
||||
typecheck: ## Vérifie le typage du backend
|
||||
typecheck: ## Verifie le typage du backend
|
||||
cd $(BACKEND) && uv run mypy app
|
||||
|
||||
test: ## Exécute les tests backend ne demandant pas de base
|
||||
test: ## Execute les tests backend ne demandant pas de base
|
||||
cd $(BACKEND) && uv run pytest --cov-fail-under=85
|
||||
|
||||
test-cov: ## Rapports de couverture HTML et XML, plus les résultats au format JUnit
|
||||
test-cov: ## Rapports de couverture HTML et XML, plus les resultats au format JUnit
|
||||
cd $(BACKEND) && uv run pytest --cov-fail-under=85 --cov-report=html \
|
||||
--cov-report=xml --junitxml=test-results/junit.xml
|
||||
|
||||
test-integration: ## Exécute les tests exigeant une base joignable
|
||||
test-integration: ## Execute les tests exigeant une base joignable
|
||||
cd $(BACKEND) && uv run pytest -m integration
|
||||
|
||||
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
|
||||
|
||||
# La cible surcharge ML_DATABASE_URL, que ce Makefile exporte vers la base de développement : la
|
||||
# garde du conftest ferait échouer la cible sans cette surcharge.
|
||||
ml-test-integration: ML_DATABASE_URL := $(ML_TEST_DATABASE_URL)
|
||||
ml-test-integration: ## Tests ML exigeant une base migrée. Faire `make db-up migrate-test` avant
|
||||
cd $(ML) && uv run pytest -m integration --no-cov
|
||||
|
||||
test-chaine: ## Chaîne ML -> DB -> API, vrais binaires. Exige les deux environnements uv
|
||||
cd $(BACKEND) && DATABASE_URL=$(TEST_DATABASE_URL) ML_PYTHON=$(CURDIR)/$(ML)/.venv/bin/python \
|
||||
uv run pytest -m chaine --no-cov
|
||||
|
||||
ml-train: ## Entraine le modele LightGBM. CSV=chemin optionnel, sinon lit ML_DATABASE_URL
|
||||
cd $(ML) && uv run python -m enervision_ml.train $(if $(CSV),--csv $(CSV),)
|
||||
|
||||
ml-score: ## Score le prochain pas horaire et l'ecrit dans `prediction`. CSV= et NOW= optionnels
|
||||
cd $(ML) && uv run python -m enervision_ml.score $(if $(CSV),--csv $(CSV),) $(if $(NOW),--now $(NOW),)
|
||||
|
||||
mlflow-up: ## Démarre le serveur MLflow (tracking + registry) en conteneur. ml/.env requis
|
||||
@test -n "$(strip $(ML_ENV_DB_PASSWORD))" \
|
||||
|| { echo "MLFLOW_DB_PASSWORD absente de ml/.env (copier ml/.env.example)"; exit 1; }
|
||||
@echo "$(ML_ENV_DB_PASSWORD)" | grep -qE '^[A-Za-z0-9]+$$' \
|
||||
|| { echo "MLFLOW_DB_PASSWORD doit contenir uniquement lettres et chiffres (interpolee dans l'URI postgresql://)"; exit 1; }
|
||||
cd $(ML) && docker compose -f docker-compose.mlflow.yml up -d --build
|
||||
@echo "mlflow -> http://localhost:5000"
|
||||
|
||||
detect-alerts: ## Détecte les alertes internes depuis les lectures en base. SITE= et NOW= optionnels
|
||||
cd $(BACKEND) && uv run python -m app.detection.internal_alerts $(if $(SITE),--site-id $(SITE),) $(if $(NOW),--now $(NOW),)
|
||||
|
||||
recommendations: ## Genere les recommandations depuis les alertes en base. SITE=identifiant optionnel
|
||||
cd $(BACKEND) && uv run python -m app.cli generate-recommendations $(if $(SITE),--site-id $(SITE),)
|
||||
|
||||
airflow-lint: ## Analyse statique des DAGs Airflow
|
||||
cd $(AIRFLOW) && uv run ruff check .
|
||||
|
||||
airflow-test: ## Verifie que les DAGs s'importent sans erreur et ont la structure attendue
|
||||
cd $(AIRFLOW) && uv run pytest
|
||||
|
||||
airflow-check: airflow-lint airflow-test ## Chaîne de vérification complète des DAGs Airflow
|
||||
|
||||
airflow-up: db-ensure-airflow ## Démarre Airflow (api-server + scheduler + dag-processor, LocalExecutor). db-up requis avant.
|
||||
docker compose up -d airflow-init airflow-apiserver airflow-scheduler airflow-dag-processor
|
||||
@echo "airflow -> http://localhost:$${AIRFLOW_PORT:-8080}"
|
||||
|
||||
airflow-down: ## Arrête l'api-server, le scheduler et le dag-processor Airflow
|
||||
docker compose stop airflow-apiserver airflow-scheduler airflow-dag-processor
|
||||
|
||||
airflow-logs: ## Suit les journaux du scheduler Airflow (où tournent les tâches, LocalExecutor)
|
||||
docker compose logs -f airflow-scheduler
|
||||
check: lint typecheck test ## Chaine de verification complete
|
||||
|
||||
docker-build: ## Construit l'image du backend
|
||||
docker build -t enervision-backend:local $(BACKEND)
|
||||
|
||||
tls-selfsigned: ## Génère le certificat de démonstration. PUBLIC_HOST=..., FORCE=1 pour écraser
|
||||
./scripts/tls-selfsigned.sh $(if $(FORCE),--force,)
|
||||
|
||||
# Piège : l'image backend ne migre pas au démarrage, et `/health/ready` ne teste que la connexion
|
||||
# et l'extension. Sans `alembic upgrade head`, la stack démarre verte sur une base sans schéma.
|
||||
stack-up: ## Démarre la stack derrière le reverse proxy, puis migre la base. PUBLIC_HOST=... au besoin
|
||||
@test -f infra/proxy/tls/fullchain.pem \
|
||||
|| { echo "Aucun certificat dans infra/proxy/tls. Lancer d'abord make tls-selfsigned"; exit 1; }
|
||||
@openssl x509 -in infra/proxy/tls/fullchain.pem -noout -checkhost "$(PUBLIC_HOST)" >/dev/null \
|
||||
|| { echo "Le certificat ne couvre pas $(PUBLIC_HOST). Relancer make tls-selfsigned PUBLIC_HOST=$(PUBLIC_HOST) FORCE=1"; exit 1; }
|
||||
@$(if $(SUPERVISION),$(supervision-garde),true)
|
||||
@$(garage-garde)
|
||||
$(COMPOSE_PROD) up -d --build
|
||||
$(COMPOSE_PROD) exec -T backend alembic upgrade head
|
||||
@$(if $(SUPERVISION),$(MAKE) --no-print-directory db-ensure-supervision,true)
|
||||
|
||||
stack-down: ## Arrête la stack complète en conservant les données
|
||||
$(COMPOSE_PROD) stop
|
||||
|
||||
stack-logs: ## Suit les journaux du reverse proxy
|
||||
$(COMPOSE_PROD) logs -f proxy
|
||||
|
||||
tls-acme: ## Demande un certificat Let's Encrypt. PUBLIC_HOST public et ACME_EMAIL requis
|
||||
@test "$(PUBLIC_HOST)" != enervision.local \
|
||||
|| { echo "PUBLIC_HOST doit être un domaine public résolvable, pas le nom de démonstration"; exit 1; }
|
||||
$(COMPOSE_PROD) --profile acme run --rm certbot certonly --webroot -w /var/www/certbot \
|
||||
-d $(PUBLIC_HOST) \
|
||||
--email $${ACME_EMAIL:?ACME_EMAIL=... requis} \
|
||||
--agree-tos --no-eff-email --deploy-hook /deploy-hook.sh
|
||||
$(COMPOSE_PROD) exec proxy nginx -s reload
|
||||
|
||||
tls-renew: ## Renouvelle les certificats Let's Encrypt et recharge le proxy
|
||||
$(COMPOSE_PROD) --profile acme run --rm certbot renew --deploy-hook /deploy-hook.sh
|
||||
$(COMPOSE_PROD) exec proxy nginx -s reload
|
||||
|
||||
# Pourquoi : la VM n'a qu'une IP privée, que Let's Encrypt ne joint pas ; le défi DNS-01 passe
|
||||
# par l'API du fournisseur DNS, dynv6 par défaut (ADR 0018). Le jeton ne passe jamais par `argv`.
|
||||
ACME_SH := neilpang/acme.sh:3.1.6
|
||||
DNS01_API ?= dns_dynv6
|
||||
DNS01_JETON_VAR ?= DYNV6_TOKEN
|
||||
DNS01_JETON_FICHIER ?= $(abspath $(CURDIR)/../dns.token)
|
||||
acme-sh = docker run --rm --user "$$(id -u):$$(id -g)" -e $(DNS01_JETON_VAR) -e AUTO_UPGRADE=0 \
|
||||
-v "$(CURDIR)/infra/proxy/acme:/acme.sh" -v "$(CURDIR)/infra/proxy/tls:/tls" $(ACME_SH)
|
||||
|
||||
# acme.sh sort en 2 quand le certificat n'est pas à renouveler, et recopie le jeton dans
|
||||
# acme/account.conf, d'où le chmod. `--dnssleep` : Let's Encrypt valide depuis plusieurs réseaux.
|
||||
tls-dns01: ## Certificat Let's Encrypt par DNS-01, renouvelé seulement à échéance. Jeton : ../dns.token
|
||||
@case "$(PUBLIC_HOST)" in *.local | localhost) echo "PUBLIC_HOST=$(PUBLIC_HOST) n'est pas un nom public"; exit 1 ;; esac
|
||||
@test -r "$(DNS01_JETON_FICHIER)" || { echo "Jeton DNS illisible : $(DNS01_JETON_FICHIER)"; exit 1; }
|
||||
@mkdir -p infra/proxy/acme && chmod 700 infra/proxy/acme
|
||||
@$(DNS01_JETON_VAR)="$$(tr -d '[:space:]' < "$(DNS01_JETON_FICHIER)")"; export $(DNS01_JETON_VAR); \
|
||||
$(acme-sh) --issue --server letsencrypt --dns $(DNS01_API) --dnssleep 90 -d "$(PUBLIC_HOST)"; \
|
||||
code=$$?; chmod -R go-rwx infra/proxy/acme; [ $$code -eq 0 ] || [ $$code -eq 2 ] || exit $$code
|
||||
@$(acme-sh) --install-cert --ecc -d "$(PUBLIC_HOST)" \
|
||||
--fullchain-file /tls/fullchain.pem --key-file /tls/privkey.pem
|
||||
@$(COMPOSE_PROD) exec -T proxy nginx -s reload 2>/dev/null \
|
||||
|| echo "Proxy arrêté : il lira le certificat à son démarrage"
|
||||
|
||||
front-up: ## Démarre ou recharge le frontal SNI de la VM, sur les ports 80 et 443 de l'hôte
|
||||
docker compose -f infra/front/compose.yml up -d
|
||||
docker compose -f infra/front/compose.yml exec -T front nginx -s reload
|
||||
|
||||
e2e-install: ## Installe Playwright et Chromium pour les tests de bout en bout
|
||||
cd $(E2E) && npm ci && npx playwright install chromium
|
||||
|
||||
e2e-prepare: ## Sème le jeu de démonstration et crée les comptes de test sur la base de `make dev`
|
||||
docker compose exec -T db psql -U $(PG_USER) -d $(PG_DB) -v ON_ERROR_STOP=1 < db/seeds/demo.sql
|
||||
cd $(BACKEND) && BASE_URL=$(E2E_API) COMPTES_FICHIER=$(E2E_COMPTES) ADMIN_SUPPLEMENTAIRE=1 \
|
||||
../../scripts/comptes-test.sh
|
||||
|
||||
e2e: ## Joue les parcours Playwright. E2E_BASE_URL= optionnel (défaut http://localhost:4200)
|
||||
cd $(E2E) && E2E_COMPTES=$(E2E_COMPTES) npx playwright test
|
||||
|
||||
load-smoke: ## Tir k6 d'une minute. K6_EMAIL= et K6_PASSWORD= d'un lecteur, K6_BASE_URL= optionnel
|
||||
$(call k6-run,smoke)
|
||||
|
||||
load-test: ## Charge nominale k6, 50 utilisateurs pendant 8 minutes. Rapport HTML dans tests/load/results
|
||||
$(call k6-run,charge)
|
||||
|
||||
load-stress: ## Monte le débit jusqu'à la rupture de l'API. Sur la VM, la prod partage la machine
|
||||
$(call k6-run,stress)
|
||||
|
||||
load-limits: ## Vérifie par le proxy que nginx limite le débit d'une même adresse (429)
|
||||
$(call k6-run,limitation-debit)
|
||||
|
||||
# Piege : le mot de passe est lu dans `.env` par le shell et passe a psql sur son entree
|
||||
# standard. Developpe par make, il apparaitrait en clair dans la ligne de commande (`ps`).
|
||||
db-ensure-supervision: ## Crée ou réaligne le rôle `supervision`, en lecture seule, de Grafana et de l'exportateur
|
||||
@mdp="$$(sed -n 's/^SUPERVISION_DB_PASSWORD=//p' .env 2>/dev/null | tail -1)"; \
|
||||
[ -n "$$mdp" ] || { echo "SUPERVISION_DB_PASSWORD manquant dans .env"; exit 1; }; \
|
||||
{ printf '\\set mot_de_passe %s\n' "$$mdp"; cat db/roles/supervision.sql; } \
|
||||
| docker compose exec -T db psql -U $(PG_USER) -d $(PG_DB) -v ON_ERROR_STOP=1 -v base=$(PG_DB) -q
|
||||
|
||||
monitoring-up: ## Démarre la supervision sur la stack en cours : Prometheus, Alertmanager, Grafana, exporteurs
|
||||
@$(supervision-garde)
|
||||
$(MONITORING) up -d --no-deps $(SERVICES_SUPERVISION)
|
||||
@$(MAKE) --no-print-directory db-ensure-supervision
|
||||
@echo "grafana -> http://localhost:$(GRAFANA_PORT) prometheus -> http://localhost:$(PROMETHEUS_PORT)"
|
||||
|
||||
monitoring-down: ## Arrête la supervision en conservant ses données
|
||||
$(MONITORING) stop $(SERVICES_SUPERVISION)
|
||||
|
||||
monitoring-logs: ## Suit les journaux de Prometheus, Alertmanager et Grafana
|
||||
$(MONITORING) logs -f prometheus alertmanager grafana
|
||||
|
||||
monitoring-check: ## Valide la configuration de supervision et joue les tests des règles d'alerte, comme la CI
|
||||
$(PROMTOOL) check config /etc/prometheus/prometheus.yml
|
||||
$(PROMTOOL) test rules /etc/prometheus/tests/enervision.test.yml
|
||||
$(MONITORING) run --rm --no-deps --entrypoint amtool alertmanager check-config /etc/alertmanager/alertmanager.yml
|
||||
@for tableau in monitoring/grafana/dashboards/*.json; do jq empty "$$tableau" || exit 1; done
|
||||
|
||||
db-up: ## Démarre la base PostgreSQL TimescaleDB
|
||||
db-up: ## Demarre la base PostgreSQL TimescaleDB
|
||||
docker compose up -d db
|
||||
|
||||
db-down: ## Arrête la base en conservant ses données
|
||||
db-down: ## Arrete la base en conservant ses donnees
|
||||
docker compose stop db
|
||||
|
||||
db-reset: ## Détruit la base et rejoue db/init
|
||||
db-reset: ## Detruit la base et rejoue db/init
|
||||
docker compose down -v && docker compose up -d db
|
||||
|
||||
db-logs: ## Suit les journaux de la base
|
||||
@@ -336,39 +52,5 @@ db-logs: ## Suit les journaux de la base
|
||||
db-psql: ## Ouvre une session psql sur la base applicative
|
||||
docker compose exec db psql -U $${POSTGRES_USER:-enervision} -d $${POSTGRES_DB:-enervision}
|
||||
|
||||
db-wait: ## Attend que la base accepte les connexions
|
||||
@for _ in $$(seq 1 60); do \
|
||||
docker compose exec -T db pg_isready -U $(PG_USER) -d $(PG_DB) >/dev/null 2>&1 && exit 0; \
|
||||
sleep 1; \
|
||||
done; \
|
||||
echo "La base n'accepte toujours pas de connexion apres 60s"; exit 1
|
||||
|
||||
# Piege : db/init ne rejoue qu'a la premiere initialisation du volume. Un `pgdata` cree avant
|
||||
# db/init/120-airflow-database.sql n'a pas de base `airflow`, et airflow-init boucle dessus.
|
||||
db-ensure-airflow: ## Crée la base de métadonnées Airflow si le volume pgdata est antérieur à db/init/120
|
||||
@docker compose exec -T db psql -U $(PG_USER) -d postgres -tAc \
|
||||
"SELECT 1 FROM pg_database WHERE datname = 'airflow'" | grep -q 1 \
|
||||
|| docker compose exec -T db psql -U $(PG_USER) -d postgres -c "CREATE DATABASE airflow"
|
||||
|
||||
migrate: ## Applique les migrations Alembic
|
||||
cd $(BACKEND) && uv run alembic upgrade head
|
||||
|
||||
migrate-test: ## Applique les migrations sur enervision_test, la base des tests d'intégration
|
||||
cd $(BACKEND) && DATABASE_URL=$(TEST_DATABASE_URL) uv run alembic upgrade head
|
||||
|
||||
bootstrap-admin: ## Crée le premier administrateur, mot de passe saisi au clavier
|
||||
cd $(BACKEND) && uv run python -m app.cli create-admin --email $${EMAIL:?EMAIL=... requis}
|
||||
|
||||
demo-data: ## Renseigne prédictions, alertes et recommandations si elles manquent. NOW= optionnel
|
||||
@nombre=$$(docker compose exec -T db psql -U $(PG_USER) -d $(PG_DB) -tAc 'SELECT count(*) FROM alert') \
|
||||
|| { echo "demo-data : base injoignable ou migrations non appliquees"; exit 1; }; \
|
||||
if [ "$$nombre" = 0 ]; then \
|
||||
$(MAKE) --no-print-directory demo-data-force; \
|
||||
else \
|
||||
echo "demo-data : $$nombre alerte(s) deja en base (make demo-data-force pour rejouer)"; \
|
||||
fi
|
||||
|
||||
demo-data-force: ## Rejoue le peuplement sans regarder l'existant. Les trois etapes sont idempotentes
|
||||
$(MAKE) --no-print-directory ml-score NOW=$(DEMO_NOW)
|
||||
$(MAKE) --no-print-directory detect-alerts NOW=$(DEMO_NOW)
|
||||
$(MAKE) --no-print-directory recommendations
|
||||
|
||||
@@ -3,43 +3,20 @@
|
||||
Monorepo de la plateforme EnerVision : collecte, stockage, analyse et restitution de
|
||||
series temporelles energetiques, deployee sur une machine on-premise.
|
||||
|
||||
## Jalons
|
||||
|
||||
| Jalon | Intitulé |
|
||||
|-------|----------------------------------------------------------|
|
||||
| J1 | Valider la préparation de l'environnement et du repo |
|
||||
| J2 | Valider le périmètre retenu et les choix technologiques |
|
||||
| J3 | Ingestion & backend |
|
||||
| J4 | Architecture, sécurité & frontend |
|
||||
| J5 | Valider la robustesse et assurer les livrables |
|
||||
| J6 | Amélioration possible |
|
||||
|
||||
Ce que la documentation apporte à chacun : [docs/architecture/00-vue-ensemble.md](docs/architecture/00-vue-ensemble.md).
|
||||
|
||||
## Stack
|
||||
## Stack cible
|
||||
|
||||
| Domaine | Technologie | Emplacement | Etat |
|
||||
|------------|-------------------------------------|---------------------|---------------|
|
||||
| Backend | FastAPI, Python 3.14 | `apps/backend` | En place |
|
||||
| Frontend | Angular 22, Node 26 | `apps/frontend` | En place |
|
||||
| Base | PostgreSQL 17 + TimescaleDB | `db` | En place |
|
||||
| ETL | Apache Airflow | `etl/airflow` | Sept DAGs |
|
||||
| Infra | Terraform (VM ENI ; module k3s) | `infra/terraform` | VM appliquée, k3s écrit non appliqué |
|
||||
| Reverse proxy | Nginx, TLS, frontal SNI | `infra/proxy`, `infra/front` | En place, certificats Let's Encrypt |
|
||||
| CI/CD | GitHub Actions | `.github/workflows` | En place |
|
||||
| Monitoring | Prometheus, Grafana, Alertmanager | `monitoring` | En place, profil Compose |
|
||||
| Stockage objet | Garage (S3), un par environnement | `infra/garage` | En place, archives de `reading` |
|
||||
| Tests e2e et de charge | Playwright, k6 | `tests` | En place |
|
||||
| ML | LightGBM, MLflow | `ml` | En place |
|
||||
| Backend | FastAPI, Python 3.14 | `apps/backend` | Initialise |
|
||||
| Frontend | Angular, Node 24 LTS | `apps/frontend` | A initialiser |
|
||||
| Base | PostgreSQL 17 + TimescaleDB | `db` | Initialise |
|
||||
| ETL | Apache Airflow | `etl/airflow` | A initialiser |
|
||||
| Infra | Terraform (k3s single-node) | `infra/terraform` | Initialise |
|
||||
| CI/CD | GitHub Actions | `.github/workflows` | A initialiser |
|
||||
| Monitoring | Prometheus, Grafana, Alertmanager | `monitoring` | A initialiser |
|
||||
|
||||
Toutes ces briques tournent sur la machine du groupe, en trois environnements (production,
|
||||
recette, dev). Le frontend sert le tableau de bord, les vues sites, recommandations et
|
||||
supervision des capteurs, toutes branchées sur l'API réelle : les fixtures sont coupées
|
||||
(`useMockFixtures: false`). Le module Terraform k3s reste une cible, écrite et validée, jamais
|
||||
appliquée.
|
||||
|
||||
L'etat detaille de chaque brique et les vues d'architecture sont dans
|
||||
[docs/architecture](docs/architecture/README.md).
|
||||
Le backend, la base et l'infrastructure (Terraform/k3s) sont initialises a ce stade. Les autres dossiers
|
||||
portent l'arborescence et un README de cadrage, leur contenu fait l'objet d'un ticket dedie.
|
||||
|
||||
## Arborescence
|
||||
|
||||
@@ -51,140 +28,57 @@ L'etat detaille de chaque brique et les vues d'architecture sont dans
|
||||
├── db/
|
||||
│ ├── init/ Bootstrap PostgreSQL + TimescaleDB
|
||||
│ ├── migrations/ Migrations SQL versionnees
|
||||
│ ├── roles/ Roles PostgreSQL hors schema (supervision)
|
||||
│ └── seeds/ Jeu de demonstration des tests
|
||||
│ └── seeds/ Jeux de donnees de reference
|
||||
├── etl/airflow/
|
||||
│ ├── dags/ DAGs d'orchestration (pipeline ML, alertes, imports, dérive, rétention)
|
||||
│ ├── dags/ DAGs d'ingestion et d'agregation
|
||||
│ ├── plugins/ Operateurs et hooks maison
|
||||
│ ├── include/ Requetes SQL et ressources des DAGs
|
||||
│ └── tests/ Tests d'integrite des DAGs
|
||||
├── infra/
|
||||
│ ├── front/ Frontal SNI de la machine : ports 80 et 443, aiguillage par nom
|
||||
│ ├── garage/ Stockage objet S3 : configuration sans secret
|
||||
│ ├── proxy/ Reverse proxy Nginx : terminaison TLS et routage
|
||||
│ └── terraform/
|
||||
│ ├── modules/ Modules reutilisables
|
||||
│ └── environments/ Racines Terraform, une par environnement
|
||||
├── ml/ Pipeline d'entrainement LightGBM, suivi MLflow
|
||||
├── infra/terraform/
|
||||
│ ├── modules/ Modules reutilisables
|
||||
│ └── environments/ Racines Terraform, une par environnement
|
||||
├── monitoring/
|
||||
│ ├── prometheus/ Collecte et regles d'alerte
|
||||
│ ├── grafana/ Provisioning et dashboards
|
||||
│ └── alertmanager/ Routage des alertes
|
||||
├── tests/
|
||||
│ ├── e2e/ Parcours Playwright contre la stack
|
||||
│ ├── garage/ Tests de fumée S3 joués par la CI contre Garage
|
||||
│ └── load/ Scenarios de charge k6
|
||||
├── docs/ ADR, vues d'architecture, runbook de pilotage, livrables de rendu
|
||||
├── docs/ ADR et vues d'architecture
|
||||
└── scripts/ Outillage local
|
||||
```
|
||||
|
||||
## Demarrage
|
||||
|
||||
Prerequis : uv, Docker, Node 26 (version de la CI et de l'image frontend, npm fourni). Le poste doit disposer de Python 3.14, que
|
||||
`uv` installe seul.
|
||||
Prerequis : uv, Docker. Le poste doit disposer de Python 3.14, que `uv` installe seul.
|
||||
|
||||
```bash
|
||||
cp .env.example .env # variables de docker-compose
|
||||
cp apps/backend/.env.example apps/backend/.env # variables du backend hors conteneur
|
||||
|
||||
make install # dependances du backend, du frontend, du ML et des DAGs
|
||||
make dev # toute la stack, voir ci-dessous
|
||||
make db-up # PostgreSQL + TimescaleDB, publie sur le port 5433
|
||||
make install # dependances du backend
|
||||
make migrate # applique les migrations Alembic
|
||||
make dev # API sur http://localhost:8000, docs sur /docs
|
||||
make check # lint + typage + tests
|
||||
```
|
||||
|
||||
`make dev` enchaine tout : demarrage des services conteneurises (base sur le port 5433, Mailpit,
|
||||
Airflow), migrations Alembic, peuplement de demonstration si les alertes manquent, puis backend
|
||||
et frontend en rechargement a chaud sur le poste.
|
||||
|
||||
| Service | Adresse |
|
||||
|---|---|
|
||||
| Backend | <http://localhost:8000> (documentation sur `/docs`) |
|
||||
| Frontend | <http://localhost:4200> |
|
||||
| Airflow | <http://localhost:8080> (`AIRFLOW_ADMIN_USERNAME` / `AIRFLOW_ADMIN_PASSWORD` du `.env`) |
|
||||
| Mailpit | <http://localhost:8025> |
|
||||
|
||||
Le `.env` doit porter les cles Airflow avant le premier `make dev` : `AIRFLOW_FERNET_KEY`,
|
||||
`AIRFLOW_API_SECRET_KEY`, `AIRFLOW_JWT_SECRET`, `AIRFLOW_APP_SECRET_KEY` et
|
||||
`AIRFLOW_ADMIN_PASSWORD`. Sans elles `airflow-init` refuse de demarrer, et `airflow-apiserver`,
|
||||
`airflow-scheduler` et `airflow-dag-processor` avec lui. Il doit aussi porter les six clés
|
||||
`GARAGE_*` (rpc, jetons, clé S3, clé SSE-C) : `make services-up` refuse sinon de démarrer Garage,
|
||||
où le DAG `retention` archive les mesures anciennes ([ADR 0019](docs/adr/0019-stockage-objet-garage-et-cycle-de-vie-des-mesures.md)).
|
||||
|
||||
Les cibles d'origine restent disponibles pour ne demarrer qu'une partie : `make db-up`,
|
||||
`make airflow-up`, `make dev-backend`, `make dev-frontend`.
|
||||
|
||||
`make help` liste les cibles disponibles.
|
||||
|
||||
Deux fichiers d'environnement, deux usages : `.env` a la racine alimente `docker-compose.yml`,
|
||||
`apps/backend/.env` alimente le backend lance sur le poste. Le port 5433 est publie plutot que
|
||||
5432, souvent deja pris par une autre base.
|
||||
|
||||
Le backend et le frontend tournent sur le poste, lances ensemble par `make dev` (logs
|
||||
entrelaces dans le meme terminal, Ctrl+C arrete les deux) ; la base, Mailpit et Airflow tournent
|
||||
en conteneur. Le service `backend` du `docker-compose.yml` sert la stack complete et la recette,
|
||||
La boucle de developpement est `make db-up` puis `make dev` : seule la base tourne en
|
||||
conteneur. Le service `backend` du `docker-compose.yml` sert la stack complete et la recette,
|
||||
et n'embarque pas le source, donc toute modification y demande un
|
||||
`docker compose up -d --build backend`.
|
||||
|
||||
### Donnees de demonstration
|
||||
|
||||
Le jeu historique s'arrete au 31/12/2024. `make demo-data` renseigne les tables que les vues
|
||||
alertes, recommandations et previsions lisent, en ancrant le scoring et la detection a cette
|
||||
date (`DEMO_NOW`) plutot qu'a l'horloge reelle, qui ne verrait qu'un parc muet depuis des mois.
|
||||
La cible ne fait rien si des alertes existent deja ; `make demo-data-force` rejoue les trois
|
||||
etapes, toutes idempotentes en base.
|
||||
|
||||
Un volume `pgdata` cree avant `db/init/120-airflow-database.sql` n'a pas de base `airflow` :
|
||||
`db/init` ne rejoue qu'a la premiere initialisation. `make db-ensure-airflow`, appelee par
|
||||
`make dev` et `make airflow-up`, la cree au besoin, sans detruire les donnees applicatives.
|
||||
|
||||
Verifier que la base repond et que l'extension est chargee :
|
||||
|
||||
```bash
|
||||
curl -s localhost:8000/api/v1/health/ready
|
||||
```
|
||||
|
||||
## Stack complète derrière le reverse proxy
|
||||
|
||||
Pour servir l'application comme sur la machine cible, en HTTPS et sous une seule origine.
|
||||
L'overlay emploie `!override` et `!reset`, donc **Docker Compose 2.24.4 ou plus récent** :
|
||||
|
||||
```bash
|
||||
make tls-selfsigned PUBLIC_HOST=enervision.local # certificat de démonstration
|
||||
make stack-up PUBLIC_HOST=enervision.local # nginx en 80/443, le reste sur 127.0.0.1
|
||||
```
|
||||
|
||||
Le navigateur avertit d'un émetteur inconnu : sur le poste, le certificat est auto-signé. Sur la
|
||||
machine, les certificats viennent de Let's Encrypt par défi DNS-01
|
||||
([ADR 0018](docs/adr/0018-noms-publics-certificats-dns01-et-frontal-sni.md)). Routage, mode ACME et renouvellement dans
|
||||
[`infra/proxy/README.md`](infra/proxy/README.md) ; la décision et ses motifs dans
|
||||
[l'ADR 0007](docs/adr/0007-terminaison-tls-et-reverse-proxy-nginx.md).
|
||||
|
||||
Sur la VM ENI, trois environnements cohabitent, production sur `main`, recette sur `dev`, et
|
||||
`dev` pour toute autre branche lancée à la main
|
||||
([ADR 0017](docs/adr/0017-environnement-dev-a-la-demande.md)), chacun dans son dossier et son
|
||||
projet Compose, derrière un frontal SNI commun : `scripts/provision-host.sh` les prépare, le
|
||||
workflow `deploy.yml` les redéploie par un runner auto-hébergé, une fois la CI du commit poussé
|
||||
verte ([ADR 0014](docs/adr/0014-pipeline-ci-unique-et-deploiement-conditionne.md)). Ports, noms
|
||||
d'hôte et garde-fous dans [`docs/architecture/10-infra.md`](docs/architecture/10-infra.md) et
|
||||
[l'ADR 0009](docs/adr/0009-deux-environnements-compose-sur-la-vm-eni.md).
|
||||
|
||||
## Tests de bout en bout, charge et supervision
|
||||
|
||||
| Besoin | Commandes | Détail |
|
||||
|---|---|---|
|
||||
| Parcours utilisateur (Playwright) | `make e2e-install`, puis `make e2e-prepare e2e` contre `make dev` | [`tests/e2e/README.md`](tests/e2e/README.md) |
|
||||
| Tir de charge (k6) | `make load-smoke`, `load-test`, `load-stress`, `load-limits` | [`tests/load/README.md`](tests/load/README.md) |
|
||||
| Supervision | `make monitoring-up`, Grafana sur <http://localhost:3001> | [`monitoring/README.md`](monitoring/README.md) |
|
||||
|
||||
La CI joue les parcours, un tir de fumée et le contrôle de la limitation de débit à chaque PR
|
||||
qui touche l'application, contre la stack de prod derrière le proxy
|
||||
([ADR 0015](docs/adr/0015-tests-e2e-et-de-charge-contre-la-stack-compose.md)). La supervision
|
||||
est active en prod, à la demande ailleurs
|
||||
([ADR 0016](docs/adr/0016-supervision-en-profil-compose.md)).
|
||||
|
||||
## Conventions
|
||||
|
||||
- Branches : `feat/`, `fix/`, `chore/`, `docs/`, `test/` suivi d'un libelle court.
|
||||
- Commits : Conventional Commits, portee = dossier de premier niveau concerne.
|
||||
- Toute decision structurante donne lieu a un ADR dans `docs/adr`.
|
||||
- Toute PR qui change un composant met a jour sa vue dans `docs/architecture`, dans la meme PR.
|
||||
|
||||
@@ -1,24 +1,6 @@
|
||||
APP_ENV=local
|
||||
APP_DEBUG=false
|
||||
APP_DEBUG=true
|
||||
APP_LOG_LEVEL=INFO
|
||||
|
||||
# L'API refuse de démarrer tant que cette valeur reste un exemple ou fait moins de
|
||||
# 32 caractères. Générer la vôtre : python -c "import secrets; print(secrets.token_urlsafe(48))"
|
||||
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
|
||||
APP_MOCK_API_BASE_URL=https://api-mock.charlieandre.fr
|
||||
APP_MOCK_API_USERNAME=change_me
|
||||
APP_MOCK_API_PASSWORD=change_me
|
||||
APP_MOCK_API_TIMEOUT_SECONDS=10
|
||||
|
||||
@@ -11,14 +11,13 @@ WORKDIR /app
|
||||
RUN --mount=type=cache,target=/root/.cache/uv \
|
||||
--mount=type=bind,source=uv.lock,target=uv.lock \
|
||||
--mount=type=bind,source=pyproject.toml,target=pyproject.toml \
|
||||
uv sync --locked --no-install-project --no-dev --no-build
|
||||
uv sync --locked --no-install-project --no-dev
|
||||
|
||||
# Le projet lui-meme n'est pas installe (pas de second `uv sync`) : il tourne depuis /app, le
|
||||
# repertoire de travail, et rien ne lit ses metadonnees. L'installer imposerait de le construire
|
||||
# (backend hatchling), donc de retirer `--no-build` de l'etape ci-dessus, qui garantit que
|
||||
# l'installation des dependances n'execute aucun script de build (regle Sonar docker:S8541).
|
||||
COPY . /app
|
||||
|
||||
RUN --mount=type=cache,target=/root/.cache/uv \
|
||||
uv sync --locked --no-dev
|
||||
|
||||
|
||||
FROM python:3.14-slim AS runtime
|
||||
|
||||
|
||||
+11
-58
@@ -28,7 +28,7 @@ de demarrer sans elles.
|
||||
## Commandes
|
||||
|
||||
Depuis la racine du monorepo, via le `Makefile` : `make install`, `make dev`, `make lint`,
|
||||
`make format`, `make typecheck`, `make test`, `make check`, `make openapi`, `make docker-build`.
|
||||
`make format`, `make typecheck`, `make test`, `make check`, `make docker-build`.
|
||||
|
||||
Directement depuis ce dossier :
|
||||
|
||||
@@ -39,12 +39,8 @@ uv run ruff format . # format
|
||||
uv run mypy app # typage strict
|
||||
uv run pytest # tests + couverture
|
||||
uv run pytest -m integration # tests exigeant une base joignable
|
||||
uv run python -m app.cli export-openapi # régénère openapi.json
|
||||
```
|
||||
|
||||
`openapi.json` est versionné : `tests/api/test_openapi.py` échoue si le fichier ne correspond
|
||||
plus aux routes déclarées. Toute PR qui change une route le régénère dans le même commit.
|
||||
|
||||
Les conventions de tests, les gabarits et le detail des marqueurs sont dans
|
||||
[`TESTING.md`](TESTING.md).
|
||||
|
||||
@@ -61,21 +57,13 @@ independants de l'environnement.
|
||||
```
|
||||
app/
|
||||
├── api/
|
||||
│ ├── deps.py Dépendances partagées : session, settings, principal, gardes de rôle
|
||||
│ ├── errors.py Gestionnaires 422 et 500
|
||||
│ ├── middleware.py En-têtes de sécurité
|
||||
│ ├── security.py Garde du point /metrics
|
||||
│ ├── deps.py Dependances FastAPI partagees (session, settings)
|
||||
│ └── v1/
|
||||
│ ├── router.py Agrégation des routes de la version 1
|
||||
│ └── endpoints/ Un module par ressource exposée
|
||||
│ ├── router.py Agregation des routes de la version 1
|
||||
│ └── endpoints/ Un module par ressource exposee
|
||||
├── core/
|
||||
│ ├── config.py Settings Pydantic, source unique de configuration
|
||||
│ ├── cookies.py Attributs du cookie de rafraîchissement
|
||||
│ ├── hashing.py Argon2id, poussé dans un fil sous limiteur
|
||||
│ ├── logging.py Journalisation console en local, JSON en production
|
||||
│ ├── principal.py L'identité que voit le code métier
|
||||
│ ├── roles.py Rôles ordonnés
|
||||
│ └── security.py Encodage et décodage des jetons d'accès
|
||||
│ └── logging.py Journalisation console en local, JSON en production
|
||||
├── db/
|
||||
│ ├── base.py Base declarative SQLAlchemy
|
||||
│ └── session.py Engine et sessions asynchrones
|
||||
@@ -83,7 +71,6 @@ app/
|
||||
├── schemas/ Modeles Pydantic d'entree et de sortie
|
||||
├── repositories/ Acces aux donnees, une classe par agregat
|
||||
├── services/ Regles metier, orchestrent les repositories
|
||||
├── cli.py Commandes hors HTTP, dont l'amorcage du premier admin
|
||||
└── main.py Factory applicative
|
||||
tests/ Miroir de app/
|
||||
alembic/ Migrations du schema applicatif
|
||||
@@ -94,46 +81,12 @@ Le sens de dependance est unique : `endpoints` vers `services` vers `repositorie
|
||||
|
||||
## Routes
|
||||
|
||||
| Route | Rôle | Accès |
|
||||
|---|---|---|
|
||||
| `/api/v1/health/live` | Sonde de vivacité, aucune dépendance externe | public |
|
||||
| `/api/v1/health/ready` | Sonde de disponibilité, vérifie la base et TimescaleDB | public |
|
||||
| `/api/v1/auth/login` | Ouvre une session | public |
|
||||
| `/api/v1/auth/refresh` | Fait tourner la session | cookie |
|
||||
| `/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` |
|
||||
| `/api/v1/users/{id}/password-reset` | Réinitialise et ferme les sessions | `admin` |
|
||||
| `/api/v1/sites` | Liste les sites | `lecteur` |
|
||||
| `/api/v1/sites/{site_id}` | Décrit un site | `lecteur` |
|
||||
| `/api/v1/recommendations` | Liste les recommandations | `lecteur` |
|
||||
| `/api/v1/recommendations/{recommendation_id}` | Décrit une recommandation | `lecteur` |
|
||||
| `/api/v1/recommendations/generate` | Génère les recommandations depuis les alertes (POST) | `admin` |
|
||||
| `/metrics` | Métriques au format Prometheus | jeton si `APP_METRICS_TOKEN` |
|
||||
| `/docs`, `/openapi.json` | Documentation, fermée en `staging` et `prod` | public sinon |
|
||||
|
||||
Le contrat détaillé pour le frontend est dans
|
||||
[`docs/architecture/31-contrat-authentification.md`](../../docs/architecture/31-contrat-authentification.md).
|
||||
|
||||
## Premier administrateur
|
||||
|
||||
Aucun compte n'existe après les migrations. Il s'en crée un en ligne de commande :
|
||||
|
||||
```bash
|
||||
make bootstrap-admin EMAIL=prenom.nom@enervision.fr # mot de passe saisi au clavier
|
||||
# ou, depuis apps/backend :
|
||||
uv run python -m app.cli create-admin --email prenom.nom@enervision.fr --generate
|
||||
```
|
||||
|
||||
Le compte est créé avec `must_change_password`, donc la première connexion ne donne accès qu'à
|
||||
`/auth/me` et `/auth/password` jusqu'au changement. Le mot de passe ne transite jamais par
|
||||
`argv`, visible de tout `ps`, et aucune révision Alembic n'insère de compte : son empreinte
|
||||
resterait dans Git pour toujours.
|
||||
| Route | Role |
|
||||
|------------------------|-------------------------------------------------|
|
||||
| `/api/v1/health/live` | Sonde de vivacite, aucune dependance externe |
|
||||
| `/api/v1/health/ready` | Sonde de disponibilite, verifie la base et TimescaleDB |
|
||||
| `/metrics` | Metriques au format Prometheus |
|
||||
| `/docs`, `/openapi.json` | Documentation, desactivee quand `APP_ENV=prod` |
|
||||
|
||||
## Migrations
|
||||
|
||||
|
||||
@@ -123,11 +123,6 @@ async def test_repository_reads_back_what_it_wrote(session: AsyncSession) -> Non
|
||||
defaut, ce qui garde `make check` jouable sans Docker. Tout autre marqueur doit etre
|
||||
declare dans `pyproject.toml` : `--strict-markers` refuse les marqueurs inconnus.
|
||||
|
||||
Ces tests ne sont pas pour autant facultatifs : le job `integration` de
|
||||
`.github/workflows/backend.yml` monte un service TimescaleDB, applique les migrations et
|
||||
les joue a chaque poussee. Un test `integration` casse donc la CI comme un autre. En local,
|
||||
`make db-up` puis `make test-integration`.
|
||||
|
||||
## Couverture
|
||||
|
||||
Les branches sont mesurees, pas seulement les lignes. Le seuil de 85 % ne s'applique
|
||||
@@ -146,48 +141,3 @@ make check # lint + typage + suite unitaire
|
||||
uv run pytest tests/api/test_health.py # un seul fichier
|
||||
uv run pytest -k readiness # par motif de nom
|
||||
```
|
||||
|
||||
## Quatre fichiers à connaître avant de toucher à l'authentification
|
||||
|
||||
`tests/api/acces.py` porte la classification des routes du contrat, en quatre ensembles :
|
||||
`ROUTES_PUBLIQUES`, `ROUTE_COOKIE`, `ROUTES_SANS_ROLE` et la table `ROLE_MINIMUM`. Ce n'est pas
|
||||
un fichier de test, c'est la référence que les trois autres confrontent au comportement observé.
|
||||
**Toute route ajoutée doit y être classée** : `test_every_declared_route_is_classified` échoue
|
||||
sinon, et échoue aussi sur une entrée qui ne correspond plus à aucune route.
|
||||
|
||||
`tests/api/test_route_protection.py` interroge réellement chaque route sans identifiant et
|
||||
échoue si l'une d'elles répond autre chose qu'un 401 ou un 403. Il n'inspecte pas l'arbre de
|
||||
dépendances : celui-ci n'est accessible que par l'API privée de FastAPI, et surtout une route
|
||||
peut porter la bonne dépendance tout en répondant quand même. **Rendre une route publique impose
|
||||
donc de modifier `ROUTES_PUBLIQUES` dans `acces.py`**, ce qui apparaît en clair dans la diff
|
||||
d'une pull request.
|
||||
|
||||
`tests/api/test_matrice_acces.py` croise chaque route gardée avec chacun des trois rôles, dans
|
||||
les deux sens : un rôle insuffisant reçoit un 403 `Droits insuffisants`, un rôle suffisant ne le
|
||||
reçoit jamais. Le second sens est ce qui rend visible une garde posée trop haut, par exemple
|
||||
`AdminDep` sur une route de lecture. La même matrice est rejouée sous `integration` avec de vrais
|
||||
jetons, donc en traversant le décodage du JWT et la relecture du compte en base, que
|
||||
`dependency_overrides` court-circuite.
|
||||
|
||||
`tests/services/test_auth.py` donne au faux hacheur un **compteur d'appels**. C'est ce qui rend
|
||||
possibles les deux assertions qui prouvent la conception, et qu'aucune autre forme de test
|
||||
n'atteint :
|
||||
|
||||
- adresse inconnue → le compteur vaut 1, donc le haché leurre a bien été vérifié et il n'y a pas
|
||||
d'oracle temporel ;
|
||||
- limite de débit atteinte → le compteur vaut 0, donc la limite est évaluée avant Argon2.
|
||||
|
||||
`tests/api/test_parcours_authentification.py` joue six parcours complets contre la vraie base,
|
||||
sous le marqueur `integration`, sans serveur ni port ouvert. C'est là que se démontrent
|
||||
l'atomicité de la rotation, la mort de la famille au rejeu d'un cookie déjà tourné, et la
|
||||
révocation immédiate d'un compte désactivé.
|
||||
|
||||
## Deux pièges d'écriture de test
|
||||
|
||||
**Lire les attributs avant le `rollback`.** Un `session.rollback()` périme les attributs chargés,
|
||||
et les relire déclenche une entrée-sortie hors du contexte greenlet, donc un `MissingGreenlet`.
|
||||
On capture la valeur dans une variable locale avant d'annuler.
|
||||
|
||||
**`audit_log` ne se nettoie pas.** La table est en ajout seul, garanti par déclencheur : un test
|
||||
ne peut pas effacer ce qu'il y écrit, et les lignes d'une exécution précédente sont encore là.
|
||||
Chaque test filtre donc sur son propre `target_id` plutôt que de supposer une table vide.
|
||||
|
||||
@@ -19,7 +19,7 @@ config = context.config
|
||||
if config.config_file_name is not None:
|
||||
fileConfig(config.config_file_name)
|
||||
|
||||
config.set_main_option("sqlalchemy.url", get_settings().database_url.replace("%", "%%"))
|
||||
config.set_main_option("sqlalchemy.url", get_settings().database_url)
|
||||
|
||||
target_metadata = Base.metadata
|
||||
|
||||
|
||||
-119
@@ -1,119 +0,0 @@
|
||||
"""tentatives de connexion et journal d audit
|
||||
|
||||
Revision ID: 517053a3c044
|
||||
Revises: b1a7c3d9e240
|
||||
Create Date: 2026-09-15 14:31:07.966180
|
||||
|
||||
Deux tables aux vocations opposees. `login_attempt` est le compteur de la limitation
|
||||
de debit : son volume est pilote par l'attaquant, donc elle se purge. `audit_log` est
|
||||
en ajout seul, garanti par deux declencheurs.
|
||||
|
||||
Le declencheur TRUNCATE n'est pas redondant : TRUNCATE ne passe pas par les
|
||||
declencheurs de ligne. Et RAISE EXCEPTION plutot qu'un RETURN NULL, qui annulerait
|
||||
l'operation silencieusement.
|
||||
"""
|
||||
|
||||
from collections.abc import Sequence
|
||||
|
||||
import sqlalchemy as sa
|
||||
from alembic import op
|
||||
from sqlalchemy.dialects import postgresql
|
||||
|
||||
revision: str = "517053a3c044"
|
||||
down_revision: str | Sequence[str] | None = "b1a7c3d9e240"
|
||||
branch_labels: str | Sequence[str] | None = None
|
||||
depends_on: str | Sequence[str] | None = None
|
||||
|
||||
FONCTION_AJOUT_SEUL = """
|
||||
CREATE FUNCTION audit_log_append_only() RETURNS trigger AS $$
|
||||
BEGIN
|
||||
RAISE EXCEPTION 'audit_log est en ajout seul : % interdit', TG_OP;
|
||||
END
|
||||
$$ LANGUAGE plpgsql;
|
||||
"""
|
||||
|
||||
DECLENCHEUR_LIGNE = """
|
||||
CREATE TRIGGER audit_log_no_update_delete
|
||||
BEFORE UPDATE OR DELETE ON audit_log
|
||||
FOR EACH ROW EXECUTE FUNCTION audit_log_append_only();
|
||||
"""
|
||||
|
||||
DECLENCHEUR_TRUNCATE = """
|
||||
CREATE TRIGGER audit_log_no_truncate
|
||||
BEFORE TRUNCATE ON audit_log
|
||||
FOR EACH STATEMENT EXECUTE FUNCTION audit_log_append_only();
|
||||
"""
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
op.create_table(
|
||||
"login_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.Column("outcome", sa.Text(), nullable=False),
|
||||
sa.Column("user_id", sa.UUID(), nullable=True),
|
||||
sa.CheckConstraint(
|
||||
"outcome in ('success', 'bad_credentials', 'throttled', 'inactive')",
|
||||
name="ck_login_attempt_outcome",
|
||||
),
|
||||
sa.PrimaryKeyConstraint("id", name="pk_login_attempt"),
|
||||
)
|
||||
op.create_index(
|
||||
"ix_login_attempt_email_date", "login_attempt", ["email_tried", "occurred_at"]
|
||||
)
|
||||
op.create_index("ix_login_attempt_ip_date", "login_attempt", ["client_ip", "occurred_at"])
|
||||
|
||||
op.create_table(
|
||||
"audit_log",
|
||||
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("actor_id", sa.UUID(), nullable=True),
|
||||
sa.Column("actor_email", sa.Text(), nullable=True),
|
||||
sa.Column("actor_role", sa.Text(), nullable=True),
|
||||
sa.Column("action", sa.Text(), nullable=False),
|
||||
sa.Column("target_type", sa.Text(), nullable=True),
|
||||
sa.Column("target_id", sa.Text(), nullable=True),
|
||||
sa.Column("outcome", sa.Text(), nullable=False),
|
||||
sa.Column("client_ip", postgresql.INET(), nullable=True),
|
||||
sa.Column("user_agent", sa.Text(), nullable=True),
|
||||
sa.Column(
|
||||
"detail",
|
||||
postgresql.JSONB(astext_type=sa.Text()),
|
||||
server_default=sa.text("jsonb_build_object()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.CheckConstraint("outcome in ('success', 'failure')", name="ck_audit_log_outcome"),
|
||||
sa.PrimaryKeyConstraint("id", name="pk_audit_log"),
|
||||
)
|
||||
op.create_index("ix_audit_log_date", "audit_log", ["occurred_at"])
|
||||
op.create_index("ix_audit_log_action_date", "audit_log", ["action", "occurred_at"])
|
||||
|
||||
op.execute(FONCTION_AJOUT_SEUL)
|
||||
op.execute(DECLENCHEUR_LIGNE)
|
||||
op.execute(DECLENCHEUR_TRUNCATE)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
op.execute("DROP TRIGGER IF EXISTS audit_log_no_truncate ON audit_log;")
|
||||
op.execute("DROP TRIGGER IF EXISTS audit_log_no_update_delete ON audit_log;")
|
||||
op.execute("DROP FUNCTION IF EXISTS audit_log_append_only();")
|
||||
|
||||
op.drop_index("ix_audit_log_action_date", table_name="audit_log")
|
||||
op.drop_index("ix_audit_log_date", table_name="audit_log")
|
||||
op.drop_table("audit_log")
|
||||
|
||||
op.drop_index("ix_login_attempt_ip_date", table_name="login_attempt")
|
||||
op.drop_index("ix_login_attempt_email_date", table_name="login_attempt")
|
||||
op.drop_table("login_attempt")
|
||||
@@ -1,77 +0,0 @@
|
||||
"""jetons de rafraichissement
|
||||
|
||||
Revision ID: 821f71be74c0
|
||||
Revises: 517053a3c044
|
||||
Create Date: 2026-09-15 14:42:09.757949
|
||||
|
||||
Le jeton lui-meme n'est jamais stocke : seule son empreinte SHA-256 l'est, dans
|
||||
`token_hash`. Un pg_dump qui fuiterait ne livrerait donc aucune session utilisable.
|
||||
|
||||
L'index partiel `ix_refresh_token_vivants` sert la revocation en cascade et la
|
||||
recherche des sessions actives, qui ne regardent jamais les lignes deja tournees.
|
||||
"""
|
||||
|
||||
from collections.abc import Sequence
|
||||
|
||||
import sqlalchemy as sa
|
||||
from alembic import op
|
||||
from sqlalchemy.dialects import postgresql
|
||||
|
||||
revision: str = "821f71be74c0"
|
||||
down_revision: str | Sequence[str] | None = "517053a3c044"
|
||||
branch_labels: str | Sequence[str] | None = None
|
||||
depends_on: str | Sequence[str] | None = None
|
||||
|
||||
MOTIFS = "'logout', 'rotation', 'reuse_detected', 'password_change', 'admin'"
|
||||
JETONS_VIVANTS = "revoked_at is null and rotated_at is null"
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
op.create_table(
|
||||
"refresh_token",
|
||||
sa.Column(
|
||||
"id", sa.UUID(), server_default=sa.text("gen_random_uuid()"), nullable=False
|
||||
),
|
||||
sa.Column("family_id", sa.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("rotated_at", sa.DateTime(timezone=True), nullable=True),
|
||||
sa.Column("revoked_at", sa.DateTime(timezone=True), nullable=True),
|
||||
sa.Column("revoked_reason", sa.Text(), nullable=True),
|
||||
sa.Column("replaced_by", sa.UUID(), nullable=True),
|
||||
sa.Column("client_ip", postgresql.INET(), nullable=True),
|
||||
sa.Column("user_agent", sa.Text(), nullable=True),
|
||||
sa.CheckConstraint(
|
||||
f"revoked_reason is null or revoked_reason in ({MOTIFS})",
|
||||
name="ck_refresh_token_revoked_reason",
|
||||
),
|
||||
sa.ForeignKeyConstraint(
|
||||
["user_id"], ["app_user.id"], name="fk_refresh_token_user", ondelete="CASCADE"
|
||||
),
|
||||
sa.PrimaryKeyConstraint("id", name="pk_refresh_token"),
|
||||
sa.UniqueConstraint("token_hash", name="uq_refresh_token_hash"),
|
||||
)
|
||||
op.create_index("ix_refresh_token_family", "refresh_token", ["family_id"])
|
||||
op.create_index("ix_refresh_token_user", "refresh_token", ["user_id"])
|
||||
op.create_index(
|
||||
"ix_refresh_token_vivants",
|
||||
"refresh_token",
|
||||
["user_id"],
|
||||
postgresql_where=JETONS_VIVANTS,
|
||||
)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
op.drop_index(
|
||||
"ix_refresh_token_vivants", table_name="refresh_token", postgresql_where=JETONS_VIVANTS
|
||||
)
|
||||
op.drop_index("ix_refresh_token_user", table_name="refresh_token")
|
||||
op.drop_index("ix_refresh_token_family", table_name="refresh_token")
|
||||
op.drop_table("refresh_token")
|
||||
@@ -1,72 +0,0 @@
|
||||
"""comptes applicatifs
|
||||
|
||||
Revision ID: b1a7c3d9e240
|
||||
Revises: 5353c0e4f094
|
||||
Create Date: 2026-09-15 14:40:00.000000
|
||||
|
||||
Cree `app_user`, la table des comptes humains et de service. Le nom evite `user`,
|
||||
mot reserve de PostgreSQL. `gen_random_uuid()` est au coeur de PG17, aucune
|
||||
extension n'est necessaire.
|
||||
"""
|
||||
|
||||
from collections.abc import Sequence
|
||||
|
||||
import sqlalchemy as sa
|
||||
from alembic import op
|
||||
from sqlalchemy.dialects import postgresql
|
||||
|
||||
revision: str = "b1a7c3d9e240"
|
||||
down_revision: str | Sequence[str] | None = "5353c0e4f094"
|
||||
branch_labels: str | Sequence[str] | None = None
|
||||
depends_on: str | Sequence[str] | None = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
op.create_table(
|
||||
"app_user",
|
||||
sa.Column(
|
||||
"id",
|
||||
postgresql.UUID(as_uuid=True),
|
||||
server_default=sa.text("gen_random_uuid()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column("email", sa.String(length=320), nullable=False),
|
||||
sa.Column("password_hash", sa.Text(), nullable=False),
|
||||
sa.Column("role", sa.Text(), nullable=False),
|
||||
sa.Column("kind", sa.Text(), server_default=sa.text("'human'"), nullable=False),
|
||||
sa.Column("is_active", sa.Boolean(), server_default=sa.text("true"), nullable=False),
|
||||
sa.Column(
|
||||
"must_change_password", sa.Boolean(), server_default=sa.text("false"), nullable=False
|
||||
),
|
||||
sa.Column(
|
||||
"credentials_changed_at",
|
||||
sa.DateTime(timezone=True),
|
||||
server_default=sa.text("now()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column("last_login_at", sa.DateTime(timezone=True), nullable=True),
|
||||
sa.Column("full_name", sa.Text(), nullable=True),
|
||||
sa.Column(
|
||||
"created_at",
|
||||
sa.DateTime(timezone=True),
|
||||
server_default=sa.text("now()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column(
|
||||
"updated_at",
|
||||
sa.DateTime(timezone=True),
|
||||
server_default=sa.text("now()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.CheckConstraint("email = lower(email)", name="ck_app_user_email_minuscule"),
|
||||
sa.CheckConstraint(
|
||||
"role in ('lecteur', 'operateur', 'admin')", name="ck_app_user_role"
|
||||
),
|
||||
sa.CheckConstraint("kind in ('human', 'service')", name="ck_app_user_kind"),
|
||||
sa.PrimaryKeyConstraint("id", name="pk_app_user"),
|
||||
sa.UniqueConstraint("email", name="uq_app_user_email"),
|
||||
)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
op.drop_table("app_user")
|
||||
@@ -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")
|
||||
@@ -1,81 +0,0 @@
|
||||
"""rapports de derive du modele de prevision
|
||||
|
||||
Revision ID: d3f1a2b7c904
|
||||
Revises: c0adab96238c
|
||||
Create Date: 2026-09-22 14:40:00.000000
|
||||
|
||||
`site_id` est nullable, et c'est le coeur du schema : une ligne par site, plus une ligne
|
||||
globale tous sites confondus, que `NULL` designe. Un seul site qui derive est invisible dans
|
||||
une moyenne d'ensemble, et une derive d'ensemble sans rupture par site signale un changement
|
||||
de modele ou de saison, pas une panne.
|
||||
|
||||
L'unicite passe par un index a `coalesce` et non par une `UniqueConstraint` : deux lignes
|
||||
globales successives ont toutes deux `site_id` a NULL, et NULL n'est egal a aucune valeur, pas
|
||||
meme a lui-meme. Meme forme que `uq_reading_source`.
|
||||
|
||||
Les trois `CHECK` sont portees par la base, comme `ck_prediction_status` : un verdict sans
|
||||
motif, ou un statut inconnu, ne doit pas dependre de la vigilance de l'appelant.
|
||||
"""
|
||||
|
||||
from collections.abc import Sequence
|
||||
|
||||
import sqlalchemy as sa
|
||||
from alembic import op
|
||||
from sqlalchemy.dialects import postgresql
|
||||
|
||||
revision: str = "d3f1a2b7c904"
|
||||
down_revision: str | Sequence[str] | None = "c0adab96238c"
|
||||
branch_labels: str | Sequence[str] | None = None
|
||||
depends_on: str | Sequence[str] | None = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
op.create_table(
|
||||
"drift_report",
|
||||
sa.Column("drift_report_id", sa.BigInteger(), autoincrement=True, nullable=False),
|
||||
sa.Column(
|
||||
"computed_at",
|
||||
sa.DateTime(timezone=True),
|
||||
server_default=sa.text("now()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column("site_id", sa.Text(), nullable=True),
|
||||
sa.Column("window_start", sa.DateTime(timezone=True), nullable=False),
|
||||
sa.Column("window_end", sa.DateTime(timezone=True), nullable=False),
|
||||
sa.Column("reference_start", sa.DateTime(timezone=True), nullable=True),
|
||||
sa.Column("reference_end", sa.DateTime(timezone=True), nullable=True),
|
||||
sa.Column("n_observations", sa.Integer(), nullable=False),
|
||||
sa.Column("mae", sa.Double(), nullable=True),
|
||||
sa.Column("mape", sa.Double(), nullable=True),
|
||||
sa.Column("bias", sa.Double(), nullable=True),
|
||||
sa.Column("reference_mae", sa.Double(), nullable=True),
|
||||
sa.Column("coverage_ratio", sa.Double(), nullable=True),
|
||||
sa.Column("insufficient_data_ratio", sa.Double(), nullable=True),
|
||||
sa.Column("model_references", postgresql.ARRAY(sa.Text()), nullable=False),
|
||||
sa.Column("status", sa.Text(), nullable=False),
|
||||
sa.Column("reason", sa.Text(), nullable=True),
|
||||
sa.CheckConstraint(
|
||||
"status IN ('stable', 'derive', 'indetermine')", name="ck_drift_report_status"
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"status = 'stable' OR reason IS NOT NULL", name="ck_drift_report_reason"
|
||||
),
|
||||
sa.CheckConstraint("n_observations >= 0", name="ck_drift_report_observations"),
|
||||
sa.ForeignKeyConstraint(
|
||||
["site_id"], ["site.site_id"], name="fk_drift_report_site", ondelete="RESTRICT"
|
||||
),
|
||||
sa.PrimaryKeyConstraint("drift_report_id"),
|
||||
)
|
||||
op.create_index(
|
||||
"ix_drift_report_site_computed", "drift_report", ["site_id", "computed_at"], unique=False
|
||||
)
|
||||
op.create_index(
|
||||
"uq_drift_report_window",
|
||||
"drift_report",
|
||||
["window_end", sa.literal_column("coalesce(site_id, '')")],
|
||||
unique=True,
|
||||
)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
op.drop_table("drift_report")
|
||||
@@ -1,218 +0,0 @@
|
||||
"""Création des six tables Data et de l'hypertable reading.
|
||||
|
||||
Revision ID: e6d2026091501
|
||||
Revises: 821f71be74c0
|
||||
"""
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
from sqlalchemy.dialects import postgresql
|
||||
|
||||
revision = "e6d2026091501"
|
||||
down_revision = "821f71be74c0"
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
# ### commands auto generated by Alembic - please adjust! ###
|
||||
op.create_table(
|
||||
"dataset",
|
||||
sa.Column("dataset_id", sa.BigInteger(), autoincrement=True, nullable=False),
|
||||
sa.Column("dataset_name", sa.Text(), nullable=False),
|
||||
sa.Column("archive_sha256", sa.String(length=64), nullable=False),
|
||||
sa.Column("storage_uri", sa.Text(), nullable=False),
|
||||
sa.Column("source_timezone", sa.Text(), nullable=True),
|
||||
sa.Column(
|
||||
"metadata", postgresql.JSONB(none_as_null=True, astext_type=sa.Text()), nullable=False
|
||||
),
|
||||
sa.CheckConstraint("dataset_id > 0", name="ck_dataset_positive_id"),
|
||||
sa.PrimaryKeyConstraint("dataset_id"),
|
||||
sa.UniqueConstraint("archive_sha256", name="uq_dataset_archive_sha256"),
|
||||
)
|
||||
op.create_table(
|
||||
"site",
|
||||
sa.Column("site_id", sa.Text(), nullable=False),
|
||||
sa.Column("site_name", sa.Text(), nullable=False),
|
||||
sa.Column("site_type", sa.Text(), nullable=False),
|
||||
sa.Column("location", sa.Text(), nullable=True),
|
||||
sa.Column("capacity_kw", sa.Double(), nullable=True),
|
||||
sa.Column("status", sa.Text(), nullable=True),
|
||||
sa.PrimaryKeyConstraint("site_id"),
|
||||
)
|
||||
op.create_table(
|
||||
"prediction",
|
||||
sa.Column("prediction_id", sa.BigInteger(), autoincrement=True, nullable=False),
|
||||
sa.Column("site_id", sa.Text(), nullable=False),
|
||||
sa.Column(
|
||||
"created_at",
|
||||
sa.DateTime(timezone=True),
|
||||
server_default=sa.text("now()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column("target_at", sa.DateTime(timezone=True), nullable=False),
|
||||
sa.Column("target_metric", sa.Text(), nullable=False),
|
||||
sa.Column("period_minutes", sa.Integer(), nullable=True),
|
||||
sa.Column("predicted_value", sa.Double(), nullable=True),
|
||||
sa.Column("model_reference", sa.Text(), nullable=False),
|
||||
sa.Column("status", sa.Text(), nullable=False),
|
||||
sa.Column("failure_reason", sa.Text(), nullable=True),
|
||||
sa.CheckConstraint(
|
||||
"(status = 'available' AND predicted_value IS NOT NULL AND failure_reason IS NULL) OR (status IN ('insufficient_data', 'error') AND predicted_value IS NULL AND failure_reason IS NOT NULL)",
|
||||
name="ck_prediction_status",
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"target_metric <> 'consumption_kwh' OR period_minutes IS NOT NULL",
|
||||
name="ck_prediction_energy_period",
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"target_metric IN ('consumption_kwh', 'consumption_kw')", name="ck_prediction_metric"
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"period_minutes IS NULL OR period_minutes > 0", name="ck_prediction_period"
|
||||
),
|
||||
sa.ForeignKeyConstraint(
|
||||
["site_id"], ["site.site_id"], name="fk_prediction_site", ondelete="RESTRICT"
|
||||
),
|
||||
sa.PrimaryKeyConstraint("prediction_id"),
|
||||
sa.UniqueConstraint("prediction_id", "site_id", name="uq_prediction_id_site"),
|
||||
)
|
||||
op.create_index(
|
||||
"ix_prediction_site_target", "prediction", ["site_id", "target_at"], unique=False
|
||||
)
|
||||
op.create_table(
|
||||
"reading",
|
||||
sa.Column("reading_id", sa.BigInteger(), autoincrement=True, nullable=False),
|
||||
sa.Column("site_id", sa.Text(), nullable=False),
|
||||
sa.Column("timestamp", sa.DateTime(timezone=True), nullable=False),
|
||||
sa.Column("source", sa.Text(), nullable=False),
|
||||
sa.Column("dataset_id", sa.BigInteger(), nullable=True),
|
||||
sa.Column("consumption_kw", sa.Double(), nullable=True),
|
||||
sa.Column("consumption_kwh", sa.Double(), nullable=True),
|
||||
sa.Column("consumption_euros", sa.Numeric(precision=14, scale=2), nullable=True),
|
||||
sa.Column("voltage_v", sa.Double(), nullable=True),
|
||||
sa.Column("current_a", sa.Double(), nullable=True),
|
||||
sa.Column("power_factor", sa.Double(), nullable=True),
|
||||
sa.Column("temperature_celsius", sa.Double(), nullable=True),
|
||||
sa.Column("humidity_percent", sa.Double(), nullable=True),
|
||||
sa.Column("solar_irradiance_wm2", sa.Double(), nullable=True),
|
||||
sa.Column("is_working_hours", sa.Boolean(), nullable=True),
|
||||
sa.Column("data_quality", sa.Text(), nullable=True),
|
||||
sa.Column("null_reasons", postgresql.ARRAY(sa.Text()), nullable=True),
|
||||
sa.Column(
|
||||
"imputed_values", postgresql.JSONB(none_as_null=True, astext_type=sa.Text()), nullable=True
|
||||
),
|
||||
sa.Column("imputation_method", sa.Text(), nullable=True),
|
||||
sa.Column(
|
||||
"ingested_at",
|
||||
sa.DateTime(timezone=True),
|
||||
server_default=sa.text("now()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column(
|
||||
"raw_data", postgresql.JSONB(none_as_null=True, astext_type=sa.Text()), nullable=False
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"(source = 'csv' AND dataset_id IS NOT NULL) OR (source IN ('api_current', 'api_history') AND dataset_id IS NULL)",
|
||||
name="ck_reading_dataset_source",
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"data_quality IS NULL OR data_quality IN ('good', 'partial', 'degraded', 'critical')",
|
||||
name="ck_reading_quality",
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"source IN ('csv', 'api_current', 'api_history')", name="ck_reading_source"
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"(imputed_values IS NULL AND imputation_method IS NULL) OR (imputed_values IS NOT NULL AND imputation_method IS NOT NULL)",
|
||||
name="ck_reading_imputation",
|
||||
),
|
||||
sa.ForeignKeyConstraint(
|
||||
["dataset_id"], ["dataset.dataset_id"], name="fk_reading_dataset", ondelete="RESTRICT"
|
||||
),
|
||||
sa.ForeignKeyConstraint(
|
||||
["site_id"], ["site.site_id"], name="fk_reading_site", ondelete="RESTRICT"
|
||||
),
|
||||
sa.PrimaryKeyConstraint("reading_id", "timestamp"),
|
||||
)
|
||||
op.create_index("ix_reading_dataset_id", "reading", ["dataset_id"], unique=False)
|
||||
op.create_index(
|
||||
"ix_reading_site_timestamp", "reading", ["site_id", "timestamp"], unique=False
|
||||
)
|
||||
op.create_index(
|
||||
"uq_reading_source",
|
||||
"reading",
|
||||
["site_id", "timestamp", "source", sa.literal_column("coalesce(dataset_id, 0)")],
|
||||
unique=True,
|
||||
)
|
||||
op.execute(
|
||||
"SELECT create_hypertable('reading', by_range('timestamp'), create_default_indexes => FALSE)"
|
||||
)
|
||||
op.create_table(
|
||||
"alert",
|
||||
sa.Column("alert_id", sa.BigInteger(), autoincrement=True, nullable=False),
|
||||
sa.Column("source_alert_id", sa.Text(), nullable=False),
|
||||
sa.Column("site_id", sa.Text(), nullable=False),
|
||||
sa.Column("source", sa.Text(), nullable=False),
|
||||
sa.Column("timestamp", sa.DateTime(timezone=True), nullable=False),
|
||||
sa.Column("type", sa.Text(), nullable=False),
|
||||
sa.Column("severity", sa.Text(), nullable=False),
|
||||
sa.Column("message", sa.Text(), nullable=False),
|
||||
sa.Column("value", sa.Double(), nullable=True),
|
||||
sa.Column("threshold", sa.Double(), nullable=True),
|
||||
sa.Column("metric", sa.Text(), nullable=True),
|
||||
sa.Column("prediction_id", sa.BigInteger(), nullable=True),
|
||||
sa.Column(
|
||||
"raw_data", postgresql.JSONB(none_as_null=True, astext_type=sa.Text()), nullable=False
|
||||
),
|
||||
sa.CheckConstraint(
|
||||
"severity IN ('low', 'medium', 'high', 'critical')", name="ck_alert_severity"
|
||||
),
|
||||
sa.CheckConstraint("source IN ('api_mock', 'enervision')", name="ck_alert_source"),
|
||||
sa.CheckConstraint(
|
||||
"type IN ('spike', 'threshold', 'anomaly', 'outage', 'sensor')", name="ck_alert_type"
|
||||
),
|
||||
sa.ForeignKeyConstraint(
|
||||
["prediction_id", "site_id"],
|
||||
["prediction.prediction_id", "prediction.site_id"],
|
||||
name="fk_alert_prediction_site",
|
||||
ondelete="RESTRICT",
|
||||
),
|
||||
sa.ForeignKeyConstraint(
|
||||
["site_id"], ["site.site_id"], name="fk_alert_site", ondelete="RESTRICT"
|
||||
),
|
||||
sa.PrimaryKeyConstraint("alert_id"),
|
||||
sa.UniqueConstraint(
|
||||
"source", "site_id", "source_alert_id", name="uq_alert_source_reference"
|
||||
),
|
||||
)
|
||||
op.create_index("ix_alert_site_timestamp", "alert", ["site_id", "timestamp"], unique=False)
|
||||
op.create_table(
|
||||
"recommendation",
|
||||
sa.Column("recommendation_id", sa.BigInteger(), autoincrement=True, nullable=False),
|
||||
sa.Column("alert_id", sa.BigInteger(), nullable=False),
|
||||
sa.Column("action", sa.Text(), nullable=False),
|
||||
sa.Column("explanation", sa.Text(), nullable=False),
|
||||
sa.Column("rule_reference", sa.Text(), nullable=False),
|
||||
sa.Column(
|
||||
"created_at",
|
||||
sa.DateTime(timezone=True),
|
||||
server_default=sa.text("now()"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.ForeignKeyConstraint(
|
||||
["alert_id"], ["alert.alert_id"], name="fk_recommendation_alert", ondelete="RESTRICT"
|
||||
),
|
||||
sa.PrimaryKeyConstraint("recommendation_id"),
|
||||
sa.UniqueConstraint("alert_id", "rule_reference", name="uq_recommendation_alert_rule"),
|
||||
)
|
||||
# ### end Alembic commands ###
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
op.drop_table("recommendation")
|
||||
op.drop_table("alert")
|
||||
op.drop_table("reading")
|
||||
op.drop_table("prediction")
|
||||
op.drop_table("site")
|
||||
op.drop_table("dataset")
|
||||
@@ -1,309 +1,10 @@
|
||||
# Piège : `get_current_principal()` relit le compte en base à chaque requête au lieu de faire
|
||||
# confiance aux claims. C'est le renoncement assumé à la propriété « sans état » : sur un seul
|
||||
# service et une seule base, elle n'achetait rien, et la lecture par clé primaire coûte moins
|
||||
# d'un pour cent du budget d'une requête. Ce qu'elle achète, c'est la révocation immédiate.
|
||||
# Piège : le `Principal` est construit depuis la ligne, jamais depuis le claim `role`. Un claim
|
||||
# périmé ne peut donc pas provoquer d'élévation de privilège.
|
||||
|
||||
from collections.abc import Callable
|
||||
from datetime import timedelta
|
||||
from functools import lru_cache
|
||||
from typing import Annotated
|
||||
|
||||
from fastapi import Depends, HTTPException, Request, status
|
||||
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
|
||||
from fastapi import Depends
|
||||
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
|
||||
from app.core.security import decode_access_token as decode_token
|
||||
from app.db.session import get_session
|
||||
from app.repositories.alert import AlertRepository
|
||||
from app.repositories.audit_log import AuditLogRepository
|
||||
from app.repositories.drift import DriftRepository
|
||||
from app.repositories.login_attempt import LoginAttemptRepository
|
||||
from app.repositories.password_reset_attempt import PasswordResetAttemptRepository
|
||||
from app.repositories.password_reset_token import PasswordResetTokenRepository
|
||||
from app.repositories.prediction import PredictionRepository
|
||||
from app.repositories.reading import ReadingRepository
|
||||
from app.repositories.recommendation import RecommendationRepository
|
||||
from app.repositories.refresh_token import RefreshTokenRepository
|
||||
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.drift import DriftService
|
||||
from app.services.prediction import PredictionService
|
||||
from app.services.reading import ReadingService
|
||||
from app.services.recommendation import RecommendationService
|
||||
from app.services.sensor import SensorService
|
||||
from app.services.site import SiteService
|
||||
from app.services.stats import StatsService
|
||||
from app.services.user import UserService
|
||||
|
||||
SessionDep = Annotated[AsyncSession, Depends(get_session)]
|
||||
SettingsDep = Annotated[Settings, Depends(get_settings)]
|
||||
|
||||
CODE_CHANGEMENT_REQUIS = "password_change_required"
|
||||
|
||||
# Nom ASCII : un outillage tiers (ZAP, cf. .github/workflows/dast.yml) peut mal analyser un nom
|
||||
# de schéma accentué dans le contrat OpenAPI. Piège vécu, pas anticipé.
|
||||
_porteur = HTTPBearer(auto_error=False, scheme_name="JetonAcces")
|
||||
CredentialsDep = Annotated[HTTPAuthorizationCredentials | None, Depends(_porteur)]
|
||||
|
||||
|
||||
def _non_authentifie(description: str) -> HTTPException:
|
||||
return HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="Authentification requise",
|
||||
headers={"WWW-Authenticate": f'Bearer error="{description}"'},
|
||||
)
|
||||
|
||||
|
||||
def get_token_policy(settings: SettingsDep) -> TokenPolicy:
|
||||
return TokenPolicy(
|
||||
secret=settings.secret_key.get_secret_value(),
|
||||
issuer=settings.jwt_issuer,
|
||||
audience=settings.jwt_audience,
|
||||
access_ttl=timedelta(seconds=settings.access_token_ttl_seconds),
|
||||
)
|
||||
|
||||
|
||||
# Construire un `Argon2Hasher` calcule un haché leurre, donc 17 ms : il est mis en cache sur
|
||||
# les paramètres plutôt que reconstruit à chaque requête.
|
||||
@lru_cache
|
||||
def _hasher_cache(
|
||||
time_cost: int, memory_cost_kib: int, parallelism: int, max_concurrency: int
|
||||
) -> Argon2Hasher:
|
||||
return build_hasher(
|
||||
time_cost=time_cost,
|
||||
memory_cost_kib=memory_cost_kib,
|
||||
parallelism=parallelism,
|
||||
max_concurrency=max_concurrency,
|
||||
)
|
||||
|
||||
|
||||
def get_hasher(settings: SettingsDep) -> Argon2Hasher:
|
||||
return _hasher_cache(
|
||||
settings.argon2_time_cost,
|
||||
settings.argon2_memory_cost_kib,
|
||||
settings.argon2_parallelism,
|
||||
settings.argon2_max_concurrency,
|
||||
)
|
||||
|
||||
|
||||
def get_client_ip(request: Request, settings: SettingsDep) -> str | None:
|
||||
# Derrière un proxy, `request.client.host` vaut l'IP du proxy : le compteur par IP
|
||||
# deviendrait global, donc un déni de service auto-infligé. Le dernier élément est le seul
|
||||
# qu'un proxy de confiance ait écrit, les précédents sont fournis par le client.
|
||||
if settings.trust_proxy_headers:
|
||||
transmis = request.headers.get("x-forwarded-for")
|
||||
if transmis:
|
||||
return transmis.split(",")[-1].strip()
|
||||
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),
|
||||
attempts=LoginAttemptRepository(session),
|
||||
refresh_tokens=RefreshTokenRepository(session),
|
||||
audit=AuditLogRepository(session),
|
||||
hasher=hasher,
|
||||
transaction=session,
|
||||
token_policy=token_policy,
|
||||
login_policy=LoginPolicy(
|
||||
window_seconds=settings.login_window_seconds,
|
||||
max_failures_per_identifier_and_ip=(settings.login_max_failures_per_identifier_and_ip),
|
||||
max_failures_per_ip=settings.login_max_failures_per_ip,
|
||||
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,
|
||||
)
|
||||
|
||||
|
||||
AuthServiceDep = Annotated[AuthService, Depends(get_auth_service)]
|
||||
|
||||
|
||||
def get_user_service(
|
||||
session: SessionDep,
|
||||
hasher: Annotated[Argon2Hasher, Depends(get_hasher)],
|
||||
) -> UserService:
|
||||
return UserService(
|
||||
users=UserRepository(session),
|
||||
refresh_tokens=RefreshTokenRepository(session),
|
||||
audit=AuditLogRepository(session),
|
||||
hasher=hasher,
|
||||
transaction=session,
|
||||
)
|
||||
|
||||
|
||||
UserServiceDep = Annotated[UserService, Depends(get_user_service)]
|
||||
|
||||
|
||||
def get_site_service(session: SessionDep) -> SiteService:
|
||||
return SiteService(sites=SiteRepository(session), readings=ReadingRepository(session))
|
||||
|
||||
|
||||
SiteServiceDep = Annotated[SiteService, Depends(get_site_service)]
|
||||
|
||||
|
||||
def get_alert_service(session: SessionDep) -> AlertService:
|
||||
return AlertService(
|
||||
alerts=AlertRepository(session),
|
||||
readings=ReadingRepository(session),
|
||||
predictions=PredictionRepository(session),
|
||||
sites=SiteRepository(session),
|
||||
)
|
||||
|
||||
|
||||
AlertServiceDep = Annotated[AlertService, Depends(get_alert_service)]
|
||||
|
||||
|
||||
def get_recommendation_service(session: SessionDep) -> RecommendationService:
|
||||
return RecommendationService(
|
||||
recommendations=RecommendationRepository(session),
|
||||
alerts=AlertRepository(session),
|
||||
transaction=session,
|
||||
)
|
||||
|
||||
|
||||
RecommendationServiceDep = Annotated[RecommendationService, Depends(get_recommendation_service)]
|
||||
|
||||
|
||||
def get_stats_service(session: SessionDep) -> StatsService:
|
||||
return StatsService(sites=SiteRepository(session), readings=ReadingRepository(session))
|
||||
|
||||
|
||||
StatsServiceDep = Annotated[StatsService, Depends(get_stats_service)]
|
||||
|
||||
|
||||
def get_reading_service(session: SessionDep) -> ReadingService:
|
||||
return ReadingService(readings=ReadingRepository(session))
|
||||
|
||||
|
||||
ReadingServiceDep = Annotated[ReadingService, Depends(get_reading_service)]
|
||||
|
||||
|
||||
def get_sensor_service(session: SessionDep) -> SensorService:
|
||||
return SensorService(sites=SiteRepository(session), readings=ReadingRepository(session))
|
||||
|
||||
|
||||
SensorServiceDep = Annotated[SensorService, Depends(get_sensor_service)]
|
||||
|
||||
|
||||
def get_prediction_service(session: SessionDep) -> PredictionService:
|
||||
return PredictionService(
|
||||
sites=SiteRepository(session), predictions=PredictionRepository(session)
|
||||
)
|
||||
|
||||
|
||||
PredictionServiceDep = Annotated[PredictionService, Depends(get_prediction_service)]
|
||||
|
||||
|
||||
def get_drift_service(session: SessionDep) -> DriftService:
|
||||
return DriftService(DriftRepository(session))
|
||||
|
||||
|
||||
DriftServiceDep = Annotated[DriftService, Depends(get_drift_service)]
|
||||
|
||||
|
||||
async def get_current_principal(
|
||||
credentials: CredentialsDep,
|
||||
session: SessionDep,
|
||||
token_policy: Annotated[TokenPolicy, Depends(get_token_policy)],
|
||||
) -> Principal:
|
||||
if credentials is None:
|
||||
raise _non_authentifie("invalid_request")
|
||||
|
||||
try:
|
||||
claims = decode_token(token_policy, credentials.credentials)
|
||||
except TokenExpiredError as erreur:
|
||||
raise _non_authentifie("expired") from erreur
|
||||
except TokenInvalidError as erreur:
|
||||
raise _non_authentifie("invalid_token") from erreur
|
||||
|
||||
compte = await UserRepository(session).get_by_id(claims.subject)
|
||||
if compte is None or not compte.is_active:
|
||||
raise _non_authentifie("invalid_token")
|
||||
# Piège : `iat` est une date JWT, donc en secondes entières. Comparer sans tronquer le
|
||||
# marqueur rejetterait tout jeton émis dans la même seconde que le changement, c'est-à-dire
|
||||
# celui que `/auth/password` vient de rendre pour garder l'appareil courant connecté.
|
||||
if int(claims.issued_at.timestamp()) < int(compte.credentials_changed_at.timestamp()):
|
||||
raise _non_authentifie("token_stale")
|
||||
if claims.role != compte.role:
|
||||
raise _non_authentifie("token_stale")
|
||||
|
||||
return Principal(
|
||||
id=compte.id,
|
||||
email=compte.email,
|
||||
role=Role(compte.role),
|
||||
kind=AccountKind(compte.kind),
|
||||
must_change_password=compte.must_change_password,
|
||||
)
|
||||
|
||||
|
||||
CurrentPrincipalDep = Annotated[Principal, Depends(get_current_principal)]
|
||||
|
||||
|
||||
def require_role(minimum: Role) -> Callable[[Principal], Principal]:
|
||||
def garde(principal: CurrentPrincipalDep) -> Principal:
|
||||
if principal.must_change_password:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_403_FORBIDDEN, detail=CODE_CHANGEMENT_REQUIS
|
||||
)
|
||||
if not has_at_least(principal.role, minimum):
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Droits insuffisants")
|
||||
return principal
|
||||
|
||||
return garde
|
||||
|
||||
|
||||
LecteurDep = Annotated[Principal, Depends(require_role(Role.LECTEUR))]
|
||||
OperateurDep = Annotated[Principal, Depends(require_role(Role.OPERATEUR))]
|
||||
AdminDep = Annotated[Principal, Depends(require_role(Role.ADMIN))]
|
||||
|
||||
|
||||
def require_trusted_origin(request: Request, settings: SettingsDep) -> None:
|
||||
# Un navigateur envoie toujours `Origin` sur une requête non sûre. Son absence signale un
|
||||
# client hors navigateur, qui ne détient aucun cookie de victime : rien à protéger.
|
||||
origine = request.headers.get("origin")
|
||||
if origine is None:
|
||||
return
|
||||
if origine not in settings.allowed_origins:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Origine refusée")
|
||||
|
||||
@@ -1,47 +0,0 @@
|
||||
# Piège : la réponse 422 par défaut de FastAPI contient la clé `input`, c'est-à-dire la valeur
|
||||
# rejetée. Sur `/auth/login`, un corps malformé renverrait donc le mot de passe au client et le
|
||||
# déposerait dans les journaux d'erreur. `validation_error_handler()` ne laisse passer que le
|
||||
# champ fautif et le type d'erreur.
|
||||
|
||||
import uuid
|
||||
from typing import Any
|
||||
|
||||
from fastapi import FastAPI, Request, status
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
from app.core.logging import get_logger
|
||||
|
||||
logger = get_logger(__name__)
|
||||
|
||||
|
||||
async def validation_error_handler(_: Request, exception: RequestValidationError) -> JSONResponse:
|
||||
champs: list[dict[str, Any]] = [
|
||||
{
|
||||
"champ": ".".join(str(element) for element in erreur["loc"]),
|
||||
"type": erreur["type"],
|
||||
}
|
||||
for erreur in exception.errors()
|
||||
]
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, content={"detail": champs}
|
||||
)
|
||||
|
||||
|
||||
async def unhandled_error_handler(request: Request, exception: Exception) -> JSONResponse:
|
||||
correlation = uuid.uuid4().hex
|
||||
logger.exception(
|
||||
"erreur non gérée correlation=%s methode=%s chemin=%s",
|
||||
correlation,
|
||||
request.method,
|
||||
request.url.path,
|
||||
)
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
content={"detail": "Erreur interne", "correlation": correlation},
|
||||
)
|
||||
|
||||
|
||||
def register_error_handlers(application: FastAPI) -> None:
|
||||
application.add_exception_handler(RequestValidationError, validation_error_handler) # type: ignore[arg-type]
|
||||
application.add_exception_handler(Exception, unhandled_error_handler)
|
||||
@@ -1,38 +0,0 @@
|
||||
# Pourquoi : `SecurityHeadersMiddleware` ne pose ni HSTS ni CSP, et c'est délibéré.
|
||||
# L'application ignore si TLS termine devant elle, donc elle ne peut pas décider d'un HSTS ;
|
||||
# et une CSP sur une API JSON ne protège presque rien, celle qui compte protège la page
|
||||
# Angular. Les deux appartiennent au terminateur TLS.
|
||||
# Contrainte : `/docs` charge Swagger depuis un CDN, une CSP stricte ici casserait la
|
||||
# documentation sans rien sécuriser.
|
||||
|
||||
from collections.abc import Awaitable, Callable
|
||||
from typing import Final
|
||||
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response
|
||||
|
||||
EN_TETES: Final[dict[str, str]] = {
|
||||
"X-Content-Type-Options": "nosniff",
|
||||
"X-Frame-Options": "DENY",
|
||||
"Referrer-Policy": "no-referrer",
|
||||
# same-origin : aucun client ne charge l'API en no-cors depuis une autre origine
|
||||
# (proxy.conf.json en dev, reverse proxy nginx ensuite, cf. docs/architecture/20-backend.md).
|
||||
"Cross-Origin-Resource-Policy": "same-origin",
|
||||
}
|
||||
|
||||
PREFIXE_AUTHENTIFICATION: Final = "/auth"
|
||||
|
||||
|
||||
class SecurityHeadersMiddleware(BaseHTTPMiddleware):
|
||||
async def dispatch(
|
||||
self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
|
||||
) -> Response:
|
||||
response = await call_next(request)
|
||||
for nom, valeur in EN_TETES.items():
|
||||
response.headers.setdefault(nom, valeur)
|
||||
|
||||
# Une réponse d'authentification ne doit jamais être conservée par un intermédiaire.
|
||||
if PREFIXE_AUTHENTIFICATION in request.url.path:
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
return response
|
||||
@@ -1,207 +0,0 @@
|
||||
# Piège : `cookie_de_rafraichissement` est purement documentaire, d'où son `auto_error=False`.
|
||||
# Avec la valeur par défaut, FastAPI répondrait 403 avant d'atteindre `lit_le_cookie()`, et
|
||||
# `/auth/refresh` cesserait de rendre le 401 que le frontend attend.
|
||||
|
||||
from typing import Any, Final
|
||||
|
||||
from fastapi.security import APIKeyCookie
|
||||
|
||||
from app.core.config import REFRESH_COOKIE_DEFAUT
|
||||
from app.schemas.errors import ErrorResponse, InternalErrorResponse, ValidationErrorResponse
|
||||
|
||||
Reponses = dict[int | str, dict[str, Any]]
|
||||
|
||||
SUMMARY: Final = "Collecte, analyse et restitution de séries temporelles énergétiques."
|
||||
|
||||
DESCRIPTION: Final = """
|
||||
Toutes les routes sont préfixées par `/api/v1`.
|
||||
|
||||
**Authentification.** Le jeton d'accès se présente dans l'en-tête `Authorization: Bearer ...`.
|
||||
Le jeton de rafraîchissement est un cookie `HttpOnly` que le code client ne voit jamais : il
|
||||
suffit d'émettre les requêtes avec les identifiants de session. `POST /auth/refresh` rend un
|
||||
nouveau jeton d'accès et fait tourner le cookie.
|
||||
|
||||
**Rôles.** `lecteur`, puis `operateur`, puis `admin`. Chaque rôle couvre les droits du
|
||||
précédent.
|
||||
|
||||
**Erreurs.** Le corps porte toujours une clé `detail`. Un `403` dont le `detail` vaut
|
||||
`password_change_required` n'est pas un refus de droits : il exige le changement du mot de passe
|
||||
provisoire avant toute autre action.
|
||||
|
||||
Le parcours de session complet est décrit dans
|
||||
`docs/architecture/31-contrat-authentification.md`.
|
||||
"""
|
||||
|
||||
TAGS: Final[list[dict[str, Any]]] = [
|
||||
{
|
||||
"name": "health",
|
||||
"description": (
|
||||
"Sondes d'infrastructure, publiques. `live` prouve que le processus répond, `ready` "
|
||||
"que la base répond et que l'extension TimescaleDB est chargée."
|
||||
),
|
||||
},
|
||||
{
|
||||
"name": "auth",
|
||||
"description": (
|
||||
"Ouverture, rotation et fermeture de session, et changement de son propre mot de passe."
|
||||
),
|
||||
},
|
||||
{
|
||||
"name": "users",
|
||||
"description": "Administration des comptes. Réservé au rôle `admin`.",
|
||||
},
|
||||
{
|
||||
"name": "sites",
|
||||
"description": "Consultation du parc de sites. Accessible à partir du rôle `lecteur`.",
|
||||
},
|
||||
{
|
||||
"name": "alerts",
|
||||
"description": "Consultation des alertes de consommation. Accessible à partir du rôle "
|
||||
"`lecteur`.",
|
||||
},
|
||||
{
|
||||
"name": "recommendations",
|
||||
"description": (
|
||||
"Consultation des recommandations issues des alertes. Accessible à partir du rôle "
|
||||
"`lecteur`. Leur génération par le moteur de règles est réservée au rôle `admin`."
|
||||
),
|
||||
},
|
||||
{
|
||||
"name": "stats",
|
||||
"description": "Statistiques agrégées de consommation. Accessible à partir du rôle "
|
||||
"`lecteur`.",
|
||||
},
|
||||
{
|
||||
"name": "readings",
|
||||
"description": (
|
||||
"Historique des lectures de consommation. Fenêtre temporelle plafonnée à 90 jours, "
|
||||
"24 dernières heures par défaut si `start`/`end` sont omis. Accessible à partir du "
|
||||
"rôle `lecteur`."
|
||||
),
|
||||
},
|
||||
{
|
||||
"name": "sensors",
|
||||
"description": "État de santé des capteurs par site. Réservé au rôle `admin`.",
|
||||
},
|
||||
{
|
||||
"name": "predictions",
|
||||
"description": (
|
||||
"Dernière prévision de consommation par site, calculée hors ligne par le pipeline "
|
||||
"de scoring (`ml/`) et simplement lue ici. Accessible à partir du rôle `lecteur`."
|
||||
),
|
||||
},
|
||||
{
|
||||
"name": "monitoring",
|
||||
"description": (
|
||||
"Surveillance de la dérive du modèle : écart entre les prévisions déjà écrites et "
|
||||
"les lectures réellement arrivées, par site et tous sites confondus. Réservé à "
|
||||
"partir du rôle `operateur`, qui agit sur un pipeline dégradé."
|
||||
),
|
||||
},
|
||||
]
|
||||
|
||||
cookie_de_rafraichissement = APIKeyCookie(
|
||||
name=REFRESH_COOKIE_DEFAUT,
|
||||
# Nom ASCII : un outillage tiers (ZAP, cf. .github/workflows/dast.yml) peut mal analyser un
|
||||
# nom de schéma accentué dans le contrat OpenAPI. Piège vécu, pas anticipé.
|
||||
scheme_name="CookieRafraichissement",
|
||||
description=(
|
||||
"Cookie `HttpOnly` posé par `/auth/login` et tourné par `/auth/refresh`. Il prend le "
|
||||
"préfixe `__Secure-` dès que l'API tourne derrière TLS, et n'est émis que vers "
|
||||
"`/api/v1/auth`."
|
||||
),
|
||||
auto_error=False,
|
||||
)
|
||||
|
||||
# Le 422 n'est déclaré que sur les routes qui acceptent un corps ou un paramètre : ailleurs,
|
||||
# aucune validation ne peut échouer et l'annoncer serait faux.
|
||||
REPONSE_VALIDATION: Final[Reponses] = {
|
||||
422: {
|
||||
"model": ValidationErrorResponse,
|
||||
"description": (
|
||||
"Corps invalide. Le détail nomme le champ fautif et le type d'erreur, jamais la "
|
||||
"valeur envoyée."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
REPONSE_SERVEUR: Final[Reponses] = {
|
||||
500: {
|
||||
"model": InternalErrorResponse,
|
||||
"description": (
|
||||
"Erreur interne. `correlation` identifie la trace côté serveur, qui n'est pas "
|
||||
"renvoyée au client."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
REPONSE_INDISPONIBLE: Final[Reponses] = {
|
||||
503: {
|
||||
"model": ErrorResponse,
|
||||
"description": "Base injoignable, ou extension TimescaleDB absente de la base.",
|
||||
},
|
||||
}
|
||||
|
||||
REPONSES_AUTHENTIFIEES: Final[Reponses] = {
|
||||
401: {
|
||||
"model": ErrorResponse,
|
||||
"description": (
|
||||
"Jeton absent, illisible, périmé, ou rendu caduc par un changement de rôle ou une "
|
||||
"désactivation. L'en-tête `WWW-Authenticate` porte la cause dans `error=`."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
REPONSES_ADMIN: Final[Reponses] = {
|
||||
**REPONSES_AUTHENTIFIEES,
|
||||
403: {
|
||||
"model": ErrorResponse,
|
||||
"description": (
|
||||
"Droits insuffisants, ou mot de passe provisoire à changer quand `detail` vaut "
|
||||
"`password_change_required`."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
REPONSES_OPERATEUR: Final[Reponses] = {
|
||||
**REPONSES_AUTHENTIFIEES,
|
||||
403: {
|
||||
"model": ErrorResponse,
|
||||
"description": (
|
||||
"Droits insuffisants, ou mot de passe provisoire à changer quand `detail` vaut "
|
||||
"`password_change_required`."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
# `lecteur` est le rôle minimum : `require_role` n'y refuse jamais un 403 pour droits
|
||||
# insuffisants, seulement pour le mot de passe provisoire.
|
||||
REPONSES_LECTEUR: Final[Reponses] = {
|
||||
**REPONSES_AUTHENTIFIEES,
|
||||
403: {
|
||||
"model": ErrorResponse,
|
||||
"description": (
|
||||
"Mot de passe provisoire à changer (`detail` vaut `password_change_required`)."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
REPONSE_ORIGINE_REFUSEE: Final[Reponses] = {
|
||||
403: {
|
||||
"model": ErrorResponse,
|
||||
"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"},
|
||||
}
|
||||
},
|
||||
},
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
# Pourquoi : `/metrics` est protégé par un jeton statique et non par un rôle applicatif. Coupler
|
||||
# la supervision au modèle d'utilisateurs casserait la collecte à chaque panne
|
||||
# d'authentification, c'est-à-dire précisément quand on a besoin des métriques. Le vrai contrôle
|
||||
# reste le réseau : Prometheus scrute sur le réseau interne et `/metrics` ne sort pas.
|
||||
|
||||
import secrets
|
||||
|
||||
from fastapi import HTTPException, Request, status
|
||||
|
||||
from app.api.deps import SettingsDep
|
||||
|
||||
|
||||
def require_metrics_token(request: Request, settings: SettingsDep) -> None:
|
||||
attendu = settings.metrics_token
|
||||
if attendu is None:
|
||||
return
|
||||
|
||||
presente = request.headers.get("authorization", "")
|
||||
prefixe = "Bearer "
|
||||
if not presente.startswith(prefixe) or not secrets.compare_digest(
|
||||
presente[len(prefixe) :], attendu.get_secret_value()
|
||||
):
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Jeton requis")
|
||||
@@ -1,23 +0,0 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from app.api.deps import AlertServiceDep, LecteurDep
|
||||
from app.api.openapi import REPONSE_VALIDATION
|
||||
from app.schemas.alert import AlertResponse, AlertSeverity
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get(
|
||||
"",
|
||||
response_model=list[AlertResponse],
|
||||
summary="Liste les alertes",
|
||||
responses=REPONSE_VALIDATION,
|
||||
)
|
||||
async def list_alerts(
|
||||
_: LecteurDep,
|
||||
service: AlertServiceDep,
|
||||
site_id: str | None = None,
|
||||
severity: AlertSeverity | None = None,
|
||||
) -> list[AlertResponse]:
|
||||
alertes = await service.list_all(site_id=site_id, severity=severity)
|
||||
return [AlertResponse.model_validate(alerte) for alerte in alertes]
|
||||
@@ -1,365 +0,0 @@
|
||||
# Piège : le jeton de rafraîchissement ne quitte jamais le cookie httpOnly, et le jeton
|
||||
# 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 app.api.deps import (
|
||||
AuthServiceDep,
|
||||
CurrentPrincipalDep,
|
||||
SettingsDep,
|
||||
get_client_ip,
|
||||
require_trusted_origin,
|
||||
)
|
||||
from app.api.openapi import (
|
||||
REPONSE_LIMITE,
|
||||
REPONSE_ORIGINE_REFUSEE,
|
||||
REPONSE_VALIDATION,
|
||||
REPONSES_AUTHENTIFIEES,
|
||||
Reponses,
|
||||
cookie_de_rafraichissement,
|
||||
)
|
||||
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,
|
||||
)
|
||||
|
||||
router = APIRouter()
|
||||
logger = get_logger(__name__)
|
||||
|
||||
DETAIL_IDENTIFIANTS = "Identifiants invalides"
|
||||
DETAIL_SESSION = "Session invalide"
|
||||
DETAIL_LIEN_RESET = "Lien invalide ou expiré"
|
||||
|
||||
REPONSES_LOGIN: Reponses = {
|
||||
**REPONSE_VALIDATION,
|
||||
401: {
|
||||
"model": ErrorResponse,
|
||||
"description": (
|
||||
"Identifiants faux, compte inconnu ou compte désactivé. Le message est le même dans "
|
||||
"les trois cas, et n'apprend donc rien sur l'existence du compte."
|
||||
),
|
||||
},
|
||||
429: {
|
||||
"model": ErrorResponse,
|
||||
"description": "Trop de tentatives sur cette fenêtre glissante.",
|
||||
"headers": {
|
||||
"Retry-After": {
|
||||
"description": "Secondes à attendre avant une nouvelle tentative.",
|
||||
"schema": {"type": "integer"},
|
||||
}
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
REPONSES_REFRESH: Reponses = {
|
||||
**REPONSE_ORIGINE_REFUSEE,
|
||||
401: {
|
||||
"model": ErrorResponse,
|
||||
"description": (
|
||||
"Cookie absent, session expirée, révoquée, ou jeton déjà tourné. Dans ce dernier cas "
|
||||
"toute la famille de sessions est révoquée et le cookie est effacé avec la réponse."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
REPONSES_LOGOUT: Reponses = {**REPONSE_ORIGINE_REFUSEE}
|
||||
|
||||
REPONSES_LOGOUT_ALL: Reponses = {**REPONSES_AUTHENTIFIEES, **REPONSE_ORIGINE_REFUSEE}
|
||||
|
||||
REPONSES_MOT_DE_PASSE: Reponses = {
|
||||
**REPONSE_VALIDATION,
|
||||
**REPONSE_ORIGINE_REFUSEE,
|
||||
401: {
|
||||
"model": ErrorResponse,
|
||||
"description": "Jeton d'accès invalide, ou mot de passe courant faux.",
|
||||
},
|
||||
}
|
||||
|
||||
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
|
||||
) -> TokenResponse:
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
response.set_cookie(**RefreshCookie.build(settings, session.refresh_secret).as_kwargs())
|
||||
return TokenResponse(
|
||||
access_token=session.access_token,
|
||||
expires_in=session.expires_in,
|
||||
principal=PrincipalResponse.from_principal(session.principal),
|
||||
)
|
||||
|
||||
|
||||
# Piège : une `HTTPException` construit sa propre réponse, donc tout en-tête posé sur la
|
||||
# `Response` injectée est perdu. L'effacement du cookie doit voyager avec l'exception,
|
||||
# sans quoi un navigateur garderait un cookie mort après une détection de réutilisation.
|
||||
def entete_de_suppression(settings: SettingsDep) -> str:
|
||||
temoin = Response()
|
||||
temoin.delete_cookie(**RefreshCookie.expired(settings).as_deletion_kwargs())
|
||||
return temoin.headers["set-cookie"]
|
||||
|
||||
|
||||
def lit_le_cookie(request: Request, settings: SettingsDep) -> str:
|
||||
secret = request.cookies.get(cookie_name(settings))
|
||||
if not secret:
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=DETAIL_SESSION)
|
||||
return secret
|
||||
|
||||
|
||||
@router.post(
|
||||
"/login",
|
||||
response_model=TokenResponse,
|
||||
summary="Ouvre une session",
|
||||
responses=REPONSES_LOGIN,
|
||||
)
|
||||
async def login(
|
||||
payload: LoginRequest,
|
||||
request: Request,
|
||||
response: Response,
|
||||
settings: SettingsDep,
|
||||
service: AuthServiceDep,
|
||||
client_ip: str | None = Depends(get_client_ip),
|
||||
) -> TokenResponse:
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
agent = request.headers.get("user-agent")
|
||||
|
||||
try:
|
||||
session = await service.authenticate(
|
||||
email=payload.email, password=payload.password, client_ip=client_ip, user_agent=agent
|
||||
)
|
||||
except RateLimitedError as erreur:
|
||||
logger.warning("auth.rate_limited email=%s ip=%s", payload.email, client_ip)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_429_TOO_MANY_REQUESTS,
|
||||
detail="Trop de tentatives, réessayez plus tard",
|
||||
headers={"Retry-After": str(erreur.retry_after)},
|
||||
) from erreur
|
||||
except InvalidCredentialsError as erreur:
|
||||
logger.warning("auth.login.failure email=%s ip=%s", payload.email, client_ip)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED, detail=DETAIL_IDENTIFIANTS
|
||||
) from erreur
|
||||
|
||||
logger.info("auth.login.success user_id=%s ip=%s", session.principal.id, client_ip)
|
||||
return repond(response, settings, session)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/refresh",
|
||||
response_model=TokenResponse,
|
||||
summary="Fait tourner la session",
|
||||
dependencies=[Depends(require_trusted_origin), Depends(cookie_de_rafraichissement)],
|
||||
responses=REPONSES_REFRESH,
|
||||
)
|
||||
async def refresh(
|
||||
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.refresh(
|
||||
secret=lit_le_cookie(request, settings),
|
||||
client_ip=client_ip,
|
||||
user_agent=request.headers.get("user-agent"),
|
||||
)
|
||||
except SessionRejectedError as erreur:
|
||||
logger.warning("auth.refresh.rejected ip=%s", client_ip)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail=DETAIL_SESSION,
|
||||
headers={
|
||||
"Set-Cookie": entete_de_suppression(settings),
|
||||
"Cache-Control": "no-store",
|
||||
},
|
||||
) from erreur
|
||||
|
||||
return repond(response, settings, session)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/logout",
|
||||
status_code=status.HTTP_204_NO_CONTENT,
|
||||
summary="Ferme la session courante",
|
||||
dependencies=[Depends(require_trusted_origin), Depends(cookie_de_rafraichissement)],
|
||||
responses=REPONSES_LOGOUT,
|
||||
)
|
||||
async def logout(
|
||||
request: Request, response: Response, settings: SettingsDep, service: AuthServiceDep
|
||||
) -> None:
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
secret = request.cookies.get(cookie_name(settings))
|
||||
if secret:
|
||||
await service.logout(secret=secret)
|
||||
response.delete_cookie(**RefreshCookie.expired(settings).as_deletion_kwargs())
|
||||
|
||||
|
||||
@router.post(
|
||||
"/logout-all",
|
||||
status_code=status.HTTP_204_NO_CONTENT,
|
||||
summary="Ferme toutes les sessions du compte",
|
||||
dependencies=[Depends(require_trusted_origin)],
|
||||
responses=REPONSES_LOGOUT_ALL,
|
||||
)
|
||||
async def logout_all(
|
||||
principal: CurrentPrincipalDep,
|
||||
response: Response,
|
||||
settings: SettingsDep,
|
||||
service: AuthServiceDep,
|
||||
) -> None:
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
revoquees = await service.logout_all(principal)
|
||||
logger.info("auth.logout_all user_id=%s sessions=%s", principal.id, revoquees)
|
||||
response.delete_cookie(**RefreshCookie.expired(settings).as_deletion_kwargs())
|
||||
|
||||
|
||||
@router.get(
|
||||
"/me",
|
||||
response_model=PrincipalResponse,
|
||||
summary="Décrit le compte connecté",
|
||||
responses=REPONSES_AUTHENTIFIEES,
|
||||
)
|
||||
async def me(principal: CurrentPrincipalDep) -> PrincipalResponse:
|
||||
return PrincipalResponse.from_principal(principal)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/password",
|
||||
response_model=TokenResponse,
|
||||
summary="Change son propre mot de passe",
|
||||
dependencies=[Depends(require_trusted_origin)],
|
||||
responses=REPONSES_MOT_DE_PASSE,
|
||||
)
|
||||
async def change_password(
|
||||
payload: PasswordChangeRequest,
|
||||
principal: CurrentPrincipalDep,
|
||||
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.change_password(
|
||||
principal=principal,
|
||||
current_password=payload.current_password,
|
||||
new_password=payload.new_password,
|
||||
client_ip=client_ip,
|
||||
user_agent=request.headers.get("user-agent"),
|
||||
)
|
||||
except InvalidCredentialsError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED, detail=DETAIL_IDENTIFIANTS
|
||||
) from erreur
|
||||
|
||||
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)
|
||||
@@ -3,17 +3,16 @@ from sqlalchemy import text
|
||||
from sqlalchemy.exc import SQLAlchemyError
|
||||
|
||||
from app.api.deps import SessionDep, SettingsDep
|
||||
from app.api.openapi import REPONSE_INDISPONIBLE
|
||||
from app.core.logging import get_logger
|
||||
from app.schemas.health import LivenessStatus, ReadinessStatus
|
||||
|
||||
logger = get_logger(__name__)
|
||||
router = APIRouter()
|
||||
router = APIRouter(tags=["health"])
|
||||
|
||||
TIMESCALEDB_VERSION = text("SELECT extversion FROM pg_extension WHERE extname = 'timescaledb'")
|
||||
|
||||
|
||||
@router.get("/live", summary="Sonde de vivacité")
|
||||
@router.get("/live", summary="Sonde de vivacite")
|
||||
async def liveness(settings: SettingsDep) -> LivenessStatus:
|
||||
return LivenessStatus(
|
||||
status="ok",
|
||||
@@ -23,17 +22,15 @@ async def liveness(settings: SettingsDep) -> LivenessStatus:
|
||||
)
|
||||
|
||||
|
||||
@router.get("/ready", summary="Sonde de disponibilité", responses=REPONSE_INDISPONIBLE)
|
||||
@router.get("/ready", summary="Sonde de disponibilite")
|
||||
async def readiness(session: SessionDep) -> ReadinessStatus:
|
||||
try:
|
||||
version: str | None = await session.scalar(TIMESCALEDB_VERSION)
|
||||
# `# fmt: skip` contourne un bug de ruff format 0.16.7 : il retire les parenthèses de ce
|
||||
# `except` à deux types, ce qui produit une syntaxe invalide (`except A, B:`).
|
||||
except (SQLAlchemyError, OSError): # fmt: skip
|
||||
logger.exception("Base de données injoignable")
|
||||
except SQLAlchemyError, OSError:
|
||||
logger.exception("Base de donnees injoignable")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
detail="Base de données injoignable",
|
||||
detail="Base de donnees injoignable",
|
||||
) from None
|
||||
|
||||
if version is None:
|
||||
@@ -43,5 +40,4 @@ async def readiness(session: SessionDep) -> ReadinessStatus:
|
||||
detail="Extension TimescaleDB absente",
|
||||
)
|
||||
|
||||
logger.debug("Extension TimescaleDB en version %s", version)
|
||||
return ReadinessStatus(status="ready", database="reachable", timescaledb="loaded")
|
||||
return ReadinessStatus(status="ready", database="reachable", timescaledb=version)
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from app.api.deps import DriftServiceDep, OperateurDep
|
||||
from app.api.openapi import REPONSE_VALIDATION
|
||||
from app.schemas.drift import DriftReportResponse
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get(
|
||||
"/drift",
|
||||
response_model=list[DriftReportResponse],
|
||||
summary="Dernier rapport de dérive par site, plus la ligne globale",
|
||||
responses=REPONSE_VALIDATION,
|
||||
)
|
||||
async def get_drift(
|
||||
_: OperateurDep, service: DriftServiceDep, site_id: str | None = None
|
||||
) -> list[DriftReportResponse]:
|
||||
rapports = await service.derniers(site_id=site_id)
|
||||
return [DriftReportResponse.model_validate(rapport) for rapport in rapports]
|
||||
@@ -1,18 +0,0 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from app.api.deps import LecteurDep, PredictionServiceDep
|
||||
from app.schemas.prediction import PredictionSummaryResponse
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get(
|
||||
"",
|
||||
response_model=PredictionSummaryResponse,
|
||||
summary="Dernière prédiction de consommation par site",
|
||||
)
|
||||
async def get_predictions(
|
||||
_: LecteurDep, service: PredictionServiceDep
|
||||
) -> PredictionSummaryResponse:
|
||||
resume = await service.summary()
|
||||
return PredictionSummaryResponse.model_validate(resume)
|
||||
@@ -1,54 +0,0 @@
|
||||
from datetime import datetime
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Query, status
|
||||
|
||||
from app.api.deps import LecteurDep, ReadingServiceDep
|
||||
from app.api.openapi import REPONSE_VALIDATION, Reponses
|
||||
from app.schemas.errors import ErrorResponse
|
||||
from app.schemas.reading import ReadingResponse
|
||||
from app.services.reading import FenetreInverseeError, FenetreTropLargeError
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
REPONSES_FENETRE: Reponses = {
|
||||
**REPONSE_VALIDATION,
|
||||
400: {
|
||||
"model": ErrorResponse,
|
||||
"description": (
|
||||
"Fenêtre temporelle invalide : `start` postérieur ou égal à `end`, ou écart entre "
|
||||
"les deux supérieur à 90 jours."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
@router.get(
|
||||
"",
|
||||
response_model=list[ReadingResponse],
|
||||
summary="Liste l'historique des lectures",
|
||||
responses=REPONSES_FENETRE,
|
||||
)
|
||||
async def list_readings(
|
||||
_: LecteurDep,
|
||||
service: ReadingServiceDep,
|
||||
site_id: str | None = None,
|
||||
start: datetime | None = None,
|
||||
end: datetime | None = None,
|
||||
limit: int = Query(500, ge=1, le=2000),
|
||||
offset: int = Query(0, ge=0),
|
||||
) -> list[ReadingResponse]:
|
||||
try:
|
||||
lectures = await service.list_history(
|
||||
site_id=site_id, start=start, end=end, limit=limit, offset=offset
|
||||
)
|
||||
except FenetreInverseeError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail="`start` doit être strictement antérieur à `end`",
|
||||
) from erreur
|
||||
except FenetreTropLargeError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail="L'écart entre `start` et `end` ne peut pas dépasser 90 jours",
|
||||
) from erreur
|
||||
return [ReadingResponse.model_validate(lecture) for lecture in lectures]
|
||||
@@ -1,64 +0,0 @@
|
||||
from fastapi import APIRouter, HTTPException, status
|
||||
|
||||
from app.api.deps import AdminDep, LecteurDep, RecommendationServiceDep
|
||||
from app.api.openapi import REPONSE_VALIDATION, REPONSES_ADMIN, Reponses
|
||||
from app.schemas.errors import ErrorResponse
|
||||
from app.schemas.recommendation import (
|
||||
RecommendationGenerationResponse,
|
||||
RecommendationResponse,
|
||||
)
|
||||
from app.services.recommendation import RecommendationNotFoundError
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
REPONSES_GENERATION: Reponses = {**REPONSES_ADMIN, **REPONSE_VALIDATION}
|
||||
|
||||
REPONSES_INTROUVABLE: Reponses = {
|
||||
**REPONSE_VALIDATION,
|
||||
404: {"model": ErrorResponse, "description": "Aucune recommandation ne porte cet identifiant."},
|
||||
}
|
||||
|
||||
|
||||
@router.get("", response_model=list[RecommendationResponse], summary="Liste les recommandations")
|
||||
async def list_recommendations(
|
||||
_: LecteurDep, service: RecommendationServiceDep
|
||||
) -> list[RecommendationResponse]:
|
||||
recommendations = await service.list_all()
|
||||
return [RecommendationResponse.model_validate(r) for r in recommendations]
|
||||
|
||||
|
||||
@router.get(
|
||||
"/{recommendation_id}",
|
||||
response_model=RecommendationResponse,
|
||||
summary="Décrit une recommandation",
|
||||
responses=REPONSES_INTROUVABLE,
|
||||
)
|
||||
async def get_recommendation(
|
||||
recommendation_id: int, _: LecteurDep, service: RecommendationServiceDep
|
||||
) -> RecommendationResponse:
|
||||
try:
|
||||
recommendation = await service.get_by_id(recommendation_id)
|
||||
except RecommendationNotFoundError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND, detail="Recommandation introuvable"
|
||||
) from erreur
|
||||
return RecommendationResponse.model_validate(recommendation)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/generate",
|
||||
response_model=RecommendationGenerationResponse,
|
||||
summary="Génère les recommandations à partir des alertes",
|
||||
responses=REPONSES_GENERATION,
|
||||
)
|
||||
async def generate_recommendations(
|
||||
_: AdminDep,
|
||||
service: RecommendationServiceDep,
|
||||
site_id: str | None = None,
|
||||
) -> RecommendationGenerationResponse:
|
||||
rapport = await service.generate(site_id=site_id)
|
||||
return RecommendationGenerationResponse(
|
||||
alerts_examined=rapport.alertes_examinees,
|
||||
recommendations_created=rapport.recommandations_creees,
|
||||
already_present=rapport.deja_presentes,
|
||||
)
|
||||
@@ -1,16 +0,0 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from app.api.deps import AdminDep, SensorServiceDep
|
||||
from app.schemas.sensor import SensorStatusResponse
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get(
|
||||
"/status",
|
||||
response_model=SensorStatusResponse,
|
||||
summary="État de santé des capteurs par site",
|
||||
)
|
||||
async def get_status(_: AdminDep, service: SensorServiceDep) -> SensorStatusResponse:
|
||||
etat = await service.status()
|
||||
return SensorStatusResponse.model_validate(etat)
|
||||
@@ -1,52 +0,0 @@
|
||||
from fastapi import APIRouter, HTTPException, status
|
||||
|
||||
from app.api.deps import LecteurDep, SiteServiceDep
|
||||
from app.api.openapi import REPONSE_VALIDATION, Reponses
|
||||
from app.schemas.errors import ErrorResponse
|
||||
from app.schemas.site import SiteCurrentResponse, SiteResponse
|
||||
from app.services.site import SiteNotFoundError
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
REPONSES_INTROUVABLE: Reponses = {
|
||||
**REPONSE_VALIDATION,
|
||||
404: {"model": ErrorResponse, "description": "Aucun site ne porte cet identifiant."},
|
||||
}
|
||||
|
||||
|
||||
@router.get("", response_model=list[SiteResponse], summary="Liste les sites")
|
||||
async def list_sites(_: LecteurDep, service: SiteServiceDep) -> list[SiteResponse]:
|
||||
sites = await service.list_all()
|
||||
return [SiteResponse.model_validate(site) for site in sites]
|
||||
|
||||
|
||||
@router.get(
|
||||
"/{site_id}",
|
||||
response_model=SiteResponse,
|
||||
summary="Décrit un site",
|
||||
responses=REPONSES_INTROUVABLE,
|
||||
)
|
||||
async def get_site(site_id: str, _: LecteurDep, service: SiteServiceDep) -> SiteResponse:
|
||||
try:
|
||||
site = await service.get_by_id(site_id)
|
||||
except SiteNotFoundError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND, detail="Site introuvable"
|
||||
) from erreur
|
||||
return SiteResponse.model_validate(site)
|
||||
|
||||
|
||||
@router.get(
|
||||
"/{site_id}/current",
|
||||
response_model=SiteCurrentResponse,
|
||||
summary="Dernière mesure d'un site",
|
||||
responses=REPONSES_INTROUVABLE,
|
||||
)
|
||||
async def get_current(site_id: str, _: LecteurDep, service: SiteServiceDep) -> SiteCurrentResponse:
|
||||
try:
|
||||
actuel = await service.current(site_id)
|
||||
except SiteNotFoundError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND, detail="Site introuvable"
|
||||
) from erreur
|
||||
return SiteCurrentResponse.model_validate(actuel)
|
||||
@@ -1,16 +0,0 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from app.api.deps import LecteurDep, StatsServiceDep
|
||||
from app.schemas.stats import StatsSummaryResponse
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get(
|
||||
"/summary",
|
||||
response_model=StatsSummaryResponse,
|
||||
summary="Résume la consommation instantanée du parc",
|
||||
)
|
||||
async def get_summary(_: LecteurDep, service: StatsServiceDep) -> StatsSummaryResponse:
|
||||
resume = await service.summary()
|
||||
return StatsSummaryResponse.model_validate(resume)
|
||||
@@ -1,142 +0,0 @@
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Response, status
|
||||
|
||||
from app.api.deps import AdminDep, UserServiceDep
|
||||
from app.api.openapi import REPONSE_VALIDATION, Reponses
|
||||
from app.core.logging import get_logger
|
||||
from app.schemas.errors import ErrorResponse
|
||||
from app.schemas.user import (
|
||||
TemporaryPasswordResponse,
|
||||
UserCreateRequest,
|
||||
UserResponse,
|
||||
UserUpdateRequest,
|
||||
)
|
||||
from app.services.user import EmailAlreadyUsedError, LastAdminError, UserNotFoundError
|
||||
|
||||
router = APIRouter()
|
||||
logger = get_logger(__name__)
|
||||
|
||||
REPONSES_CREATION: Reponses = {
|
||||
**REPONSE_VALIDATION,
|
||||
409: {"model": ErrorResponse, "description": "Adresse déjà portée par un autre compte."},
|
||||
}
|
||||
|
||||
REPONSES_INTROUVABLE: Reponses = {
|
||||
**REPONSE_VALIDATION,
|
||||
404: {"model": ErrorResponse, "description": "Aucun compte ne porte cet identifiant."},
|
||||
}
|
||||
|
||||
REPONSES_MODIFICATION: Reponses = {
|
||||
**REPONSES_INTROUVABLE,
|
||||
400: {"model": ErrorResponse, "description": "Corps vide, aucune modification demandée."},
|
||||
409: {
|
||||
"model": ErrorResponse,
|
||||
"description": (
|
||||
"L'opération laisserait la plateforme sans administrateur actif, qu'il s'agisse de "
|
||||
"rétrograder le dernier ou de le désactiver."
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
@router.get("", response_model=list[UserResponse], summary="Liste les comptes")
|
||||
async def list_users(_: AdminDep, service: UserServiceDep) -> list[UserResponse]:
|
||||
comptes = await service.list_all()
|
||||
return [UserResponse.model_validate(compte) for compte in comptes]
|
||||
|
||||
|
||||
@router.post(
|
||||
"",
|
||||
response_model=TemporaryPasswordResponse,
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
summary="Crée un compte avec un mot de passe provisoire",
|
||||
responses=REPONSES_CREATION,
|
||||
)
|
||||
async def create_user(
|
||||
payload: UserCreateRequest,
|
||||
acteur: AdminDep,
|
||||
service: UserServiceDep,
|
||||
response: Response,
|
||||
) -> TemporaryPasswordResponse:
|
||||
# Le mot de passe provisoire ne doit être conservé par aucun intermédiaire.
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
try:
|
||||
cree = await service.create(
|
||||
actor=acteur,
|
||||
email=payload.email,
|
||||
role=payload.role,
|
||||
full_name=payload.full_name,
|
||||
)
|
||||
except EmailAlreadyUsedError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_409_CONFLICT, detail="Adresse déjà utilisée"
|
||||
) from erreur
|
||||
|
||||
logger.info("user.created actor=%s target=%s", acteur.id, cree.user.id)
|
||||
return TemporaryPasswordResponse(
|
||||
user=UserResponse.model_validate(cree.user),
|
||||
temporary_password=cree.temporary_password,
|
||||
)
|
||||
|
||||
|
||||
@router.patch(
|
||||
"/{user_id}",
|
||||
response_model=UserResponse,
|
||||
summary="Change le rôle ou l'activation",
|
||||
responses=REPONSES_MODIFICATION,
|
||||
)
|
||||
async def update_user(
|
||||
user_id: UUID,
|
||||
payload: UserUpdateRequest,
|
||||
acteur: AdminDep,
|
||||
service: UserServiceDep,
|
||||
) -> UserResponse:
|
||||
compte = None
|
||||
try:
|
||||
if payload.role is not None:
|
||||
compte = await service.change_role(actor=acteur, user_id=user_id, role=payload.role)
|
||||
if payload.is_active is not None:
|
||||
compte = await service.set_active(
|
||||
actor=acteur, user_id=user_id, is_active=payload.is_active
|
||||
)
|
||||
except UserNotFoundError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND, detail="Compte introuvable"
|
||||
) from erreur
|
||||
except LastAdminError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_409_CONFLICT,
|
||||
detail="Dernier administrateur actif, l'opération le laisserait sans successeur",
|
||||
) from erreur
|
||||
|
||||
if compte is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST, detail="Aucune modification demandée"
|
||||
)
|
||||
logger.info("user.updated actor=%s target=%s", acteur.id, user_id)
|
||||
return UserResponse.model_validate(compte)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/{user_id}/password-reset",
|
||||
response_model=TemporaryPasswordResponse,
|
||||
summary="Réinitialise le mot de passe et ferme les sessions",
|
||||
responses=REPONSES_INTROUVABLE,
|
||||
)
|
||||
async def reset_password(
|
||||
user_id: UUID, acteur: AdminDep, service: UserServiceDep, response: Response
|
||||
) -> TemporaryPasswordResponse:
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
try:
|
||||
reinitialise = await service.reset_password(actor=acteur, user_id=user_id)
|
||||
except UserNotFoundError as erreur:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND, detail="Compte introuvable"
|
||||
) from erreur
|
||||
|
||||
logger.info("user.password_reset actor=%s target=%s", acteur.id, user_id)
|
||||
return TemporaryPasswordResponse(
|
||||
user=UserResponse.model_validate(reinitialise.user),
|
||||
temporary_password=reinitialise.temporary_password,
|
||||
)
|
||||
@@ -1,49 +1,6 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from app.api.openapi import (
|
||||
REPONSE_SERVEUR,
|
||||
REPONSES_ADMIN,
|
||||
REPONSES_LECTEUR,
|
||||
REPONSES_OPERATEUR,
|
||||
)
|
||||
from app.api.v1.endpoints import (
|
||||
alerts,
|
||||
auth,
|
||||
health,
|
||||
monitoring,
|
||||
predictions,
|
||||
readings,
|
||||
recommendations,
|
||||
sensors,
|
||||
sites,
|
||||
stats,
|
||||
users,
|
||||
)
|
||||
from app.api.v1.endpoints import health
|
||||
|
||||
api_router = APIRouter(responses=REPONSE_SERVEUR)
|
||||
api_router.include_router(health.router, prefix="/health", tags=["health"])
|
||||
api_router.include_router(auth.router, prefix="/auth", tags=["auth"])
|
||||
api_router.include_router(users.router, prefix="/users", tags=["users"], responses=REPONSES_ADMIN)
|
||||
api_router.include_router(sites.router, prefix="/sites", tags=["sites"], responses=REPONSES_LECTEUR)
|
||||
api_router.include_router(
|
||||
alerts.router, prefix="/alerts", tags=["alerts"], responses=REPONSES_LECTEUR
|
||||
)
|
||||
api_router.include_router(
|
||||
recommendations.router,
|
||||
prefix="/recommendations",
|
||||
tags=["recommendations"],
|
||||
responses=REPONSES_LECTEUR,
|
||||
)
|
||||
api_router.include_router(stats.router, prefix="/stats", tags=["stats"], responses=REPONSES_LECTEUR)
|
||||
api_router.include_router(
|
||||
readings.router, prefix="/readings", tags=["readings"], responses=REPONSES_LECTEUR
|
||||
)
|
||||
api_router.include_router(
|
||||
sensors.router, prefix="/sensors", tags=["sensors"], responses=REPONSES_ADMIN
|
||||
)
|
||||
api_router.include_router(
|
||||
predictions.router, prefix="/predictions", tags=["predictions"], responses=REPONSES_LECTEUR
|
||||
)
|
||||
api_router.include_router(
|
||||
monitoring.router, prefix="/monitoring", tags=["monitoring"], responses=REPONSES_OPERATEUR
|
||||
)
|
||||
api_router = APIRouter()
|
||||
api_router.include_router(health.router, prefix="/health")
|
||||
|
||||
@@ -1,201 +0,0 @@
|
||||
# Pourquoi : `create_admin()` est une commande et non une révision Alembic. Une révision qui
|
||||
# insérerait un compte graverait son empreinte dans Git pour toujours, et son mot de passe
|
||||
# serait connu de quiconque lit le dépôt. L'ADR 0001 pose par ailleurs qu'Alembic porte le
|
||||
# schéma, pas les données.
|
||||
# Piège : le mot de passe ne transite jamais par `argv`, visible de tout `ps`, ni par
|
||||
# l'historique du shell. Il est saisi par `getpass` ou tiré au sort par la commande.
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import secrets
|
||||
import string
|
||||
import sys
|
||||
from getpass import getpass
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from pydantic import SecretStr
|
||||
|
||||
from app.core.config import Settings, get_settings
|
||||
from app.core.hashing import build_hasher
|
||||
from app.core.roles import Role
|
||||
from app.db.session import get_session_factory
|
||||
from app.main import create_app
|
||||
from app.repositories.alert import AlertRepository
|
||||
from app.repositories.recommendation import RecommendationRepository
|
||||
from app.repositories.user import UserRepository
|
||||
from app.schemas.auth import PASSWORD_MIN_LENGTH, SPECIAL_CHARACTERS, valide_complexite
|
||||
from app.services.recommendation import RecommendationService
|
||||
|
||||
LONGUEUR_MOT_DE_PASSE_GENERE = 24
|
||||
CHEMIN_CONTRAT = Path(__file__).resolve().parent.parent / "openapi.json"
|
||||
|
||||
|
||||
async def create_admin(
|
||||
settings: Settings, *, email: str, password: str, force: bool
|
||||
) -> tuple[bool, str]:
|
||||
hacheur = build_hasher(
|
||||
time_cost=settings.argon2_time_cost,
|
||||
memory_cost_kib=settings.argon2_memory_cost_kib,
|
||||
parallelism=settings.argon2_parallelism,
|
||||
max_concurrency=settings.argon2_max_concurrency,
|
||||
)
|
||||
empreinte = await hacheur.hash(password)
|
||||
|
||||
async with get_session_factory()() as session:
|
||||
depot = UserRepository(session)
|
||||
|
||||
if not force and await depot.count_active_admins() > 0:
|
||||
return False, "Un administrateur actif existe déjà, relancer avec --force pour forcer"
|
||||
|
||||
if await depot.get_by_email(email) is not None:
|
||||
return False, f"Le compte {email} existe déjà"
|
||||
|
||||
await depot.create(
|
||||
email=email,
|
||||
password_hash=empreinte,
|
||||
role=Role.ADMIN,
|
||||
must_change_password=True,
|
||||
)
|
||||
await session.commit()
|
||||
|
||||
return (
|
||||
True,
|
||||
f"Administrateur {email.strip().lower()} créé, mot de passe à changer à la connexion",
|
||||
)
|
||||
|
||||
|
||||
async def generate_recommendations(*, site_id: str | None) -> str:
|
||||
async with get_session_factory()() as session:
|
||||
service = RecommendationService(
|
||||
recommendations=RecommendationRepository(session),
|
||||
alerts=AlertRepository(session),
|
||||
transaction=session,
|
||||
)
|
||||
rapport = await service.generate(site_id=site_id)
|
||||
|
||||
return (
|
||||
f"{rapport.alertes_examinees} alerte(s) examinée(s), "
|
||||
f"{rapport.recommandations_creees} recommandation(s) créée(s), "
|
||||
f"{rapport.deja_presentes} déjà présente(s)"
|
||||
)
|
||||
|
||||
|
||||
# Piège : le schéma ne doit dépendre ni du `.env` du poste ni des variables `APP_*`, sinon le
|
||||
# fichier versionné changerait de machine en machine et le test de dérive deviendrait un oracle
|
||||
# de configuration locale. Tout ce qui atteint le schéma est donc posé ici, `_env_file` compris.
|
||||
def settings_du_contrat() -> Settings:
|
||||
return Settings(
|
||||
_env_file=None,
|
||||
name="EnerVision API",
|
||||
version="0.1.0",
|
||||
env="local",
|
||||
api_prefix="/api/v1",
|
||||
secret_key=SecretStr("contrat-openapi-sans-effet-sur-le-schema"),
|
||||
database_url="postgresql+asyncpg://openapi:contrat@localhost:5432/enervision",
|
||||
)
|
||||
|
||||
|
||||
def schema_du_contrat() -> dict[str, Any]:
|
||||
schema: dict[str, Any] = create_app(settings_du_contrat()).openapi()
|
||||
return schema
|
||||
|
||||
|
||||
def rend_le_contrat() -> str:
|
||||
return json.dumps(schema_du_contrat(), indent=2, ensure_ascii=False) + "\n"
|
||||
|
||||
|
||||
def export_openapi(destination: Path) -> str:
|
||||
destination.write_text(rend_le_contrat(), encoding="utf-8")
|
||||
return f"Contrat OpenAPI écrit dans {destination}"
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(prog="python -m app.cli", description="Outils EnerVision")
|
||||
sous_commandes = parser.add_subparsers(dest="commande", required=True)
|
||||
|
||||
admin = sous_commandes.add_parser("create-admin", help="Crée le premier administrateur")
|
||||
admin.add_argument("--email", required=True)
|
||||
admin.add_argument(
|
||||
"--generate", action="store_true", help="Tire un mot de passe au sort et l'affiche une fois"
|
||||
)
|
||||
admin.add_argument(
|
||||
"--force", action="store_true", help="Crée le compte même si un administrateur existe"
|
||||
)
|
||||
|
||||
contrat = sous_commandes.add_parser(
|
||||
"export-openapi", help="Écrit le contrat OpenAPI sur disque"
|
||||
)
|
||||
contrat.add_argument("--output", default=str(CHEMIN_CONTRAT))
|
||||
|
||||
recommandations = sous_commandes.add_parser(
|
||||
"generate-recommendations",
|
||||
help="Applique le moteur de règles aux alertes en base",
|
||||
)
|
||||
recommandations.add_argument(
|
||||
"--site-id", default=None, help="Limite le traitement aux alertes d'un site"
|
||||
)
|
||||
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()
|
||||
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 mot_de_passe != getpass("Confirmation : "):
|
||||
raise SystemExit("Les deux saisies diffèrent")
|
||||
return mot_de_passe
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
arguments = build_parser().parse_args(argv)
|
||||
|
||||
if arguments.commande == "export-openapi":
|
||||
print(export_openapi(Path(arguments.output)))
|
||||
return 0
|
||||
|
||||
if arguments.commande == "generate-recommendations":
|
||||
print(asyncio.run(generate_recommendations(site_id=arguments.site_id)))
|
||||
return 0
|
||||
|
||||
mot_de_passe = read_password(generate=arguments.generate)
|
||||
|
||||
succes, message = asyncio.run(
|
||||
create_admin(
|
||||
get_settings(),
|
||||
email=arguments.email,
|
||||
password=mot_de_passe,
|
||||
force=arguments.force,
|
||||
)
|
||||
)
|
||||
print(message)
|
||||
return 0 if succes else 1
|
||||
|
||||
|
||||
if __name__ == "__main__": # pragma: no cover
|
||||
sys.exit(main())
|
||||
@@ -1,17 +1,10 @@
|
||||
from functools import lru_cache
|
||||
from typing import Literal, Self
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import Field, SecretStr, field_validator, model_validator
|
||||
from pydantic import Field, SecretStr
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
|
||||
Environment = Literal["local", "dev", "staging", "prod"]
|
||||
SameSite = Literal["lax", "strict", "none"]
|
||||
|
||||
SECRET_KEY_MIN_LENGTH = 32
|
||||
REFRESH_COOKIE_DEFAUT = "ev_refresh"
|
||||
SENTINELLES_INTERDITES = frozenset(
|
||||
{"change_me", "changeme", "secret", "secret-de-test", "changez-moi", "todo"}
|
||||
)
|
||||
|
||||
|
||||
class Settings(BaseSettings):
|
||||
@@ -34,71 +27,6 @@ class Settings(BaseSettings):
|
||||
database_pool_size: int = 5
|
||||
database_max_overflow: int = 10
|
||||
|
||||
mock_api_base_url: str = "https://api-mock.charlieandre.fr"
|
||||
mock_api_username: str | None = None
|
||||
mock_api_password: SecretStr | None = None
|
||||
mock_api_timeout_seconds: float = Field(default=10.0, gt=0)
|
||||
|
||||
jwt_issuer: str = "enervision-api"
|
||||
jwt_audience: str = "enervision-web"
|
||||
access_token_ttl_seconds: int = Field(default=900, ge=60, le=3600)
|
||||
refresh_token_ttl_seconds: int = Field(default=604800, ge=3600, le=2592000)
|
||||
|
||||
refresh_cookie_name: str = REFRESH_COOKIE_DEFAUT
|
||||
cookie_path: str = "/api/v1/auth"
|
||||
cookie_samesite: SameSite = "strict"
|
||||
cookie_secure: bool | None = None
|
||||
|
||||
argon2_time_cost: int = Field(default=2, ge=1, le=10)
|
||||
argon2_memory_cost_kib: int = Field(default=19456, ge=8192)
|
||||
argon2_parallelism: int = Field(default=1, ge=1, le=4)
|
||||
argon2_max_concurrency: int = Field(default=4, ge=1, le=32)
|
||||
|
||||
login_window_seconds: int = Field(default=900, ge=60)
|
||||
login_max_failures_per_identifier_and_ip: int = Field(default=5, ge=1)
|
||||
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
|
||||
|
||||
s3_endpoint_url: str | None = None
|
||||
s3_region: str = "garage"
|
||||
s3_access_key: str | None = None
|
||||
s3_secret_key: SecretStr | None = None
|
||||
s3_bucket: str | None = None
|
||||
s3_sse_key: SecretStr | None = None
|
||||
reading_retention_days: int = Field(default=1095, ge=30)
|
||||
|
||||
# Compose passe `APP_METRICS_TOKEN` et les réglages S3 vides quand rien n'est posé : vide vaut
|
||||
# absent, sinon `/metrics` exigerait un `Bearer` sans valeur et l'archivage un endpoint vide.
|
||||
@field_validator(
|
||||
"metrics_token",
|
||||
"s3_endpoint_url",
|
||||
"s3_access_key",
|
||||
"s3_secret_key",
|
||||
"s3_bucket",
|
||||
"s3_sse_key",
|
||||
mode="before",
|
||||
)
|
||||
@classmethod
|
||||
def _jeton_vide_vaut_absent(cls, valeur: object) -> object:
|
||||
return None if valeur == "" else valeur
|
||||
|
||||
@property
|
||||
def allowed_origins(self) -> list[str]:
|
||||
return [origin.strip() for origin in self.cors_origins.split(",") if origin.strip()]
|
||||
@@ -107,44 +35,6 @@ class Settings(BaseSettings):
|
||||
def is_production(self) -> bool:
|
||||
return self.env == "prod"
|
||||
|
||||
@property
|
||||
def cookies_are_secure(self) -> bool:
|
||||
return self.env != "local" if self.cookie_secure is None else self.cookie_secure
|
||||
|
||||
@property
|
||||
def api_docs_are_exposed(self) -> bool:
|
||||
if self.expose_api_docs is not None:
|
||||
return self.expose_api_docs
|
||||
return self.env not in ("staging", "prod")
|
||||
|
||||
@model_validator(mode="after")
|
||||
def _refuse_les_configurations_dangereuses(self) -> Self:
|
||||
secret = self.secret_key.get_secret_value()
|
||||
if len(secret) < SECRET_KEY_MIN_LENGTH:
|
||||
raise ValueError(
|
||||
f"APP_SECRET_KEY doit faire au moins {SECRET_KEY_MIN_LENGTH} caractères"
|
||||
)
|
||||
if secret.strip().lower() in SENTINELLES_INTERDITES:
|
||||
raise ValueError("APP_SECRET_KEY est une valeur d'exemple, il faut en générer une")
|
||||
|
||||
# Piège : `create_app()` passe `debug` à FastAPI, qui renvoie alors la trace complète
|
||||
# au client, et à l'engine, qui journalise le SQL et ses paramètres.
|
||||
if self.debug and self.env in ("staging", "prod"):
|
||||
raise ValueError("APP_DEBUG doit rester faux hors des environnements locaux")
|
||||
|
||||
if "*" in self.cors_origins:
|
||||
raise ValueError("APP_CORS_ORIGINS n'accepte pas de joker, les origines sont listées")
|
||||
|
||||
# Sans origines, aucun middleware CORS n'est monté et la vérification d'`Origin` des
|
||||
# routes d'authentification n'a plus de référentiel auquel comparer.
|
||||
if self.env != "local" and not self.allowed_origins:
|
||||
raise ValueError("APP_CORS_ORIGINS doit lister au moins une origine hors local")
|
||||
|
||||
if self.cookie_samesite == "none" and not self.cookies_are_secure:
|
||||
raise ValueError("Un cookie SameSite=None est rejeté par les navigateurs sans Secure")
|
||||
|
||||
return self
|
||||
|
||||
|
||||
@lru_cache
|
||||
def get_settings() -> Settings:
|
||||
|
||||
@@ -1,61 +0,0 @@
|
||||
# Piège : le cookie de suppression doit reprendre exactement le nom et le `Path` du cookie
|
||||
# posé, sinon le navigateur en garde une copie et la déconnexion n'est que cosmétique.
|
||||
# `RefreshCookie.expired()` existe pour que les deux ne puissent pas diverger.
|
||||
|
||||
from dataclasses import asdict, dataclass
|
||||
from typing import Any, Self
|
||||
|
||||
from app.core.config import SameSite, Settings
|
||||
|
||||
SECURE_PREFIX = "__Secure-"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class RefreshCookie:
|
||||
key: str
|
||||
value: str
|
||||
max_age: int
|
||||
path: str
|
||||
secure: bool
|
||||
httponly: bool
|
||||
samesite: SameSite
|
||||
|
||||
@classmethod
|
||||
def build(cls, settings: Settings, value: str) -> Self:
|
||||
return cls(
|
||||
key=cookie_name(settings),
|
||||
value=value,
|
||||
max_age=settings.refresh_token_ttl_seconds,
|
||||
path=settings.cookie_path,
|
||||
secure=settings.cookies_are_secure,
|
||||
httponly=True,
|
||||
samesite=settings.cookie_samesite,
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def expired(cls, settings: Settings) -> Self:
|
||||
return cls(
|
||||
key=cookie_name(settings),
|
||||
value="",
|
||||
max_age=0,
|
||||
path=settings.cookie_path,
|
||||
secure=settings.cookies_are_secure,
|
||||
httponly=True,
|
||||
samesite=settings.cookie_samesite,
|
||||
)
|
||||
|
||||
def as_kwargs(self) -> dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
def as_deletion_kwargs(self) -> dict[str, Any]:
|
||||
# `Response.delete_cookie()` n'accepte ni `value` ni `max_age`, mais il exige le même
|
||||
# nom, le même chemin et les mêmes attributs, sinon le navigateur garde le cookie.
|
||||
arguments = asdict(self)
|
||||
del arguments["value"], arguments["max_age"]
|
||||
return arguments
|
||||
|
||||
|
||||
def cookie_name(settings: Settings) -> str:
|
||||
if settings.cookies_are_secure:
|
||||
return f"{SECURE_PREFIX}{settings.refresh_cookie_name}"
|
||||
return settings.refresh_cookie_name
|
||||
@@ -1,63 +0,0 @@
|
||||
# Piège : `PasswordHasher.verify()` bloque 17 ms. Appelé tel quel dans un `async def`, il fige
|
||||
# la boucle d'événements et gèle toutes les requêtes en cours, pas seulement la connexion.
|
||||
# `Argon2Hasher` le pousse donc dans un fil, sous un `CapacityLimiter` : le pool par défaut
|
||||
# d'anyio accepte 40 fils, soit 40 x 19 Mio dans le pire cas sur une machine qui héberge aussi
|
||||
# PostgreSQL, Prometheus et Grafana.
|
||||
# Piège : `verify_dummy()` doit être appelé quand l'utilisateur est introuvable. Sans lui,
|
||||
# l'écart entre 2 ms et 17 ms est un oracle d'existence de compte, mesurable à distance.
|
||||
|
||||
import secrets
|
||||
|
||||
import anyio
|
||||
import anyio.to_thread
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import Argon2Error, InvalidHashError, VerificationError
|
||||
|
||||
_ERREURS_DE_VERIFICATION = (VerificationError, InvalidHashError, Argon2Error)
|
||||
|
||||
|
||||
class Argon2Hasher:
|
||||
def __init__(self, hasher: PasswordHasher, *, max_concurrency: int) -> None:
|
||||
self._hasher = hasher
|
||||
self._limiter = anyio.CapacityLimiter(max_concurrency)
|
||||
self._leurre = hasher.hash(secrets.token_urlsafe(32))
|
||||
|
||||
async def hash(self, password: str) -> str:
|
||||
return await anyio.to_thread.run_sync(self._hasher.hash, password, limiter=self._limiter)
|
||||
|
||||
async def verify(self, stored: str, password: str) -> bool:
|
||||
return await anyio.to_thread.run_sync(self._verify, stored, password, limiter=self._limiter)
|
||||
|
||||
async def verify_dummy(self) -> None:
|
||||
await self.verify(self._leurre, "")
|
||||
|
||||
def needs_rehash(self, stored: str) -> bool:
|
||||
try:
|
||||
return self._hasher.check_needs_rehash(stored)
|
||||
except _ERREURS_DE_VERIFICATION:
|
||||
return True
|
||||
|
||||
def _verify(self, stored: str, password: str) -> bool:
|
||||
try:
|
||||
return self._hasher.verify(stored, password)
|
||||
except _ERREURS_DE_VERIFICATION:
|
||||
return False
|
||||
|
||||
|
||||
def build_hasher(
|
||||
*,
|
||||
time_cost: int,
|
||||
memory_cost_kib: int,
|
||||
parallelism: int,
|
||||
max_concurrency: int,
|
||||
) -> Argon2Hasher:
|
||||
return Argon2Hasher(
|
||||
PasswordHasher(
|
||||
time_cost=time_cost,
|
||||
memory_cost=memory_cost_kib,
|
||||
parallelism=parallelism,
|
||||
hash_len=32,
|
||||
salt_len=16,
|
||||
),
|
||||
max_concurrency=max_concurrency,
|
||||
)
|
||||
@@ -1,48 +1,8 @@
|
||||
# Pourquoi : `RedactingFilter` est la troisième ligne de défense, pas la première. La première
|
||||
# est de ne jamais passer un secret au logger, la deuxième de ne jamais mettre un jeton dans
|
||||
# une URL, que le journal d'accès enregistrerait de toute façon. Le filtre rattrape l'erreur
|
||||
# que personne n'a relue, notamment l'écho SQL quand `debug` est actif.
|
||||
|
||||
import logging
|
||||
import re
|
||||
from logging.config import dictConfig
|
||||
from typing import Final
|
||||
|
||||
from app.core.config import Settings
|
||||
|
||||
CAVIARDAGE: Final = "[expurgé]"
|
||||
|
||||
REMPLACEMENTS: Final[tuple[tuple[re.Pattern[str], str], ...]] = (
|
||||
(re.compile(r"Bearer\s+[A-Za-z0-9._~+/-]{20,}=*"), f"Bearer {CAVIARDAGE}"),
|
||||
(re.compile(r"eyJ[A-Za-z0-9._-]{20,}"), CAVIARDAGE),
|
||||
(re.compile(r"\$argon2[a-z0-9]*\$\S+"), CAVIARDAGE),
|
||||
(
|
||||
re.compile(r'("?(?:password|mot_de_passe|secret|token)"?\s*[:=]\s*")[^"]*(")'),
|
||||
rf"\1{CAVIARDAGE}\2",
|
||||
),
|
||||
(
|
||||
re.compile(r"((?:password|mot_de_passe|secret|token)[A-Za-z_]*=)[^&\s;\"]+"),
|
||||
rf"\1{CAVIARDAGE}",
|
||||
),
|
||||
(re.compile(r"(ev_refresh=)[^;\s]+"), rf"\1{CAVIARDAGE}"),
|
||||
)
|
||||
|
||||
|
||||
def redact(message: str) -> str:
|
||||
for motif, remplacement in REMPLACEMENTS:
|
||||
message = motif.sub(remplacement, message)
|
||||
return message
|
||||
|
||||
|
||||
class RedactingFilter(logging.Filter):
|
||||
def filter(self, record: logging.LogRecord) -> bool:
|
||||
message = record.getMessage()
|
||||
expurge = redact(message)
|
||||
if expurge != message:
|
||||
record.msg = expurge
|
||||
record.args = ()
|
||||
return True
|
||||
|
||||
|
||||
def configure_logging(settings: Settings) -> None:
|
||||
formatter = "json" if settings.is_production else "console"
|
||||
@@ -50,9 +10,6 @@ def configure_logging(settings: Settings) -> None:
|
||||
{
|
||||
"version": 1,
|
||||
"disable_existing_loggers": False,
|
||||
"filters": {
|
||||
"redaction": {"()": "app.core.logging.RedactingFilter"},
|
||||
},
|
||||
"formatters": {
|
||||
"console": {
|
||||
"format": "%(asctime)s %(levelname)-8s %(name)s %(message)s",
|
||||
@@ -66,7 +23,6 @@ def configure_logging(settings: Settings) -> None:
|
||||
"default": {
|
||||
"class": "logging.StreamHandler",
|
||||
"formatter": formatter,
|
||||
"filters": ["redaction"],
|
||||
"stream": "ext://sys.stdout",
|
||||
},
|
||||
},
|
||||
|
||||
@@ -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)
|
||||
@@ -1,18 +0,0 @@
|
||||
# Pourquoi : tout le code métier dépend de `Principal` et jamais du modèle ORM ni des claims
|
||||
# du jeton. C'est ce qui garde la bascule vers un fournisseur OIDC locale à
|
||||
# `get_current_principal()` et à `AuthService.authenticate()`, au lieu de la répandre dans
|
||||
# chaque endpoint.
|
||||
|
||||
from dataclasses import dataclass
|
||||
from uuid import UUID
|
||||
|
||||
from app.core.roles import AccountKind, Role
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Principal:
|
||||
id: UUID
|
||||
email: str
|
||||
role: Role
|
||||
kind: AccountKind
|
||||
must_change_password: bool
|
||||
@@ -1,26 +0,0 @@
|
||||
from enum import StrEnum
|
||||
from typing import Final
|
||||
|
||||
|
||||
class Role(StrEnum):
|
||||
# Contrainte : ces valeurs voyagent en base, en JSON et dans les jetons. Elles restent
|
||||
# en ASCII, contrairement au libellé « opérateur » affiché à l'utilisateur.
|
||||
LECTEUR = "lecteur"
|
||||
OPERATEUR = "operateur"
|
||||
ADMIN = "admin"
|
||||
|
||||
|
||||
class AccountKind(StrEnum):
|
||||
HUMAIN = "human"
|
||||
SERVICE = "service"
|
||||
|
||||
|
||||
ROLE_RANK: Final[dict[Role, int]] = {
|
||||
Role.LECTEUR: 0,
|
||||
Role.OPERATEUR: 1,
|
||||
Role.ADMIN: 2,
|
||||
}
|
||||
|
||||
|
||||
def has_at_least(actual: Role, required: Role) -> bool:
|
||||
return ROLE_RANK[actual] >= ROLE_RANK[required]
|
||||
@@ -1,117 +0,0 @@
|
||||
# Piège : `decode_access_token()` porte trois barrières indépendantes, et retirer l'une
|
||||
# d'elles ne casse aucun test évident. L'algorithme est épinglé, sinon un jeton forgé en
|
||||
# `alg: none` passerait. L'audience et l'émetteur sont vérifiés, sinon un jeton émis pour
|
||||
# un autre service serait accepté. Le claim `typ` est comparé, sinon un jeton de
|
||||
# rafraîchissement servirait de jeton d'accès, ce qui transformerait une fenêtre de
|
||||
# 15 minutes en fenêtre de 7 jours.
|
||||
# Contrainte : ce module ne lit jamais `get_settings()`, qui est mis en cache par
|
||||
# `lru_cache` et se contaminerait entre tests. Tout paramètre arrive par `TokenPolicy`.
|
||||
|
||||
import hashlib
|
||||
import secrets
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import Final
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
import jwt
|
||||
|
||||
ACCESS_TOKEN_TYPE: Final = "access" # noqa: S105
|
||||
REFRESH_SECRET_BYTES: Final = 32
|
||||
|
||||
_ALGORITHME: Final = "HS256"
|
||||
_CLAIMS_REQUIS: Final = ["iss", "aud", "sub", "iat", "exp", "jti", "typ", "role", "kind"]
|
||||
|
||||
|
||||
class TokenInvalidError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class TokenExpiredError(TokenInvalidError):
|
||||
pass
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class TokenPolicy:
|
||||
secret: str
|
||||
issuer: str
|
||||
audience: str
|
||||
access_ttl: timedelta
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class AccessClaims:
|
||||
subject: UUID
|
||||
role: str
|
||||
kind: str
|
||||
token_id: UUID
|
||||
issued_at: datetime
|
||||
|
||||
|
||||
def encode_access_token(
|
||||
policy: TokenPolicy,
|
||||
*,
|
||||
subject: UUID,
|
||||
role: str,
|
||||
kind: str,
|
||||
now: datetime | None = None,
|
||||
) -> str:
|
||||
emis_a = now or datetime.now(UTC)
|
||||
return jwt.encode(
|
||||
{
|
||||
"iss": policy.issuer,
|
||||
"aud": policy.audience,
|
||||
"sub": str(subject),
|
||||
"iat": emis_a,
|
||||
"exp": emis_a + policy.access_ttl,
|
||||
"jti": str(uuid4()),
|
||||
"typ": ACCESS_TOKEN_TYPE,
|
||||
"role": role,
|
||||
"kind": kind,
|
||||
},
|
||||
policy.secret,
|
||||
algorithm=_ALGORITHME,
|
||||
)
|
||||
|
||||
|
||||
def decode_access_token(policy: TokenPolicy, token: str) -> AccessClaims:
|
||||
try:
|
||||
charge = jwt.decode(
|
||||
token,
|
||||
policy.secret,
|
||||
algorithms=[_ALGORITHME],
|
||||
audience=policy.audience,
|
||||
issuer=policy.issuer,
|
||||
options={"require": _CLAIMS_REQUIS},
|
||||
)
|
||||
except jwt.ExpiredSignatureError as erreur:
|
||||
raise TokenExpiredError("Jeton expiré") from erreur
|
||||
except jwt.InvalidTokenError as erreur:
|
||||
raise TokenInvalidError("Jeton invalide") from erreur
|
||||
|
||||
if charge["typ"] != ACCESS_TOKEN_TYPE:
|
||||
raise TokenInvalidError("Type de jeton inattendu")
|
||||
|
||||
try:
|
||||
sujet = UUID(charge["sub"])
|
||||
identifiant = UUID(charge["jti"])
|
||||
except (AttributeError, TypeError, ValueError) as erreur:
|
||||
raise TokenInvalidError("Identifiants du jeton illisibles") from erreur
|
||||
|
||||
return AccessClaims(
|
||||
subject=sujet,
|
||||
role=str(charge["role"]),
|
||||
kind=str(charge["kind"]),
|
||||
token_id=identifiant,
|
||||
issued_at=datetime.fromtimestamp(charge["iat"], tz=UTC),
|
||||
)
|
||||
|
||||
|
||||
def generate_refresh_secret() -> str:
|
||||
return secrets.token_urlsafe(REFRESH_SECRET_BYTES)
|
||||
|
||||
|
||||
# SHA-256 nu, pas Argon2id : 256 bits de CSPRNG n'ont ni dictionnaire ni préimage atteignable,
|
||||
# et une KDF lente coûterait 17 ms à chaque rafraîchissement pour aucun gain.
|
||||
def fingerprint_refresh(secret: str) -> bytes:
|
||||
return hashlib.sha256(secret.encode("utf-8")).digest()
|
||||
@@ -2,4 +2,4 @@ from sqlalchemy.orm import DeclarativeBase
|
||||
|
||||
|
||||
class Base(DeclarativeBase):
|
||||
"""Base déclarative commune à tous les modèles."""
|
||||
"""Base declarative commune a tous les modeles."""
|
||||
|
||||
@@ -1,68 +0,0 @@
|
||||
# Détection d'alertes internes EnerVision (issue #104) : script lancé à la main pour l'instant,
|
||||
# comme `enervision_ml.score` côté ML, sans automatisation Airflow pour l'ordonnancer.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import sys
|
||||
from datetime import UTC, datetime
|
||||
|
||||
from app.core.config import get_settings
|
||||
from app.db.session import get_session_factory
|
||||
from app.repositories.alert import AlertRepository
|
||||
from app.repositories.prediction import PredictionRepository
|
||||
from app.repositories.reading import ReadingRepository
|
||||
from app.repositories.site import SiteRepository
|
||||
from app.services.alert import AlertService
|
||||
|
||||
|
||||
async def run_detection(*, now: datetime | None = None, site_id: str | None = None) -> int:
|
||||
"""Exécute les cinq règles de détection et enregistre les nouvelles alertes. Rend le nombre de
|
||||
lignes effectivement insérées (les doublons de `source_alert_id` sont silencieusement
|
||||
ignorés)."""
|
||||
async with get_session_factory()() as session:
|
||||
service = AlertService(
|
||||
alerts=AlertRepository(session),
|
||||
readings=ReadingRepository(session),
|
||||
predictions=PredictionRepository(session),
|
||||
sites=SiteRepository(session),
|
||||
)
|
||||
nouvelles = await service.detect(now=now, site_id=site_id)
|
||||
await session.commit()
|
||||
return len(nouvelles)
|
||||
|
||||
|
||||
def _parse_instant(valeur: str) -> datetime:
|
||||
instant = datetime.fromisoformat(valeur)
|
||||
return instant if instant.tzinfo is not None else instant.replace(tzinfo=UTC)
|
||||
|
||||
|
||||
def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
|
||||
parser = argparse.ArgumentParser(
|
||||
prog="python -m app.detection.internal_alerts",
|
||||
description="Détection d'alertes internes EnerVision",
|
||||
)
|
||||
parser.add_argument("--site-id", default=None, help="Limite la détection à un seul site.")
|
||||
parser.add_argument(
|
||||
"--now",
|
||||
type=_parse_instant,
|
||||
default=None,
|
||||
help=(
|
||||
"Instant de référence (ISO 8601, UTC si le fuseau est omis). Défaut : l'heure courante."
|
||||
),
|
||||
)
|
||||
return parser.parse_args(argv)
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = parse_args(argv)
|
||||
# Échoue tôt si `APP_SECRET_KEY`/`DATABASE_URL` manquent, avant toute requête à la base.
|
||||
get_settings()
|
||||
nombre = asyncio.run(run_detection(now=args.now, site_id=args.site_id))
|
||||
print(f"{nombre} nouvelle(s) alerte(s) enregistrée(s).")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__": # pragma: no cover
|
||||
sys.exit(main())
|
||||
@@ -1,621 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Any, cast
|
||||
|
||||
import pandas as pd
|
||||
from sqlalchemy import text
|
||||
from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
|
||||
|
||||
from app.core.config import get_settings
|
||||
|
||||
REQUIRED_COLUMNS = {
|
||||
"timestamp",
|
||||
"site_id",
|
||||
"site_type",
|
||||
"site_name",
|
||||
"consumption_kwh",
|
||||
"consumption_euros",
|
||||
"temperature_celsius",
|
||||
"humidity_percent",
|
||||
"solar_irradiance_wm2",
|
||||
"hour",
|
||||
"day_of_week",
|
||||
"day_name",
|
||||
"month",
|
||||
"is_weekend",
|
||||
"is_working_hours",
|
||||
}
|
||||
|
||||
MEASURE_COLUMNS = [
|
||||
"consumption_kwh",
|
||||
"consumption_euros",
|
||||
"temperature_celsius",
|
||||
"humidity_percent",
|
||||
"solar_irradiance_wm2",
|
||||
]
|
||||
|
||||
SOURCE_NAME = "csv"
|
||||
|
||||
|
||||
def compute_sha256(path: Path) -> str:
|
||||
"""Calcule l'empreinte SHA-256 du fichier source."""
|
||||
sha256 = hashlib.sha256()
|
||||
|
||||
with path.open("rb") as source:
|
||||
for block in iter(lambda: source.read(1024 * 1024), b""):
|
||||
sha256.update(block)
|
||||
|
||||
return sha256.hexdigest()
|
||||
|
||||
|
||||
def load_metadata(path: Path) -> dict[str, Any]:
|
||||
"""Charge les métadonnées fournies avec le dataset."""
|
||||
with path.open("r", encoding="utf-8") as source:
|
||||
metadata = json.load(source)
|
||||
|
||||
if not isinstance(metadata, dict):
|
||||
raise ValueError("Le fichier de métadonnées doit contenir un objet JSON.")
|
||||
|
||||
return cast(dict[str, Any], metadata)
|
||||
|
||||
|
||||
def classify_quality(
|
||||
row: dict[str, Any],
|
||||
) -> tuple[str, list[str]]:
|
||||
"""
|
||||
Déduit une qualité technique à partir des champs manquants.
|
||||
|
||||
Les valeurs NULL sont conservées. On ne cherche pas ici à
|
||||
déterminer la cause physique exacte de leur absence.
|
||||
"""
|
||||
missing = [column for column in MEASURE_COLUMNS if pd.isna(row.get(column))]
|
||||
|
||||
if not missing:
|
||||
quality = "good"
|
||||
elif len(missing) == len(MEASURE_COLUMNS):
|
||||
quality = "critical"
|
||||
elif "consumption_kwh" in missing:
|
||||
quality = "degraded"
|
||||
else:
|
||||
quality = "partial"
|
||||
|
||||
reasons = [f"missing:{column}" for column in missing]
|
||||
|
||||
return quality, reasons
|
||||
|
||||
|
||||
def validate_source(
|
||||
frame: pd.DataFrame,
|
||||
metadata: dict[str, Any],
|
||||
) -> None:
|
||||
"""Valide le dataset avant tout chargement en base."""
|
||||
missing_columns = REQUIRED_COLUMNS.difference(frame.columns)
|
||||
|
||||
if missing_columns:
|
||||
raise ValueError(f"Colonnes obligatoires absentes : {sorted(missing_columns)}")
|
||||
|
||||
expected_records = int(metadata["total_records"])
|
||||
|
||||
if len(frame) != expected_records:
|
||||
raise ValueError(f"Nombre de lignes inattendu : {len(frame)} au lieu de {expected_records}")
|
||||
|
||||
expected_sites = set(metadata["sites"].keys())
|
||||
actual_sites = set(frame["site_id"].unique())
|
||||
|
||||
if actual_sites != expected_sites:
|
||||
raise ValueError(
|
||||
f"Sites incohérents. Attendus={sorted(expected_sites)}, trouvés={sorted(actual_sites)}"
|
||||
)
|
||||
|
||||
duplicated = frame.duplicated(subset=["site_id", "timestamp"]).sum()
|
||||
|
||||
if duplicated:
|
||||
raise ValueError(f"{duplicated} doublons (site_id, timestamp) détectés")
|
||||
|
||||
static_variants = frame.groupby("site_id")[["site_type", "site_name"]].nunique()
|
||||
|
||||
if (static_variants > 1).any().any():
|
||||
raise ValueError("Un site possède plusieurs valeurs de site_type ou site_name.")
|
||||
|
||||
# Vérifie également que tous les timestamps
|
||||
# peuvent être interprétés correctement.
|
||||
pd.to_datetime(
|
||||
frame["timestamp"],
|
||||
errors="raise",
|
||||
)
|
||||
|
||||
|
||||
def normalize_timestamps(
|
||||
frame: pd.DataFrame,
|
||||
source_timezone: str,
|
||||
) -> pd.DataFrame:
|
||||
"""
|
||||
Normalise les timestamps et leur associe une timezone.
|
||||
|
||||
Les timestamps originaux sont conservés dans une colonne
|
||||
temporaire afin de pouvoir les stocker dans raw_data.
|
||||
"""
|
||||
normalized = frame.copy()
|
||||
|
||||
normalized["_source_timestamp"] = normalized["timestamp"]
|
||||
|
||||
timestamps = pd.to_datetime(
|
||||
normalized["timestamp"],
|
||||
errors="raise",
|
||||
)
|
||||
|
||||
if timestamps.dt.tz is None:
|
||||
timestamps = timestamps.dt.tz_localize(source_timezone)
|
||||
else:
|
||||
timestamps = timestamps.dt.tz_convert(source_timezone)
|
||||
|
||||
normalized["timestamp"] = timestamps
|
||||
|
||||
return normalized
|
||||
|
||||
|
||||
def to_json_value(value: Any) -> Any:
|
||||
"""
|
||||
Convertit une valeur Pandas/Numpy en valeur
|
||||
compatible JSON.
|
||||
"""
|
||||
if value is None:
|
||||
return None
|
||||
|
||||
try:
|
||||
if pd.isna(value):
|
||||
return None
|
||||
except TypeError, ValueError:
|
||||
pass
|
||||
|
||||
if isinstance(value, pd.Timestamp):
|
||||
return value.isoformat()
|
||||
|
||||
if hasattr(value, "item"):
|
||||
return value.item()
|
||||
|
||||
return value
|
||||
|
||||
|
||||
async def ensure_dataset(
|
||||
connection: AsyncConnection,
|
||||
metadata: dict[str, Any],
|
||||
sha256: str,
|
||||
source_timezone: str,
|
||||
storage_uri: str,
|
||||
) -> int:
|
||||
"""
|
||||
Crée l'entrée dataset si elle n'existe pas.
|
||||
|
||||
Le SHA-256 permet de reconnaître un fichier déjà importé
|
||||
et participe à l'idempotence et à la traçabilité.
|
||||
"""
|
||||
result = await connection.execute(
|
||||
text(
|
||||
"""
|
||||
SELECT dataset_id
|
||||
FROM dataset
|
||||
WHERE archive_sha256 = :sha256
|
||||
LIMIT 1
|
||||
"""
|
||||
),
|
||||
{
|
||||
"sha256": sha256,
|
||||
},
|
||||
)
|
||||
|
||||
existing = result.scalar_one_or_none()
|
||||
|
||||
if existing is not None:
|
||||
return int(existing)
|
||||
|
||||
metadata_summary = {
|
||||
"generator_version": metadata.get("generator_version"),
|
||||
"total_sites": metadata.get("total_sites"),
|
||||
"total_records": metadata.get("total_records"),
|
||||
"date_range": metadata.get("date_range"),
|
||||
"frequency": metadata.get("frequency"),
|
||||
"null_injection_enabled": metadata.get("null_injection_enabled"),
|
||||
"null_strategies": metadata.get("null_strategies"),
|
||||
"importer": "historical_import_v1",
|
||||
}
|
||||
|
||||
result = await connection.execute(
|
||||
text(
|
||||
"""
|
||||
INSERT INTO dataset (
|
||||
dataset_name,
|
||||
archive_sha256,
|
||||
storage_uri,
|
||||
source_timezone,
|
||||
"metadata"
|
||||
)
|
||||
VALUES (
|
||||
:dataset_name,
|
||||
:archive_sha256,
|
||||
:storage_uri,
|
||||
:source_timezone,
|
||||
CAST(:metadata AS jsonb)
|
||||
)
|
||||
RETURNING dataset_id
|
||||
"""
|
||||
),
|
||||
{
|
||||
"dataset_name": ("EnerVision historical dataset 2023-2024"),
|
||||
"archive_sha256": sha256,
|
||||
"storage_uri": storage_uri,
|
||||
"source_timezone": source_timezone,
|
||||
"metadata": json.dumps(
|
||||
metadata_summary,
|
||||
ensure_ascii=False,
|
||||
),
|
||||
},
|
||||
)
|
||||
|
||||
return int(result.scalar_one())
|
||||
|
||||
|
||||
async def upsert_sites(
|
||||
connection: AsyncConnection,
|
||||
frame: pd.DataFrame,
|
||||
) -> None:
|
||||
"""Insère ou met à jour les sites du dataset."""
|
||||
sites = cast(
|
||||
list[dict[str, Any]],
|
||||
frame[
|
||||
[
|
||||
"site_id",
|
||||
"site_type",
|
||||
"site_name",
|
||||
]
|
||||
]
|
||||
.drop_duplicates(subset=["site_id"])
|
||||
.to_dict(orient="records"),
|
||||
)
|
||||
|
||||
await connection.execute(
|
||||
text(
|
||||
"""
|
||||
INSERT INTO site (
|
||||
site_id,
|
||||
site_type,
|
||||
site_name
|
||||
)
|
||||
VALUES (
|
||||
:site_id,
|
||||
:site_type,
|
||||
:site_name
|
||||
)
|
||||
ON CONFLICT (site_id)
|
||||
DO UPDATE SET
|
||||
site_type = EXCLUDED.site_type,
|
||||
site_name = EXCLUDED.site_name
|
||||
"""
|
||||
),
|
||||
sites,
|
||||
)
|
||||
|
||||
|
||||
def build_reading_batch(
|
||||
chunk: pd.DataFrame,
|
||||
dataset_id: int,
|
||||
) -> list[dict[str, Any]]:
|
||||
"""
|
||||
Transforme un chunk Pandas en lignes prêtes
|
||||
à être chargées dans la table reading.
|
||||
"""
|
||||
rows: list[dict[str, Any]] = []
|
||||
|
||||
records = cast(
|
||||
list[dict[str, Any]],
|
||||
chunk.to_dict(orient="records"),
|
||||
)
|
||||
|
||||
for record in records:
|
||||
quality, reasons = classify_quality(record)
|
||||
|
||||
raw_data = {
|
||||
column: to_json_value(value)
|
||||
for column, value in record.items()
|
||||
if column != "_source_timestamp"
|
||||
}
|
||||
|
||||
# Dans raw_data, on conserve le timestamp
|
||||
# exactement tel qu'il était dans le CSV.
|
||||
raw_data["timestamp"] = to_json_value(record["_source_timestamp"])
|
||||
|
||||
rows.append(
|
||||
{
|
||||
"site_id": record["site_id"],
|
||||
"timestamp": record["timestamp"],
|
||||
"source": SOURCE_NAME,
|
||||
"dataset_id": dataset_id,
|
||||
# Non fourni par le dataset historique.
|
||||
"consumption_kw": None,
|
||||
"consumption_kwh": to_json_value(record["consumption_kwh"]),
|
||||
"consumption_euros": to_json_value(record["consumption_euros"]),
|
||||
# Non fournis par le CSV historique.
|
||||
"voltage_v": None,
|
||||
"current_a": None,
|
||||
"power_factor": None,
|
||||
"temperature_celsius": (to_json_value(record["temperature_celsius"])),
|
||||
"humidity_percent": (to_json_value(record["humidity_percent"])),
|
||||
"solar_irradiance_wm2": (to_json_value(record["solar_irradiance_wm2"])),
|
||||
"is_working_hours": bool(record["is_working_hours"]),
|
||||
"data_quality": quality,
|
||||
"null_reasons": reasons,
|
||||
# Aucune imputation pendant l'ingestion RAW.
|
||||
# Les valeurs manquantes sont conservées telles quelles
|
||||
# afin de préserver la donnée source.
|
||||
"imputed_values": None,
|
||||
"imputation_method": None,
|
||||
# Conservation de la donnée source
|
||||
# pour la traçabilité.
|
||||
"raw_data": json.dumps(
|
||||
raw_data,
|
||||
ensure_ascii=False,
|
||||
),
|
||||
}
|
||||
)
|
||||
|
||||
return rows
|
||||
|
||||
|
||||
READING_INSERT = text(
|
||||
"""
|
||||
INSERT INTO reading (
|
||||
site_id,
|
||||
timestamp,
|
||||
source,
|
||||
dataset_id,
|
||||
consumption_kw,
|
||||
consumption_kwh,
|
||||
consumption_euros,
|
||||
voltage_v,
|
||||
current_a,
|
||||
power_factor,
|
||||
temperature_celsius,
|
||||
humidity_percent,
|
||||
solar_irradiance_wm2,
|
||||
is_working_hours,
|
||||
data_quality,
|
||||
null_reasons,
|
||||
imputed_values,
|
||||
imputation_method,
|
||||
raw_data
|
||||
)
|
||||
VALUES (
|
||||
:site_id,
|
||||
:timestamp,
|
||||
:source,
|
||||
:dataset_id,
|
||||
:consumption_kw,
|
||||
:consumption_kwh,
|
||||
:consumption_euros,
|
||||
:voltage_v,
|
||||
:current_a,
|
||||
:power_factor,
|
||||
:temperature_celsius,
|
||||
:humidity_percent,
|
||||
:solar_irradiance_wm2,
|
||||
:is_working_hours,
|
||||
:data_quality,
|
||||
:null_reasons,
|
||||
CAST(:imputed_values AS jsonb),
|
||||
:imputation_method,
|
||||
CAST(:raw_data AS jsonb)
|
||||
)
|
||||
ON CONFLICT DO NOTHING
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
async def import_historical(
|
||||
csv_path: Path,
|
||||
metadata_path: Path,
|
||||
source_timezone: str,
|
||||
batch_size: int,
|
||||
dry_run: bool,
|
||||
storage_uri: str,
|
||||
) -> None:
|
||||
"""
|
||||
Exécute le pipeline ETL historique EnerVision.
|
||||
|
||||
Étapes :
|
||||
1. Extract
|
||||
2. Validate
|
||||
3. Transform
|
||||
4. Load
|
||||
"""
|
||||
metadata = load_metadata(metadata_path)
|
||||
|
||||
frame = pd.read_csv(csv_path)
|
||||
|
||||
validate_source(
|
||||
frame,
|
||||
metadata,
|
||||
)
|
||||
|
||||
print(f"Lignes : {len(frame)}")
|
||||
print(f"Sites : {frame['site_id'].nunique()}")
|
||||
print(f"Période : {frame['timestamp'].min()} -> {frame['timestamp'].max()}")
|
||||
print(f"Doublons : {frame.duplicated(['site_id', 'timestamp']).sum()}")
|
||||
|
||||
print("\nValeurs NULL :")
|
||||
print(frame[MEASURE_COLUMNS].isna().sum())
|
||||
|
||||
sha256 = compute_sha256(csv_path)
|
||||
|
||||
print(f"\nSHA-256 : {sha256}")
|
||||
|
||||
if dry_run:
|
||||
print("\nDry-run terminé : aucune donnée écrite.")
|
||||
return
|
||||
|
||||
normalized = normalize_timestamps(
|
||||
frame,
|
||||
source_timezone,
|
||||
)
|
||||
|
||||
settings = get_settings()
|
||||
|
||||
engine = create_async_engine(
|
||||
str(settings.database_url),
|
||||
pool_pre_ping=True,
|
||||
)
|
||||
|
||||
try:
|
||||
async with engine.begin() as connection:
|
||||
dataset_id = await ensure_dataset(
|
||||
connection=connection,
|
||||
metadata=metadata,
|
||||
sha256=sha256,
|
||||
source_timezone=source_timezone,
|
||||
storage_uri=storage_uri,
|
||||
)
|
||||
|
||||
await upsert_sites(
|
||||
connection,
|
||||
normalized,
|
||||
)
|
||||
|
||||
result = await connection.execute(
|
||||
text(
|
||||
"""
|
||||
SELECT COUNT(*)
|
||||
FROM reading
|
||||
WHERE dataset_id = :dataset_id
|
||||
AND source = :source
|
||||
"""
|
||||
),
|
||||
{
|
||||
"dataset_id": dataset_id,
|
||||
"source": SOURCE_NAME,
|
||||
},
|
||||
)
|
||||
|
||||
before = int(result.scalar_one())
|
||||
|
||||
for start in range(
|
||||
0,
|
||||
len(normalized),
|
||||
batch_size,
|
||||
):
|
||||
chunk = normalized.iloc[start : start + batch_size]
|
||||
|
||||
rows = build_reading_batch(
|
||||
chunk,
|
||||
dataset_id,
|
||||
)
|
||||
|
||||
await connection.execute(
|
||||
READING_INSERT,
|
||||
rows,
|
||||
)
|
||||
|
||||
loaded = min(
|
||||
start + batch_size,
|
||||
len(normalized),
|
||||
)
|
||||
|
||||
print(f"Chargement : {loaded}/{len(normalized)}")
|
||||
|
||||
result = await connection.execute(
|
||||
text(
|
||||
"""
|
||||
SELECT COUNT(*)
|
||||
FROM reading
|
||||
WHERE dataset_id = :dataset_id
|
||||
AND source = :source
|
||||
"""
|
||||
),
|
||||
{
|
||||
"dataset_id": dataset_id,
|
||||
"source": SOURCE_NAME,
|
||||
},
|
||||
)
|
||||
|
||||
after = int(result.scalar_one())
|
||||
|
||||
print("\nImport terminé.")
|
||||
print(f"dataset_id : {dataset_id}")
|
||||
print(f"lectures avant : {before}")
|
||||
print(f"lectures après : {after}")
|
||||
print(f"nouvelles lectures : {after - before}")
|
||||
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
"""Définit les arguments CLI de l'import."""
|
||||
parser = argparse.ArgumentParser(description=("Import historique EnerVision"))
|
||||
|
||||
parser.add_argument(
|
||||
"--csv",
|
||||
type=Path,
|
||||
required=True,
|
||||
help="Chemin vers le CSV historique.",
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--metadata",
|
||||
type=Path,
|
||||
required=True,
|
||||
help=("Chemin vers le fichier dataset_metadata.json."),
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--source-timezone",
|
||||
default="UTC",
|
||||
help=("Timezone associée aux timestamps du dataset. Défaut : UTC."),
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--batch-size",
|
||||
type=int,
|
||||
default=1000,
|
||||
help=("Nombre de lignes insérées par batch. Défaut : 1000."),
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--dry-run",
|
||||
action="store_true",
|
||||
help=("Valide les données sans écrire en base."),
|
||||
)
|
||||
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
"""Point d'entrée CLI du pipeline."""
|
||||
args = parse_args()
|
||||
|
||||
if args.batch_size <= 0:
|
||||
raise ValueError("--batch-size doit être strictement supérieur à 0.")
|
||||
|
||||
# resolve() est volontairement exécuté ici,
|
||||
# dans la partie synchrone du programme.
|
||||
# Cela évite une opération filesystem bloquante
|
||||
# à l'intérieur d'une fonction async.
|
||||
storage_uri = args.csv.resolve().as_uri()
|
||||
|
||||
asyncio.run(
|
||||
import_historical(
|
||||
csv_path=args.csv,
|
||||
metadata_path=args.metadata,
|
||||
source_timezone=(args.source_timezone),
|
||||
batch_size=args.batch_size,
|
||||
dry_run=args.dry_run,
|
||||
storage_uri=storage_uri,
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,527 +0,0 @@
|
||||
# Contrainte : la réponse de l'API Mock est une entrée hostile, pas une source de confiance.
|
||||
# Voir OWASP API10 dans docs/architecture/owasp-traceabilite.md. Rien de ce qu'elle renvoie
|
||||
# n'atteint la base sans passer par build_site_row() ou build_reading_row() : seuls les champs
|
||||
# attendus sont recopiés, les grandeurs physiques sont bornées par PHYSICAL_BOUNDS, la taille des
|
||||
# tableaux est plafonnée par MAX_SITES et par limit_for_window() (dérivé de la fenêtre, jamais
|
||||
# fourni par l'appelant), et les lectures dont le timestamp déborde de la fenêtre demandée sont
|
||||
# écartées (fetch_readings). Une valeur hors bornes devient NULL et laisse sa trace dans
|
||||
# null_reasons plutôt que de lever : le mock émet des anomalies par construction, et raw_data
|
||||
# conserve de toute façon la réponse d'origine intacte.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
import httpx
|
||||
from sqlalchemy import text
|
||||
from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
|
||||
|
||||
from app.core.config import get_settings
|
||||
from app.etl.historical_import import SOURCE_NAME as SOURCE_CSV
|
||||
|
||||
SOURCE_HISTORY = "api_history"
|
||||
|
||||
MAX_SITES = 100
|
||||
|
||||
MAX_LIMIT = 1000
|
||||
|
||||
# Les quatre seules valeurs que la contrainte ck_reading_quality accepte.
|
||||
ACCEPTED_QUALITIES = frozenset({"good", "partial", "degraded", "critical"})
|
||||
|
||||
PHYSICAL_BOUNDS: dict[str, tuple[float, float]] = {
|
||||
"consumption_kw": (0.0, 100_000.0),
|
||||
"consumption_kwh": (0.0, 100_000.0),
|
||||
"voltage_v": (0.0, 1_000.0),
|
||||
"current_a": (0.0, 10_000.0),
|
||||
"power_factor": (0.0, 1.0),
|
||||
"temperature_celsius": (-90.0, 60.0),
|
||||
"humidity_percent": (0.0, 100.0),
|
||||
}
|
||||
|
||||
CAPACITY_BOUNDS = (0.0, 100_000.0)
|
||||
|
||||
|
||||
def create_mock_api_client() -> httpx.AsyncClient:
|
||||
settings = get_settings()
|
||||
|
||||
username = settings.mock_api_username
|
||||
password = (
|
||||
settings.mock_api_password.get_secret_value()
|
||||
if settings.mock_api_password is not None
|
||||
else None
|
||||
)
|
||||
|
||||
if not username or not username.strip() or not password or not password.strip():
|
||||
raise ValueError("Les identifiants de l'API Mock ne sont pas configurés.")
|
||||
|
||||
return httpx.AsyncClient(
|
||||
base_url=settings.mock_api_base_url.rstrip("/"),
|
||||
auth=(username, password),
|
||||
timeout=settings.mock_api_timeout_seconds,
|
||||
)
|
||||
|
||||
|
||||
def read_text(payload: dict[str, Any], key: str) -> str:
|
||||
value = payload.get(key)
|
||||
|
||||
if not isinstance(value, str) or not value:
|
||||
raise ValueError(f"Champ {key} absent ou invalide dans la réponse de l'API Mock.")
|
||||
|
||||
return value
|
||||
|
||||
|
||||
def optional_text(value: Any) -> str | None:
|
||||
return value if isinstance(value, str) else None
|
||||
|
||||
|
||||
def coerce_measure(
|
||||
value: Any,
|
||||
bounds: tuple[float, float],
|
||||
) -> float | None:
|
||||
if isinstance(value, bool) or not isinstance(value, int | float):
|
||||
return None
|
||||
|
||||
lower, upper = bounds
|
||||
|
||||
# Écarte aussi NaN et les infinis, qu'aucune comparaison de bornes ne retient.
|
||||
return float(value) if lower <= value <= upper else None
|
||||
|
||||
|
||||
def resolve_quality(
|
||||
value: Any,
|
||||
rejected: list[str],
|
||||
) -> str | None:
|
||||
quality = value if isinstance(value, str) and value in ACCEPTED_QUALITIES else None
|
||||
|
||||
if rejected:
|
||||
return "critical" if quality == "critical" else "degraded"
|
||||
|
||||
return quality
|
||||
|
||||
|
||||
def resolve_null_reasons(
|
||||
value: Any,
|
||||
rejected: list[str],
|
||||
) -> list[str]:
|
||||
reported = [str(reason) for reason in value] if isinstance(value, list) else []
|
||||
|
||||
return reported + rejected
|
||||
|
||||
|
||||
async def fetch_sites(
|
||||
client: httpx.AsyncClient,
|
||||
) -> list[dict[str, Any]]:
|
||||
response = await client.get("/api/v1/sites")
|
||||
|
||||
response.raise_for_status()
|
||||
|
||||
payload = response.json()
|
||||
|
||||
if not isinstance(payload, list):
|
||||
raise ValueError("La réponse /api/v1/sites doit être une liste.")
|
||||
|
||||
if len(payload) > MAX_SITES:
|
||||
raise ValueError(f"La réponse /api/v1/sites dépasse le plafond de {MAX_SITES} sites.")
|
||||
|
||||
return payload
|
||||
|
||||
|
||||
def build_site_row(
|
||||
site: dict[str, Any],
|
||||
) -> dict[str, Any]:
|
||||
return {
|
||||
"site_id": read_text(site, "site_id"),
|
||||
"site_type": read_text(site, "site_type"),
|
||||
"site_name": read_text(site, "site_name"),
|
||||
"location": optional_text(site.get("location")),
|
||||
"capacity_kw": coerce_measure(site.get("capacity_kw"), CAPACITY_BOUNDS),
|
||||
"status": optional_text(site.get("status")),
|
||||
}
|
||||
|
||||
|
||||
async def upsert_sites(
|
||||
connection: AsyncConnection,
|
||||
sites: list[dict[str, Any]],
|
||||
) -> None:
|
||||
rows = [build_site_row(site) for site in sites]
|
||||
|
||||
if not rows:
|
||||
return
|
||||
|
||||
await connection.execute(
|
||||
text(
|
||||
"""
|
||||
INSERT INTO site (
|
||||
site_id,
|
||||
site_type,
|
||||
site_name,
|
||||
location,
|
||||
capacity_kw,
|
||||
status
|
||||
)
|
||||
VALUES (
|
||||
:site_id,
|
||||
:site_type,
|
||||
:site_name,
|
||||
:location,
|
||||
:capacity_kw,
|
||||
:status
|
||||
)
|
||||
ON CONFLICT (site_id)
|
||||
DO UPDATE SET
|
||||
site_type = EXCLUDED.site_type,
|
||||
site_name = EXCLUDED.site_name,
|
||||
location = EXCLUDED.location,
|
||||
capacity_kw = EXCLUDED.capacity_kw,
|
||||
status = EXCLUDED.status
|
||||
"""
|
||||
),
|
||||
rows,
|
||||
)
|
||||
|
||||
|
||||
def _timestamp_in_window(reading: dict[str, Any], start_time: datetime, end_time: datetime) -> bool:
|
||||
valeur = reading.get("timestamp")
|
||||
if not isinstance(valeur, str):
|
||||
return False
|
||||
|
||||
try:
|
||||
instant = parse_datetime(valeur)
|
||||
except ValueError:
|
||||
return False
|
||||
|
||||
return start_time <= instant < end_time
|
||||
|
||||
|
||||
async def fetch_readings(
|
||||
client: httpx.AsyncClient,
|
||||
site_id: str,
|
||||
start_time: datetime,
|
||||
end_time: datetime,
|
||||
limit: int = MAX_LIMIT,
|
||||
) -> list[dict[str, Any]]:
|
||||
response = await client.get(
|
||||
"/api/v1/readings",
|
||||
params={
|
||||
"site_id": site_id,
|
||||
"start_time": start_time.isoformat(),
|
||||
"end_time": end_time.isoformat(),
|
||||
"limit": limit,
|
||||
},
|
||||
)
|
||||
|
||||
response.raise_for_status()
|
||||
|
||||
payload = response.json()
|
||||
|
||||
if not isinstance(payload, list):
|
||||
raise ValueError("La réponse /api/v1/readings doit être une liste.")
|
||||
|
||||
if len(payload) > limit:
|
||||
raise ValueError(f"La réponse /api/v1/readings dépasse la limite demandée de {limit}.")
|
||||
|
||||
# Le garde-fou `refuse_if_overlaps_historical_dataset` ne vérifie que la fenêtre demandée :
|
||||
# une réponse (bug du mock, ou hostile) dont les `timestamp` débordent de
|
||||
# `[start_time, end_time)` contournerait ce contrôle et écrirait exactement le doublon
|
||||
# inter-source qu'il doit empêcher. Écarter ces lectures ici rend le contrôle par fenêtre
|
||||
# suffisant.
|
||||
dans_la_fenetre = [
|
||||
lecture
|
||||
for lecture in payload
|
||||
if isinstance(lecture, dict) and _timestamp_in_window(lecture, start_time, end_time)
|
||||
]
|
||||
|
||||
if len(dans_la_fenetre) != len(payload):
|
||||
ecartees = len(payload) - len(dans_la_fenetre)
|
||||
print(f"{site_id}: {ecartees} lecture(s) hors fenêtre écartée(s).")
|
||||
|
||||
return dans_la_fenetre
|
||||
|
||||
|
||||
def build_reading_row(
|
||||
reading: dict[str, Any],
|
||||
) -> dict[str, Any]:
|
||||
measures: dict[str, float | None] = {}
|
||||
rejected: list[str] = []
|
||||
|
||||
for name, bounds in PHYSICAL_BOUNDS.items():
|
||||
received = reading.get(name)
|
||||
measures[name] = coerce_measure(received, bounds)
|
||||
|
||||
if received is not None and measures[name] is None:
|
||||
rejected.append(f"out_of_physical_bounds:{name}")
|
||||
|
||||
return {
|
||||
"site_id": read_text(reading, "site_id"),
|
||||
"timestamp": parse_datetime(read_text(reading, "timestamp")),
|
||||
"source": SOURCE_HISTORY,
|
||||
"dataset_id": None,
|
||||
**measures,
|
||||
"consumption_euros": None,
|
||||
"solar_irradiance_wm2": None,
|
||||
"is_working_hours": None,
|
||||
"data_quality": resolve_quality(reading.get("data_quality"), rejected),
|
||||
"null_reasons": resolve_null_reasons(reading.get("null_reasons"), rejected),
|
||||
"imputed_values": None,
|
||||
"imputation_method": None,
|
||||
"raw_data": json.dumps(
|
||||
reading,
|
||||
ensure_ascii=False,
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
# `uq_reading_source` autorise deux lignes au même (site_id, timestamp) dès que `source` diffère :
|
||||
# sans ce garde-fou, importer une fenêtre déjà couverte par le dataset historique (source='csv')
|
||||
# dupliquerait silencieusement chaque point plutôt que de lever une erreur. Ce garde-fou protège
|
||||
# l'ingestion ; il ne dit rien de la lecture (`GET /readings` renvoie les deux lignes en cas de
|
||||
# doublon malgré tout, cf. la section réconciliation de 40-data.md).
|
||||
OVERLAP_CHECK = text(
|
||||
"SELECT count(*) FROM reading WHERE source = :source_csv "
|
||||
"AND timestamp >= :start_time AND timestamp < :end_time"
|
||||
)
|
||||
|
||||
|
||||
async def refuse_if_overlaps_historical_dataset(
|
||||
connection: AsyncConnection,
|
||||
start_time: datetime,
|
||||
end_time: datetime,
|
||||
) -> None:
|
||||
resultat = await connection.execute(
|
||||
OVERLAP_CHECK,
|
||||
{"source_csv": SOURCE_CSV, "start_time": start_time, "end_time": end_time},
|
||||
)
|
||||
nombre = resultat.scalar_one()
|
||||
|
||||
if nombre > 0:
|
||||
raise ValueError(
|
||||
f"La fenêtre [{start_time.isoformat()}, {end_time.isoformat()}) recouvre "
|
||||
f"{nombre} lecture(s) déjà importée(s) du dataset historique (source='{SOURCE_CSV}') : "
|
||||
"import refusé pour éviter un doublon inter-source."
|
||||
)
|
||||
|
||||
|
||||
# Le conflit vise l'index unique uq_reading_source plutôt que la table entière : sans cible
|
||||
# nommée, DO NOTHING avalerait aussi une violation de clé primaire.
|
||||
READING_INSERT = text(
|
||||
"""
|
||||
INSERT INTO reading (
|
||||
site_id,
|
||||
timestamp,
|
||||
source,
|
||||
dataset_id,
|
||||
consumption_kw,
|
||||
consumption_kwh,
|
||||
consumption_euros,
|
||||
voltage_v,
|
||||
current_a,
|
||||
power_factor,
|
||||
temperature_celsius,
|
||||
humidity_percent,
|
||||
solar_irradiance_wm2,
|
||||
is_working_hours,
|
||||
data_quality,
|
||||
null_reasons,
|
||||
imputed_values,
|
||||
imputation_method,
|
||||
raw_data
|
||||
)
|
||||
VALUES (
|
||||
:site_id,
|
||||
:timestamp,
|
||||
:source,
|
||||
:dataset_id,
|
||||
:consumption_kw,
|
||||
:consumption_kwh,
|
||||
:consumption_euros,
|
||||
:voltage_v,
|
||||
:current_a,
|
||||
:power_factor,
|
||||
:temperature_celsius,
|
||||
:humidity_percent,
|
||||
:solar_irradiance_wm2,
|
||||
:is_working_hours,
|
||||
:data_quality,
|
||||
:null_reasons,
|
||||
CAST(:imputed_values AS jsonb),
|
||||
:imputation_method,
|
||||
CAST(:raw_data AS jsonb)
|
||||
)
|
||||
ON CONFLICT (site_id, timestamp, source, (coalesce(dataset_id, 0)))
|
||||
DO NOTHING
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
def build_reading_batch(
|
||||
readings: list[dict[str, Any]],
|
||||
) -> list[dict[str, Any]]:
|
||||
return [build_reading_row(reading) for reading in readings]
|
||||
|
||||
|
||||
def limit_for_window(start_time: datetime, end_time: datetime) -> int:
|
||||
"""Nombre de lectures à demander pour que l'API Mock en rende une par heure, alignée.
|
||||
|
||||
L'API ne renvoie pas un flux à un rythme naturel : elle répartit exactement `limit` lectures,
|
||||
espacées uniformément, sur toute la fenêtre `[start_time, end_time)` demandée, la première
|
||||
au tout début de la fenêtre (vérifié empiriquement). Deux façons d'obtenir une lecture
|
||||
alignée sur l'heure :
|
||||
|
||||
- une fenêtre d'exactement N heures (`start_time` sur l'heure) donne, avec `limit=N`, N
|
||||
lectures espacées d'1h pile, la première à `start_time` : c'est le chemin du backfill
|
||||
manuel (plusieurs jours d'historique en un seul appel).
|
||||
- une fenêtre plus courte qu'une heure, ou qui n'est pas un multiple entier d'heure, ne peut
|
||||
espacer plusieurs lectures d'1h pile (l'espacement de l'API vaut toujours
|
||||
`durée / limit`) : seule `limit=1` reste alignée, la lecture unique atterrissant à
|
||||
`start_time`. C'est le chemin du DAG horaire, dont la fenêtre part de l'heure pile qui
|
||||
précède son déclenchement jusqu'à l'instant du déclenchement lui-même (`:45`), donc plus
|
||||
courte qu'une heure.
|
||||
|
||||
Dans les deux cas, `start_time` doit tomber pile sur l'heure : c'est elle qui ancre
|
||||
l'alignement, jamais `end_time`. Un `limit` plus grand que celui rendu ici fabriquerait des
|
||||
lectures infra-horaires, incompatibles avec les lags positionnels de `build_features`.
|
||||
"""
|
||||
if start_time.minute or start_time.second or start_time.microsecond:
|
||||
raise ValueError(
|
||||
f"La fenêtre doit démarrer pile sur l'heure : {start_time.isoformat()} ne l'est pas."
|
||||
)
|
||||
|
||||
duree = end_time - start_time
|
||||
heures, reste = divmod(duree.total_seconds(), 3600)
|
||||
|
||||
# Fenêtre plus courte qu'une heure, ou pas un multiple entier : aucun `limit` supérieur à 1
|
||||
# n'espacerait ses lectures d'1h pile (l'espacement vaut toujours durée / limit). Seule la
|
||||
# lecture unique, ancrée sur `start_time`, reste alignée.
|
||||
limit = int(heures) if reste == 0 and heures >= 1 else 1
|
||||
|
||||
if limit > MAX_LIMIT:
|
||||
raise ValueError(
|
||||
f"La fenêtre demandée couvre {limit}h, au-delà du plafond de {MAX_LIMIT} "
|
||||
"lectures accepté par l'API Mock."
|
||||
)
|
||||
|
||||
return limit
|
||||
|
||||
|
||||
async def import_mock_api_history(
|
||||
start_time: datetime,
|
||||
end_time: datetime,
|
||||
dry_run: bool,
|
||||
) -> None:
|
||||
settings = get_settings()
|
||||
limit = limit_for_window(start_time, end_time)
|
||||
|
||||
engine = create_async_engine(
|
||||
str(settings.database_url),
|
||||
pool_pre_ping=True,
|
||||
)
|
||||
|
||||
try:
|
||||
# Garde-fou d'abord, y compris en dry-run : il est en lecture seule, et annoncer un
|
||||
# succès pour une fenêtre que l'import réel refusera serait trompeur.
|
||||
async with engine.connect() as connection:
|
||||
await refuse_if_overlaps_historical_dataset(connection, start_time, end_time)
|
||||
|
||||
async with create_mock_api_client() as client:
|
||||
sites = await fetch_sites(client)
|
||||
|
||||
print(f"Sites récupérés : {len(sites)}")
|
||||
|
||||
all_readings: list[dict[str, Any]] = []
|
||||
|
||||
for site in sites:
|
||||
site_id = read_text(site, "site_id")
|
||||
|
||||
readings = await fetch_readings(
|
||||
client=client,
|
||||
site_id=site_id,
|
||||
start_time=start_time,
|
||||
end_time=end_time,
|
||||
limit=limit,
|
||||
)
|
||||
|
||||
print(f"{site_id}: {len(readings)} lectures")
|
||||
|
||||
all_readings.extend(readings)
|
||||
|
||||
print(f"Lectures récupérées : {len(all_readings)}")
|
||||
|
||||
if dry_run:
|
||||
print("Dry-run terminé : aucune donnée écrite.")
|
||||
return
|
||||
|
||||
async with engine.begin() as connection:
|
||||
await upsert_sites(
|
||||
connection,
|
||||
sites,
|
||||
)
|
||||
|
||||
rows = build_reading_batch(all_readings)
|
||||
|
||||
if rows:
|
||||
await connection.execute(
|
||||
READING_INSERT,
|
||||
rows,
|
||||
)
|
||||
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
print("Import API Mock terminé.")
|
||||
|
||||
|
||||
def parse_datetime(value: str) -> datetime:
|
||||
# Sans fuseau, l'API le traite comme reçu, telle quelle, mais l'encodeur `timestamptz`
|
||||
# d'asyncpg lirait un datetime naif dans le fuseau *local du processus* (correct dans le
|
||||
# conteneur Airflow en UTC, décalé de 1-2h pour un import manuel lancé depuis un poste en
|
||||
# Europe/Paris). Poser `tzinfo=UTC` explicitement, même pattern que `_vers_utc()` dans
|
||||
# `app/services/reading.py`, garantit que la borne envoyée à l'API et celle comparée en SQL
|
||||
# (refuse_if_overlaps_historical_dataset) désignent le même instant.
|
||||
instant = datetime.fromisoformat(value.replace("Z", "+00:00"))
|
||||
return instant if instant.tzinfo is not None else instant.replace(tzinfo=UTC)
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
parser = argparse.ArgumentParser(description=("Import historique depuis l'API Mock EnerVision"))
|
||||
|
||||
parser.add_argument(
|
||||
"--start-time",
|
||||
required=True,
|
||||
type=parse_datetime,
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--end-time",
|
||||
required=True,
|
||||
type=parse_datetime,
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--dry-run",
|
||||
action="store_true",
|
||||
)
|
||||
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
args = parse_args()
|
||||
|
||||
if args.start_time >= args.end_time:
|
||||
raise ValueError("--start-time doit être antérieur à --end-time.")
|
||||
|
||||
asyncio.run(
|
||||
import_mock_api_history(
|
||||
start_time=args.start_time,
|
||||
end_time=args.end_time,
|
||||
dry_run=args.dry_run,
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,349 +0,0 @@
|
||||
# Pourquoi : la suppression n'est pas confiée à add_retention_policy, qui ignorerait l'export.
|
||||
# archive_reading_chunks() exporte chaque chunk vers Garage, le relit, puis le supprime seul.
|
||||
# Piège : drop_chunks pose un verrou exclusif sur reading, site et dataset jusqu'au COMMIT. La
|
||||
# suppression tient donc dans une transaction dédiée et courte, séparée de la lecture du chunk.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import base64
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
import anyio.to_thread
|
||||
import boto3
|
||||
import pandas as pd
|
||||
from botocore.exceptions import ClientError
|
||||
from pydantic import SecretStr
|
||||
from sqlalchemy import text
|
||||
from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, create_async_engine
|
||||
|
||||
from app.core.config import Settings, get_settings
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from types_boto3_s3.client import S3Client
|
||||
|
||||
SSE_KEY_LENGTH = 32
|
||||
FORMAT_BORNE = "%Y%m%dT%H%M%SZ"
|
||||
|
||||
ELIGIBLE_CHUNKS = text(
|
||||
"SELECT chunk_schema, chunk_name, range_start, range_end "
|
||||
"FROM timescaledb_information.chunks "
|
||||
"WHERE hypertable_name = 'reading' AND range_end <= :older_than "
|
||||
"ORDER BY range_start"
|
||||
)
|
||||
|
||||
# Lecture via l'hypertable, jamais la table interne : l'exclusion de partition vise le seul chunk.
|
||||
CHUNK_ROWS = text(
|
||||
"SELECT * FROM reading WHERE timestamp >= :start AND timestamp < :end "
|
||||
"ORDER BY timestamp, reading_id"
|
||||
)
|
||||
|
||||
# Les deux bornes sont inclusives pour drop_chunks : celles du chunk le désignent, et lui seul.
|
||||
DROP_CHUNK = text(
|
||||
"SELECT drop_chunks('reading', "
|
||||
"older_than => CAST(:end AS timestamptz), newer_than => CAST(:start AS timestamptz))"
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Chunk:
|
||||
schema: str
|
||||
name: str
|
||||
range_start: datetime
|
||||
range_end: datetime
|
||||
|
||||
@property
|
||||
def qualified_name(self) -> str:
|
||||
return f"{self.schema}.{self.name}"
|
||||
|
||||
|
||||
@dataclass
|
||||
class Rapport:
|
||||
chunks_vus: int = 0
|
||||
exportes: int = 0
|
||||
deja_presents: int = 0
|
||||
supprimes: int = 0
|
||||
lignes: int = 0
|
||||
|
||||
|
||||
def object_key(chunk: Chunk) -> str:
|
||||
start = chunk.range_start.astimezone(UTC)
|
||||
end = chunk.range_end.astimezone(UTC)
|
||||
return (
|
||||
f"reading/{start.year}/reading_{start.strftime(FORMAT_BORNE)}_"
|
||||
f"{end.strftime(FORMAT_BORNE)}.csv.gz"
|
||||
)
|
||||
|
||||
|
||||
async def eligible_chunks(conn: AsyncConnection, older_than: datetime) -> list[Chunk]:
|
||||
result = await conn.execute(ELIGIBLE_CHUNKS, {"older_than": older_than})
|
||||
return [
|
||||
Chunk(
|
||||
schema=row["chunk_schema"],
|
||||
name=row["chunk_name"],
|
||||
range_start=row["range_start"],
|
||||
range_end=row["range_end"],
|
||||
)
|
||||
for row in result.mappings().all()
|
||||
]
|
||||
|
||||
|
||||
async def read_chunk_rows(conn: AsyncConnection, chunk: Chunk) -> list[dict[str, Any]]:
|
||||
result = await conn.execute(CHUNK_ROWS, {"start": chunk.range_start, "end": chunk.range_end})
|
||||
return [dict(row) for row in result.mappings().all()]
|
||||
|
||||
|
||||
def _csv_cell(value: object) -> object:
|
||||
if isinstance(value, dict | list):
|
||||
return json.dumps(value, ensure_ascii=False, sort_keys=True)
|
||||
return value
|
||||
|
||||
|
||||
def serialize_csv_gzip(rows: list[dict[str, Any]]) -> bytes:
|
||||
if not rows:
|
||||
raise ValueError("Aucune ligne à sérialiser : un CSV sans colonne ne se relit pas.")
|
||||
|
||||
frame = pd.DataFrame([{name: _csv_cell(value) for name, value in row.items()} for row in rows])
|
||||
buffer = io.BytesIO()
|
||||
frame.to_csv(buffer, mode="wb", index=False, compression={"method": "gzip", "mtime": 0})
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def sha256_of(data: bytes) -> str:
|
||||
return hashlib.sha256(data).hexdigest()
|
||||
|
||||
|
||||
def _is_missing_object(erreur: ClientError) -> bool:
|
||||
error = erreur.response.get("Error")
|
||||
metadata = erreur.response.get("ResponseMetadata")
|
||||
code = error.get("Code") if error is not None else None
|
||||
status = metadata.get("HTTPStatusCode") if metadata is not None else None
|
||||
return code == "NoSuchKey" or status == 404
|
||||
|
||||
|
||||
class ArchiveStore:
|
||||
def __init__(self, client: S3Client, bucket: str, sse_key: bytes | None) -> None:
|
||||
self._client = client
|
||||
self._bucket = bucket
|
||||
self._sse_key = sse_key
|
||||
|
||||
# boto3 encode lui-même la clé en base64 et calcule son MD5 : la fournir brute, sans MD5.
|
||||
def _sse_headers(self) -> dict[str, Any]:
|
||||
if self._sse_key is None:
|
||||
return {}
|
||||
return {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": self._sse_key}
|
||||
|
||||
def put(self, key: str, body: bytes, metadata: dict[str, str]) -> None:
|
||||
self._client.put_object(
|
||||
Bucket=self._bucket,
|
||||
Key=key,
|
||||
Body=body,
|
||||
ContentType="text/csv",
|
||||
ContentEncoding="gzip",
|
||||
Metadata=metadata,
|
||||
**self._sse_headers(),
|
||||
)
|
||||
|
||||
def fetch_sha256(self, key: str) -> str | None:
|
||||
try:
|
||||
response = self._client.get_object(Bucket=self._bucket, Key=key, **self._sse_headers())
|
||||
except ClientError as erreur:
|
||||
if _is_missing_object(erreur):
|
||||
return None
|
||||
raise
|
||||
return sha256_of(response["Body"].read())
|
||||
|
||||
|
||||
def decode_sse_key(encoded: SecretStr | None) -> bytes | None:
|
||||
if encoded is None:
|
||||
return None
|
||||
|
||||
key = base64.b64decode(encoded.get_secret_value(), validate=True)
|
||||
if len(key) != SSE_KEY_LENGTH:
|
||||
raise ValueError(
|
||||
f"APP_S3_SSE_KEY doit encoder exactement {SSE_KEY_LENGTH} octets en base64, "
|
||||
f"pas {len(key)}."
|
||||
)
|
||||
return key
|
||||
|
||||
|
||||
def build_archive_store(settings: Settings) -> ArchiveStore:
|
||||
endpoint = settings.s3_endpoint_url
|
||||
access_key = settings.s3_access_key
|
||||
secret_key = settings.s3_secret_key
|
||||
bucket = settings.s3_bucket
|
||||
|
||||
if endpoint is None or access_key is None or secret_key is None or bucket is None:
|
||||
raise ValueError(
|
||||
"L'archivage vers Garage exige APP_S3_ENDPOINT_URL, APP_S3_ACCESS_KEY, "
|
||||
"APP_S3_SECRET_KEY et APP_S3_BUCKET."
|
||||
)
|
||||
|
||||
client = boto3.client(
|
||||
"s3",
|
||||
endpoint_url=endpoint,
|
||||
aws_access_key_id=access_key,
|
||||
aws_secret_access_key=secret_key.get_secret_value(),
|
||||
region_name=settings.s3_region,
|
||||
)
|
||||
return ArchiveStore(client, bucket=bucket, sse_key=decode_sse_key(settings.s3_sse_key))
|
||||
|
||||
|
||||
async def drop_chunk(conn: AsyncConnection, chunk: Chunk) -> None:
|
||||
result = await conn.execute(DROP_CHUNK, {"start": chunk.range_start, "end": chunk.range_end})
|
||||
supprimes = list(result.scalars().all())
|
||||
|
||||
if supprimes != [chunk.qualified_name]:
|
||||
raise RuntimeError(
|
||||
f"drop_chunks devait supprimer exactement {chunk.qualified_name}, "
|
||||
f"il a rendu {supprimes}."
|
||||
)
|
||||
|
||||
|
||||
async def _export(
|
||||
store: ArchiveStore,
|
||||
key: str,
|
||||
rows: list[dict[str, Any]],
|
||||
*,
|
||||
dry_run: bool,
|
||||
rapport: Rapport,
|
||||
) -> str:
|
||||
body = serialize_csv_gzip(rows)
|
||||
sha = sha256_of(body)
|
||||
|
||||
if await anyio.to_thread.run_sync(store.fetch_sha256, key) == sha:
|
||||
rapport.deja_presents += 1
|
||||
return f"{len(body)} octets déjà présents"
|
||||
|
||||
if dry_run:
|
||||
return f"{len(body)} octets à exporter"
|
||||
|
||||
metadata = {"sha256": sha, "rows": str(len(rows))}
|
||||
await anyio.to_thread.run_sync(store.put, key, body, metadata)
|
||||
relu = await anyio.to_thread.run_sync(store.fetch_sha256, key)
|
||||
|
||||
if relu != sha:
|
||||
raise RuntimeError(
|
||||
f"Relecture de {key} : sha256 {relu} au lieu de {sha}, le chunk est conservé."
|
||||
)
|
||||
|
||||
rapport.exportes += 1
|
||||
return f"{len(body)} octets exportés et relus"
|
||||
|
||||
|
||||
async def _archive_chunk(
|
||||
engine: AsyncEngine,
|
||||
store: ArchiveStore,
|
||||
chunk: Chunk,
|
||||
*,
|
||||
dry_run: bool,
|
||||
rapport: Rapport,
|
||||
) -> None:
|
||||
async with engine.connect() as conn:
|
||||
rows = await read_chunk_rows(conn, chunk)
|
||||
|
||||
key = object_key(chunk)
|
||||
rapport.lignes += len(rows)
|
||||
|
||||
if rows:
|
||||
action = await _export(store, key, rows, dry_run=dry_run, rapport=rapport)
|
||||
else:
|
||||
action = "vide, rien à exporter"
|
||||
|
||||
if dry_run:
|
||||
print(f"{key} : {len(rows)} ligne(s), {action}, suppression simulée.")
|
||||
return
|
||||
|
||||
async with engine.begin() as conn:
|
||||
await drop_chunk(conn, chunk)
|
||||
|
||||
rapport.supprimes += 1
|
||||
print(f"{key} : {len(rows)} ligne(s), {action}, chunk {chunk.qualified_name} supprimé.")
|
||||
|
||||
|
||||
async def archive_reading_chunks(
|
||||
engine: AsyncEngine,
|
||||
store: ArchiveStore,
|
||||
*,
|
||||
older_than: datetime,
|
||||
dry_run: bool,
|
||||
) -> Rapport:
|
||||
rapport = Rapport()
|
||||
|
||||
async with engine.connect() as conn:
|
||||
chunks = await eligible_chunks(conn, older_than)
|
||||
|
||||
rapport.chunks_vus = len(chunks)
|
||||
print(
|
||||
f"{len(chunks)} chunk(s) de reading entièrement antérieur(s) au {older_than.isoformat()}."
|
||||
)
|
||||
|
||||
for chunk in chunks:
|
||||
await _archive_chunk(engine, store, chunk, dry_run=dry_run, rapport=rapport)
|
||||
|
||||
bilan = "Dry-run terminé : rien n'a été écrit ni supprimé." if dry_run else "Archivage terminé."
|
||||
print(
|
||||
f"{bilan} Chunks vus : {rapport.chunks_vus}, exportés : {rapport.exportes}, "
|
||||
f"déjà présents : {rapport.deja_presents}, supprimés : {rapport.supprimes}, "
|
||||
f"lignes : {rapport.lignes}."
|
||||
)
|
||||
return rapport
|
||||
|
||||
|
||||
async def _run(
|
||||
settings: Settings,
|
||||
store: ArchiveStore,
|
||||
*,
|
||||
older_than: datetime,
|
||||
dry_run: bool,
|
||||
) -> Rapport:
|
||||
engine = create_async_engine(str(settings.database_url), pool_pre_ping=True)
|
||||
try:
|
||||
return await archive_reading_chunks(engine, store, older_than=older_than, dry_run=dry_run)
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(
|
||||
prog="python -m app.etl.reading_retention",
|
||||
description=(
|
||||
"Exporte vers Garage puis supprime les chunks de reading entièrement plus vieux "
|
||||
"que la borne de rétention."
|
||||
),
|
||||
)
|
||||
parser.add_argument(
|
||||
"--older-than-days",
|
||||
type=int,
|
||||
default=None,
|
||||
help="Borne en jours, par défaut APP_READING_RETENTION_DAYS.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--dry-run",
|
||||
action="store_true",
|
||||
help="Liste et mesure les chunks éligibles sans rien écrire ni supprimer.",
|
||||
)
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> None:
|
||||
args = build_parser().parse_args(argv)
|
||||
settings = get_settings()
|
||||
|
||||
jours = (
|
||||
settings.reading_retention_days if args.older_than_days is None else args.older_than_days
|
||||
)
|
||||
older_than = datetime.now(UTC) - timedelta(days=jours)
|
||||
store = build_archive_store(settings)
|
||||
|
||||
asyncio.run(_run(settings, store, older_than=older_than, dry_run=args.dry_run))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+10
-93
@@ -1,20 +1,10 @@
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import Depends, FastAPI
|
||||
from fastapi import FastAPI
|
||||
from fastapi.middleware.cors import CORSMiddleware
|
||||
from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
|
||||
from fastapi.staticfiles import StaticFiles
|
||||
from prometheus_client import CollectorRegistry, GCCollector, PlatformCollector, ProcessCollector
|
||||
from prometheus_fastapi_instrumentator import Instrumentator, metrics
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import HTMLResponse
|
||||
from prometheus_fastapi_instrumentator import Instrumentator
|
||||
|
||||
from app.api.errors import register_error_handlers
|
||||
from app.api.middleware import SecurityHeadersMiddleware
|
||||
from app.api.openapi import DESCRIPTION, SUMMARY, TAGS
|
||||
from app.api.security import require_metrics_token
|
||||
from app.api.v1.router import api_router
|
||||
from app.core.config import Settings, get_settings
|
||||
from app.core.logging import configure_logging, get_logger
|
||||
@@ -22,116 +12,43 @@ from app.db.session import get_engine
|
||||
|
||||
logger = get_logger(__name__)
|
||||
|
||||
METHODES_AUTORISEES = ["GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"]
|
||||
EN_TETES_AUTORISES = ["Authorization", "Content-Type"]
|
||||
STATIC_DIR = Path(__file__).parent / "static"
|
||||
LOGO_URL = "/static/logo-icon.png"
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_: FastAPI) -> AsyncIterator[None]:
|
||||
settings = get_settings()
|
||||
logger.info(
|
||||
"Démarrage de %s %s en environnement %s", settings.name, settings.version, settings.env
|
||||
"Demarrage de %s %s en environnement %s", settings.name, settings.version, settings.env
|
||||
)
|
||||
yield
|
||||
await get_engine().dispose()
|
||||
|
||||
|
||||
# Pourquoi : le registre global n'accepte chaque métrique qu'une fois. Toute application créée
|
||||
# après la première, dans les tests notamment, n'aurait rien mesuré.
|
||||
def _registre_de_metriques() -> CollectorRegistry:
|
||||
registre = CollectorRegistry()
|
||||
ProcessCollector(registry=registre)
|
||||
PlatformCollector(registry=registre)
|
||||
GCCollector(registry=registre)
|
||||
return registre
|
||||
|
||||
|
||||
def create_app(settings: Settings | None = None) -> FastAPI:
|
||||
resolved = settings or get_settings()
|
||||
configure_logging(resolved)
|
||||
|
||||
documentee = resolved.api_docs_are_exposed
|
||||
application = FastAPI(
|
||||
title=resolved.name,
|
||||
version=resolved.version,
|
||||
summary=SUMMARY,
|
||||
description=DESCRIPTION,
|
||||
openapi_tags=TAGS,
|
||||
debug=resolved.debug,
|
||||
lifespan=lifespan,
|
||||
docs_url=None,
|
||||
redoc_url=None,
|
||||
openapi_url="/openapi.json" if documentee else None,
|
||||
docs_url=None if resolved.is_production else "/docs",
|
||||
redoc_url=None if resolved.is_production else "/redoc",
|
||||
openapi_url=None if resolved.is_production else "/openapi.json",
|
||||
)
|
||||
|
||||
if documentee:
|
||||
application.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
|
||||
|
||||
# ReDoc supporte nativement `info.x-logo` (extension Redocly) pour afficher un logo
|
||||
# en en-tête ; Swagger UI n'a pas d'equivalent, il ne reprend que le favicon.
|
||||
openapi_original = application.openapi
|
||||
|
||||
def openapi_avec_logo() -> dict[str, object]:
|
||||
schema = openapi_original()
|
||||
schema["info"]["x-logo"] = {"url": LOGO_URL, "altText": "EnerVision"}
|
||||
return schema
|
||||
|
||||
application.openapi = openapi_avec_logo # type: ignore[method-assign]
|
||||
|
||||
@application.get("/docs", include_in_schema=False)
|
||||
async def docs_swagger(_: Request) -> HTMLResponse:
|
||||
return get_swagger_ui_html(
|
||||
openapi_url="/openapi.json",
|
||||
title=f"{application.title} · Swagger UI",
|
||||
swagger_favicon_url=LOGO_URL,
|
||||
)
|
||||
|
||||
@application.get("/redoc", include_in_schema=False)
|
||||
async def docs_redoc(_: Request) -> HTMLResponse:
|
||||
return get_redoc_html(
|
||||
openapi_url="/openapi.json",
|
||||
title=f"{application.title} · ReDoc",
|
||||
redoc_favicon_url=LOGO_URL,
|
||||
)
|
||||
|
||||
application.add_middleware(SecurityHeadersMiddleware)
|
||||
|
||||
if resolved.allowed_origins:
|
||||
# Méthodes et en-têtes listés plutôt que joker : avec `allow_credentials`, la liste
|
||||
# d'origines devient l'unique contrôle, autant documenter le contrat exact.
|
||||
application.add_middleware(
|
||||
CORSMiddleware,
|
||||
allow_origins=resolved.allowed_origins,
|
||||
allow_credentials=True,
|
||||
allow_methods=METHODES_AUTORISEES,
|
||||
allow_headers=EN_TETES_AUTORISES,
|
||||
expose_headers=["Retry-After"],
|
||||
max_age=600,
|
||||
allow_methods=["*"],
|
||||
allow_headers=["*"],
|
||||
)
|
||||
|
||||
register_error_handlers(application)
|
||||
|
||||
# Les sondes de santé tombent toutes les 30 s : comptées, elles fausseraient latences et débit.
|
||||
# Seaux fins autour du seuil de charge (p95 < 500 ms, ADR 0015), route par route.
|
||||
registre = _registre_de_metriques()
|
||||
Instrumentator(
|
||||
excluded_handlers=["/metrics", f"{resolved.api_prefix}/health/.*"], registry=registre
|
||||
).add(
|
||||
metrics.default(latency_lowr_buckets=(0.05, 0.1, 0.25, 0.5, 1, 2.5), registry=registre)
|
||||
).instrument(application).expose(
|
||||
application,
|
||||
endpoint="/metrics",
|
||||
include_in_schema=False,
|
||||
dependencies=[Depends(require_metrics_token)],
|
||||
Instrumentator().instrument(application).expose(
|
||||
application, endpoint="/metrics", include_in_schema=False
|
||||
)
|
||||
application.include_router(api_router, prefix=resolved.api_prefix)
|
||||
|
||||
# Piège : sans cette surcharge, une configuration passée à `create_app()` ne piloterait
|
||||
# que la construction, et les dépendances continueraient de lire `get_settings()` depuis
|
||||
# l'environnement. Un test « en production » ne testerait alors pas la production.
|
||||
if settings is not None:
|
||||
application.dependency_overrides[get_settings] = lambda: resolved
|
||||
|
||||
return application
|
||||
|
||||
@@ -1,34 +1,2 @@
|
||||
# Piège : tout modèle absent de ce module reste invisible de `alembic revision
|
||||
# --autogenerate`, qui générerait alors un drop de sa table.
|
||||
|
||||
from app.models.audit_log import AuditLog
|
||||
from app.models.energy import (
|
||||
Alert,
|
||||
Dataset,
|
||||
DriftReport,
|
||||
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
|
||||
|
||||
__all__ = [
|
||||
"Alert",
|
||||
"AppUser",
|
||||
"AuditLog",
|
||||
"Dataset",
|
||||
"DriftReport",
|
||||
"LoginAttempt",
|
||||
"PasswordResetAttempt",
|
||||
"PasswordResetToken",
|
||||
"Prediction",
|
||||
"Reading",
|
||||
"Recommendation",
|
||||
"RefreshToken",
|
||||
"Site",
|
||||
]
|
||||
# Piege : tout modele absent de ce module reste invisible de `alembic revision
|
||||
# --autogenerate`, qui genererait alors un drop de sa table.
|
||||
|
||||
@@ -1,66 +0,0 @@
|
||||
# Pourquoi : `actor_id` ne porte volontairement aucune clé étrangère. Une contrainte
|
||||
# `ON DELETE SET NULL` déclencherait un UPDATE que le déclencheur d'ajout seul refuserait, donc
|
||||
# la suppression d'un compte échouerait ; une contrainte `NO ACTION` interdirait toute
|
||||
# suppression. `actor_email` et `actor_role` sont dénormalisés pour la même raison : le journal
|
||||
# dit ce qui était vrai au moment de l'acte, pas ce qui est vrai aujourd'hui.
|
||||
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from enum import StrEnum
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy import BigInteger, CheckConstraint, DateTime, Identity, Index, Text, func
|
||||
from sqlalchemy.dialects.postgresql import INET, JSONB
|
||||
from sqlalchemy.dialects.postgresql import UUID as PG_UUID
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.db.base import Base
|
||||
|
||||
|
||||
class AuditOutcome(StrEnum):
|
||||
SUCCES = "success"
|
||||
ECHEC = "failure"
|
||||
|
||||
|
||||
class AuditAction(StrEnum):
|
||||
COMPTE_CREE = "user.created"
|
||||
COMPTE_ROLE_CHANGE = "user.role_changed"
|
||||
COMPTE_DESACTIVE = "user.disabled"
|
||||
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"
|
||||
ADMIN_AMORCE = "bootstrap.admin_created"
|
||||
|
||||
|
||||
ISSUES_AUTORISEES = ", ".join(f"'{issue.value}'" for issue in AuditOutcome)
|
||||
|
||||
|
||||
class AuditLog(Base):
|
||||
__tablename__ = "audit_log"
|
||||
__table_args__ = (
|
||||
CheckConstraint(f"outcome in ({ISSUES_AUTORISEES})", name="ck_audit_log_outcome"),
|
||||
Index("ix_audit_log_date", "occurred_at"),
|
||||
Index("ix_audit_log_action_date", "action", "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()
|
||||
)
|
||||
actor_id: Mapped[uuid.UUID | None] = mapped_column(PG_UUID(as_uuid=True), nullable=True)
|
||||
actor_email: Mapped[str | None] = mapped_column(Text, nullable=True)
|
||||
actor_role: Mapped[str | None] = mapped_column(Text, nullable=True)
|
||||
action: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
target_type: Mapped[str | None] = mapped_column(Text, nullable=True)
|
||||
target_id: Mapped[str | None] = mapped_column(Text, nullable=True)
|
||||
outcome: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
client_ip: Mapped[str | None] = mapped_column(INET, nullable=True)
|
||||
user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
|
||||
detail: Mapped[dict[str, Any]] = mapped_column(
|
||||
JSONB, nullable=False, server_default=func.jsonb_build_object()
|
||||
)
|
||||
@@ -1,256 +0,0 @@
|
||||
"""Tables du modèle de données EnerVision (CSV, API Mock et résultats ML)."""
|
||||
|
||||
from datetime import datetime
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy import (
|
||||
BigInteger,
|
||||
Boolean,
|
||||
CheckConstraint,
|
||||
DateTime,
|
||||
Double,
|
||||
ForeignKey,
|
||||
ForeignKeyConstraint,
|
||||
Index,
|
||||
Integer,
|
||||
Numeric,
|
||||
String,
|
||||
Text,
|
||||
UniqueConstraint,
|
||||
func,
|
||||
text,
|
||||
)
|
||||
from sqlalchemy.dialects.postgresql import ARRAY, JSONB
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.db.base import Base
|
||||
|
||||
|
||||
class Dataset(Base):
|
||||
__tablename__ = "dataset"
|
||||
__table_args__ = (
|
||||
CheckConstraint("dataset_id > 0", name="ck_dataset_positive_id"),
|
||||
UniqueConstraint("archive_sha256", name="uq_dataset_archive_sha256"),
|
||||
)
|
||||
|
||||
dataset_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
dataset_name: Mapped[str] = mapped_column(Text)
|
||||
archive_sha256: Mapped[str] = mapped_column(String(64))
|
||||
storage_uri: Mapped[str] = mapped_column(Text)
|
||||
source_timezone: Mapped[str | None] = mapped_column(Text)
|
||||
# "metadata" est réservé par SQLAlchemy ; le nom SQL reste inchangé.
|
||||
dataset_metadata: Mapped[dict[str, Any]] = mapped_column("metadata", JSONB(none_as_null=True))
|
||||
|
||||
|
||||
class Site(Base):
|
||||
__tablename__ = "site"
|
||||
|
||||
site_id: Mapped[str] = mapped_column(Text, primary_key=True)
|
||||
site_name: Mapped[str] = mapped_column(Text)
|
||||
site_type: Mapped[str] = mapped_column(Text)
|
||||
location: Mapped[str | None] = mapped_column(Text)
|
||||
capacity_kw: Mapped[float | None] = mapped_column(Double)
|
||||
status: Mapped[str | None] = mapped_column(Text)
|
||||
|
||||
|
||||
class Reading(Base):
|
||||
__tablename__ = "reading"
|
||||
__table_args__ = (
|
||||
CheckConstraint(
|
||||
"source IN ('csv', 'api_current', 'api_history')", name="ck_reading_source"
|
||||
),
|
||||
CheckConstraint(
|
||||
"(source = 'csv' AND dataset_id IS NOT NULL) OR "
|
||||
"(source IN ('api_current', 'api_history') AND dataset_id IS NULL)",
|
||||
name="ck_reading_dataset_source",
|
||||
),
|
||||
CheckConstraint(
|
||||
"data_quality IS NULL OR data_quality IN ('good', 'partial', 'degraded', 'critical')",
|
||||
name="ck_reading_quality",
|
||||
),
|
||||
CheckConstraint(
|
||||
"(imputed_values IS NULL AND imputation_method IS NULL) OR "
|
||||
"(imputed_values IS NOT NULL AND imputation_method IS NOT NULL)",
|
||||
name="ck_reading_imputation",
|
||||
),
|
||||
Index("ix_reading_site_timestamp", "site_id", "timestamp"),
|
||||
Index("ix_reading_dataset_id", "dataset_id"),
|
||||
)
|
||||
|
||||
reading_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
site_id: Mapped[str] = mapped_column(
|
||||
Text, ForeignKey("site.site_id", name="fk_reading_site", ondelete="RESTRICT")
|
||||
)
|
||||
timestamp: Mapped[datetime] = mapped_column(DateTime(timezone=True), primary_key=True)
|
||||
source: Mapped[str] = mapped_column(Text)
|
||||
dataset_id: Mapped[int | None] = mapped_column(
|
||||
BigInteger,
|
||||
ForeignKey("dataset.dataset_id", name="fk_reading_dataset", ondelete="RESTRICT"),
|
||||
)
|
||||
consumption_kw: Mapped[float | None] = mapped_column(Double)
|
||||
consumption_kwh: Mapped[float | None] = mapped_column(Double)
|
||||
consumption_euros: Mapped[Decimal | None] = mapped_column(Numeric(14, 2))
|
||||
voltage_v: Mapped[float | None] = mapped_column(Double)
|
||||
current_a: Mapped[float | None] = mapped_column(Double)
|
||||
power_factor: Mapped[float | None] = mapped_column(Double)
|
||||
temperature_celsius: Mapped[float | None] = mapped_column(Double)
|
||||
humidity_percent: Mapped[float | None] = mapped_column(Double)
|
||||
solar_irradiance_wm2: Mapped[float | None] = mapped_column(Double)
|
||||
is_working_hours: Mapped[bool | None] = mapped_column(Boolean)
|
||||
data_quality: Mapped[str | None] = mapped_column(Text)
|
||||
null_reasons: Mapped[list[str] | None] = mapped_column(ARRAY(Text))
|
||||
imputed_values: Mapped[dict[str, Any] | None] = mapped_column(JSONB(none_as_null=True))
|
||||
imputation_method: Mapped[str | None] = mapped_column(Text)
|
||||
ingested_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=func.now()
|
||||
)
|
||||
raw_data: Mapped[dict[str, Any]] = mapped_column(JSONB(none_as_null=True))
|
||||
|
||||
|
||||
Index(
|
||||
"uq_reading_source",
|
||||
Reading.site_id,
|
||||
Reading.timestamp,
|
||||
Reading.source,
|
||||
func.coalesce(Reading.dataset_id, text("0")),
|
||||
unique=True,
|
||||
)
|
||||
|
||||
|
||||
class Prediction(Base):
|
||||
__tablename__ = "prediction"
|
||||
__table_args__ = (
|
||||
UniqueConstraint("prediction_id", "site_id", name="uq_prediction_id_site"),
|
||||
Index("ix_prediction_site_target", "site_id", "target_at"),
|
||||
CheckConstraint(
|
||||
"target_metric IN ('consumption_kwh', 'consumption_kw')",
|
||||
name="ck_prediction_metric",
|
||||
),
|
||||
CheckConstraint(
|
||||
"period_minutes IS NULL OR period_minutes > 0", name="ck_prediction_period"
|
||||
),
|
||||
CheckConstraint(
|
||||
"target_metric <> 'consumption_kwh' OR period_minutes IS NOT NULL",
|
||||
name="ck_prediction_energy_period",
|
||||
),
|
||||
CheckConstraint(
|
||||
"(status = 'available' AND predicted_value IS NOT NULL AND failure_reason IS NULL) OR "
|
||||
"(status IN ('insufficient_data', 'error') AND predicted_value IS NULL "
|
||||
"AND failure_reason IS NOT NULL)",
|
||||
name="ck_prediction_status",
|
||||
),
|
||||
)
|
||||
|
||||
prediction_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
site_id: Mapped[str] = mapped_column(
|
||||
Text, ForeignKey("site.site_id", name="fk_prediction_site", ondelete="RESTRICT")
|
||||
)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
|
||||
target_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
target_metric: Mapped[str] = mapped_column(Text)
|
||||
period_minutes: Mapped[int | None] = mapped_column(Integer)
|
||||
predicted_value: Mapped[float | None] = mapped_column(Double)
|
||||
model_reference: Mapped[str] = mapped_column(Text)
|
||||
status: Mapped[str] = mapped_column(Text)
|
||||
failure_reason: Mapped[str | None] = mapped_column(Text)
|
||||
|
||||
|
||||
class Alert(Base):
|
||||
__tablename__ = "alert"
|
||||
__table_args__ = (
|
||||
UniqueConstraint("source", "site_id", "source_alert_id", name="uq_alert_source_reference"),
|
||||
Index("ix_alert_site_timestamp", "site_id", "timestamp"),
|
||||
ForeignKeyConstraint(
|
||||
["prediction_id", "site_id"],
|
||||
["prediction.prediction_id", "prediction.site_id"],
|
||||
name="fk_alert_prediction_site",
|
||||
ondelete="RESTRICT",
|
||||
),
|
||||
CheckConstraint("source IN ('api_mock', 'enervision')", name="ck_alert_source"),
|
||||
CheckConstraint(
|
||||
"type IN ('spike', 'threshold', 'anomaly', 'outage', 'sensor')", name="ck_alert_type"
|
||||
),
|
||||
CheckConstraint(
|
||||
"severity IN ('low', 'medium', 'high', 'critical')", name="ck_alert_severity"
|
||||
),
|
||||
)
|
||||
|
||||
alert_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
source_alert_id: Mapped[str] = mapped_column(Text)
|
||||
site_id: Mapped[str] = mapped_column(
|
||||
Text, ForeignKey("site.site_id", name="fk_alert_site", ondelete="RESTRICT")
|
||||
)
|
||||
source: Mapped[str] = mapped_column(Text)
|
||||
timestamp: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
type: Mapped[str] = mapped_column(Text)
|
||||
severity: Mapped[str] = mapped_column(Text)
|
||||
message: Mapped[str] = mapped_column(Text)
|
||||
value: Mapped[float | None] = mapped_column(Double)
|
||||
threshold: Mapped[float | None] = mapped_column(Double)
|
||||
metric: Mapped[str | None] = mapped_column(Text)
|
||||
prediction_id: Mapped[int | None] = mapped_column(BigInteger)
|
||||
raw_data: Mapped[dict[str, Any]] = mapped_column(JSONB(none_as_null=True))
|
||||
|
||||
|
||||
class Recommendation(Base):
|
||||
__tablename__ = "recommendation"
|
||||
__table_args__ = (
|
||||
UniqueConstraint("alert_id", "rule_reference", name="uq_recommendation_alert_rule"),
|
||||
)
|
||||
|
||||
recommendation_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
alert_id: Mapped[int] = mapped_column(
|
||||
BigInteger,
|
||||
ForeignKey("alert.alert_id", name="fk_recommendation_alert", ondelete="RESTRICT"),
|
||||
)
|
||||
action: Mapped[str] = mapped_column(Text)
|
||||
explanation: Mapped[str] = mapped_column(Text)
|
||||
rule_reference: Mapped[str] = mapped_column(Text)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
|
||||
|
||||
|
||||
class DriftReport(Base):
|
||||
__tablename__ = "drift_report"
|
||||
__table_args__ = (
|
||||
CheckConstraint(
|
||||
"status IN ('stable', 'derive', 'indetermine')", name="ck_drift_report_status"
|
||||
),
|
||||
CheckConstraint("status = 'stable' OR reason IS NOT NULL", name="ck_drift_report_reason"),
|
||||
CheckConstraint("n_observations >= 0", name="ck_drift_report_observations"),
|
||||
Index("ix_drift_report_site_computed", "site_id", "computed_at"),
|
||||
)
|
||||
|
||||
drift_report_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
computed_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=func.now()
|
||||
)
|
||||
# `NULL` porte la ligne globale, tous sites confondus : une derive d'ensemble et la derive
|
||||
# d'un seul site ne se lisent pas dans le meme chiffre.
|
||||
site_id: Mapped[str | None] = mapped_column(
|
||||
Text, ForeignKey("site.site_id", name="fk_drift_report_site", ondelete="RESTRICT")
|
||||
)
|
||||
window_start: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
window_end: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
reference_start: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
|
||||
reference_end: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
|
||||
n_observations: Mapped[int] = mapped_column(Integer)
|
||||
mae: Mapped[float | None] = mapped_column(Double)
|
||||
mape: Mapped[float | None] = mapped_column(Double)
|
||||
bias: Mapped[float | None] = mapped_column(Double)
|
||||
reference_mae: Mapped[float | None] = mapped_column(Double)
|
||||
coverage_ratio: Mapped[float | None] = mapped_column(Double)
|
||||
insufficient_data_ratio: Mapped[float | None] = mapped_column(Double)
|
||||
model_references: Mapped[list[str]] = mapped_column(ARRAY(Text))
|
||||
status: Mapped[str] = mapped_column(Text)
|
||||
reason: Mapped[str | None] = mapped_column(Text)
|
||||
|
||||
|
||||
# Piège : une `UniqueConstraint` ne dédoublonnerait pas les lignes globales, dont `site_id` est
|
||||
# NULL et qu'aucune n'est égale à une autre. Même forme que `uq_reading_source`.
|
||||
Index(
|
||||
"uq_drift_report_window",
|
||||
DriftReport.window_end,
|
||||
func.coalesce(DriftReport.site_id, text("''")),
|
||||
unique=True,
|
||||
)
|
||||
@@ -1,44 +0,0 @@
|
||||
# Pourquoi : les tentatives vivent ici et non dans `audit_log`, qui est en ajout seul. Leur
|
||||
# volume est piloté par l'attaquant : une force brute y écrirait des millions de lignes
|
||||
# indestructibles. Cette table-ci se purge, et c'est aussi le compteur de la limitation.
|
||||
# Piège : la tentative est enregistrée même quand l'email est inconnu, sinon le 429 dirait
|
||||
# qu'un compte existe.
|
||||
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from enum import StrEnum
|
||||
|
||||
from sqlalchemy import BigInteger, CheckConstraint, DateTime, Identity, Index, String, 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 LoginOutcome(StrEnum):
|
||||
SUCCES = "success"
|
||||
IDENTIFIANTS_INVALIDES = "bad_credentials"
|
||||
LIMITE = "throttled"
|
||||
COMPTE_INDISPONIBLE = "inactive"
|
||||
|
||||
|
||||
ISSUES_AUTORISEES = ", ".join(f"'{issue.value}'" for issue in LoginOutcome)
|
||||
|
||||
|
||||
class LoginAttempt(Base):
|
||||
__tablename__ = "login_attempt"
|
||||
__table_args__ = (
|
||||
CheckConstraint(f"outcome in ({ISSUES_AUTORISEES})", name="ck_login_attempt_outcome"),
|
||||
Index("ix_login_attempt_email_date", "email_tried", "occurred_at"),
|
||||
Index("ix_login_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)
|
||||
outcome: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
user_id: Mapped[uuid.UUID | None] = mapped_column(PG_UUID(as_uuid=True), nullable=True)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -1,64 +0,0 @@
|
||||
# Pourquoi : un jeton de rafraîchissement est une chaîne opaque, jamais un JWT. Il doit être
|
||||
# révocable, donc cette ligne existe de toute façon ; le JWT n'ajouterait qu'un second chemin de
|
||||
# signature. Surtout, la séparation devient structurelle : un JWT ne figure dans aucune ligne,
|
||||
# une chaîne opaque échoue au décodage. Aucune confusion de type n'est possible.
|
||||
# Piège : `expires_at` est absolu et hérité du prédécesseur à chaque rotation. S'il glissait,
|
||||
# la promesse de sept jours serait fictive et une session active ne finirait jamais.
|
||||
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from enum import StrEnum
|
||||
|
||||
from sqlalchemy import CheckConstraint, 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 RevocationReason(StrEnum):
|
||||
DECONNEXION = "logout"
|
||||
ROTATION = "rotation"
|
||||
REUTILISATION = "reuse_detected"
|
||||
CHANGEMENT_MOT_DE_PASSE = "password_change"
|
||||
ADMINISTRATION = "admin"
|
||||
|
||||
|
||||
MOTIFS_AUTORISES = ", ".join(f"'{motif.value}'" for motif in RevocationReason)
|
||||
|
||||
|
||||
class RefreshToken(Base):
|
||||
__tablename__ = "refresh_token"
|
||||
__table_args__ = (
|
||||
CheckConstraint(
|
||||
f"revoked_reason is null or revoked_reason in ({MOTIFS_AUTORISES})",
|
||||
name="ck_refresh_token_revoked_reason",
|
||||
),
|
||||
Index("ix_refresh_token_family", "family_id"),
|
||||
Index("ix_refresh_token_user", "user_id"),
|
||||
Index(
|
||||
"ix_refresh_token_vivants",
|
||||
"user_id",
|
||||
postgresql_where="revoked_at is null and rotated_at is null",
|
||||
),
|
||||
)
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(
|
||||
PG_UUID(as_uuid=True), primary_key=True, server_default=func.gen_random_uuid()
|
||||
)
|
||||
family_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), nullable=False)
|
||||
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)
|
||||
rotated_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
|
||||
revoked_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
|
||||
revoked_reason: Mapped[str | None] = mapped_column(Text, nullable=True)
|
||||
replaced_by: Mapped[uuid.UUID | None] = mapped_column(PG_UUID(as_uuid=True), nullable=True)
|
||||
client_ip: Mapped[str | None] = mapped_column(INET, nullable=True)
|
||||
user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
|
||||
@@ -1,50 +0,0 @@
|
||||
# Contrainte : la table s'appelle `app_user` et non `user`, qui est un mot réservé PostgreSQL,
|
||||
# raccourci de `CURRENT_USER`. Le nom rappelle aussi qu'il s'agit d'un compte applicatif, par
|
||||
# opposition au rôle PostgreSQL qui porte, lui, le cantonnement des accès.
|
||||
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import Boolean, CheckConstraint, DateTime, String, Text, func, text
|
||||
from sqlalchemy.dialects.postgresql import UUID as PG_UUID
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.core.roles import AccountKind, Role
|
||||
from app.db.base import Base
|
||||
|
||||
ROLES_AUTORISES = ", ".join(f"'{role.value}'" for role in Role)
|
||||
NATURES_AUTORISEES = ", ".join(f"'{nature.value}'" for nature in AccountKind)
|
||||
|
||||
|
||||
class AppUser(Base):
|
||||
__tablename__ = "app_user"
|
||||
__table_args__ = (
|
||||
CheckConstraint("email = lower(email)", name="ck_app_user_email_minuscule"),
|
||||
CheckConstraint(f"role in ({ROLES_AUTORISES})", name="ck_app_user_role"),
|
||||
CheckConstraint(f"kind in ({NATURES_AUTORISEES})", name="ck_app_user_kind"),
|
||||
)
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(
|
||||
PG_UUID(as_uuid=True), primary_key=True, server_default=func.gen_random_uuid()
|
||||
)
|
||||
email: Mapped[str] = mapped_column(String(320), unique=True, nullable=False)
|
||||
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
role: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
kind: Mapped[str] = mapped_column(Text, nullable=False, server_default=text("'human'"))
|
||||
is_active: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("true"))
|
||||
must_change_password: Mapped[bool] = mapped_column(
|
||||
Boolean, nullable=False, server_default=text("false")
|
||||
)
|
||||
# Une seule colonne couvre le changement de mot de passe, le changement de rôle et la
|
||||
# désactivation : tout jeton émis avant cet instant est périmé.
|
||||
credentials_changed_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), nullable=False, server_default=func.now()
|
||||
)
|
||||
last_login_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
|
||||
full_name: Mapped[str | None] = mapped_column(Text, nullable=True)
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), nullable=False, server_default=func.now()
|
||||
)
|
||||
updated_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), nullable=False, server_default=func.now(), onupdate=func.now()
|
||||
)
|
||||
@@ -1,115 +0,0 @@
|
||||
# Surveillance de dérive du modèle de prévision (EC06, issue #45) : même gabarit que
|
||||
# `app.detection.internal_alerts`, ordonnancé par le DAG `derive`.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import sys
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
from app.core.config import get_settings
|
||||
from app.db.session import get_session_factory
|
||||
from app.repositories.drift import DriftRepository, NouveauRapportDerive
|
||||
from app.services.drift import STATUT_DERIVE, DriftService, Seuils
|
||||
|
||||
|
||||
async def run_drift(
|
||||
*, now: datetime | None = None, site_id: str | None = None, seuils: Seuils | None = None
|
||||
) -> list[NouveauRapportDerive]:
|
||||
"""Calcule les rapports de la fenêtre et les enregistre. Rend ce qui a été calculé, que la
|
||||
ligne ait été écrite ou ignorée par l'index d'idempotence."""
|
||||
async with get_session_factory()() as session:
|
||||
depot = DriftRepository(session)
|
||||
rapports = await DriftService(depot, seuils=seuils).evaluate(now=now, site_id=site_id)
|
||||
await depot.enregistre(rapports)
|
||||
await session.commit()
|
||||
return rapports
|
||||
|
||||
|
||||
def _parse_instant(valeur: str) -> datetime:
|
||||
instant = datetime.fromisoformat(valeur)
|
||||
return instant if instant.tzinfo is not None else instant.replace(tzinfo=UTC)
|
||||
|
||||
|
||||
def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
|
||||
defauts = Seuils()
|
||||
parser = argparse.ArgumentParser(
|
||||
prog="python -m app.monitoring.drift",
|
||||
description="Surveillance de dérive du modèle de prévision EnerVision",
|
||||
)
|
||||
parser.add_argument("--site-id", default=None, help="Limite le calcul à un seul site.")
|
||||
parser.add_argument(
|
||||
"--now",
|
||||
type=_parse_instant,
|
||||
default=None,
|
||||
help=(
|
||||
"Instant de référence (ISO 8601, UTC si le fuseau est omis). Défaut : l'heure courante."
|
||||
),
|
||||
)
|
||||
parser.add_argument(
|
||||
"--window-hours",
|
||||
type=int,
|
||||
default=int(defauts.fenetre.total_seconds() // 3600),
|
||||
help="Durée de la fenêtre récente, et de la fenêtre de référence qui la précède.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--grace-hours",
|
||||
type=int,
|
||||
default=int(defauts.grace.total_seconds() // 3600),
|
||||
help="Délai laissé à l'ingestion avant qu'une prévision soit jugée vérifiable.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--min-observations",
|
||||
type=int,
|
||||
default=defauts.min_observations,
|
||||
help="En deçà, le verdict est `indetermine` plutôt qu'un chiffre trompeur.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--bias-threshold",
|
||||
type=float,
|
||||
default=defauts.seuil_biais,
|
||||
help=(
|
||||
"Biais absolu en kWh au-delà duquel le verdict bascule en dérive. "
|
||||
"Zéro, le défaut, laisse le biais informatif : voir l'ADR 0013."
|
||||
),
|
||||
)
|
||||
parser.add_argument(
|
||||
"--fail-on-drift",
|
||||
action="store_true",
|
||||
help="Sort en code non nul si une dérive est constatée, pour que la tâche rougisse.",
|
||||
)
|
||||
return parser.parse_args(argv)
|
||||
|
||||
|
||||
def seuils_depuis(args: argparse.Namespace) -> Seuils:
|
||||
return Seuils(
|
||||
fenetre=timedelta(hours=args.window_hours),
|
||||
grace=timedelta(hours=args.grace_hours),
|
||||
min_observations=args.min_observations,
|
||||
seuil_biais=args.bias_threshold,
|
||||
)
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = parse_args(argv)
|
||||
# Échoue tôt si `APP_SECRET_KEY`/`DATABASE_URL` manquent, avant toute requête à la base.
|
||||
get_settings()
|
||||
rapports = asyncio.run(
|
||||
run_drift(now=args.now, site_id=args.site_id, seuils=seuils_depuis(args))
|
||||
)
|
||||
|
||||
for rapport in rapports:
|
||||
cible = rapport.site_id or "TOUS SITES"
|
||||
mae = f"{rapport.mae:.2f}" if rapport.mae is not None else "-"
|
||||
print(
|
||||
f"{cible} : {rapport.status}, MAE {mae} kWh sur {rapport.n_observations} prévision(s)"
|
||||
f"{' : ' + rapport.reason if rapport.reason else ''}"
|
||||
)
|
||||
|
||||
derive = any(rapport.status == STATUT_DERIVE for rapport in rapports)
|
||||
return 1 if derive and args.fail_on_drift else 0
|
||||
|
||||
|
||||
if __name__ == "__main__": # pragma: no cover
|
||||
sys.exit(main())
|
||||
@@ -1,64 +0,0 @@
|
||||
from collections.abc import Sequence
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.dialects.postgresql import insert
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.energy import Alert
|
||||
|
||||
# Douze colonnes par alerte, contre quatre pour une recommandation : le plafond asyncpg de
|
||||
# 32 767 parametres tombe a 2 730 lignes, d'ou un lot plus petit que `recommendation.py`.
|
||||
TAILLE_DE_LOT = 1000
|
||||
|
||||
|
||||
class AlertRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def list_all(
|
||||
self, *, site_id: str | None = None, severity: str | None = None
|
||||
) -> Sequence[Alert]:
|
||||
requete = select(Alert).order_by(Alert.timestamp.desc(), Alert.alert_id.desc())
|
||||
if site_id is not None:
|
||||
requete = requete.where(Alert.site_id == site_id)
|
||||
if severity is not None:
|
||||
requete = requete.where(Alert.severity == severity)
|
||||
return (await self._session.scalars(requete)).all()
|
||||
|
||||
async def create_many(self, alerts: Sequence[Alert]) -> Sequence[Alert]:
|
||||
# `ON CONFLICT DO NOTHING` sur `uq_alert_source_reference` : rejouer la détection sur une
|
||||
# fenêtre qui recouvre une exécution précédente ne doit pas dupliquer une alerte déjà
|
||||
# enregistrée. `RETURNING` ne renvoie donc que les lignes effectivement insérées.
|
||||
if not alerts:
|
||||
return []
|
||||
valeurs = [
|
||||
{
|
||||
"source_alert_id": alerte.source_alert_id,
|
||||
"site_id": alerte.site_id,
|
||||
"source": alerte.source,
|
||||
"timestamp": alerte.timestamp,
|
||||
"type": alerte.type,
|
||||
"severity": alerte.severity,
|
||||
"message": alerte.message,
|
||||
"value": alerte.value,
|
||||
"threshold": alerte.threshold,
|
||||
"metric": alerte.metric,
|
||||
"prediction_id": alerte.prediction_id,
|
||||
"raw_data": alerte.raw_data,
|
||||
}
|
||||
for alerte in alerts
|
||||
]
|
||||
creees: list[Alert] = []
|
||||
# Piège : asyncpg plafonne une requête à 32 767 paramètres. Une détection sur une fenêtre
|
||||
# chargée dépasse ce seuil, et l'`INSERT` d'un seul tenant échouerait.
|
||||
for debut in range(0, len(valeurs), TAILLE_DE_LOT):
|
||||
requete = (
|
||||
insert(Alert)
|
||||
.values(valeurs[debut : debut + TAILLE_DE_LOT])
|
||||
.on_conflict_do_nothing(constraint="uq_alert_source_reference")
|
||||
.returning(Alert)
|
||||
)
|
||||
resultat = await self._session.execute(requete)
|
||||
creees.extend(resultat.scalars().all())
|
||||
await self._session.flush()
|
||||
return creees
|
||||
@@ -1,62 +0,0 @@
|
||||
# Piège : `detail` passe par une liste blanche de clés et jamais par un `dict(**kwargs)`. La
|
||||
# table est en ajout seul : une clé inattendue qui porterait un secret ou une donnée
|
||||
# personnelle ne pourrait plus en être retirée.
|
||||
|
||||
from collections.abc import Mapping
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core.principal import Principal
|
||||
from app.models.audit_log import AuditAction, AuditLog, AuditOutcome
|
||||
|
||||
CLES_DE_DETAIL_AUTORISEES = frozenset(
|
||||
{
|
||||
"email",
|
||||
"role_avant",
|
||||
"role_apres",
|
||||
"famille",
|
||||
"motif",
|
||||
"source",
|
||||
"sessions_revoquees",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def assemble_detail(brut: Mapping[str, Any] | None) -> dict[str, Any]:
|
||||
if not brut:
|
||||
return {}
|
||||
return {cle: valeur for cle, valeur in brut.items() if cle in CLES_DE_DETAIL_AUTORISEES}
|
||||
|
||||
|
||||
class AuditLogRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def record(
|
||||
self,
|
||||
*,
|
||||
action: AuditAction,
|
||||
outcome: AuditOutcome = AuditOutcome.SUCCES,
|
||||
actor: Principal | None = None,
|
||||
actor_label: str | None = None,
|
||||
target_type: str | None = None,
|
||||
target_id: str | None = None,
|
||||
client_ip: str | None = None,
|
||||
user_agent: str | None = None,
|
||||
detail: Mapping[str, Any] | None = None,
|
||||
) -> None:
|
||||
self._session.add(
|
||||
AuditLog(
|
||||
actor_id=actor.id if actor else None,
|
||||
actor_email=actor.email if actor else actor_label,
|
||||
actor_role=actor.role.value if actor else None,
|
||||
action=action.value,
|
||||
target_type=target_type,
|
||||
target_id=target_id,
|
||||
outcome=outcome.value,
|
||||
client_ip=client_ip,
|
||||
user_agent=user_agent,
|
||||
detail=assemble_detail(detail),
|
||||
)
|
||||
)
|
||||
@@ -1,184 +0,0 @@
|
||||
"""Piège : deux dédoublonnages, pas un - DriftRepository.paires()
|
||||
|
||||
`prediction` n'a pas d'unicité sur `(site_id, target_at)` : chaque run de scoring empile une
|
||||
ligne de plus. `uq_reading_source` autorise de son côté deux lectures au même instant quand la
|
||||
`source` diffère. Joindre les deux tables sans `DISTINCT ON` des deux côtés compterait donc la
|
||||
même heure plusieurs fois, et la moyenne d'erreur pèserait ces sites en double.
|
||||
|
||||
On retient la prédiction du run le plus récent, celle que sert `GET /api/v1/predictions`, avec
|
||||
`prediction_id` en départage : `created_at` vaut l'heure de début de transaction et ne
|
||||
distingue pas deux lignes du même run.
|
||||
"""
|
||||
|
||||
from collections.abc import Sequence
|
||||
from dataclasses import asdict, dataclass
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import Subquery, func, select
|
||||
from sqlalchemy.dialects.postgresql import insert
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.energy import DriftReport, Prediction, Reading
|
||||
|
||||
TARGET_METRIC = "consumption_kwh"
|
||||
STATUT_DISPONIBLE = "available"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class PaireDerive:
|
||||
site_id: str
|
||||
target_at: datetime
|
||||
predicted_value: float
|
||||
actual_value: float
|
||||
model_reference: str
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class NouveauRapportDerive:
|
||||
site_id: str | None
|
||||
window_start: datetime
|
||||
window_end: datetime
|
||||
reference_start: datetime | None
|
||||
reference_end: datetime | None
|
||||
n_observations: int
|
||||
mae: float | None
|
||||
mape: float | None
|
||||
bias: float | None
|
||||
reference_mae: float | None
|
||||
coverage_ratio: float | None
|
||||
insufficient_data_ratio: float | None
|
||||
model_references: list[str]
|
||||
status: str
|
||||
reason: str | None
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ComptageStatut:
|
||||
site_id: str
|
||||
status: str
|
||||
nombre: int
|
||||
|
||||
|
||||
def _predictions_retenues(*, debut: datetime, fin: datetime, site_id: str | None) -> Subquery:
|
||||
requete = (
|
||||
select(
|
||||
Prediction.site_id,
|
||||
Prediction.target_at,
|
||||
Prediction.predicted_value,
|
||||
Prediction.model_reference,
|
||||
Prediction.status,
|
||||
)
|
||||
.distinct(Prediction.site_id, Prediction.target_at)
|
||||
.where(
|
||||
Prediction.target_metric == TARGET_METRIC,
|
||||
Prediction.target_at >= debut,
|
||||
Prediction.target_at < fin,
|
||||
)
|
||||
.order_by(Prediction.site_id, Prediction.target_at, Prediction.prediction_id.desc())
|
||||
)
|
||||
if site_id is not None:
|
||||
requete = requete.where(Prediction.site_id == site_id)
|
||||
return requete.subquery()
|
||||
|
||||
|
||||
def _lectures_retenues(*, debut: datetime, fin: datetime, site_id: str | None) -> Subquery:
|
||||
requete = (
|
||||
select(Reading.site_id, Reading.timestamp, Reading.consumption_kwh)
|
||||
.distinct(Reading.site_id, Reading.timestamp)
|
||||
.where(
|
||||
Reading.timestamp >= debut,
|
||||
Reading.timestamp < fin,
|
||||
Reading.consumption_kwh.is_not(None),
|
||||
)
|
||||
.order_by(Reading.site_id, Reading.timestamp, Reading.reading_id.desc())
|
||||
)
|
||||
if site_id is not None:
|
||||
requete = requete.where(Reading.site_id == site_id)
|
||||
return requete.subquery()
|
||||
|
||||
|
||||
class DriftRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def paires(
|
||||
self, *, debut: datetime, fin: datetime, site_id: str | None = None
|
||||
) -> Sequence[PaireDerive]:
|
||||
predictions = _predictions_retenues(debut=debut, fin=fin, site_id=site_id)
|
||||
lectures = _lectures_retenues(debut=debut, fin=fin, site_id=site_id)
|
||||
requete = (
|
||||
select(
|
||||
predictions.c.site_id,
|
||||
predictions.c.target_at,
|
||||
predictions.c.predicted_value,
|
||||
lectures.c.consumption_kwh,
|
||||
predictions.c.model_reference,
|
||||
)
|
||||
.select_from(predictions)
|
||||
.join(
|
||||
lectures,
|
||||
(lectures.c.site_id == predictions.c.site_id)
|
||||
& (lectures.c.timestamp == predictions.c.target_at),
|
||||
)
|
||||
.where(predictions.c.status == STATUT_DISPONIBLE)
|
||||
.order_by(predictions.c.site_id, predictions.c.target_at)
|
||||
)
|
||||
|
||||
lignes = await self._session.execute(requete)
|
||||
return [
|
||||
PaireDerive(
|
||||
site_id=ligne[0],
|
||||
target_at=ligne[1],
|
||||
predicted_value=ligne[2],
|
||||
actual_value=ligne[3],
|
||||
model_reference=ligne[4],
|
||||
)
|
||||
for ligne in lignes
|
||||
]
|
||||
|
||||
async def comptages(
|
||||
self, *, debut: datetime, fin: datetime, site_id: str | None = None
|
||||
) -> Sequence[ComptageStatut]:
|
||||
predictions = _predictions_retenues(debut=debut, fin=fin, site_id=site_id)
|
||||
requete = (
|
||||
select(predictions.c.site_id, predictions.c.status, func.count())
|
||||
.select_from(predictions)
|
||||
.group_by(predictions.c.site_id, predictions.c.status)
|
||||
)
|
||||
|
||||
lignes = await self._session.execute(requete)
|
||||
return [
|
||||
ComptageStatut(site_id=ligne[0], status=ligne[1], nombre=ligne[2]) for ligne in lignes
|
||||
]
|
||||
|
||||
# Pourquoi : l'idempotence est déléguée à `uq_drift_report_window` plutôt qu'à une lecture
|
||||
# préalable, comme pour les recommandations. Rejouer la commande sur la même fenêtre ne
|
||||
# duplique donc rien.
|
||||
async def enregistre(self, rapports: Sequence[NouveauRapportDerive]) -> int:
|
||||
if not rapports:
|
||||
return 0
|
||||
|
||||
valeurs = [asdict(rapport) for rapport in rapports]
|
||||
requete = (
|
||||
insert(DriftReport)
|
||||
.values(valeurs)
|
||||
.on_conflict_do_nothing(
|
||||
index_elements=[DriftReport.window_end, func.coalesce(DriftReport.site_id, "")]
|
||||
)
|
||||
.returning(DriftReport.drift_report_id)
|
||||
)
|
||||
return len((await self._session.scalars(requete)).all())
|
||||
|
||||
async def derniers(self, *, site_id: str | None = None) -> Sequence[DriftReport]:
|
||||
requete = (
|
||||
select(DriftReport)
|
||||
.distinct(DriftReport.site_id)
|
||||
.order_by(
|
||||
DriftReport.site_id,
|
||||
DriftReport.computed_at.desc(),
|
||||
DriftReport.drift_report_id.desc(),
|
||||
)
|
||||
)
|
||||
if site_id is not None:
|
||||
requete = requete.where(DriftReport.site_id == site_id)
|
||||
return (await self._session.scalars(requete)).all()
|
||||
@@ -1,67 +0,0 @@
|
||||
# Pourquoi : les trois compteurs tiennent en une seule requête, grâce aux clauses FILTER de
|
||||
# PostgreSQL. Trois `count(*)` séparés feraient trois allers-retours sur le chemin critique de
|
||||
# la connexion, qui est justement celui qu'un attaquant martèle.
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy import and_, func, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.login_attempt import LoginAttempt, LoginOutcome
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class FailureCounts:
|
||||
per_identifier_and_ip: int
|
||||
per_ip: int
|
||||
per_identifier: int
|
||||
|
||||
|
||||
class LoginAttemptRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def record(
|
||||
self,
|
||||
*,
|
||||
email: str,
|
||||
client_ip: str | None,
|
||||
outcome: LoginOutcome,
|
||||
user_id: UUID | None = None,
|
||||
) -> None:
|
||||
self._session.add(
|
||||
LoginAttempt(
|
||||
email_tried=email.strip().lower(),
|
||||
client_ip=client_ip,
|
||||
outcome=outcome.value,
|
||||
user_id=user_id,
|
||||
)
|
||||
)
|
||||
|
||||
async def count_recent_failures(
|
||||
self, *, email: str, client_ip: str | None, window_seconds: int
|
||||
) -> FailureCounts:
|
||||
identifiant = email.strip().lower()
|
||||
meme_email = LoginAttempt.email_tried == identifiant
|
||||
meme_ip = LoginAttempt.client_ip == client_ip
|
||||
|
||||
requete = select(
|
||||
func.count().filter(and_(meme_email, meme_ip)),
|
||||
func.count().filter(meme_ip),
|
||||
func.count().filter(meme_email),
|
||||
).where(
|
||||
LoginAttempt.outcome != LoginOutcome.SUCCES.value,
|
||||
LoginAttempt.occurred_at > datetime.now(UTC) - timedelta(seconds=window_seconds),
|
||||
meme_email | meme_ip,
|
||||
)
|
||||
|
||||
par_identifiant_et_ip, par_ip, par_identifiant = (
|
||||
await self._session.execute(requete)
|
||||
).one()
|
||||
return FailureCounts(
|
||||
per_identifier_and_ip=par_identifiant_et_ip,
|
||||
per_ip=par_ip,
|
||||
per_identifier=par_identifiant,
|
||||
)
|
||||
@@ -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)
|
||||
@@ -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())
|
||||
@@ -1,49 +0,0 @@
|
||||
from collections.abc import Sequence
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.energy import Prediction
|
||||
|
||||
|
||||
class PredictionRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def list_since(
|
||||
self, *, since: datetime, site_id: str | None = None
|
||||
) -> Sequence[Prediction]:
|
||||
# Restreint à `available` : une prévision `insufficient_data`/`error` n'a pas de
|
||||
# `predicted_value` à comparer à une lecture réelle (détection d'anomalie).
|
||||
# Piège : `prediction` n'a pas d'unicité sur `(site_id, target_at)` (cf.
|
||||
# `enervision_ml.score`, qui insère toujours une nouvelle ligne plutôt que d'écraser la
|
||||
# précédente). `prediction_id` en dernier départage donc les égalités de `target_at` par
|
||||
# ordre croissant : `_detect_anomaly` construit un dict qui garde le dernier rencontré,
|
||||
# c'est-à-dire le run le plus récent plutôt qu'une ligne choisie au hasard par le plan
|
||||
# d'exécution.
|
||||
requete = (
|
||||
select(Prediction)
|
||||
.where(Prediction.target_at >= since, Prediction.status == "available")
|
||||
.order_by(Prediction.site_id, Prediction.target_at, Prediction.prediction_id)
|
||||
)
|
||||
if site_id is not None:
|
||||
requete = requete.where(Prediction.site_id == site_id)
|
||||
return (await self._session.scalars(requete)).all()
|
||||
|
||||
async def latest_by_site(self) -> Sequence[Prediction]:
|
||||
# `.distinct(site_id)` compile en `DISTINCT ON (site_id)` sous PostgreSQL : une seule
|
||||
# ligne par site, la plus récente grâce à l'ordre composite qui suit. Même mécanisme que
|
||||
# `ReadingRepository.latest_by_site`. Trié sur `target_at` (couvert par
|
||||
# `ix_prediction_site_target`) plutôt que `created_at` : c'est la prévision la plus
|
||||
# récente qui compte pour un tableau de bord, pas forcément le dernier run de scoring.
|
||||
requete = (
|
||||
select(Prediction)
|
||||
.distinct(Prediction.site_id)
|
||||
.order_by(
|
||||
Prediction.site_id,
|
||||
Prediction.target_at.desc(),
|
||||
Prediction.prediction_id.desc(),
|
||||
)
|
||||
)
|
||||
return (await self._session.scalars(requete)).all()
|
||||
@@ -1,70 +0,0 @@
|
||||
from collections.abc import Sequence
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.energy import Reading
|
||||
|
||||
|
||||
class ReadingRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def latest_by_site(self) -> Sequence[Reading]:
|
||||
# `.distinct(site_id)` compile en `DISTINCT ON (site_id)` sous PostgreSQL : une seule
|
||||
# ligne par site, la plus récente grâce à l'ordre composite qui suit. `reading_id` départage
|
||||
# les égalités de timestamp, que `uq_reading_source` autorise à `source` différente.
|
||||
requete = (
|
||||
select(Reading)
|
||||
.distinct(Reading.site_id)
|
||||
.order_by(Reading.site_id, Reading.timestamp.desc(), Reading.reading_id.desc())
|
||||
)
|
||||
return (await self._session.execute(requete)).scalars().all()
|
||||
|
||||
async def latest_for_site(self, site_id: str) -> Reading | None:
|
||||
# Piège : `uq_reading_source` autorise deux lignes au même `site_id`+`timestamp` quand la
|
||||
# `source` diffère. Sans `reading_id` en départage, le `LIMIT 1` renverrait au hasard.
|
||||
requete = (
|
||||
select(Reading)
|
||||
.where(Reading.site_id == site_id)
|
||||
.order_by(Reading.timestamp.desc(), Reading.reading_id.desc())
|
||||
.limit(1)
|
||||
)
|
||||
lecture: Reading | None = await self._session.scalar(requete)
|
||||
return lecture
|
||||
|
||||
async def list_since(self, *, since: datetime, site_id: str | None = None) -> Sequence[Reading]:
|
||||
# Trié par site puis par heure croissante : la détection d'alertes (spike) a besoin de
|
||||
# comparer chaque lecture à celle qui la précède immédiatement pour le même site.
|
||||
# `reading_id` en dernier départage : `uq_reading_source` autorise deux lignes au même
|
||||
# `site_id`+`timestamp` quand la `source` diffère (même piège que `latest_for_site`), sans
|
||||
# quoi l'ordre entre elles ne serait pas garanti d'un appel à l'autre.
|
||||
requete = (
|
||||
select(Reading)
|
||||
.where(Reading.timestamp >= since)
|
||||
.order_by(Reading.site_id, Reading.timestamp, Reading.reading_id)
|
||||
)
|
||||
if site_id is not None:
|
||||
requete = requete.where(Reading.site_id == site_id)
|
||||
return (await self._session.scalars(requete)).all()
|
||||
|
||||
async def list_history(
|
||||
self,
|
||||
*,
|
||||
start: datetime,
|
||||
end: datetime,
|
||||
site_id: str | None = None,
|
||||
limit: int,
|
||||
offset: int,
|
||||
) -> Sequence[Reading]:
|
||||
requete = (
|
||||
select(Reading)
|
||||
.where(Reading.timestamp >= start, Reading.timestamp < end)
|
||||
.order_by(Reading.timestamp.desc(), Reading.reading_id.desc())
|
||||
.limit(limit)
|
||||
.offset(offset)
|
||||
)
|
||||
if site_id is not None:
|
||||
requete = requete.where(Reading.site_id == site_id)
|
||||
return (await self._session.scalars(requete)).all()
|
||||
@@ -1,51 +0,0 @@
|
||||
from collections.abc import Sequence
|
||||
from dataclasses import asdict, dataclass
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.dialects.postgresql import insert
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.energy import Recommendation
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class NouvelleRecommandation:
|
||||
alert_id: int
|
||||
action: str
|
||||
explanation: str
|
||||
rule_reference: str
|
||||
|
||||
|
||||
TAILLE_DE_LOT = 1000
|
||||
|
||||
|
||||
class RecommendationRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def list_all(self) -> Sequence[Recommendation]:
|
||||
requete = select(Recommendation).order_by(Recommendation.recommendation_id)
|
||||
return (await self._session.scalars(requete)).all()
|
||||
|
||||
async def get_by_id(self, recommendation_id: int) -> Recommendation | None:
|
||||
requete = select(Recommendation).where(
|
||||
Recommendation.recommendation_id == recommendation_id
|
||||
)
|
||||
recommendation: Recommendation | None = await self._session.scalar(requete)
|
||||
return recommendation
|
||||
|
||||
# Pourquoi : l'idempotence est déléguée à `uq_recommendation_alert_rule` plutôt qu'à une
|
||||
# lecture préalable, qui laisserait une fenêtre entre le contrôle et l'insertion.
|
||||
async def create_missing(self, nouvelles: Sequence[NouvelleRecommandation]) -> int:
|
||||
creees = 0
|
||||
# Piège : asyncpg plafonne une requête à 32 767 paramètres, soit 8 191 lignes de quatre
|
||||
# colonnes. Au-delà de ce seuil un `INSERT` d'un seul tenant échouerait.
|
||||
for debut in range(0, len(nouvelles), TAILLE_DE_LOT):
|
||||
requete = (
|
||||
insert(Recommendation)
|
||||
.values([asdict(nouvelle) for nouvelle in nouvelles[debut : debut + TAILLE_DE_LOT]])
|
||||
.on_conflict_do_nothing(constraint="uq_recommendation_alert_rule")
|
||||
.returning(Recommendation.recommendation_id)
|
||||
)
|
||||
creees += len((await self._session.scalars(requete)).all())
|
||||
return creees
|
||||
@@ -1,106 +0,0 @@
|
||||
# Piège : `claim_for_rotation()` est une seule instruction. Un SELECT puis un UPDATE
|
||||
# laisseraient une fenêtre où deux onglets réussissent la même rotation. Zéro ligne retournée
|
||||
# signifie donc, sans ambiguïté, que le jeton était déjà tourné, révoqué, expiré ou inconnu, et
|
||||
# c'est `inspect()` qui départage ensuite ces cas.
|
||||
|
||||
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.refresh_token import RefreshToken, RevocationReason
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ClaimedToken:
|
||||
id: UUID
|
||||
family_id: UUID
|
||||
user_id: UUID
|
||||
expires_at: datetime
|
||||
|
||||
|
||||
class RefreshTokenRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def create(
|
||||
self,
|
||||
*,
|
||||
user_id: UUID,
|
||||
family_id: UUID,
|
||||
token_hash: bytes,
|
||||
expires_at: datetime,
|
||||
client_ip: str | None,
|
||||
user_agent: str | None,
|
||||
) -> RefreshToken:
|
||||
jeton = RefreshToken(
|
||||
user_id=user_id,
|
||||
family_id=family_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 claim_for_rotation(self, token_hash: bytes) -> ClaimedToken | None:
|
||||
requete = (
|
||||
update(RefreshToken)
|
||||
.where(
|
||||
RefreshToken.token_hash == token_hash,
|
||||
RefreshToken.rotated_at.is_(None),
|
||||
RefreshToken.revoked_at.is_(None),
|
||||
RefreshToken.expires_at > func.clock_timestamp(),
|
||||
)
|
||||
.values(
|
||||
rotated_at=func.clock_timestamp(),
|
||||
revoked_at=func.clock_timestamp(),
|
||||
revoked_reason=RevocationReason.ROTATION.value,
|
||||
)
|
||||
.returning(
|
||||
RefreshToken.id,
|
||||
RefreshToken.family_id,
|
||||
RefreshToken.user_id,
|
||||
RefreshToken.expires_at,
|
||||
)
|
||||
)
|
||||
ligne = (await self._session.execute(requete)).one_or_none()
|
||||
if ligne is None:
|
||||
return None
|
||||
return ClaimedToken(
|
||||
id=ligne.id,
|
||||
family_id=ligne.family_id,
|
||||
user_id=ligne.user_id,
|
||||
expires_at=ligne.expires_at,
|
||||
)
|
||||
|
||||
async def inspect(self, token_hash: bytes) -> RefreshToken | None:
|
||||
requete = select(RefreshToken).where(RefreshToken.token_hash == token_hash)
|
||||
return (await self._session.execute(requete)).scalar_one_or_none()
|
||||
|
||||
async def link_replacement(self, ancien_id: UUID, nouveau_id: UUID) -> None:
|
||||
await self._session.execute(
|
||||
update(RefreshToken).where(RefreshToken.id == ancien_id).values(replaced_by=nouveau_id)
|
||||
)
|
||||
|
||||
async def revoke_family(self, family_id: UUID, reason: RevocationReason) -> int:
|
||||
resultat = await self._session.execute(
|
||||
update(RefreshToken)
|
||||
.where(RefreshToken.family_id == family_id, RefreshToken.revoked_at.is_(None))
|
||||
.values(revoked_at=func.clock_timestamp(), revoked_reason=reason.value)
|
||||
.returning(RefreshToken.id)
|
||||
)
|
||||
return len(resultat.all())
|
||||
|
||||
async def revoke_all_for_user(self, user_id: UUID, reason: RevocationReason) -> int:
|
||||
resultat = await self._session.execute(
|
||||
update(RefreshToken)
|
||||
.where(RefreshToken.user_id == user_id, RefreshToken.revoked_at.is_(None))
|
||||
.values(revoked_at=func.clock_timestamp(), revoked_reason=reason.value)
|
||||
.returning(RefreshToken.id)
|
||||
)
|
||||
return len(resultat.all())
|
||||
@@ -1,20 +0,0 @@
|
||||
from collections.abc import Sequence
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.energy import Site
|
||||
|
||||
|
||||
class SiteRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def list_all(self) -> Sequence[Site]:
|
||||
requete = select(Site).order_by(Site.site_id)
|
||||
return (await self._session.scalars(requete)).all()
|
||||
|
||||
async def get_by_id(self, site_id: str) -> Site | None:
|
||||
requete = select(Site).where(Site.site_id == site_id)
|
||||
site: Site | None = await self._session.scalar(requete)
|
||||
return site
|
||||
@@ -1,97 +0,0 @@
|
||||
# Piège : `set_role()` et `set_active()` avancent `credentials_changed_at`. C'est ce qui rend
|
||||
# un changement de rôle ou une désactivation effectifs à la requête suivante au lieu d'attendre
|
||||
# l'expiration du jeton d'accès. Une mise à jour qui l'oublierait laisserait 15 minutes de
|
||||
# privilèges périmés.
|
||||
|
||||
from collections.abc import Sequence
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy import func, select, update
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core.roles import AccountKind, Role
|
||||
from app.models.user import AppUser
|
||||
|
||||
|
||||
class UserRepository:
|
||||
def __init__(self, session: AsyncSession) -> None:
|
||||
self._session = session
|
||||
|
||||
async def get_by_email(self, email: str) -> AppUser | None:
|
||||
requete = select(AppUser).where(AppUser.email == email.strip().lower())
|
||||
return (await self._session.execute(requete)).scalar_one_or_none()
|
||||
|
||||
async def get_by_id(self, user_id: UUID) -> AppUser | None:
|
||||
return await self._session.get(AppUser, user_id)
|
||||
|
||||
async def list_all(self) -> Sequence[AppUser]:
|
||||
requete = select(AppUser).order_by(AppUser.email)
|
||||
return (await self._session.execute(requete)).scalars().all()
|
||||
|
||||
async def count_active_admins(self) -> int:
|
||||
requete = (
|
||||
select(func.count())
|
||||
.select_from(AppUser)
|
||||
.where(AppUser.role == Role.ADMIN.value, AppUser.is_active.is_(True))
|
||||
)
|
||||
return (await self._session.execute(requete)).scalar_one()
|
||||
|
||||
async def create(
|
||||
self,
|
||||
*,
|
||||
email: str,
|
||||
password_hash: str,
|
||||
role: Role,
|
||||
kind: AccountKind = AccountKind.HUMAIN,
|
||||
full_name: str | None = None,
|
||||
must_change_password: bool = False,
|
||||
) -> AppUser:
|
||||
compte = AppUser(
|
||||
email=email.strip().lower(),
|
||||
password_hash=password_hash,
|
||||
role=role.value,
|
||||
kind=kind.value,
|
||||
full_name=full_name,
|
||||
must_change_password=must_change_password,
|
||||
)
|
||||
self._session.add(compte)
|
||||
await self._session.flush()
|
||||
return compte
|
||||
|
||||
async def update_password(
|
||||
self, user_id: UUID, password_hash: str, *, must_change_password: bool
|
||||
) -> None:
|
||||
await self._session.execute(
|
||||
update(AppUser)
|
||||
.where(AppUser.id == user_id)
|
||||
.values(
|
||||
password_hash=password_hash,
|
||||
must_change_password=must_change_password,
|
||||
credentials_changed_at=func.clock_timestamp(),
|
||||
)
|
||||
)
|
||||
|
||||
async def rehash_password(self, user_id: UUID, password_hash: str) -> None:
|
||||
# Un simple recalcul avec des paramètres Argon2 plus récents ne périme aucun jeton.
|
||||
await self._session.execute(
|
||||
update(AppUser).where(AppUser.id == user_id).values(password_hash=password_hash)
|
||||
)
|
||||
|
||||
async def touch_last_login(self, user_id: UUID) -> None:
|
||||
await self._session.execute(
|
||||
update(AppUser).where(AppUser.id == user_id).values(last_login_at=func.now())
|
||||
)
|
||||
|
||||
async def set_role(self, user_id: UUID, role: Role) -> None:
|
||||
await self._session.execute(
|
||||
update(AppUser)
|
||||
.where(AppUser.id == user_id)
|
||||
.values(role=role.value, credentials_changed_at=func.clock_timestamp())
|
||||
)
|
||||
|
||||
async def set_active(self, user_id: UUID, *, is_active: bool) -> None:
|
||||
await self._session.execute(
|
||||
update(AppUser)
|
||||
.where(AppUser.id == user_id)
|
||||
.values(is_active=is_active, credentials_changed_at=func.clock_timestamp())
|
||||
)
|
||||
@@ -1,34 +0,0 @@
|
||||
from datetime import datetime
|
||||
from enum import StrEnum
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
|
||||
class AlertType(StrEnum):
|
||||
SPIKE = "spike"
|
||||
THRESHOLD = "threshold"
|
||||
ANOMALY = "anomaly"
|
||||
OUTAGE = "outage"
|
||||
SENSOR = "sensor"
|
||||
|
||||
|
||||
class AlertSeverity(StrEnum):
|
||||
LOW = "low"
|
||||
MEDIUM = "medium"
|
||||
HIGH = "high"
|
||||
CRITICAL = "critical"
|
||||
|
||||
|
||||
class AlertResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
alert_id: int
|
||||
site_id: str
|
||||
timestamp: datetime
|
||||
type: AlertType
|
||||
severity: AlertSeverity
|
||||
message: str
|
||||
value: float | None
|
||||
threshold: float | None
|
||||
metric: str | None
|
||||
prediction_id: int | None
|
||||
@@ -1,95 +0,0 @@
|
||||
# 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 app.core.principal import Principal
|
||||
from app.core.roles import AccountKind, Role
|
||||
|
||||
PASSWORD_MIN_LENGTH = 8
|
||||
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
|
||||
password: str = Field(min_length=1, max_length=PASSWORD_MAX_LENGTH)
|
||||
|
||||
|
||||
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)
|
||||
|
||||
id: UUID
|
||||
email: str
|
||||
role: Role
|
||||
kind: AccountKind
|
||||
must_change_password: bool
|
||||
|
||||
@classmethod
|
||||
def from_principal(cls, principal: Principal) -> Self:
|
||||
return cls.model_validate(principal)
|
||||
|
||||
|
||||
class ResetTokenValidationResponse(BaseModel):
|
||||
valid: bool
|
||||
|
||||
|
||||
class TokenResponse(BaseModel):
|
||||
access_token: str
|
||||
token_type: Literal["bearer"] = "bearer" # noqa: S105
|
||||
expires_in: int
|
||||
principal: PrincipalResponse
|
||||
@@ -1,31 +0,0 @@
|
||||
from datetime import datetime
|
||||
from enum import StrEnum
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
|
||||
class DriftStatus(StrEnum):
|
||||
STABLE = "stable"
|
||||
DERIVE = "derive"
|
||||
INDETERMINE = "indetermine"
|
||||
|
||||
|
||||
class DriftReportResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
site_id: str | None
|
||||
computed_at: datetime
|
||||
window_start: datetime
|
||||
window_end: datetime
|
||||
reference_start: datetime | None
|
||||
reference_end: datetime | None
|
||||
n_observations: int
|
||||
mae: float | None
|
||||
mape: float | None
|
||||
bias: float | None
|
||||
reference_mae: float | None
|
||||
coverage_ratio: float | None
|
||||
insufficient_data_ratio: float | None
|
||||
model_references: list[str]
|
||||
status: DriftStatus
|
||||
reason: str | None
|
||||
@@ -1,23 +0,0 @@
|
||||
# Piège : ces modèles ne décrivent rien, ils publient. Ce sont eux que Swagger montre, donc ils
|
||||
# doivent suivre `validation_error_handler()` et `unhandled_error_handler()` d'`app/api/errors.py`
|
||||
# à la lettre. Un champ renommé là-bas sans l'être ici rend la documentation fausse en silence.
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class ErrorResponse(BaseModel):
|
||||
detail: str
|
||||
|
||||
|
||||
class FieldError(BaseModel):
|
||||
champ: str
|
||||
type: str
|
||||
|
||||
|
||||
class ValidationErrorResponse(BaseModel):
|
||||
detail: list[FieldError]
|
||||
|
||||
|
||||
class InternalErrorResponse(BaseModel):
|
||||
detail: str
|
||||
correlation: str
|
||||
@@ -10,10 +10,7 @@ class LivenessStatus(BaseModel):
|
||||
environment: str
|
||||
|
||||
|
||||
# Contrainte : la sonde ne publie pas la version de TimescaleDB. Une version exacte de
|
||||
# composant, servie sans authentification, est de la reconnaissance gratuite pour qui
|
||||
# cherche une CVE. Elle part dans le journal, où elle sert au diagnostic.
|
||||
class ReadinessStatus(BaseModel):
|
||||
status: Literal["ready"]
|
||||
database: Literal["reachable"]
|
||||
timescaledb: Literal["loaded"]
|
||||
timescaledb: str
|
||||
|
||||
@@ -1,43 +0,0 @@
|
||||
from datetime import datetime
|
||||
from enum import StrEnum
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
|
||||
class PredictionTargetMetric(StrEnum):
|
||||
CONSUMPTION_KWH = "consumption_kwh"
|
||||
CONSUMPTION_KW = "consumption_kw"
|
||||
|
||||
|
||||
class PredictionStatus(StrEnum):
|
||||
AVAILABLE = "available"
|
||||
INSUFFICIENT_DATA = "insufficient_data"
|
||||
ERROR = "error"
|
||||
|
||||
|
||||
class SitePredictionResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
target_at: datetime
|
||||
target_metric: PredictionTargetMetric
|
||||
period_minutes: int | None
|
||||
predicted_value: float | None
|
||||
status: PredictionStatus
|
||||
failure_reason: str | None
|
||||
model_reference: str
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class SitePredictionSummaryResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
site_id: str
|
||||
site_name: str
|
||||
prediction: SitePredictionResponse | None
|
||||
|
||||
|
||||
class PredictionSummaryResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
timestamp: datetime
|
||||
sites: list[SitePredictionSummaryResponse]
|
||||
@@ -1,45 +0,0 @@
|
||||
from datetime import datetime
|
||||
from decimal import Decimal
|
||||
from enum import StrEnum
|
||||
from typing import Any
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
|
||||
class ReadingSource(StrEnum):
|
||||
CSV = "csv"
|
||||
API_CURRENT = "api_current"
|
||||
API_HISTORY = "api_history"
|
||||
|
||||
|
||||
class ReadingDataQuality(StrEnum):
|
||||
GOOD = "good"
|
||||
PARTIAL = "partial"
|
||||
DEGRADED = "degraded"
|
||||
CRITICAL = "critical"
|
||||
|
||||
|
||||
class ReadingResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
reading_id: int
|
||||
site_id: str
|
||||
timestamp: datetime
|
||||
source: ReadingSource
|
||||
consumption_kw: float | None
|
||||
consumption_kwh: float | None
|
||||
# Piège : `Decimal` (miroir de `Numeric(14, 2)` en base, pour ne pas arrondir un montant)
|
||||
# sérialise en chaîne dans le JSON, pas en nombre — un consommateur qui ferait un `parseFloat`
|
||||
# naïf perdrait la précision que ce choix visait à garder.
|
||||
consumption_euros: Decimal | None
|
||||
voltage_v: float | None
|
||||
current_a: float | None
|
||||
power_factor: float | None
|
||||
temperature_celsius: float | None
|
||||
humidity_percent: float | None
|
||||
solar_irradiance_wm2: float | None
|
||||
is_working_hours: bool | None
|
||||
data_quality: ReadingDataQuality | None
|
||||
null_reasons: list[str] | None
|
||||
imputed_values: dict[str, Any] | None
|
||||
imputation_method: str | None
|
||||
@@ -1,20 +0,0 @@
|
||||
from datetime import datetime
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
|
||||
class RecommendationResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
recommendation_id: int
|
||||
alert_id: int
|
||||
action: str
|
||||
explanation: str
|
||||
rule_reference: str
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class RecommendationGenerationResponse(BaseModel):
|
||||
alerts_examined: int
|
||||
recommendations_created: int
|
||||
already_present: int
|
||||
@@ -1,42 +0,0 @@
|
||||
from datetime import datetime
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
|
||||
|
||||
class SensorDiagnosticResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
status: Literal["ok", "failing"]
|
||||
since: datetime | None = Field(
|
||||
description=(
|
||||
"Horodatage de la dernière lecture reçue pour ce site. Ce n'est pas le début de la "
|
||||
"panne : l'historique ne permet pas de le dater sans requête supplémentaire."
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class SiteSensorsResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
consumption: SensorDiagnosticResponse
|
||||
electrical: SensorDiagnosticResponse
|
||||
temperature: SensorDiagnosticResponse
|
||||
humidity: SensorDiagnosticResponse
|
||||
network: SensorDiagnosticResponse
|
||||
|
||||
|
||||
class SiteSensorStatusResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
site_id: str
|
||||
site_name: str
|
||||
sensors: SiteSensorsResponse
|
||||
overall: Literal["ok", "degraded", "critical"]
|
||||
|
||||
|
||||
class SensorStatusResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
timestamp: datetime
|
||||
sites: list[SiteSensorStatusResponse]
|
||||
@@ -1,32 +0,0 @@
|
||||
from datetime import datetime
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
|
||||
class SiteResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
site_id: str
|
||||
site_name: str
|
||||
site_type: str
|
||||
location: str | None
|
||||
capacity_kw: float | None
|
||||
status: str | None
|
||||
|
||||
|
||||
class SiteCurrentResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
timestamp: datetime | None
|
||||
site_id: str
|
||||
site_type: str
|
||||
consumption_kw: float | None
|
||||
consumption_kwh: float | None
|
||||
voltage_v: float | None
|
||||
current_a: float | None
|
||||
power_factor: float | None
|
||||
temperature_celsius: float | None
|
||||
humidity_percent: float | None
|
||||
null_reasons: list[str]
|
||||
data_quality: Literal["good", "partial", "degraded", "critical"]
|
||||
@@ -1,26 +0,0 @@
|
||||
from datetime import datetime
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
|
||||
class SiteSummaryResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
site_id: str
|
||||
site_name: str
|
||||
current_consumption_kw: float | None
|
||||
capacity_kw: float
|
||||
load_percent: float | None
|
||||
data_quality: Literal["good", "partial", "degraded", "critical"]
|
||||
|
||||
|
||||
class StatsSummaryResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
timestamp: datetime
|
||||
total_sites: int
|
||||
total_consumption_kw: float
|
||||
total_capacity_kw: float
|
||||
average_load_percent: float
|
||||
sites: list[SiteSummaryResponse]
|
||||
@@ -1,41 +0,0 @@
|
||||
# Contrainte : les schémas de lecture et d'écriture sont séparés. Un modèle unique laisserait
|
||||
# passer `role` ou `is_active` depuis un corps de requête, et renverrait `password_hash` en
|
||||
# réponse. C'est l'attribution de masse, API3 du top 10 API.
|
||||
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, EmailStr, Field
|
||||
|
||||
from app.core.roles import AccountKind, Role
|
||||
|
||||
|
||||
class UserCreateRequest(BaseModel):
|
||||
email: EmailStr
|
||||
role: Role
|
||||
full_name: str | None = Field(default=None, max_length=200)
|
||||
|
||||
|
||||
class UserUpdateRequest(BaseModel):
|
||||
role: Role | None = None
|
||||
is_active: bool | None = None
|
||||
|
||||
|
||||
class UserResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
id: UUID
|
||||
email: str
|
||||
role: Role
|
||||
kind: AccountKind
|
||||
is_active: bool
|
||||
must_change_password: bool
|
||||
full_name: str | None
|
||||
last_login_at: datetime | None
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class TemporaryPasswordResponse(BaseModel):
|
||||
# Affiché une seule fois : l'empreinte seule est conservée côté serveur.
|
||||
user: UserResponse
|
||||
temporary_password: str
|
||||
@@ -1,323 +0,0 @@
|
||||
from collections.abc import Sequence
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
from app.models.energy import Alert, Prediction, Reading, Site
|
||||
from app.repositories.alert import AlertRepository
|
||||
from app.repositories.prediction import PredictionRepository
|
||||
from app.repositories.reading import ReadingRepository
|
||||
from app.repositories.site import SiteRepository
|
||||
|
||||
# Fenêtre de lectures/prédictions analysée à chaque exécution : assez large pour couvrir une paire
|
||||
# de lectures consécutives (spike) et une coupure prolongée (outage), sans réanalyser tout
|
||||
# l'historique à chaque lancement manuel du script de détection.
|
||||
LOOKBACK = timedelta(hours=48)
|
||||
|
||||
# Cadence nominale d'une lecture : le CSV historique comme l'API Mock livrent un pas horaire.
|
||||
EXPECTED_INTERVAL = timedelta(hours=1)
|
||||
# Au-delà de trois pas manqués, on parle de coupure plutôt que d'un simple retard d'ingestion.
|
||||
OUTAGE_THRESHOLD = EXPECTED_INTERVAL * 3
|
||||
|
||||
# +/-50% entre deux lectures consécutives du même site.
|
||||
SPIKE_RELATIVE_THRESHOLD = 0.5
|
||||
# 30% d'écart entre la consommation réelle et la prévision du même site/instant.
|
||||
ANOMALY_RELATIVE_THRESHOLD = 0.3
|
||||
# Une prévision quasi nulle rend l'écart relatif ininterprétable ; on l'ignore plutôt.
|
||||
ANOMALY_MINIMUM_PREDICTED_VALUE = 1e-6
|
||||
|
||||
THRESHOLD_METRIC = "consumption_kw"
|
||||
ANOMALY_METRIC = "consumption_kwh"
|
||||
# `data_quality` -> sévérité du capteur défaillant. `good` est volontairement absent : il ne
|
||||
# déclenche jamais d'alerte.
|
||||
QUALITE_VERS_SEVERITE: dict[str, str] = {
|
||||
"partial": "low",
|
||||
"degraded": "medium",
|
||||
"critical": "critical",
|
||||
}
|
||||
|
||||
|
||||
class AlertService:
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
alerts: AlertRepository,
|
||||
readings: ReadingRepository,
|
||||
predictions: PredictionRepository,
|
||||
sites: SiteRepository,
|
||||
) -> None:
|
||||
self._alerts = alerts
|
||||
self._readings = readings
|
||||
self._predictions = predictions
|
||||
self._sites = sites
|
||||
|
||||
async def list_all(
|
||||
self, *, site_id: str | None = None, severity: str | None = None
|
||||
) -> Sequence[Alert]:
|
||||
return await self._alerts.list_all(site_id=site_id, severity=severity)
|
||||
|
||||
async def detect(
|
||||
self, *, now: datetime | None = None, site_id: str | None = None
|
||||
) -> Sequence[Alert]:
|
||||
"""Compare les lectures/prévisions récentes aux cinq règles internes et enregistre les
|
||||
alertes déclenchées (`source='enervision'`). Idempotent grâce à `source_alert_id` :
|
||||
rejouer sur une fenêtre déjà analysée ne recrée pas les mêmes lignes."""
|
||||
instant = now or datetime.now(UTC)
|
||||
depuis = instant - LOOKBACK
|
||||
|
||||
sites = await self._sites.list_all()
|
||||
if site_id is not None:
|
||||
sites = [site for site in sites if site.site_id == site_id]
|
||||
sites_par_id = {site.site_id: site for site in sites}
|
||||
if not sites_par_id:
|
||||
return []
|
||||
|
||||
lectures = [
|
||||
lecture
|
||||
for lecture in await self._readings.list_since(since=depuis, site_id=site_id)
|
||||
if lecture.site_id in sites_par_id
|
||||
]
|
||||
predictions = [
|
||||
prediction
|
||||
for prediction in await self._predictions.list_since(since=depuis, site_id=site_id)
|
||||
if prediction.site_id in sites_par_id
|
||||
]
|
||||
dernieres_lectures = {
|
||||
lecture.site_id: lecture
|
||||
for lecture in await self._readings.latest_by_site()
|
||||
if lecture.site_id in sites_par_id
|
||||
}
|
||||
|
||||
candidates = [
|
||||
*_detect_threshold(lectures, sites_par_id),
|
||||
*_detect_spike(lectures),
|
||||
*_detect_anomaly(lectures, predictions),
|
||||
*_detect_outage(sites, dernieres_lectures, instant),
|
||||
*_detect_sensor(lectures),
|
||||
]
|
||||
if not candidates:
|
||||
return []
|
||||
return await self._alerts.create_many(candidates)
|
||||
|
||||
|
||||
def _severity_from_ratio(ratio: float) -> str:
|
||||
if ratio >= 2.0:
|
||||
return "critical"
|
||||
if ratio >= 1.5:
|
||||
return "high"
|
||||
if ratio >= 1.2:
|
||||
return "medium"
|
||||
return "low"
|
||||
|
||||
|
||||
def _detect_threshold(lectures: Sequence[Reading], sites_par_id: dict[str, Site]) -> list[Alert]:
|
||||
# Seuil fixe = la capacité déclarée du site : dépasser `capacity_kw` est un dépassement
|
||||
# matériel, pas une simple variation, et évite un seuil arbitraire non fourni par le domaine.
|
||||
alertes = []
|
||||
for lecture in lectures:
|
||||
site = sites_par_id[lecture.site_id]
|
||||
valeur = lecture.consumption_kw
|
||||
if site.capacity_kw is None or site.capacity_kw <= 0 or valeur is None:
|
||||
continue
|
||||
if valeur <= site.capacity_kw:
|
||||
continue
|
||||
alertes.append(
|
||||
Alert(
|
||||
source_alert_id=f"threshold:{THRESHOLD_METRIC}:{lecture.timestamp.isoformat()}",
|
||||
site_id=lecture.site_id,
|
||||
source="enervision",
|
||||
timestamp=lecture.timestamp,
|
||||
type="threshold",
|
||||
severity=_severity_from_ratio(valeur / site.capacity_kw),
|
||||
message=(
|
||||
f"Puissance appelée {valeur:.1f} kW au-dessus de la capacité du site "
|
||||
f"({site.capacity_kw:.1f} kW)"
|
||||
),
|
||||
value=valeur,
|
||||
threshold=site.capacity_kw,
|
||||
metric=THRESHOLD_METRIC,
|
||||
prediction_id=None,
|
||||
raw_data={},
|
||||
)
|
||||
)
|
||||
return alertes
|
||||
|
||||
|
||||
def _detect_spike(lectures: Sequence[Reading]) -> list[Alert]:
|
||||
# `lectures` est triée par site, heure puis `reading_id` (cf. `ReadingRepository.list_since`) :
|
||||
# deux lignes consécutives du même site sont donc deux mesures consécutives dans le temps,
|
||||
# sauf lorsqu'elles partagent le même horodatage (deux `source` différentes pour le même
|
||||
# instant, permises par `uq_reading_source`) : ce n'est alors pas une variation réelle, on
|
||||
# l'ignore plutôt que de générer une fausse alerte figée par son `source_alert_id`.
|
||||
alertes = []
|
||||
precedente: Reading | None = None
|
||||
for lecture in lectures:
|
||||
if (
|
||||
precedente is None
|
||||
or precedente.site_id != lecture.site_id
|
||||
or precedente.timestamp == lecture.timestamp
|
||||
):
|
||||
precedente = lecture
|
||||
continue
|
||||
avant, apres = precedente.consumption_kw, lecture.consumption_kw
|
||||
precedente = lecture
|
||||
if avant is None or apres is None:
|
||||
continue
|
||||
if avant == 0:
|
||||
# Une variation relative n'a pas de sens depuis zéro, mais un redémarrage direct à
|
||||
# une consommation positive reste le signal le plus alarmant du lot : `critical`
|
||||
# plutôt qu'un ratio indéfini.
|
||||
if apres > 0:
|
||||
alertes.append(_spike_alert(lecture, avant, apres, severity="critical"))
|
||||
continue
|
||||
variation = abs(apres - avant) / abs(avant)
|
||||
if variation < SPIKE_RELATIVE_THRESHOLD:
|
||||
continue
|
||||
alertes.append(
|
||||
_spike_alert(
|
||||
lecture,
|
||||
avant,
|
||||
apres,
|
||||
severity=_severity_from_ratio(variation / SPIKE_RELATIVE_THRESHOLD),
|
||||
)
|
||||
)
|
||||
return alertes
|
||||
|
||||
|
||||
def _spike_alert(lecture: Reading, avant: float, apres: float, *, severity: str) -> Alert:
|
||||
return Alert(
|
||||
source_alert_id=f"spike:{THRESHOLD_METRIC}:{lecture.timestamp.isoformat()}",
|
||||
site_id=lecture.site_id,
|
||||
source="enervision",
|
||||
timestamp=lecture.timestamp,
|
||||
type="spike",
|
||||
severity=severity,
|
||||
message=(
|
||||
f"Variation brutale entre deux lectures consécutives ({avant:.1f} kW -> {apres:.1f} kW)"
|
||||
),
|
||||
value=apres,
|
||||
threshold=avant,
|
||||
metric=THRESHOLD_METRIC,
|
||||
prediction_id=None,
|
||||
raw_data={},
|
||||
)
|
||||
|
||||
|
||||
def _detect_anomaly(lectures: Sequence[Reading], predictions: Sequence[Prediction]) -> list[Alert]:
|
||||
# Alignement strict (site_id, target_at == timestamp) : `enervision_ml.score` produit une
|
||||
# cible à l'heure pile suivant la dernière lecture, sur la même grille horaire que `reading`.
|
||||
predictions_par_cle = {
|
||||
(prediction.site_id, prediction.target_at): prediction
|
||||
for prediction in predictions
|
||||
if prediction.target_metric == ANOMALY_METRIC
|
||||
}
|
||||
alertes = []
|
||||
for lecture in lectures:
|
||||
prediction = predictions_par_cle.get((lecture.site_id, lecture.timestamp))
|
||||
reel = lecture.consumption_kwh
|
||||
if prediction is None or reel is None or prediction.predicted_value is None:
|
||||
continue
|
||||
predite = prediction.predicted_value
|
||||
if abs(predite) < ANOMALY_MINIMUM_PREDICTED_VALUE:
|
||||
continue
|
||||
ecart = abs(reel - predite) / abs(predite)
|
||||
if ecart < ANOMALY_RELATIVE_THRESHOLD:
|
||||
continue
|
||||
alertes.append(
|
||||
Alert(
|
||||
source_alert_id=f"anomaly:{ANOMALY_METRIC}:{lecture.timestamp.isoformat()}",
|
||||
site_id=lecture.site_id,
|
||||
source="enervision",
|
||||
timestamp=lecture.timestamp,
|
||||
type="anomaly",
|
||||
severity=_severity_from_ratio(ecart / ANOMALY_RELATIVE_THRESHOLD),
|
||||
message=(
|
||||
f"Écart de {ecart * 100:.0f}% entre la consommation mesurée ({reel:.1f} kWh) "
|
||||
f"et la prévision ({predite:.1f} kWh)"
|
||||
),
|
||||
value=reel,
|
||||
threshold=predite,
|
||||
metric=ANOMALY_METRIC,
|
||||
prediction_id=prediction.prediction_id,
|
||||
raw_data={},
|
||||
)
|
||||
)
|
||||
return alertes
|
||||
|
||||
|
||||
def _detect_outage(
|
||||
sites: Sequence[Site], dernieres_lectures: dict[str, Reading], now: datetime
|
||||
) -> list[Alert]:
|
||||
alertes = []
|
||||
for site in sites:
|
||||
derniere = dernieres_lectures.get(site.site_id)
|
||||
if derniere is None:
|
||||
alertes.append(
|
||||
_outage_alert(
|
||||
site.site_id,
|
||||
now,
|
||||
reference=None,
|
||||
message="Aucune lecture n'a jamais été reçue pour ce site",
|
||||
severity="critical",
|
||||
)
|
||||
)
|
||||
continue
|
||||
absence = now - derniere.timestamp
|
||||
if absence < OUTAGE_THRESHOLD:
|
||||
continue
|
||||
alertes.append(
|
||||
_outage_alert(
|
||||
site.site_id,
|
||||
now,
|
||||
reference=derniere.timestamp,
|
||||
message=(
|
||||
f"Aucune lecture depuis {absence} (dernière lecture : "
|
||||
f"{derniere.timestamp.isoformat()})"
|
||||
),
|
||||
severity=_severity_from_ratio(absence / OUTAGE_THRESHOLD),
|
||||
)
|
||||
)
|
||||
return alertes
|
||||
|
||||
|
||||
def _outage_alert(
|
||||
site_id: str, now: datetime, *, reference: datetime | None, message: str, severity: str
|
||||
) -> Alert:
|
||||
return Alert(
|
||||
source_alert_id=f"outage:{reference.isoformat() if reference is not None else 'jamais'}",
|
||||
site_id=site_id,
|
||||
source="enervision",
|
||||
timestamp=now,
|
||||
type="outage",
|
||||
severity=severity,
|
||||
message=message,
|
||||
value=None,
|
||||
threshold=None,
|
||||
metric=None,
|
||||
prediction_id=None,
|
||||
raw_data={},
|
||||
)
|
||||
|
||||
|
||||
def _detect_sensor(lectures: Sequence[Reading]) -> list[Alert]:
|
||||
alertes = []
|
||||
for lecture in lectures:
|
||||
severite = QUALITE_VERS_SEVERITE.get(lecture.data_quality or "")
|
||||
if severite is None:
|
||||
continue
|
||||
raisons = ", ".join(lecture.null_reasons or []) or "raison non précisée"
|
||||
alertes.append(
|
||||
Alert(
|
||||
source_alert_id=f"sensor:{lecture.timestamp.isoformat()}",
|
||||
site_id=lecture.site_id,
|
||||
source="enervision",
|
||||
timestamp=lecture.timestamp,
|
||||
type="sensor",
|
||||
severity=severite,
|
||||
message=f"Qualité de mesure {lecture.data_quality} ({raisons})",
|
||||
value=None,
|
||||
threshold=None,
|
||||
metric=None,
|
||||
prediction_id=None,
|
||||
raw_data={},
|
||||
)
|
||||
)
|
||||
return alertes
|
||||
@@ -1,464 +0,0 @@
|
||||
# Piège : les compteurs de limitation sont lus AVANT le hachage Argon2. Dans l'autre ordre,
|
||||
# chaque requête rejetée coûterait quand même 17 ms de processeur et 19 Mio de mémoire, et la
|
||||
# protection deviendrait l'amplificateur de déni de service qu'elle est censée empêcher.
|
||||
# Piège : quand l'email est inconnu, `verify_dummy()` consomme le même temps qu'une
|
||||
# vérification réelle. Sans lui, l'écart de temps de réponse est un oracle d'existence.
|
||||
# Piège : la tentative échouée est validée en base AVANT que l'erreur ne soit levée.
|
||||
# `get_session()` ne valide pas de lui-même, donc la preuve disparaîtrait avec la transaction.
|
||||
# Piège : dans `refresh()`, un jeton expiré ne révoque PAS la famille, un jeton déjà tourné si.
|
||||
# La rotation ne protège de rien par elle-même : elle rend la réutilisation détectable, et
|
||||
# c'est la détection qui termine le vol.
|
||||
|
||||
from dataclasses import dataclass
|
||||
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 (
|
||||
TokenPolicy,
|
||||
encode_access_token,
|
||||
fingerprint_refresh,
|
||||
generate_refresh_secret,
|
||||
)
|
||||
from app.models.audit_log import AuditAction, AuditOutcome
|
||||
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: ...
|
||||
|
||||
|
||||
class AuthError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidCredentialsError(AuthError):
|
||||
pass
|
||||
|
||||
|
||||
class SessionRejectedError(AuthError):
|
||||
pass
|
||||
|
||||
|
||||
class RateLimitedError(AuthError):
|
||||
def __init__(self, retry_after: int) -> None:
|
||||
super().__init__("Trop de tentatives")
|
||||
self.retry_after = retry_after
|
||||
|
||||
|
||||
class InvalidOrExpiredResetTokenError(AuthError):
|
||||
pass
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class LoginPolicy:
|
||||
window_seconds: int
|
||||
max_failures_per_identifier_and_ip: int
|
||||
max_failures_per_ip: int
|
||||
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
|
||||
access_token: str
|
||||
expires_in: int
|
||||
refresh_secret: str
|
||||
|
||||
|
||||
class AuthService:
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
users: UserRepository,
|
||||
attempts: LoginAttemptRepository,
|
||||
refresh_tokens: RefreshTokenRepository,
|
||||
audit: AuditLogRepository,
|
||||
hasher: Argon2Hasher,
|
||||
transaction: Transaction,
|
||||
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
|
||||
self._refresh = refresh_tokens
|
||||
self._audit = audit
|
||||
self._hasher = hasher
|
||||
self._transaction = transaction
|
||||
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
|
||||
) -> AuthenticatedSession:
|
||||
await self._refuse_si_limite(email=email, client_ip=client_ip, user_agent=user_agent)
|
||||
|
||||
compte = await self._users.get_by_email(email)
|
||||
if compte is None:
|
||||
await self._hasher.verify_dummy()
|
||||
await self._echoue(email, client_ip, LoginOutcome.IDENTIFIANTS_INVALIDES)
|
||||
|
||||
if not await self._hasher.verify(compte.password_hash, password):
|
||||
await self._echoue(
|
||||
email, client_ip, LoginOutcome.IDENTIFIANTS_INVALIDES, user_id=compte.id
|
||||
)
|
||||
|
||||
if not compte.is_active or compte.kind != AccountKind.HUMAIN.value:
|
||||
await self._echoue(
|
||||
email, client_ip, LoginOutcome.COMPTE_INDISPONIBLE, user_id=compte.id
|
||||
)
|
||||
|
||||
if self._hasher.needs_rehash(compte.password_hash):
|
||||
await self._users.rehash_password(compte.id, await self._hasher.hash(password))
|
||||
|
||||
await self._users.touch_last_login(compte.id)
|
||||
await self._attempts.record(
|
||||
email=email, client_ip=client_ip, outcome=LoginOutcome.SUCCES, user_id=compte.id
|
||||
)
|
||||
secret = await self._ouvre_une_famille(
|
||||
user_id=compte.id, client_ip=client_ip, user_agent=user_agent
|
||||
)
|
||||
await self._transaction.commit()
|
||||
|
||||
return self._session(self._en_principal(compte), secret)
|
||||
|
||||
async def refresh(
|
||||
self, *, secret: str, client_ip: str | None, user_agent: str | None
|
||||
) -> AuthenticatedSession:
|
||||
empreinte = fingerprint_refresh(secret)
|
||||
revendique = await self._refresh.claim_for_rotation(empreinte)
|
||||
if revendique is None:
|
||||
await self._traite_rotation_refusee(empreinte, client_ip, user_agent)
|
||||
|
||||
compte = await self._users.get_by_id(revendique.user_id)
|
||||
if compte is None or not compte.is_active:
|
||||
await self._refresh.revoke_family(revendique.family_id, RevocationReason.ADMINISTRATION)
|
||||
await self._transaction.commit()
|
||||
raise SessionRejectedError("Session révoquée")
|
||||
|
||||
nouveau_secret = generate_refresh_secret()
|
||||
nouveau = await self._refresh.create(
|
||||
user_id=revendique.user_id,
|
||||
family_id=revendique.family_id,
|
||||
token_hash=fingerprint_refresh(nouveau_secret),
|
||||
expires_at=revendique.expires_at,
|
||||
client_ip=client_ip,
|
||||
user_agent=user_agent,
|
||||
)
|
||||
await self._refresh.link_replacement(revendique.id, nouveau.id)
|
||||
await self._transaction.commit()
|
||||
|
||||
return self._session(self._en_principal(compte), nouveau_secret)
|
||||
|
||||
async def logout(self, *, secret: str) -> None:
|
||||
ligne = await self._refresh.inspect(fingerprint_refresh(secret))
|
||||
if ligne is not None:
|
||||
await self._refresh.revoke_family(ligne.family_id, RevocationReason.DECONNEXION)
|
||||
await self._transaction.commit()
|
||||
|
||||
async def change_password(
|
||||
self,
|
||||
*,
|
||||
principal: Principal,
|
||||
current_password: str,
|
||||
new_password: str,
|
||||
client_ip: str | None,
|
||||
user_agent: str | None,
|
||||
) -> AuthenticatedSession:
|
||||
compte = await self._users.get_by_id(principal.id)
|
||||
if compte is None or not await self._hasher.verify(compte.password_hash, current_password):
|
||||
raise InvalidCredentialsError("Identifiants invalides")
|
||||
|
||||
await self._users.update_password(
|
||||
principal.id, await self._hasher.hash(new_password), must_change_password=False
|
||||
)
|
||||
# Toutes les sessions tombent, puis on en rouvre une : l'appareil courant reste
|
||||
# connecté et tous les autres sont déconnectés.
|
||||
revoquees = await self._refresh.revoke_all_for_user(
|
||||
principal.id, RevocationReason.CHANGEMENT_MOT_DE_PASSE
|
||||
)
|
||||
secret = await self._ouvre_une_famille(
|
||||
user_id=principal.id, client_ip=client_ip, user_agent=user_agent
|
||||
)
|
||||
await self._audit.record(
|
||||
action=AuditAction.COMPTE_MOT_DE_PASSE_CHANGE,
|
||||
actor=principal,
|
||||
target_type="app_user",
|
||||
target_id=str(principal.id),
|
||||
client_ip=client_ip,
|
||||
user_agent=user_agent,
|
||||
detail={"sessions_revoquees": revoquees},
|
||||
)
|
||||
await self._transaction.commit()
|
||||
|
||||
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
|
||||
)
|
||||
await self._audit.record(
|
||||
action=AuditAction.SESSIONS_REVOQUEES,
|
||||
actor=principal,
|
||||
detail={"sessions_revoquees": revoquees},
|
||||
)
|
||||
await self._transaction.commit()
|
||||
return revoquees
|
||||
|
||||
def _session(self, principal: Principal, refresh_secret: str) -> AuthenticatedSession:
|
||||
jeton = encode_access_token(
|
||||
self._token_policy,
|
||||
subject=principal.id,
|
||||
role=principal.role.value,
|
||||
kind=principal.kind.value,
|
||||
)
|
||||
return AuthenticatedSession(
|
||||
principal=principal,
|
||||
access_token=jeton,
|
||||
expires_in=int(self._token_policy.access_ttl.total_seconds()),
|
||||
refresh_secret=refresh_secret,
|
||||
)
|
||||
|
||||
def _en_principal(self, compte: object) -> Principal:
|
||||
return Principal(
|
||||
id=compte.id, # type: ignore[attr-defined]
|
||||
email=compte.email, # type: ignore[attr-defined]
|
||||
role=Role(compte.role), # type: ignore[attr-defined]
|
||||
kind=AccountKind(compte.kind), # type: ignore[attr-defined]
|
||||
must_change_password=compte.must_change_password, # type: ignore[attr-defined]
|
||||
)
|
||||
|
||||
async def _ouvre_une_famille(
|
||||
self, *, user_id: UUID, client_ip: str | None, user_agent: str | None
|
||||
) -> str:
|
||||
secret = generate_refresh_secret()
|
||||
await self._refresh.create(
|
||||
user_id=user_id,
|
||||
family_id=uuid4(),
|
||||
token_hash=fingerprint_refresh(secret),
|
||||
expires_at=datetime.now(UTC) + self._refresh_ttl,
|
||||
client_ip=client_ip,
|
||||
user_agent=user_agent,
|
||||
)
|
||||
return secret
|
||||
|
||||
async def _traite_rotation_refusee(
|
||||
self, empreinte: bytes, client_ip: str | None, user_agent: str | None
|
||||
) -> NoReturn:
|
||||
ligne = await self._refresh.inspect(empreinte)
|
||||
if ligne is None:
|
||||
raise SessionRejectedError("Session inconnue")
|
||||
|
||||
if ligne.expires_at <= datetime.now(UTC):
|
||||
raise SessionRejectedError("Session expirée")
|
||||
|
||||
# Présenter un jeton déjà tourné est une preuve de compromission, pas un accident : toute
|
||||
# la famille tombe, y compris la session encore vivante du voleur ou de la victime.
|
||||
revoquees = await self._refresh.revoke_family(
|
||||
ligne.family_id, RevocationReason.REUTILISATION
|
||||
)
|
||||
await self._audit.record(
|
||||
action=AuditAction.REFRESH_REUTILISE,
|
||||
outcome=AuditOutcome.ECHEC,
|
||||
target_type="refresh_token",
|
||||
target_id=str(ligne.family_id),
|
||||
client_ip=client_ip,
|
||||
user_agent=user_agent,
|
||||
detail={"famille": str(ligne.family_id), "sessions_revoquees": revoquees},
|
||||
)
|
||||
await self._transaction.commit()
|
||||
raise SessionRejectedError("Session révoquée")
|
||||
|
||||
async def _refuse_si_limite(
|
||||
self, *, email: str, client_ip: str | None, user_agent: str | None
|
||||
) -> None:
|
||||
politique = self._login_policy
|
||||
compteurs = await self._attempts.count_recent_failures(
|
||||
email=email, client_ip=client_ip, window_seconds=politique.window_seconds
|
||||
)
|
||||
|
||||
depasse = (
|
||||
compteurs.per_identifier_and_ip >= politique.max_failures_per_identifier_and_ip
|
||||
or compteurs.per_ip >= politique.max_failures_per_ip
|
||||
or compteurs.per_identifier >= politique.max_failures_per_identifier
|
||||
)
|
||||
if not depasse:
|
||||
return
|
||||
|
||||
await self._attempts.record(email=email, client_ip=client_ip, outcome=LoginOutcome.LIMITE)
|
||||
# Un blocage déclenché par l'identifiant seul signe une attaque distribuée : lui seul
|
||||
# mérite une trace durable, les échecs ordinaires restent dans `login_attempt`.
|
||||
if compteurs.per_identifier >= politique.max_failures_per_identifier:
|
||||
await self._audit.record(
|
||||
action=AuditAction.LIMITE_PAR_IDENTIFIANT,
|
||||
outcome=AuditOutcome.ECHEC,
|
||||
actor_label=email.strip().lower(),
|
||||
client_ip=client_ip,
|
||||
user_agent=user_agent,
|
||||
detail={"motif": "seuil par identifiant depasse"},
|
||||
)
|
||||
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,
|
||||
client_ip: str | None,
|
||||
outcome: LoginOutcome,
|
||||
*,
|
||||
user_id: UUID | None = None,
|
||||
) -> NoReturn:
|
||||
await self._attempts.record(
|
||||
email=email, client_ip=client_ip, outcome=outcome, user_id=user_id
|
||||
)
|
||||
await self._transaction.commit()
|
||||
raise InvalidCredentialsError("Identifiants invalides")
|
||||
@@ -1,18 +0,0 @@
|
||||
# Contrainte : `ck_reading_quality` accepte NULL et quatre valeurs seulement, alors que le contrat
|
||||
# frontend n'a aucune valeur pour l'absence de qualité. `qualite_ou_critique()` replie donc sur
|
||||
# `critical`, la seule des quatre qui n'induise pas une confiance qu'on n'a pas. `QUALITES_CONNUES`
|
||||
# reste exposé pour les appelants qui doivent distinguer un `critical` stocké d'un repli.
|
||||
|
||||
from typing import Literal, get_args
|
||||
|
||||
DataQuality = Literal["good", "partial", "degraded", "critical"]
|
||||
|
||||
QUALITES_CONNUES: frozenset[str] = frozenset(get_args(DataQuality))
|
||||
|
||||
_PAR_VALEUR: dict[str, DataQuality] = {valeur: valeur for valeur in get_args(DataQuality)}
|
||||
|
||||
|
||||
def qualite_ou_critique(valeur: str | None) -> DataQuality:
|
||||
if valeur is None:
|
||||
return "critical"
|
||||
return _PAR_VALEUR.get(valeur, "critical")
|
||||
@@ -1,233 +0,0 @@
|
||||
"""Contrainte : la dérive se mesure sur ce qui a déjà eu lieu - DriftService.evaluate()
|
||||
|
||||
Une prévision ne devient vérifiable que quand la lecture de son instant cible est ingérée. La
|
||||
fenêtre est donc fermée à droite par un délai de grâce : sans lui, la dernière heure ferait
|
||||
chuter le taux de couverture à chaque exécution, et le verdict dirait « dérive » alors que
|
||||
seule l'ingestion n'avait pas fini son tour.
|
||||
|
||||
La comparaison se fait entre deux fenêtres vives de même durée, pas contre la métrique de
|
||||
référence du modèle journalisée à l'entraînement. Ce ne sont pas les mêmes grandeurs :
|
||||
l'entraînement mesure un backtest où la météo de l'heure cible est connue, le scoring prévoit
|
||||
une heure future dont la météo ne l'est pas. Les comparer classerait le modèle « en dérive »
|
||||
dès le premier jour, ce qui ne prouverait rien.
|
||||
"""
|
||||
|
||||
from collections.abc import Sequence
|
||||
from dataclasses import dataclass, replace
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
from app.models.energy import DriftReport
|
||||
from app.repositories.drift import (
|
||||
ComptageStatut,
|
||||
DriftRepository,
|
||||
NouveauRapportDerive,
|
||||
PaireDerive,
|
||||
)
|
||||
|
||||
STATUT_STABLE = "stable"
|
||||
STATUT_DERIVE = "derive"
|
||||
STATUT_INDETERMINE = "indetermine"
|
||||
|
||||
STATUT_INSUFFISANT = "insufficient_data"
|
||||
STATUT_DISPONIBLE = "available"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Seuils:
|
||||
# 168 h, la saisonnalité hebdomadaire que le modèle apprend par son lag principal : une
|
||||
# fenêtre plus courte comparerait un week-end à une semaine ouvrée.
|
||||
fenetre: timedelta = timedelta(hours=168)
|
||||
grace: timedelta = timedelta(hours=2)
|
||||
min_observations: int = 24
|
||||
ratio_derive: float = 1.25
|
||||
mae_plancher: float = 0.0
|
||||
# Un biais se compte en kWh, donc ne se transpose pas d'un site à l'autre : zéro le désactive,
|
||||
# sans cesser de le mesurer. Réglé par `--bias-threshold`, arbitrage dans l'ADR 0013.
|
||||
seuil_biais: float = 0.0
|
||||
seuil_couverture: float = 0.8
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Metriques:
|
||||
n_observations: int
|
||||
mae: float | None
|
||||
mape: float | None
|
||||
bias: float | None
|
||||
model_references: list[str]
|
||||
|
||||
|
||||
def mesure(paires: Sequence[PaireDerive]) -> Metriques:
|
||||
if not paires:
|
||||
return Metriques(n_observations=0, mae=None, mape=None, bias=None, model_references=[])
|
||||
|
||||
ecarts = [paire.predicted_value - paire.actual_value for paire in paires]
|
||||
# Le MAPE diverge sur une consommation nulle : les sites à l'arrêt sortent de ce seul
|
||||
# rapport, jamais des autres métriques.
|
||||
ratios = [
|
||||
abs(ecart / paire.actual_value)
|
||||
for ecart, paire in zip(ecarts, paires, strict=True)
|
||||
if paire.actual_value != 0
|
||||
]
|
||||
|
||||
return Metriques(
|
||||
n_observations=len(paires),
|
||||
mae=sum(abs(ecart) for ecart in ecarts) / len(ecarts),
|
||||
mape=(sum(ratios) / len(ratios) * 100) if ratios else None,
|
||||
bias=sum(ecarts) / len(ecarts),
|
||||
model_references=sorted({paire.model_reference for paire in paires}),
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Verdict:
|
||||
status: str
|
||||
reason: str | None
|
||||
|
||||
|
||||
class DriftService:
|
||||
def __init__(self, depot: DriftRepository, *, seuils: Seuils | None = None) -> None:
|
||||
self._depot = depot
|
||||
self._seuils = seuils or Seuils()
|
||||
|
||||
async def derniers(self, *, site_id: str | None = None) -> Sequence[DriftReport]:
|
||||
"""Ce que sert l'API : le dernier rapport de chaque site, plus la ligne globale."""
|
||||
return await self._depot.derniers(site_id=site_id)
|
||||
|
||||
async def evaluate(
|
||||
self, *, now: datetime | None = None, site_id: str | None = None
|
||||
) -> list[NouveauRapportDerive]:
|
||||
"""Une ligne par site, plus une ligne globale dont le `site_id` est nul."""
|
||||
fin = (now or datetime.now(UTC)) - self._seuils.grace
|
||||
debut = fin - self._seuils.fenetre
|
||||
reference_fin = debut
|
||||
reference_debut = reference_fin - self._seuils.fenetre
|
||||
|
||||
recentes = await self._depot.paires(debut=debut, fin=fin, site_id=site_id)
|
||||
anciennes = await self._depot.paires(
|
||||
debut=reference_debut, fin=reference_fin, site_id=site_id
|
||||
)
|
||||
comptages = await self._depot.comptages(debut=debut, fin=fin, site_id=site_id)
|
||||
|
||||
gabarit = NouveauRapportDerive(
|
||||
site_id=None,
|
||||
window_start=debut,
|
||||
window_end=fin,
|
||||
reference_start=reference_debut,
|
||||
reference_end=reference_fin,
|
||||
n_observations=0,
|
||||
mae=None,
|
||||
mape=None,
|
||||
bias=None,
|
||||
reference_mae=None,
|
||||
coverage_ratio=None,
|
||||
insufficient_data_ratio=None,
|
||||
model_references=[],
|
||||
status=STATUT_INDETERMINE,
|
||||
reason=None,
|
||||
)
|
||||
|
||||
rapports = [
|
||||
self._rapport(
|
||||
gabarit,
|
||||
site=site,
|
||||
recentes=[p for p in recentes if p.site_id == site],
|
||||
anciennes=[p for p in anciennes if p.site_id == site],
|
||||
comptages=[c for c in comptages if c.site_id == site],
|
||||
)
|
||||
for site in sorted(
|
||||
{paire.site_id for paire in recentes} | {c.site_id for c in comptages}
|
||||
)
|
||||
]
|
||||
rapports.append(
|
||||
self._rapport(
|
||||
gabarit, site=None, recentes=recentes, anciennes=anciennes, comptages=comptages
|
||||
)
|
||||
)
|
||||
return rapports
|
||||
|
||||
def _rapport(
|
||||
self,
|
||||
gabarit: NouveauRapportDerive,
|
||||
*,
|
||||
site: str | None,
|
||||
recentes: Sequence[PaireDerive],
|
||||
anciennes: Sequence[PaireDerive],
|
||||
comptages: Sequence[ComptageStatut],
|
||||
) -> NouveauRapportDerive:
|
||||
metriques = mesure(recentes)
|
||||
reference = mesure(anciennes)
|
||||
couverture = _couverture(len(recentes), comptages)
|
||||
verdict = self._verdict(metriques, reference_mae=reference.mae, couverture=couverture)
|
||||
|
||||
return replace(
|
||||
gabarit,
|
||||
site_id=site,
|
||||
n_observations=metriques.n_observations,
|
||||
mae=metriques.mae,
|
||||
mape=metriques.mape,
|
||||
bias=metriques.bias,
|
||||
reference_mae=reference.mae,
|
||||
coverage_ratio=couverture,
|
||||
insufficient_data_ratio=_part_insuffisante(comptages),
|
||||
model_references=metriques.model_references,
|
||||
status=verdict.status,
|
||||
reason=verdict.reason,
|
||||
)
|
||||
|
||||
def _verdict(
|
||||
self, metriques: Metriques, *, reference_mae: float | None, couverture: float | None
|
||||
) -> Verdict:
|
||||
seuils = self._seuils
|
||||
if metriques.n_observations < seuils.min_observations:
|
||||
return Verdict(
|
||||
STATUT_INDETERMINE,
|
||||
f"{metriques.n_observations} prévision(s) vérifiée(s) sur la fenêtre, "
|
||||
f"minimum {seuils.min_observations}.",
|
||||
)
|
||||
|
||||
if couverture is not None and couverture < seuils.seuil_couverture:
|
||||
return Verdict(
|
||||
STATUT_DERIVE,
|
||||
f"Couverture de {couverture:.0%}, sous le seuil de {seuils.seuil_couverture:.0%} : "
|
||||
"le pipeline, pas le modèle.",
|
||||
)
|
||||
|
||||
plafond = _plafond(reference_mae, ratio=seuils.ratio_derive, plancher=seuils.mae_plancher)
|
||||
if metriques.mae is not None and plafond is not None and metriques.mae > plafond:
|
||||
return Verdict(
|
||||
STATUT_DERIVE,
|
||||
f"MAE de {metriques.mae:.2f} kWh au-delà de {plafond:.2f} kWh, "
|
||||
"seuil dérivé de la fenêtre de référence.",
|
||||
)
|
||||
|
||||
if (
|
||||
seuils.seuil_biais > 0
|
||||
and metriques.bias is not None
|
||||
and abs(metriques.bias) > seuils.seuil_biais
|
||||
):
|
||||
return Verdict(
|
||||
STATUT_DERIVE,
|
||||
f"Biais de {metriques.bias:+.2f} kWh : le modèle se trompe toujours du même côté.",
|
||||
)
|
||||
|
||||
return Verdict(STATUT_STABLE, None)
|
||||
|
||||
|
||||
def _plafond(reference_mae: float | None, *, ratio: float, plancher: float) -> float | None:
|
||||
if reference_mae is None:
|
||||
return plancher or None
|
||||
return max(plancher, reference_mae * ratio)
|
||||
|
||||
|
||||
def _couverture(apparie: int, comptages: Sequence[ComptageStatut]) -> float | None:
|
||||
"""Part des prévisions disponibles qui ont trouvé leur réalisé. Mesure l'ingestion et
|
||||
l'ordonnancement, pas la qualité du modèle."""
|
||||
disponibles = sum(c.nombre for c in comptages if c.status == STATUT_DISPONIBLE)
|
||||
return apparie / disponibles if disponibles else None
|
||||
|
||||
|
||||
def _part_insuffisante(comptages: Sequence[ComptageStatut]) -> float | None:
|
||||
total = sum(c.nombre for c in comptages)
|
||||
if not total:
|
||||
return None
|
||||
return sum(c.nombre for c in comptages if c.status == STATUT_INSUFFISANT) / total
|
||||
@@ -1,68 +0,0 @@
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime
|
||||
|
||||
from app.models.energy import Prediction, Site
|
||||
from app.repositories.prediction import PredictionRepository
|
||||
from app.repositories.site import SiteRepository
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SitePrediction:
|
||||
target_at: datetime
|
||||
target_metric: str
|
||||
period_minutes: int | None
|
||||
predicted_value: float | None
|
||||
status: str
|
||||
failure_reason: str | None
|
||||
model_reference: str
|
||||
created_at: datetime
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SitePredictionSummary:
|
||||
site_id: str
|
||||
site_name: str
|
||||
prediction: SitePrediction | None
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class PredictionSummary:
|
||||
timestamp: datetime
|
||||
sites: list[SitePredictionSummary]
|
||||
|
||||
|
||||
class PredictionService:
|
||||
def __init__(self, sites: SiteRepository, predictions: PredictionRepository) -> None:
|
||||
self._sites = sites
|
||||
self._predictions = predictions
|
||||
|
||||
async def summary(self) -> PredictionSummary:
|
||||
sites = await self._sites.list_all()
|
||||
dernieres = {p.site_id: p for p in await self._predictions.latest_by_site()}
|
||||
|
||||
return PredictionSummary(
|
||||
timestamp=datetime.now(UTC),
|
||||
sites=[_resume_site(site, dernieres.get(site.site_id)) for site in sites],
|
||||
)
|
||||
|
||||
|
||||
def _resume_site(site: Site, derniere: Prediction | None) -> SitePredictionSummary:
|
||||
# Piège : l'absence de ligne signifie « jamais scoré », pas une valeur pseudo-statut, qui
|
||||
# n'existe pas dans la contrainte de la table. `prediction` reste `None` plutôt que de
|
||||
# fabriquer un statut absent du domaine `available`/`insufficient_data`/`error`.
|
||||
prediction = None
|
||||
if derniere is not None:
|
||||
prediction = SitePrediction(
|
||||
target_at=derniere.target_at,
|
||||
target_metric=derniere.target_metric,
|
||||
period_minutes=derniere.period_minutes,
|
||||
predicted_value=derniere.predicted_value,
|
||||
status=derniere.status,
|
||||
failure_reason=derniere.failure_reason,
|
||||
model_reference=derniere.model_reference,
|
||||
created_at=derniere.created_at,
|
||||
)
|
||||
|
||||
return SitePredictionSummary(
|
||||
site_id=site.site_id, site_name=site.site_name, prediction=prediction
|
||||
)
|
||||
@@ -1,59 +0,0 @@
|
||||
from collections.abc import Sequence
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
from app.models.energy import Reading
|
||||
from app.repositories.reading import ReadingRepository
|
||||
|
||||
FENETRE_PAR_DEFAUT = timedelta(hours=24)
|
||||
FENETRE_MAXIMALE = timedelta(days=90)
|
||||
|
||||
|
||||
class FenetreInverseeError(Exception):
|
||||
"""`start` est postérieur ou égal à `end`."""
|
||||
|
||||
|
||||
class FenetreTropLargeError(Exception):
|
||||
"""L'écart entre `start` et `end` dépasse `FENETRE_MAXIMALE`."""
|
||||
|
||||
|
||||
class ReadingService:
|
||||
def __init__(self, *, readings: ReadingRepository) -> None:
|
||||
self._readings = readings
|
||||
|
||||
async def list_history(
|
||||
self,
|
||||
*,
|
||||
site_id: str | None = None,
|
||||
start: datetime | None = None,
|
||||
end: datetime | None = None,
|
||||
limit: int,
|
||||
offset: int,
|
||||
) -> Sequence[Reading]:
|
||||
debut, fin = self._resoudre_fenetre(start, end)
|
||||
return await self._readings.list_history(
|
||||
site_id=site_id, start=debut, end=fin, limit=limit, offset=offset
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _resoudre_fenetre(
|
||||
start: datetime | None, end: datetime | None
|
||||
) -> tuple[datetime, datetime]:
|
||||
# Piège : un datetime naïf (sans fuseau dans la chaîne ISO reçue) fait échouer la
|
||||
# comparaison à `reading.timestamp` (`timestamptz`) au niveau du pilote, en 500 plutôt
|
||||
# qu'un refus propre. On le traite comme de l'UTC plutôt que de le rejeter.
|
||||
debut = _vers_utc(start)
|
||||
fin = _vers_utc(end) or datetime.now(UTC)
|
||||
if debut is None:
|
||||
debut = fin - FENETRE_PAR_DEFAUT
|
||||
|
||||
if debut >= fin:
|
||||
raise FenetreInverseeError
|
||||
if fin - debut > FENETRE_MAXIMALE:
|
||||
raise FenetreTropLargeError
|
||||
return debut, fin
|
||||
|
||||
|
||||
def _vers_utc(instant: datetime | None) -> datetime | None:
|
||||
if instant is None:
|
||||
return None
|
||||
return instant if instant.tzinfo is not None else instant.replace(tzinfo=UTC)
|
||||
@@ -1,62 +0,0 @@
|
||||
from collections.abc import Sequence
|
||||
from dataclasses import dataclass
|
||||
from typing import Protocol
|
||||
|
||||
from app.models.energy import Recommendation
|
||||
from app.repositories.alert import AlertRepository
|
||||
from app.repositories.recommendation import RecommendationRepository
|
||||
from app.services.recommendation_rules import applique_les_regles
|
||||
|
||||
|
||||
class Transaction(Protocol):
|
||||
async def commit(self) -> None: ...
|
||||
|
||||
|
||||
class RecommendationError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class RecommendationNotFoundError(RecommendationError):
|
||||
pass
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class RapportGeneration:
|
||||
alertes_examinees: int
|
||||
recommandations_creees: int
|
||||
deja_presentes: int
|
||||
|
||||
|
||||
class RecommendationService:
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
recommendations: RecommendationRepository,
|
||||
alerts: AlertRepository,
|
||||
transaction: Transaction,
|
||||
) -> None:
|
||||
self._recommendations = recommendations
|
||||
self._alerts = alerts
|
||||
self._transaction = transaction
|
||||
|
||||
async def list_all(self) -> Sequence[Recommendation]:
|
||||
return await self._recommendations.list_all()
|
||||
|
||||
async def get_by_id(self, recommendation_id: int) -> Recommendation:
|
||||
recommendation = await self._recommendations.get_by_id(recommendation_id)
|
||||
if recommendation is None:
|
||||
raise RecommendationNotFoundError(recommendation_id)
|
||||
return recommendation
|
||||
|
||||
async def generate(self, *, site_id: str | None = None) -> RapportGeneration:
|
||||
alertes = await self._alerts.list_all(site_id=site_id)
|
||||
nouvelles = [nouvelle for alerte in alertes for nouvelle in applique_les_regles(alerte)]
|
||||
|
||||
creees = await self._recommendations.create_missing(nouvelles)
|
||||
await self._transaction.commit()
|
||||
|
||||
return RapportGeneration(
|
||||
alertes_examinees=len(alertes),
|
||||
recommandations_creees=creees,
|
||||
deja_presentes=len(nouvelles) - creees,
|
||||
)
|
||||
@@ -1,117 +0,0 @@
|
||||
# Piège : `rule_reference` est la clé d'idempotence en base, portée par la contrainte
|
||||
# `uq_recommendation_alert_rule`. Renommer une référence déjà livrée ne remplace pas les
|
||||
# recommandations existantes, il en crée de nouvelles à côté. Une règle qui change de sens
|
||||
# prend donc une référence suffixée `-v2` - REGLES.
|
||||
|
||||
from collections.abc import Callable
|
||||
from dataclasses import dataclass
|
||||
from typing import Final
|
||||
|
||||
from app.models.energy import Alert
|
||||
from app.repositories.recommendation import NouvelleRecommandation
|
||||
from app.schemas.alert import AlertSeverity, AlertType
|
||||
|
||||
FACTEUR_DEPASSEMENT_MAJEUR: Final = 1.2
|
||||
POURCENTAGE_DEPASSEMENT_MAJEUR: Final = round((FACTEUR_DEPASSEMENT_MAJEUR - 1) * 100)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Regle:
|
||||
reference: str
|
||||
action: str
|
||||
declencheur: Callable[[Alert], bool]
|
||||
motif: Callable[[Alert], str]
|
||||
|
||||
|
||||
def _du_type(attendu: AlertType) -> Callable[[Alert], bool]:
|
||||
return lambda alerte: alerte.type == attendu
|
||||
|
||||
|
||||
def _de_severite(attendue: AlertSeverity) -> Callable[[Alert], bool]:
|
||||
return lambda alerte: alerte.severity == attendue
|
||||
|
||||
|
||||
# Un seuil nul ou négatif rendrait le rapport `value / threshold` arbitraire : l'alerte ne
|
||||
# renseigne alors aucun dépassement exploitable, et la règle ne se déclenche pas.
|
||||
def _depasse_largement_le_seuil(alerte: Alert) -> bool:
|
||||
if alerte.value is None or alerte.threshold is None or alerte.threshold <= 0:
|
||||
return False
|
||||
return alerte.value >= alerte.threshold * FACTEUR_DEPASSEMENT_MAJEUR
|
||||
|
||||
|
||||
REGLES: Final[tuple[Regle, ...]] = (
|
||||
Regle(
|
||||
reference="spike-delestage-v1",
|
||||
action="Délester les équipements non prioritaires sur le créneau du pic",
|
||||
declencheur=_du_type(AlertType.SPIKE),
|
||||
motif=lambda alerte: f"Pic de consommation signalé sur le site {alerte.site_id}",
|
||||
),
|
||||
Regle(
|
||||
reference="threshold-reduction-v1",
|
||||
action="Ramener la puissance appelée sous le seuil contractuel",
|
||||
declencheur=_du_type(AlertType.THRESHOLD),
|
||||
motif=lambda alerte: f"Seuil de consommation dépassé sur le site {alerte.site_id}",
|
||||
),
|
||||
Regle(
|
||||
reference="outage-secours-v1",
|
||||
action="Basculer sur l'alimentation de secours et prévenir l'exploitant",
|
||||
declencheur=_du_type(AlertType.OUTAGE),
|
||||
motif=lambda alerte: (
|
||||
f"Risque de surcharge ou de coupure imminente sur le site {alerte.site_id}"
|
||||
),
|
||||
),
|
||||
Regle(
|
||||
reference="sensor-maintenance-v1",
|
||||
action="Planifier une intervention de maintenance sur le capteur",
|
||||
declencheur=_du_type(AlertType.SENSOR),
|
||||
motif=lambda alerte: (
|
||||
f"Capteur défaillant sur le site {alerte.site_id}, les mesures ne sont plus fiables"
|
||||
),
|
||||
),
|
||||
Regle(
|
||||
reference="anomaly-verification-v1",
|
||||
action="Confronter la mesure à la prévision et vérifier le paramétrage du site",
|
||||
declencheur=_du_type(AlertType.ANOMALY),
|
||||
motif=lambda alerte: (
|
||||
f"Écart anormal entre la mesure et le comportement attendu du site {alerte.site_id}"
|
||||
),
|
||||
),
|
||||
Regle(
|
||||
reference="escalade-astreinte-v1",
|
||||
action="Escalader à l'astreinte sous une heure",
|
||||
declencheur=_de_severite(AlertSeverity.CRITICAL),
|
||||
motif=lambda alerte: f"Alerte de sévérité critique sur le site {alerte.site_id}",
|
||||
),
|
||||
Regle(
|
||||
reference="contrat-puissance-v1",
|
||||
action="Réévaluer la puissance souscrite au contrat",
|
||||
declencheur=_depasse_largement_le_seuil,
|
||||
motif=lambda alerte: (
|
||||
f"Dépassement d'au moins {POURCENTAGE_DEPASSEMENT_MAJEUR} % du seuil "
|
||||
f"sur le site {alerte.site_id}"
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def applique_les_regles(alerte: Alert) -> list[NouvelleRecommandation]:
|
||||
contexte = _contexte_de_mesure(alerte)
|
||||
return [
|
||||
NouvelleRecommandation(
|
||||
alert_id=alerte.alert_id,
|
||||
action=regle.action,
|
||||
explanation=f"{regle.motif(alerte)}{contexte}.",
|
||||
rule_reference=regle.reference,
|
||||
)
|
||||
for regle in REGLES
|
||||
if regle.declencheur(alerte)
|
||||
]
|
||||
|
||||
|
||||
def _contexte_de_mesure(alerte: Alert) -> str:
|
||||
if alerte.value is None:
|
||||
return ""
|
||||
grandeur = alerte.metric or "valeur"
|
||||
if alerte.threshold is None:
|
||||
return f" ({grandeur} mesurée à {alerte.value})"
|
||||
return f" ({grandeur} mesurée à {alerte.value}, seuil {alerte.threshold})"
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user