Procédure d'identification des données de projet dans votre script

Chaque fois que vous partagez un résultat, que ce soit en tant que paquetage ou service, et que le résultat fait référence à un outil de script, cet outil est analysé afin de rechercher toutes les données de projet utilisées dans le script. Une fois les données de projet identifiées, ces données sont consolidées dans un dossier temporaire qui est empaqueté (si vous partagez un paquetage) ou téléchargé sur le serveur (si vous partagez un service).

A l'issue de l'analyse du script, chaque chaîne entre guillemets (simples ou doubles) utilisée dans une variable Python ou en tant qu'argument d'une fonction est testée afin de vérifier que la chaîne correspond à un chemin d'accès aux données existantes. Dans ce cas, on entend par données

• Une couche dans la table des matières. (ArcMap ou ArcGlobe)
• un dossier,
• un fichier,
• un jeu de données géographiques comme une classe d'entités, un fichier de formes, une géodatabase, un document ArcMap (.mxd) et un fichier de couche (.lyr).

Dans le cadre de cette discussion, seules les données utilisées en entrée dans les outils de géotraitement ou chemins faisant référence à d'autres modules Python méritent notre attention. Les données en sortie sont également consolidées mais ne sont pas considérées comme des données de projet.

Chaque fois qu'une chaîne entre guillemets est identifiée dans le script, le test visant à vérifier l'existence de données se déroule comme suit :

1. La chaîne fait-elle référence à une couche dans la table des matières ?
2. La chaine contient-elle un chemin absolu d'accès aux données (comme "e:\Warehousing\ToolData\SanFrancisco.gdb\streets") ?
3. La chaîne fait-elle référence à des données que l'on peut rechercher par rapport à l'emplacement du script ? L'emplacement du script est défini comme suit :
   • Dossier contenant le script.
   • Si le script est incorporé dans la boîte à outils, l'emplacement correspond au dossier qui contient la boîte à outils.
   • Si le script se trouve dans une boîte à outils Python, l'emplacement correspond au dossier qui contient la boîte à outils Python.

Ces tests se déroulent suivant un ordre séquentiel. Si le test est réussi et que les données existent, les données sont consolidées sauf dans le cas suivant : si vous partagez un service, le magasin de données du serveur est analysé afin de savoir si les données résident dans le magasin de données. Le cas échéant, les données ne sont pas consolidées.

Exemples

Les exemples ci-après reposent sur cette structure de dossier :

Chemins relatifs et dossiers

La technique suivante d'identification des données par rapport à l'emplacement du script correspond à un schéma classique, en particulier pour les services créés pour ArcGIS 10.0. Pour information, le code de script qui suit réside dans le dossier Scripts illustré ci-dessus. Le dossier ToolData contient une géodatabase fichier SanFrancisco.gdb. La géodatabase fichier SanFrancisco.gdb contient une classe d'entités appelée Streets. Dans l'échantillon de code ci-après, le chemin d'accès au dossier ToolData est construit par rapport à l'emplacement du script (le dossier Scripts).

import arcpy import os import sys
# Get the directory the script lives in.
# Folders will be found relative to this location.
#
scriptPath = sys.path[0]
# Construct paths to ../ToolData/SanFrancisco.gdb/Streets and
#                    ../ToolData/Warehouse.lyr
#
toolDataPath = os.path.join(scriptPath, "..", "ToolData")
streetFeatures = os.path.join(toolDataPath, "SanFrancisco.gdb", "Streets")
streetLyr = os.path.join(toolDataPath, "Warehouse.lyr")

