Discussion :

[poalcospe]

Bonjour,

Après de nombreuses recherches sur le net, je n'ai pu trouver la solution répondant à mon problème.

Je suis en train de développer un outil (avec interface graphique) permettant de lancer des scripts python de projets différents.
Afin de ne pas avoir de problème de dépendances, je demande à l’utilisateur de cibler le répertoire du projet ainsi que le script qu'il souhaite lancer.

Pour développer cet outil j'ai donc dans mon IDE un projet "outil_benchmark" qui est le projet intégrant l'IHM, et un projet "projet_test" qui regroupe différents scripts de test à appeler. Evidemment, le but final est que l'outil soit compilé en exécutable et que donc le projet "outil_benchmark" disparaisse de l'IDE.

Dans mon arborescence "projet_test", j'ai:

projet_test

__init__.py

module_1

__init__.py

script_a_lancer.py

module_2

__init__.py

import_particulier.py

Pour être lancé, le "script_a_lancer.py" importe "import_particulier.py". "import_particulier.py" fait lui appel à de nombreux autres import présents dans "projet_test".

Lorsque l'utilisateur entre le répertoire du projet à utiliser, j'utilise

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
sys.path.append('chemin/du/projet')
print (sys.path) #le lien a bien ete ajoute au PYTHONPATH
from module_sous_projet import * #les projets etant gros, j'ai besoin de tout importer en une seule fois
...
proc = subprocess.Popen(['python', 'script_a_lancer.py'])

La lancement se fait, mais plante dès l'import de "import_particulier.py", me disant que ce module n’existe pas...
Pourtant, je vérifie bien plus haut que tout le projet fait parti du PYTHONPATH.

D'où ma question, ai-je oublié quelque chose ou ai-je mal manipulé le package sys ?

Je m'excuse par avance mais je ne peux pas recopier le code ici, il est sur un pc où toutes les sorties de documents sont bloquées par sécurité. Les lignes sont recopiées à la main.

Cordialement,

Poalcospe

[wiztricks]

La lancement se fait, mais plante dès l'import de "import_particulier.py", me disant que ce module n’existe pas...
Pourtant, je vérifie bien plus haut que tout le projet fait parti du PYTHONPATH.

D'où ma question, ai-je oublié quelque chose ou ai-je mal manipulé le package sys ?

Je m'excuse par avance mais je ne peux pas recopier le code ici, il est sur un pc où toutes les sorties de documents sont bloquées par sécurité. Les lignes sont recopiées à la main.

Il ne devrait pas être compliqué de reproduire les chemins et les bouts de code intéressants "ailleurs" que dans une zone confidentielle.
En attendant que vous ayez le temps de faire cela et fournir des détails plus précis, sys.path est construit au lancement de l'interpréteur et ne se propage pas dans l'interpréteur crée par subprocess.open. Donc pour autant que les définitions faites soient correctes, inutile de bricoler sys.path de l'appelant.

note: PYTHONPATH est une variable d'environnement qui servira à construire sys.path

- W

[poalcospe]

Je vais essayé de donner plus de précisions concernant mon code:

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
import sys
import os
import subprocess
import PySide
 
sys.path.append('chemin/du/projet')
print (sys.path) #le lien a bien ete ajoute au PYTHONPATH
from module_sous_projet import * #les projets etant gros, j'ai besoin de tout importer en une seule fois
 
class Benchmark(QtGui.QMainWindow):
 
    def __init__(self,parent=None):
    #initialisation des interfaces graphiques et des signaux
 
    def button(self,MainWindow):
    #construction des buttons, widgets, récupération des valeurs entrées par l'utilisateur
 
    def process(self, new_benchmark): 
        #Lorsque le lien du projet et du script sont référés, le bouton ok active cette fonction
        os.chdir(self.project_path)
        sys.argv = [self.python_script, self.project, self.profile]
        proc = subprocess.Popen(['python', self.python_script])
 
 
 
