[PyQt 5] Mise à jour d’une QProgressBar

**Le Farfadet Spatial** · 16/08/2018, 17h17

Salut à tous !

Je suis en train de travailler sur une application pour gérer mes entrées et sorties de modèle. Comme j’effectue des traitements un peu long, j’ai besoin de barre de progression.

En m’inspirant de Progressbar2, j’ai réalisé une classe permettant d’utiliser la barre de progression à travers un itérable. Cependant, si une fenêtre s’ouvre bien, la barre de progression ne s’affiche jamais, comme le montre l’exemple minimum complet suivant (il utilise Python 3 et PyQt 5) :

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
"""
Exemple de classe permettant d’utiliser une QProgressBar avec un itérable.
 
:module: iterableQProgressBar
:author: Yoann LE BARS
:version: 1.0
:date: 16/08/2018
 
Copyright © 2018 Le Bars, Yoann
 
This program is distributed under CeCLL-B license, it can be copied and
modified freely as long as initial author is cited. Complete text
of CeCILL licence can be found on-line:
 
<http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html>
"""
 
import sys
from PyQt5.QtWidgets import QWidget, QProgressBar, QApplication, QPushButton
 
class ProgressBar (QWidget):
    """
    Class providing an easy way to use QProgressBar 
    """
 
    def __init__ (self, title, minValue = 0, maxValue = None):
        """
        Class initialiser.
        
        :param title: Window title.
        :param minValue: Minimum value in iteration.
        :param maxValue: Maximum value in iteration.
        """
 
        super().__init__()
        self.setWindowTitle(title)
        self.setGeometry(300, 300, 210, 35)
        # Actual progress bar.
        self._pbar = QProgressBar(self)
        self._pbar.setGeometry(30, 40, 200, 25)
        # Iterable through which iterate.
        self._iterable = None
        # Minimum iteration value.
        self._minValue = minValue
        self._pbar.setMinimum(self._minValue)
        # Maximum iteration value.
        self._maxValue = maxValue
        # Current iteration value.
        self._currValue = self._minValue
        # Whether or not iteration has started.
        self._started = False
 
    def __call__ (self, iterable, maxValue = None):
        """
        Use a ProgressBar to iterate through an iterable.
 
        
        :param iterable: The iterable through which iterate.
        :param maxValue: Maximum value in iteration.
        :return: A pointer to current instance.
        """
 
        if maxValue is None:
            self._maxValue = len(iterable)
        else:
            self._maxValue = maxValue
 
        self._pbar.setMaximum(self._maxValue)
        self._pbar.setValue(self._currValue)
        self._iterable = iter(iterable)
        self.show()
        return self
 
    def __iter__ (self):
        """
        Defines the class as iterable.
 
        :return: A pointer to current instance.
        """
 
        return self
 
    def __next__ (self):
        """
        What to be done every next iteration.
        """
 
        try:
            # New value in iteration.
            value = next(self._iterable)
            if self._started:
                self._currValue = self._currValue + 1
            else:
                self._started = True
                self._currValue = self._minValue
            self._pbar.setValue(self._currValue)
            return value
        except StopIteration:
            raise
 
    def __exit__ (self, exc_type, exc_value, traceback):
        """
        What to do when exiting ProgressBar.
 
        :param exc_type: Type of execution.
        :param exc_value: Execution code.
        :param traceback: Execution trace.
        """
 
        pass
 
    def __enter__ (self):
        """
        What to do when entering ProgressBar.
 
        :return: A pointer to current instance.
        """
 
        return self
 
class Exemple (QWidget):
    """
    Classe pour la fenêtre principale d’exemple.
    """
 
    def _realiseAction (self):
        """
        Que faire lorsque le bouton est appuyé.
        """
 
        # Iterable pour test.
        liste = [valeur for valeur in range(100000)]
 
        # Barre de progression indiquant l’état d’avancement dans le fichier.
        progression = ProgressBar('Lecture de la liste')
        for valeur in progression(liste):
            print(valeur)
 
    def __init__ (self):
        """
        Initialisation de la fenêtre.
        """
 
        super().__init__()
        self.setGeometry(300, 300, 280, 170)
        self.setWindowTitle('Test de la barre de progression.')
        # Bouton pour lancer l’activité.
        self._btn = QPushButton('Démarrer', self)
        self._btn.move(40, 80)
        self._btn.clicked.connect(self._realiseAction)
        self.show()
 
if __name__ == '__main__':
    # Instance de l’application.    
    app = QApplication(sys.argv)
    # Fenêtre de test.
    ex = Exemple()
    sys.exit(app.exec_())

Lorsque l’on appuie sur le bouton « Démarrer », on voit bien apparaître la fenêtre de la barre de progression, mais cette fenêtre est désespérément noire.

