Géoplateforme – Validation (plugin QGIS)

Plugin QGIS pour l'API Validation de la Géoplateforme : téléverser une couche ou un fichier, lancer une validation, suivre son état, récupérer les résultats (rapport CSV, source, données normalisées) et les logs, avec gestion de l'authentification via le gestionnaire QGIS (OAuth2, Basic, PKI...).

Sommaire

• Fonctionnalités
• Référentiels
• Installation
• Utilisation
• Architecture
• Pourquoi une réécriture ?
• Développement

Fonctionnalités

• Validation : téléversement d'une couche du projet, d'un fichier vecteur (converti en GeoPackage) ou d'une archive ZIP existante, puis lancement de la validation (paramètres SRS, normalize, max-errors, encoding, plugins, extra, rétention).
• Suivi des validations : liste filtrable (statut, jeu de données), téléchargement des résultats — politique stricte : rapport CSV, source et fichier normalisé ne sont proposés que si status == SUCCESS — et des logs (disponibles quel que soit le statut).
• Suppression des données d'une validation (source + normalisé), le rapport restant consultable, conformément au comportement documenté de l'API.
• Catalogue de référentiels : un modèle intégré pour tester immédiatement, des entrées personnalisées, et le catalogue complet publié par schema.data.gouv.fr (voir ci-dessous).
• Tout est aussi disponible comme algorithmes de la boîte à outils Processing (Géoplateforme – Validateur / Géoplateforme – Outils), chaînables dans un modèle ou un script.

Référentiels

L'API Validation valide un jeu de données par rapport à un référentiel (schéma JSON décrivant les règles attendues). Ces référentiels ne sont pas hébergés par la Géoplateforme elle-même : ils proviennent du registre national schema.data.gouv.fr, et plus précisément de son index public :

https://schema.data.gouv.fr/schemas/schemas.json

⚠️ Tous les schémas référencés sur schema.data.gouv.fr ne sont pas nécessairement compatibles avec l'API Validation (seuls les schémas dont l'URL pointe vers un fichier .json explicite sont retenus par le plugin). Un référentiel d'exemple (CNIG PCRS v2.0) est intégré au plugin pour permettre un premier essai sans dépendre de la disponibilité du catalogue distant.

L'onglet Référentiels permet de :

• rafraîchir le catalogue depuis schema.data.gouv.fr ;
• ajouter des entrées personnalisées (URL de modèle JSON connue par ailleurs, non répertoriée sur schema.data.gouv.fr) ;
• consulter nom, titre, type, mandataire, versions et statut de chaque référentiel.

Installation

Prérequis : QGIS ≥ 3.34.

1. Récupérez l'archive dist/gpf_validation-<version>.zip (voir Développement pour la générer vous-même), ou clonez ce dépôt.
2. Dans QGIS : Extensions ▸ Installer/Gérer les extensions ▸ Installer à partir d'un ZIP, puis sélectionnez l'archive.
   • Alternative manuelle : copiez le dossier gpf_validation/ dans le répertoire des plugins de votre profil QGIS :
     • Windows : %APPDATA%\QGIS\QGIS3\profiles\default\python\plugins\
     • Linux : ~/.local/share/QGIS/QGIS3/profiles/default/python/plugins/
     • macOS : ~/Library/Application Support/QGIS/QGIS3/profiles/default/python/plugins/
3. Activez le plugin dans Extensions ▸ Installer/Gérer les extensions ▸ Installées.

Utilisation