if __name__=='__main__':
    app = QtGui.QApplication(sys.argv)
    MainWindow = Benchmark()
    MainWindow.show()
    sys.exit(app.exec_())

De ce que je comprend, l'utilisation de sys.path avec subprocess ne sert à rien ? Je devrais plutot utiliser subprocess pour indiquer mon environnement et mes arguments, ou bien utiliser sys pour lancer le script c'est bien ça ?

J'ai du mal à bien comprendre la doc sur subprocess, donc je dois certainement louper des trucs...

[wiztricks]

Salut,

JDe ce que je comprend, l'utilisation de sys.path avec subprocess ne sert à rien ? Je devrais plutot utiliser subprocess pour indiquer mon environnement et mes arguments, ou bien utiliser sys pour lancer le script c'est bien ça ?

Popen admet le paramètre env. C'est un dictionnaire. Vous pouvez y passer PYTHONPATH avec le chemin souhaité. Mais comme vos arborescences ne sont pas claires, pas facile d'essayer pour vous.

- W

[poalcospe]

L'arborescence de mon projet est la suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
<outil_benchmark>
    <__init__.py>
    <main.py>
 
<projet_test>
    <__init__.py>
    <module_1>
        <__init__.py>
        <script_a_lancer.py>
    <module_2>
        <__init__.py>
        <import_particulier.py>

J'ai essayé de modifier PYTHONPATH mais sans succès avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

proc = subprocess.Popen(['python', script], env=dict(PYTHONPATH="D:/Projet/.../projet_test"))

J'espère avoir completé les informations manquantes...

[wiztricks]

Salut,

J'ai fabriqué la structure suivante (et je suis sur Windows):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
<<current directory>>
   + test   (folder inside)       
      + main
        __init__.py
        + m1
            __init__.py
            module1.py
        + m2
            __init__.py
            module2.py

module1 fait "import m2.module2" et print('done')
module2 fait juste "print(__file_)"
à la console Windows:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
$ set PYTHONPATH=
 
$ python test\main\m1\module1.py
Traceback (most recent call last):
  File "test\main\m1\module1.py", line 1, in <module>
    import m2.module2
ImportError: No module named 'm2'

normal... avec le PYTHONPATH

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ set PYTHONPATH=test\main
$
$ python test\main\m1\module1.py
...\forum\test\main\m2\module2.py
done

La même avec subprocess:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> import subprocess as sp
>>> sp.call('python test\main\m1\module1.py')
Traceback (most recent call last):
  File "test\main\m1\module1.py", line 1, in <module>
    import m2.module2
ImportError: No module named 'm2'
1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
>>> sp.call('python test\main\m1\module1.py', env={'PYTHONPATH': r'test\main'})
Fatal Python error: Failed to initialize Windows random API (CryptoGen)
3

C'est parce qu'il manque des choses:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> import os
>>> env = os.environ.copy()
>>> env['PYTHONPATH'] =  r"test\main"
>>> sp.call('python test\main\m1\module1.py', env=env, shell=True)
...\test\main\m2\module2.py
done
0

- W

[poalcospe]

J'ai recopié le code que tu m'as donné en effectuant deux essais deux projets différents.

Je vais déjà un peu plus loin, je n'ai plus d'erreur sur l'import du module2.py

Par contre, dans ce module2.py qui fait de multiples autres imports, j'ai une erreur un import Mobile.pyc, alors qu'il est bien présent dans site-packages.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Traceback (most recent call last):
    File "Path\to\module1.py", line 1, in <module>
        from module2.imports import *
    File "Path\to\module2\__init__.py", line 6, in <module>
        from Mobile import *
ImportError: No module named Mobile

Afin d'être sur que ça ne venait pas du projet, j'ai essayé avec un autre. Cette fois ci c'est l'un des imports présents dans c:\python31\lib qui n'est pas trouvé, alors que les 3 précédents le sont:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
import sys
import os
import functools
import configparser
 
 
Traceback (most recent call last):
    File "Path\to\new\project\module.py", line 16, in <module>
        import configparser