Je pense faire une erreur idiote, mais je ne parviens pas à trouver où se situe le problème. Quelqu’un aurait-il une idée ?

**VinsS** · 16/08/2018, 19h01

Salut,

Que veux-tu faire exactement ?
Pourquoi ne pas utiliser simplement une QProgressBar et lui envoyer les valeurs au fur et à mesure plutôt que ce code inutile ?

**tyrtamos** · 17/08/2018, 07h28

Bonjour,

QProgressBar permet d'intégrer une barre de progression dans une fenêtre existante. Mais si on veut simplement une petite fenêtre qui ne contient que la barre de progression, ça existe déjà: QProgressDialog. Voir https://doc.qt.io/qt-5/qprogressdialog.html.

Une fois ceci fait, le vrai problème est de savoir comment une tâche longue quelconque peut-elle mettre à jour la barre de progression, puisque sans précaution, la tâche longue monopolisera le CPU et bloquera donc le graphique. Une méthode très concise mais un peu brutale sera de forcer le rafraichissement du graphique avec QtCore.QCoreApplication.processEvents(). Mais la méthode que je préfère est de mettre la tâche longue dans un thread (QThread), et de lancer la mise à jour de la barre de progression grâce à des signaux (xxx.emit(...)). Il faut dans ce cas créer un signal pour la mise à jour et un signal pour la fin.

A noter que la barre de progression nécessite de connaître l'évolution maxi de la valeur. Quand on ne la connait pas, on peut tout de même utiliser la barre de progression, mais en lui demandant d'afficher une "chenille" sans fin, qui ne sera arrêtée qu'à la fin de l'action. Cela permettra simplement d'indiquer à l'utilisateur que l'opération est en cours.

**Le Farfadet Spatial** · 17/08/2018, 17h43

Salut à tous*!

Envoyé par tyrtamos

Mais si on veut simplement une petite fenêtre qui ne contient que la barre de progression, ça existe déjà: QProgressDialog. Voir https://doc.qt.io/qt-5/qprogressdialog.html.

Merci, j’avais réussi à complètement passer à côté. Ça m’a permis de réduire la quantité de code (voir plus bas), ce qui est toujours une bonne chose.

Envoyé par tyrtamos

Une fois ceci fait, le vrai problème est de savoir comment une tâche longue quelconque peut-elle mettre à jour la barre de progression, puisque sans précaution, la tâche longue monopolisera le CPU et bloquera donc le graphique. Une méthode très concise mais un peu brutale sera de forcer le rafraichissement du graphique avec QtCore.QCoreApplication.processEvents(). Mais la méthode que je préfère est de mettre la tâche longue dans un thread (QThread), et de lancer la mise à jour de la barre de progression grâce à des signaux (xxx.emit(...)). Il faut dans ce cas créer un signal pour la mise à jour et un signal pour la fin.

Le code suivant a le comportement attendu. Cependant, il est peut-être possible de faire mieux (j’en parle après) :

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
"""
Exemple de classe permettant d’utiliser une QProgressBar avec un itérable.
 
:module: iterableQProgressBar
:author: Yoann LE BARS
:version: 1.0
:date: 16/08/2018
 
Copyright © 2018 Le Bars, Yoann
 
This program is distributed under CeCLL-B license, it can be copied and
modified freely as long as initial author is cited. Complete text
of CeCILL licence can be found on-line:
 
<http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html>
"""
 
import sys
from PyQt5.QtWidgets import QWidget, QProgressDialog, QApplication, QPushButton
from PyQt5 import QtCore
 
class ProgressBar (QProgressDialog):
    """
    Class providing an easy way to use QProgressDialog.
    """
 
    def __init__ (self, title, minValue = 0, maxValue = None):
        """
        Class initialiser.
        
        :param title: Window title.
        :param minValue: Minimum value in iteration.
        :param maxValue: Maximum value in iteration.
        """
 
        super().__init__(title, None, minValue, 0)
