Merge branch 'release/2.7.9'

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.github/workflows/deploy.yaml

@@ -20,7 +20,7 @@ jobs:
     environment: ${{ github.ref_name }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Set up SSH key
         run: |

.template.env

@@ -9,16 +9,17 @@ ANNOUNCEMENTS=
 
 # Chemin vers le schéma de données
 DATA_SCHEMA_PATH=https://www.data.gouv.fr/api/1/datasets/r/9a4144c0-ee44-4dec-bee5-bbef38191d9a
+DATA_SCHEMA_PATH_LOCAL=../schema.json
 
 # Colonnes masquées par défaut
 DISPLAYED_COLUMNS="uid, acheteur_id, acheteur_nom, montant, objet, titulaire_nom, titulaire_id, dateNotification, dureeMois, acheteur_departement_code, sourceDataset"
 
 # Formulaire de contact
 SENDER_SERVER_DOMAIN="mail.example.com" # serveur SMTP
-LOGIN_PASSWORD="" # mot de passe du serveur
-LOGIN_EMAIL="connect@example.fr" # adresse utilisée pour se connecter au serveur SMTP
-FROM_EMAIL="from@example.com" # adresse d'envoi des emails (From)
-TO_EMAIL="to@example.com" # adresse de destination des emails (To)
+LOGIN_PASSWORD=""                       # mot de passe du serveur
+LOGIN_EMAIL="connect@example.fr"        # adresse utilisée pour se connecter au serveur SMTP
+FROM_EMAIL="from@example.com"           # adresse d'envoi des emails (From)
+TO_EMAIL="to@example.com"               # adresse de destination des emails (To)
 
 # Matomo
 MATOMO_ID_SITE=

CHANGELOG.md

@@ -1,3 +1,22 @@
+##### 2.7.9 (9 juin 2026)
+
+- Ajout d'une vue "étapes" (elle sera mieux intégrée dans le site à l'avenir)
+- Correction de petites erreurs qui polluent les logs
+
+##### 2.7.8 (18 mai 2026)
+
+- Récupération du schéma de données plus robuste, ne pas dépendre de data.gouv.fr
+
+##### 2.7.7 (11 mai 2026)
+
+- Suppression des mentions sur les profils d'acheteur. Omnikles/Safetender publie via l'API DUME et Klekoon ne publie pas, mais c'est peut-être pas le seul, donc je préfère supprimer et refaire un tour.
+
+##### 2.7.6 (5 mai 2026)
+
+- Correction du problème de filtre par date dans les tableaux
+- Retour des cartes dans les pages acheteur et titulaire
+- Possibilité de chercher un SIRET/SIREN avec des espaces dans les champs `SIRET acheteur` et `Identifiant titulaire`
+
 ##### 2.7.5 (24 avril 2026)
 
 - Amélioration des permormances de l'observatoire

docs/superpowers/plans/2026-04-28-organization-maps.md

@@ -0,0 +1,108 @@
+# Plan: Ajouter des cartes de localisation aux pages acheteur et titulaire
+
+## Date: 2026-04-28
+
+## Statut: Approuvé
+
+## Objectif: Ajouter des cartes interactives montrant la localisation des organisations sur les pages acheteur et titulaire
+
+## Contexte
+
+- Les pages acheteur et titulaire ont déjà des placeholders pour les cartes (`acheteur_map` et `titulaire_map`)
+- La fonction `point_on_map()` existe déjà dans `src/figures.py` mais utilise un centrage fixe sur la France
+- Les données de localisation proviennent de l'API Annuaire des Entreprises
+- Les codes départementaux sont disponibles et plus fiables que les coordonnées pour la détection de région
+
+## Exigences
+
+### 1. Carte interactive
+
+- **Localisation**: Colonne de droite dans la section d'informations sur l'organisation
+- **Taille**: 400px de largeur × 300px de hauteur (fixe)
+- **Contenu**: Carte centrée sur la France ou le département d'outre-mer approprié avec un point rouge à l'emplacement de l'organisation
+- **Niveau de zoom**: Approprié pour montrer l'Hexagone ou le département d'outre-mer spécifique
+- **Style**: Fond de carte clair avec point rouge visible
+- **Interactivité**: Carte zoomable et déplaçable (pas de configuration statique)
+
+### 2. Sources de données
+
+- Utiliser les colonnes `acheteur_latitude` et `acheteur_longitude` pour les pages acheteur
+- Utiliser les colonnes `titulaire_latitude` et `titulaire_longitude` pour les pages titulaire
+- Utiliser les codes départementaux (`acheteur_departement_code`, `titulaire_departement_code`) pour la détection de région
+- Solution de repli: Si les coordonnées ou codes départementaux sont manquants ou invalides, afficher une div vide
+
+### 3. Détection de région
+
+- **Départements métropolitains**: Codes à 2 caractères (ex: "75" pour Paris) → Carte Hexagone
+- **Départements d'outre-mer**:
+  - "971" → Guadeloupe
+  - "972" → Martinique
+  - "973" → Guyane
+  - "974" → La Réunion
+  - "976" → Mayotte
+- **Code département manquant**: Retourner une div vide (pas de détection basée sur les coordonnées)
+
+### 4. Gestion des erreurs
+
+- Coordonnées invalides → div vide
+- Code département manquant → div vide
+- Échec de l'API Annuaire → div vide (comportement existant)
+- Format de code département invalide → div vide
+
+## Implémentation
+
+### Fichiers à modifier
+
+#### 1. `src/figures.py` - Améliorer la fonction `point_on_map()`
+
+**Ligne 178-209**: Remplacer la fonction existante par une version améliorée avec:
+
+- Détection de région basée sur les codes départementaux
+- Configuration de carte interactive (zoomable)
+- Point plus grand (size=15)
+- Commentaires en français
+
+#### 2. `src/pages/acheteur.py` - Mettre à jour le callback
+
+**Ligne 249-297**: Modifier `update_acheteur_infos()` pour:
+
+- Extraire le code département du code postal
+- Passer le code département à `point_on_map()`
+- Ajouter des commentaires en français
+
+#### 3. `src/pages/titulaire.py` - Mettre à jour le callback
+
+**Ligne 259-297**: Modifier `update_titulaire_infos()` pour:
+
+- Extraire le code département du code postal
+- Passer le code département à `point_on_map()`
+- Ajouter des commentaires en français
+
+## Plan de Test
+
+### Cas de test prioritaires
+
+1. **Organisation métropolitaine**: Code département "75" (Paris) → Carte Hexagone
+2. **Organisation à La Réunion**: Code département "974" → Carte centrée sur La Réunion
+3. **Code département manquant**: Retourne une div vide
+4. **Coordonnées invalides**: Retourne une div vide
+5. **Interactivité**: Vérifier zoom et déplacement
+
+### Critères d'acceptation
+
+- [ ] Cartes fonctionnelles avec codes départementaux valides
+- [ ] Div vide pour codes manquants/invalides
+- [ ] Cartes correctement centrées et zoomées
+- [ ] Interactivité (zoom et déplacement)
+- [ ] Point de localisation visible (size=15)
+
+## Approbation
+
+Plan approuvé avec spécifications:
+
+- Réutiliser et améliorer `point_on_map`
+- Retourner div vide sans code département
+- Point légèrement plus grand
+- Cartes zoomables
+- Utiliser codes départementaux pour détection de région
+- Commentaires en français

docs/superpowers/plans/2026-06-04-page-etapes-seuils.md

