Récupérer les données météorologiques en utilisant l’API de data.gouv.fr
est souvent uniquement assimilé à un site web. Or, il permet aussi :
de moissonner des ressources distantes comme des catalogues ;
de consulter via une API les pages, les jeux de données associés à des pages, les organisations, leurs jeux de données, les réutilisations, etc.
de mettre à jour les jeux de données via l'API.
Il existe une référence à ce propos sur . Un guide est disponible sur https://guides.data.gouv.fr/guide-data.gouv.fr/api.
Pour le hackathon nous vous avons préparé un dépôt github contenant des utilitaires vous permettant de télécharger les données.
Vous trouverez ci-dessous des exemples plus génériques vous expliquant en détail comment télécharger les données sur la plateforme data.gouv.fr. Nos exemples sont réalisés soit en ligne de commande en Bash, soit en Python. Pour les exemples Bash, il faut disposer de , , et installés sur votre machine.
Lister les ressources et les jeux de données d'une organisation
On cible ici Météo-France.
En bash, on passe en CSV.
# Nous trichons un peu : nous savons qu'il n'y a que 106 jeux de données pour le moment et cela nous évite de paginer ici.
curl '<https://www.data.gouv.fr/api/1/organizations/534fff8ba3a7292c64a77ed4/datasets/?page=1&page_size=200>' | jq . >| meteo-france-organization.json
echo '"ds_id","ds_title","ds_page","id","title","format","filetype","mime","type","url"' >| datasets_organization_meteo_france.csv
jq -r '.data[] | .page as $ds_page | .title as $ds_title| .id as $ds_id | .resources[] | [$ds_id, $ds_title, $ds_page, .id, .title, .format, .filetype, .mime, .["type"], .url] | @csv' meteo-france-organization.json >> datasets_organization_meteo_france.csv
En Python, on récupère les données.
import csv
import urllib.request
import json
start = 1
page_size = 10
organization_id = '534fff8ba3a7292c64a77ed4'
api_url = f'<https://www.data.gouv.fr/api/1/organizations/{organization_id}/datasets/?page={start}&page_size={page_size}>'
def get_all_organisations_datasets(initial_url):
api_url = initial_url
data = []
while api_url is not None:
with urllib.request.urlopen(api_url) as resp:
response_json = json.load(resp)
api_url = response_json.get('next_page')
data = data + response_json.get('data')
return data
results = get_all_organisations_datasets(api_url)
infos = []
field_names = ["ds_id","ds_title","ds_page","id","title","format","filetype","mime","type","url"]
infos.append(field_names)
for result in results:
ds_id = result.get('id')
ds_title = result.get('title')
ds_page = result.get('page')
for resource in result.get('resources'):
infos.append([
ds_id,
ds_title,
ds_page,
resource.get('id'),
resource.get('title'),
resource.get('format'),
resource.get('filetype'),
resource.get('mime'),
resource.get('type'),
resource.get('url')
])
with open('datasets_organization_meteo_france.csv', 'w') as csvfile:
writer = csv.writer(csvfile, quoting=csv.QUOTE_ALL)
writer.writerows(infos)
print(len(results))
Inconvénient : il est mis à jour tous les jours, cette fréquence bien qu'importante ne convient pas forcément à tous les utilisateurs.
Avantage : les fichiers sont exploitables via des logiciels de type tableur
import urllib.request
import json
dataset_id = '6569b4473bedf2e7abad3b72'
url = f'<https://www.data.gouv.fr/api/1/datasets/{dataset_id}/>'
# Start of datasets infos ressources retrieval
with urllib.request.urlopen(url) as resp:
json_content = json.load(resp)
urls = [resource.get('url') for resource in json_content.get('resources') if resource.get('type') != 'documentation']
print(urls)
Récupérer les id des organisations ("organizations") ou des jeux de données ("datasets")
Pour récupérer les id des organisations
Cherchez l'organisation Météo-France et rendez-vous sur sa page ;
Allez dans l'onglet "Informations" ;
Il existe pour les organisations un système de pagination. Ainsi, il faut vérifier si dans le retour de l'URL précédente si next_page contient une URL. Il faut alors l'appeler et répéter l'opération autant de fois que nécessaire.
Pour récupérer les id des jeux de données
Rendez-vous dans l'onglet "Informations" pour retrouver l'id du jeu de données.
Le "raccourci" possible
Nous avons tendance à préférer les identifiants techniques mais un autre moyen plus rapide est de passer le slug de la page ou de l'organisation.
Le slug correspond à du texte qui s'appuie sur le titre de l'organisation ou du jeu de données en remplaçant les espaces par des tirets et les lettres accentuées en lettres sans accents avec des minuscules partout dans l'URL.
meteo.data.gouv.fr : les "topics"
Données climatologiques de base
Données climatologiques de référence pour le changement climatique
"65e0c82c2da27c1dff5fa66f","Données de Prévision Numérique du Temps (PNT)"
"6571f2db0273fc306408f265","Données climatologiques de référence pour le changement climatique"
"6571f26dc009674feb726be9","Données climatologiques de base"
topic_ids_meteo=("65e0c82c2da27c1dff5fa66f" "6571f2db0273fc306408f265" "6571f26dc009674feb726be9")
echo "to_id,to_name,to_page,id,title,page,uri" >| topics_datasets.csv
for id in ${topic_ids_meteo[@]};
do echo "<https://www.data.gouv.fr/api/1/topics/${id}/>";
curl "<https://www.data.gouv.fr/api/1/topics/${id}/>" | jq -c -r '.page as $to_page | .name as $to_name | .id as $to_id | .datasets[] | [$to_id, $to_name, $to_page, .id, .title, .page, .uri] | @csv' >> topics_datasets.csv
done;
Utiliser les données météorologiques
Les formats de données météorologiques sont des formats multidimensionnels, en particulier pour les données liées aux satellites car ils nécessitent de gérer les coordonnées soit ponctuelles soit associées à une grille (déjà 2 dimensions), des dates d'acquisition (une autre dimension) et des mesures diverses (encore une dimension).
Manipuler les formats de fichiers grib2
Inspection en Bash
wget <https://object.data.gouv.fr/meteofrance-pnt/pnt/2024-04-02T12:00:00Z/arome/001/HP1/arome__001__HP1__01H__2024-04-02T12:00:00Z.grib2>
# On va généralement inspecter avec less ou filtrer avec des outils type grep
gdalinfo arome__001__HP1__01H__2024-04-02T12\\:00\\:00Z.grib2
# On a une sortie JSON potentiellement plus facilement exploitable avec par exemple jq
gdalinfo -json arome__001__HP1__01H__2024-04-02T12\\:00\\:00Z.grib2
Inspection en Python
import pygrib
openpath='arome__001__HP1__01H__2024-04-02T12:00:00Z.grib2'
grbs = pygrib.open(openpath)
grbs.seek(0)
for grb in grbs:
print(grb)
Pour l'exemple ci-dessous, passez par conda avec conda install --channel conda-forge xarray cfgrib eccodes -y
import numpy as np
import xarray as xr
import matplotlib.pyplot as plt
openpath = 'arome__001__HP1__01H__2024-04-02T12:00:00Z.grib2'
# Below commeneted due to https://github.com/meteofrance/meteonet/issues/20
# ds = xr.open_dataset(openpath,engine='cfgrib',backend_kwargs={'indexpath': ''})
meteodata = xr.open_dataset(openpath, engine='cfgrib',
backend_kwargs={'filter_by_keys': {'cfVarName': 'ws'}})
backend_kwargs={'filter_by_keys': {'name': 'Relative humidity'}})
print(meteodata['ws'])
ds_heightAboveGround50 = meteodata.sel(heightAboveGround=50)
plt.contourf(ds_heightAboveGround50['ws'])
plt.colorbar()
plt.savefig('ds_heightAboveGround50.png')
Inspection dans QGIS
Mettre les données en bases de données
Cela peut surtout s'avérer utile pour mettre des données attributaires comme les stations ou les mesures associées prises sur les stations. Il est ensuite plus facile de les manipuler si vous avez des connaissances en SQL. Néanmoins, rien ne vous empêche selon vos préférences de faire tous vos traitements dans des dataframes en Python ou en R.
SQLite
C'est un format de fichier qui contient une base de données relationnelle ne nécessitant aucune installation.
En utilisant l’utilitaire sqlite-utils, installable via pip install sqlite-utils
Pour exploiter le fichier généré, vous pouvez lancer une commande du type
sqlite-utils query meteo_hor.db "SELECT * FROM meteo_hor" --csv
GPKG
C'est un format qui s'appuie sur la base de données SQLite. La particularité est qu'il permet de gérer de la donnée géographique en intégrant des fonctionnalités spatiales du type "recherche toutes stations à moins de 10 km de chez moi".
ogr2ogr -f GPKG meteo_hor.gpkg -dialect SQLite -sql "SELECT *, MakePoint(cast(LON AS REAL), cast(LAT AS REAL), 4326) AS geometry FROM \"H_01_latest-2023-2024\"" /vsigzip/H_01_latest-2023-2024.csv.gz -nln csv_hor
# Une alternative à l'exemple ci-dessus de passer une fichier pour la requête SQL
# qui évite d'avoir à échapper les guillemets
# Editer le fichier query.sql avec le contenu suivant
# SELECT *, MakePoint(cast(LON AS REAL), cast(LAT AS REAL), 4326) AS geometry FROM "H_01_latest-2023-2024"
ogr2ogr -f GPKG meteo_hor.gpkg -dialect SQLite -sql @query.sql /vsigzip/H_01_latest-2023-2024.csv.gz -nln csv_hor
Parquet
Ce format permet des sélections rapides même en passant par des fichiers distants, évitant par exemple des téléchargements complets sur votre machine. Il existe une variation dite GeoParquet qui permet de stocker les données géographiques.
ogr2ogr -f Parquet meteo_hor.parquet -dialect SQLite -sql "SELECT *, MakePoint(cast(LON AS REAL), cast(LAT AS REAL), 4326) AS geometry FROM \"H_01_latest-2023-2024\"" /vsigzip/H_01_latest-2023-2024.csv.gz
La différence notable est que la taille du GPKG généré est de l’ordre de 20 fois plus gros que le fichier GeoParquet.
PostgreSQL/PostGIS
PostgreSQL est une base de données client/serveur. Elle nécessite une installation sur votre machine ou un serveur distant. Elle peut gérer de très gros volumes de données, étant en concurrence avec des SGBD type Oracle ou MySQL Server.
Si vous manipulez de la donnée géographique, vous ne pourrez pas passer à côté de sa cartouche spatiale PostGIS qui est à ce jour la meilleure du marché dans les SGBD existants.
Charger les données dans PostgreSQL avec le client psql (fourni dès l'installation de PostgreSQL/PostGIS) en ligne de commande
Pour manipuler des données géographiques vecteur ou raster : ogrinfo/ogr2ogr/gdalinfo/gdalwarp fournis par GDAL
Pour manipuler des données csv ou passer par du parquet facilement : duckdb
En Python
Pensez à passer par des Notebooks Jupyter. Utilisez conda/mamba et des environnements virtuels
Les bibliothèques qui pourraient vous être utiles :
pandas avec son module “géo” geopandas
xarray, cfgrib, eccodes pour manipuler les grib2 type Arome ou Arpège
matplotlib avec cartopy et basemap
Logiciel SIG QGIS
Pour une analyse visuelle rapide, vous pouvez passer par QGIS qui permet de gérer les WMS, les CSV et les GeoJSON.
Utiliser les API de Météo-France
Après création d’un compte, il est possible souscrire à des APIs. Par défaut, le compte ne permet rien sauf de souscrire à des APIs. Quand on a choisi une API, on peut souscrire puis commencer à utiliser pour son usage.
La page d’accueil du site reproduite ci-dessous est très claire à ce propos.
Exemple avec QGIS
Ajout de WMS Arome
Il est aussi possible de passer par les fichiers du catalogue de données de data.gouv.fr pour obtenir un contenu similaire. Le lien web est :
Il s'agit de pages de jeux de données comme
Passez par ;
Descendez en bas pour voir mentionné l'id comme sur :
Vous pouvez réexploiter cette id via une URL du type pour l'organisation 534fff8ba3a7292c64a77ed4
Allez sur un jeu de données des "Données climatologiques de base - horaires",
Ensuite, il faudra entrer comme URL avec l'id 6569b4473bedf2e7abad3b72 pour accéder au json des ressources associées au jeu de données.
Pour l'organisation , il suffit de copier la partie meteo-france de l'url et d'ouvrir la page pour avoir le même résultat que .
Pour le jeu de données , les URLs ou sont équivalentes.
Derrière se cache un site dérivé de .
L'API de expose ce que l’on appelle des "topics", qui sont des regroupements de données et qui sont consommés via le front de meteo.data.gouv.fr.
3 topics sont actuellement utilisés sur :
Il est ensuite possible de retrouver les correspondances entre noms des topics sur .
Si on veut toutes les données du portail , voici un recette en bash :
Pour cela, plusieurs formats sont utilisés. On stocke généralement les données brutes sous forme de fichiers dits GRIB, un format standardisé par l'OMM (Organisation Mondiale de la Météorologie). Vous pouvez en savoir plus en passant par .
Inspection grib2 dans Qgis
Pour en savoir plus, lire
L'outil pour facilement manipuler ces fichiers est qui peut être appelé en R, Python, dans le navigateur comme en ligne de commande.
Vous pouvez si nécessaire consulter .
Voir
Un bon point d’entrée pour des exemples (en particulier pour les données type Arome/Arpege) : .
Vous pouvez vous référer pour un tuto rapide à .
Vous pouvez également vous référer à .
Bien que les données soient ouvertes sous licence Etalab, les APIs nécessitent de créer un compte sur (pour éviter les abus et pouvoir suivre les usages).
