Le portail francophone de la géomatique

Merci Nicolas pour ton premier élément de réponse.

Pour réponde à tes questions suivantes :

- Mes scripts sont en fait réellement des procédures qui doivent être exécutées dans un ordre bien défini.
- L'argument dont je parle est général et le même pour tous les scripts qui vont tourner. Il s'agit, pour que tu situes mieux, du numéro de la carte pour laquelle nous voulons générer les vecteurs.
- Bref, j'ai 20 scripts, que je veux batcher, qui servent à générer diverses sortes de vecteurs. Ces scripts doivent être appliquées pour 70 cartes différents. L'argument, repris dnas chaque script est le même...le numéro de la carte. C'est pour ça que je me suis dit qu'il porrait être mis comme argument "global" dans le script "batch".

Je ne sais pas si je suis très claire...mais je pense que ça peut aller.

Merci pour ton aide,

Frédérique

PS : D'accord pour dire que la commande DOS est peu sexy dans son style Ghotic ;-) !

Re-,

Nicolas, j'ai testé ta proposition de code...y a un petit soucis, il les lance tous en même temps alors que j'aimerais qu'ils soient lancés à la suite les uns des autres.

Joël, je travaille avec Python Shell... je vais faire des petits recherches pour voir de quoi tu me parles. Merci pour l'info en tout cas.

Bon après-midi,

Frédérique

Le plus simple mais le moins joli serait d'utiliser la fonction sleep
Elle permet au programme d'attendre un temps défini avant de relancer un autre action.

Elle s'utilise de cette façon :

import time
time.sleep (5)

La variable temps est exprimé en seconde.


Ca peut être une solution simple si tes scripts mettent assez peu de temps à s'executer.

Sinon l'autre solution consisterait à importer tous tes scripts dans un script unique. pour cela il faut ajouter dans les variables d'environnement le chemin d'accès à tes scripts PYTHONPATH = c:\dossier1\script;.... Ainsi un " import script1" fonctionne (sans mettre le ".py")

A+

Oui c'est ça. Travailler avec des fonctions s'apprend très facilement avec Python, dès que tes scripts prennent de l'ampleur cela devient indispensable.

Actuellement tes script sont sous cette forme:

# -*- coding:Latin-1 -*-
import sys, os
import arcgisscripting

# Create the Geoprocessor object
gp = arcgisscripting.create(9.3)
# Récupérer les inputs
input1 = sys.argv[1]
input2 = sys.argv[2]
#Lancer les traitements
gp.addmessage("Traitment 1")

Tu peux écrire ceci sous cette forme

# -*- coding:Latin-1 -*-
import sys, os
import arcgisscripting


def doScript(param1, param2):
    # Create the Geoprocessor object
    gp = arcgisscripting.create(9.3)
    #Execute les traitements
    gp.addmessage("Traitment 1")


# Récupérer les inputs
input1 = sys.argv[1]
input2 = sys.argv[2]
#Lancer les traitements
doScript(input1, input2)

Ici tous ce qui est hors de la fonction est exécuté à la lecture du script. C'est donc la dernière ligne du script qui permet de lancer le code contenu dans la fonction.

Tu peux ensuite importer ce script à partir d'un nouveau script de façon à pouvoir accéder aux fonctions qu'il contient. Pour que l'import fonctionne il suffit simplement que tous tes scripts se trouvent dans le même dossier.

L'idée c'est faire qqchose comme ça :

# -*- coding:Latin-1 -*-
import sys, os
import script1, script2

# Récupérer les inputs
input1 = sys.argv[1]
input2 = sys.argv[2]
#Lancer les traitements
script1.doScript(input1, input2)
script2.doScript(input1, input2)

Toutefois il manque encore un détail à régler pour que cela fonctionne. En effet, tout code importé est exécuté ! Dans cet exemple l'import de script1 entraine l'import de arcgisscripting et surtout va exécuter tout le code en dehors de la fonction doScript. Or ce code n'est utile que lorsque script1 est exécuter en tant que programme principal mais n'a pas de sens lorsqu'on l'importe.

Heureusement il est possible de tester si le programme est exécuter en tant que programme principal avec la condition "if __name__ == '__main__':"

Ce qui nous donne pour script1

# -*- coding:Latin-1 -*-
import sys, os
import arcgisscripting


def doScript(param1, param2):
    # Create the Geoprocessor object
    gp = arcgisscripting.create(9.3)
    #Execute les traitements
    gp.addmessage("Traitment 1")

if __name__ == '__main__':
    # Récupérer les inputs
    input1 = sys.argv[1]
    input1 = sys.argv[2]
    #Lancer les traitement
    doScript(input1, input2)

Cette fois le programme peut être importé sans erreur ou exécuté comme programme principal.

Tout ça peut paraitre déroutant au début mais si on résume il a peu de modification à faire:
1. pour chaque script, réinjecter le code dans une fonction avec numCarte pour paramètre
2. si tu veux pouvoir continuer à les exécuter de façon autonome via une toolbox spécifique: introduire le code permettant de lancer la fonction sous la condition if __name__ == '__main__':
3. créer un nouveau programme qui importe les scripts dont tu as besoin, récupère le paramètre saisi dans ta toolbox (numCarte) et exécute les fonctions importées dans le bon ordre.

Je pense que c'est vraiment la solution la plus propre et logique, je trouve que ça n'a pas vraiment de sens d'utiliser os.system pour exécuter des scripts Python avec Python....