#        self.setWindowModality(QtCore.Qt.WindowModal)
        if maxValue is not None:
            self.setMaximum(maxValue)
        # Iterable through which iterate.
        self._iterable = None
        self.setValue(self.minimum())
        self.setWindowTitle('Progression')
        # Whether or not iteration has started.
        self._started = False
 
    def __call__ (self, iterable, maxValue = None):
        """
        Use a ProgressBar to iterate through an iterable.
 
        
        :param iterable: The iterable through which iterate.
        :param maxValue: Maximum value in iteration.
        :return: A pointer to current instance.
        """
 
        if maxValue is None:
            self.setMaximum(len(iterable))
        else:
            self.setMaximum(maxValue)
 
        self._iterable = iter(iterable)
        self.show()
        return self
 
    def __iter__ (self):
        """
        Defines the class as iterable.
 
        :return: A pointer to current instance.
        """
 
        return self
 
    def __next__ (self):
        """
        What to be done every next iteration.
        """
 
        try:
            # New value in iteration.
            iter = next(self._iterable)
            if self.wasCanceled():
                raise StopIteration ()
            if self._started:
                self.setValue(self.value() + 1)
            else:
                self._started = True
                self.setValue(self.minimum())
            QtCore.QCoreApplication.processEvents()
            return iter
        except StopIteration:
            self._started = False
            self.setValue(self.maximum())
            self.cancel()
            QtCore.QCoreApplication.processEvents()
            raise
 
    def __exit__ (self, exc_type, exc_value, traceback):
        """
        What to do when exiting ProgressBar.
 
        :param exc_type: Type of execution.
        :param exc_value: Execution code.
        :param traceback: Execution trace.
        """
 
        pass
 
    def __enter__ (self):
        """
        What to do when entering ProgressBar.
 
        :return: A pointer to current instance.
        """
 
        return self
 
    def reset (self, title, valMin = 0, valMax = None):
        """
        Reset progress bar.
 
        :param title: New window title.
        :param valMin: Minimum value during progress.
        :param valMax: Maximum value during progress.
        """
 
        super().reset()
        self.setLabelText(title)
        self.setMinimum(valMin)
        if valMax is not None:
            self.setMaximum(valMax)
        self.setValue(valMin)
        self._started = False
 
class Exemple (QWidget):
    """
    Classe pour la fenêtre principale d’exemple.
    """
 
    def _realiseAction (self):
        """
        Que faire lorsque le bouton est appuyé.
        """
 
        # Barre de progression indiquant l’état d’avancement de l’activité.
        progression = ProgressBar('Création de la liste')
        # Iterable pour test.
        liste = [valeur for valeur in progression(range(100000))]
 
        progression.reset('Lecture de la liste')
        for valeur in progression(liste):
            print(valeur)
 
    def __init__ (self):
        """
        Initialisation de la fenêtre.
        """
 
        super().__init__()
        self.setGeometry(300, 300, 280, 170)
        self.setWindowTitle('Test de la barre de progression.')
        # Bouton pour lancer l’activité.
        self._btn = QPushButton('Démarrer', self)
        self._btn.move(40, 80)
        self._btn.clicked.connect(self._realiseAction)
        self.show()
 
if __name__ == '__main__':
    # Instance de l’application.    
    app = QApplication(sys.argv)
    # Fenêtre de test.
    ex = Exemple()
    sys.exit(app.exec_())

En l’espèce, ajouter une structure de processus léger me semble une complication inutile. En revanche, en lisant la documentation, il m’a semblé qu’en définissant la fenêtre en tant que « WindowModal », il n’était pas nécessaire de forcer le traitement des évènements. J’ai laissé ma tentative en commentaire pour montrer comment j’avais fait, mais ça n’a rien donné.

Du coup, j’ai placé deux « processEvents ». Je ne sais pas si ça pose problème, je suis donc preneur de toutes remarques concernant la qualité du code.

Envoyé par VinsS

Que veux-tu faire exactement ?

Confère les deux exemples dans la classe de test du code que j’ai posté : cela permet de créer simplement des barres de progressions au travers d’itérateurs. D’une part, dans la mesure où mon application est basée sur un modèle de greffons, cela permet à la fois d’harmoniser l’apparence dans l’application, mais également de permettre à chaque développeur de greffon d’utiliser facilement une barre de progression et donc de le faire, quelque soit son niveau de programmation et de connaissance de Qt.

Par ailleurs, l’application utilise souvent des fonctions internes de Python, typiquement les fonctions d’interpolations. En passant par ce système qui est appelé automatiquement à chaque nouvelle itération, cela permet d’avoir une barre de progression efficace même avec une fonction qui est une boîte noire.

À bientôt.

**tyrtamos** · 17/08/2018, 18h23

Envoyé par Le Farfadet Spatial

En l’espèce, ajouter une structure de processus léger me semble une complication inutile

Garde tout de même l'idée: tu y reviendras pour des raisons de qualité de fonctionnement.

**Le Farfadet Spatial** · 20/08/2018, 13h56

Salut à tous !

J’ai fini par trouver comment déclarer la fenêtre de progression comme modale. Du coup, j’en suis au code suivant :

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
"""
Exemple de classe permettant d’utiliser une QProgressBar avec un itérable.
 
:module: iterableQProgressBar
:author: Yoann LE BARS
:version: 1.0
:date: 16/08/2018
 
Copyright © 2018 Le Bars, Yoann
 
This program is distributed under CeCLL-B license, it can be copied and
modified freely as long as initial author is cited. Complete text
of CeCILL licence can be found on-line:
 
<http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html>
"""
 
import sys
from PyQt5.QtWidgets import QWidget, QProgressDialog, QApplication, QPushButton
#from PyQt5 import QtCore
 