ImportError: No module named configparser

Faut-il ré ajouter dans le PYTHONPATH les librairies présentes dans c:\python31 ?

NB: configparser est importé dans mon main.py qui lance mon IHM.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
import sys
import os
import functools
import configparser
import time
import subprocess
import PySide
 
env=os.environ.copy()
env["PYTHONPATH"]=r'Path\\to\\test_project'

[wiztricks]

Salut,

Sans fournir de quoi reproduire le problème constaté...
Déjà, il faut chercher les ennuis pour écrire "env["PYTHONPATH"]=r'Path\\to\\test_project'"...

- W

[josmiley]

Déjà, il faut chercher les ennuis pour écrire "env["PYTHONPATH"]=r'Path\\to\\test_project'"...

- W

Lol, et je lol rarement...

[poalcospe]

C'est parce qu'il manque des choses:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> import os
>>> env = os.environ.copy()
>>> env['PYTHONPATH'] =  r"test\main"
>>> sp.call('python test\main\m1\module1.py', env=env, shell=True)
...\test\main\m2\module2.py
done
0

- W

J'avoue ne pas comprendre; n'est pas ce que tu avais marqué ?

[wiztricks]

J'avoue ne pas comprendre; n'est pas ce que tu avais marqué ?

Dans r'Path\\to\\test_project'", vous doublez les '\' et le "r" ("raw string") dit de ne pas les interpréter comme caractère d’échappement.
C'est ce genre d'imprécision qui fait la différence entre du code "fonctionnel": on peut l'exécuter pour reproduire un problème et même si on n'en comprend pas la cause, on a une base de travail... et une histoire illustrée par des lignes de code.
On peut écouter l'histoire mais comme il est difficile de communiquer le contexte, pas facile d'avancer sans que avoir de quoi reproduire le problème constaté...

- W

[poalcospe]

Je vois, c'est une règle dont je n'étais pas au courant.

Ceci étant dit, il semblerait que mon problème d'import était finalement du au projet contenant le script que j'appelais. Pour une raison encore inconnue ce script qui était fonctionnel il y a encore 1 mois ne l'est plus aujourd'hui.

Ayant découvert cela, je me suis également rendu compte que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
sys.path.append(os.path.abspath('D:/Project/Python/test_base'))
from test_project import *
subprocess.Popen(['python', 'D:/Project/Python/test_base/test_project/module1/test_script.py'])

fonctionnait et me lançait bien le script en question.

Maintenant je vais avoir besoin de passer des arguments à test_script.py pour lancer son exécution. test_script.py devra à son tour retourner un statut à main.py.
J'ai vu que subprocess comportait deux méthodes adaptées à ce que je souhaite faire; subprocess.Popen() et subprocess.call() (les deux fonctionnent pour appeler mon script).

Quelle est la différence entre ces deux méthodes ? De ce que j'ai pu comprendre, subprocess.Popen() est plus adaptée pour la communication entre scripts est-ce bien ça ?

[wiztricks]

Salut,

Ayant découvert cela, je me suis également rendu compte que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
sys.path.append(os.path.abspath('D:/Project/Python/test_base'))
from test_project import *
subprocess.Popen(['python', 'D:/Project/Python/test_base/test_project/module1/test_script.py'])

fonctionnait et me lançait bien le script en question.

Les tribulations avec le path sont liées a ce que test_script faisait un import de ../module2/autre_script.py qui plante sans avoir définit PYTHONPATH. Et comme c'est un problème qu'on sait reproduire, il ne peut disparaître.
Pour lancer un script "normal", faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
#sys.path.append(os.path.abspath('D:/Project/Python/test_base'))
#from test_project import *
subprocess.Popen(['python', 'D:/Project/Python/test_base/test_project/module1/test_script.py'])

