PySide aguarde pelo sinal da thread principal em um thread de trabalho

Question

Eu decidi adicionar uma interface de usuário para um dos meus scripts.O script é um simples web scraper.Eu decidi usar um thread de trabalho como baixar e analisar os dados pode demorar um pouco.Eu decidi usar o PySide, mas meu conhecimento de Qt, em geral, é bastante limitada.

Como o script é suposto para aguardar a entrada do usuário ao chegar em um captcha eu decidi que deveria esperar até que um QLineEdit incêndios returnPressed e, em seguida, enviar conteúdo para o thread de trabalho de modo que ele pode enviá-lo para validação.Que deve ser melhor do que ocupado, aguardando o retorno tecla ser premida.

Parece que à espera de um sinal não é tão simples como eu pensava que seria e, depois de procurar por um tempo, me deparei com várias soluções semelhantes este.Sinalização em threads e um local loop de eventos em que o thread de trabalho fazer a minha solução um pouco mais complicado embora.

Depois de mexer com ele por várias horas, ele ainda não vai funcionar.

O que é suposto acontecer:

• Transferir dados até que se refere ao captcha e inserir um loop
• Download captcha e exibi-lo ao usuário, iniciar QEventLoop chamando self.loop.exec_()
• Saída QEventLoop chamando loop.quit() em um threads de trabalho de fenda que está ligado via self.line_edit.returnPressed.connect(self.worker.stop_waiting) no main_window classe
• Validar o captcha e o loop se a validação falhar, caso contrário, repetir o último url, que deve estar disponível para download agora, em seguida, passar com a seguinte url

O que acontece:

• ...veja acima...

• Sair QEventLoop não funciona. self.loop.isRunning() retorna False depois de chamar a sua exit(). self.isRunning retorna True, como tal, a thread não parecem morrer sob estranhas circunstâncias.Ainda que o thread é interrompida no self.loop.exec_() linha.Como tal, o thread está preso a execução do laço, mesmo que o ciclo de eventos diz-me que não está a funcionar.

• O GUI responde como fazer as ranhuras do trabalhador classe thread.Eu posso ver o texto a enviar para o thread de trabalho, o status do ciclo de eventos e a linha própria, mas nada acima mencionado linha é executada.

O código é um pouco complicada, como tal adicionar um pouco de pseudo-código python-mix deixando de fora o que não tem importância:

class MainWindow(...):
    # couldn't find a way to send the text with the returnPressed signal, so I
    # added a helper signal, seems to work though. Doesn't work in the
    # constructor, might be a PySide bug?
    helper_signal = PySide.QtCore.Signal(str)
    def __init__(self):
        # ...setup...
        self.worker = WorkerThread()
        self.line_edit.returnPressed.connect(self.helper_slot)
        self.helper_signal.connect(self.worker.stop_waiting)

    @PySide.QtCore.Slot()
    def helper_slot(self):
        self.helper_signal.emit(self.line_edit.text())

class WorkerThread(PySide.QtCore.QThread):
    wait_for_input = PySide.QtCore.QEventLoop()

    def run(self):
        # ...download stuff...
        for url in list_of_stuff:
            self.results.append(get(url))

    @PySide.QtCore.Slot(str)
    def stop_waiting(self, text):
        self.solution = text
        # this definitely gets executed upon pressing return
        self.wait_for_input.exit()

    # a wrapper for requests.get to handle captcha
    def get(self, *args, **kwargs):
        result = requests.get(*args, **kwargs)
        while result.history: # redirect means captcha
            # ...parse and extract captcha...
            # ...display captcha to user via not shown signals to main thread...

            # wait until stop_waiting stops this event loop and as such the user
            # has entered something as a solution
            self.wait_for_input.exec_()

            # ...this part never get's executed, unless I remove the event
            # loop...

            post = { # ...whatever data necessary plus solution... }
            # send the solution
            result = requests.post('http://foo.foo/captcha_url'), data=post)
        # no captcha was there, return result
        return result

frame = MainWindow()
frame.show()
frame.worker.start()
app.exec_()

Answer 1

O slot é executado dentro do thread que criou o QThread, e não a thread que o QThread controles.

Você precisa mover um QObject para o segmento e ligar seu slot para o sinal, e que o slot será executado dentro do thread:

class SignalReceiver(QtCore.QObject):
    def __init__(self):
        self.eventLoop = QEventLoop(self)             

    @PySide.QtCore.Slot(str)
    def stop_waiting(self, text):                   
        self.text = text
        eventLoop.exit()

    def wait_for_input(self):
        eventLoop.exec()
        return self.text

class MainWindow(...):
     ...
     def __init__(self):
        ...
        self.helper_signal.connect(self.worker.signalReceiver.stop_waiting)

class WorkerThread(PySide.QtCore.QThread): 
    def __init__(self):
        self.signalReceiver = SignalReceiver() 
        # After the following call the slots will be executed in the thread             
        self.signalReceiver.moveToThread(self)    

    def get(self,  *args, **kwargs):
        result = requests.get(*args, **kwargs)
        while result.history:
            ...
            self.result = self.signalReceiver.wait_for_input()   

Answer 2

O que você está descrevendo parece ideal para QWaitCondition.

Exemplo simples:

import sys
from PySide import QtCore, QtGui

waitCondition = QtCore.QWaitCondition()
mutex = QtCore.QMutex()

class Main(QtGui.QMainWindow):
    def __init__(self, parent=None):
        super(Main, self).__init__()

        self.text = QtGui.QLineEdit()
        self.text.returnPressed.connect(self.wakeup)

        self.worker = Worker(self)
        self.worker.start()

        self.setCentralWidget(self.text)

    def wakeup(self):
        waitCondition.wakeAll()

class Worker(QtCore.QThread):
    def __init__(self, parent=None):
        super(Worker, self).__init__(parent)

    def run(self):
        print "initial stuff"

        mutex.lock()
        waitCondition.wait(mutex)
        mutex.unlock()

        print "after returnPressed"

if __name__=="__main__":      
    app = QtGui.QApplication(sys.argv)
    m = Main()
    m.show()
    sys.exit(app.exec_())