class ProgressBar (QProgressDialog):
    """
    Class providing an easy way to use QProgressDialog.
    """
 
    def __init__ (self, title, minValue = 0, maxValue = None):
        """
        Class initialiser.
        
        :param title: Window title.
        :param minValue: Minimum value in iteration.
        :param maxValue: Maximum value in iteration.
        """
 
        super().__init__(title, None, minValue, 0)
        self.setMinimumDuration(0)
        self.setModal(True)
        if maxValue is not None:
            self.setMaximum(maxValue)
        # Iterable through which iterate.
        self._iterable = None
        self.setValue(self.minimum())
        self.setWindowTitle('Progression')
        # Whether or not iteration has started.
        self._started = False
 
    def __call__ (self, iterable, maxValue = None):
        """
        Use a ProgressBar to iterate through an iterable.
 
        
        :param iterable: The iterable through which iterate.
        :param maxValue: Maximum value in iteration.
        :return: A pointer to current instance.
        """
 
        if maxValue is None:
            self.setMaximum(len(iterable))
        else:
            self.setMaximum(maxValue)
 
        self._iterable = iter(iterable)
        self.show()
        return self
 
    def __iter__ (self):
        """
        Defines the class as iterable.
 
        :return: A pointer to current instance.
        """
 
        return self
 
    def __next__ (self):
        """
        What to be done every next iteration.
        """
 
        try:
            # New value in iteration.
            iter = next(self._iterable)
            if self.wasCanceled():
                raise StopIteration ()
            if self._started:
                self.setValue(self.value() + 1)
            else:
                self._started = True
                self.setValue(self.minimum())
#            QtCore.QCoreApplication.processEvents()
            return iter
        except StopIteration:
            self._started = False
            self.setValue(self.maximum())
            self.cancel()
#            QtCore.QCoreApplication.processEvents()
            raise
 
    def __exit__ (self, exc_type, exc_value, traceback):
        """
        What to do when exiting ProgressBar.
 
        :param exc_type: Type of execution.
        :param exc_value: Execution code.
        :param traceback: Execution trace.
        """
 
        pass
 
    def __enter__ (self):
        """
        What to do when entering ProgressBar.
 
        :return: A pointer to current instance.
        """
 
        return self
 
    def reset (self, title, valMin = 0, valMax = None):
        """
        Reset progress bar.
 
        :param title: New window title.
        :param valMin: Minimum value during progress.
        :param valMax: Maximum value during progress.
        """
 
        super().reset()
        self.setLabelText(title)
        self.setMinimum(valMin)
        if valMax is not None:
            self.setMaximum(valMax)
        self.setValue(valMin)
        self._started = False
 
class Exemple (QWidget):
    """
    Classe pour la fenêtre principale d’exemple.
    """
 
    def _realiseAction (self):
        """
        Que faire lorsque le bouton est appuyé.
        """
 
        # Barre de progression indiquant l’état d’avancement de l’activité.
        progression = ProgressBar('Création de la liste')
        # Iterable pour test.
        liste = [valeur for valeur in progression(range(100000))]
 
        progression.reset('Lecture de la liste')
        for valeur in progression(liste):
            print(valeur)
 
    def __init__ (self):
        """
        Initialisation de la fenêtre.
        """
 
        super().__init__()
        self.setGeometry(300, 300, 280, 170)
        self.setWindowTitle('Test de la barre de progression.')
        # Bouton pour lancer l’activité.
        self._btn = QPushButton('Démarrer', self)
        self._btn.move(40, 80)
        self._btn.clicked.connect(self._realiseAction)
        self.show()
 
if __name__ == '__main__':
    # Instance de l’application.    
    app = QApplication(sys.argv)
    # Fenêtre de test.
    ex = Exemple()
    sys.exit(app.exec_())

Avec un tel code, je laisse le fonctionnement interne de Qt se charger de toute la mise à jour des fenêtres. De ce que j’ai pu trouver par ailleurs sur le web, cela semble être une façon assez standard de gérer une barre de progression dans une boucle simple – sachant que le code que je présente est pour gérer une barre de progression dans un itérateur, cela signifie que je ne me place que dans le cas de boucles simples.

Envoyé par tyrtamos

Garde tout de même l'idée: tu y reviendras pour des raisons de qualité de fonctionnement.

Je suis tout prêt à le croire, mais avec le code que je présente dans ce message, je laisse Qt s’occuper des évènements en interne. Par ailleurs, sur l’application sur laquelle je travaille, typiquement l’utilisateur n’a aucun intérêt à interagir avec l’application tant que le traitement demandé n’est pas achevé. Il a même plutôt intérêt à ne pas interagir pour éviter de créer des artefacts.