doit suffire.

Quelle est la différence entre ces deux méthodes ? De ce que j'ai pu comprendre, subprocess.Popen() est plus adaptée pour la communication entre scripts est-ce bien ça ?

Popen facilite les échanges de messages via les canaux d'entrée sortie standards (stdin, stdout,...) entre les deux process: c'est asynchrone, vous pouvez récupérer facilement les canaux,... Ceci dit "call" est suffisant si vous voulez seulement appeler un script avec paramètres et récupérer le statut de fin (et travailler en "synchrone"). Après pour les détails, il faut commencer par lire la documentation, voir des exemples,...
Comme vous utilisez PySide, QProcess est aussi un bon candidat.

- W

[poalcospe]

Merci pour ta réponse.

J'ai creusé les deux pistes; QProcess et subprocess. Malheureusement il semble qu'une des deux classes ne puisse me renvoyer des valeurs, mais uniquement le stdout de la console. Je m'explique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import time
import csv
 
class Profile_loading${Name}(object) :  
    '''
    @Script: ${module}.py
    @Author: ${user}
    @Created on ${date}
    @Description: ${cursor}
    @Req: 
    @Destructive: no 
    '''
 
	def __init__(self, project=None, profile=None, measure=None):
		self.project=project
		self.profile=profile
		self.measure=measure
		self.timing_list=[]
		self.loading_list=[]
 
	def process(self):
		Log.LogInfo("	##------------------------ PROFILE 1 LOADING PROCESS ------------------------")
		for i in range(0,2):
			'''
                        loading....
                        '''		 
			self.loading_list.append(loading_time)
 
		for i in range(0, len(self.measure)):
			self.timing_list.append(self.measure[i] + self.loading_list[i])
 
		return self.timing_list, self.loading_list
 
 
#=================================================================
if __name__ == "__main__":
    Profile_loading = Profile_loading(project='P1', profile='c:\User\Profiles\profile1.txt', measure=[2.33,5.36,4.23])
	Profile_loading.process()

Cette classe est appelée par ma classe Main, et je souhaite récupérer dans mon Main les deux listes. Ce script étant dans un projet différent, je dois utiliser subprocess ou QProcess pour le lancer. J'ai l'impression après plusieurs recherches et essais (notamment subprocess.check_output(), subprocess.call(), subprocess.Popen()) que l'on ne peut que récupérer ce qui sort de la console, mais pas les valeurs que l'on veut retourner. Vrai ou y a-t-il un moyen de le faire ?

[wiztricks]

Cette classe est appelée par ma classe Main, et je souhaite récupérer dans mon Main les deux listes. Ce script étant dans un projet différent, je dois utiliser subprocess ou QProcess pour le lancer. J'ai l'impression après plusieurs recherches et essais (notamment subprocess.check_output(), subprocess.call(), subprocess.Popen()) que l'on ne peut que récupérer ce qui sort de la console, mais pas les valeurs que l'on veut retourner. Vrai ou y a-t-il un moyen de le faire ?

Je ne sais pas ce que signifie "cette classe est appelée par ma classe Main". Si vous voulez appelez une classe d'un module externe, il faut passer par "import". Et dans ce cas, il faut effectivement ajouter le chemin dans sys.path pour qu'import fonctionne.
Sinon, oui, à priori, un process externe (lancé avec Popen ou autre) ne sait communiquer qu'avec stdin, stdout, stderr,... et si vous voulez échanger des objets Python (comme des listes de...) il faut sérialiser vos objets avec pickle et les transférer explicitement.
note: tester un programme avec Popen, c'est le lancer comme le lancerait un utilisateur. Il n'a pas à en connaître la structure interne. Si vous devez connaître la structure interne, vous ne faites pas non plus le même type de tests. Et vous avez déjà des bibliothèques "standard" comme unittest qui vous permettent de les mettre en place.

- W