schemi di GUI multiprocessing per combattere il blocco "Non risponde"

Question

Quali sono i modi migliori per creare un sistema di codifica GUI multiprocessing?

Vorrei creare un posto per la comunità di internet e trovare esempi su come utilizzare il modulo multiprocessing in python.

Ho visto diversi piccoli esempi di processi multiprocessing su internet di semplici funzioni globali che sono chiamate in un modulo principale, ma ho trovato che questo si traduce raramente facilmente in qualsiasi cosa che chiunque faccia effettivamente riguardo alle GUI. Penserei che molti programmi avrebbero le funzioni che vogliono usare in un processo separato come metodi di oggetti (che possono essere aggregati di altri oggetti, ecc.) E forse un singolo elemento della GUI avrebbe un oggetto associato che deve chiamare questo processo, ecc

per esempio, io ho un programma relativamente complessa e sto avendo problemi ad ottenere una GUI reattivo per esso, che ho creduto di essere a causa della mia mancanza di comprensione in multiprocessing e filettatura con QThread. Tuttavia, so che l'esempio riportato di seguito almeno trasferirà le informazioni tra i processi nel modo in cui desidero (poiché è in grado di eseguire le istruzioni print) ma la mia GUI sta ancora bloccando. Qualcuno sa che cosa potrebbe causare questo, e se è ancora un problema con la mia mancanza di comprensione in architetture mutlithreaded/multiprocessing?

Ecco un piccolo esempio di codice pseudo di quello che sto facendo:

class Worker: 
    ... 
    def processing(self, queue): 
     # put stuff into queue in a loop 

# This thread gets data from Worker 
class Worker_thread(QThread): 
    def __init__(self): 
     ... 
     # make process with Worker inside 
    def start_processing(self): 
     # continuously get data from Worker 
     # send data to Tab object with signals/slots 

class Tab(QTabWidget): 
    # spawn a thread separate from main GUI thread 

    # update GUI using slot 
    def update_GUI() 

e questo codice è esempio completamente compilabile che incarna lo sturcture sovrastante del mio programma:

from PyQt4 import QtCore, QtGui 
import multiprocessing as mp 
import numpy as np 
import sys 
import time 

# This object can hold several properties which will be used for the processing 
# and will be run in the background, while it updates a thread with all of it's progress 
class Worker: 
    def __init__(self, some_var): 
     self.some_var = some_var 
     self.iteration = 0 

    def some_complex_processing(self, queue): 
     for i in range(0,5000): 
      self.iteration += 1 
      queue.put(self.iteration) 
     queue.put('done with processing') 

# This Woker_thread is a thread which will spawn a separate process (Worker). 
# This separate is needed in order to separate the data retrieval 
# from the main GUI thread, which should only quickly update when needed 
class Worker_thread(QtCore.QThread): 
    # signals and slots are used to communicate back to the main GUI thread 
    update_signal = QtCore.pyqtSignal(int) 
    done_signal = QtCore.pyqtSignal() 

    def __init__(self, parent, worker): 
     QtCore.QThread.__init__(self, parent) 
     self.queue = mp.Queue() 
     self.worker = worker 
     self.parent = parent 
     self.process = mp.Process(target=self.worker.some_complex_processing, args=(self.queue,)) 

    # When the process button is pressed, this function will start getting data from Worker 
    # this data is then retrieved by the queue and pushed through a signal 
    # to Tab.update_GUI 
    @QtCore.pyqtSlot() 
    def start_computation(self): 
     self.process.start() 
     while(True): 
      try: 
       message = self.queue.get() 
       self.update_signal.emit(message) 
      except EOFError: 
       pass 
      if message == 'done with processing': 
       self.done_signal.emit() 
       break 
      #self.parent.update_GUI(message) 
     self.process.join() 
     return 

# Each tab will start it's own thread, which will spawn a process 
class Tab(QtGui.QTabWidget): 
    start_comp = QtCore.pyqtSignal() 
    def __init__(self, parent, this_worker): 
     self.parent = parent 
     self.this_worker = this_worker 
     QtGui.QTabWidget.__init__(self, parent) 

     self.treeWidget = QtGui.QTreeWidget(self) 
     self.properties = QtGui.QTreeWidgetItem(self.treeWidget, ["Properties"]) 
     self.step = QtGui.QTreeWidgetItem(self.properties, ["Iteration #"]) 

     self.thread = Worker_thread(parent=self, worker=self.this_worker) 
     self.thread.update_signal.connect(self.update_GUI) 
     self.thread.done_signal.connect(self.thread.quit) 
     self.start_comp.connect(self.thread.start_computation) 
     self.thread.start() 

    ############################### 
    # Here is what should update the GUI at every iteration of Worker.some_complex_processing() 
    # The message appears to be getting sent, due to seeing the print statement in the console, but the GUI is not updated. 
    @QtCore.pyqtSlot(int) 
    def update_GUI(self, iteration): 
     self.step.setText(0, str(iteration)) 
     #time.sleep(0.1) 
     print iteration 

    def start_signal_emit(self): 
     self.start_comp.emit() 