Par ailleurs, dans la mesure où ma classe est créée pour être utilisée dans les itérations d’un itérateur, cela veut dire qu’il faut que je me débrouille, dans la fonction « __init__ » de la classe « ProgressBar », pour placer les itérations dans un processus léger, sachant que je ne peux pas présumer autre chose sur ce processus qu’il s’agit d’itérations. Du coup, je ne vois pas comment faire.

Si le mode modal existe dans Qt, c’est bien parce qu’il y a des cas où il est parfaitement approprié, non ? À l’inverse, les processus légers ne sont pas une panacée à utiliser quel que soit le cas, sans se demander s’ils sont bien ce qu’il faut pour une tâche précise.

Bref : je suis disposé à croire que je sois dans un cas où les processus légers sont appropriés, mais j’ai besoin d’arguments l’indiquant. Par ailleurs, pour réaliser des processus légers à partir d’une classe itérable, j’ai besoin d’être guidé. Donc, s’il y a plus d’éléments sur la question, je suis preneur.

À bientôt.

**Le Farfadet Spatial** · 22/08/2018, 16h53

Salut à tous !

J’imagine que s’il n’y a pas eu de réponse, c’est que personne n’a rien de particulier à dire sur le sujet. Au cas où, avant de clore la discussion, je tente d’abord de la faire remonter.

À bientôt.

**tyrtamos** · 22/08/2018, 17h56

Bonjour,

Pour expliciter comment je fais pour mettre à jour une barre de progression avec un thread, voilà un petit code de principe avec QProgressDialog:

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# Python 3.5, PyQt 5.9
 
"""
modèle pour progression en % d'une tâche longue avec callback qui
s'exécute dans un thread
"""
 
import sys
from PyQt5 import (QtWidgets, QtCore)
 
# pour la simulation d'une tâche longue
from time import time, sleep
 
#############################################################################
def action(callback=None):
    """action qui dure 5 secondes mais qui renvoie un % d'avancement
       en appelant la méthode callback
    """
    delai = 5  # delai de 5 secondes
    t0 = time()  # temps initial
    while True:
        tempspasse = time() - t0
        if callback != None:
            callback(tempspasse / delai)  # envoi du % d'avancement
        if tempspasse > delai:
            break  # délai dépassé
        sleep(0.1)  # simulation d'un temps de traitement
 
#############################################################################
class Monthread(QtCore.QThread):
 
    # création d'un nouveau signal pour info du % d'avancement
    progduthread = QtCore.pyqtSignal(float)
    # création d'un nouveau signal pour info de la fin du thread
    finduthread = QtCore.pyqtSignal(str)
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
 
    #========================================================================
    def run(self):
        # lancement d'une tâche qui dure 5 secondes (5 sec)
        action(self.avancement)
        # fin normale du thread
        self.finduthread.emit("Fin de l'action")
 
    #========================================================================
    def avancement(self, pourc):
        """méthode lancée pendant l'action avec callback
        """
        # envoi du % d'avancement pour mise à jour de la barre de progression
        self.progduthread.emit(pourc)
 
#############################################################################
class Fenetre(QtWidgets.QWidget):
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
        self.resize(300, 200)
 
        # bouton qui exécute la méthode action
        self.bouton = QtWidgets.QPushButton("début", self)
        self.bouton.clicked.connect(self.action)
 
        # position du bouton dans la fenêtre
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        self.setLayout(posit)
 
        # création des variables définies plus tard
        self.monthread = None
        self.prog = None
 
    #========================================================================
    def action(self):
        """méthode lancée par le bouton pour démarrer ou stopper une
           opération longue dans un thread
        """
        if self.monthread == None or not self.monthread.isRunning():
            # => démarrage de l'action dans le thread
 
            # création du QProgressDialog
            self.prog = QtWidgets.QProgressDialog("En cours...", "Annuler", 0, 100, self)
            self.prog.setWindowTitle("Action")
            # branchement du bouton "annuler" à la méthode 'stopaction'
            self.prog.canceled.connect(self.stopaction)
            # affichage de la fenêtre de progression
            self.prog.show()
 
            # lancement du thread avec son opération
            self.monthread = Monthread()
            # se préparer à recevoir le % d'avancement
            self.monthread.progduthread.connect(self.progression)
            # se préparer à recevoir le signal de fin du thread
            self.monthread.finduthread.connect(self.finaction)
            # démarrer le thread
            self.monthread.start()
            # surtout pas de "self.monthread.join()" ici!!!
 
            # changement du texte du bouton
            self.bouton.setText("Stop")
 
        else:
            # => arrêt du thread avant la fin, demandé par le bouton "Stop"
            self.stopaction()
 
    #========================================================================
    def progression(self, pourc):
        """mise à jour de la barre de progression
        """
        self.prog.setValue(pourc * 100)
        if pourc >= 100:
            self.prog.reset()
 
    #========================================================================
    def stopaction(self):
        """méthode lancée par le bouton "annuler" de la fenêtre de progression
        """
        # arrêt brutal du thread
        self.monthread.terminate()
        # arrêt de la fenêtre de progression
        self.prog.reset()
        # retour au texte initial du bouton
        self.bouton.setText("Début")
 
    #========================================================================
    def finaction(self, msg):
        """méthode lancée à la fin normale du thread
        """
        # arrêt de la fenêtre de progression
        self.prog.reset()
        # retour au texte initial du bouton
        self.bouton.setText("Début")
        # affichage du message de fin
        QtWidgets.QMessageBox.information(self,
            "Information",
            msg)
 
