Aller au contenu

Organisation du code dans un script avec des fonctions#

Communication avec l'utilisateur des erreurs et des logs#

Avant de commencer à vraiment écrire un script avec des fonctions, regardons comment communiquer des informations à l'utilisateur.

On peut envoyer des messages vers l'utilisateur avec l'utilisation de la messageBar de la classe QgisInterface :

1
2
3
4
iface.messageBar().pushMessage('Erreur','On peut afficher une erreur', Qgis.Critical)
iface.messageBar().pushMessage('Avertissement','ou un avertissement', Qgis.Warning)
iface.messageBar().pushMessage('Information','ou une information', Qgis.Info)
iface.messageBar().pushMessage('Succès','ou un succès', Qgis.Success)

Cette fonction prend 3 paramètres :

  • un titre
  • un message
  • un niveau d'alerte

On peut aussi écrire des logs comme ceci (plus discret, mais plus verbeux) :

1
2
3
4
QgsMessageLog.logMessage('Une erreur est survenue','Notre outil', Qgis.Critical)
QgsMessageLog.logMessage('Un avertissement','Notre outil', Qgis.Warning)
QgsMessageLog.logMessage('Une information','Notre outil', Qgis.Info)
QgsMessageLog.logMessage('Un succès','Notre outil', Qgis.Success)

Cette fonction prend 3 paramètres :

  • un message
  • une catégorie, souvent le nom de l'extension ou de l'outil en question
  • un niveau d'alerte

Charger automatiquement plusieurs couches à l'aide d'un script#

La console, c'est bien, mais c'est très limitant. Passons à l'écriture d'un script qui va nous faciliter l'organisation du code.

Ci-dessous, voici le dernier script du chapitre précédent, mais avec la gestion des erreurs ci-dessus :

  • Redémarrer QGIS
  • N'ouvrez pas le projet précédent
  • Ouvrer la console, puis cliquer sur Afficher l'éditeur
  • Copier/coller le script ci-dessous
  • Exécuter le
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from os.path import join, isfile, isdir
dossier = '201909_11_ILE_DE_FRANCE_SHP_L93_2154'
thematique = 'H_OSM_ADMINISTRATIF'
couche = 'COMMUNE'

racine = QgsProject.instance().homePath()
if not racine:
    iface.messageBar().pushMessage('Erreur de chargement','Le projet n\'est pas enregistré', Qgis.Critical)
else:
    fichier_shape = join(racine, dossier, thematique, '{}.shp'.format(couche))
    if not isfile(fichier_shape):
        iface.messageBar().pushMessage('Erreur de chargement','Le chemin n\'existe pas: "{}"'.format(fichier_shape), Qgis.Critical)
    else:
        layer = QgsVectorLayer(fichier_shape, couche, 'ogr')
        if not layer.isValid():
            iface.messageBar().pushMessage('Erreur de chargement','La couche n\'est pas valide', Qgis.Critical)
        else:
            QgsProject.instance().addMapLayer(layer)
            iface.messageBar().pushMessage('Bravo','Well done!', Qgis.Success)
  • À l'aide du mémo Python :
  • Essayons de faire une fonction qui prend 2 paramètres
    • la thématique (le dossier)
    • le nom du shapefile
  • La fonction se chargera de faire le nécessaire, par exemple: charger_couche('H_OSM_ADMINISTRATIF', 'COMMUNE')
  • La fonction peut également retourner False si la couche n'est pas chargée (une erreur) ou sinon l'objet couche.
1
2
def charger_couche(thematique, couche):
    pass

Tip

Le mot-clé pass ne sert à rien. C'est un mot-clé Python pour rendre un bloc valide mais ne faisant rien. On peut le supprimer le bloc n'est pas vide.

Afficher la solution intermédiaire
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from os.path import join, isfile, isdir
dossier = '201909_11_ILE_DE_FRANCE_SHP_L93_2154'