# GUI stuff 
class MainWindow(QtGui.QMainWindow): 
    def __init__(self, parent = None): 
     QtGui.QMainWindow.__init__(self) 
     self.tab_list = [] 
     self.setTabShape(QtGui.QTabWidget.Rounded) 
     self.centralwidget = QtGui.QWidget(self) 
     self.top_level_layout = QtGui.QGridLayout(self.centralwidget) 

     self.tabWidget = QtGui.QTabWidget(self.centralwidget) 
     self.top_level_layout.addWidget(self.tabWidget, 1, 0, 25, 25) 

     process_button = QtGui.QPushButton("Process") 
     self.top_level_layout.addWidget(process_button, 0, 1) 
     QtCore.QObject.connect(process_button, QtCore.SIGNAL("clicked()"), self.process) 

     self.setCentralWidget(self.centralwidget) 
     self.centralwidget.setLayout(self.top_level_layout) 

     # Make Tabs in loop from button 
     for i in range(0,10): 
      name = 'tab' + str(i) 
      self.tab_list.append(Tab(self.tabWidget, Worker(name))) 
      self.tabWidget.addTab(self.tab_list[-1], name) 

    # Do the processing 
    def process(self): 
     for tab in self.tab_list: 
      tab.start_signal_emit() 
     return 

if __name__ == "__main__": 
    app = QtGui.QApplication([]) 
    win = MainWindow() 
    win.show() 
    sys.exit(app.exec_()) 

Altro Informazioni: Sto scrivendo un programma che mi piacerebbe generare diversi processi e farli mostrare continuamente i loro progressi attraverso la loro elaborazione. Vorrei che il programma fosse multiprocesso per ottenere la massima velocità possibile dal programma.

Al momento, sto cercando di utilizzare un thread per generare un processo e utilizzare segnali e slot per aggiornare la GUI mentre i dati vengono continuamente recuperati da una coda. Sembra che il queues, signals e slots funzionino quando si utilizzano le istruzioni print, ma non è possibile aggiornare la GUI. Se qualcuno ha altri suggerimenti su come dovrei strutturare questo per mantenere il programma più gestibile, mi piacerebbe imparare.

EDIT: ho fatto le regolazioni messe avanti da Lin Min, con l'aggiunta di fare Worker un QObject in modo che moveToThread() avrebbe funzionato.
Ecco il nuovo codice che ho in questo momento:

from PyQt4 import QtCore, QtGui 
import multiprocessing as mp 
import numpy as np 
import sys 
import time 

class Worker(QtCore.QObject): 
    update_signal = QtCore.pyqtSignal(int) 
    done_signal = QtCore.pyqtSignal() 

    def __init__(self, some_var): 
     QtCore.QObject.__init__(self, parent=None) 
     self.some_var = some_var 
     self.iteration = 0 
     self.queue = mp.Queue() 
     self.process = mp.Process(target=self.some_complex_processing, args=(self.queue,)) 

    def some_complex_processing(self, queue): 
     for i in range(0,5000): 
      self.iteration += 1 
      queue.put(self.iteration) 
     queue.put('done with processing') 

    @QtCore.pyqtSlot() 
    def start_computation(self): 
     self.process.start() 
     while(True): 
      try: 
       message = self.queue.get() 
       self.update_signal.emit(message) 
      except EOFError: 
       pass 
      if message == 'done with processing': 
       self.done_signal.emit() 
       break 
     self.process.join() 
     return 