1. Onglet Paramètres : vérifiez l'URL de l'API (par défaut https://data.geopf.fr/validation/api) et sélectionnez une configuration d'authentification (authcfg), créée au préalable dans QGIS ▸ Préférences ▸ Authentification (ou fournie par le plugin Géoplateforme officiel).
2. Onglet Référentiels (optionnel) : rafraîchissez le catalogue ou ajoutez vos propres référentiels.
3. Onglet Validation : choisissez la source (couches du projet ou fichiers locaux), cochez les éléments à envoyer, sélectionnez un référentiel, ajustez les paramètres, puis cliquez sur Téléverser et lancer la validation. L'envoi s'exécute en arrière-plan : QGIS reste utilisable pendant le transfert.
4. Onglet Validations : listez, filtrez, téléchargez les résultats (si SUCCESS) ou les logs (quel que soit le statut), et supprimez les données d'une validation si besoin.

Architecture

gpf_validation/
├── __init__.py            # classFactory (point d'entrée QGIS)
├── plugin.py               # cycle de vie (initGui/unload), action de menu
├── metadata.txt
├── resources/icon.png
├── core/                    # logique métier pure, réutilisée partout
│   ├── constants.py          # URLs par défaut, clés de réglages, valeurs par défaut
│   ├── exceptions.py         # hiérarchie d'erreurs (GpfValidationError, ApiRequestError...)
│   ├── models.py              # Referentiel, ValidationSummary (dataclasses, sans Qt)
│   ├── urls.py                 # construction des URLs/payloads (sans Qt, testable)
│   ├── settings.py             # façade typée sur QgsSettings
│   ├── api_client.py           # ValidationApiClient : point d'entrée unique vers l'API
│   ├── referentiel_catalog.py  # récupération/parsing du catalogue schema.data.gouv.fr
│   └── export.py               # conversion couche/fichier vecteur → GeoPackage zippé
├── network/
│   └── http_client.py          # unique client HTTP synchrone (GET/DELETE/JSON/multipart)
├── processing_provider/
│   ├── provider.py              # enregistrement explicite des algorithmes
│   └── algorithms/               # un algorithme = un fichier, base commune pour l'upload
└── gui/
    ├── main_dialog.py            # assemble les 4 onglets
    ├── tasks.py                   # exécution asynchrone (QgsTask) depuis l'UI
    └── tabs/                       # un onglet = un widget, pas de logique métier

Principe directeur : la logique métier (construction des requêtes, interprétation des réponses, règles comme « pas de téléchargement hors SUCCESS ») vit dans core/, indépendamment de Qt/QGIS quand c'est possible (models.py, urls.py, referentiel_catalog.py n'importent ni Qt ni QGIS). Les algorithmes Processing et l'interface graphique ne sont que des clients de core.api_client.ValidationApiClient : aucune requête HTTP n'est construite ailleurs.

Pourquoi une réécriture ?

Ce plugin remplace une première version prototype (qgis_validation_geoplateforme) qui fonctionnait mais cumulait plusieurs défauts caractéristiques d'un prototype qui a grossi sans être restructuré :

Constat sur la v0	Choix dans cette réécriture
Un seul fichier de ~1700 lignes (gpf_validation_plugin.py) mélangeant UI, logique métier et réseau	Séparation en couches : core/ / network/ / processing_provider/ / gui/
Le même code HTTP (http_get, http_json_request, gestion de l'auth) recopié à l'identique dans cinq fichiers d'algorithmes	Un seul NetworkClient (network/http_client.py) et un seul ValidationApiClient (core/api_client.py)
Les trois algorithmes d'upload (couche / ZIP / fichier vecteur) dupliquaient ~90% de leur code	Base commune UploadValidateAlgorithmBase, chaque sous-classe ne fournit que sa source
Provider Processing qui scanne dynamiquement les fichiers (pkgutil.walk_packages) et avale les erreurs d'import dans un simple print()	Enregistrement explicite des algorithmes : une erreur casse le chargement de façon visible
processing.run(...) appelé dans le thread GUI, avec le commentaire « pour éviter les crashs Qt/Windows » → l'interface se fige pendant tout l'envoi	Envoi via QgsTask (mécanisme QGIS documenté pour l'exécution en arrière-plan) : QGIS reste utilisable pendant le transfert
Fichier network/upload_progress.py non utilisé par le reste du code (code mort)	Supprimé ; la progression passe par le mécanisme standard QgsTask.progressChanged
Téléchargement des résultats et des logs fusionnés dans un seul algorithme à interrupteurs multiples	Deux algorithmes à responsabilité unique (download_outputs, download_logs)
Aucun test	Suite de tests unitaires (tests/) sur la logique pure (URLs, catalogue, modèles), + CI (lint + tests + compilation)

Développement

Tests

Les modules qui n'ont pas besoin de Qt/QGIS (core/urls.py, core/models.py, core/referentiel_catalog.py) sont couverts par une suite pytest classique, exécutable sans installer QGIS :

pip install -r requirements-dev.txt
pytest

Les modules qui importent qgis (algorithmes Processing, GUI, clients réseau) sont vérifiés syntaxiquement (python -m compileall) et doivent être testés fonctionnellement dans QGIS (voir ci-dessous).

Lint

ruff check .

Test manuel dans QGIS

1. Copiez ou liez gpf_validation/ dans le dossier de plugins de votre profil QGIS (voir Installation).
2. Activez le plugin, ouvrez le panneau, vérifiez la boîte à outils Processing (groupe Géoplateforme – Validateur).
3. Après toute modification du code, supprimez les dossiers __pycache__ du plugin puis relancez QGIS.

Générer l'archive de distribution

python scripts/build_package.py

Produit dist/gpf_validation-<version>.zip, installable via Extensions ▸ Installer à partir d'un ZIP.

Licence

GPL-3.0, voir LICENSE.