Sending a custom signal from a worker

[mhc]

Hi all, I'm working in a Python application, using PySide on a Raspberry Pi, with Raspbian Jessie OS.

I'm very new in Python, so I'm not an expert at all, and probably it's a begginer's question.

In my application, I have:

main thread -> Gui Thread that implements front end.
subyacent thread -> Makes some long work (no gui at all, plain code), implemented in a Custom class named MyWorker.

In some places of subyacent thread's code, I need to emit a signal that have to be catched by the main thread. In a previous version, I did it this way:

Main thread's code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#Slot for clicked button def Slot_Start_Calculation (self):       self.MyLongThread = QThread()     MyLongWorker = MyWorker(self, Qty)     MyLongWorker.moveToThread(self.MyLongThread)       self.MyLongThread.started.connect(MyLongWorker.Run_LongWorker)     MyLongWorker.WorkerFinished.connect(self.MyLongThread.quit)     MyLongWorker.WorkerFinished.connect(self.MyLongWorker.deleteLater)     MyLongThread.finished.connect(self.MyLongThread.deleteLater)       MyLongThread.start()     def Slot_Worker_Sent_A_Signal (self, Result):       print ("Worker sent this result: " + str(Result))     .     .     .

MyWorker's code

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

class MyWorker(QObject):   WorkerFinished = Signal() CustomSignal = Signal(int)   def __init__(self, parent, Quantity)       super().__init__(parent)     self_parent = parent     self.Quantity = Quantity     print("Myworker's constructor")   def __del__(self):     print("Myworker's destructor")     def Run_LongWorker (self):       self.CustomSignal.connect(self.parent.Slot_Worker_Sent_A_Signal)     .     .     .     self.CustomSignal.emit(MyPartialResult)     .     .     .     self.WorkerFinished.emit()

This code is running in a test environment from some weeks ago while I finish some details of the GUI, and I didn't see anything wrong. Yesterday searching in the web I casually noticed that QObject::moveToThread can't move objects with a parent

[1]]https:[//forum.qt.io/topic/40653/qobject-movetothread-cannot-move-objects-with-a-parent][1]

so I'm afraid that my code may have problems that I have not yet detected.

I modified this part of code, and now it is:

New code for main Thread

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#New slot for clicked button. def Slot_Start_Calculation (self):       MyLongThread = QThread()     MyLongWorker = MyWorker(Qty)     MyLongWorker.moveToThread(MyLongThread)       MyLongThread.started.connect(MyLongWorker.Run_LongWorker)     MyLongWorker.WorkerFinished.connect(MyLongThread.quit)     MyLongWorker.WorkerFinished.connect(MyLongWorker.deleteLater)     MyLongThread.finished.connect(MyLongThread.deleteLater)       MyLongThread.start()     def Slot_Worker_Sent_A_Signal (self, Result):       print ("Worker sent this result: " + str(Result))     .     .     .

New code for MyWorker

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

class MyWorker(QObject):       WorkerFinished = Signal()     CustomSignal = Signal(int)       def __init__(self, Quantity)           super().__init__()         self.Quantity = Quantity         print("Myworker's constructor")       def __del__(self):         print("Myworker's destructor")       def Run_LongWorker (self):           self.CustomSignal.connect( ??? .Slot_Worker_Sends_A_Signal)         .         .         .         self.CustomSignal.emit(MyPartialResult)         .         .         .         self.WorkerFinished.emit()

So, now, I don't really know how to connect this signal to a slot that lives in main thread, cause if I'm not wrong, there is no parent/children relation since I changed thread affinity.

Could someone please tell me if there is a way to do this, and guide me towards documentation about this problem?

Many thanks in advance.

[Larz60+]

Here's something to read: http://greenteapress.com/semaphores/Litt...phores.pdf

[mhc]

Thank you very much Larz60+. I will read it, and I will publish my solution if I can find it.

Regards

[mhc]

Hi again.

I read the document that Larz60+ recommended (very good and interesting), but I still can't see how to deal with a solution to my specific problem.

Thing that misleads me is how can I use a semaphore in my main thread (if this is the resource that Larz60+ suggested me) beacuse main thread is a GUI with an event loop in which, if I wait for a signal from the Worker, I´m leaving hung all functions of the front end.

Sorry cause trying to be simple I was very inespecific with the function of the worker. I think that the important thing to take in account is that this worker makes a job than can be running for many minutes, then has to inform a partial result to main thread and keep running for a while.

Could someone please tell me if I'm wrong, or guide me in the right direction?

Many thanks in advance!

[mhc]

Finally, I think I found an answer. In constructor of the Worker class, I had to change the parent object reference and the super class init calling.

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

class MyWorker(QObject):    WorkerFinished = Signal() CustomSignal = Signal(int)    def __init__(self, parent = None, Quantity)        super().__init__()     self.Quantity = Quantity     print("Myworker's constructor")    def __del__(self):     print("Myworker's destructor")       def Run_LongWorker (self):        self.CustomSignal.connect(self.parent.Slot_Worker_Sent_A_Signal)     .     .     .     self.CustomSignal.emit(MyPartialResult)     .     .     .     self.WorkerFinished.emit()

And now everything is working as expected.

If somebody sees a problem with that code, please feel free to tell me.

Thanks!