class Tab(QtGui.QTabWidget): 
    start_comp = QtCore.pyqtSignal() 
    def __init__(self, parent, this_worker): 
     self.parent = parent 
     self.this_worker = this_worker 
     QtGui.QTabWidget.__init__(self, parent) 

     self.treeWidget = QtGui.QTreeWidget(self) 
     self.properties = QtGui.QTreeWidgetItem(self.treeWidget, ["Properties"]) 
     self.step = QtGui.QTreeWidgetItem(self.properties, ["Iteration #"]) 

     # Use QThread is enough 
     self.thread = QtCore.QThread(); 
     # Change the thread affinity of worker to self.thread. 
     self.this_worker.moveToThread(self.thread); 
     self.this_worker.update_signal.connect(self.update_GUI) 
     self.this_worker.done_signal.connect(self.thread.quit) 
     self.start_comp.connect(self.this_worker.start_computation) 
     self.thread.start() 

    ############################### 
    # Here is what should update the GUI at every iteration of Worker.some_complex_processing() 
    # The message appears to be getting sent, due to seeing the print statement in the console, but the GUI is not updated. 
    @QtCore.pyqtSlot(int) 
    def update_GUI(self, iteration): 
     self.step.setText(0, str(iteration)) 
     #time.sleep(0.1) 
     print iteration 

    def start_signal_emit(self): 
     self.start_comp.emit() 

# GUI stuff 
class MainWindow(QtGui.QMainWindow): 
    def __init__(self, parent = None): 
     QtGui.QMainWindow.__init__(self) 
     self.tab_list = [] 
     self.setTabShape(QtGui.QTabWidget.Rounded) 
     self.centralwidget = QtGui.QWidget(self) 
     self.top_level_layout = QtGui.QGridLayout(self.centralwidget) 

     self.tabWidget = QtGui.QTabWidget(self.centralwidget) 
     self.top_level_layout.addWidget(self.tabWidget, 1, 0, 25, 25) 

     process_button = QtGui.QPushButton("Process") 
     self.top_level_layout.addWidget(process_button, 0, 1) 
     QtCore.QObject.connect(process_button, QtCore.SIGNAL("clicked()"), self.process) 

     self.setCentralWidget(self.centralwidget) 
     self.centralwidget.setLayout(self.top_level_layout) 

     # Make Tabs in loop from button 
     for i in range(0,10): 
      name = 'tab' + str(i) 
      self.tab_list.append(Tab(self.tabWidget, Worker(name))) 
      self.tabWidget.addTab(self.tab_list[-1], name) 

    # Do the processing 
    def process(self): 
     for tab in self.tab_list: 
      tab.start_signal_emit() 
     return 

if __name__ == "__main__": 
    app = QtGui.QApplication([]) 
    win = MainWindow() 
    win.show() 
    sys.exit(app.exec_()) 

Grazie per tutte le risposte, apprezzo il livello di dettaglio che ognuno è andato in nel descrivere l'idea che credono di essere una soluzione, ma sfortunatamente non sono ancora stato in grado di eseguire questi tipi di processi che operano sull'oggetto a cui appartengono mentre si visualizza l'attributo dell'oggetto su una GUI.
Tuttavia, ho imparato una quantità decente da questo post, che mi ha permesso di rendermi conto che la versione con thread che ho al momento è appesa alla GUI poiché la funzione di aggiornamento della GUI è troppo grande e richiede troppa elaborazione.

Quindi, ho preso l'approccio QTimer() alla mia versione multi-thread e sta andando molto meglio! Consiglierei a tutti coloro che affrontano problemi simili di tentare almeno qualcosa di simile a questo.

Non ero a conoscenza di questo approccio per risolvere i problemi di aggiornamento della GUI ed è ora una soluzione pseudo o temporanea al problema che sto affrontando.

Answer 1

Un'applicazione GUI è perfetto per le cose di test, come è facile per deporre le uova nuovi compiti e visualizzare ciò che sta accadendo, così ho scritto un piccolo esempio app (Screenshot, il codice è sotto) come volevo impararlo per me stesso.

In un primo momento, ho adottato un approccio simile al tuo, cercando di implementare il modello Consumer/Producer e mi sono battuto con i processi in background che facevano infiniti cicli di attesa per nuovi lavori e mi occupavo della comunicazione avanti e indietro. Poi ho scoperto l'interfaccia Pool e quindi ho potuto sostituire tutto quel codice hidious con poche righe. Tutto ciò che serve è un unico pool e un paio di callback:

#!/usr/bin/env python3 
import multiprocessing, time, random, sys 
from PySide.QtCore import * # equivalent: from PyQt4.QtCore import * 
from PySide.QtGui import * # equivalent: from PyQt4.QtGui import * 

def compute(num): 
    print("worker() started at %d" % num) 
    random_number = random.randint(1, 6) 
    if random_number in (2, 4, 6): 
     raise Exception('Random Exception in _%d' % num) 
    time.sleep(random_number) 
    return num 