@@ -0,0 +1,699 @@
+# Page `/etapes` — « Quelles données pour quelles étapes et quels seuils ? » — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Créer une page statique `/etapes` qui affiche un graphique HTML/CSS montrant quelles données (Approch, Journaux d'annonces légales, BOAMP, JOUE, DECP) sont publiées à chaque étape de la passation d'un marché public et à partir de quel seuil réglementaire.
+
+**Architecture:** Une nouvelle page Dash auto-enregistrée (`src/pages/etapes.py`) qui expose un `layout` composé uniquement de `html.Div`/`dcc.Markdown` (aucun callback, aucune donnée dynamique). La page rend **deux représentations des mêmes données** basculées par media query : sur desktop/tablette, un graphique en grille CSS (1 colonne de libellés + 5 colonnes de seuils) où chaque publication est une barre positionnée en pourcentage ; sur mobile portrait (< 768 px), une liste verticale par étape. Le style vit dans `src/assets/css/style.css` (auto-chargé par Dash). L'URL est ajoutée au sitemap mais pas à la navbar.
+
+**Tech Stack:** Python 3, Dash 3.4 (pages API), CSS (grille + positionnement absolu), Flask (route sitemap existante).
+
+---
+
+## Contexte pour l'engineer (à lire avant de commencer)
+
+- decp.info est une app Dash multi-pages. Chaque page est un module dans `src/pages/` qui appelle `register_page(...)` au niveau du module et expose une variable `layout`. Dash découvre ces pages automatiquement grâce à `use_pages=True` (voir `src/app.py:30`).
+- **Imports** : toujours importer les modules de l'app avec le préfixe `src.` (ex. `from src.utils.seo import META_CONTENT`).
+- La navbar (`src/app.py:170-182`) est construite à partir d'une **liste blanche de noms** : `["Recherche", "À propos", "Tableau", "Observatoire"]`. Une page dont le `name` n'est pas dans cette liste **n'apparaît pas** dans la navbar. On ne touche donc PAS à la navbar.
+- Le sitemap (`src/app.py:70-86`) est une **liste d'URLs codée en dur**. Il faut y ajouter `/etapes`.
+- Le CSS personnalisé est dans `src/assets/css/style.css` (Dash charge automatiquement tout ce qui est dans `src/assets/`). On y ajoute les règles du graphique.
+- **Pré-requis commit** : ce dépôt utilise `pre-commit` (prettier, ruff). Les hooks ne tournent que si le virtualenv est activé. Avant chaque `git commit`, faire `source .venv/bin/activate` dans la même commande shell. Prettier peut reformater les fichiers Markdown/CSS : si un commit échoue parce que des fichiers ont été modifiés par un hook, refaire `git add` puis `git commit`.
+- **Référence visuelle** : la maquette validée est `.superpowers/brainstorm/80498-1780599135/content/chart-concept-v3.html`. Le code HTML/CSS ci-dessous en est la transposition.
+- Ce projet n'a **pas** de test automatisé pour cette page (contenu 100 % statique). La vérification est manuelle via `python run.py`. Les tâches ci-dessous remplacent donc le cycle TDD par des vérifications de rendu explicites.
+
+---
+
+## File Structure
+
+- **Create** `src/pages/etapes.py` — la page : `register_page(...)` + `layout`. Contient `build_chart()` (graphique grille desktop), `build_mobile()` (liste verticale mobile, alimentée par la structure `STAGES_MOBILE`) et `build_legend()`, pour garder le `layout` lisible. Responsabilité unique : décrire la page `/etapes`.
+- **Modify** `src/app.py` — ajouter `"/etapes"` à la liste `pages` de la fonction `sitemap()`.
+- **Modify** `src/assets/css/style.css` — ajouter un bloc de règles préfixées `.etapes-*` : graphique en grille, liste mobile `.etapes-m-*`, et media query de bascule à 768 px.
+
+---
+
+## Task 1 : Squelette de la page `/etapes`
+
+**Files:**
+
+- Create: `src/pages/etapes.py`
+
+- [ ] **Step 1: Créer le fichier avec l'enregistrement de page et un layout minimal**
+
+Créer `src/pages/etapes.py` avec exactement ce contenu (le graphique sera ajouté en Task 2) :
+
+```python
+from dash import dcc, html, register_page
+
+from src.utils.seo import META_CONTENT
+
+NAME = "Quelles données pour quelles étapes et quels seuils ?"
+
+register_page(
+    __name__,
+    path="/etapes",
+    title=f"{NAME} | decp.info",
+    name="Étapes et données",
+    description=(
+        "À chaque étape d'un marché public (programmation, publicité, "
+        "attribution), quelles données sont publiées et à partir de quel "
+        "seuil : DECP, BOAMP, JOUE, journaux d'annonces légales, Approch."
+    ),
+    image_url=META_CONTENT["image_url"],
+)
+
+layout = html.Div(
+    className="container",
+    children=[
+        html.H2(NAME),
+        dcc.Markdown(
+            "Un marché public passe par plusieurs étapes. À chacune, des "
+            "données peuvent être publiées — selon le montant du marché et "
+            "des obligations réglementaires. Ce graphique situe les "
+            "principales publications de données par **étape** (de haut en "
+            "bas) et par **seuil** (de gauche à droite, en euros hors taxes)."
+        ),
+        # Le graphique sera inséré ici en Task 2
+        dcc.Markdown(
+            "**À noter :** l'axe horizontal n'est pas linéaire — les seuils "
+            "sont espacés régulièrement pour rester lisibles. Les étapes "
+            "*Contrat* et *Paiement* n'ont aujourd'hui aucune donnée publiée "
+            "en open data.",
+            className="etapes-note",
+        ),
+    ],
+)
+```
+
+- [ ] **Step 2: Lancer l'app et vérifier que la page se charge**
+
+Run :
+
+```bash
+source .venv/bin/activate && python run.py
+```
+
+Puis ouvrir `http://127.0.0.1:8050/etapes` dans un navigateur.
+Expected : la page affiche le titre « Quelles données pour quelles étapes et quels seuils ? », le paragraphe d'intro et la note, avec le bandeau de navigation en haut. Aucune erreur dans la console du serveur. Arrêter le serveur (Ctrl-C).
+
+- [ ] **Step 3: Vérifier l'absence dans la navbar**
+
+Sur n'importe quelle page, vérifier visuellement que « Étapes et données » **n'apparaît pas** dans la barre de navigation (la liste blanche `src/app.py:181` ne la contient pas).
+Expected : la navbar montre uniquement Recherche / Tableau / Observatoire / À propos.
+
+- [ ] **Step 4: Commit**
+
+```bash
+source .venv/bin/activate && git add src/pages/etapes.py && git commit -m "feat(etapes): squelette de la page /etapes"
+```
+
+(Si le commit échoue car un hook a reformaté le fichier : refaire `git add src/pages/etapes.py && git commit -m "feat(etapes): squelette de la page /etapes"`.)
+
+---
+
+## Task 2 : Le graphique HTML/CSS
+
+**Files:**
+
+- Modify: `src/pages/etapes.py`
+
+Le graphique est une grille de 6 colonnes : 1 colonne de libellés d'étape (150 px) + 5 colonnes de seuils égales. L'en-tête X et chaque ligne d'étape occupent les colonnes 2 → 6 (`grid-column: 2 / -1`). À l'intérieur d'une ligne, les barres sont positionnées en `position:absolute` avec `left`/`right` en pourcentage, où chaque segment de seuil = 20 % de la largeur :
+
+- Segment 1 (0 € → 40 k€) : 0 % – 20 %
+- Segment 2 (40 k€ → 90 k€) : 20 % – 40 %
+- Segment 3 (90 k€ → 140/216 k€) : 40 % – 60 %
+- Segment 4 (140/216 k€ → 5,404 M€) : 60 % – 80 %
+- Segment 5 (≥ 5,404 M€) : 80 % – 100 %
+
+Une barre qui « commence à 40 k€ et va jusqu'à l'infini » s'écrit donc `left:20%; right:2%` (les `2%` de marge évitent de coller au bord). Une barre qui remplit la case 90 k€ → seuil formalisé s'écrit `left:40%; right:40%`.
+
+- [ ] **Step 1: Ajouter la fonction `build_chart()` au-dessus de `layout`**
+
+Dans `src/pages/etapes.py`, insérer cette fonction entre le bloc `register_page(...)` et la définition de `layout` :
+
+```python
+def _lane(*bars):
+    """Une ligne d'étape : fond segmenté en 5 + barres positionnées."""
+    return html.Div(
+        className="etapes-lane",
+        children=[
+            html.Div(
+                className="etapes-segs",
+                children=[html.Div() for _ in range(5)],
+            ),
+            *bars,
+        ],
+    )
+
+
+def _bar(label, color, style):
+    base = {"backgroundColor": color}
+    base.update(style)
+    return html.Div(label, className="etapes-bar", style=base)
+
+
+def build_chart():
+    return html.Div(
+        className="etapes-chart-scroll",
+        children=html.Div(
+            className="etapes-chart",
+            children=[
+                # En-tête : coin vide + 5 marqueurs de seuils
+                html.Div(className="etapes-corner"),
+                html.Div(
+                    className="etapes-xhead",
+                    children=[
+                        html.Div("0 €", className="etapes-xcell"),
+                        html.Div(
+                            [html.Strong("40 000 €"), "seuil DECP"],
+                            className="etapes-xcell",
+                        ),
+                        html.Div(
+                            [html.Strong("90 000 €"), "publicité"],
+                            className="etapes-xcell",
+                        ),
+                        html.Div(
+                            [html.Strong("140 k€ / 216 k€"), "seuils formalisés (UE)"],
+                            className="etapes-xcell",
+                        ),
+                        html.Div(
+                            [html.Strong("5,404 M€"), "travaux (UE)"],
+                            className="etapes-xcell",
+                        ),
+                    ],
+                ),
+                # Programmation
+                html.Div("Programmation", className="etapes-stage"),
+                _lane(
+                    _bar(
+                        "Approch — sourcing / préinformation (non réglementaire)",
+                        "#7c5cff",
+                        {"left": "2%", "right": "2%"},
+                    ),
+                ),
+                # Publicité (appel d'offres)
+                html.Div(
+                    ["Publicité ", html.Small("(appel d'offres)")],
+                    className="etapes-stage",
+                ),
+                _lane(
+                    _bar(
+                        "Journaux d'annonces légales",
+                        "#f79009",
+                        {"left": "40%", "right": "40%", "top": "6px", "height": "20px"},
+                    ),
+                    _bar(
+                        "BOAMP",
+                        "#1570ef",
+                        {"left": "40%", "right": "2%", "top": "28px", "height": "20px"},
+                    ),
+                    _bar(
+                        "JOUE — avis de marché",
+                        "#0e9384",
+                        {"left": "60%", "right": "2%", "top": "6px", "height": "20px"},
+                    ),
+                ),
+                # Attribution
+                html.Div("Attribution", className="etapes-stage"),
+                _lane(
+                    _bar(
+                        "DECP — données essentielles",
+                        "#12b76a",
+                        {"left": "20%", "right": "2%", "top": "6px", "height": "20px"},
+                    ),
+                    _bar(
+                        "JOUE — avis d'attribution",
+                        "#0e9384",
+                        {"left": "60%", "right": "2%", "top": "28px", "height": "20px"},
+                    ),
+                ),
+                # Contrat (vide)
+                html.Div("Contrat", className="etapes-stage"),
+                html.Div(
+                    "— aucune donnée publiée aujourd'hui —",
+                    className="etapes-lane etapes-empty",
+                ),
+                # Paiement (vide)
+                html.Div("Paiement", className="etapes-stage"),
+                html.Div(
+                    "— aucune donnée publiée aujourd'hui —",
+                    className="etapes-lane etapes-empty",
+                ),
+            ],
+        ),
+    )
+
+
+def build_legend():
+    items = [
+        ("Approch", "#7c5cff"),
+        ("Journaux d'annonces légales", "#f79009"),
+        ("BOAMP", "#1570ef"),
+        ("JOUE", "#0e9384"),
+        ("DECP", "#12b76a"),
+    ]
+    return html.Div(
+        className="etapes-legend",
+        children=[
+            html.Span(
+                [
+                    html.I(style={"backgroundColor": color}),
+                    label,
+                ]
+            )
+            for label, color in items
+        ],
+    )
+```
+
+- [ ] **Step 2: Insérer le graphique et la légende dans `layout`**
+
+Dans `layout`, remplacer la ligne de commentaire `# Le graphique sera inséré ici en Task 2` par :
+
+```python
+        build_chart(),
+        build_legend(),
+```
+
+- [ ] **Step 3: Lancer l'app et vérifier le rendu**
+
+Run :
+
+```bash
+source .venv/bin/activate && python run.py
+```
+
+Ouvrir `http://127.0.0.1:8050/etapes`.
+Expected (comparer à la maquette `.superpowers/brainstorm/80498-1780599135/content/chart-concept-v3.html`) :
+
+- En-tête X : `0 € · 40 000 € (seuil DECP) · 90 000 € (publicité) · 140 k€/216 k€ (seuils formalisés UE) · 5,404 M€ (travaux UE)`.
+- Lignes de haut en bas : Programmation (barre Approch pleine largeur), Publicité (Journaux d'annonces légales + BOAMP + JOUE), Attribution (DECP + JOUE), Contrat (vide), Paiement (vide).
+- La barre « Journaux d'annonces légales » occupe la case 90 k€ → seuil formalisé ; DECP démarre à 40 k€ ; JOUE et BOAMP démarrent aux bons segments.
+- La légende sous le graphique liste les 5 publications avec leurs couleurs.
+
+À ce stade le style brut (couleurs des barres) doit déjà être visible car appliqué inline ; la mise en page de la grille sera finalisée en Task 4. Si la grille n'est pas encore correcte (colonnes non alignées), c'est attendu — continuer. Arrêter le serveur.
+
+- [ ] **Step 4: Commit**
+
+```bash
+source .venv/bin/activate && git add src/pages/etapes.py && git commit -m "feat(etapes): graphique données par étape et par seuil"
+```
+
+(Si échec dû à un hook : refaire `git add` puis `git commit`.)
+
+---
+
+## Task 3 : Vue mobile (liste verticale par étape)
+
+**Files:**
+
+- Modify: `src/pages/etapes.py`
+
+Sur écran portrait étroit, le graphique en grille n'est pas lisible (vue d'ensemble perdue). On ajoute une **liste verticale par étape** qui décrit les mêmes données en texte. Le basculement entre les deux rendus se fera en CSS (Task 4). Pour éviter la duplication, les publications de chaque étape sont décrites dans une structure de données Python consommée par le rendu mobile.
+
+- [ ] **Step 1: Ajouter la structure de données et `build_mobile()`**
+
+Dans `src/pages/etapes.py`, ajouter ce bloc juste avant la fonction `build_legend()` :
+
+```python
+# Données par étape, partagées par la vue mobile.
+# Chaque item : (libellé, couleur, plage de seuils en texte).
+STAGES_MOBILE = [
+    (
+        "Programmation",
+        [
+            ("Approch", "#7c5cff", "tous montants — publication non réglementaire"),
+        ],
+    ),
+    (
+        "Publicité (appel d'offres)",
+        [
+            ("Journaux d'annonces légales", "#f79009", "de 90 000 € au seuil formalisé"),
+            ("BOAMP", "#1570ef", "à partir de 90 000 €"),
+            (
+                "JOUE — avis de marché",
+                "#0e9384",
+                "à partir des seuils formalisés (140 k€ / 216 k€)",
+            ),
+        ],
+    ),
+    (
+        "Attribution",
+        [
+            ("DECP — données essentielles", "#12b76a", "à partir de 40 000 €"),
+            ("JOUE — avis d'attribution", "#0e9384", "à partir des seuils formalisés"),
+        ],
+    ),
+    ("Contrat", []),
+    ("Paiement", []),
+]
+
+
+def build_mobile():
+    blocks = []
+    for stage, items in STAGES_MOBILE:
+        if items:
+            children = [
+                html.Div(
+                    [
+                        html.I(style={"backgroundColor": color}),
+                        html.Span(label, className="etapes-m-label"),
+                        html.Span(seuil, className="etapes-m-seuil"),
+                    ],
+                    className="etapes-m-item",
+                )
+                for label, color, seuil in items
+            ]
+        else:
+            children = [
+                html.Div(
+                    "aucune donnée publiée aujourd'hui",
+                    className="etapes-m-item etapes-m-empty",
+                )
+            ]
+        blocks.append(
+            html.Div(
+                [html.H4(stage, className="etapes-m-stage"), *children],
+                className="etapes-m-block",
+            )
+        )
+    return html.Div(blocks, className="etapes-mobile")
+```
+
+- [ ] **Step 2: Insérer `build_mobile()` dans `layout`**
+
+Dans `layout`, la ligne `build_chart(),` (insérée en Task 2) est suivie de `build_mobile(),`, soit :
+
+```python
+        build_chart(),
+        build_mobile(),
+        build_legend(),
+```
+
+- [ ] **Step 3: Lancer l'app et vérifier (rendu brut, avant CSS de bascule)**
+
+Run :
+
+```bash
+source .venv/bin/activate && python run.py
+```
+
+Ouvrir `http://127.0.0.1:8050/etapes`. À ce stade les deux rendus s'affichent l'un sous l'autre (la bascule CSS arrive en Task 4) : sous le graphique, la liste affiche Programmation (Approch…), Publicité (3 publications), Attribution (2 publications), puis Contrat et Paiement avec « aucune donnée publiée aujourd'hui ». C'est attendu. Arrêter le serveur.
+
+- [ ] **Step 4: Commit**
+
+```bash
+source .venv/bin/activate && git add src/pages/etapes.py && git commit -m "feat(etapes): vue mobile liste par étape"
+```
+
+(Si échec dû à un hook : refaire `git add` puis `git commit`.)
+
+---
+
+## Task 4 : CSS du graphique + bascule mobile
+
+**Files:**
+
+- Modify: `src/assets/css/style.css`
+
+- [ ] **Step 1: Ajouter le bloc CSS à la fin de `src/assets/css/style.css`**
+
+Ajouter à la fin du fichier :
+
+```css
+/* ===== Page /etapes : graphique données par étape et par seuil ===== */
+
+.etapes-chart-scroll {
+  overflow-x: auto;
+  margin: 1rem 0;
+}
+
+.etapes-chart {
+  min-width: 720px;
+  background: #fff;
+  border: 1px solid #d0d5dd;
+  border-radius: 8px;
+  overflow: hidden;
+  font-size: 13px;
+  display: grid;
+  grid-template-columns: 150px repeat(5, 1fr);
+}
+
+.etapes-corner {
+  border-bottom: 2px solid #344054;
+}
+
+.etapes-xhead {
+  grid-column: 2 / -1;
+  display: grid;
+  grid-template-columns: repeat(5, 1fr);
+  border-bottom: 2px solid #344054;
+}
+
+.etapes-xcell {
+  text-align: center;
+  padding: 6px 2px;
+  font-size: 11px;
+  color: #475467;
+  border-left: 1px dashed #d0d5dd;
+}
+
+.etapes-xcell strong {
+  display: block;
+  color: #101828;
+  font-size: 12px;
+}
+
+.etapes-stage {
+  padding: 14px 10px;
+  font-weight: 600;
+  color: #101828;
+  border-bottom: 1px solid #eaecf0;
+  display: flex;
+  align-items: center;
+}
+
+.etapes-stage small {
+  font-weight: 400;
+  color: #667085;
+}
+
+.etapes-lane {
+  grid-column: 2 / -1;
+  position: relative;
+  border-bottom: 1px solid #eaecf0;
+  min-height: 52px;
+}
+
+.etapes-segs {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  grid-template-columns: repeat(5, 1fr);
+}
+
+.etapes-segs > div {
+  border-left: 1px dashed #eaecf0;
+}
+
+.etapes-bar {
+  position: absolute;
+  top: 9px;
+  height: 32px;
+  border-radius: 6px;
+  color: #fff;
+  font-size: 11px;
+  font-weight: 600;
+  display: flex;
+  align-items: center;
+  padding: 0 10px;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.12);
+  white-space: nowrap;
+  overflow: hidden;
+}
+
+.etapes-empty {
+  color: #98a2b3;
+  font-style: italic;
+  padding: 14px;
+  display: flex;
+  align-items: center;
+}
+
+.etapes-legend {
+  margin-top: 14px;
+  display: flex;
+  gap: 16px;
+  flex-wrap: wrap;
+  font-size: 12px;
+}
+
+.etapes-legend span {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.etapes-legend i {
+  width: 14px;
+  height: 14px;
+  border-radius: 3px;
+  display: inline-block;
+}
+
+.etapes-note {
+  margin-top: 8px;
+  color: #667085;
+  font-size: 13px;
+}
+
+/* --- Vue mobile (liste par étape) : masquée par défaut --- */
+
+.etapes-mobile {
+  display: none;
+  margin: 1rem 0;
+}
+
+.etapes-m-block {
+  border: 1px solid #d0d5dd;
+  border-radius: 8px;
+  margin-bottom: 12px;
+  overflow: hidden;
+}
+
+.etapes-m-stage {
+  margin: 0;
+  padding: 10px 12px;
+  background: #f9fafb;
+  border-bottom: 1px solid #eaecf0;
+  font-size: 15px;
+  color: #101828;
+}
+
+.etapes-m-item {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  padding: 8px 12px;
+  border-bottom: 1px solid #f2f4f7;
+  font-size: 13px;
+}
+
+.etapes-m-item:last-child {
+  border-bottom: none;
+}
+
+.etapes-m-item i {
+  width: 12px;
+  height: 12px;
+  border-radius: 3px;
+  flex: 0 0 auto;
+  position: relative;
+  top: 2px;
+}
+
+.etapes-m-label {
+  font-weight: 600;
+  color: #101828;
+}
+
+.etapes-m-seuil {
+  color: #667085;
+}
+
+.etapes-m-empty {
+  color: #98a2b3;
+  font-style: italic;
+}
+
+/* --- Bascule desktop / mobile au point de rupture 768 px --- */
+
+@media (max-width: 768px) {
+  .etapes-chart-scroll,
+  .etapes-legend {
+    display: none;
+  }
+  .etapes-mobile {
+    display: block;
+  }
+}
+```
+
+- [ ] **Step 2: Lancer l'app et vérifier le rendu final**
+
+Run :
+
+```bash
+source .venv/bin/activate && python run.py
+```
+
+Ouvrir `http://127.0.0.1:8050/etapes` en grand écran (≥ 768 px).
+Expected : le graphique est identique à la maquette v3 — colonnes alignées, en-tête X avec ligne de séparation foncée, barres colorées bien positionnées dans chaque segment, lignes Contrat/Paiement grisées en italique, légende sous le graphique. La **liste mobile est masquée** (le graphique seul est visible).
+
+- [ ] **Step 3: Vérifier la bascule responsive**
+
+Dans le navigateur, ouvrir les devtools et passer en mode mobile portrait (largeur < 768 px, ex. iPhone SE 375 px). Tester aussi une largeur intermédiaire (~800 px).
+Expected :
+
+- À largeur intermédiaire (~800 px, ≥ 768) : le **graphique** s'affiche, défilable horizontalement (`overflow-x:auto` + `min-width:720px`), barres non écrasées ; liste mobile masquée.
+- En portrait (< 768 px) : le graphique **et la légende disparaissent**, remplacés par la **liste verticale par étape** — chaque étape est un bloc avec son titre, et chaque publication a sa pastille de couleur, son nom et sa plage de seuils en texte. Aucun défilement horizontal nécessaire. Contrat/Paiement affichent « aucune donnée publiée aujourd'hui » en italique.
+
+Arrêter le serveur.
+
+- [ ] **Step 4: Commit**
+
+```bash
+source .venv/bin/activate && git add src/assets/css/style.css && git commit -m "feat(etapes): styles du graphique étapes/seuils"
+```
+
+(Si échec dû à un hook prettier : refaire `git add` puis `git commit`.)
+
+---
+
+## Task 5 : Référencement de la page dans le sitemap
+
+**Files:**
+
+- Modify: `src/app.py` (fonction `sitemap()`, ~ligne 73)
+
+- [ ] **Step 1: Ajouter `/etapes` à la liste des URLs du sitemap**
+
+Dans `src/app.py`, dans la fonction `sitemap()`, modifier la liste `pages` :
+
+```python
+    pages = [
+        "/",
+        "/observatoire",
+        "/tableau",
+        "/a-propos",
+        "/etapes",
+    ]
+```
+
+- [ ] **Step 2: Vérifier le sitemap**
+
+Run :
+
+```bash
+source .venv/bin/activate && python run.py
+```
+
+Ouvrir `http://127.0.0.1:8050/sitemap.xml`.
+Expected : le XML contient désormais une entrée `<loc>https://decp.info/etapes</loc>`. Arrêter le serveur.
+
+- [ ] **Step 3: Commit**
+
+```bash
+source .venv/bin/activate && git add src/app.py && git commit -m "feat(etapes): référencement de /etapes dans le sitemap"
+```
+
+---
+
+## Vérification finale (checklist de la spec)
+
+- [ ] `/etapes` affiche le graphique fidèle à la maquette v3, avec le bandeau de navigation global en haut.
+- [ ] La page est **absente** de la navbar.
+- [ ] `/sitemap.xml` **contient** `/etapes`.
+- [ ] Sur fenêtre intermédiaire (≥ 768 px), le graphique défile horizontalement sans s'écraser.
+- [ ] Sur écran portrait étroit (< 768 px), le graphique est masqué et remplacé par la liste verticale par étape, lisible sans défilement horizontal.
+- [ ] Titre H2 de la page = « Quelles données pour quelles étapes et quels seuils ? ».
+- [ ] `name` de la page = « Étapes et données ».