def charger_couche(thematique, couche):
    """Fonction qui charge une couche shapefile dans une thématique."""
    racine = QgsProject.instance().homePath()
    if not racine:
        iface.messageBar().pushMessage('Erreur de chargement','Le projet n\'est pas enregistré', Qgis.Critical)
    else:
        fichier_shape = join(racine, dossier, thematique, '{}.shp'.format(couche))
        if not isfile(fichier_shape):
            iface.messageBar().pushMessage('Erreur de chargement','Le chemin n\'existe pas: "{}"'.format(fichier_shape), Qgis.Critical)
        else:
            layer = QgsVectorLayer(fichier_shape, couche, 'ogr')
            if not layer.isValid():
                iface.messageBar().pushMessage('Erreur de chargement','La couche n\'est pas valide', Qgis.Critical)
            else:
                QgsProject.instance().addMapLayer(layer)
                iface.messageBar().pushMessage('Bravo','Well done!', Qgis.Success)

thematique = 'H_OSM_ADMINISTRATIF'
couche = 'COMMUNE'
charger_couche(thematique, couche)

Améliorons encore cette solution intermédiaire avec la gestion des erreurs et aussi en gardant le code le plus à gauche possible grâce à l'instruction return qui ordonne la sortie de la fonction.

Afficher une des solutions finales
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from os.path import join, isfile, isdir

def charger_couche(thematique, couche):
    """Fonction qui charge une couche shapefile dans une thématique."""
    dossier = '201909_11_ILE_DE_FRANCE_SHP_L93_2154'

    racine = QgsProject.instance().homePath()
    if not racine:
        iface.messageBar().pushMessage('Erreur de chargement','Le projet n\'est pas enregistré', Qgis.Critical)
        return False

    fichier_shape = join(racine, dossier, thematique, '{}.shp'.format(couche))
    if not isfile(fichier_shape):
        iface.messageBar().pushMessage('Erreur de chargement','Le chemin n\'existe pas: "{}"'.format(fichier_shape), Qgis.Critical)
        return False

    layer = QgsVectorLayer(fichier_shape, shapefile, 'ogr')
    if not layer.isValid():
        iface.messageBar().pushMessage('Erreur de chargement','La couche n\'est pas valide', Qgis.Critical)
        return False

    QgsProject.instance().addMapLayer(layer)
    iface.messageBar().pushMessage('Bravo','Well done!', Qgis.Success)
    return layer

charger_couche('H_OSM_ADMINISTRATIF', 'COMMUNE')
charger_couche('H_OSM_ADMINISTRATIF', 'ARRONDISSEMENT')
  • Essayons de faire une fonction qui liste les shapefiles d'une certaine thématique.

On peut utiliser la méthode os.walk(path) permet de parcourir un chemin et de lister les répertoires et les fichiers.

Ou alors on peut utiliser une autre méthode, un peu plus à la mode en utilisant le mode pathlib qui comporte également les fonctions isfile, isdir etc.

En utilisant le module os.walk, un peu historique :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import os

def liste_shapefiles(thematique):
    """Liste les shapefiles d'une thématique."""
    dossier = '201909_11_ILE_DE_FRANCE_SHP_L93_2154'
    racine = QgsProject.instance().homePath()
    shapes = []
    for root, directories, files in os.walk(os.path.join(racine, dossier, thematique)):
        for file in files:
            if file.lower().endswith('.shp'):
                shapes.append(file.replace('.shp', ''))
    return shapes

shapes = liste_shapefiles('H_OSM_ADMINISTRATIF')
print(shapes)

En utilisant le "nouveau" module pathlib:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
from pathlib import Path

def liste_shapefiles(thematique):
    """Liste les shapefiles d'une thématique."""
    racine = QgsProject.instance().homePath()
    dossier = Path(racine).joinpath('202103_OSM2IGEO_91_LANGUEDOC_ROUSSILLON_SHP_L93_2154', thematique)
    shapes = []
    for file in dossier.iterdir():
        if file.suffix.lower() == '.shp':
            shapes.append(file.stem)
    return shapes