class MainWindow(QMainWindow): 
    def __init__(self): 
     QMainWindow.__init__(self) 
     self.toolBar = self.addToolBar("Toolbar") 
     self.toolBar.addAction(QAction('Add Task', self, triggered=self.addTask)) 
     self.list = QListWidget() 
     self.setCentralWidget(self.list) 

     # Pool of Background Processes 
     self.pool = multiprocessing.Pool(processes=4) 

    def addTask(self): 
     num_row = self.list.count() 
     self.pool.apply_async(func=compute, args=(num_row,), callback=self.receiveResult, 
           error_callback=self.receiveException) 
     item = QListWidgetItem("item %d" % num_row) 
     item.setForeground(Qt.gray) 
     self.list.addItem(item) 

    def receiveResult(self, result): 
     assert isinstance(result, int) 
     print("end_work(), where result is %s" % result) 
     self.list.item(result).setForeground(Qt.darkGreen) 

    def receiveException(self, exception): 
     error = str(exception) 
     _pos = error.find('_') + 1 
     num_row = int(error[_pos:]) 
     item = self.list.item(num_row) 
     item.setForeground(Qt.darkRed) 
     item.setText(item.text() + ' Retry...') 
     self.pool.apply_async(func=compute, args=(num_row,), callback=self.receiveResult, 
           error_callback=self.receiveException) 

if __name__ == '__main__': 
    app = QApplication(sys.argv) 
    main_window = MainWindow() 
    main_window.show() 
    sys.exit(app.exec_()) 

Edit: ho fatto un altro esempio utilizzando un QTimer invece di callback, controllando periodicamente la presenza di voci in una coda, l'aggiornamento di un QProgressBar:

#!/usr/bin/env python3 
import multiprocessing, multiprocessing.pool, time, random, sys 
from PySide.QtCore import * 
from PySide.QtGui import * 

def compute(num_row): 
    print("worker started at %d" % num_row) 
    random_number = random.randint(1, 10) 
    for second in range(random_number): 
     progress = float(second)/float(random_number) * 100 
     compute.queue.put((num_row, progress,)) 
     time.sleep(1) 
    compute.queue.put((num_row, 100)) 

def pool_init(queue): 
    # see http://stackoverflow.com/a/3843313/852994 
    compute.queue = queue 

class MainWindow(QMainWindow): 
    def __init__(self): 
     QMainWindow.__init__(self) 
     self.toolBar = self.addToolBar("Toolbar") 
     self.toolBar.addAction(QAction('Add Task', self, triggered=self.addTask)) 
     self.table = QTableWidget() 
     self.table.verticalHeader().hide() 
     self.table.setColumnCount(2) 
     self.setCentralWidget(self.table) 

     # Pool of Background Processes 
     self.queue = multiprocessing.Queue() 
     self.pool = multiprocessing.Pool(processes=4, initializer=pool_init, initargs=(self.queue,)) 

     # Check for progress periodically 
     self.timer = QTimer() 
     self.timer.timeout.connect(self.updateProgress) 
     self.timer.start(2000) 

    def addTask(self): 
     num_row = self.table.rowCount() 
     self.pool.apply_async(func=compute, args=(num_row,)) 
     label = QLabel("Queued") 
     bar = QProgressBar() 
     bar.setValue(0) 
     self.table.setRowCount(num_row + 1) 
     self.table.setCellWidget(num_row, 0, label) 
     self.table.setCellWidget(num_row, 1, bar) 

    def updateProgress(self): 
     if self.queue.empty(): return 
     num_row, progress = self.queue.get() # unpack 
     print("received progress of %s at %s" % (progress, num_row)) 
     label = self.table.cellWidget(num_row, 0) 
     bar = self.table.cellWidget(num_row, 1) 
     bar.setValue(progress) 
     if progress == 100: 
      label.setText('Finished') 
     elif label.text() == 'Queued': 
      label.setText('Downloading') 
     self.updateProgress() # recursion 

if __name__ == '__main__': 
    app = QApplication(sys.argv) 
    main_window = MainWindow() 
    main_window.show() 
    sys.exit(app.exec_()) 

Answer 2