Dans le code ci-dessus, la chaîne "ToolData" (un argument de la fonction os.path.join) est testée afin de vérifier s'il s'agit de données qui existent. Dans ce cas, il existe un dossier appelé ToolData, par rapport à l'emplacement du script. Ce dossier ToolData sera consolidé, c'est à dire que tout son contenu (à l'exception des sous-dossiers comme indiqué plus haut) sera empaqueté ou téléchargé sur le serveur (sauf si le dossier ToolData fait partie du magasin de données du serveur).

Il convient de noter que c'est le contenu de ce dossier qui est copié, et non pas les fichiers individuels. Par exemple, dans le code ci-dessus, le chemin d'accès au jeu de données e:/Warehousing/ToolData/SanFrancisco.gdb/Streets est créé. Le processus de consolidation ne permet pas d'isoler et de copier uniquement le jeu de données Streets, il copie l'intégralité du dossier ToolData.

Chemin absolu d'accès à un jeu de données géographiques

On appelle chemin absolu un chemin qui commence par la lettre d'une unité, comme e:/, comme illustré dans l'échantillon de code ci-après.

import arcpy import os
streetFeatures = 'e:/Warehousing/ToolData/SanFrancisco.gdb/Streets'

Dans le code ci-dessus, le jeu de données Streets et toutes les autres données dont il dépend (comme les classes de relations et les domaines) seront consolidés.

Exemple hybride

import arcpy import os
toolDataPath = r'e:\Warehousing\ToolData'
warehouseLyr = os.path.join(toolDataPath, "Warehouse.lyr")

Dans le code ci-dessus, l'intégralité du contenu du dossier ToolData est consolidé. Comme le contenu du dossier (en dehors des sous-dossiers) est consolidé, Warehouse.lyr est également consolidé, ainsi que toutes les données auxquelles Warehouse.lyr fait référence.

thePath = r"E:\data\telluride\newdata.gdb\slopes"

Importation d'autres modules Python

Votre script peut importer d'autres scripts développés par vos soins. Par exemple, le code ci-dessous illustre l'importation d'un module Python intitulé myutils.py, qui se trouve dans le même répertoire que le script parent, et qui contient une routine nommée getFIDName. getFIDName.

import arcpy import myutils inFeatures = arcpy.GetParameterAsText(0)
inFID = myutils.getFIDName(inFeatures)

Chaque fois qu'une instruction importer est rencontrée, l'ordre suivant est utilisé pour localiser le script :

• Dossier identique à celui du script. Si le script est incorporé dans la boîte à outils, le dossier qui contient la boîte à outils est utilisé.
• Dossier référencé par la variable d'environnement système PYTHONPATH.
• Tout dossier référencé par la variable d'environnement système PATH.

Une autre technique de référencement des modules à importer consiste à utiliser la méthode sys.path.append . Cette méthode permet de définir un chemin d'accès à un dossier contenant les scripts que vous devez importer.

import arcpy import sys import os
# Append the path to the utility modules to the system path
#  for the duration of this script.
#
myPythonModules = r'e:\Warehousing\Scripts'
sys.path.append(myPythonModules)
import myutils # a Python file within myPythonModules

Dans le code ci-dessus, il convient de noter que la méthode sys.path.append nécessite un dossier en tant qu'argument. Comme 'e:\Warehousing\Scripts' est un dossier, l'intégralité du contenu du dossier sera consolidé. Les règles de copie du contenu d'un dossier s'appliquent également dans ce cas, tout le contenu du dossier est copié à l'exception des sous-dossiers qui ne correspondent pas à des jeux de données géographiques.

Code de validation d'un outil

Si vous avez l'habitude d'écrire des outils de script, vous pouvez fournir votre propre logique de validation d'outil. Les clients du service de géotraitement n'ont pas la possibilité d'exécuter votre logique de validation d'outil. Seul le serveur peut le faire. Lorsque le client envoie sa demande de tâche d'exécution au service, votre logique de validation est exécutée sur le serveur. Si vos routines de validation génèrent une erreur, la tâche interrompt l'exécution. Si vous êtes en train de renvoyer des messages à partir de votre service, le client reçoit les messages générés par vos routines de validation.

La logique de validation est implémentée avec Python et le code de validation est analysé pour identifier les données de projet et les modules, comme pour tout autre script Python. Ainsi, la logique de validation peut ouvrir un dossier (par exemple, d:\approved_projections) contenant des fichiers de projection (.prj) pour créer une liste de choix de références spatiales à l'intention des utilisateurs qui exécutent l'outil. Ce dossier n'est pas un paramètre d'outil ; il s'agit des données de projet utilisées dans le script de validation de l'outil. Les mêmes règles que celles décrites ci-dessus pour les scripts Python s'appliquent ici : le dossier d:\approved_projections est consolidé et copié sur le serveur (à moins qu'il ne figure déjà dans le magasin de données du serveur).

Création des données de projet et des paramètres d'outil des modules

Comme décrit ci-dessus, les scripts Python sont analysés lorsqu'ils sont partagés et les décisions sont prises pour savoir quelles données sont utilisées par le script en fonction des chaînes entre guillemets trouvées dans le code. Si vous voulez contrôler ce processus, vous pouvez utiliser la méthode qui consiste à créer des paramètres pour toutes les données et tous les modules utilisés par le script. L'échantillon de script ci-dessous illustre le concept, toutes les données de projet et tous les modules sont convertis en paramètres qui sont transmis au script.

import arcpy import sys import os
inFeatures = arcpy.GetParameterAsText(0)            # Feature Layer projectDataFolder = arcpy.GetParameterAsText(1)     # Folder myPythonModules = arcpy.GetParameterAsText(2)       # Folder
# Append the path to the utility modules to the system path
#  for the duration of this script.
#
sys.path.append(myPythonModules)
import myutils # a Python file within myPythonModules
# Construct a variable to hold the Streets feature class found in the
#  project data folder
#
streetsFeatures = os.path.join(projectDataFolder, "SanFrancisco.gdb", "Streets")

Lorsque le script utilise les paramètres pour toutes ses données comme illustré ci-dessus, plusieurs événements positifs se produisent :

• Vous connaissez mieux les données dont le script a besoin : comme il s'agit d'un paramètre, il s'affiche dans la boîte de dialogue des outils. Vous n'avez pas besoin de modifier le code pour savoir quelles données vous utilisez.
• La logique de validation de l'outil interne prime : si la valeur du paramètre fait référence à des données qui n'existent pas, la boîte de dialogue des outils renvoie un message d'erreur et vous ne pouvez pas exécuter l'outil permettant de créer un résultat.
• Pour redéfinir l'emplacement des données, vous pouvez rechercher l'emplacement à l'aide de la boîte de dialogue des outils plutôt que de saisir l'emplacement dans le script (ce qui est source d'erreurs).
• Lorsque le résultat est partagé en tant que service, l'éditeur de services définit les paramètres de dossier sur Mode en entrée ou Constante ; de cette manière le client ne voit jamais les paramètres. Lors de la publication, les deux dossiers sont copiés sur le serveur (sauf s'ils sont enregistrés dans le magasin de données). Lorsque votre tâche est exécutée sur le serveur, votre script reçoit les chemins d'accès aux dossiers copiés.

Modules tiers

Les modules tiers (à savoir les modules ne faisant pas partie de l'installation de base de Python) ne sont pas consolidés. Vous devez vous assurer que le module existe et s'exécute correctement sur le serveur. Cela ne s'applique pas aux modules numpy ou matplotlib qui sont installés avec ArcGIS Server.

Prise en main de Python, d'ArcPy et des outils de script

Si vous ne connaissez pas Python, ArcPy et les outils de script, le tableau ci-dessous contient des rubriques qui vous aideront dans votre apprentissage.