#############################################################################
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fen = Fenetre()
    fen.show()
    sys.exit(app.exec_())

A prendre par copier-coller et exécuter pour voir.

Il est vrai que je travaille avec les threads depuis longtemps, et que je choisis facilement cette solution qui marche très bien. Tu as le droit de ne pas être d'accord.

**Le Farfadet Spatial** · 23/08/2018, 15h46

Salut à tous !

Envoyé par tyrtamos

Pour expliciter comment je fais pour mettre à jour une barre de progression avec un thread, voilà un petit code de principe avec QProgressDialog:

Merci, c’est toujours bon à prendre. Cela dit, ça ne règle pas mon problème*: je passe par un itérable, il faudrait donc que je place les itérations dans un processus léger et je ne vois pas comment le faire.

Envoyé par tyrtamos

Il est vrai que je travaille avec les threads depuis longtemps, et que je choisis facilement cette solution qui marche très bien. Tu as le droit de ne pas être d'accord.

Dans l’immédiat, je ne suis ni d’accord, ni pas d’accord. Je ne vois surtout pas comment faire autrement. Par ailleurs, je manque d’expérience avec les processus légers de Qt, je ne suis pas vraiment au fait de ses avantages et inconvénients.

À bientôt.

**Le Farfadet Spatial** · 28/08/2018, 16h54

Salut à tous !

Bon, je pense que s’il n’y a plus de réponse, c’est que personne n’a de solution à proposer pour placer les itérations dans un processus léger. Cela dit, encore une fois, avant de clore définitivement ce fil de discussion, je le fais remonter.

À bientôt.

**tyrtamos** · 29/08/2018, 07h38

Bonjour,

Envoyé par Le Farfadet Spatial

c’est que personne n’a de solution à proposer pour placer les itérations dans un processus léger.

Je ne comprends pas la difficulté que tu rencontres avec ça. Si ta tâche longue se fait sur la base d'itération, tu intègres l'itération dans la méthode "run" du thread (celle qui est lancée par "start()"). Et si au lancement du thread tu sais combien d'itérations il y aura, tu as ce qu'il faut pour mettre à jour la barre de progression: à chaque itération, ton thread enverra par ".emit(...)" au graphique l'info de progression.

**Le Farfadet Spatial** · 29/08/2018, 11h39

Salut à tous !

Envoyé par tyrtamos

Je ne comprends pas la difficulté que tu rencontres avec ça. Si ta tâche longue se fait sur la base d'itération, tu intègres l'itération dans la méthode "run" du thread (celle qui est lancée par "start()"). Et si au lancement du thread tu sais combien d'itérations il y aura, tu as ce qu'il faut pour mettre à jour la barre de progression: à chaque itération, ton thread enverra par ".emit(...)" au graphique l'info de progression.

Confère le code que j’ai donné. Voici comment est créée et appelée la barre de progression :

Code :

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

1
2
3
4
# Barre de progression indiquant l’état d’avancement de l’activité.
progression = ProgressBar('Création de la liste')
# Iterable pour test.
liste = [valeur for valeur in progression(range(100000))]

Ce qui appelle le code de mise à jour de la barre de progression, ce sont les itérations de la compréhension de liste. Or, il faut que je crée le processus léger dans le code de la classe « ProgressBar ». La seule solution que je vois, c’est de placer tant les itérations que la mise à jour de la barre dans le même processus léger, ce qui ne me semble pas avoir d’intérêt.

Typiquement, voici comment j’utilise « ProgressBar » dans le code de mon application :

Code :

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

1
2
3
4
5
6
# Progress bar title.
pBarTitle = self._translate('PlotComp', 'Getting computed values in solution {}.')
# Progress bar indicating advancement computations.
pBar = PluginsUtils.ProgressBar(pBarTitle.format(sNumber))
# Computed values.
cValues = [interpolate.griddata(points, values[i], (x0, y0), method = 'cubic') for i in pBar(range(cFile.dimensions['time'].size))]

