Discussion :

[Sve@r]

Salut Tyrtamos
J'apprends toujours énormément de tes codes. J'ai bien évidemment décortiqué celui-là avec enthousiasme et aimerais bien voir celui dont tu parles qui fait du multiprocessing

Mais j'ai une question sur cette instruction self.operationlongue.fini.connect aux lignes 128 et 140. Ce n'est pas un appel de fonction. Quel est son rôle?

Sinon je sentais confusément que ce flag "stop" pouvait être évité donc je l'ai réécrit (ça m'aide à le comprendre)

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
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
#!/usr/bin/env python3
# coding: utf-8
 
import sys
import time
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
 
class cWork(QThread):
	sigInfo=pyqtSignal(int)				# Signal information travail
	sigTerminated=pyqtSignal(bool)			# Signal travail terminé
 
	def __init__(self, bornes, *args, **kwargs):
		super().__init__(*args, **kwargs)
		self.__bornes=bornes
	# ___init__()
 
	def run(self):
		for i in range(*self.__bornes):
			self.sigInfo[int].emit(i)
			time.sleep(0.05)
		# for
 
		self.sigTerminated[bool].emit(True)
	# run()
 
	# Arrêt du thread (méthode surchargée)
	def terminate(self, *, force=False):
		super().terminate()
		if force: self.sigTerminated[bool].emit(False)
	# terminate()
# class cWork()
 
class myWidget(QWidget):
	def __init__(self, bornes=(0, 100), *args, **kwargs):
		super().__init__(*args, **kwargs)
 
		# Les bornes du travail
		self.__bornes=bornes
 
		# Création thread
		self.__travail=cWork(self.__bornes)
		self.__travail.sigInfo[int].connect(self.__slotProgress)
		self.__travail.sigTerminated[bool].connect(self.__slotTerminated)
 
		# Boutons départ et arrêt
		self.__startBtn=QPushButton("Départ", parent=self, clicked=self.__slotStart)
		self.__stopBtn=QPushButton("Arrêt", parent=self, clicked=self.__slotStop)
 
		# Barre de progression
		self.__progress=QProgressBar(parent=self)
		self.__progress.setAlignment(Qt.AlignHCenter)
		self.__progress.setRange(0, 100)
 
		# Layout de positionnement
		mainLayout=QVBoxLayout(self)
		mainLayout.addWidget(self.__startBtn, stretch=0)
		mainLayout.addWidget(self.__stopBtn, stretch=0)
		mainLayout.addStretch(1)
		mainLayout.addWidget(self.__progress, stretch=0)
 
		# Affichage fenêtre
		self.show()
	# __init__()
 
        @pyqtSlot(bool)
	def __slotStart(self, flag):
		# Si le thread est déjà en route, il ne redémarre pas
		if self.__travail.isRunning(): return
 
		# Initialise la barre de progression
		self.__progress.reset()
 
		# Lance le thread (mais ne l'attend pas avec .join!!!)
		self.__travail.start()
	# __slotStart()
 
	# Arrête le thread
        @pyqtSlot(bool)
	def __slotStop(self, flag):
		# Si le thread est déjà arrêté, il ne s'arrête pas deux fois
		if not self.__travail.isRunning(): return
 
		# Thread arrêté de force
		self.__travail.terminate(force=True)
	# __slotStop()
 
	# Met à jour la barre de progression
        @pyqtSlot(int)
	def __slotProgress(self, i):
		self.__progress.setValue(
			i * self.__progress.maximum() / (self.__bornes[1] - self.__bornes[0] - 1)
		)
	# __slotProgress()
 
	# Lorsque le travail se termine
        @pyqtSlot(bool)
	def __slotTerminated(self, terminated):
		QMessageBox.information(
			self,
			"Opération longue",
			"Fin normale" if terminated else "Arrêt demandé avant la fin!",
		)
	# __slotTerminated()
 
	# Evènement fermeture fenêtre
	def closeEvent(self, event):
		# Si le thread est actif
		if self.__travail.isRunning():
			# Arrêt thread
			self.__travail.terminate(force=True)
 
			# Désactive les liens (pas certain que ce soit vraiment nécessaire mais...)
			self.__travail.sigInfo[int].disconnect()
			self.__travail.sigTerminated[bool].disconnect()
		# if
 
		super().closeEvent(event)
	# closeEvent()
# class myWidget
 
if __name__ == "__main__":
	app=QApplication(sys.argv)
	fen=myWidget((0, 100))
	sys.exit(app.exec_())
# if

[tyrtamos]

Bonjour Sve@r

Mais j'ai une question sur cette instruction self.operationlongue.fini.connect aux lignes 128 et 140. Ce n'est pas un appel de fonction. Quel est son rôle?

Il s'agit bien sûr d'une erreur! Il faut écrire .disconnect(). Je déconnecte les liens par précaution suite à des problèmes rencontrés dans le passé, mais je ne suis pas sûr que ce soit encore nécessaire. Il doit y avoir eu un malheureux copier-coller non corrigé... Je vais corriger le code lui-même.

Merci !

[Sve@r]

Il s'agit bien sûr d'une erreur! Il faut écrire .disconnect().

Arf, j'étais tellement impressionné que je ne pensais pas à une erreur (l'ai même repris dans le code similaire que j'ai écrit à partir du tien)

[tyrtamos]

Je n'ai pas honte d'avoir fait une erreur: celui qui n'en fait pas n'est pas humain... Mais je m'en veux de ne pas avoir passé mon code avec pylint comme je fais d'habitude.
Il aurait alors raconté 2 fois:

W0104: Statement seems to have no effect (pointless-statement)

Ce qui m'aurait mis la puce à l'oreille...

Il m'aurait dit aussi que les "ok" aux lignes 77 et 103 n'étaient pas utilisés, mais ça je le savais déjà: c'était seulement pour respecter la syntaxe du signal clicked du QPushButton. On peut donc les remplacer par "_".

Et pour savoir ce que je pense des erreurs, relis ma signature...

[rabeh.ram]

Merci à tous ceux qui ont contribué a cette discussion ;
Je comprends la conception pour lier une barre de progression avec une fonction et cela grâce a les codes fournis
merci encore pour votre soutien

le problème a été résolu.