Examiner et tester un script
Les scripts Python permettent d’automatiser des tâches dans ArcGIS Pro. Vous pouvez partager sous forme de fichiers Python .py les scripts que vous créez avec d’autres utilisateurs. Cependant, l’utilisation d’un script créé par un tiers exige d’avoir une certaine connaissance de Python, même s’il ne s’agit que de changer les noms des jeux de données à traiter. Pour partager un script Python dans un formulaire plus simple d’utilisation, vous pouvez créer un outil de script Python.
Un outil de script Python vous permet de créer le script Python avec une interface conviviale qui ressemble aux outils de géotraitement classiques. Pour que votre outil de script se comporte comme un outil de géotraitement classique, vous pouvez ajouter du code pour valider les entrées de l’utilisateur et lui renvoyer des messages. Vous pouvez également inclure une documentation d’aide intégrée, expliquant comment utiliser l’outil et configurer ses paramètres.
La création d’outils de script facilite le partage des fonctions d’un script Python avec d’autres utilisateurs. Les scripts Python peuvent être incorporés dans un fichier de boîte à outils personnalisée (.atbx), qui simplifie le partage.
Ouvrir un projet et examiner les jeux de données
Vous allez commencer par télécharger les données du didacticiel, ouvrir un projet existant et examiner les données que l’outil va traiter.
- Téléchargez le fichier PythonTool.zip de ce tutoriel et recherchez son emplacement sur votre ordinateur.
Remarque :
La plupart des navigateurs Web téléchargent les fichiers dans le dossier Downloads de votre ordinateur par défaut. - Cliquez avec le bouton droit sur le fichier PythonTool.zip et procédez à son extraction dans le dossier C:\Tutorials\.
Remarque :
Si ce dossier n’existe pas déjà sur votre ordinateur, vous pouvez le créer et y extraire le fichier compressé (zip). Vous pouvez également l’extraire à un autre emplacement, mais les instructions et le script utilisent le chemin C:\Tutorials. Aussi, si vous placez le dossier PythonTool à un autre emplacement, vous devrez mettre à jour le script de sorte à désigner le chemin du dossier choisi. - Démarrez ArcGIS Pro et connectez-vous à ArcGIS Online.
Remarque :
Si vous ne disposez pas d’un compte d’organisation, consultez les options disponibles pour accéder aux logiciels.
- Dans ArcGIS Pro, cliquez sur Open another project (Ouvrir un autre projet).
- Dans la fenêtre Open Project (Ouvrir le projet), accédez au dossier PythonTool, cliquez sur Python Tool.aprx, puis sur OK.
Le projet s’ouvre.
La carte affiche plusieurs classes d’entités pour la région de Washington, D.C.
- Si la fenêtre Catalog (Catalogue) n’est pas déjà visible, cliquez sur l’onglet View (Vue) sur le ruban, puis sur Catalog Pane (Fenêtre Catalogue).
- Dans la fenêtre Catalog (Catalogue), développez Folders (Dossiers), puis PythonTool.
- Développez la géodatabase DC.gdb.
La géodatabase contient huit classes d’entités. Certaines sont des couches sur la carte.
Le dossier PythonTool contient en outre un shapefile nommé neighborhood.shp qui se trouve aussi sur la carte.
Supposons que vous travaillez dans un bureau en ville et que vous recevez régulièrement des demandes d’extraction de données pour des quartiers donnés de la ville.
Pour accomplir cette tâche, vous devez découper toutes les classes d’entités de la géodatabase d’un quartier et les stocker dans une nouvelle géodatabase. Cette nouvelle géodatabase doit ensuite être compressée en archive ZIP que vous pouvez facilement partager ou utiliser à des fins de sauvegarde.
Cet ensemble de tâches fait quasiment partie du quotidien des lieux de travail SIG.
Elles peuvent être effectuées dans ArcGIS Pro à l’aide de l’outil Create File Geodatabase (Créer une géodatabase fichier) pour la création de la nouvelle géodatabase, puis en exécutant l’outil Clip (Découper) autant de fois qu’il y a de classe d’entités. Vous pouvez ensuite créer l’archive ZIP à partir de File Explorer ou à l’aide d’un utilitaire de compression. Ce processus peut s’avérer fastidieux et chronophage, surtout s’il y a un grand nombre de classes d’entités à traiter.
Aussi, comme il s’agit d’une tâche fréquente, il est pertinent de l’automatiser.
Le projet inclut un script permettant d’automatiser la tâche. Vous allez examiner et tester ce script autonome, puis créer un outil de script Python basé sur ce script.
Examiner et tester un script Python
Vous allez commencer par ouvrir le script et en examiner le contenu.
- Dans File Explorer, accédez au dossier C:\Tutorials\PythonTool.
- Cliquez avec le bouton droit sur le fichier de script Python clip_zip.py, puis cliquez sur Edit with IDLE (ArcGIS Pro) (Modifier avec IDLE [ArcGIS Pro]).
Remarque :
Si ArcGIS Desktop 10.x (ArcMap) est installé, le menu contextuel comporte également le raccourci Edit with IDLE (Mettre à jour avec IDLE). N’utilisez pas ce raccourci car il n’ouvre pas la version correcte de Python.Remarque :
Si vous utilisez Windows 11 et que l’option Edit with IDLE (ArcGIS Pro) (Mettre à jour avec IDLE [ArcGIS Pro]) n’apparaît pas, cliquez sur Show more options (Afficher plus d’options), puis sur Edit with IDLE (ArcGIS Pro) (Mettre à jour avec IDLE [ArcGIS Pro]).Le script s’ouvre dans IDLE, l’éditeur par défaut de Python.
Vous allez examiner ce script pour comprendre son fonctionnement, puis le tester.
Le script commence par les importations :
import arcpy import os import zipfile
Ces lignes importent les modules que le script va utiliser.
ArcPy est nécessaire pour exécuter les outils de géotraitement et les tâches associées, le module os est nécessaire pour les manipulations de chemin et le module zipfile requis pour créer une archive ZIP.
La partie suivante du script définit l’espace de travail et les chemins des jeux de données en entrée et en sortie. Sans les commentaires, elle ressemble à ceci :
arcpy.env.workspace = "C:/Tutorials/PythonTool/DC.gdb" clip_fc = "C:/Tutorials/PythonTool/neighborhood.shp" gdb = "C:/Tutorials/PythonTool/Clip.gdb" gdb_path, new_gdb = os.path.split(gdb) gdb = "C:/Tutorials/PythonTool/Clip.zip" arcpy.env.overwriteOutput = True
L’espace de travail défini est la géodatabase DC.gdb. Elle contient les classes d’entités qui doivent être découpées. La classe d’entités neighborhood.shp va être utilisée pour les entités découpées. La géodatabase Clip.gdb va être créée par le script pour contenir la sortie de l’outil Clip (Découper). Le chemin complet de la géodatabase est divisé entre le dossier, C:\Tutorials\PythonTool, et le nom de la géodatabase, Clip.gdb, à l’aide de os.path.split(). Ces éléments sont requis en tant que variables distinctes plus loin dans le script. L’archive ZIP Clip.zip va contenir les contenus complets de la géodatabase Clip.gdb.
Tous les jeux de données se trouvent dans le même dossier, mais cela n’est pas indispensable au fonctionnement du script. Par exemple, la nouvelle géodatabase pourrait être créée dans un autre dossier.
Le script se poursuit ensuite avec la création de la nouvelle géodatabase. Un message imprimé confirme que la nouvelle géodatabase a été créée.
arcpy.CreateFileGDB_management(gdb_path, new_gdb) print(f"Output geodatabase {gdb} created")
C’est dans la section suivante que l’outil Clip (Découper) est exécuté :
inputs = arcpy.ListFeatureClasses() for fc in inputs: fc_name = arcpy.da.Describe(fc)["baseName"] new_fc = os.path.join(gdb, fc_name) arcpy.analysis.Clip(fc, clip_fc, new_fc) print(f"Output feature class {new_fc} created")
La fonction ListFeatureClasses() renvoie toutes les classes d’entités se trouvant dans l’espace de travail, qui est la géodatabase DC.gdb. À l’intérieur de la boucle for qui suit, le nom de la base de la classe d’entités est obtenu. Bien que cela ne soit pas absolument nécessaire dans notre exemple, cela renforce le script, car toute extension de fichier (comme .shp) est supprimée lorsque les shapefiles sont des entrées. Le chemin complet de la classe d’entités en sortie est créé à l’aide de os.path.join(). Cela est nécessaire pour que la sortie aille dans la géodatabase Clip.gdb et non dans l’espace de travail. L’outil Clip (Découper) s’exécute et un message imprimé confirme que la nouvelle classe d’entités a été créée. Ces étapes sont répétées pour chaque classe d’entités de la liste.
La dernière section crée l’archive ZIP :
with zipfile.ZipFile(out_zip, "w") as myzip: for f in os.listdir(gdb): if not f.endswith(".lock"): file_name = os.path.join(gdb, f) arc_name = os.path.join(new_gdb, f) myzip.write(file_name, arc_name)
Une nouvelle archive ZIP est créée à l’aide de zipfile.ZipFile(). Une instruction with sert ici à créer et ouvrir le fichier, mais aussi à s’assurer de sa fermeture à l’issue du traitement. Les contenus de la géodatabase sont déterminés à l’aide de os.listdir(), qui renvoie une liste de tous les fichiers se trouvant dans le dossier de la géodatabase. Tous les fichiers dont l’extension est .lock sont ignorés. Les autres sont écrits dans l’archive ZIP. La variable file_name représente le chemin d’accès complet de chaque fichier dans la géodatabase d’origine. La variable arc_name représente chaque fichier à écrire dans l’archive ZIP, mais en incluant uniquement le nom de la géodatabase et le nom du fichier. Cela réplique la façon dont vous créeriez manuellement une archive ZIP dans File Explorer.
Maintenant que vous avez examiné le script, vous allez vous préparer à le tester.
- Dans IDLE, observez les chemins utilisés au début du script.
Si vous avez copié le dossier du didacticiel ailleurs qu’à l’emplacement C:/Tutorials/PythonTool/, vous devez obtenir le chemin vers les données à l’aide de File Explorer.
- Mettez à jour les quatre chemins d’accès dans cette section :
arcpy.env.workspace = "C:/Tutorials/PythonTool/DC.gdb" clip_fc = "C:/Tutorials/PythonTool/neighborhood.shp" gdb = "C:/Tutorials/PythonTool/Clip.gdb" gdb_path, new_gdb = os.path.split(gdb) gdb = "C:/Tutorials/PythonTool/Clip.zip" arcpy.env.overwriteOutput = True
Remarque :
Notez que dans le script, les chemins utilisent la barre oblique / comme séparateur. Si vous copiez un chemin à partir de File Explorer, c’est le caractère séparateur de chemin Windows par défaut, \, qui est utilisé. Vous devez donc remplacer toutes les barres obliques inverses par des barres obliques dans le script.Les chemins complets précodés se situent uniquement dans la section supérieure du script, où ils sont affectés à des variables. Ces variables sont utilisées par le reste du script. Les chemins complets et les noms de fichier ne sont pas répétés au-delà de la première section. Cette stratégie permet d’identifier plus facilement ce qui doit être changé et sera utile lorsque le script sera adapté pour être utilisé comme outil de script Python plus loin dans le script.
- Dans IDLE, cliquez sur File (Fichier), puis sur Save (Enregistrer) pour enregistrer les changements apportés au script.
- Dans IDLE, cliquez sur Run (Exécuter), puis sur Run Module (Exécuter le module) pour exécuter le script.
Le script s’exécute.
La fenêtre IDLE Shell apparaît et le script imprime les messages de progression au fur et à mesure qu’il traite les données.
Remarque :
Si vous n’avez pas modifié correctement les chemins, des messages d’erreurs peuvent s’afficher. Par exemple, si l’espace de travail n’est pas défini correctement, la liste des entrées est vide et le script renvoie l’erreur suivante :TypeError: ‘NoneType’ object is not iterable
De même, si le chemin de la géodatabase Clip.gdb est erroné, le script renvoie l’erreur suivante :
ERROR 000732: File GDB Location: Dataset … does not exist or is not supported
Ces erreurs illustrent la difficulté que constitue le partage de scripts. La création d’un outil de script est une bonne façon d’empêcher ce type d’erreur.
Si le script est exécuté correctement, les messages confirme que la géodatabase et les classes d’entités découpées ont été créées. Cela se vérifie à l’aide de ArcGIS Pro et de File Explorer.
- Dans ArcGIS Pro, dans la fenêtre Catalog (Catalogue), cliquez avec le bouton droit sur le dossier PythonTool, puis cliquez sur Refresh (Actualiser).
- Dans la fenêtre Catalog (Catalogue), dans le dossier PythonTool, vérifiez que la géodatabase Clip.gdb a été créée.
- Développez la géodatabase Clip.gdb.
- Dans la géodatabase Clip.gdb, cliquez avec le bouton droit sur bike_racks et cliquez sur Add To Current Map (Ajouter à la carte actuelle).
La nouvelle couche découpée bike_racks est ajoutée à la carte.
- Dans File Explorer, accédez au dossier C:\Tutorials\PythonTool.
Le fichier Clip.zip est ajouté au dossier.
Le script autonome fonctionne comme prévu. Si vous souhaitez utiliser le script pour d’autres jeux de données, vous pouvez l’ouvrir et modifier les chemins. Cette étape n’est pas très conviviale pour les utilisateurs qui ne sont pas familiarisés avec la création de scripts Python. De plus, le risque d’erreurs lors de la modification des chemins dans le script est élevé. Dans la section suivante, vous allez créer un outil de script Python comportant une interface conviviale.
Créer un outil et ajouter des paramètres
La phase suivante du processus consiste à créer un outil de script et à en configurer les paramètres. Cela définit l’interface utilisateur de l’outil.
Créer une boîte à outils et un outil de script
Les outils de script Python sont créés dans ArcGIS Pro. Ils sont stockés dans une boîte à outils personnalisée. Vous allez maintenant créer une boîte à outils personnalisée dans votre projet et y ajouter un outil de script.
- Dans ArcGIS Pro, dans la fenêtre Catalog (Catalogue), cliquez avec le bouton droit sur le dossier PythonTool, puis cliquez sur New (Nouveau) et sur Toolbox (.atbx) (Boîte à outils [.atbx]).
La boîte à outils est créée.
- Saisissez Clip_and_ZIP pour le nom de la boîte à outils et appuyez sur la touche Entrée.
Le nom de la boîte à outils est Clip_and_ZIP.
Remarque :
Anciennes versions de ArcGIS Pro utilisées au format .tbx. Vous pouvez continuer d’utiliser les anciennes boîtes à outils dans ce format, mais lorsque vous en créez de nouvelles, utilisez le format .atbx à compter de ArcGIS Pro 3.0. - Cliquez avec le bouton droit de la souris sur la boîte à outils Clip_and_ZIP, pointez le curseur sur New (Nouveau), puis cliquez sur Script.
La fenêtre New Script (Nouveau script) s’affiche.
Cette fenêtre sert à définir les propriétés générales de l’outil, à configurer les paramètres de l’outil, à saisir le code d’exécution et à ajouter le code de validation. Vous effectuerez toutes ces étapes dans la suite de ce didacticiel.
Pour l’heure, vous allez spécifier le nom, l’étiquette et la description de l’outil de script.
- Dans la zone de texte Name (Nom), saisissez ClipandZIP.
Le nom de l’outil est le nom d’identification unique interne qu’il utilise. Il ne peut contenir que des lettres et des chiffres. Les espaces et les caractères spéciaux ne sont pas autorisés.
- Dans la zone de texte Label (Étiquette), saisissez Clip and ZIP (Découper et zipper).
L’étiquette de l’outil est le nom convivial de l’outil qui s’affiche dans la boîte à outils et lorsqu’il est ouvert dans la boîte de dialogue des outils. L’étiquette peut contenir des espaces et des caractères spéciaux.
La zone de texte suivante, Toolbox (Boîte à outils), correspond à l’endroit où réside l’outil. Le chemin de la boîte à outils et son nom s’affichent en fonction de l’emplacement du fichier .atbx et ne peuvent pas être modifiés dans la fenêtre. Il est important de comprendre que l’outil de script n’est pas un fichier distinct et qu’il fait partie du fichier .atbx.
- Dans la zone de texte Description, saisissez This script tool allows you to select multiple layers or feature classes and clip them using on or more polygon features. The results are stored in a new geodatabase and a ZIP archive of this new geodatabase is created for easy sharing or backup. (Cet outil de script vous permet de sélectionner plusieurs couches ou classes d’entités et de les découper à l’aide d’une ou plusieurs entités surfaciques. Les résultats sont stockés dans une nouvelle géodatabase et une archive ZIP de cette dernière est créée à des fins de sauvegarde et de partage simplifié.)
- Cliquez sur OK.
L’outil de script est créé avec les propriétés générales que vous saisissez.
- Dans la fenêtre Catalog (Catalogue), dans la boîte d’outils Clip_and_ZIP, double-cliquez sur l’outil Clip and ZIP (Découper et zipper).
L’outil de script s’ouvre dans la fenêtre Geoprocessing (Géotraitement). Le début ressemble à la structure d’un outil de géotraitement, mais la suite est essentiellement vide.
- Fermez l’outil.
L’étape suivante consiste à configurer les paramètres de l’outil.
Examiner les propriétés de l’outil
La configuration soigneuse des paramètres de l’outil est une part essentielle de la création d’un outil de script Python. Les paramètres de l’outil définissent l’interface utilisateur de l’outil, qui va permettre à son utilisateur de saisir les données et les autres valeurs qui seront traitées par le script.
- Cliquez avec le bouton droit de la souris sur l’outil Clip and ZIP (Découper et zipper), puis cliquez sur Properties (Propriétés).
La fenêtre Tool Properties: Clip and ZIP (Propriétés de l’outil : Découper et zipper) apparaît et vos saisies précédentes sont affichées sur l’onglet General (Général).
- Cliquez sur l’onglet Paramètres.
C’est ici que vous allez configurer les paramètres de l’outil. Les paramètres de l’outil sont organisés dans une table. Chaque ligne de la table est un paramètre et les colonnes sont les propriétés de chaque paramètre.
Vous allez utiliser cette table pour créer les paramètres suivants :
- Input feature layers (Couches d’entités en entrée) : l’utilisateur peut sélectionner n’importe quelle couche d’entités sur la carte active, ou accéder à n’importe quelle classe d’entités sur le disque.
- Clip polygons (Polygones de découpage) : l’utilisateur peut sélectionner une couche d’entités surfaciques, accéder à une couche d’entités surfaciques sur le disque ou créer un jeu d’entités composé de polygones sur la carte active.
- Output geodatabase (Géodatabase en sortie) : l’utilisateur peut spécifier le chemin et le nom de fichier d’une nouvelle géodatabase pour y stocker les résultats.
- Output ZIP archive (Archive ZIP en sortie) : l’utilisateur peut spécifier le chemin et le nom de fichier de l’archive ZIP à créer avec les contenus de la géodatabase.
Ajouter le paramètre de couche d’entités en entrée
Vous allez commencer par ajouter le paramètre de couche d’entités en entrée.
- Dans la colonne Label (Étiquette), saisissez Input feature layers (Couches d’entités en entrée) et appuyez sur la touche Entrée.
L’étiquette du paramètre est l’étiquette lisible par l’utilisateur qui s’affiche dans la fenêtre de l’outil.
Le nom du paramètre est automatiquement renseigné à partir de l’étiquette, les espaces étant remplacés par des traits de soulignement. Le nom du paramètre est utilisé en interne par l’outil de script et peut être utilisé lors de la définition des paramètres de l’outil dans un script Python.
- Dans la colonne Data Type (Type de données), cliquez sur le bouton Change Data Type (Modifier le type de données).
La fenêtre Parameter Data Type (Type de données des paramètres) s’affiche.
La valeur par défaut est String (Chaîne), mais vous allez la modifier par Feature Layer (Couche d’entités).
- Cliquez sur la liste déroulante du type de données, faites-la défiler jusqu’à la section F et cliquez sur Feature Layer (Couche d’entités).
En définissant le type de données Feature Layer (Couche d’entités), vous autorisez l’utilisateur à sélectionner des couches d’entités dans la carte active à l’aide d’une liste déroulante sur l’outil, ou à accéder aux classes d’entités sur le disque.
Vous voulez que l’outil puisse accepter plusieurs couches d’entités en entrée.
- Cochez l’option Multiple values (Valeurs multiples).
Si vous cochez Multiple values (Valeurs multiples), l’utilisateur peut sélectionner une ou plusieurs entrées pour ce paramètre dans l’outil. Il peut s’agir d’une combinaison de couches d’entités et de classes d’entités.
- Cliquez sur OK pour fermer la fenêtre Parameter Data Type (Type de données des paramètres).
- Pour Type, acceptez la valeur par défaut, Required (Obligatoire).
Si un paramètre est Required (Obligatoire), l’outil ne peut pas être exécuté sans être paramétré.
- Pour Direction, acceptez la valeur par défaut, Input (Entrée).
En définissant Input (Entrée) comme direction du paramètre, vous indiquez à l’outil qu’il s’agit d’une des couches ou des valeurs en entrée qu’il va traiter. Cela permet également d’utiliser l’outil dans ModelBuilder, où les couches d’entités peuvent être connectées à l’outil en tant qu’entrées.
Le premier paramètre est terminé. Vous pouvez tout de suite vérifier à quoi ressemble l’outil avec cet unique paramètre.
- Dans la fenêtre Tool Properties: Clip and ZIP (Propriétés de l’outil : Découper et zipper), cliquez sur OK.
- Dans la fenêtre Catalog (Catalogue), dans la boîte d’outils Clip_and_ZIP, double-cliquez sur l’outil Clip and ZIP (Découper et zipper).
L’outil de script s’ouvre dans la fenêtre Geoprocessing (Géotraitement). Le premier paramètre y figure à présent. Une liste déroulante permet de sélectionner les couches d’entités à partir de la carte active et un bouton de navigation permet d’accéder aux classes d’entités sur le disque. L’astérisque rouge qui précède l’étiquette du paramètre question indique que celui-ci est obligatoire.
À ce stade, vous configurez les paramètres de l’outil et affichez l’interface utilisateur de l’outil afin de vérifier que les paramètres s’affichent correctement. Vous ne pouvez pas encore tester la bonne exécution et le fonctionnement correct de l’outil, car le code Python n’a pas été ajouté.
Remarque :
Si vous sélectionnez au moins une couche d’entités en entrée et exécutez l’outil, vous recevez un message d’erreur. - Fermez l’outil.
Ajouter le paramètre des polygones de découpage
Vous allez maintenant configurer le paramètre des polygones de découpage.
- Cliquez avec le bouton droit de la souris sur l’outil Clip and ZIP (Découper et zipper), puis cliquez sur Properties (Propriétés).
- Dans l’onglet Parameters (Paramètres), dans la deuxième ligne de la table, cliquez dans la colonne Label (Étiquette), saisissez Clip Polygons (Polygones de découpage) et appuyez sur la touche Entrée.
Dans le champ Name (Nom), le nom du paramètre est mis à jour et devient Clip_Polygons.
- Dans la colonne Data Type (Type de données), cliquez sur le bouton Change Data Type (Modifier le type de données).
- Pour Data Type (Type de données), cliquez sur la liste déroulante et sélectionnez Feature Set (Jeu d’entités).
Un jeu d’entités est la représentation allégée d’une classe d’entités. Dans le cas d’un outil de géotraitement, un jeu de données permet à l’outil d’accepter une entrée interactive. Un utilisateur peut créer des entités en dessinant sur la carte, de la même façon que vous créeriez des entités tout en apportant des modifications, à l’aide de la fenêtre Create Features (Créer des entités). L’utilisateur peut également sélectionner des couches d’entités sur la carte active, ou accéder à des classes d’entités sur le disque.
- Cliquez sur OK pour fermer la fenêtre Parameter Data Type (Type de données des paramètres).
- Pour Type, acceptez la valeur par défaut, Required (Obligatoire).
- Pour Direction, acceptez la valeur par défaut, Input (Entrée).
Vous allez ensuite définit un filtre sur ce paramètre afin que le paramètre Clip Polygons (Polygones de découpage) de l’outil n’accepte que des entités surfaciques en entrée.
- Faites défiler l’affichage vers la droite et cliquez dans la colonne Filter (Filtre).
- Cliquez sur la liste déroulante Filter (Filtre) et sélectionnez Feature Type (Type d’entité).
La fenêtre Feature Type Filter (Filtre Type d’entité) apparaît.
- Cochez l’option Polygon (Polygone).
Désormais, lorsqu’un utilisateur exécute l’outil, seuls les polygones peuvent être utilisés pour la géométrie de découpage en entrée.
-
Dans la fenêtre Feature Type Filter (Filtre Type d’entité), cliquez sur OK.
Vous avez configuré le paramètre Clip Polygons (Polygones de découpage).
Ajouter le paramètre de géodatabase en sortie
Vous allez maintenant configurer le paramètre de la géodatabase en sortie.
- Dans l’onglet Parameters (Paramètres), dans la troisième ligne de la table, cliquez dans la colonne Label (Étiquette), saisissez Output geodatabase (Géodatabase en sortie) et appuyez sur la touche Entrée.
- Dans la colonne Data Type (Type de données), cliquez sur le bouton Change Data Type (Modifier le type de données).
- Pour Data Type (Type de données), cliquez sur la liste déroulante, sélectionnez Workspace (Espace de travail) et cliquez sur OK.
- Pour Type, acceptez la valeur par défaut, Required (Obligatoire).
- Cliquez sur la colonne Direction, puis, dans la liste déroulante, sélectionnez Output (Sortie).
En définissant Output (Sortie) comme Direction du paramètre, vous indiquez à l’outil qu’il s’agit d’une des sorties qu’il va produire. Cela permet également à l’outil d’être utilisé dans ModelBuilder, où les éléments en sortie seront générés pour l’outil.
- Cliquez dans la colonne Filter (Filtre).
- Cliquez sur la liste déroulante Filter (Filtre) et sélectionnez Workspace (Espace de travail).
- Dans la fenêtre Workspace Filter (Filtre Espace de travail), cochez l’option Local Database (Base de données locale).
En définissant Local Database (Base de données locale) comme filtre, vous permettez à l’utilisateur de spécifier une géodatabase fichier comme sortie, mais également une géodatabase d’entreprise ou un dossier.
- Cliquez sur OK.
Vous avez configuré le paramètre Output geodatabase (Géodatabase en sortie).
Ajouter le paramètre d’archive ZIP en sortie
Vous allez maintenant configurer le paramètre de l’archive ZIP en sortie.
- Dans l’onglet Parameters (Paramètres), dans la quatrième ligne de la table, cliquez dans la colonne Label (Étiquette), saisissez Output ZIP archive (Archive ZIP en sortie) et appuyez sur la touche Entrée.
- Dans la colonne Data Type (Type de données), cliquez sur le bouton Change Data Type (Modifier le type de données).
- Pour Data Type (Type de données), cliquez sur la liste déroulante, sélectionnez File (Fichier) et cliquez sur OK.
Une archive ZIP étant un fichier, il s’agit du type de données correct.
- Cliquez sur la colonne Direction, puis, dans la liste déroulante, sélectionnez Output (Sortie).
- Cliquez sur la liste déroulante Filter (Filtre) et sélectionnez File (Fichier).
- Dans la fenêtre File Filter (Filtre Fichier) , dans la zone de texte Extensions, saisissez zip.
L’extension de fichier doit se composer exclusivement des lettres de l’extension, sans inclure le point séparateur. Ne saisissez pas .zip.
L’extension de fichier est sensible à la casse.
- Cliquez sur OK.
Vous avez ajouté tous les paramètres de l’outil.
- Dans la fenêtre Tool Properties: Clip and ZIP (Propriétés de l’outil : Découper et zipper), cliquez sur OK.
L’étape suivante consiste à tester les paramètres que vous avez configurés.
Tester les paramètres
Une fois que vous avez créé tous les paramètres de l’outil, vous pouvez tester la fenêtre de l’outil pour vérifier que la configuration de chaque paramètre est correcte.
- Dans la fenêtre Catalog (Catalogue), dans la boîte d’outils Clip_and_ZIP, double-cliquez sur l’outil Clip and ZIP (Découper et zipper).
L’outil Clip and ZIP (Découper et zipper) s’ouvre. Tous les paramètres que vous avez configurés aux étapes précédentes apparaissent à présent dans la fenêtre de l’outil.
- Dans l’outil Clip and ZIP (Découper et zipper), cliquez sur la liste déroulante Input feature layers (Couches d’entités en entrée) et sélectionnez bike_racks.
Une deuxième zone de texte Input feature layers (Couches d’entités en entrée) apparaît en dessous de celle de bike_racks, car ce paramètre d’outil autorise plusieurs valeurs.
- Cliquez sur le bouton de navigation Input feature layers (Couches d’entités en entrée), développez la géodatabase DC.gdb, puis cliquez sur bike_routes et enfin sur OK.
La classe d’entités bike_routes ne se trouvait pas sur la carte, mais vous l’avez ajoutée à l’outil Clip_and_ZIP.
Cela confirme que l’utilisateur peut sélectionner plusieurs entrées, notamment des couches d’entités sur la carte active et des classes d’entités sur le disque.
- Cliquez sur l’outil de construction Clip Polygons (Polygones de découpage).
Le jeu d’entités de construction en entrée est limité aux entités surfaciques.
Cela empêche les utilisateurs de tenter de découper à l’aide d’entités linéaires ou ponctuelles, ce qui génèrerait une erreur.
Vous allez maintenant tester les sorties.
- Dans la zone de texte Output geodatabase (Géodatabase en sortie), saisissez C:\Tutorials\PythonTool\Clip, puis cliquez dans la zone de texte Output ZIP archive (Archive ZIP en sortie).
La saisie d’un chemin d’accès à un dossier déclenche une icône d’alerte d’erreur sur le paramètre Output geodatabase (Géodatabase en sortie).
- Placez le curseur sur l’icône d’alerte d’erreur.
Un message d’erreur s’affiche. Il indique qu’aucune géodatabase ne se trouve à l’emplacement que vous avez spécifié ou que le type d’espace de travail est erroné.
De plus, si vous saisissez une extension de fichier incorrecte, .fdb par exemple, elle est automatiquement modifiée par .gdb.
Une validation similaire se produit pour le dernier paramètre.
- Dans la zone de texte Output ZIP archive (Archive ZIP en sortie), saisissez C:\Tutorials\PythonTool\Clip, puis cliquez dans la zone de texte Output geodatabase (Géodatabase en sortie).
L’outil ajoute l’extension de fichier .zip à Clip (Découper).
- Dans la zone de texte Output ZIP archive (Archive ZIP en sortie), saisissez C:\Tutorials\PythonTool\Clip.zipped, puis cliquez dans la zone de texte Output geodatabase (Géodatabase en sortie).
La saisie d’un chemin se terminant par une extension de fichier incorrecte déclenche une icône d’alerte d’erreur sur le paramètre Output ZIP archive (Archive ZIP en sortie).
- Placez le curseur sur l’icône d’alerte d’erreur.
Si vous placez le curseur sur l’icône, un message d’erreur apparaît, indiquant qu’il s’agit d’un type de fichier incorrect.
- Fermez l’outil.
Vos tests montrent que les filtres et la configuration des autres paramètres fonctionnent. Grâce à la conception soigneuse des paramètres, votre outil est plus robuste, car il empêche les utilisateurs de l’exécuter avec des valeurs non valides.
Vous avez testé les paramètres, mais l’outil n’est pas encore prêt à être exécuté, car le code n’a pas été ajouté. C'est ce que vous allez faire maintenant.
Mettre à jour le code d’exécution
Le code d’exécution d’un outil de script Python est le code Python qui s’exécute lorsqu’un utilisateur clique sur Run (Exécuter) dans la fenêtre Geoprocessing (Géotraitement). Vous allez utiliser le script autonome que vous avez examiné précédemment, mais vous allez devoir le modifier de sorte à lui attribuer les paramètres saisis par un utilisateur dans la fenêtre de l’outil.
- Cliquez avec le bouton droit de la souris sur l’outil Clip and ZIP (Découper et zipper), puis cliquez sur Properties (Propriétés).
- Cliquez sur l'onglet Execution (Exécution).
L’onglet affiche un modèle de code Python pour un outil de script.
Le code débute par un espace réservé de commentaire sur plusieurs lignes dédié à la documentation du script. Dans Python, trois guillemets ouvrent un commentaire sur plusieurs lignes et trois guillemets le clôturent. Le texte que vous insérez dans le commentaire n’est pas exécuté par Python.
Après le commentaire, la première ligne de code est import arcpy. Comme la plupart des scripts de l’outil de géotraitement utilisent ArcPy, il est inclus dans le modèle.
Ensuite, une fonction appelée script_tool() est définie. Une fonction est créée à l’aide du mot-clé def, suivi du nom de la fonction et des arguments de la fonction. Vous allez changer le nom de la fonction de modèle pour qu’elle corresponde à votre outil.
La fonction de modèle spécifie deux paramètres, mais votre outil en accepte plus. Vous allez également apporter des modifications sur ce point.
Le code d’exécution pour l’outil de script va aller dans cette fonction.
Le bloc de modèle de fonction se termine par une instruction de renvoi. Celle-ci clôt la fonction et renvoie les résultats.
La dernière section du code commence par if __name__ == '__main__':. Il s’agit d’une instruction conditionnelle et le bloc de code indenté qui suit ne sera exécuté que lorsque la condition sera évaluée à True. La variable __name__, encadrée par deux traits de soulignement, a la valeur '__main__' quel que soit le script.
Lorsque vous exécutez le code en tant que script, ce qui est le cas lorsque vous exécutez un outil de script, le bloc de code indenté est exécuté. En revanche, pour un module importé, la variable a pour valeur le nom de ce dernier. Dans ce cas, le bloc de code indenté n’est pas exécuté. Cette structure de code permet de faire la distinction entre l’exécution du code en tant que script et son importation en tant que module dans un autre script. Ce scénario ne s’applique pas ici. Pour créer l’outil de script, il suffit de savoir que le bloc de code indenté est exécuté en même temps que l’outil de script. Le bloc de code reçoit des paramètres à l’aide de la fonction ArcPy GetParameterAsText() et la fonction ScriptTool() est ensuite appelée sur les paramètres.
Le modèle utilise deux paramètres appelés param0 et param1. Il s’agit d’espaces réservés temporaires que vous allez mettre à jour pour qu’ils correspondent à votre script.
Remarque :
Dans les étapes suivantes, vous allez commencer à modifier le code d’exécution. Il est important de comprendre où est stocké le code. Par défaut, le code Python est incorporé. Cela signifie qu’il fait partie du fichier de boîte à outils .atbx et qu’il n’est pas stocké séparément. Toutefois, vous pouvez exporter le code vers un fichier .py pour le mettre à jour plus facilement et l’incorporer ultérieurement. Vous allez mettre ce processus en pratique en apportant des modifications incrémentielles au code.Vous allez maintenant modifier le nom de la fonction, script_tool(), pour le rendre plus pertinent. Pour commencer, vous allez mettre à jour le code incorporé directement dans la boîte de dialogue des propriétés de l’outil.
- Dans l’onglet Execution (Exécution), dans la zone du code, modifiez la ligne def script_tool(param0, param1): par def ClipZip(param0, param1): .
Modifiez-la ici :
Elle doit ressemble à ceci :
Lorsque vous modifiez le code dans la boîte de dialogue des propriétés de l’outil, les lignes de code qui ont été modifiées sont précédées d’un marqueur jaune.
- Dans la zone du code, modifiez la ligne script_tool(param0, param1) par ClipZip(param0, param1).
Vous avez mis à jour le nom de la fonction aux deux endroits où il apparaît dans le modèle de l’outil de script.
Ce mode de mise à jour du code est pratique et rapide, mais la zone de code offre des fonctions limitées par rapport à un éditeur Python classique. Vous allez maintenant découvrir deux façons de mettre à jour le code dans un éditeur Python classique.
- Dans l’onglet Execution (Exécution), sous la zone du code, cliquez sur OK.
Les modifications apportées au code incorporé sont enregistrées automatiquement et les marqueurs jaunes disparaissent lorsque vous fermez la boîte de dialogue des propriétés de l’outil.
- Cliquez avec le bouton droit de la souris sur l’outil Clip and ZIP (Découper et zipper), puis cliquez sur Properties (Propriétés).
- Au bas de la zone du code, cliquez sur le bouton Open in Script Editor (Ouvrir dans l’éditeur de script).
Un fichier de script temporaire s’ouvre dans l’éditeur Python par défaut. À moins que vous ayez configuré un autre éditeur, le script s’ouvre dans IDLE.
Les mises à jour que vous avez effectuées dans la zone du script sont présentes dans le script.
Remarque :
Vous pouvez configurer l’éditeur Python depuis l’onglet Project (Projet). Cliquez sur l’onglet Project (Projet), cliquez sur Options et sélectionnez Geoprocessing (Géotraitement) dans la fenêtre de gauche. L’option Script Editor (Éditeur de script) est vide par défaut, ce qui signifie qu’IDLE est utilisé. Vous pouvez le modifier en indiquant le chemin de votre éditeur préféré. Dans le cadre de ce didacticiel, nous allons garder IDLE.Le chemin d’accès ressemble à C:\Users\UserName\AppData\Local\Temp\1\ArcGISProTemp19512\
Le nom de fichier se compose des lettres tmp, suivies d’un code alphanumérique et de l’extension de fichier .py. Lorsque vous apportez des modifications au code et enregistrez le fichier .py, ces modifications sont ajoutées au bloc de code d’exécution incorporé. Vous allez mettre ce processus en pratique.
- Dans IDLE, ajoutez une nouvelle ligne de code en dessous de import arcpy et ajoutez le code suivant :
import os import zipfile
Ces deux modules sont utilisés dans le script autonome d’origine. Vous pouvez copier et coller le code depuis le script ou le saisir.
- Dans IDLE, cliquez sur File (Fichier), puis sur Save (Enregistrer).
- Fermez IDLE.
Le code que vous avez ajouté dans IDLE se trouve maintenant la zone du code.
Vous allez maintenant mettre à jour les paramètres du script dans un fichier de script autonome.
Enregistrer le script dans un fichier distinct
Le code que vous avez utilisé jusqu’ici est incorporé dans la boîte à outils. Vous pouvez aussi l’exporter vers un fichier .py afin de l’utiliser dans votre éditeur Python préféré.
- Dans l’onglet Execution (Exécution), au-dessus de la zone du script, cliquez sur la flèche verte du bouton Export script to file (Exporter le script vers un fichier).
- Dans la fenêtre Export Script (Exporter un script), vérifiez que l’emplacement est bien le dossier PythonTool et, dans le champ Name (Nom), saisissez clip_zip_tool.py.
Le script d’origine, qui contient la plupart du code que vous devez transférer et mettre à jour, se nomme clip_zip.xy ; aussi, veillez à utiliser un autre nom pour ne pas remplacer le fichier d’origine.
- Cliquez sur Save (Enregistrer).
Maintenant que vous avez exporté le code depuis la zone de script vers un fichier de script Python externe, le code n’est plus stocké dans la boîte à outils.
Le chemin d’accès au fichier de script est s’affiche en haut de la zone.
Disposer d’un fichier .py distinct présente l’avantage de pouvoir travailler plus facilement sur le code dans votre éditeur préféré. Mais dans ce didacticiel, vous allez continuer à utiliser IDLE.
Le code affiché dans la fenêtre des propriétés de l’outil n’est plus le code incorporé, mais le code du fichier .py. Vous pouvez néanmoins continuer de modifier le code directement dans la fenêtre des propriétés de l’outil et le fichier .py sera automatiquement enregistré à la fermeture de cette fenêtre.
Pour la suite de ce didacticiel, vous allez généralement ouvrir le fichier .py dans IDLE plutôt que dans la fenêtre des propriétés de l’outil pour le mettre à jour.
- Au bas de la zone du code, cliquez sur le bouton Open in Script Editor (Ouvrir dans l’éditeur de script).
Le fichier .py s’ouvre dans IDLE.
Le chemin et le nom du fichier ne sont plus temporaires.
Remarque :
Il est possible de modifier le fichier de script .py dans la zone de code de l’onglet Execution (Exécution) et dans IDLE en même temps. Ce n’est cependant pas une bonne pratique. Vous obtiendrez un message d’avertissement et devrez déterminer les modifications à conserver. Pour éviter cela, modifiez le script dans une application à la fois seulement.À présent que vous avez importé le code dans un fichier .py, vous allez fermer cette fenêtre.
- Dans la fenêtre Properties (Propriétés), cliquez sur OK.
Vous allez maintenant changer le code afin qu’il corresponde aux paramètres de l’outil de script.
- Dans IDLE, après la ligne if __name__ == "__main__":, remplacez les deux lignes de paramètres commençant par param0 et param1 par le code suivant :
inputs = arcpy.GetParameter(0) clip_fc = arcpy.GetParameterAsText(1) gdb = arcpy.GetParameterAsText(2) out_zip = arcpy.GetParameterAsText(3)
Le code mis à jour doit se présenter comme suit :
Remarque :
Il est important que l’indentation des nouvelles lignes corresponde au niveau d’indentation d’origine, à savoir de quatre espaces.Vous définissez quatre paramètres pour l’outil de script. C’est ainsi que le script Python va recevoir ces quatre paramètres.
Les paramètres peuvent être obtenus de l’outil de script à l’aide des fonctions ArcPy GetParameter() et GetParameterAsText(). L’interface utilisateur transmet les paramètres au script sous forme de tuple Python, un type de données ordonnées qui utilise l’indexation de base zéro. Le premier paramètre commence à l’index 0, le second à l’index 1, et ainsi de suite. Ces valeurs d’index sont référencées par les numéros entre parenthèses à la fin de chaque nouvelle ligne. Si l’ordre de ces numéros ne correspond pas à celui des paramètres dans l’interface utilisateur de l’outil, le script obtient des valeurs de données incorrectes.
Remarque :
À partir d’ArcGIS Pro 3.2, vous pouvez également faire référence aux paramètres par leur nom. Par exemple, au lieu d’utiliser arcpy.GetParameter(0), vous pouvez utiliser arcpy.GetParameter("Input_feature_layers"). Vous pouvez ainsi saisir les paramètres dans n’importe quel ordre, sans avoir besoin de connaître l’index de chacun.Le premier paramètre se compose d’une liste Python contenant plusieurs noms de classe d’entités en entrée. Comme la fonction GetParameter() conserve ce format, elle peut être utilisée pour le premier paramètre. Les autres paramètres sont reçus sont forme de texte à l’aide de GetParameterAsText().
Chaque valeur de paramètre est attribuée à une variable. Les variables sont transmises à la fonction ClipZip. Les noms de variable sont choisis pour être cohérents avec le code dans le script autonome existant.
- Modifiez la ligne ClipZip(param0, param1) pour remplacer param0, param1 par les variables contenant les valeurs de paramètre :
ClipZip(inputs, clip_fc, gdb, out_zip)
La modification doit se présenter comme suit :
Cette ligne appelle la fonction ClipZip() avec ces paramètres.
- Supprimez la ligne arcpy.SetParameterAsText(2, "Result").
Cet outil de script n’utilise pas cette ligne du modèle.
Vous allez maintenant mettre à jour la définition de la fonction ClipZip().
- Modifiez la ligne def ClipZip(param0, param1): pour remplacer param0, param1 par les variables contenant les valeurs de paramètre :
def ClipZip(inputs, clip_fc, gdb, out_zip):
La modification doit se présenter comme suit :
Cela définit l’acceptation des quatre paramètres par la fonction ClipZip().
Les variables de la définition de la fonction ne doivent pas obligatoirement utiliser les mêmes noms que l’onglet Parameter (Paramètre), mais l’ordre des variables doit être le même. Les noms de variable de la ligne de définition de la fonction doivent être cohérents avec les variables indiquées dans le bloc de code qui définit ce que fait la fonction (qui doit encore être ajoutée).
- Dans IDLE, cliquez sur File (Fichier), puis sur Save (Enregistrer).
Les modifications que vous avez apportées dans IDLE sont enregistrées dans le fichier de script.
Le script doit ressembler à ce qui suit :
Vous allez maintenant ajouter le code du script d’origine au bloc de code.
Copier le code du script d’origine
Le script d’origine contient le code que vous allez ajouter au bloc de code de votre outil de script.
- Dans IDLE, cliquez sur File (Fichier), puis sur Open (Ouvrir).
- Dans le dossier C:\Tutorials\PythonTool, cliquez sur clip_zip.py, puis sur Open (Ouvrir).
- Dans IDLE, dans le script clip_zip.py, cliquez au début de la ligne # Workspace and datasets, puis cliquez et faites glisser jusqu’à la fin du script pour sélectionner tout le code, sauf les lignes import.
- Cliquez avec le bouton droit sur le code sélectionné, puis choisissez Copy (Copier).
- Dans IDLE, passez à la fenêtre clip_zip_tool.py.
- Sélectionnez le commentaire """Script code goes below""".
- Cliquez avec le bouton droit sur le code sélectionné, puis choisissez Paste (Coller).
Le code est collé dans le bloc de code de la fonction ClipZip.
Vous en avez terminé avec le script d’origine. Vous allez maintenant fermer cette fenêtre et vous concentrer sur le code clip_zip_tool.py.
- Dans IDLE, fermez la fenêtre du script clip_zip.py.
Tout le bloc de code que vous avez copié dans le script clip_zip_tool.py doit être indenté de quatre espaces pour faire partie de la fonction.
Il est possible de faire cela manuellement, en saisissant quatre espaces avant chaque ligne, mais vous pouvez aussi sélectionner les lignes concernées et les indenter toutes en même temps.
Dans notre cas, il est préférable d’indenter toutes les lignes en même temps, car l’espace blanc indenté est significatif dans Python. Or, si vous ajoutez par inadvertance trois espaces, ou cinq, à une ligne, le code ne s’exécutera pas correctement. De plus, comme le code comprend plusieurs lignes et inclut des sections indentées pour les boucles et les conditions, l’ajout manuel de l’indentation risque d’introduire des erreurs.
- Dans IDLE, dans la fenêtre clip_zip_tool.py, cliquez et faites glisser pour sélectionner le code que vous avez collé et qui n’est pas encore indenté de quatre espaces pour le faire correspondre au contenu du bloc de code.
La ligne # Workspace and datasets peut être indentée ou pas, selon que vous avez sélectionné ou non les espaces avant le commentaire """Script code goes below""" lorsque vous avez collé le code.
Veillez à arrêter la sélection avant la ligne return.
- Cliquez sur Format (Mise en forme), puis sur Indent Region (Indenter le bloc).
Les lignes de code sont chacune indentée de quatre espaces.
- Vérifiez que le bloc de code de la fonction ClipZip, les lignes qui suivent la ligne def ClipZip et jusqu’à la ligne return comprise, sont tous indentés de quatre espaces (ou plus, pour les lignes incluses dans des boucles ou dans des instructions conditionnelles).
- Dans IDLE, cliquez sur File (Fichier), puis sur Save (Enregistrer).
Supprimer les valeurs précodées
Plusieurs lignes du script d’origine définissent des variables vers des chemins spécifiques. Cela s’appelle précoder les chemins. Cela est nécessaire pour que le script puisse localiser et traiter les données. Cependant, dans un outil de script, l’utilisateur de l’outil spécifie les entrées et les sorties à l’aide de commandes de l’interface utilisateur de l’outil. Vous avez défini le script pour qu’il utilise arcpy.GetParameter et arcpy.GetParameterAsText pour obtenir ces informations de l’interface utilisateur de l’outil. L’étape suivante consiste à supprimer les lignes précodées.
- Supprimez chacune des lignes qui spécifient un chemin précodé.
Il s’agit des lignes commençant par arcpy.env.workspace = , clip_fc = , gdb = et out_zip =.
- Supprimez la ligne arcpy.env.overwriteOutput = True.
Il est inutile de la conserver, car la propriété overwriteOutput est contrôlée par ArcGIS Pro lorsque le code est exécuté comme outil de script.
- Conservez la ligne de code qui attribue des valeurs aux variables gdb_path et new_gdb en fractionnant la valeur de la variable gdb.
- Vérifiez que la ligne est indente de quatre espaces, au même niveau que le commentaire # Workspace and datasets.
Vous avez supprimé toutes les lignes de code comportant des valeurs précodées. Le script va obtenir les valeurs à partir des paramètres de l’outil de script.
- Enregistrez le script.
Modifier les instructions d’impression en messages
Le script d’origine utilisait des instructions print pour imprimer le statut de la fenêtre IDLE Shell. Or, cela fonctionne uniquement lorsque vous exécutez le script depuis l’éditeur de script. Vous allez donc mettre à jour les instructions print afin qu’elles utilisent arcpy.AddMessage pour envoyer ces informations aux messages de géotraitement.
Il y a trois instructions print. Vous allez en modifier deux et supprimer la troisième.
- Mettez à jour la ligne print(f"Output geodatabase {gdb} created") de sorte à modifier print par arcpy.AddMessage.
La ligne doit maintenant se présenter comme suit :
arcpy.AddMessage(f"Output geodatabase {gdb} created")
L’instruction d’impression suivante dans le code imprime la liste des classes d’entités en entrée. La liste de la classe d’entités de variable inputs est maintenant définie par l’outil de script ; aussi, la ligne qui définit des entrées à l’aide de arcpy.ListFeatureClasses n’est pas nécessaire. Vous allez supprimer cette instruction d’impression et la ligne qui compose la liste.
- Dans la section # Clip each input feature class, sélectionnez la ligne inputs = arcpy.ListFeatureClasses() et la ligne print(inputs), et supprimez-les.
La section doit ressembler à ce qui suit :
Vous allez maintenant mettre à jour la troisième instruction print.
- Mettez à jour la ligne print(f"Output feature class {new_fc} created") de sorte à modifier print par arcpy.AddMessage.
La ligne doit indiquer ce qui suit :
arcpy.AddMessage(f"Output feature class {new_fc} created")
- Dans IDLE, cliquez sur File (Fichier), puis sur Save (Enregistrer).
La dernière section de code qui crée le fichier ZIP ne nécessite aucun changement.
- Fermez IDLE.
Testez l’outil de script.
L’outil de script est maintenant prêt à être testé.
- Dans ArcGIS Pro, dans la fenêtre Catalog (Catalogue), développez la géodatabase DC.gdb.
- Cliquez avec le bouton droit sur bike_routes et cliquez sur Add To Current Map (Ajouter à la carte actuelle).
- Développez la boîte d’outils Clip_and_ZIP.atbx et double-cliquez sur l’outil Clip and ZIP (Découper et zipper).
L’outil Clip and ZIP (Découper et zipper) s’ouvre.
- Pour le paramètre Input feature layers (Couches d’entités en entrée), cliquez sur le bouton en forme de flèche Add Many (Ajouter plusieurs).
- Dans la zone Add Many (Ajouter plusieurs), cochez bike_racks, bike_routes et bus_lines, puis cliquez sur Add (Ajouter).
- Pour le paramètre Clip Polygons (Polygones de découpage), sélectionnez la couche neighborhood.
- Pour le paramètre Output geodatabase (Géodatabase en sortie), saisissez C:\Tutorials\PythonTool\Clip.gdb
- Pour le paramètre Output ZIP archive (Archive ZIP en sortie), saisissez C:\Tutorials\PythonTool\Clip.zip
- Cliquez sur Run (Exécuter).
L’outil s’exécute. À l’issue de l’exécution, une bannière verte indiquant qu’il a terminé s’affiche au bas de l’outil.
- Sur la bannière, cliquez sur View Details (Afficher les détails).
La section Messages de l’outil affiche les messages qui ont été générés par l’outil, en utilisant le code que vous avez modifié, d’instructions print en arcpy.AddMessage.
- Fermez la fenêtre Details (Détails).
- Cliquez sur l’onglet Catalog (Catalogue).
La géodatabase Clip.gdb a été ajoutée au dossier du projet.
L’archive ZIP n’apparaît pas dans la fenêtre Catalog (Catalogue), mais vous pouvez utiliser Windows File Explorer pour vérifier qu’elle a bien été créée.
Vous avez créé un outil de script Python qui fonctionne. L’outil contient des paramètres en entrée et en sortie, et certains filtres de base qui peuvent leur être appliqués pour empêcher la survenue de problèmes courants.
Dans la section suivante, vous allez apprendre à ajouter du code de validation supplémentaire pour renforcer votre script.
Améliorer l’outil avec la validation
Les outils de script sont conçus pour utiliser les entrées de l’utilisateur. La validation sert à garantir que celles-ci ont du sens et qu’elles ne produisent pas d’erreur. La première étape de la validation consiste à concevoir avec soin les paramètres de l’outil. Par exemple, le paramètre Clip Polygons (Polygones de découpage) comporte un filtre qui permet de s’assurer que seules des entités surfaciques sont sélectionnées. Dans cette section, vous allez découvrir d’autres approches en matière de validation.
Ajouter une recherche de classes d’entités vides
Prenons un scénario dans lequel une des classes d’entités en sortie est vide. Cela se produit lorsque aucune des entités d’une classe d’entités en entrée n’est comprise dans les limites du polygone de découpage. Dans ce cas, il est utile de générer un message indiquant que la sortie est vide.
- Dans la fenêtre Catalog (Catalogue), cliquez avec le bouton droit de la souris sur Clip and ZIP (Découper et zipper), puis cliquez sur Properties (Propriétés).
- Cliquez sur l'onglet Execution (Exécution).
- Dans la section # Clip each input feature class, sélectionnez la ligne arcpy.AddMessage(f"Output feature class {new_fc} created").
- Remplacez la ligne par le code suivant :
count = int(arcpy.management.GetCount(new_fc)[0]) if count > 0: arcpy.AddMessage(f"Output feature class {new_fc} created") else: arcpy.AddWarning(f"Output feature class {new_fc} created but does not contain any features.")
- Vérifiez que l’indentation du code correspond à cette image :
Le nouveau code commence par la ligne count = int(arcpy.management.GetCount(new_fc)[0]), qui obtient le nombre d’entités présentes dans la classe d’entités en sortie. Cette ligne doit être indentée au même niveau que la ligne précédente, qui commence par arcpy.analysis.Clip.
La ligne suivante contient une instruction conditionnelle if qui détermine si la nouvelle classe d’entités contient des entités. Si elle en contient, le bloc conditionnel s’exécute et ajoute le message d’origine. Si elle n’en contient pas, le bloc else s’exécute et arcpy.AddWarning est utilisé pour ajouter un message d’avertissement qui indique que la classe d’entités a été créée, mais qu’elle est vide. Les deux lignes conditionnelles, après if et else, doivent être indentées de quatre espaces, comme les lignes précédentes.
- Cliquez sur OK pour fermer la fenêtre Properties (Propriétés) de l’outil et enregistrer vos modifications
- Double-cliquez sur l’outil Clip and ZIP (Découper et zipper)
- Dans la fenêtre Input feature layers (Couches d’entités en entrée), cliquez sur Parcourir puis, dans la géodatabase DC.gdb, cliquez sur la classe d’entités points_outside, puis sur OK.
Cette classe d’entités contient des entités ponctuelles qui se trouvent toutes en dehors du polygone des shapefiles avoisinants. Vous allez l’utiliser pour tester l’outil.
- Pour la deuxième des Input feature layers (Couches d’entités en entrée), sélectionnez la couche bike_routes sur la carte.
- Pour le paramètre Clip Polygons (Polygones de découpage), sélectionnez la couche d’entités neighborhood.
- Pour le paramètre Output geodatabase (Géodatabase en sortie), saisissez le chemin suivant : C:\Tutorials\PythonTool\Clip.gdb.
- Pour le paramètre Output ZIP archive (Archive ZIP en sortie), saisissez le chemin suivant : C:\Tutorials\PythonTool\Clip.zip.
- Cliquez sur Run (Exécuter).
L’outil s’exécute. À l’issue de l’exécution, une bannière jaune indiquant qu’il a terminé, mais avec des avertissements, s’affiche au bas de l’outil.
- Sur la bannière, cliquez sur View Details (Afficher les détails).
La section Messages de l’outil affiche les messages qui ont été générés par le code mis à jour. Un message d’avertissement indique que la classe d’entités points_outside a été créée mais qu’elle ne contient pas d’entité.
Les autres messages de l’outil sont également présents, comme prévu.
- Fermez les messages Clip and ZIP (Découper et zipper) et l’outil Clip and ZIP (Découper et zipper).
Ce type de validation intervient après l’exécution de l’outil et la création des sorties. Il est également possible d’utiliser la validation avant d’exécuter l’outil.
Utiliser la validation pour rechercher les entrées vides
Prenons un scénario dans lequel les polygones de découpage sélectionnés par un utilisateur comprennent une classe d’entités vide. Les entrées étant valides, aucune erreur n’est générée. Pourtant, les sorties ne sont pas pertinentes puisque toutes les nouvelles classes d’entités créées sont vides. S’il existe un moyen de savoir à l’avance que les sorties ne seront pas pertinentes, idéalement, l’outil ne doit pas s’exécuter.
Vous allez modifier les propriétés de l’outil de script et ajouter une recherche d’entrée vide. Ce type de validation n’est pas ajouté au fichier de script, mais il utilise un type de validation différent.
- Dans la fenêtre Catalog (Catalogue), cliquez avec le bouton droit de la souris sur Clip and ZIP (Découper et zipper), puis cliquez sur Properties (Propriétés).
- Cliquez sur l’onglet Validation.
L’onglet Validation affiche une zone de code, mais il ne s’agit pas d’un fichier de script. Le code indiqué ici ne réside que dans les propriétés de l’outil et n’est pas stocké dans un fichier .py distinct. L’onglet Validation contient le modèle de code que vous pouvez utiliser comme point de départ.
Le modèle de code affiche une classe nommée ToolValidator. Cette classe inclut plusieurs méthodes utilisées pour différents types de validation. La plupart des validations interviennent avant l’exécution de l’outil.
Vous pouvez modifier le code directement dans la zone de code ou ouvrir le code dans un fichier de script temporaire en cliquant sur Open in Script Editor (Ouvrir dans un éditeur de script).
- Cliquez sur Open in Script Editor (Ouvrir dans l’éditeur de script).
- Dans la section def updateMessages, sélectionnez les deux lignes de commentaire.
- Sélectionnez les trois lignes dans le bloc de code def updateMessages.
- Remplacez les commentaires et l’instruction return en copiant et en collant le code suivant :
# When the clip polgyon feature set, feature layer or # feature class does not contain any features, a warning # message appears in the tool dialog since this would result # in empty feature classes in the new geodatabase. if self.params[1].value: count = int(arcpy.management.GetCount(self.params[1].value)[0]) if count < 1: self.params[1].setWarningMessage("No clip features. This results in empty outputs.") return
Le code est collé dans la définition de méthode. Il y a toutefois un problème. La première ligne de commentaire est indentée correctement, mais les lignes suivantes doivent être indentées de quatre espaces de plus.
- Sélectionnez les lignes devant être indentées.
- Cliquez sur Format (Mise en forme), puis sur Indent Region (Indenter le bloc).
- Vérifiez que l’indentation est correcte à présent.
- Dans IDLE, cliquez sur File (Fichier), puis sur Save (Enregistrer).
- Fermez IDLE.
Dans ArcGIS Pro, un avertissement indiquant que des modifications ont été apportées s’affiche.
- Cliquez sur Oui.
- Cliquez sur OK pour fermer la fenêtre des propriétés de l’outil.
- Double-cliquez sur l’outil Clip and ZIP (Découper et zipper).
- Pour Input feature layers (Couches d’entités en entrée), ajoutez les couches bike_racks et bike_routes.
- Pour le paramètre Clip Polygons (Polygones de découpage), cliquez sur Parcourir puis, dans la géodatabase DC.gdb, cliquez sur la classe d’entités polygon_empty, puis sur OK.
La classe d’entités polygon_empty est une classe d’entités surfaciques qui ne contient pas d’entité.
Une icône d’avertissement apparaît en regard de la zone de saisie Clip Polygons (Polygones de découpage).
- Pointez le curseur sur l’icône d’avertissement.
Le code de validation de l’outil que vous avez ajouté détecte que la classe d’entités surfaciques est vide et émet un message d’avertissement.
Un message d’avertissement n’empêche pas l’utilisateur d’exécuter l’outil, mais le prévient à l’avance de ce que seront les résultats. Si vous utilisez setErrorMessage au lieu de setWarningMessage, un message d’erreur s’affiche et empêche l’outil de s’exécuter. Lors de la création de l’outil, vous devez bien réfléchir au type de message le plus pertinent.
Remarque :
Le code de validation utilisé ici inclut l’outil Get Count (Compter). Cet outil s’exécute lorsqu’une valeur a été sélectionnée pour le paramètre. En règle générale, il n’est pas intéressant d’utiliser des outils de géotraitement dans le code de validation, car cela peut prendre beaucoup de temps et entraîner des problèmes inattendus. Mais l’outil Get Count (Compter) est une exception à cette règle, car il est très simple et rapide à exécuter, même avec des jeux de données très volumineux.
Ajouter des valeurs par défaut
Un autre type de validation d’outil consiste à renseigner automatiquement les paramètres de l’outil avec des valeurs par défaut. Cette technique est employée dans de nombreux outils de géotraitement. Par exemple, lorsque vous exécutez l’outil Clip (Découper), le nom de la classe d’entités en sortie est par défaut celui de la classe d’entités en entrée, suivi de _Clip. Pour l’outil Clip and ZIP (Découper et zipper), il n’existe pas de valeurs par défaut pour les paramètres Output geodatabase (Géodatabase en sortie) et Output ZIP archive (Archive ZIP en sortie). Vous pouvez ajouter des valeurs par défaut au code de validation.
- Fermez l’outil Clip and Zip (Découper et zipper).
- Ouvrez l’outil Properties (Propriétés) et cliquez sur l’onglet Validation.
- Cliquez sur Open in Script Editor (Ouvrir dans l’éditeur de script).
- Dans IDLE, sélectionnez les trois lignes dans le bloc de code def updateParameters.
- Remplacez les lignes par le code suivant :
# The output geodatabase and ZIP archive are given default # names of Clip.gdb and Clip.zip, respectively, inside the # workspace of the project. Users can specify a different # file name and folder. if self.params[0].value and self.params[1].value: folder = os.path.split(arcpy.env.workspace)[0] self.params[2].value = os.path.join(folder, "Clip.gdb") self.params[3].value = os.path.join(folder, "Clip.zip") return
- Examinez le code que vous avez collé.
La première ligne de commentaire est indentée correctement, mais toutes les autres doivent être indentées de quatre espaces de plus.
- Sélectionnez les lignes devant être indentées, puis cliquez sur Format (Mise en forme) et sur Indent Region (Indenter le bloc).
Le problème d’indentation est résolu.
- Dans IDLE, cliquez sur File (Fichier), puis sur Save (Enregistrer).
- Fermez IDLE.
- Dans ArcGIS Pro, dans le message d’avertissement qui apparaît, cliquez sur Yes (Oui).
- Cliquez sur OK pour fermer la fenêtre des propriétés de l’outil.
- Double-cliquez sur l’outil Clip and ZIP (Découper et zipper).
- Pour Input feature layers (Couches d’entités en entrée), ajoutez les couches bike_racks et bike_routes.
- Pour le paramètre Clip Polygons (Polygones de découpage), sélectionnez la couche neighborhood.
Aussitôt qu’une valeur est attribuée aux deux premiers paramètres, le troisième et le quatrième paramètres sont renseignés avec leurs valeurs par défaut. Un message d’avertissement s’affiche, car les fichiers Clip.gdb et Clip.zip existent déjà.
L’outil peut être exécuté malgré ces avertissements, mais vous pouvez aussi changer les noms de sortie et l’exécuter ensuite.
Dans ce didacticiel, vous avez appris à créer un outil de script qui offre une interface conviviale pour le code Python. Vous avez vu comment configurer des paramètres pour l’outil de script et modifier le code de sorte à l’autoriser à accepter des paramètres de cet outil. Vous avez également appris à supprimer des chemins précodés et à ajouter des messages return relatifs au code. Enfin, vous avez découvert comment ajouter une validation au code afin de le rendre plus robuste.