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()]) thread = QThread() thread.start() try: task = Task(function=QThread.currentThread) task.moveToThread(thread) self.assertIsNot(task.thread(), QThread.currentThread()) self.assertIs(task.thread(), thread) results = Future() def record(value): # record the result value and the calling thread results.set_result((QThread.currentThread(), value)) task.resultReady.connect(record, Qt.DirectConnection) task.start() f = task.future() emit_thread, thread_ = results.result(3) self.assertIs(f.result(3), thread) self.assertIs(emit_thread, thread) self.assertIs(thread_, thread) finally: thread.quit() thread.wait()
def test_methodinvoke(self): executor = ThreadExecutor() state = [None, None] class StateSetter(QObject): @Slot(object) def set_state(self, value): state[0] = value state[1] = QThread.currentThread() def func(callback): callback(QThread.currentThread()) obj = StateSetter() f1 = executor.submit(func, methodinvoke(obj, "set_state", (object,))) f1.result() # So invoked method can be called QCoreApplication.processEvents() self.assertIs(state[1], QThread.currentThread(), "set_state was called from the wrong thread") self.assertIsNot(state[0], QThread.currentThread(), "set_state was invoked in the main thread") executor.shutdown(wait=True)
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 test_methodinvoke(self): executor = ThreadExecutor() state = [None, None] class StateSetter(QObject): @pyqtSlot(object) def set_state(self, value): state[0] = value state[1] = QThread.currentThread() def func(callback): callback(QThread.currentThread()) obj = StateSetter() f1 = executor.submit(func, methodinvoke(obj, "set_state", (object, ))) f1.result() # So invoked method can be called from the event loop self.app.processEvents() self.assertIs( state[1], QThread.currentThread(), "set_state was called from the wrong thread", ) self.assertIsNot( state[0], QThread.currentThread(), "set_state was invoked in the main thread", ) executor.shutdown(wait=True)
def _task_finished(self, f): """ Parameters: ---------- f: conncurent.futures.Future future instance holding the result of learner evaluation """ assert self.thread() is QThread.currentThread() assert self._task is not None assert self._task.future is f assert f.done() self._task = None if not self.was_canceled: self.cancel_button.setDisabled(True) try: results = f.result() except Exception as ex: log = logging.getLogger() log.exception(__name__, exc_info=True) self.error("Exception occured during evaluation: {!r}".format(ex)) for key in self.results.keys(): self.results[key] = None else: self.update_view(results[1]) self.progressBarFinished(processEvents=False)
def __onRunFinished(self): assert QThread.currentThread() is self.thread() assert self.__state == State.Processing assert self.__pendingTask is not None assert self.sender() is self.__pendingTask.watcher assert self.__pendingTask.future.done() task = self.__pendingTask self.__pendingTask = None try: data, n_skipped = task.future.result() except Exception: sys.excepthook(*sys.exc_info()) state = State.Error data = None n_skipped = 0 self.error(traceback.format_exc()) else: state = State.Done self.error() if data: self._n_image_data = len(data) self._n_image_categories = len(data.domain.class_var.values)\ if data.domain.class_var else 0 self.data = data self._n_skipped = n_skipped self.__setRuntimeState(state) self.commit()
def setCurrentCharFormat(self, charformat): # type: (QTextCharFormat) -> None """Set the QTextCharFormat to be used when writing. """ assert QThread.currentThread() is self.thread() if self.__currentCharFormat != charformat: self.__currentCharFormat = QTextCharFormat(charformat)
def clear(self): # type: () -> None """ Clear the displayed text. """ assert QThread.currentThread() is self.thread() self.__text.clear()
def write(self, string): # type: (str) -> None assert QThread.currentThread() is self.thread() self.__text.moveCursor(QTextCursor.End, QTextCursor.MoveAnchor) self.__text.setCurrentCharFormat(self.__currentCharFormat) self.__text.insertPlainText(string)
def _task_finished(self, f): """ Parameters ---------- f : Future The future instance holding the result of learner evaluation. """ assert self.thread() is QThread.currentThread() assert self._task is not None assert self._task.future is f assert f.done() self._task = None self.progressBarFinished() # try: # result = f.result() # type: List[Results] # except Exception as ex: # # Log the exception with a traceback # log = logging.getLogger() # log.exception(__name__, exc_info=True) # self.error("Exception occurred during evaluation: {!r}".format(ex)) # # clear all results # self.result= None # else: print(self.learn.validate())
def __onRunFinished(self): assert QThread.currentThread() is self.thread() assert self.__state == State.Processing assert self.__pendingTask is not None assert self.sender() is self.__pendingTask.watcher assert self.__pendingTask.future.done() task = self.__pendingTask self.__pendingTask = None try: corpus, errors = task.future.result() except Exception: sys.excepthook(*sys.exc_info()) state = State.Error corpus = None errors = [] self.error(traceback.format_exc()) else: state = State.Done self.error() if corpus: self.n_text_data = len(corpus) self.n_text_categories = len(corpus.domain.class_var.values)\ if corpus.domain.class_var else 0 self.corpus = corpus self.n_skipped = len(errors) if len(errors): self.Warning.read_error("Some files" if len(errors) > 1 else "One file") self.__setRuntimeState(state) self.commit()
def _task_finished(self, f): """ Parameters ---------- f : Future The future instance holding the built model """ assert self.thread() is QThread.currentThread() assert self._task is not None assert self._task.future is f assert f.done() self._task.deleteLater() self._task = None self.setBlocking(False) self.progressBarFinished() try: self.model = f.result() except Exception as ex: # pylint: disable=broad-except # Log the exception with a traceback log = logging.getLogger() log.exception(__name__, exc_info=True) self.model = None self.show_fitting_failed(ex) else: self.model.name = self.learner_name self.model.instances = self.data self.model.skl_model.orange_callback = None # remove unpicklable callback self.Outputs.model.send(self.model)
def __onRunFinished(self): assert QThread.currentThread() is self.thread() assert self.__state == State.Processing assert self.__pendingTask is not None assert self.sender() is self.__pendingTask.watcher assert self.__pendingTask.future.done() task = self.__pendingTask self.__pendingTask = None try: image_meta = task.future.result() except Exception as err: sys.excepthook(*sys.exc_info()) state = State.Error image_meta = [] self.error(traceback.format_exc()) else: state = State.Done self.error() categories = {} for imeta in image_meta: # derive categories from the path relative to the starting dir dirname = os.path.dirname(imeta.path) relpath = os.path.relpath(dirname, task.startdir) categories[dirname] = relpath self._imageMeta = image_meta self._imageCategories = categories self.__setRuntimeState(state) self.commit()
def __onRunFinished(self): assert QThread.currentThread() is self.thread() assert self.__state == State.Processing assert self.__pendingTask is not None assert self.sender() is self.__pendingTask.watcher assert self.__pendingTask.future.done() task = self.__pendingTask self.__pendingTask = None try: corpus, errors = task.future.result() except Exception: sys.excepthook(*sys.exc_info()) state = State.Error corpus = None errors = [] self.error(traceback.format_exc()) else: state = State.Done self.error() if corpus: self.n_text_data = len(corpus) self.n_text_categories = len(corpus.domain.class_var.values)\ if corpus.domain.class_var else 0 self.corpus = corpus self.n_skipped = len(errors) if len(errors): self.Warning.read_error( "Some files" if len(errors) > 1 else "One file") self.__setRuntimeState(state) self.commit()
def __set_results(self, f): assert self.thread() is QThread.currentThread() if self._task is None or self._task.future is not f: self._log.info("Reaping stale task") return assert f.done() task, self._task = self._task, None self.auto_commit_widget.setDisabled(False) self.cancel_button.setDisabled(True) self.cb_image_attr.setDisabled(False) self.cb_embedder.setDisabled(False) self.progressBarFinished() self.setBlocking(False) try: embeddings = f.result() except ConnectionError: self._log.exception("Error", exc_info=True) self._send_output_signals((None, None, 0)) return except Exception as err: self._log.exception("Error", exc_info=True) self.error( "\n".join(traceback.format_exception_only(type(err), err))) self._send_output_signals((None, None, 0)) return assert self._input_data is not None assert len(self._input_data) == len(task.file_paths_mask) self._send_output_signals(embeddings)
def __onRunFinished(self): assert QThread.currentThread() is self.thread() assert self.__state == State.Processing assert self.__pendingTask is not None assert self.sender() is self.__pendingTask.watcher assert self.__pendingTask.future.done() task = self.__pendingTask self.__pendingTask = None try: data, n_skipped = task.future.result() except Exception: sys.excepthook(*sys.exc_info()) state = State.Error data = None n_skipped = 0 self.error(traceback.format_exc()) else: state = State.Done self.error() if data: self._n_image_data = len(data) self._n_image_categories = len(data.domain.class_var.values)\ if data.domain.class_var else 0 else: self._n_image_data, self._n_image_categories = 0, 0 self.data = data self._n_skipped = n_skipped self.__setRuntimeState(state) self.commit()
def download_complete(self, future): assert self.thread() is QThread.currentThread() assert future.done() self._task = None self.progressBarFinished() self.setCursor(Qt.ArrowCursor) self.btn_download.setText(self.LABEL_DOWNLOAD) self.btn_connect.setEnabled(True) self.Information.fetching_node_info.clear() table = None try: df = future.result() # type: pd.DataFrame except self.Cancelled: pass except Exception as e: log.exception("Failed to download data for nodes") self.Error.fetching_node_info_failed(e) else: if df.shape[0] > self.sample_size: df = df.sample(self.sample_size) table = table_from_frame(df) self.Outputs.data.send(table)
def _gene_selection_task_finished(self, f): assert self.thread() is QThread.currentThread() assert self._task is not None assert self._task.future is f assert f.done() self._task = None self.progressBarFinished() self.clusters, genes, self.model, self.pvalues = f.result() genes = [str(gene) for gene in genes] self.columns = DiscreteVariable("Gene", genes, ordered=True) self.tableview.set_headers( self.clusters, self.columns.values, circles=True, cell_size=self.CELL_SIZES[self.cell_size_ix], bold_headers=False) def tooltip(i, j): return ( "<b>cluster</b>: {}<br /><b>gene</b>: {}<br /><b>fraction expressing</b>: {:.2f}<br />\ <b>p-value</b>: {:.2e}".format( self.clusters[i], self.columns.values[j], self.model[i, j], self.pvalues[i, j])) self.tableview.update_table(self.model, tooltip=tooltip) self._invalidate()
def run(self): """ Reimplemented from `QRunnable.run` """ self.eventLoop = QEventLoop() self.eventLoop.processEvents() # Move the task to the current thread so it's events, signals, slots # are triggered from this thread. assert self.task.thread() is _TaskDepotThread.instance() QMetaObject.invokeMethod( self.task.thread(), "transfer", Qt.BlockingQueuedConnection, Q_ARG(object, self.task), Q_ARG(object, QThread.currentThread()) ) self.eventLoop.processEvents() # Schedule task.run from the event loop. self.task.start() # Quit the loop and exit when task finishes or is cancelled. self.task.finished.connect(self.eventLoop.quit) self.task.cancelled.connect(self.eventLoop.quit) self.eventLoop.exec_()
def setBioMartDatasets(self, datasets): assert(QThread.currentThread() is self.thread()) self.setEnabled(True) self.datasets = [data for data in datasets if getattr(data, "visible", "0") != "0"] self.datasetsCombo.clear() self.datasetsCombo.addItems([data.displayName for data in self.datasets])
def __onReportProgress(self, arg): # report on scan progress from a worker thread # arg must be a namespace(count: int, lastpath: str) assert QThread.currentThread() is self.thread() if self.__state == State.Processing: self.pathlabel.setText(prettifypath(arg.lastpath)) self.progress_widget.setValue(int(100 * arg.progress))
def __emitpending(self, index, future): # type: (int, Future) -> None assert QThread.currentThread() is self.thread() assert self.__futures[index] is future assert future.done() assert self.__countdone < len(self.__futures) self.__futures[index] = None self.__countdone += 1 if future.cancelled(): self.cancelledAt.emit(index, future) self.doneAt.emit(index, future) elif future.done(): self.finishedAt.emit(index, future) self.doneAt.emit(index, future) if future.exception(): self.exceptionReadyAt.emit(index, future.exception()) else: self.resultReadyAt.emit(index, future.result()) else: assert False self.progressChanged.emit(self.__countdone, len(self.__futures)) if self.__countdone == len(self.__futures): self.doneAll.emit()
def __del__(self: QObject): # Note: This is otherwise quite similar to how PyQt5 does this except # for the resurrection (i.e. the wrapper is allowed to be freed, but # C++ part is deleteLater-ed). if sip.ispyowned(self): try: own_thread = self.thread() is QThread.currentThread() except RuntimeError: return if not own_thread: # object resurrection; keep python wrapper alive and schedule # deletion from the object's own thread. PyOwned.__delete_later_set.add(self) ref = weakref.ref(self) # Clear final ref from 'destroyed' signal. As late as possible # in QObject' destruction. def clear(): self = ref() try: PyOwned.__delete_later_set.remove(self) except KeyError: pass self.destroyed.connect(clear, Qt.DirectConnection) self.deleteLater()
def on_computed(self, future): assert self.thread() is QThread.currentThread() assert future.done() self._task = None self.progressBarFinished() df = future.result() # Only retain "significant" p-values df = df[df[CORRECTED_LABEL] < .2] columns = [var.name for var in df.index.name] + list(df.columns) lst = [list(i) + list(j) for i, j in zip(df.index, df.values)] results_table = table_from_frame(pd.DataFrame(lst, columns=columns), force_nominal=True) results_table.name = 'Significant Groups' self.Outputs.results.send(results_table) self.view.set_vars(list(df.index.name)) self.model.setHorizontalHeaderLabels(columns, len(df.index.name)) self.model.wrap(lst) self.view.sortByColumn(len(columns) - 1, Qt.AscendingOrder) self.Information.nothing_significant(shown=not lst) self.btn_compute.setEnabled(True)
def run(self): """ Reimplemented from `QRunnable.run` """ self.eventLoop = QEventLoop() self.eventLoop.processEvents() # Move the task to the current thread so it's events, signals, slots # are triggered from this thread. assert self.task.thread() is _TaskDepotThread.instance() QMetaObject.invokeMethod( self.task.thread(), "transfer", Qt.BlockingQueuedConnection, Q_ARG(object, self.task), Q_ARG(object, QThread.currentThread()), ) self.eventLoop.processEvents() # Schedule task.run from the event loop. self.task.start() # Quit the loop and exit when task finishes or is cancelled. self.task.finished.connect(self.eventLoop.quit) self.task.cancelled.connect(self.eventLoop.quit) self.eventLoop.exec_()
def _task_finished(self, f): """ Parameters ---------- f : Future The future instance holding the result of learner evaluation. """ assert self.thread() is QThread.currentThread() assert self._task is not None assert self._task.future is f assert f.done() self._task = None self.progressBarFinished() self.train_button.setEnabled(True) self.model.eval( ) # eval mode (batchnorm uses moving mean/variance instead of mini-batch mean/variance) with torch.no_grad(): correct = 0 total = 0 for images, labels in self.test_data: images = images.to(self.device) labels = labels.to(self.device) outputs = self.model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() self.label.setText('测试数据集的准确率为: {} %'.format(100 * correct / total))
def __commit_complete(self, f): # complete the commit operation after the required file has been # downloaded assert QThread.currentThread() is self.thread() assert self.__awaiting_state is not None assert self.__awaiting_state.future is f if self.isBlocking(): self.progressBarFinished(processEvents=None) self.setBlocking(False) self.setStatusMessage("") self.__awaiting_state = None try: path = f.result() except Exception as ex: log.exception("Error:") self.error(format_exception(ex)) path = None self.__update_cached_state() if path is not None: data = Orange.data.Table(path) else: data = None self.Outputs.data.send(data)
def __download_finish(self, result): # type: (Future[None]) -> None assert QThread.currentThread() is self.thread() assert result.done() self.setBlocking(False) self.setStatusMessage("") self.progressBarFinished(processEvents=False) try: result.result() except ConnectTimeout: logging.getLogger(__name__).error("Error:") self.error( 2, "Internet connection error, unable to load data. " + "Check connection and create a new GO Browser widget.") except RequestException as err: logging.getLogger(__name__).error("Error:") self.error(2, "Internet error:\n" + str(err)) except BaseException as err: logging.getLogger(__name__).error("Error:") self.error(2, "Error:\n" + str(err)) raise else: self.error(2) finally: self.__state = State.Ready
def _handleException(self, exception): assert(QThread.currentThread() is self.thread()) print("Task failed with:", exception, file=sys.stderr) import logging log = logging.getLogger(__name__) log.exception("Error:", exc_info=exception) self.error(0, str(exception)) self.setEnabled(True)
def __onReportProgress(self, arg): # report on scan progress from a worker thread # arg must be a namespace(count: int, lastpath: str) assert QThread.currentThread() is self.thread() if self.__state == State.Processing: self.pathlabel.setText(prettifypath(arg.lastpath)) self.progress_widget.setValue(arg.progress) self.progress_widget.setValue(100 * arg.progress)
def transfer(self, obj, thread): """ Transfer `obj` (:class:`QObject`) instance from this thread to the target `thread` (a :class:`QThread`). """ assert obj.thread() is self assert QThread.currentThread() is self obj.moveToThread(thread)
def _stateChanged(self, future, state): """ The `future` state has changed (called by :class:`Future`). """ ev = StateChangedEvent(state) if self.thread() is QThread.currentThread(): QCoreApplication.sendEvent(self, ev) else: QCoreApplication.postEvent(self, ev)
def setBioMartRegistry(self, registry): assert(QThread.currentThread() is self.thread()) self.setEnabled(True) self.registry = registry self.marts = [mart for mart in self.registry.marts() if getattr(mart, "visible", "0") != "0"] self.martsCombo.clear() for mart in self.marts: self.martsCombo.addItem(mart.displayName)
def __task_complete(self, task): # handle a completed task assert self.thread() is QThread.currentThread() if self.__task is not task: assert task.cancelled log.debug("Reaping cancelled task: %r", "<>") return self.setBlocking(False) self.progressBarFinished(processEvents=None) self.setStatusMessage("") result = task.future assert result.done() self.__task = None try: results = result.result() # type: Results learners = results.learners # type: List[Learner] except Exception as er: log.exception("testing error (in __task_complete):", exc_info=True) self.error("\n".join(traceback.format_exception_only(type(er), er))) self.__state = State.Done return self.__state = State.Done learner_key = { slot.learner: key for key, slot in self.learners.items() } assert all(learner in learner_key for learner in learners) # Update the results for individual learners class_var = results.domain.class_var for learner, result in zip(learners, results.split_by_model()): stats = None if class_var.is_primitive(): ex = result.failed[0] if ex: stats = [Try.Fail(ex)] * len(self.scorers) result = Try.Fail(ex) else: stats = [ Try(scorer_caller(scorer, result)) for scorer in self.scorers ] result = Try.Success(result) key = learner_key.get(learner) self.learners[key] = \ self.learners[key]._replace(results=result, stats=stats) self._update_header() self._update_stats_model() self.commit()
def __call__(self, exc_type, exc_value, tb): if self._stream: header = exc_type.__name__ + ' Exception' if QThread.currentThread() != QCoreApplication.instance().thread(): header += " (in non-GUI thread)" text = traceback.format_exception(exc_type, exc_value, tb) text.insert(0, '{:-^79}\n'.format(' ' + header + ' ')) text.append('-' * 79 + '\n') self._stream.writelines(text) self.handledException.emit((exc_type, exc_value, tb))
def setStatusMessage(self, text): """ Set widget's status message. This is a short status string to be displayed inline next to the instantiated widget icon in the canvas. """ assert QThread.currentThread() == self.thread() if self.__statusMessage != text: self.__statusMessage = text self.statusMessageChanged.emit(text)
def _init_task_finished(self, f): assert self.thread() is QThread.currentThread() assert self._task is not None assert self._task.future is f assert f.done() self._task = None self.progressBarFinished() self.ca = f.result() self._set_gene_selection()
def __on_exception(self, idx, ex): assert QThread.currentThread() is self.thread() assert self.__task is not None if isinstance(ex, NotEnoughData): self.Error.not_enough_data(len(self.data), self.k_from + idx) # Only show failed message if there is only 1 k to compute elif not self.optimize_k: self.Error.failed(str(ex)) self.clusterings[self.k_from + idx] = str(ex)
def test_executor(self): executor = ThreadExecutor() f = executor.submit(QThread.currentThread) self.assertIsNot(f.result(3), QThread.currentThread()) f = executor.submit(lambda: 1 / 0) with self.assertRaises(ZeroDivisionError): f.result() results = [] task = Task(function=QThread.currentThread) task.resultReady.connect(results.append, Qt.DirectConnection) f = executor.submit(task) self.assertIsNot(f.result(3), QThread.currentThread()) executor.shutdown()
def flush(self): """ Flush all pending signal emits currently enqueued. Must only ever be called from the thread this object lives in (:func:`QObject.thread()`). """ if QThread.currentThread() is not self.thread(): raise RuntimeError("`flush()` called from a wrong thread.") # NOTE: QEvent.MetaCall is the event implementing the # `Qt.QueuedConnection` method invocation. QCoreApplication.sendPostedEvents(self, QEvent.MetaCall)
def _initializemodel(self): assert self.thread() is QThread.currentThread() model, self.gds_info, self.gds = self._inittask.result() model.setParent(self) proxy = self.treeWidget.model() proxy.setFilterKeyColumn(0) proxy.setFilterRole(TextFilterRole) proxy.setFilterCaseSensitivity(False) proxy.setFilterFixedString(self.filterString) proxy.setSourceModel(model) proxy.sort(0, Qt.DescendingOrder) self.progressBarFinished() self.setBlocking(False) self.setEnabled(True) filter_items = " ".join( gds[key] for gds in self.gds for key in self.searchKeys ) tr_chars = ",.:;!?(){}[]_-+\\|/%#@$^&*<>~`" tr_table = str.maketrans(tr_chars, " " * len(tr_chars)) filter_items = filter_items.translate(tr_table) filter_items = sorted(set(filter_items.split(" "))) filter_items = [item for item in filter_items if len(item) > 3] self.completer.setTokenList(filter_items) if self.currentGds: current_id = self.currentGds["dataset_id"] gdss = [(i, qunpack(proxy.data(proxy.index(i, 1), Qt.DisplayRole))) for i in range(proxy.rowCount())] current = [i for i, data in gdss if data and data == current_id] if current: current_index = proxy.index(current[0], 0) self.treeWidget.selectionModel().select( current_index, QItemSelectionModel.Select | QItemSelectionModel.Rows ) self.treeWidget.scrollTo( current_index, QTreeView.PositionAtCenter) for i in range(8): self.treeWidget.resizeColumnToContents(i) self.treeWidget.setColumnWidth( 1, min(self.treeWidget.columnWidth(1), 300)) self.treeWidget.setColumnWidth( 2, min(self.treeWidget.columnWidth(2), 200)) self.updateInfo()
def onResultsReady(self, results): """Handle the results of centering and z-scoring """ assert(QThread.currentThread() is self.thread()) Gc, Rc, z_scores = results self.setEnabled(True) self.setBlocking(False) self.progressBarFinished() self.centered = Gc, Rc self.z_scores = z_scores self.plotMA(Gc, Rc, z_scores, self.zCutoff) self.commitIf()
def onDownloadFinished(self): # on download completed/canceled/error assert QThread.currentThread() is self.thread() for task in list(self._tasks): future = task.future() if future.done(): self.EndDownloadTask(task) self._tasks.remove(task) if not self._tasks: # Clear/reset the overall progress self.progress.setRange(0, 0) self.cancelButton.setEnabled(False)
def __task_complete(self, task): # handle a completed task assert self.thread() is QThread.currentThread() if self.__task is not task: assert task.cancelled log.debug("Reaping cancelled task: %r", "<>") return self.setBlocking(False) self.progressBarFinished(processEvents=None) self.setStatusMessage("") result = task.future assert result.done() self.__task = None try: results = result.result() # type: Results learners = results.learners # type: List[Learner] except Exception as er: log.exception("testing error (in __task_complete):", exc_info=True) self.error("\n".join(traceback.format_exception_only(type(er), er))) self.__state = State.Done return self.__state = State.Done learner_key = {slot.learner: key for key, slot in self.learners.items()} assert all(learner in learner_key for learner in learners) # Update the results for individual learners class_var = results.domain.class_var for learner, result in zip(learners, results.split_by_model()): stats = None if class_var.is_primitive(): ex = result.failed[0] if ex: stats = [Try.Fail(ex)] * len(self.scorers) result = Try.Fail(ex) else: stats = [Try(scorer_caller(scorer, result)) for scorer in self.scorers] result = Try.Success(result) key = learner_key.get(learner) self.learners[key] = \ self.learners[key]._replace(results=result, stats=stats) self._update_header() self._update_stats_model() self.commit()
def __make_task_runnable(self, task): if task.thread() is not QThread.currentThread(): raise ValueError("Can only submit Tasks from it's own " + "thread.") if task.parent() is not None: raise ValueError("Can not submit Tasks with a parent.") task.moveToThread(self._get_depot_thread()) # Use the Task's own Future object f = task.future() runnable = _TaskRunnable(f, task, (), {}) return f, runnable
def __init__(self, parent=None): QObject.__init__(self, parent) assert QThread.currentThread() is QApplication.instance().thread() netmanager = self._NETMANAGER_REF and self._NETMANAGER_REF() if netmanager is None: netmanager = QNetworkAccessManager() cache = QNetworkDiskCache() cache.setCacheDirectory( os.path.join(settings.widget_settings_dir(), __name__ + ".ImageLoader.Cache") ) netmanager.setCache(cache) ImageLoader._NETMANAGER_REF = weakref.ref(netmanager) self._netmanager = netmanager
def test_executor(self): executor = ThreadExecutor() f1 = executor.submit(pow, 100, 100) f2 = executor.submit(lambda: 1 / 0) f3 = executor.submit(QThread.currentThread) self.assertTrue(f1.result(), pow(100, 100)) with self.assertRaises(ZeroDivisionError): f2.result() self.assertIsInstance(f2.exception(), ZeroDivisionError) self.assertIsNot(f3.result(), QThread.currentThread())
def __commit_finished(self): assert QThread.currentThread() is self.thread() assert self.__task is not None assert self.data is not None self.__task = None self.setBlocking(False) self.progressBarFinished() if self.optimize_k: self.update_results() if self.optimize_k and all(isinstance(self.clusterings[i], str) for i in range(self.k_from, self.k_to + 1)): # Show the error of the last clustering self.Error.failed(self.clusterings[self.k_to]) self.send_data()
def _task_finished(self, f): """ Parameters ---------- f : Future The future instance holding the result of learner evaluation. """ assert self.thread() is QThread.currentThread() assert self._task is not None assert self._task.future is f assert f.done() self._task = None self.progressBarFinished() try: results = f.result() # type: List[Results] except Exception as ex: # Log the exception with a traceback log = logging.getLogger() log.exception(__name__, exc_info=True) self.error("Exception occurred during evaluation: {!r}" .format(ex)) # clear all results for key in self.results.keys(): self.results[key] = None else: # split the combined result into per learner/model results ... results = [list(Results.split_by_model(p_results)) for p_results in results] # type: List[List[Results]] assert all(len(r.learners) == 1 for r1 in results for r in r1) assert len(results) == len(self.curvePoints) learners = [r.learners[0] for r in results[0]] learner_id = {learner: id_ for id_, learner in self.learners.items()} # ... and update self.results for i, learner in enumerate(learners): id_ = learner_id[learner] self.results[id_] = [p_results[i] for p_results in results] # [end-snippet-9] # update the display self._update_curve_points() self._update_table()