Ok, non ho familiarità con Qt stesso, ma ho fatto un lavoro simile con Tkinter. Sono abbastanza sicuro che stai incontrando il Global Interpreter Lock di Python qui. Nello specifico, stai iniziando la tua coda e la tua applicazione GUI nello stesso thread, quindi quando la coda blocca l'attesa di input, anche la GUI sta bloccando. Prova ad avviare app = QtGui.QApplication([]) nella propria discussione o processo. Scrivere le GUI con le code è sempre un po 'complicato, e ho scoperto che di solito richiede almeno un ulteriore strato di threading di quanto non mi aspetti di aspettarmelo.

Answer 3

Tutto ciò che avete fatto in Worker_Thread avrebbe dovuto essere spostato sul lavoratore. Qt assegna l'affinità del thread a ciascuno degli oggetti in base a dove viene creato l'oggetto. Gli oggetti Worker_Thread sono creati nel thread principale, quindi ha affinità thread principale. Se un segnale dal thread principale è collegato a uno slot di un oggetto creato nel thread principale, lo slot verrà eseguito anche nel thread principale. (Non importa che sia QueuedConnection o DirectConnection). E lo slot blocca la GUI.

Fate questo:

class Worker: 
    update_signal = QtCore.pyqtSignal(int) 
    done_signal = QtCore.pyqtSignal() 

    def __init__(self, some_var): 
     self.some_var = some_var 
     self.iteration = 0 
     self.queue = mp.Queue() 
     self.process = mp.Process(target=self.some_complex_processing, args=(self.queue,)) 

    def some_complex_processing(self, queue): 
     for i in range(0,5000): 
      self.iteration += 1 
      queue.put(self.iteration) 
     queue.put('done with processing') 

    @QtCore.pyqtSlot() 
    def start_computation(self): 
     self.process.start() 
     while(True): 
      try: 
       message = self.queue.get() 
       self.update_signal.emit(message) 
      except EOFError: 
       pass 
      if message == 'done with processing': 
       self.done_signal.emit() 
       break 
     self.process.join() 
     return 



class Tab(QtGui.QTabWidget): 
    start_comp = QtCore.pyqtSignal() 
    def __init__(self, parent, this_worker): 
     self.parent = parent 
     self.this_worker = this_worker 
     QtGui.QTabWidget.__init__(self, parent) 

     self.treeWidget = QtGui.QTreeWidget(self) 
     self.properties = QtGui.QTreeWidgetItem(self.treeWidget, ["Properties"]) 
     self.step = QtGui.QTreeWidgetItem(self.properties, ["Iteration #"]) 

     # Use QThread is enough 
     self.thread = QtCore.QThread(); 
     # Change the thread affinity of worker to self.thread. 
     self.this_worker.moveToThread(self.thread); 
     self.this_worker.update_signal.connect(self.update_GUI) 
     self.this_worker.done_signal.connect(self.thread.quit) 
     self.start_comp.connect(self.this_worker.start_computation) 
     self.thread.start() 

    ############################### 
    # Here is what should update the GUI at every iteration of Worker.some_complex_processing() 
    # The message appears to be getting sent, due to seeing the print statement in the console, but the GUI is not updated. 
    @QtCore.pyqtSlot(int) 
    def update_GUI(self, iteration): 
     self.step.setText(0, str(iteration)) 
     #time.sleep(0.1) 
     print iteration 

    def start_signal_emit(self): 
     self.start_comp.emit() 

Answer 4

Grazie mille per aver postato questa domanda e tutti i contributori per il loro contributo. Mi ha fornito un'impalcatura utile per sperimentare con PyQt e multiprocessing.

Ho iniziato con il secondo esempio di codice elencato nella domanda. Le mie modifiche e commenti:

• In Windows, tutti argomenti Process.__init__() devono essere pickleable. Vedrai che @valmynd rende la sua funzione compute una funzione di primo livello, proprio per questo motivo. Ciò è in parte dovuto al fatto che il multiprocessing reimporterà il modulo contenente la funzione target. Per ricordarmelo, provo a mettere la funzione obiettivo nel suo modulo (e assicurarmi che tutte le informazioni siano passate come argomenti selezionabili). Ho spostato la complessa funzione di elaborazione nel suo modulo chiamato workermodule.py.
• Senza un lavoro sufficiente nella complessa funzione di elaborazione, il ciclo termina troppo rapidamente per consentire a qualsiasi modifica di essere visibile nella GUI.Pertanto, ho aggiunto del lavoro extra (inutile) all'interno della complessa funzione di elaborazione. Come notato nel commento, è possibile time.sleep, ma è più soddisfacente accendere tutti i core per un po '.
• Con i seguenti due frammenti di codice, ottengo un'interfaccia grafica liscia con aggiornamenti continui al valore di iterazione e i processi secondari vengono eseguiti alla massima velocità.
• Si noti che è possibile creare self.process con due code come argomenti, uno per l'input e uno per l'output. Quindi la complessa funzione di elaborazione dovrebbe controllare periodicamente la coda di input per i dati.