La fonction « interpolate » est une fonction de SciPy, c’est une boîte noire. De toute façon, ne pas passer par une compréhension de liste serait totalement inefficace, d’autant que le jeu de données (contenu dans un fichier au format NetCDF) est assez lourd. En conséquence, je ne peux pas passer par une boucle « for », il faut impérativement que la mise à jour de la barre de progression soit réalisée par les appels à l’itérateur. Or, dans un tel code (la classe « ProgressBar » que j’ai donnée correspond au code de mon application), je ne vois pas comment faire pour placer les itérations dans un autre processus léger que celui de la mise à jour de la barre de progression.

À bientôt.

**tyrtamos** · 29/08/2018, 13h41

Bonjour,

Tu es coincé parce que tu as mélangé l'itérateur et la barre de progression: je ne vois aucune raison de faire ça.

Voilà un code de principe:

J'ai créé un itérateur "Iterateur" qui fait à peu près ce que fait range.

J'ai un thread qui pilote l'action longue qui contient l'itérateur, et qui envoie sous forme de signaux l'info de mise à jour de la barre de progression, et la fin du thread.

Et enfin, la partie graphique, qui lancera le thread, mettra à jour la barre de progression et l'arrêtera à la fin du thread.

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import sys
from PyQt5 import (QtWidgets, QtCore)
 
# pour la simulation d'une tâche longue
from time import sleep
 
##############################################################################
class Iterateur(object):
 
    def __init__(self, deb, fin=None, pas=None):
        if pas==None:
            if fin==None:
                # 1 seul paramètre
                self.deb, self.fin, self.pas = 0, deb, 1
            else:
                # 2 paramètres
                self.deb, self.fin, self.pas = deb, fin, 1
        else:
            # 3 paramètres
            self.deb, self.fin, self.pas = deb, fin, pas
 
        self.cpt = self.deb  # initialisation du compteur
 
    def __iter__(self):
        return self
 
    def __next__(self): # => "next" pour Python2 et "__next__" pour Python3
        if self.cpt >= self.fin:
            raise StopIteration
        k = self.cpt
        self.cpt += self.pas  # incrementation du compteur pour le prochain appel
        return k 
 
#############################################################################
class Monthread(QtCore.QThread):
 
    # création d'un nouveau signal pour info du % d'avancement
    progduthread = QtCore.pyqtSignal(float)
    # création d'un nouveau signal pour info de la fin du thread
    finduthread = QtCore.pyqtSignal(str)
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
 
    #========================================================================
    def run(self):
        # nb d'itération prévue
        nmax = 100
        # lancement d'une tâche longue
        for i in Iterateur(nmax):
            # simule une tâche de calcul longue
            sleep(0.1) 
            # envoi de l'info de progression au graphique
            self.progduthread.emit((i+1)/100)
 
        # signale que le thread est terminé
        self.finduthread.emit("Fin de l'action")
 
#############################################################################
class Fenetre(QtWidgets.QWidget):
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
        self.resize(300, 200)
 
        # bouton qui exécute la méthode action
        self.bouton = QtWidgets.QPushButton("début", self)
        self.bouton.clicked.connect(self.action)
 
        # position du bouton dans la fenêtre
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        self.setLayout(posit)
 
        # création des variables définies plus tard
        self.monthread = None
        self.prog = None
 
    #========================================================================
    def action(self):
        """méthode lancée par le bouton pour démarrer ou stopper une
           opération longue dans un thread
        """
        if self.monthread == None or not self.monthread.isRunning():
            # => démarrage de l'action dans le thread
 
            # création du QProgressDialog
            self.prog = QtWidgets.QProgressDialog("En cours...", "Annuler", 0, 100, self)
            self.prog.setWindowTitle("Action")
            # branchement du bouton "annuler" à la méthode 'stopaction'
            self.prog.canceled.connect(self.stopaction)
            # affichage de la fenêtre de progression
            self.prog.show()
 
            # lancement du thread avec son opération
            self.monthread = Monthread()
            # se préparer à recevoir le % d'avancement
            self.monthread.progduthread.connect(self.progression)
            # se préparer à recevoir le signal de fin du thread
            self.monthread.finduthread.connect(self.finaction)
            # démarrer le thread
            self.monthread.start()
            # surtout pas de "self.monthread.join()" ici!!!
 
            # changement du texte du bouton
            self.bouton.setText("Stop")
 
        else:
            # => arrêt du thread avant la fin, demandé par le bouton "Stop"
            self.stopaction()
 
    #========================================================================
    def progression(self, pourc):
        """mise à jour de la barre de progression
        """
        self.prog.setValue(pourc * 100)
        if pourc >= 100:
            self.prog.reset()
 
    #========================================================================
    def stopaction(self):
        """méthode lancée par le bouton "annuler" de la fenêtre de progression
        """
        # débranchement des liens
        self.monthread.progduthread.disconnect()
        self.monthread.finduthread.disconnect()
        # arrêt brutal du thread
        self.monthread.terminate()
        # arrêt de la fenêtre de progression
        self.prog.reset()
        # retour au texte initial du bouton
        self.bouton.setText("Début")
 
    #========================================================================
    def finaction(self, msg):
        """méthode lancée à la fin normale du thread
        """
        # arrêt de la fenêtre de progression
        self.prog.reset()
        # retour au texte initial du bouton
        self.bouton.setText("Début")
        # affichage du message de fin
        QtWidgets.QMessageBox.information(self,
            "Information",
            msg)
 