docs/superpowers/specs/2026-06-04-page-etapes-seuils-design.md

@@ -0,0 +1,122 @@
+# Page `/etapes` — « Quelles données pour quelles étapes et quels seuils ? »
+
+Date : 2026-06-04
+Branche : `dev`
+
+## Objectif
+
+Créer une page pédagogique sur decp.info qui montre, sur un seul graphique, **quelles données sont publiées à chaque étape de la passation d'un marché public** et **à partir de quel seuil réglementaire** (en € HT).
+
+La page aide à comprendre l'écosystème des publications de données de la commande publique et à situer les DECP (le cœur de decp.info) parmi les autres sources.
+
+## Portée
+
+- Une page dédiée à l'URL `/etapes`.
+- Layout standard (bandeau de navigation global affiché en haut, comme toutes les pages).
+- **Non listée** dans la navbar pour l'instant (on ne sait pas encore comment la lier depuis le reste de l'app — elle n'est pas secrète).
+- **Référencée** dans le sitemap pour le SEO.
+- Graphique en **HTML/CSS statique** (pas de Plotly, pas de SVG, pas d'interactivité).
+- Pas de test automatisé spécifique (contenu statique) ; vérification visuelle via `python run.py`.
+
+Hors portée : tout lien entrant depuis la navbar ou d'autres pages, toute interactivité (survol, filtre), toute donnée dynamique.
+
+## Le graphique
+
+### Axes
+
+- **Axe Y** (de haut en bas) — étapes de la passation :
+  1. Programmation
+  2. Publicité (appel d'offres)
+  3. Attribution
+  4. Contrat — _vide_ (« aucune donnée publiée aujourd'hui »)
+  5. Paiement — _vide_ (« aucune donnée publiée aujourd'hui »)
+- **Axe X** — seuils réglementaires en € HT, **segmenté** (espacement égal entre seuils, pas linéaire, sinon tout serait écrasé entre 40 k€ et 5,4 M€). Marqueurs de colonnes :
+  - `0 €`
+  - `40 000 €` — seuil DECP
+  - `90 000 €` — seuil de publicité
+  - `140 000 € / 216 000 €` — seuils formalisés (UE)
+  - `5 404 000 €` — travaux (UE)
+
+### Barres (publications de données)
+
+Chaque barre est une bande horizontale colorée, positionnée sur sa ligne d'étape et couvrant la plage de seuils où la publication s'applique.
+
+| Publication                     | Étape(s)                                                      | Plage de seuils               | Note                                                                 |
+| ------------------------------- | ------------------------------------------------------------- | ----------------------------- | -------------------------------------------------------------------- |
+| **Approch**                     | Programmation                                                 | toute la largeur              | sourcing / préinformation, publication **non réglementaire**         |
+| **Journaux d'annonces légales** | Publicité                                                     | 90 000 € → seuil formalisé    | remplit exactement cette case                                        |
+| **BOAMP**                       | Publicité                                                     | ≥ 90 000 € (jusqu'à l'infini) | au-delà des seuils UE, publicité obligatoire au BOAMP **et** au JOUE |
+| **JOUE**                        | Publicité (avis de marché) + Attribution (avis d'attribution) | ≥ seuils formalisés           | deux barres, une par étape                                           |
+| **DECP**                        | Attribution                                                   | ≥ 40 000 € (jusqu'à l'infini) | données essentielles de la commande publique                         |
+
+### Légende
+
+Sous le graphique : une pastille de couleur + le nom complet pour chaque publication (Approch, Journaux d'annonces légales, BOAMP, JOUE, DECP).
+
+## Implémentation
+
+### Nouveau fichier `src/pages/etapes.py`
+
+Enregistrement de la page :
+
+```python
+register_page(
+    __name__,
+    path="/etapes",
+    title="Quelles données pour quelles étapes et quels seuils ? | decp.info",
+    name="Étapes et données",
+    description="À chaque étape d'un marché public (programmation, publicité, attribution), quelles données sont publiées et à partir de quel seuil : DECP, BOAMP, JOUE, journaux d'annonces légales, Approch.",
+    image_url=META_CONTENT["image_url"],
+)
+```
+
+Le `name="Étapes et données"` n'est pas dans la liste blanche de la navbar (`src/app.py:181`), la page reste donc hors navigation tout en étant accessible.
+
+`layout` = `html.Div(className="container", children=[...])` :
+
+1. `html.H2("Quelles données pour quelles étapes et quels seuils ?")`
+2. Paragraphe d'intro (`dcc.Markdown`) expliquant ce que montre le graphique.
+3. Le graphique (composants `html.Div` reproduisant la maquette v3, barres positionnées en `left`/`right` en `%`).
+4. La légende.
+5. Note de bas (`dcc.Markdown`) : axe X segmenté (non linéaire) ; Contrat et Paiement sans données ouvertes à ce jour.
+
+### Modification de `src/app.py`
+
+Ajouter `"/etapes"` à la liste des URLs du sitemap (`sitemap()`, ~ligne 73) :
+
+```python
+pages = [
+    "/",
+    "/observatoire",
+    "/tableau",
+    "/a-propos",
+    "/etapes",
+]
+```
+
+Aucune modification de la navbar.
+
+### CSS
+
+Bloc dédié dans `src/assets/css/` (fichier existant ou nouveau), avec classes préfixées (ex. `.etapes-chart`, `.etapes-lane`, `.etapes-bar`…) pour éviter toute collision.
+
+### Responsive — deux rendus
+
+Le graphique en grille n'est pas lisible sur écran portrait étroit (la vue d'ensemble est perdue). On rend donc **deux représentations des mêmes données**, basculées par media query (point de rupture ~768 px) :
+
+- **Desktop / tablette (≥ 768 px)** : le graphique en grille (maquette v3), enveloppé dans un conteneur `overflow-x:auto` + `min-width` pour les écrans intermédiaires. Le rendu mobile est masqué.
+- **Mobile (< 768 px)** : le graphique est masqué et remplacé par une **liste verticale par étape**. Chaque étape est un bloc qui liste ses publications, chacune avec sa pastille de couleur, son nom, et sa **plage de seuils en texte** (ex. « DECP — à partir de 40 000 € »). Les étapes Contrat/Paiement affichent « aucune donnée publiée aujourd'hui ».
+
+Pour éviter la duplication, les publications de chaque étape (libellé, couleur, texte de plage) sont décrites **une seule fois** dans une structure de données Python, consommée par le rendu mobile et la légende. Le graphique en grille garde son positionnement explicite (intrinsèquement spatial).
+
+## Vérification
+
+- `python run.py` puis ouvrir `/etapes` : le graphique s'affiche, fidèle à la maquette v3, avec le bandeau de navigation en haut.
+- `/etapes` **absente** de la navbar.
+- `/sitemap.xml` **contient** `/etapes`.
+- Sur fenêtre intermédiaire : défilement horizontal du graphique, pas d'écrasement.
+- Sur écran portrait étroit (< 768 px) : le graphique en grille est masqué, remplacé par la liste verticale par étape, lisible sans défilement horizontal.
+
+## Référence
+
+Maquette validée : `.superpowers/brainstorm/80498-1780599135/content/chart-concept-v3.html`.

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "decp.info"
 description = "Interface d'exploration et d'analyse des marchés publics français."
-version = "2.7.5"
+version = "2.7.9"
 requires-python = ">= 3.10"
 authors = [{ name = "Colin Maudry", email = "colin@colmo.tech" }]
 dependencies = [
@@ -21,6 +21,7 @@ dependencies = [
   "duckdb",
   "flask-caching",
   "pyarrow>=23.0.1",
+  "flask-cors>=6.0.2",
 ]
 
 [dependency-groups]
@@ -41,6 +42,6 @@ env = [
   "DATA_FILE_PARQUET_PATH=tests/test.parquet",
   "DEVELOPMENT=true",
   "REBUILD_DUCKDB=true",
-  "DATA_SCHEMA_PATH=/home/colin/git/decp-processing/dist/schema.json",
+  "DATA_SCHEMA_LOCAL=/home/colin/git/decp-processing/dist/schema.json",
 ]
 addopts = "-p no:warnings"

run.py

@@ -1,7 +1,10 @@
+from flask_cors import CORS
+
 from src.app import app
 
 # To use `gunicorn run:server` (prod)
 server = app.server
+CORS(server)
 
 # To use `python run.py` (dev)
 if __name__ == "__main__":

src/app.py

@@ -6,7 +6,7 @@ import pandas  # noqa: F401  # eager import: avoid plotly's lazy-import race acr
 import tomllib
 from dash import Dash, Input, Output, State, dcc, html, page_container, page_registry
 from dotenv import load_dotenv
-from flask import Response
+from flask import Flask, Response
 
 from src.utils import DEVELOPMENT
 from src.utils.cache import cache
@@ -27,12 +27,10 @@ META_TAGS = [
 if DEVELOPMENT:
     META_TAGS.append({"name": "robots", "content": "noindex"})
 
-app: Dash = Dash(
-    title="decp.info",
-    use_pages=True,
-    compress=True,
-    meta_tags=META_TAGS,
-)
+# Le cache doit être initialisé AVANT la construction de Dash : `use_pages=True`
+# importe les modules de pages pendant l'instanciation, et certains appellent des
+# fonctions memoizées (@cache.memoize) dès l'import (ex. tableau.py).
+server = Flask(__name__)
 
 cache_dir = os.getenv("CACHE_DIR", "/tmp/decp-cache")
 
@@ -40,7 +38,7 @@ if os.path.exists(cache_dir):
     rmtree(cache_dir)
 
 cache.init_app(
-    app.server,
+    server,
     config={
         "CACHE_TYPE": "FileSystemCache",
         "CACHE_DIR": cache_dir,
@@ -51,6 +49,14 @@ cache.init_app(
     },
 )
 
+app: Dash = Dash(
+    server=server,
+    title="decp.info",
+    use_pages=True,
+    compress=True,
+    meta_tags=META_TAGS,
+)
+
 
 # robots.txt
 @app.server.route("/robots.txt")
@@ -69,6 +75,7 @@ def sitemap():
         "/observatoire",
         "/tableau",
         "/a-propos",
+        "/etapes",
     ]
     xml = '<?xml version="1.0" encoding="UTF-8"?>\n'
     xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
@@ -145,7 +152,13 @@ navbar = dbc.Navbar(
                 style={"minWidth": "230px"},
             ),
             dbc.Nav(
-                children=[dcc.Markdown(os.getenv("ANNOUNCEMENTS"), id="announcements")],
+                children=[
+                    dcc.Markdown(
+                        os.getenv("ANNOUNCEMENTS"),
+                        id="announcements",
+                        dangerously_allow_html=True,
+                    ),
+                ],
                 style={
                     "maxWidth": "1200px",
                     "display": "inline-block",

src/assets/css/style.css

@@ -144,6 +144,10 @@ p.version > a {
   max-width: 900px;
 }
 
+#announcements p {
+  margin-bottom: 0.2rem;
+}
+
 .seeBorder {
   border: dotted 1px green;
 }
@@ -542,3 +546,218 @@ input[type="number"]::-webkit-inner-spin-button {
 input[type="number"] {
   -moz-appearance: textfield;
 }
+
+/* ===== Page /etapes : graphique données par étape et par seuil ===== */
+
+.etapes-chart-scroll {
+  overflow-x: auto;
+  margin: 1rem 0;
+}
+
+.etapes-chart {
+  min-width: 720px;
+  background: #fff;
+  border: 1px solid #d0d5dd;
+  border-radius: 8px;
+  overflow: hidden;
+  font-size: 13px;
+  display: grid;
+  grid-template-columns: 150px repeat(5, 1fr);
+}
+
+.etapes-corner {
+  border-bottom: 2px solid #344054;
+}
+
+.etapes-xhead {
+  grid-column: 2 / -1;
+  display: grid;
+  grid-template-columns: repeat(5, 1fr);
+  border-bottom: 2px solid #344054;
+}
+
+.etapes-xcell {
+  text-align: center;
+  padding: 6px 2px;
+  font-size: 11px;
+  color: #475467;
+  border-left: 1px dashed #d0d5dd;
+}
+
+.etapes-xcell strong {
+  display: block;
+  color: #101828;
+  font-size: 12px;
+}
+
+.etapes-stage {
+  padding: 14px 10px;
+  font-weight: 600;
+  color: #101828;
+  border-bottom: 1px solid #eaecf0;
+  display: flex;
+  align-items: center;
+}
+
+.etapes-stage small {
+  font-weight: 400;
+  color: #667085;
+}
+
+.etapes-lane {
+  grid-column: 2 / -1;
+  position: relative;
+  border-bottom: 1px solid #eaecf0;
+  min-height: 52px;
+}
+
+.etapes-segs {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  grid-template-columns: repeat(5, 1fr);
+}
+
+.etapes-segs > div {
+  border-left: 1px dashed #eaecf0;
+}
+
+.etapes-bar {
+  position: absolute;
+  top: 9px;
+  height: 32px;
+  border-radius: 6px;
+  color: #fff;
+  font-size: 11px;
+  font-weight: 600;
+  display: flex;
+  align-items: center;
+  padding: 0 10px;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.12);
+  white-space: nowrap;
+  overflow: hidden;
+  cursor: pointer;
+  transition: filter 0.15s, box-shadow 0.15s;
+}
+
+.etapes-bar:hover {
+  filter: brightness(1.12);
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.22);
+}
+
+.etapes-empty {
+  color: #98a2b3;
+  font-style: italic;
+  padding: 14px;
+  display: flex;
+  align-items: center;
+}
+
+.etapes-note {
+  margin-top: 8px;
+  color: #667085;
+  font-size: 13px;
+}
+
+/* --- Vue mobile (liste par étape) : masquée par défaut --- */
+
+.etapes-mobile {
+  display: none;
+  margin: 1rem 0;
+}
+
+.etapes-m-block {
+  border: 1px solid #d0d5dd;
+  border-radius: 8px;
+  margin-bottom: 12px;
+  overflow: hidden;
+}
+
+.etapes-m-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  background: #f9fafb;
+  border-bottom: 1px solid #eaecf0;
+}
+
+.etapes-m-stage {
+  margin: 0;
+  padding: 10px 12px;
+  font-size: 15px;
+  color: #101828;
+}
+
+.etapes-m-link {
+  background: none;
+  border: none;
+  color: #1570ef;
+  font-size: 12px;
+  font-weight: 600;
+  cursor: pointer;
+  padding: 0 12px;
+  white-space: nowrap;
+}
+
+.etapes-m-link:hover {
+  text-decoration: underline;
+}
+
+.etapes-m-item {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  padding: 8px 12px;
+  border-bottom: 1px solid #f2f4f7;
+  font-size: 13px;
+}
+
+.etapes-m-item:last-child {
+  border-bottom: none;
+}
+
+.etapes-m-item i {
+  width: 12px;
+  height: 12px;
+  border-radius: 3px;
+  flex: 0 0 auto;
+  position: relative;
+  top: 2px;
+}
+
+.etapes-m-label {
+  font-weight: 600;
+  color: #101828;
+}
+
+.etapes-m-seuil {
+  color: #667085;
+}
+
+.etapes-m-empty {
+  color: #98a2b3;
+  font-style: italic;
+}
+
+.etapes-detail {
+  margin: 1rem 0;
+  padding: 1rem 1.25rem;
+  border: 1px solid #d0d5dd;
+  border-radius: 8px;
+  background: #f9fafb;
+}
+
+.etapes-detail:empty {
+  display: none;
+}
+
+/* --- Bascule desktop / mobile au point de rupture 768 px --- */
+
+@media (max-width: 768px) {
+  .etapes-chart-scroll {
+    display: none;
+  }
+  .etapes-mobile {
+    display: block;
+  }
+}

src/db.py

@@ -8,27 +8,31 @@ import polars as pl
 import polars.selectors as cs
 from polars.exceptions import ComputeError
 
-from src.utils import logger
+from src.utils import get_last_modified, logger
 
 
-def should_rebuild(db_path: Path, parquet_path: Path) -> bool:
+def should_rebuild(db_path: Path, parquet_path: str) -> bool:
     db_path = Path(db_path)
-    parquet_path = Path(parquet_path)
     if not db_path.exists():
         return True
     dev = os.getenv("DEVELOPMENT", "False").lower() == "true"
     force = os.getenv("REBUILD_DUCKDB", "False").lower() == "true"
     if dev and not force:
         return False
-    return parquet_path.stat().st_mtime > db_path.stat().st_mtime
+    last_modified: float = get_last_modified(parquet_path)
+    return last_modified > db_path.stat().st_mtime
 
 
-def _load_source_frame(parquet_path: Path) -> pl.DataFrame:
+def _load_source_frame() -> pl.DataFrame:
     """Read the source parquet and apply the row-level transforms.
 
     Kept here (not in utils.py) so src.db has no dependency on utils.
     Mirrors the behavior previously in utils.get_decp_data().
     """
+
+    parquet_path: str = os.getenv("DATA_FILE_PARQUET_PATH", "")
+    if not (parquet_path.startswith("http")):
+        assert os.path.exists(parquet_path)
     try:
         lff: pl.LazyFrame = pl.scan_parquet(str(parquet_path))
     except ComputeError:
@@ -58,20 +62,21 @@ def _load_source_frame(parquet_path: Path) -> pl.DataFrame:
     return lff.collect()
 
 
-def build_database(db_path: Path, parquet_path: Path) -> None:
+def build_database(db_path: Path) -> None:
     """Build the DuckDB database atomically under an exclusive lock.
 
     Caller MUST hold the fcntl.flock on the .lock file.
     """
     db_path = Path(db_path)
-    parquet_path = Path(parquet_path)
     tmp_path = db_path.with_suffix(".duckdb.tmp")
     staging_parquet = db_path.with_suffix(".staging.parquet")
     if tmp_path.exists():
         tmp_path.unlink()
 
-    logger.info(f"Construction de la base DuckDB à partir de {parquet_path}...")
-    frame = _load_source_frame(parquet_path)
+    logger.info(
+        f"Construction de la base DuckDB à partir de {os.getenv('DATA_FILE_PARQUET_PATH', '')}..."
+    )
+    frame = _load_source_frame()
 
     # Write transformed frame as parquet so DuckDB can read it natively
     # (avoids pyarrow dependency for the Polars→DuckDB handoff)
@@ -111,13 +116,13 @@ def build_database(db_path: Path, parquet_path: Path) -> None:
 
 def _ensure_database() -> Path:
     db_path = Path(os.getenv("DUCKDB_PATH", "./decp.duckdb"))
-    parquet_path = Path(os.getenv("DATA_FILE_PARQUET_PATH"))
+    parquet_path = os.getenv("DATA_FILE_PARQUET_PATH", "")
     lock_path = db_path.with_suffix(".duckdb.lock")
 
     with open(lock_path, "w") as lock_fd:
         fcntl.flock(lock_fd, fcntl.LOCK_EX)
         if should_rebuild(db_path, parquet_path):
-            build_database(db_path, parquet_path)
+            build_database(db_path)
         else:
             logger.debug("Base de données déjà disponible et à jour.")
     return db_path

src/figures.py

@@ -11,8 +11,10 @@ import plotly.graph_objects as go
 import polars as pl
 from dash import dash_table, dcc, html
 from dash_extensions.javascript import Namespace
+from polars.exceptions import ColumnNotFoundError
 
 from src.db import schema
+from src.utils import logger
 from src.utils.data import DATA_SCHEMA, DEPARTEMENTS_GEOJSON
 from src.utils.table import add_links, format_number, setup_table_columns
 
@@ -173,39 +175,78 @@ def get_sources_tables(source_path) -> html.Div:
     return html.Div(children=datatable)
 
 
-def point_on_map(lat, lon):
-    lat = float(lat)
-    lon = float(lon)
+def point_on_map(lat, lon, departement_code=None):
+    """Fonction améliorée utilisant les codes départementaux pour la détection de région.
 
-    # Create a scatter mapbox or choropleth map
+    Args:
+        lat: Coordonnée de latitude
+        lon: Coordonnée de longitude
+        departement_code: Code du département (ex: '75', '971', etc.)
+
+    Returns:
+        html.Div contenant la carte, ou div vide si invalide
+    """
+    # Validation des coordonnées
+    try:
+        lat = float(lat)
+        lon = float(lon)
+    except (TypeError, ValueError):
+        return html.Div()  # Div vide pour les coordonnées invalides
+
+    # Vérification que les coordonnées sont valides
+    if not (-90 <= lat <= 90) or not (-180 <= lon <= 180):
+        return html.Div()
+
+    # Si aucun code département n'est fourni, retourner une div vide
+    if not departement_code:
+        return html.Div()
+
+    # Détermination de la région en utilisant le code département
+    # Logique identique à get_geographic_maps
+    if departement_code in ["971", "972", "973", "974", "976"]:
+        region_key = departement_code  # Département d'outre-mer
+    elif len(departement_code) == 2:  # Département métropolitain
+        region_key = "Hexagone"
+    else:
+        return html.Div()  # Format de code département invalide
+
+    # Paramètres de carte par région (réutilisés de get_geographic_maps)
+    regions = {
+        "Hexagone": {"center": [46.6, 2.2], "zoom": 5},
+        "971": {"center": [16.23, -61.55], "zoom": 9},  # Guadeloupe
+        "972": {"center": [14.64, -61.02], "zoom": 10},  # Martinique
+        "973": {"center": [3.93, -53.12], "zoom": 7},  # Guyane
+        "974": {"center": [-21.11, 55.53], "zoom": 9},  # La Réunion
+        "976": {"center": [-12.82, 45.16], "zoom": 10},  # Mayotte
+    }
+
+    settings = regions.get(region_key, regions["Hexagone"])
+
+    # Création de la carte
     fig = px.scatter_map(
-        lat=[lat], lon=[lon], height=300, width=400, color=[1], size=[1]
+        lat=[lat],
+        lon=[lon],
+        height=300,
+        # width=400,
+        color=[1],
+        zoom=settings["zoom"],
     )
 
-    fig.update_coloraxes(showscale=False)
+    fig.update_traces(marker=dict(size=10))
 
-    # Set map style (you can use 'open-street-map', 'carto-positron', etc.)
+    # Configuration de la carte (interactive - zoomable)
     fig.update_layout(
-        mapbox_style="light",  # Light, clean background
+        map_style="light",  # Fond de carte clair
         margin={"r": 0, "t": 0, "l": 0, "b": 0},
+        mapbox_center={"lat": settings["center"][0], "lon": settings["center"][1]},
+        mapbox_zoom=settings["zoom"],
+        coloraxis_showscale=False,
     )
 
-    # Optionally, center the map on France
-    fig.update_geos(
-        center=dict(lat=46.603354, lon=1.888334),  # Center of France
-        lataxis_range=[41, 51.5],  # Latitude range for France
-        lonaxis_range=[-5, 10],  # Longitude range for France
+    return html.Div(
+        dcc.Graph(figure=fig, config={"displayModeBar": False}),
     )
 
-    # But scatter_mapbox doesn't use geos, so better to control via zoom/center manually
-    # Let's reset and use proper centering in scatter_mapbox instead:
-
-    fig.update_layout(map_center={"lat": 46.6, "lon": 1.89}, map_zoom=4)
-
-    graph = dcc.Graph(id="map", figure=fig)
-    graph = html.Div(style={"width": "400px"})
-    return graph
-
 
 class DataTable(dash_table.DataTable):
     def __init__(
@@ -833,7 +874,11 @@ def get_top_org_table(data, org_type: str, extra_columns: list, filters: bool =
     lff = lff.cast(pl.String)
     lff = lff.fill_null("")
 
-    dff: pl.DataFrame = lff.collect(engine="streaming")
+    try:
+        dff: pl.DataFrame = lff.collect(engine="streaming")
+    except ColumnNotFoundError:
+        logger.warning(f"get_top_org_table: column not found. {lff.collect_schema()}")
+        return html.Div()
 
     if dff.height == 0:
         return html.Div()

src/pages/a-propos.py

@@ -87,14 +87,7 @@ Vous pouvez consommer les données qui alimentent decp.info
                         dcc.Markdown(
                             """Les données visibles sur ce site proviennent exclusivement de la publication de données ouvertes par les acheteurs publics ou en leur nom, régie par [l'arrêté du 22 décembre 2022](https://www.legifrance.gouv.fr/jorf/id/JORFTEXT000046850496). Leur qualité est donc principalement liée à la qualité de leur saisie par les agents publics, parfois peu aidé·es par la qualité des outils à leur disposition. Je pense que l'analyse de marchés individuels et le comptage de marchés sur des critères autres que financiers sont plutôt fiables. En revanche, certains montants de marché estimés à des valeurs farfelues ([1 euro](https://decp.info/marches/432766947000192025S01301), [1 milliard](https://decp.info/marches/2459004280001320210000000271)) faussent les calculs par aggrégation (sommes, moyennes, médianes) et donc la production de statistiques financières fiables. Acheteurs, acheteuses : s'il vous plaît, essayez d'estimer les montants des marchés publics attribués de manière plus précise.
 
-Quant à l'exhaustivité, je consolide toutes les sources de données exploitables que j'ai pu identifier (voir [ci-dessous](/a-propos#sources). Certains profils d'acheteurs ne publient pas leurs données malgré l'obligation réglementaire :
-
-- klekoon.fr (ils y travaillent)
-- safetender.com (Omnikles)
-
-**marches-publics.info** (AWS) publie ses données de manière assez sporadique depuis début 2023. Compte tenu de son poids dans le secteur, c'est assez dommageable pour la transparence des marchés publics.
-
-Au milieu de ces mauvaises nouvelles, je tiens à souligner la belle continuité de la publication par la DGFiP des données des marchés publics remontées via le [protocole PES](https://www.collectivites-locales.gouv.fr/finances-locales/le-protocole-dechange-standard-pes). Merci à leurs équipes."""
+Quant à l'exhaustivité, je consolide toutes les sources de données exploitables que j'ai pu identifier (voir [ci-dessous](/bin.usr-is-merged/)). Je tiens à souligner la belle continuité de la publication par la DGFiP des données des marchés publics remontées via le [protocole PES](https://www.collectivites-locales.gouv.fr/finances-locales/le-protocole-dechange-standard-pes). Merci à leurs équipes."""
                         ),
                         html.H4("Sources de données ", id="sources"),
                         get_sources_tables(os.getenv("SOURCE_STATS_CSV_PATH")),

src/pages/acheteur.py

@@ -257,8 +257,15 @@ def update_acheteur_infos(url):
     if data_etablissement:
         data_etablissement = data_etablissement[0]
 
+        # Extraction du code département à partir du code postal
+        code_postal = data_etablissement.get("code_postal", "")
+        departement_code = code_postal[:2] if code_postal else None
+
+        # Création de la carte avec le code département pour un centrage approprié
         acheteur_map = point_on_map(
-            data_etablissement["latitude"], data_etablissement["longitude"]
+            data_etablissement["latitude"],
+            data_etablissement["longitude"],
+            departement_code,
         )
         code_departement, nom_departement, nom_region = get_departement_region(
             data_etablissement["code_postal"]

src/pages/arbre/liste_marches_org.py

@@ -2,6 +2,7 @@ import polars as pl
 from dash import Input, Output, callback, dcc, html, register_page
 
 from src.db import get_cursor
+from src.utils import logger
 from src.utils.data import DF_ACHETEURS, DF_TITULAIRES
 
 NAME = "Liste des marchés publics"
@@ -27,9 +28,12 @@ def make_org_nom_verbe(org_type, org_id) -> tuple:
 
 
 def get_title(code, org_type, org_id):
-    org_nom, verbe = make_org_nom_verbe(org_type, org_id)
-
-    return f"Marchés publics {verbe} par {org_nom} | decp.info"
+    if org_type:
+        org_nom, verbe = make_org_nom_verbe(org_type, org_id)
+        return f"Marchés publics {verbe} par {org_nom} | decp.info"
+    else:
+        logger.warning(f"Pas de org_type pour org_id: {org_id}")
+        return "Marchés publics | decp.info"
 
 
 def get_description(code, org_type, org_id):

src/pages/etapes.py

@@ -0,0 +1,297 @@
+from dash import Input, Output, State, callback, ctx, dcc, html, register_page
+
+from src.utils.seo import META_CONTENT
+
+NAME = "Quelles données pour quelles étapes et quels seuils dans les marchés publics ?"
+
+register_page(
+    __name__,
+    path="/etapes",
+    title=f"{NAME} | decp.info",
+    name="Étapes et données",
+    description=(
+        "À chaque étape d'un marché public (programmation, publicité, "
+        "attribution), quelles données sont publiées et à partir de quel "
+        "seuil : DECP, BOAMP, JOUE, journaux d'annonces légales, Approch."
+    ),
+    image_url=META_CONTENT["image_url"],
+)
+
+# Contenu des fiches — à rédiger en Markdown.
+# Clés barres : "bar-approch", "bar-jal", "bar-boamp", "bar-joue-marche",
+#               "bar-decp", "bar-joue-attribution"
+# Clés étapes (mobile) : "stage-programmation", "stage-publicite",
+#                         "stage-attribution", "stage-contrat", "stage-paiement"
+ALL_CONTENT: dict[str, str | None] = {
+    "bar-approch": None,
+    "bar-jal": None,
+    "bar-boamp": None,
+    "bar-joue-marche": None,
+    "bar-decp": None,
+    "bar-joue-attribution": None,
+    "stage-programmation": None,
+    "stage-publicite": None,
+    "stage-attribution": None,
+    "stage-contrat": None,
+    "stage-paiement": None,
+}
+
+_BAR_IDS = [
+    "bar-approch",
+    "bar-jal",
+    "bar-boamp",
+    "bar-joue-marche",
+    "bar-decp",
+    "bar-joue-attribution",
+]
+_STAGE_IDS = [
+    "stage-programmation",
+    "stage-publicite",
+    "stage-attribution",
+    "stage-contrat",
+    "stage-paiement",
+]
+
+
+def _lane(*bars):
+    """Une ligne d'étape : fond segmenté en 5 + barres positionnées."""
+    return html.Div(
+        className="etapes-lane",
+        children=[
+            html.Div(
+                className="etapes-segs",
+                children=[html.Div() for _ in range(5)],
+            ),
+            *bars,
+        ],
+    )
+
+
+def _bar(label, color, style, bar_id=None):
+    base = {"backgroundColor": color}
+    base.update(style)
+    props = {"className": "etapes-bar", "style": base}
+    if bar_id is not None:
+        props["id"] = bar_id
+        props["n_clicks"] = 0
+    return html.Div(label, **props)
+
+
+def build_chart():
+    return html.Div(
+        className="etapes-chart-scroll",
+        children=html.Div(
+            className="etapes-chart",
+            children=[
+                # En-tête : coin vide + 5 marqueurs de seuils
+                html.Div(className="etapes-corner"),
+                html.Div(
+                    className="etapes-xhead",
+                    children=[
+                        html.Div("0 €", className="etapes-xcell"),
+                        html.Div(
+                            [html.Strong("40 000 €"), "seuil DECP"],
+                            className="etapes-xcell",
+                        ),
+                        html.Div(
+                            [html.Strong("90 000 €"), "publicité"],
+                            className="etapes-xcell",
+                        ),
+                        html.Div(
+                            [html.Strong("140 k€ / 216 k€"), "seuils formalisés (UE)"],
+                            className="etapes-xcell",
+                        ),
+                        html.Div(
+                            [html.Strong("5,404 M€"), "travaux (UE)"],
+                            className="etapes-xcell",
+                        ),
+                    ],
+                ),
+                # Programmation
+                html.Div("Programmation", className="etapes-stage"),
+                _lane(
+                    _bar(
+                        "Approch — sourcing / préinformation (non réglementaire)",
+                        "#7c5cff",
+                        {"left": "2%", "right": "2%"},
+                        bar_id="bar-approch",
+                    ),
+                ),
+                # Publicité (appel d'offres)
+                html.Div(["Publicité"], className="etapes-stage"),
+                _lane(
+                    _bar(
+                        "JAL",
+                        "#f79009",
+                        {"left": "40%", "right": "40%", "top": "6px", "height": "20px"},
+                        bar_id="bar-jal",
+                    ),
+                    _bar(
+                        "BOAMP",
+                        "#1570ef",
+                        {"left": "40%", "right": "2%", "top": "28px", "height": "20px"},
+                        bar_id="bar-boamp",
+                    ),
+                    _bar(
+                        "JOUE — avis de marché",
+                        "#0e9384",
+                        {"left": "60%", "right": "2%", "top": "6px", "height": "20px"},
+                        bar_id="bar-joue-marche",
+                    ),
+                ),
+                # Attribution
+                html.Div("Attribution", className="etapes-stage"),
+                _lane(
+                    _bar(
+                        "DECP — données essentielles",
+                        "#12b76a",
+                        {"left": "20%", "right": "2%", "top": "6px", "height": "20px"},
+                        bar_id="bar-decp",
+                    ),
+                    _bar(
+                        "JOUE — avis d'attribution",
+                        "#0e9384",
+                        {"left": "60%", "right": "2%", "top": "28px", "height": "20px"},
+                        bar_id="bar-joue-attribution",
+                    ),
+                ),
+                # Contrat (vide)
+                html.Div("Contrat", className="etapes-stage"),
+                html.Div(
+                    "— aucune donnée publiée aujourd'hui —",
+                    className="etapes-lane etapes-empty",
+                ),
+                # Paiement (vide)
+                html.Div("Paiement", className="etapes-stage"),
+                html.Div(
+                    "— aucune donnée publiée aujourd'hui —",
+                    className="etapes-lane etapes-empty",
+                ),
+            ],
+        ),
+    )
+
+
+# Données par étape, partagées par la vue mobile.
+# Chaque tuple : (libellé étape, id CSS, [(libellé, couleur, plage seuils)]).
+STAGES_MOBILE = [
+    (
+        "Programmation",
+        "stage-programmation",
+        [
+            ("Approch", "#7c5cff", "tous montants — publication non réglementaire"),
+        ],
+    ),
+    (
+        "Publicité (appel d'offres)",
+        "stage-publicite",
+        [
+            ("JAL", "#f79009", "de 90 000 € au seuil formalisé"),
+            ("BOAMP", "#1570ef", "à partir de 90 000 €"),
+            (
+                "JOUE — avis de marché",
+                "#0e9384",
+                "à partir des seuils formalisés (140 k€ / 216 k€)",
+            ),
+        ],
+    ),
+    (
+        "Attribution",
+        "stage-attribution",
+        [
+            ("DECP — données essentielles", "#12b76a", "à partir de 40 000 €"),
+            ("JOUE — avis d'attribution", "#0e9384", "à partir des seuils formalisés"),
+        ],
+    ),
+    ("Contrat", "stage-contrat", []),
+    ("Paiement", "stage-paiement", []),
+]
+
+
+def build_mobile():
+    blocks = []
+    for stage, stage_id, items in STAGES_MOBILE:
+        if items:
+            children = [
+                html.Div(
+                    [
+                        html.I(style={"backgroundColor": color}),
+                        html.Span(label, className="etapes-m-label"),
+                        html.Span(seuil, className="etapes-m-seuil"),
+                    ],
+                    className="etapes-m-item",
+                )
+                for label, color, seuil in items
+            ]
+        else:
+            children = [
+                html.Div(
+                    "aucune donnée publiée aujourd'hui",
+                    className="etapes-m-item etapes-m-empty",
+                )
+            ]
+        blocks.append(
+            html.Div(
+                [
+                    html.Div(
+                        [
+                            html.H4(stage, className="etapes-m-stage"),
+                            html.Button(
+                                "Voir fiche →",
+                                id=stage_id,
+                                n_clicks=0,
+                                className="etapes-m-link",
+                            ),
+                        ],
+                        className="etapes-m-header",
+                    ),
+                    *children,
+                ],
+                className="etapes-m-block",
+            )
+        )
+    return html.Div(blocks, className="etapes-mobile")
+
+
+layout = html.Div(
+    className="container",
+    children=[
+        html.H2(NAME),
+        dcc.Markdown(
+            "Un marché public passe par plusieurs étapes. À chacune, des "
+            "données peuvent être publiées — selon le montant du marché et "
+            "des obligations réglementaires. Ce graphique situe les "
+            "principales publications de données par **étape** (de haut en "
+            "bas) et par **seuil** (de gauche à droite, en euros hors taxes)."
+        ),
+        build_chart(),
+        build_mobile(),
+        dcc.Store(id="etapes-selected", data=None),
+        html.Div(id="etapes-detail", className="etapes-detail"),
+        dcc.Markdown(
+            "**À noter :** l'axe horizontal n'est pas linéaire — les seuils "
+            "sont espacés régulièrement pour rester lisibles. Les étapes "
+            "*Contrat* et *Paiement* n'ont aujourd'hui aucune donnée publiée "
+            "en open data.",
+            className="etapes-note",
+        ),
+    ],
+)
+
+
+@callback(
+    Output("etapes-detail", "children"),
+    Output("etapes-selected", "data"),
+    [Input(id_, "n_clicks") for id_ in _BAR_IDS + _STAGE_IDS],
+    State("etapes-selected", "data"),
+    prevent_initial_call=True,
+)
+def _show_detail(*args):
+    current = args[-1]
+    triggered = ctx.triggered_id
+    if triggered == current:
+        return None, None
+    content = ALL_CONTENT.get(triggered)
+    if content is None:
+        return dcc.Markdown(f"*Fiche en cours de rédaction.* {triggered}"), triggered
+    return dcc.Markdown(content), triggered

src/pages/marche.py

@@ -109,7 +109,7 @@ def update_marche_info(marche, titulaires):
         column_object = DATA_SCHEMA.get(col)
         column_name = column_object.get("title") if column_object else col
 
-        if marche[col]:
+        if marche and col in marche:
             if col == "acheteur_nom":
                 value = html.A(
                     href=f"/acheteurs/{marche['acheteur_id']}",
@@ -134,6 +134,7 @@ def update_marche_info(marche, titulaires):
                     "considerationsSociales",
                     "considerationsEnvironnementales",
                 ]
+                and col in marche
                 and "," in marche[col]
             ):
                 col_values = marche[col].split(", ")
@@ -243,7 +244,7 @@ def get_marche_jsonld(marche, titulaires) -> str:
                 titulaire.get("titulaire_id"),
                 org_name=titulaire.get("titulaire_nom"),
                 org_type="titulaire",
-                type_org_id=titulaire.get("titulaire_typeIdentifiant"),
+                type_org_id=titulaire.get("titulaire_typeIdentifiant", "SIRET"),
             ),
             "orderedItem": {
                 "@type": type_order,

src/pages/observatoire.py

@@ -824,6 +824,9 @@ def toggle_montant_modal(n_triggers, _close):
     prevent_initial_call=False,
 )
 def add_organization_name_in_title(acheteur_id, titulaire_id):
+    acheteur_id = acheteur_id.replace(" ", "") if acheteur_id else None
+    titulaire_id = titulaire_id.replace(" ", "") if titulaire_id else None
+
     def lookup_nom(df_org, id_col, nom_col, org_id):
         match = df_org.filter(pl.col(id_col) == org_id)
         return match[nom_col].item(0) if match.height >= 1 else None

src/pages/tableau.py

@@ -21,7 +21,7 @@ from dash import (
 
 from src.db import query_marches, schema
 from src.figures import DataTable, make_column_picker
-from src.utils import logger
+from src.utils import get_last_modified, logger
 from src.utils.seo import META_CONTENT
 from src.utils.table import (
     COLUMNS,
@@ -33,7 +33,7 @@ from src.utils.table import (
 )
 from src.utils.tracking import track_search
 
-update_date_timestamp = os.path.getmtime(os.getenv("DATA_FILE_PARQUET_PATH"))
+update_date_timestamp = get_last_modified(os.getenv("DATA_FILE_PARQUET_PATH", ""))
 update_date = datetime.fromtimestamp(update_date_timestamp).strftime("%d/%m/%Y")
 update_date_iso = datetime.fromtimestamp(update_date_timestamp).isoformat()
 

src/pages/titulaire.py

@@ -263,8 +263,15 @@ def update_titulaire_infos(url):
     if data_etablissement:
         data_etablissement = data_etablissement[0]
 
+        # Extraction du code département à partir du code postal
+        code_postal = data_etablissement.get("code_postal", "")
+        departement_code = code_postal[:2] if code_postal else None
+
+        # Création de la carte avec le code département pour un centrage approprié
         titulaire_map = point_on_map(
-            data_etablissement["latitude"], data_etablissement["longitude"]
+            data_etablissement["latitude"],
+            data_etablissement["longitude"],
+            departement_code,
         )
         code_departement, nom_departement, nom_region = get_departement_region(
             data_etablissement["code_postal"]

src/utils/__init__.py

@@ -1,5 +1,29 @@
 import logging
 import os
+from datetime import datetime
+from pathlib import Path
+
+import httpx
+
+from src.utils.cache import cache
+
+
+@cache.memoize()
+def get_last_modified(parquet_path: str) -> float:
+    logger.info("Récupération de la date de modification des données...")
+    logging.getLogger("httpx").setLevel("WARNING")
+    if parquet_path.startswith("http"):
+        last_modified = httpx.head(
+            url=parquet_path,
+            follow_redirects=True,
+        ).headers["last-modified"]
+        last_modified = datetime.strptime(last_modified, "%a, %d %b %Y %X %Z").strftime(
+            "%s"
+        )
+        return float(last_modified)
+    parquet_local_path = Path(parquet_path)
+    return parquet_local_path.stat().st_mtime
+
 
 logging.basicConfig(
     format="%(asctime)s %(levelname)-8s %(message)s",

src/utils/data.py

@@ -2,7 +2,9 @@ import json
 import logging
 import os
 from collections import OrderedDict
+from pathlib import Path
 
+import httpx
 import polars as pl
 from httpx import HTTPError, get
 
@@ -12,7 +14,7 @@ from src.utils import logger
 logging.getLogger("httpx").setLevel("WARNING")
 
 
-def get_annuaire_data(siret: str) -> dict:
+def get_annuaire_data(siret: str) -> dict | None:
     url = f"https://recherche-entreprises.api.gouv.fr/search?q={siret}"
     try:
         response = get(url).raise_for_status()
@@ -51,28 +53,39 @@ def get_departements_geojson() -> dict:
     return geojson
 
 
-def get_departement_region(code_postal):
-    if code_postal > "97000":
-        code_departement = code_postal[:3]
-    else:
-        code_departement = code_postal[:2]
-    nom_departement = DEPARTEMENTS[code_departement]["departement"]
-    nom_region = DEPARTEMENTS[code_departement]["region"]
-    return code_departement, nom_departement, nom_region
+def get_departement_region(code_postal: str | None):
+    if code_postal:
+        if code_postal > "97000":
+            code_departement = code_postal[:3]
+        else:
+            code_departement = code_postal[:2]
+        nom_departement = DEPARTEMENTS[code_departement]["departement"]
+        nom_region = DEPARTEMENTS[code_departement]["region"]
+        return code_departement, nom_departement, nom_region
+    return "", "", ""
 
 
 def get_data_schema() -> dict:
     # Récupération du schéma des données tabulaires
-    path = os.getenv("DATA_SCHEMA_PATH")
-    if path.startswith("http"):
-        original_schema: dict = get(
-            os.getenv("DATA_SCHEMA_PATH"), follow_redirects=True
-        ).json()
-    elif os.path.exists(path):
-        with open(path) as f:
+    url = os.getenv("DATA_SCHEMA_PATH")
+    local_path = Path(os.getenv("DATA_SCHEMA_LOCAL", ""))
+
+    original_schema = {}
+    if url:
+        try:
+            original_schema: dict = get(url, follow_redirects=True).json()
+        except (
+            httpx.ReadTimeout,
+            httpx.ReadError,
+            httpx.ConnectError,
+            httpx.ConnectTimeout,
+        ):
+            logger.error(f"Erreur HTTP lors de la récupération du schéma ({url})")
+
+    if os.path.exists(local_path) and original_schema == {}:
+        with open(local_path) as f:
             original_schema: dict = json.load(f)
-    else:
-        raise Exception(f"Chemin vers le schéma invalide: {path}")
+        logger.info(f"Utilisation du schéma local ({local_path})")
 
     new_schema = OrderedDict()
 

src/utils/seo.py

@@ -7,6 +7,8 @@ def make_org_jsonld(org_id, org_type, org_name=None, type_org_id="SIRET") -> dic
     address = None
     if type_org_id.lower() == "siret" and len(org_id) == 14:
         annuaire_data = get_annuaire_data(org_id)
+        if not annuaire_data:
+            return {}
         annuaire_address = annuaire_data["matching_etablissements"][0]
         code_postal = annuaire_address["code_postal"]
         commune = annuaire_address["libelle_commune"]

src/utils/table.py

@@ -154,6 +154,8 @@ def normalize_sort_by(sort_by) -> tuple:
 
 
 def format_number(number) -> str:
+    if not number:
+        return ""
     number = "{:,}".format(number).replace(",", " ")
     return number
 

src/utils/table_sql.py

@@ -57,10 +57,18 @@ def filter_query_to_sql(filter_query: str, schema: pl.Schema) -> tuple[str, list
         value = raw_value.strip('"')
 
         if operator == "contains":
-            where_clause, param_list = tokenize_text_filter(col_name, value)
+            if col_is_date:
+                target = f"CAST({quoted_col} AS VARCHAR)"
+
+            if col_name in ("acheteur_id", "titulaire_id"):
+                value = value.replace(" ", "")
+            where_clause, param_list = tokenize_text_filter(
+                col_name, value, col_is_date
+            )
             clauses.append(where_clause)
             params.extend(param_list)
             logger.debug(params)
+            continue
 
         elif operator in (">", "<"):
             target = f"CAST({quoted_col} AS VARCHAR)" if col_is_date else quoted_col
@@ -129,6 +137,7 @@ def dashboard_filters_to_sql(
         params.append(datetime.now() - timedelta(days=365))
 
     if dashboard_acheteur_id:
+        dashboard_acheteur_id = dashboard_acheteur_id.replace(" ", "")
         clauses.append('"acheteur_id" LIKE ?')
         params.append(f"%{dashboard_acheteur_id}%")
     else:
@@ -141,6 +150,7 @@ def dashboard_filters_to_sql(
             params.extend(dashboard_acheteur_departement_code)
 
     if dashboard_titulaire_id:
+        dashboard_titulaire_id = dashboard_titulaire_id.replace(" ", "")
         clauses.append('"titulaire_id" LIKE ?')
         params.append(f"%{dashboard_titulaire_id}%")
     else:
@@ -203,15 +213,22 @@ def dashboard_filters_to_sql(
     return " AND ".join(clauses), params
 
 
-def tokenize_text_filter(column: str, text: str) -> tuple[str, list]:
+def tokenize_text_filter(
+    column: str, text: str, col_is_date: bool = False
+) -> tuple[str, list]:
     terms = text.split()
+    # si col_is_date alors le deuxième doit être casté en VARCHAR
+    if col_is_date:
+        quoted_col = f'CAST("{column}" AS VARCHAR)'
+    else:
+        quoted_col = f'"{column}"'
 
-    conditions = [f'"{column}" IS NOT NULL', f"\"{column}\" <> ''"]
+    conditions = [f'"{column}" IS NOT NULL', f"{quoted_col} <> ''"]
 
     params = []
 
     for term in terms:
-        conditions.append(f'"{column}" ILIKE ?')
+        conditions.append(f"{quoted_col} ILIKE ?")
 
         if term.startswith("*") or term.endswith("*"):
             params.append(term.replace("*", "%"))

tests/test_main.py

@@ -292,7 +292,7 @@ def test_011_observatoire_multi_param_url(dash_duo: DashComposite):
     )
 
 
-def test_get_distance_histogram_returns_graph():
+def test_012_get_distance_histogram_returns_graph():
     import polars as pl
     from dash import dcc
 
@@ -303,7 +303,7 @@ def test_get_distance_histogram_returns_graph():
     assert isinstance(result, dcc.Graph)
 
 
-def test_get_distance_histogram_handles_nulls():
+def test_013_get_distance_histogram_handles_nulls():
     import polars as pl
     from dash import dcc
 
@@ -314,7 +314,7 @@ def test_get_distance_histogram_handles_nulls():
     assert isinstance(result, dcc.Graph)
 
 
-def test_get_distance_histogram_all_nulls():
+def test_014_get_distance_histogram_all_nulls():
     import polars as pl
     from dash import dcc
 
@@ -322,4 +322,23 @@ def test_get_distance_histogram_all_nulls():
 
     lff = pl.LazyFrame({"titulaire_distance": pl.Series([], dtype=pl.Int64)})
     result = get_distance_histogram(lff)
+
     assert isinstance(result, dcc.Graph)
+
+
+def test_015_tableau_filter_date(dash_duo: DashComposite):
+    from src.app import app
+
+    dash_duo.start_server(app)
+    dash_duo.wait_for_text_to_equal(".logo > h1", "decp.info", timeout=4)
+
+    for page in ["tableau", "acheteurs/123", "titulaires/345"]:
+        dash_duo.wait_for_page(f"{dash_duo.server_url}/{page}")
+        filter_input = '.marches_table th[data-dash-column="dateNotification"] input'
+        filter_cell_result = '.marches_table td[data-dash-column="dateNotification"] p'
+        dash_duo.wait_for_element(filter_input, timeout=2)
+        _filter_input: WebElement = dash_duo.find_element(filter_input)
+        _filter_input.send_keys("3333")  # a dateNotification that doesn't exist
+        _filter_input.send_keys(Keys.ENTER)
+        _filter_result: list[WebElement] = dash_duo.find_elements(filter_cell_result)
+        assert len(_filter_result) == 0, f"Page : {page}"