workermodule.py:

import time 

def some_complex_processing(queue): 
    iteration = 0 
    for i in range(0,5000): 
     iteration += 1 
     queue.put(iteration) 
     #time.sleep(20e-3) # ms 
     # You could time.sleep here to simulate a 
     # long-running process, but just to prove 
     # that we're not cheating, let's make this 
     # process work hard, while the GUI process 
     # should still have smooth drawing. 
     for x in range(100000): 
      y = x 
    queue.put('done with processing') 

mainfile.py:

from PyQt4 import QtCore, QtGui 
import multiprocessing as mp 
import sys 
import workermodule 

class Worker(QtCore.QObject): 
    update_signal = QtCore.pyqtSignal(int) 
    done_signal = QtCore.pyqtSignal() 

    def __init__(self, some_var): 
     QtCore.QObject.__init__(self, parent=None) 
     self.some_var = some_var 
     self.queue = mp.Queue() 
     self.process = mp.Process(
      target=workermodule.some_complex_processing, 
      args=(self.queue,) 
      ) 

    @QtCore.pyqtSlot() 
    def start_computation(self): 
     self.process.start() 
     while True: 
      try: 
       message = self.queue.get() 
       self.update_signal.emit(message) 
      except EOFError: 
       pass 
      if message == 'done with processing': 
       self.done_signal.emit() 
       break 
     self.process.join() 
     return 

class Tab(QtGui.QTabWidget): 
    start_comp = QtCore.pyqtSignal() 
    def __init__(self, parent, this_worker): 
     self.parent = parent 
     self.this_worker = this_worker 
     QtGui.QTabWidget.__init__(self, parent) 

     self.treeWidget = QtGui.QTreeWidget(self) 
     self.properties = QtGui.QTreeWidgetItem(self.treeWidget, ["Properties"]) 
     self.step = QtGui.QTreeWidgetItem(self.properties, ["Iteration #"]) 

     # Use QThread is enough 
     self.thread = QtCore.QThread(); 
     # Change the thread affinity of worker to self.thread. 
     self.this_worker.moveToThread(self.thread); 
     self.this_worker.update_signal.connect(self.update_GUI) 
     self.this_worker.done_signal.connect(self.thread.quit) 
     self.start_comp.connect(self.this_worker.start_computation) 
     self.thread.start() 

    ############################### 
    # Here is what should update the GUI at every iteration of Worker.some_complex_processing() 
    # The message appears to be getting sent, due to seeing the print statement in the console, but the GUI is not updated. 
    @QtCore.pyqtSlot(int) 
    def update_GUI(self, iteration): 
     self.step.setText(0, str(iteration)) 
     print iteration 

    def start_signal_emit(self): 
     self.start_comp.emit() 

# GUI stuff 
class MainWindow(QtGui.QMainWindow): 
    def __init__(self, parent = None): 
     QtGui.QMainWindow.__init__(self) 
     self.tab_list = [] 
     self.setTabShape(QtGui.QTabWidget.Rounded) 
     self.centralwidget = QtGui.QWidget(self) 
     self.top_level_layout = QtGui.QGridLayout(self.centralwidget) 

     self.tabWidget = QtGui.QTabWidget(self.centralwidget) 
     self.top_level_layout.addWidget(self.tabWidget, 1, 0, 25, 25) 

     process_button = QtGui.QPushButton("Process") 
     self.top_level_layout.addWidget(process_button, 0, 1) 
     QtCore.QObject.connect(process_button, QtCore.SIGNAL("clicked()"), self.process) 

     self.setCentralWidget(self.centralwidget) 
     self.centralwidget.setLayout(self.top_level_layout) 

     # Make Tabs in loop from button 
     for i in range(0,10): 
      name = 'tab' + str(i) 
      self.tab_list.append(Tab(self.tabWidget, Worker(name))) 
      self.tabWidget.addTab(self.tab_list[-1], name) 

    # Do the processing 
    def process(self): 
     for tab in self.tab_list: 
      tab.start_signal_emit() 
     return 

if __name__ == "__main__": 
    app = QtGui.QApplication([]) 
    win = MainWindow() 
    win.show() 
    sys.exit(app.exec_())