#############################################################################
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fen = Fenetre()
    fen.show()
    sys.exit(app.exec_())

A noter que si le nb d'itération n'est pas connu au départ, tu n'as plus de progression possible. Il te reste à faire que la barre de progression affiche une "chenille" qui dira simplement à l'utilisateur que le travail est en cours. Pour la configuration, il suffit de donner une plage [0, 0] ) à la barre de progression. On peut d'ailleurs changer si nécessaire la forme de la chenille!

**Le Farfadet Spatial** · 29/08/2018, 17h27

Salut à tous !

Envoyé par tyrtamos

Tu es coincé parce que tu as mélangé l'itérateur et la barre de progression: je ne vois aucune raison de faire ça.

Ça me permet de ne pas faire de boucle « for ». J’ai déjà testé avec une boucle « for », non seulement c’est beaucoup moins efficace, mais en plus le processus n’arrive jamais à son terme : après avoir saturé la mémoire, le processus est tué – cela tient sans doute également à la façon d’accéder aux fichiers NetCDF, qui, si jamais c’est réalisé sans précaution, peut vite surcharger la mémoire. À l’inverse, mes tests montrent qu’en passant par une compréhension de liste, non seulement le processus arrive à son terme, mais en plus le temps de traitement est parfaitement acceptable. Il est de toute façon nécessaire de passer par une compréhension de liste.

Évidemment, j’ai présenté ici un code simple pour juste présenter la partie qui pose problème. Il est certain que remplir une liste des cent mille premiers entiers n’est pas une tâche complexe. Cependant, dans mon cas concret, j’interpole des données sur un maillage représentant une surface de plusieurs milliers de kilomètres carrés. Je suis dans un cas où il importe de se soucier des performances.

Envoyé par tyrtamos

Voilà un code de principe:

Merci pour ce code, c’est du travail. J’apprécie vraiment.

Cependant, à moins que j’ai mal compris, il implique de passer par une boucle « for » (comme on le voit dans la méthode « run » de la classe « Monthread »). C’est d’ailleurs bien la solution que j’ai trouvée de mon côté pour réaliser un processus léger. Cette solution ne permet pas de faire une compréhension de liste et je ne peux donc pas l’utiliser.

Bien entendu, plutôt que de faire une compréhension de liste, on peut théoriquement passer par une boucle et émettre un signal à chaque itération. Cependant, c’est beaucoup moins efficace qu’en passant par une compréhension de liste. Tellement moins efficace que, comme dit, dans mon cas particulier le traitement n’arrive jamais à terme. Sachant que pour l’instant je teste avec des fichiers considérés comme contenant peu de données…

Après, il y a toujours la possibilité de passer par du code C++. Cependant, même si je maîtrise mieux C++ que Python, je préférerais éviter d’en passer par là, car ça rendrait l’infrastructure de l’application beaucoup plus complexe. D’autant que, comme déjà mentionné, avec une compréhension de liste les performances sont parfaitement acceptable.

Donc, il reste sur le problème que je dois impérativement passer par une compréhension de liste et mettre à jour ma barre de progression. C’est la raison pour laquelle je me suis basé sur le code de Progressbar2.

À bientôt.

**Le Farfadet Spatial** · 14/09/2018, 17h15

Salut à tous !

Pour ma part, je n’ai pas trouvé d’autre moyen de réaliser une compréhension de liste tout en créant un processus léger. A priori, on ne peut pas le faire avec l’approche que j’ai choisie. En ce qui me concerne, je ne vois pas d’autre moyen de réaliser une barre de progression tout en passant par une compréhension de liste.

Je pense que si personne n’a proposé une autre solution, c’est que personne ne sait comment réaliser cela – si même c’est possible. À tout hasard, je tente de relancer une dernière fois ce sujet de discussion avant de le passer définitivement en résolu.

À bientôt.

**Le Farfadet Spatial** · 18/09/2018, 15h48

Salut à tous !

Très bien, je considère donc qu’il n’y a plus rien à dire sur le sujet, que je passe donc en résolu. Encore merci pour l’aide, Tyrtamos.

À bientôt.

[PyQt 5] Mise à jour d’une QProgressBar

PyQt Python

Discussions similaires

Partager

Partager