shapes = liste_shapefiles('H_OSM_ADMINISTRATIF')
print(shapes)

Tip

Il faut se référer à la documentation du module pathlib pour comprendre le fonctionnement de cette classe.

  • Permettre le chargement automatique de toute une thématique.
Afficher la solution complète
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import os
from os.path import join, isfile, isdir
dossier = '202103_OSM2IGEO_91_LANGUEDOC_ROUSSILLON_SHP_L93_2154'
# couche = 'COMMUNE'

def liste_shapesfiles(thematique):
    """Liste les shapes d'une thématique"""
    racine = QgsProject.instance().homePath()
    if not racine:
        iface.messageBar().pushMessage('Erreur de chargement','Le projet n\'est pas enregistré', Qgis.Critical)
        return False

    shapes = []
    for root, directories, files in os.walk(os.path.join(racine, dossier, thematique)):
        # print(files)
        for file in files:
            # print(file)
            if file.lower().endswith('.shp'):
                # print(file)
                shapes.append(file.replace(".shp", ""))

    return shapes

def charger_couche(thematique, couche):

    """Fonction qui charge des couches suivant une thématique."""
    racine = QgsProject.instance().homePath()
    if not racine:
        iface.messageBar().pushMessage('Erreur de chargement','Le projet n\'est pas enregistré', Qgis.Critical)
        return False

    fichier_shape = join(racine, dossier, thematique, '{}.shp'.format(couche))
    if not isfile(fichier_shape):
        iface.messageBar().pushMessage('Erreur de chargement','Le chemin n\'existe pas: "{}"'.format(fichier_shape), Qgis.Critical)
        return False

    layer = QgsVectorLayer(fichier_shape, couche, 'ogr')
    if not layer.isValid():
        iface.messageBar().pushMessage('Erreur de chargement','La couche n\'est pas valide', Qgis.Critical)
        return False

    QgsProject.instance().addMapLayer(layer)
    iface.messageBar().pushMessage('Bravo','Well done!', Qgis.Success)
    return layer


thematique = 'H_OSM_ADMINISTRATIF'
shapes = liste_shapesfiles(thematique)
for shape in shapes:
    charger_couche(thematique, shape)

Extraction des informations sous forme d'un fichier CSV.#

On souhaite désormais réaliser une fonction d'export des métadonnées de nos couches au format CSV, avec son CSVT. Il existe déjà un module CSV dans Python pour nous aider à écrire un fichier de type CSV, mais nous n'allons pas l'utiliser. Nous allons plutôt utiliser l'API QGIS pour créer une nouvelle couche en mémoire comportant les différentes informations que l'on souhaite exporter. Puis nous allons utiliser l'API pour exporter cette couche mémoire au format CSV (l'équivalent dans QGIS de l'action Exporter la couche).

Les différents champs qui devront être exportés sont :

  • son nom
  • son type de géométrie (format humain, lisible)
  • la projection
  • le nombre d'entité
  • l'encodage
  • si le seuil de visibilité est activé
  • la source (le chemin) de la donnée

Exemple de sortie#

nom type projection nombre_entite encodage source seuil_de_visibilite
couche_1 Line EPSG:4326 5 UTF-8 /tmp/...geojson False
couche_2 Tab No geometry 0 /tmp/...shp True

Petit mémo#

Pour créer une couche tabulaire en mémoire, code qui vient du cookbook :

1
layer_info = QgsVectorLayer('None', 'info', 'memory')

La liste des couches :

1
layers = QgsProject.instance().mapLayers()

Pour utiliser une session d'édition, on peut faire :

1
2
3
layer.startEditing()  # Début de la session
layer.commitChanges()  # Fin de la session en enregistrant
layer.rollback()  # Fin de la session en annulant les modifications

