Indicateur d'activité

**guy16** · 01/06/2015, 10h59

Bonjour,

J'aimerais qu'un throbber s'affiche dans mon interface lorsqu'un script est lancé.
Le throbber s'affiche mais au mauvais moment..

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
    def startThrobber(self):
 
        self.movie_screen = QLabel()
        main_layout = QVBoxLayout()
        main_layout.addWidget(self.movie_screen)
        ui.throbberTab2.setLayout(main_layout)
        byteF = QByteArray()
        gif = "D:\Projet\Various\Images\image.gif"
        movie = QMovie(gif, byteF)
        movie.setCacheMode(QMovie.CacheAll)
        movie.setSpeed(100)
        self.movie_screen.setMovie(movie)
        movie.start()
 
        return movie
 
    def stopThrobber(self):
        movie1 = self.startThrobber()
        movie1.stop()
 
    def go(self):
 
        if ui.chkbox.isChecked():
            self.startThrobber()
 
            os.system(r'"C:\Program Files\FME\fme.exe"................) # lancer le script
            self.stopThrobber()

J'ai essayé avec un Thread (sans réussir) mais on m'a dit qu'il n'y en a pas besoin ici..
Comment faire ?

**guy16** · 01/06/2015, 11h09

Je viens de penser à qqch..
Si je mets le script (os.system) dans un Thread et je laisse le throbber dans le code principal, c'est peut-être mieux nan ?

**wiztricks** · 01/06/2015, 12h11

Salut,

Envoyé par guy16

Je viens de penser à qqch..
Si je mets le script (os.system) dans un Thread et je laisse le throbber dans le code principal, c'est peut-être mieux nan ?

Si c'est mieux c'est parce qu'alors, l'exécution du script ne bloque pas les affichages du GUI.
De toutes façons, pour lancer un script externe, il est préférable de passer par QProcess (dans le monde Qt) ou subprocess.Popen (dans le monde Python) et de préciser qu'on ne veut pas "bloquer" en attendant la fin (ce qui est parfois le défaut mais lire la doc.).
Cela évite d'avoir à créer un Thread (aysnchrone) qui lance un os.system(synchrone).

- W

**guy16** · 01/06/2015, 12h34

Merci!
Je teste subprocess pour voir. Le paramètre pour ne pas "bloquer" est Shell qu'il faut mettre en False ?

**guy16** · 02/06/2015, 11h42

Re !

Je n'arrive toujours pas à faire marcher mon code (lancer un throbber, lancer un script FME avec subprocess et arrêter le throbber une fois le script FME terminé)

Code :

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

1
2
3
4
5
6
7
8
9
10
    def go(self):
 
        if ui.chkbox.isChecked():
 
            self.startThrobber()
            script = subprocess.Popen(r'"C:\Program Files\FME\fme.exe" ................', shell=False)
 
            print(script)
 
            self.stopThrobber() # ouvre fenêtre pop up avec message et arrête le throbber

Je ne comprends pas les paramètres de Popen (stdout, stderr etc), à quoi ils servent , comment les utiliser..
Je regarde la doc https://docs.python.org/3.4/library/...ubprocess.PIPE mais ça ne m'avance pas (par exepmle, à quoi ça sert de mettre un stdin ?)

Écris comme ça, le code permet au throbber de tourner pendant qu'il s'occupe du script mais en même temps il exécute stopThrobber ()

Ce qu'il faudrait c'est qqch qui avertisse lorsque le script est terminé pour pouvoir lancer stopThrobber() (qqch comme stdout ??)

Si je mets un stdout et que je le print, ça me donne : <_io.BufferedReader name=3>

**wiztricks** · 02/06/2015, 12h27

Salut,

Envoyé par guy16

Je ne comprends pas les paramètres de Popen (stdout, stderr etc), à quoi ils servent , comment les utiliser..
Je regarde la doc https://docs.python.org/3.4/library/...ubprocess.PIPE mais ça ne m'avance pas (par exepmle, à quoi ça sert de mettre un stdin ?)

Un process est un objet système. Popen vous permet seulement d'en utiliser les différents attributs.

Envoyé par guy16

Ce qu'il faudrait c'est qqch qui avertisse lorsque le script est terminé pour pouvoir lancer stopThrobber() (qqch comme stdout ??)

Ce quelque chose pourrait être un QThread qui attende la fin du process avant de... ou un QProcess qui dispose déjà de l'instrumentation qui permet d'appeler un callback qui.. lorsque le process se termine.

- W

**guy16** · 02/06/2015, 12h50

Envoyé par wiztricks

Ce quelque chose pourrait être un QThread qui attende la fin du process avant de... ou un QProcess qui dispose déjà de l'instrumentation qui permet d'appeler un callback qui.. lorsque le process se termine.

C'est justement là où je coince. Avec subprocess.check_call je peux récupérer le 0 pour ensuite arréter le throbber de tourner mais avec check_call le throbber ne se met pas en route.

Avec un QThread : mettre le process dans le Main et faire un lien/signal vers un thread ? Il sera exécuter en même temps non ? (j'en reviens à mon problème où je ne sais pas comment savoir quand le subprocess se termine)

**Jiyuu** · 02/06/2015, 15h06

Je suis peut être à coté de la plaque mais pourquoi dans stopThrobber tu commences par un startThrobber ??? Je ne sais pas si ton problème peut venir de là, mais en gros pour moi :

tu lances un Throbber ;
tu demande l'arrêt d'un Throbber :
- tu lances un nouveau Throbber ;
- tu arrêtes ce dernier.

Quand arrêtes tu le premier ?

Moi j'aurai fait plutôt ça :

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
 
class MaClass():
 
    def initMyMovie(self):
        byteF = QByteArray()
        gif = "D:\Projet\Various\Images\image.gif"
        myMovie = QMovie(gif, byteF)
        myMovie.setCacheMode(QMovie.CacheAll)
        myMovie.setSpeed(100)
 
        return myMovie
 
    def startThrobber(self, movie):
 
        self.movie_screen = QLabel()
        main_layout = QVBoxLayout()
        main_layout.addWidget(self.movie_screen)
        ui.throbberTab2.setLayout(main_layout)
        self.movie_screen.setMovie(movie)
        movie.start()
 
        return 1
 
    def stopThrobber(self, movie):
        movie.stop()
 
        return 1
 
    def go(self):
        if ui.chkbox.isChecked():
            movie = self.initMyMovie()
            self.startThrobber(movie)
 
            os.system(r'"C:\Program Files\FME\fme.exe"................') # lancer le script
            self.stopThrobber(movie)

J'ai rien testé, c'est juste un exemple de comment j'aurai construit mon code.... mais je pense qu'il y a autant de façon que personnes voulant le faire

++

J

**guy16** · 02/06/2015, 16h20

Envoyé par Jiyuu

Je suis peut être à coté de la plaque mais pourquoi dans stopThrobber tu commences par un startThrobber ???

En fait, dans 'movie1' je récupère ce qui est renvoyé (return) par startThrobber()
Mais du coup, maintenant tu me fais douter, est-ce que ça relance la fonction ?

**wiztricks** · 02/06/2015, 16h33

Salut,

Essayez de réfléchir à ce que fait ce bout de code:

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
 
from PyQt4.QtCore import QProcess, pyqtSignal, pyqtSlot
 
from PyQt4.QtGui import QApplication, QTextEdit
 
app = QApplication([])
display = QTextEdit()
display.show()
 
def do_say_its_done(exit_code):
    display.append('done')
 
process = QProcess()
process.finished[int].connect(do_say_its_done)
process.start('python -c "import time; time.sleep(1)"')
 
app.exec_()

Je crée un QProcess qui appellera "do_say_its_done" lorsque la commande sera terminée.
A vous de l'adapter à votre contexte.

- W

**Jiyuu** · 02/06/2015, 16h36

Envoyé par guy16

En fait, dans 'movie1' je récupère ce qui est renvoyé (return) par startThrobber()
Mais du coup, maintenant tu me fais douter, est-ce que ça relance la fonction ?

Et oui ... tu la rappelles, donc ça la relance

Regarde le code que je te propose : tu lances initMyMovie() qui te retourne ton "movie" et ensuite c'est celui-là que tu lances et arrêtes.

Je ne sais pas si ça va solutionner ton problème, mais en tout cas je pense qu'il est préférable de faire ainsi.

**tyrtamos** · 02/06/2015, 16h48

Bonjour,

D'après ce que j'ai compris, on est en graphique PyQt, on lance un programme externe dans un processus, et on veut que pendant que ce programme se déroule, le graphique ne soit pas bloqué, et qu'un throbber montre que ce programme est en cours. Et le throbber doit s'arrêter quand le programme s'arrête.

Moi, j'utiliserais un QProcess, parce qu'il a le gros intérêt de lancer un signal quand le programme qu'on a lancé avec lui s'arrête.

Voilà le déroulement logique:

1- Dans la méthode de lancement du programme externe:
-> lancement de l'affichage du throbber
-> création du processus avec QProcess et création du lien pour le signal "finished" avec la méthode "finduprogramme"
-> lancement du programme externe dans le processus

Ici, le programme externe est lancé, mais le graphique n'est pas bloqué et le throbber tourne (affichage gif)

A la fin du programme externe, le processus lance un signal "finished" qui exécute la méthode "finduprogramme"

2- Dans la méthode "finduprogramme"
-> on arrête l'affichage du throbber

**guy16** · 02/06/2015, 16h51

Envoyé par Jiyuu

Et oui ... tu la rappelles, donc ça la relance

Mais ça change quoi si je la relance ?
Et 2e question, est-ce que le return 1 c'est pour lui dire de renvoyer movie ? (parce que il me met comme erreur : argument 1 has unexpected type 'int'

**guy16** · 02/06/2015, 16h57

Merci tyrtamos et wiztricks !

Je ne connaissais pas QProcess. Pour l'instant j'ai tenté avec un Qthread et le module subprocess sans réussir..
Donc je vais tenter avec QProcess

PS: oui Tyrtamos, on est en PyQt5

**guy16** · 02/06/2015, 19h15

J'en ai marre j'y arrive pas..!!

PyQt5

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
    def startThrobber(self):
        # set up the movie screen on a label
        self.movie_screen = QLabel()
        # expand and center the label
        main_layout = QVBoxLayout()
        main_layout.addWidget(self.movie_screen)
        ui.throbberTab2.setLayout(main_layout)
        # use an animated gif file you have in the working folder
        byteF = QByteArray()
        gif = "D:\Projet\Images\loader1.gif"
        movie = QMovie(gif, byteF)
        movie.setCacheMode(QMovie.CacheAll)
        movie.setSpeed(100)
        self.movie_screen.setMovie(movie)
 
        movie.start()
 
        return movie
 
 
    def stopThrobber(self, movie):
 
        movie.stop()
        QMessageBox.information(self.popup(), "Information", "Le traitement est terminé !")
 
    def go(self):
        if ui.chkbox.isChecked():
 
            self.startThrobber()
            qproc = QProcess()
            qproc.start(r'"C:\Program Files\FME\fme.exe" .........')
            qproc.finished.connect(self.stopThrobber(movie=self.startThrobber()))

Ca execute startThrobber et stopThrobber en même temps et ça lance pas le QProcess je crois.

J'ai essayé une autre méthode aussi :

Code :

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

1
2
3
4
5
6
7
8
9
10
def go(self):
            if ui.chkbox.isChecked():
 
            script = subprocess.Popen(r'"C:\Program Files\FME\fme.exe"...... ', shell=False)
 
            while script.poll() == None:
                time.sleep(1)
                self.startThrobber()
            else:
                self.stopThrobber(movie=self.startThrobber())

mais dans ce cas il n'exécute pas startThrobber (même si je le mets juste après le if ça marche pas non plus)

**wiztricks** · 02/06/2015, 19h29

Salut,

Passer en paramètre une fonction ou le retour de la fonction?
Essayez voir:

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
>>> def foo():
...     print('foo!')
...
>>> def bar(f):
...     print ('bar')
...     if callable(f):
...        f()
...
>>> bar(foo())
foo!
bar
>>> bar(foo)
bar
foo!
>>>

- W

**tyrtamos** · 02/06/2015, 21h52

Voilà un petit code qui met en œuvre la principe dont j'ai parlé plus haut: ça marche comme j'ai dit.

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# Python 3
 
import sys, os
 
from PyQt5 import QtCore, QtGui, QtWidgets
 
#############################################################################
class ImagePlayer(QtWidgets.QWidget):
    def __init__(self, filename, parent=None):
        super(ImagePlayer, self).__init__(parent)
 
        self.label = QtWidgets.QLabel()
 
        self.movie = QtGui.QMovie(filename)
        self.movie.start()
 
        dim = self.movie.currentImage().size()
        self.label.resize(dim.width(), dim.height())
        self.label.setAlignment(QtCore.Qt.AlignHCenter)
 
        self.label.setMovie(self.movie)
 
        layout = QtWidgets.QGridLayout()
        layout.addWidget(self.label, 0, 0)
        self.setLayout(layout)
 
#############################################################################
class Fenetre(QtWidgets.QWidget):
 
    #=== focusInEvent =======================================================
    def __init__(self, parent=None):
        super(Fenetre, self).__init__(parent)
        self.resize(400, 300)
 
        # créer le 1er lineEdit
        self.bouton = QtWidgets.QPushButton("Lancer le programme!", self)
        self.bouton.clicked.connect(self.lancementprogramme)
 
        # positionnement des 3 widgets dans la fenêtre
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        self.setLayout(posit)
 
    def lancementprogramme(self):
        print("lancement du programme")
 
        # affichage du throbber
        gif = os.path.abspath("ajax-loader.gif")
        self.player = ImagePlayer(gif)
        self.player.show()
 
        # lancement du programme externe dans un processus
        self.process = QtCore.QProcess()
        self.process.finished.connect(self.findeprogramme)
        self.process.start(r'"C:\Program Files (x86)\Notepad++\notepad++.exe"')
 
    def findeprogramme(self):
        print("Fin de programme")
 
        # fermeture de la fenêtre du throbber
        self.player.close()
 
#############################################################################
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fen = Fenetre()
    fen.show()
    sys.exit(app.exec_())

**wiztricks** · 02/06/2015, 22h12

Salut,

Outre appel de fonction vs. retour de fonction, la difficulté de votre code est que votre startThrobber retourne l'instance de QMovie qu'il faudra passer en paramètre à stopThrobber. Comme vous utilisez des classes la solution la plus simple serait de faire de "movie" un attribut:

Code :

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

1
2
3
4
5
6
7
8
    def startThrobber(self):
        ...
        gif = "D:\Stelios\Projet_Qt\Various\Images\loader1.gif"
        movie = self.movie = QMovie(gif, byteF)
        movie.setCacheMode(QMovie.CacheAll)
        movie.setSpeed(100)
        self.movie_screen.setMovie(movie)
        ...

Vous n'avez, dans ce cas plus de paramètre à passer:

Code :

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

1
2
3
4
    def stopThrobber(self):
 
        self.movie.stop()
        QMessageBox.information(self.popup(), "Information", "Le traitement est terminé !")

Et donc vous pouvez supprimer les appels de fonction dans le connect:

Code :

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

qproc.finished.connect(self.stopThrobber)

Une autre solution plus Pythonique sera d'utiliser les "lambda", i.e. construire à la volée une fonction de fonction a qui on passera le paramètre qu'on vient de calculer mais qui sera appelée plus tard:
On pourrait écrire:

Code :

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

1
2
    movie = self.startThrobber()
    qproc.finished.connect(lambda: self.stopThrobber(movie))

ou encore plus compact (et moins lisible):

Code :

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

1
2
 
    qproc.finished.connect(lambda movie = self.startThrobber(): self.stopThrobber(movie))

- W

**guy16** · 03/06/2015, 10h45

Envoyé par wiztricks

Outre appel de fonction vs. retour de fonction, la difficulté de votre code est que votre startThrobber retourne l'instance de QMovie qu'il faudra passer en paramètre à stopThrobber. Comme vous utilisez des classes la solution la plus simple serait de faire de "movie" un attribut

Quand je fais cela, la variable devient un booléen au lieu de rester un QMovie. Je passe movie en paramètre de def go(self, movie) et lorsque j'appelle stopThrobber(movie) ça me sort comme erreur que movie est un bool.

Je crée la variable movie dans def __init__ donc il me semblait que c'était correct comme façon de faire..

De plus, la méthode avec le QProcess ne marche, j'ai bien écrit comme les exemples que vous m'avez donné mais le process ne se lance pas et le throbber ne s'exécute pas non plus

Avec le module subprocess, startThrobber ne s'affiche pas non plus alors que j'avais cru comprendre que l'intérêt de subprocess est qu'il permettait de faire plusieurs actions simultanément.

**wiztricks** · 03/06/2015, 13h02

Salut,

Le code posté par Tyrtamos montre que cela peut tomber en marche.

Envoyé par guy16

Quand je fais cela, la variable devient un booléen au lieu de rester un QMovie. Je passe movie en paramètre de def go(self, movie) et lorsque j'appelle stopThrobber(movie) ça me sort comme erreur que movie est un bool.

Je crée la variable movie dans def __init__ donc il me semblait que c'était correct comme façon de faire..

De plus, la méthode avec le QProcess ne marche, j'ai bien écrit comme les exemples que vous m'avez donné mais le process ne se lance pas et le throbber ne s'exécute pas non plus

Pas facile de vous répondre sans que vous postiez un peu de code pour voir comment vous avez codé ce que vous dites faire.

- W

Indicateur d'activité

PyQt Python

Discussions similaires

Partager

Partager