def import_data_to_db(self, schema, convert2polygon=True, is_shp=False): """Imports the data into the database. :param schema str, what kind of data is it :param convert2polygon bool, is the data in the shp file already polygons? :param is_shp bool, is the data from a shp file? """ #TODO: fix the treading! self.is_shp = is_shp self.schema = schema self.idata = InsertData(self.IH, self.defined_field, self.db, schema, convert2polygon, is_shp) worker_thread_work = QThread() self.idata.moveToThread(worker_thread_work) worker_thread_work.started.connect(self.idata.import_data_to_db) worker_thread_work.start() waiting_thread = QThread() waiting_thread.start() wait_msg = 'Please wait while data is being prosecuted' self.wait = Waiting(wait_msg) self.wait.moveToThread(waiting_thread) self.wait.start.connect(self.wait.start_work) self.wait.start.emit('run') while not self.idata.finish: time.sleep(1) self.end_method()
def fn(self): 'QThread-Objekt instanziieren' thread_empfaenger = QThread() thread_sender = QThread() 'Motor-Objekt instanziieren' self.empfaenger = Server_empfaenger() self.sender = Server_sender() 'Motor-Objekt an den Thread übergeben' self.empfaenger.moveToThread(thread_empfaenger) self.sender.moveToThread(thread_sender) 'Signale und Slots verbinden' thread_empfaenger.started.connect(self.empfaenger.starten) # self.empfaenger.finished.connect(thread_empfaenger.quit) # self.empfaenger.finished.connect(self.empfaenger.deleteLater) thread_empfaenger.finished.connect(thread_empfaenger.deleteLater) thread_sender.started.connect(self.sender.starten) # self.sender.finished.connect(thread_sender.quit) # self.sender.finished.connect(self.sender.deleteLater) thread_sender.finished.connect(thread_sender.deleteLater) 'Methode start des Thread-Objektes aufrufen' thread_empfaenger.start() thread_sender.start() 'Methode exec des Thread-Objektes aufrufen' thread_empfaenger.exec() thread_sender.exec()
def __init__(self, filename, controller, done_loading_callback, done_writing_callback): self.controller = controller self.done_loading_callback = done_loading_callback self.writing_done_callback = done_writing_callback self.data = defaultdict(list) self.all_data = [] self.data_keys = set() self.color_change_data = [] self.actual_z = '0.0' self.speed = 0.0 self.z_hop = False self.last_point = np.array([0.0, 0.0, 0.0]) self.actual_point = [0.0, 0.0, 0.0] self.printing_time = 0.0 self.filament_length = 0.0 #print("Filename type: " + str(type(filename))) #print("Filename: " + filename) #if type(filename)==: #self.filename = u'c:\\models\\super mega testovací Jindřich šložka čěýáéůú\\anubis_PLA_OPTIMAL.gcode' self.filename = filename self.is_loaded = False self.gcode_parser = GcodeParserRunner(controller, self.filename) self.gcode_parser_thread = QThread() self.gcode_copy = GcodeCopyRunner( self.filename, "", color_change_lst=self.color_change_data) self.gcode_copy_thread = QThread()
def insert_to_db(self): self.waiting_thread = QThread() self.waiting_thread.start() wait_msg = 'Please wait while data is being prosecuted' self.wait = Waiting(wait_msg) self.wait.moveToThread(self.waiting_thread) self.worker2 = InsertHarvestToDB(self.IH, self.iface, self.polygon, self.db) #self.worker2.insert_to_db() self.worker_thread_work = QThread() self.worker_thread_work.start() time.sleep(1) self.worker2.moveToThread(self.worker_thread_work) self.worker2.starts.connect(self.worker2.insert_to_db) self.worker2.starts.emit('run') self.wait.start.connect(self.wait.start_work) self.wait.start.emit('run') self.dock_widget.PBAddFieldToDB.setEnabled(False) while not self.worker2.finished: time.sleep(1) self.CreateLayer.create_layer_style( self.worker2.layer, check_text(self.worker2.harvest_yield_col), self.worker2.tbl_name.lower(), 'harvest') QgsMapLayerRegistry.instance().addMapLayer(self.worker2.layer) QgsMapLayerRegistry.instance().removeMapLayer(self.IH.input_layer.id()) self.wait.stop_work()
def __init__(self): super(Form, self).__init__() self.initUI() self.worker = {} self.threadx = {} self.i = 0 i = 0 #Establish the maximum number of threads the machine can optimally handle #Generally relates to the number of processors self.threadtest = QThread(self) self.idealthreadcount = self.threadtest.idealThreadCount() print("This machine can handle {} threads optimally".format( self.idealthreadcount)) while i < self.idealthreadcount: self.setupThread(i) i += 1 i = 0 while i < self.idealthreadcount: self.startThread(i) i += 1 print("Main Gui running in thread {}.".format(self.thread()))
def server_starten(self): self.mode = 0 self.g_code_modus = False self.message_lenght = 1024 self.verb = socket(AF_INET, SOCK_STREAM) self.verb.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) try: self.verb.bind(('127.0.0.1', 60112)) print("Osterhase" + str(self.verb)) except Exception as e: print(e) self.thread_server_emp = QThread() 'Server-Objekt instanziieren' self.server_emp = Server_empfaenger() 'Server-Objekt an den Thread übergeben' self.server_emp.moveToThread(self.thread_server_emp) 'Signale und Slots verbinden' self.thread_server_emp.started.connect(self.server_emp.server_starten) self.server_emp.nachricht_empfangen.connect(self.nachricht_empfangen) print("server_emp.nachricht_empfangen connected") self.thread_server_emp.finished.connect( self.thread_server_emp.deleteLater) 'Methode start des Thread-Objektes aufrufen' self.thread_server_emp.start() 'Methode exec des Thread-Objektes aufrufen' self.thread_server_emp.exec()
def start_thread(self): self.weight_monitor = ArduinoMonitor() self.t = QThread(self) self.weight_monitor.weight_signal.connect(self.update_weight) self.weight_monitor.moveToThread(self.t) self.t.started.connect(self.weight_monitor.check_weight) self.t.start()
def __accepted(self): steps = self.addonwidget.item_state() if steps: # Move all uninstall steps to the front steps = sorted(steps, key=lambda step: 0 if step[0] == Uninstall else 1) self.__installer = Installer(steps=steps, user_install=self.user_install) self.__thread = QThread(self) self.__thread.start() self.__installer.moveToThread(self.__thread) self.__installer.finished.connect(self.__on_installer_finished) self.__installer.error.connect(self.__on_installer_error) self.__installer.installStatusChanged.connect( self.__progress.setLabelText) self.__progress.show() self.__progress.setLabelText("Installing") self.__installer.start() else: self.accept()
def startWorker(self, layer): # Initialize worker with selected layer worker = Worker(layer) # Disable run button self.dlg.runButton.setEnabled(False) # Ensure worker is killed if dialog is "killed" (either by the user clicking Cancel, closing the dialog, or by pressing the Escape key) self.dlg.rejected.connect(worker.kill) # Initialize new thread and move worker to it thread = QThread(self.dlg) worker.moveToThread(thread) # Connect signals to slots worker.finished.connect(self.workerFinished) worker.error.connect(self.workerError) worker.progress.connect(self.dlg.progressBar.setValue) thread.started.connect(worker.run) # Start thread and run worker thread.start() # Save reference to thread and worker self.thread = thread self.worker = worker
def search_thread(self): ''' Creates Qt thread for searching so that the GUI does not freeze and QGIS does not crash. ''' # # Disable search button while searching. # self.dlg.btnSearch.setEnabled(False) self.dlg.btnSearchCancel.setEnabled(True) self.worker = SentinelSearch(self.dlg) self.thread = QThread() self.worker.moveToThread(self.thread) self.thread.start() self.thread.started.connect(self.worker.get_query_xml) # # Signal handelling from thread. # self.worker.query_check.connect(self.query_search_check) self.worker.connecting_message.connect(self.set_search_label) self.worker.searching_message.connect(self.set_search_label) self.worker.enable_btnSearch.connect(self.enable_btnSearch) self.worker.search_progress_max.connect(self.set_progress_max) self.worker.search_progress_set.connect(self.set_progress) self.worker.set_message.connect(self.set_messageBar) self.worker.finished.connect(self.search_finished)
def __init__(self, *args, **kwargs): QWidget.__init__(self, *args, **kwargs) self.button = QtGui.QPushButton("Run", self) self.button.clicked.connect(self.onButton) self.progress = QtGui.QProgressBar(self) self.progress.setTextVisible(False) self.layout = QtGui.QVBoxLayout() self.layout.setContentsMargins(5, 5, 5, 5) self.layout.addWidget(self.button) self.layout.addWidget(self.progress) self.layout.addStretch() self.worker_thread = QThread() self.worker_thread.run = run_gestures #self.worker self.worker_thread.should_close = False self.signals = Signals() self.signals.update.connect(self.progress.setValue) self.signals.enable_button.connect(self.button.setEnabled) self.setLayout(self.layout) self.show() self.resize(self.size().width(), 0)
def __init__(self, iface, parent=None): super(ComposersDialog, self).__init__(parent) self.setupUi(self) self.iface = iface self.btnSave = QPushButton(self.tr("Save")) self.btnSave.setIcon( QgsApplication.getThemeIcon("/mActionFileSave.svg")) self.btnSave.clicked.connect(self.saveToFile) #self.btnCopy = QPushButton(self.tr("Copy")) #self.btnCopy.setIcon(QgsApplication.getThemeIcon("/mActionEditCopy.svg")) #self.btnCopy.clicked.connect(self.copyToClipboard) self.buttonBox.addButton(self.btnSave, QDialogButtonBox.ActionRole) #self.buttonBox.addButton(self.btnCopy, QDialogButtonBox.ActionRole) #self.buttonBox.helpRequested.connect() self.progressBar.hide() self.thread = QThread() self.writer = TemplateWriter() self.writer.moveToThread(self.thread) self.writer.finished.connect(self.thread.quit) self.writer.finished.connect(self.exportFinished) self.writer.composerExported.connect(self.updateProgress) self.thread.started.connect(self.writer.export) self.composers = None self.loadComposers()
def startWorker(self, dsm, dem, dsm_build, poly, poly_field, vlayer, prov, fields, idx, dir_poly, iface, plugin_dir, folderPath, dlg, imid, radius, degree, rm): # create a new worker instance # Skapar en instans av metoden som innehaller det arbete som ska utforas i en trad worker = Worker(dsm, dem, dsm_build, poly, poly_field, vlayer, prov, fields, idx, dir_poly, iface, plugin_dir, folderPath, dlg, imid, radius, degree, rm) # andrar knappen som startar verktyget till en knapp som avbryter tradens arbete. self.dlg.runButton.setText('Cancel') self.dlg.runButton.clicked.disconnect() self.dlg.runButton.clicked.connect(worker.kill) self.dlg.closeButton.setEnabled(False) # Skapar en trad som arbetet fran worker ska utforas i. thread = QThread(self.dlg) worker.moveToThread(thread) # kopplar signaler fran traden till metoder i denna "fil" worker.finished.connect(self.workerFinished) worker.error.connect(self.workerError) worker.progress.connect(self.progress_update) thread.started.connect(worker.run) # startar traden thread.start() self.thread = thread self.worker = worker
def _initThread(self): self.thread = QThread(self) self.thread.setObjectName("QGIS_Plugin_%s" % NAME_PLUGIN.replace(' ', '_')) self.worker = WorkerPopulateGroup(self.addLegendLayerWorker) self.worker.moveToThread(self.thread) self._connectWorker()
def __init__(self, iface, parent=None): super(Photo2ShapeDialog, self).__init__(parent) self.setupUi(self) self.iface = iface self.settings = QSettings('alexbruy', 'photo2shape') self.thread = QThread() self.importer = PhotoImporter() self.btnOk = self.buttonBox.button(QDialogButtonBox.Ok) self.btnClose = self.buttonBox.button(QDialogButtonBox.Close) self.btnSelectInput.clicked.connect(self.selectDirectory) self.btnSelectOutput.clicked.connect(self.selectFile) self.importer.moveToThread(self.thread) self.importer.importError.connect(self.thread.quit) self.importer.importError.connect(self.importCanceled) self.importer.importMessage.connect(self.logMessage) self.importer.importFinished.connect(self.thread.quit) self.importer.importFinished.connect(self.importCompleted) self.importer.photoProcessed.connect(self.updateProgress) self.thread.started.connect(self.importer.importPhotos) self.manageGui()
def build_index(self, project): self.searchbox.setEnabled(False) self.resultsView.setEnabled(False) self.resultsView.addItem("building search index...") validformat, settings = valid_search_settings(project.settings) if not validformat: RoamEvents.raisemessage("Searching", "Invalid search config.", level=1) self.searchbox.hide() self.resultsView.clear() self.resultsView.addItem("Invalid search config found") return self.indexthread = QThread() path = os.path.join(os.environ['APPDATA'], "roam", project.name) roam.utils.info("Search index path: {0}".format(path)) if not os.path.exists(path): os.makedirs(path) self.indexbuilder = IndexBuilder(path, settings) self.indexbuilder.moveToThread(self.indexthread) QgsMapLayerRegistry.instance().removeAll.connect(self.indexthread.quit) self.indexbuilder.indexBuilt.connect(self.index_built) self.indexbuilder.finished.connect(self.indexthread.quit) self.indexthread.started.connect(self.indexbuilder.build_index) self.indexthread.finished.connect(self.indexbuilder.quit) self.indexthread.start()
def start(self, *args, **kwargs): """Starts worker in separate thread""" # stop any previously running workers self.stop() self.result = None self.error = None self.running = True self.thread = QThread() self.worker = self.cls(*args, **kwargs) self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.start) # graceful stop does not work without direct connection (?) self.worker.finished.connect(self.thread.quit, Qt.DirectConnection) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.thread.deleteLater) # also save result/error on finish (useful for testing) self.worker.finished.connect(self.handlefinished, Qt.DirectConnection) self.worker.raised.connect(self.handleraised, Qt.DirectConnection) self.worker.completed.connect(self.handlecompleted, Qt.DirectConnection) self.worker.killed.connect(self.handlekilled, Qt.DirectConnection) self.thread.start() # returns worker so caller can connect signals, etc. return self.worker
def startWorker(self, dsm, scale, building_slope, building_aspect, voxelheight, sizey, sizex, vegdsm, vegdsm2, wheight, waspect, albedo, psi, radmatI, radmatD, radmatR, usevegdem, calc_month, dlg): # create a new worker instance worker = Worker(dsm, scale, building_slope, building_aspect, voxelheight, sizey, sizex, vegdsm, vegdsm2, wheight, waspect, albedo, psi, radmatI, radmatD, radmatR, usevegdem, calc_month, dlg) self.dlg.runButton.setText('Cancel') self.dlg.runButton.clicked.disconnect() self.dlg.runButton.clicked.connect(worker.kill) self.dlg.pushButtonClose.setEnabled(False) # start the worker in a new thread thread = QThread(self.dlg) worker.moveToThread(thread) worker.finished.connect(self.workerFinished) worker.error.connect(self.workerError) worker.progress.connect(self.progress_update) thread.started.connect(worker.run) thread.start() self.thread = thread self.worker = worker
def build_index(self, project): self.searchbox.setEnabled(False) self.resultsView.setEnabled(False) self.resultsView.addItem( "Just let me build the search index first....") validformat, settings = valid_search_settings(project.settings) if not validformat: RoamEvents.raisemessage("Searching", "Invalid search config.", level=1) self.searchbox.hide() self.resultsView.clear() self.resultsView.addItem("Invalid search config found") return self.indexthread = QThread() self.indexbuilder = IndexBuilder(project.folder, settings) self.indexbuilder.moveToThread(self.indexthread) QgsMapLayerRegistry.instance().removeAll.connect(self.indexthread.quit) self.indexbuilder.indexBuilt.connect(self.index_built) self.indexbuilder.finished.connect(self.indexthread.quit) self.indexthread.started.connect(self.indexbuilder.build_index) self.indexthread.finished.connect(self.indexbuilder.quit) self.indexthread.start()
def startCleaning(self): self.dlg.cleaningProgress.reset() self.settings = self.dlg.get_settings() if self.settings['output_type'] == 'postgis': db_settings = self.dlg.get_dbsettings() self.settings.update(db_settings) if self.settings['input']: cleaning = self.clean(self.settings, self.iface) # start the cleaning in a new thread thread = QThread() cleaning.moveToThread(thread) cleaning.finished.connect(self.cleaningFinished) cleaning.error.connect(self.cleaningError) cleaning.warning.connect(self.giveMessage) cleaning.cl_progress.connect(self.dlg.cleaningProgress.setValue) thread.started.connect(cleaning.run) # thread.finished.connect(self.cleaningFinished) self.thread = thread self.cleaning = cleaning self.thread.start() if is_debug: print 'started' else: self.giveMessage('Missing user input!', QgsMessageBar.INFO) return
def runSearch(self): '''Called when the user pushes the Search button''' selectedLayer = self.layerListComboBox.currentIndex() comparisonMode = self.comparisonComboBox.currentIndex() self.noSelection = True try: str = unicode(self.findStringEdit.text()).strip() except: self.showErrorMessage('Invalid Search String') return if str == '': self.showErrorMessage('Search string is empty') return if selectedLayer == 0: # Include all vector layers layers = self.iface.legendInterface().layers() elif selectedLayer == 1: # Include all selected vector layers layers = self.iface.legendInterface().selectedLayers() else: # Only search on the selected vector layer layers = [self.searchLayers[selectedLayer]] self.vlayers = [] # Find the vector layers that are to be searched for layer in layers: if isinstance(layer, QgsVectorLayer): self.vlayers.append(layer) if len(self.vlayers) == 0: self.showErrorMessage( 'There are no vector layers to search through') return # vlayers contains the layers that we will search in self.searchButton.setEnabled(False) self.stopButton.setEnabled(True) self.doneButton.setEnabled(False) self.clearButton.setEnabled(False) self.clearResults() self.resultsLabel.setText('') infield = self.searchFieldComboBox.currentIndex() >= 1 if infield is True: selectedField = unicode(self.searchFieldComboBox.currentText()) else: selectedField = None # Because this could take a lot of time, set up a separate thread # for a worker function to do the searching. thread = QThread() worker = Worker(self.vlayers, infield, str, comparisonMode, selectedField, self.maxResults) worker.moveToThread(thread) thread.started.connect(worker.run) worker.finished.connect(self.workerFinished) worker.foundmatch.connect(self.addFoundItem) worker.error.connect(self.workerError) self.thread = thread self.worker = worker self.noSelection = False thread.start()
def startWorker(self, ExtrairShape, CalcShape, OutShape, Ref, TypeUnits): # create a new worker instance worker = Worker(ExtrairShape, CalcShape, OutShape, Ref, TypeUnits) # configure the QgsMessageBar qgis.utils.iface.messageBar().clearWidgets() progressMessageBar = qgis.utils.iface.messageBar().createMessage('Calculating area...') progressBar = QProgressBar() progressBar.setMaximum(100) progressMessageBar.layout().addWidget(progressBar) qgis.utils.iface.messageBar().pushWidget(progressMessageBar) self.progressMessageBar = progressMessageBar # start the worker in a new thread thread = QThread() worker.moveToThread(thread) worker.finished.connect(self.workerFinished) worker.error.connect(self.workerError) worker.progress.connect(progressBar.setValue) thread.started.connect(worker.runCalc) thread.start() self.thread = thread self.worker = worker self.output = OutShape
def cancel_analyz(self): self.analyzer_runner.is_running = False self.analyzer_runner_thread.quit() self.analyzer_runner_thread.wait() self.analyzer_runner_thread = QThread() self.analyzer_runner = AnalyzerRunner(self.controller)
def start(self): self.__thread = QThread(self) self.__worker.moveToThread(self.__thread) self.__worker.finished.connect(self.finishProcess) self.__thread.started.connect(self.__worker.run) self.__thread.start()
def start_worker(worker, iface, message, with_progress=True): # configure the QgsMessageBar message_bar_item = iface.messageBar().createMessage(message) progress_bar = QProgressBar() progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) if not with_progress: progress_bar.setMinimum(0) progress_bar.setMaximum(0) cancel_button = QPushButton() cancel_button.setText('Cancel') cancel_button.clicked.connect(worker.kill) message_bar_item.layout().addWidget(progress_bar) message_bar_item.layout().addWidget(cancel_button) iface.messageBar().pushWidget(message_bar_item, iface.messageBar().INFO) # start the worker in a new thread # let Qt take ownership of the QThread thread = QThread(iface.mainWindow()) worker.moveToThread(thread) worker.set_message.connect( lambda message: set_worker_message(message, message_bar_item)) worker.toggle_show_progress.connect( lambda show: toggle_worker_progress(show, progress_bar)) worker.toggle_show_cancel.connect( lambda show: toggle_worker_cancel(show, cancel_button)) worker.finished.connect(lambda result: worker_finished( result, thread, worker, iface, message_bar_item)) worker.error.connect(lambda e: worker_error(e)) worker.progress.connect(progress_bar.setValue) thread.started.connect(worker.run) thread.start() return thread, message_bar_item
def test_task(self): results = [] task = Task(function=QThread.currentThread) task.resultReady.connect(results.append) task.start() self.app.processEvents() self.assertSequenceEqual(results, [QThread.currentThread()]) results = [] thread = QThread() thread.start() task = Task(function=QThread.currentThread) task.moveToThread(thread) self.assertIsNot(task.thread(), QThread.currentThread()) self.assertIs(task.thread(), thread) task.resultReady.connect(results.append, Qt.DirectConnection) task.start() f = task.future() self.assertIsNot(f.result(3), QThread.currentThread()) self.assertIs(f.result(3), results[-1])
def startWorker(self, iface, layer): self.dlg.header.setText("Calculating...") worker = Worker(iface, layer) messageBar = self.iface.messageBar().createMessage( 'Calculating range...', ) progressBar = QProgressBar() progressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) cancelButton = QPushButton() cancelButton.setText('Cancel') cancelButton.clicked.connect(worker.kill) messageBar.layout().addWidget(progressBar) messageBar.layout().addWidget(cancelButton) self.iface.messageBar().pushWidget(messageBar, self.iface.messageBar().INFO) self.messageBar = messageBar #start the worker in a new thread thread = QThread() worker.moveToThread(thread) worker.finished.connect(self.workerFinished) worker.error.connect(self.workerError) worker.progress.connect(progressBar.setValue) thread.started.connect(worker.run) thread.start() self.thread = thread self.worker = worker pass
def start_worker_files(self, checked, src, dst, selected_images, local_config): # create a new worker instance worker = WorkerFiles(checked, src, dst, selected_images, local_config) # configure the QgsMessageBar messageBar = self.iface.messageBar().createMessage( 'List and copy files...', ) progressBarList = QProgressBar() progressBarCopy = QProgressBar() progressBarList.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) progressBarCopy.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) cancelButton = QPushButton() cancelButton.setText('Cancel') cancelButton.clicked.connect(worker.kill) messageBar.layout().addWidget(progressBarList) messageBar.layout().addWidget(progressBarCopy) messageBar.layout().addWidget(cancelButton) self.iface.messageBar().pushWidget(messageBar, self.iface.messageBar().INFO) self.messageBarFiles = messageBar # start the worker in a new thread thread = QThread() worker.moveToThread(thread) worker.finished.connect(self.finished_worker_files) worker.error.connect(self.workerError) worker.progressList.connect(progressBarList.setValue) worker.progressCopy.connect(progressBarCopy.setValue) thread.started.connect(worker.run) thread.start() self.thread_files = thread self.worker_files = worker
def uploadDoc(self): """ Upload the file to the central repository in a separate thread using the specified file manager """ if isinstance(self.fileManager, NetworkFileManager): self.pgBar.setVisible(True) self._docSize = self.fileInfo.size() ''' Create document transfer helper for multi-threading capabilities. Use of queued connections will guarantee that signals and slots are captured in any thread. ''' workerThread = QThread(self) docWorker = DocumentTransferWorker( self.fileManager, self.fileInfo, "%s"%(self._source_entity), "%s"%(self._doc_type), self ) docWorker.moveToThread(workerThread) workerThread.started.connect(docWorker.transfer) docWorker.blockWrite.connect(self.onBlockWritten) docWorker.complete.connect(self.onCompleteTransfer) workerThread.finished.connect(docWorker.deleteLater) workerThread.finished.connect(workerThread.deleteLater) workerThread.start() # Call transfer() to get fileUUID early #docWorker.transfer() self.fileUUID = docWorker.file_uuid
def run_update(self): #self.update_pic() from PyQt4.QtCore import QThread #TODO: Fix threading self.next_thread = QThread() self.next_thread.started.connect(self.update_pic) self.next_thread.start()