On peut également faire une session d'édition avec un "contexte":

1
2
3
4
5
6
7
from qgis.core import edit

with edit(layer):
    # Faire une édition sur la couche
    pass

# À la fin du bloc d'indentation, la session d'édition est automatiquement close.

Nous allons avoir besoin de plusieurs classes dans l'API QGIS :

Pour le type de champ, on va avoir besoin de l'API Qt également :

Il va y avoir plusieurs étapes dans ce script :

  1. Récupérer la liste des couches présentes dans la légende
  2. Créer une couche en mémoire
  3. Ajouter des champs à cette couche en utilisant une session d'édition
  4. Itérer sur les couches pour ajouter ligne par ligne les métadonnées dans une session d'édition
  5. Enregistrer en CSV la couche mémoire

Tip

Pour déboguer, on peut afficher la couche mémoire en question avec QgsProject.instance().addMapLayer()

Solution#

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
from os.path import join

layers = QgsProject.instance().mapLayers()
if not layers:
    iface.messageBar().pushMessage('Pas de couche','Attention, il n\'a pas de couche', Qgis.Warning)

layers = [layer for layer in layers.values()]

layer_info = QgsVectorLayer('None', 'info', 'memory')

fields = []
fields.append(QgsField('nom', QVariant.String))
fields.append(QgsField('type', QVariant.String))
fields.append(QgsField('projection', QVariant.String))
fields.append(QgsField('nombre_entite', QVariant.Int))
fields.append(QgsField('encodage', QVariant.String))
fields.append(QgsField('source', QVariant.String))
fields.append(QgsField('seuil_de_visibilite', QVariant.String))

with edit(layer_info):
    for field in fields:
        layer_info.addAttribute(field)

QgsProject.instance().addMapLayer(layer_info)

with edit(layer_info):
    for layer in layers:
        feature = QgsFeature(layer_info.fields())
        feature.setAttribute("nom", layer.name())
        feature.setAttribute("projection", layer.crs().authid())
        feature.setAttribute("nombre_entite", layer.featureCount())
        feature.setAttribute("encodage", layer.dataProvider().encoding())
        feature.setAttribute("source", layer.source())
        feature.setAttribute("type", QgsWkbTypes.geometryDisplayString(layer.geometryType()))
        feature.setAttribute("seuil_visibilite", layer.hasScaleBasedVisibility())
        layer_info.addFeature(feature)

base_name = QgsProject.instance().baseName()
QgsVectorFileWriter.writeAsVectorFormat(
    layer_info,
    join(QgsProject.instance().homePath(), f'{base_name}.csv'),
    'utf-8',
    QgsCoordinateReferenceSystem(),
    'CSV',
    layerOptions=['CREATE_CSVT=YES']
)

# Afficher une messageBar pour confirmer que c'est OK, en vert ;-)
Pour la version avec writeAsVectorFormatV3

Il faut désormais donner le contexte pour une éventuelle reprojection que l'on trouve dans la classe QgsProject : QgsProject.instance().transformContext().

L'ensemble des options se donne via une nouvelle variable QgsVectorFileWriter.SaveVectorOptions().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'CSV'
options.fileEncoding = 'UTF-8'
options.layerOptions = ['CREATE_CSVT=YES', 'SEPARATOR=TAB']

base_name = QgsProject.instance().baseName()
QgsVectorFileWriter.writeAsVectorFormatV3(
    layer_info,
    join(QgsProject.instance().homePath(), f'{base_name}.csv'),
    QgsProject.instance().transformContext(),
    options,
)

Warning

Ajouter une couche raster et retester le script ... surprise 🎁

Tip

Pour obtenir en Python la liste des fournisseurs GDAL/OGR :

1
2
from osgeo import ogr
[ogr.GetDriver(i).GetDescription() for i in range(ogr.GetDriverCount())]    
ou dans le menu Préférences ➡ Options ➡ GDAL ➡ Pilotes vecteurs