def test_single_signal(self): w = self.widgetClass WidgetPreview(w).run(42) w.int1.assert_called_with(42) WidgetPreview(w).run(3.14) w.float1.assert_called_with(3.14) self.assertEqual(w.float2.call_count, 0) with self.assertRaises(ValueError): WidgetPreview(w).run("foo") with self.assertRaises(ValueError): WidgetPreview(w).run([])
def main_with_annotation(): from AnyQt.QtWidgets import QApplication from OWNxFile import OWNxFile app = QApplication([]) file_widget = OWNxFile() file_widget.Outputs.network.send = WidgetPreview(OWNxSave).run file_widget.open_net_file("../networks/leu_by_genesets.net")
def test_named_signals(self): w = self.widgetClass WidgetPreview(w).run(42, float2=2.7, str1="foo") w.int1.assert_called_with(42) self.assertEqual(w.float1.call_count, 0) w.float2.assert_called_with(2.7) w.str1.assert_called_with("foo") self.assertEqual(w.str2.call_count, 0)
def main(): # pragma: no cover from orangecontrib.network.network.readwrite import read_pajek from os.path import join, dirname from orangewidget.utils.widgetpreview import WidgetPreview path = join(dirname(__file__), "..", "networks") network = read_pajek(join(path, 'airtraffic.net')) data = Table(join(path, 'airtraffic_items.tab')) WidgetPreview(OWNxGroups).run(set_network=network, set_data=data)
def test_multiple_runs(self): w = self.widgetClass previewer = WidgetPreview(w) previewer.run(42, no_exit=True) w.int1(43) previewer.send_signals([(44, 1), (45, 2)]) previewer.run(46, no_exit=True) w.int1.assert_has_calls( [call(42), call(43), call(44, 1), call(45, 2), call(46)])
def test_send_signals(self): previewer = WidgetPreview(self.widgetClass) previewer.create_widget() widget = previewer.widget previewer.send_signals(42) widget.int1.assert_called_with(42) widget.int1.reset_mock() previewer.send_signals([(42, 1), (40, 2)], str2="foo", float1=[(3.14, 1), (5.1, 8)]) widget.int1.assert_has_calls([call(42, 1), call(40, 2)]) widget.str2.assert_called_with("foo") widget.float1.assert_has_calls([call(3.14, 1), call(5.1, 8)])
def test_find_handler_name(self): previewer = WidgetPreview(self.widgetClass) previewer.create_widget() find_name = previewer._find_handler_name self.assertEqual(find_name(42), "int1") self.assertEqual(find_name(3.14), "float1") self.assertRaises(ValueError, find_name, "foo") self.assertRaises(ValueError, find_name, []) self.assertRaises(ValueError, find_name, [42]) self.assertEqual(find_name([(42, 1)]), "int1") self.assertEqual(find_name([(2, 1), (3, 2)]), "int1") self.assertEqual(find_name([(42.4, 1)]), "float1") self.assertEqual(find_name([(42.4, 1), (5.1, 1)]), "float1") self.assertRaises(ValueError, find_name, [("foo", 1)]) self.assertRaises(ValueError, find_name, [])
def test_widget_is_shown_and_ran(self): w = self.widgetClass app.exec_.reset_mock() previewer = WidgetPreview(w) previewer.run() w.show.assert_called() w.show.reset_mock() app.exec_.assert_called() app.exec_.reset_mock() w.saveSettings.assert_called() w.saveSettings.reset_mock() sys.exit.assert_called() sys.exit.reset_mock() self.assertIsNone(previewer.widget) previewer.run(no_exit=True) w.show.assert_called() w.show.reset_mock() app.exec_.assert_called() app.exec_.reset_mock() w.saveSettings.assert_not_called() sys.exit.assert_not_called() self.assertIsNotNone(previewer.widget) widget = previewer.widget previewer.run(no_exec=True, no_exit=True) w.show.assert_not_called() app.exec_.assert_not_called() w.saveSettings.assert_not_called() sys.exit.assert_not_called() self.assertIs(widget, previewer.widget) previewer.run(no_exec=True) w.show.assert_not_called() app.exec_.assert_not_called() w.saveSettings.assert_called() sys.exit.assert_called() self.assertIsNone(previewer.widget)
self.view.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect) if __name__ == "__main__": from orangewidget.utils.widgetpreview import WidgetPreview from orangecontrib.text import preprocess corpus = Corpus.from_file("book-excerpts") # corpus.set_title_variable("Text") pp_list = [ preprocess.LowercaseTransformer(), preprocess.StripAccentsTransformer(), preprocess.SnowballStemmer(), ] for p in pp_list: corpus = p(corpus) w = StringVariable("Words") w.attributes["type"] = "words" words = ["house", "doctor", "boy", "way", "Rum"] words = Table( Domain([], metas=[w]), np.empty((len(words), 0)), metas=np.array(words).reshape((-1, 1)), ) WidgetPreview(OWScoreDocuments).run(set_data=corpus, set_words=words)
useful_vars[ididx] = False return useful_vars def _get_item_names(self, useful_vars): return tuple( var.name for var, useful in zip(self.data.domain.attributes, useful_vars) if useful) def _prepare_domain(self, item_names, idnames=()): idvar = self.idvar if idvar is None: idvar = ContinuousVariable(DEFAULT_NAME_FOR_ROW) elif self.idvar.is_string: idvar = DiscreteVariable(idvar.name, values=tuple(idnames)) # Renames without a warning: with only three columns, any intelligent # user will realize why renaming item_var_name, value_var_name = get_unique_names( [idvar.name], [self.item_var_name or DEFAULT_ITEM_NAME, self.value_var_name or DEFAULT_VALUE_NAME] ) item_var = DiscreteVariable(item_var_name, values=item_names) value_var = ContinuousVariable(value_var_name) return Domain([idvar, item_var], [value_var]) if __name__ == "__main__": # pragma: no cover WidgetPreview(OWMelt).run(Table("zoo")[50:])
super().closeEvent(event) def closeContext(self) -> None: """ Gather configs in contextVariables and close context. """ if not self.features: # only close in case of when features are not present if they are # feature selection is defined by the input and context should # not have impact attrs, is_logit = [], [] for config in self.configs: attrs.append(config.get_selection()) is_logit.append(config.is_logarithmic) self.attrs = attrs self.is_logit = is_logit super().closeContext() if __name__ == "__main__": from orangecontrib.timeseries import ARIMA, VAR airpassengers = Timeseries.from_file('airpassengers') msft = airpassengers.interp() model1 = ARIMA((3, 1, 1)).fit(airpassengers) model2 = VAR(4).fit(msft) ow = WidgetPreview(OWLineChart) ow.run(set_data=airpassengers, set_forecast=[(model1.predict(10, as_table=True), 0), (model2.predict(10, as_table=True), 1)])
# TODO: Allow having only a single (i.e. radial) axis try: ax2 = Spiralogram.AxesCategories[_enum_str(self.ax2, True)] except KeyError: ax2 = self.data.domain[self.ax2] self.chart.setSeries(self.data, self.agg_attr, ax1, ax2, func) def on_selection(self, indices): self.indices = self.chart.selection_indices(indices) self.commit() def commit(self): self.Outputs.time_series.send( self.data[self.indices] if self.data else None) @classmethod def migrate_context(cls, context, version): if version < 2: values = context.values context.values["agg_attr"] = values["agg_attr"][0][0] _, type = values["agg_attr"] ind, pos = values["agg_func"] if type == 101: # discrete variable is always Mode in old settings context.values["agg_func"] = ('Mode', pos) else: context.values["agg_func"] = (list(AGG_OPTIONS)[ind], pos) if __name__ == "__main__": WidgetPreview(OWSpiralogram).run(Table.from_file('airpassengers'))
def on_done(self, result: Any) -> None: self._task_state = "waiting" self.button.setText("Start") network = result[0] self._send_output_signals(result) nodes = network.number_of_nodes() edges = network.number_of_edges() summary = "{} / {}".format(nodes, edges) directed = "Directed" if network.edges[0].directed else "Undirected" details = "{} network with {} nodes and {} edges.".format( directed, nodes, edges) self.info.set_output_summary(summary, details) def on_partial_result(self, result: Any): self.cancel() def on_exception(self, ex: Exception): self.Error.unexpected_error(type(ex).__name__) self.cancel() def onDeleteWidget(self): del self._corpus_to_network super().onDeleteWidget() if __name__ == "__main__": from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWCorpusToNetwork).run(Corpus.from_file("book-excerpts"))
elif xprob is not None and yprob is not None: prob = numpy.concatenate((xprob, yprob), axis=1) else: raise ValueError() res = Orange.evaluation.Results() res.data = x.data res.domain = x.domain res.learners = x.learners res.row_indices = row_indices res.actual = actual res.predicted = predicted res.folds = None if prob is not None: res.probabilities = prob if x.models is not None and y.models is not None: res.models = [xm + ym for xm, ym in zip(x.models, y.models)] nmodels = predicted.shape[0] xfailed = getattr(x, "failed", None) or [False] * nmodels yfailed = getattr(y, "failed", None) or [False] * nmodels assert len(xfailed) == len(yfailed) res.failed = [xe or ye for xe, ye in zip(xfailed, yfailed)] return res if __name__ == "__main__": WidgetPreview(OWLearningCurveB).run()
path.addRect(rect) self.setSelectionArea(path) self.selectionChanged.emit(set(self.selectedItems()), modifiers) def updateSelectionRect(self, event): pos = event.scenePos() buttonDownPos = event.buttonDownScenePos(Qt.LeftButton) rect = QRectF(pos, buttonDownPos).normalized() rect = rect.intersected(self.sceneRect()) if not self.selectionRect: self.selectionRect = QGraphicsRectItem() self.selectionRect.setBrush(QColor(10, 10, 10, 20)) self.selectionRect.setPen(QPen(QColor(200, 200, 200, 200))) self.addItem(self.selectionRect) self.selectionRect.setRect(rect) self.selectionRectPointChanged.emit(pos) if __name__ == "__main__": from Orange.data import Table from orangecontrib.imageanalytics.image_embedder import ImageEmbedder from orangewidget.utils.widgetpreview import WidgetPreview embedding, _, _ = ImageEmbedder(model="squeezenet")( Table("https://datasets.biolab.si/core/bone-healing.xlsx"), col="Image") WidgetPreview(OWImageGrid).run(embedding)
self.n_types = '' def commit(self): selected_docs = sorted(set(self.model.word_index[row][0] for row in self.selected_rows)) concordance = self.model.get_data() if selected_docs: selected = self.corpus[selected_docs] self.Outputs.selected_documents.send(selected) else: self.Outputs.selected_documents.send(None) self.Outputs.concordances.send(concordance) def send_report(self): view = self.conc_view model = self.conc_view.model() self.report_items("Concordances", ( ("Query", model.word), ("Tokens", model.n_tokens), ("Types", model.n_types), ("Matching", self.n_matching), )) self.report_table(view) if __name__ == "__main__": # pragma: no cover from orangewidget.utils.widgetpreview import WidgetPreview corpus = Corpus.from_file("book-excerpts")[:3] WidgetPreview(OWConcordance).run(corpus)
def on_changed(self): self.commit() def commit(self): self.Warning.no_transforms_added.clear() data = self.data if not data: self.Outputs.time_series.send(None) return if not len(self.table_model): self.Warning.no_transforms_added() self.Outputs.time_series.send(None) return ts = moving_transform(data, self.table_model, self.non_overlapping and self.fixed_wlen) self.Outputs.time_series.send(ts) if __name__ == "__main__": data = Timeseries.from_file('airpassengers') attrs = [var.name for var in data.domain.attributes] if 'Adj Close' in attrs: # Make Adjusted Close a class variable attrs.remove('Adj Close') data = Timeseries.from_table( Domain(attrs, [data.domain['Adj Close']], None, source=data.domain), data) WidgetPreview(OWMovingTransform).run(data)
file_format=recent.file_format) resolved = recent.resolve(search_paths) if resolved is not None: rec.append( RecentPath.create(resolved.abspath, search_paths, **kwargs)) else: rec.append(recent) # change the list in-place for the case the widgets wraps this list self.recent_paths[:] = rec def workflowEnvChanged(self, key, value, oldvalue): """ Function called when environment changes (e.g. while saving the scheme) It make sure that all environment connected values are modified (e.g. relative file paths are changed) """ self.__initRecentItemsModel() class UserInterruptError(BaseException): """ A BaseException subclass used for cooperative task/thread cancellation """ pass if __name__ == "__main__": from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWImportImages).run()
def cancel(self): self.cancel_button.setDisabled(True) super().cancel() def _switch_to_local_embedder(self): self.Warning.switched_local_embedder() self.cb_embedder_current_id = self.embedders.index("squeezenet") def _send_output_signals(self, result: Result) -> None: self.Warning.images_skipped.clear() self.Outputs.embeddings.send(result.embedding) self.Outputs.skipped_images.send(result.skip_images) if result.num_skipped != 0: self.Warning.images_skipped(result.num_skipped) self.set_output_data_summary(result.embedding, result.skip_images) def clear_outputs(self): self._send_output_signals( Result(embedding=None, skpped_images=None, num_skipped=0)) def onDeleteWidget(self): self.cancel() super().onDeleteWidget() if __name__ == "__main__": from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWImageEmbedding).run( Table("https://datasets.biolab.si/core/bone-healing.xlsx"))
callbacks=[self._progress_updater]) self._worker_thread = EmbedderThread( lambda: self.embedder(self.network)) self._worker_thread.finished.connect(self.on_finished) self.progressBarInit() self.progressBarSet(1e-5) self._worker_thread.start() def on_finished(self): output = self._worker_thread.result self._worker_thread = None self._progress_updater = None self.progressBarFinished() self.Outputs.items.send(output) def onDeleteWidget(self): if self._worker_thread is not None: # prevent the callback from trying to access deleted widget object self._progress_updater.widget = None self._worker_thread.finished.disconnect() self._worker_thread.quit() super().onDeleteWidget() if __name__ == "__main__": from os.path import join, dirname davis = join(dirname(__file__), "..", "networks", "davis.net") network = readwrite.read_pajek(davis) WidgetPreview(OWNxEmbedding).run(network)
self.cancel_button.setDisabled(True) if isinstance(ex, EmbeddingConnectionError): self.Error.no_connection() else: self.Error.unexpected_error(type(ex).__name__) self.cancel() self.clear_outputs() def cancel(self): self.cancel_button.setDisabled(True) super().cancel() def _send_output_signals(self, embeddings, skipped): self.Outputs.new_corpus.send(embeddings) self.Outputs.skipped.send(skipped) unsuccessful = len(skipped) if skipped else 0 if unsuccessful > 0: self.Warning.unsuccessful_embeddings() def clear_outputs(self): self._send_output_signals(None, None) def onDeleteWidget(self): self.cancel() super().onDeleteWidget() if __name__ == '__main__': from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWDocumentEmbedding).run(Corpus.from_file('book-excerpts'))
self.time_var = time_var_model[0] if len(time_var_model) else None self.event_var = event_var_model[0] if len(event_var_model) else None self.openContext(domain) self.commit.now() def as_survival_data(self, data: Table) -> Optional[Table]: if not self.time_var or not self.event_var or not data: return class_vars = [self.time_var, self.event_var] time_var = self.time_var event_var = self.event_var time_var.attributes[TIME_TO_EVENT_VAR] = TIME_VAR event_var.attributes[TIME_TO_EVENT_VAR] = EVENT_VAR metas = [meta for meta in data.domain.metas if meta not in class_vars] domain = Domain(data.domain.attributes, metas=metas, class_vars=class_vars) data = data.transform(domain) return data @gui.deferred def commit(self) -> None: self.Outputs.data.send(self.as_survival_data(self._data)) if __name__ == "__main__": from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWAsSurvivalData).run(Table('http://datasets.biolab.si/core/melanoma.tab'))
def commit(self): if not self.graph.selection: self.Outputs.selected_data.send(None) return time, _ = self.data.get_column_view(self.time_var) if self.group_var is None: time_interval = self.graph.selection[0].x start, end = time_interval[0], time_interval[-1] selection = np.argwhere((time >= start) & (time <= end)).reshape(-1).astype(int) else: selection = [] group, _ = self.data.get_column_view(self.group_var) for group_id, time_interval in self.graph.selection.items(): start, end = time_interval.x[0], time_interval.x[-1] selection += (np.argwhere((time >= start) & (time <= end) & ( group == group_id)).reshape(-1).astype(int).tolist()) selection = sorted(selection) self.Outputs.selected_data.send(self.data[selection, :]) def sizeHint(self): return QSize(1280, 620) if __name__ == "__main__": from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWKaplanMeier).run(Table('iris'))
def sel_changed(self): self.query_controls = False self.radiobox.setDisabled(not self.query_controls) self.out_box.setDisabled(not self.query_controls) print("sds") print(self.number) self.ow_cache = 0 if self.lb_objects.count() == 0: self.send("Object", None) else: self._executor.submit(self.get_deplyoment_info()) def get_deplyoment_info(self): jsn_data = self.lb_objects.currentItem().data(Qt.UserRole) url = self.BASE_URL + 'deployment/' + str(jsn_data["_id"]) resp = requests.get(url, headers={'content-type': 'application/json', 'accept': 'application/json'}) if resp.status_code == 200: self.query_controls = True self.radiobox.setDisabled(not self.query_controls) self.out_box.setDisabled(not self.query_controls) # print(resp.json().len) if __name__ == "__main__": # pragma: no cover WidgetPreview(UNSdata).run()
domain = Domain(attrs, metas=metas) table = Table(domain, df_exp.to_numpy(), metas=x_metas) state.set_progress_value(next(progress_steps_download)) state.set_status('Matching genes ...') progress_steps_gm = iter( np.linspace(50, 99, len(coll_table.gene_ids))) def gm_callback(): state.set_progress_value(next(progress_steps_gm)) tax_id = species_name_to_taxid(species) gm = GeneMatcher(tax_id, progress_callback=gm_callback) table = gm.match_table_attributes(table, rename=True) table.attributes[TableAnnotation.tax_id] = tax_id table.attributes[TableAnnotation.gene_as_attr_name] = True table.attributes[TableAnnotation.gene_id_attribute] = 'Entrez ID' self.data_table = table state.set_status('Normalizing ...') table = self.normalize(table) state.set_progress_value(100) return table if __name__ == "__main__": from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWGenialisExpressions).run()
def main_without_annotation(): net = readwrite.read_pajek("../networks/leu_by_genesets.net") WidgetPreview(OWNxSave).run(net)
# Helper methods def get_selected_attributes(self): """Get select attributes in the table""" selection_model = self.agg_table_view.selectionModel() sel_rows = selection_model.selectedRows() vars_ = self.data.domain.variables + self.data.domain.metas return [vars_[index.row()] for index in sel_rows] def _set_gb_selection(self) -> None: """Set selection in groupby list according to self.gb_attrs""" sm = self.gb_attrs_view.selectionModel() values = self.gb_attrs_model[:] with disconnected(sm.selectionChanged, self.__gb_changed): for val in self.gb_attrs: index = values.index(val) model_index = self.gb_attrs_model.index(index, 0) sm.select(model_index, QItemSelectionModel.Select) @staticmethod def __aggregation_compatible(agg, attr): """Check a compatibility of aggregation with the variable""" return type(attr) in AGGREGATIONS[agg].types if __name__ == "__main__": # pylint: disable=ungrouped-imports from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWGroupBy).run(Table("iris"))
("Matches", self.n_matches) )) def showEvent(self, event): super().showEvent(event) self.update_splitter() def update_splitter(self): """ Update splitter that document list on the left never take more than 1/3 of the space. It is only set on showEvent. If user later changes sizes it stays as it is. """ w1, w2 = self.splitter.sizes() ws = w1 + w2 if w2 < 2/3 * ws: self.splitter.setSizes([ws * 1/3, ws * 2/3]) if __name__ == '__main__': from orangecontrib.text.preprocess import BASE_TOKENIZER from orangecontrib.text.tag.pos import AveragedPerceptronTagger from orangewidget.utils.widgetpreview import WidgetPreview corpus = Corpus.from_file('book-excerpts') corpus = corpus[:3] tagger = AveragedPerceptronTagger() tagged_corpus = tagger(BASE_TOKENIZER(corpus)) tagged_corpus.ngram_range = (1, 2) WidgetPreview(OWCorpusViewer).run(tagged_corpus)
if (result_corpus is None # probably because of rate error at beginning # or fewer tweets than expected or self.mode == self.CONTENT and len(result_corpus) < self.max_tweets or self.mode == self.AUTHOR # for authors, we expect self.max_tweets for each author and len(result_corpus) < self.max_tweets * len(self.word_list)): self.Info.nut_enough_tweets() self.Outputs.corpus.send(result_corpus) def on_exception(self, ex): self.search_button.setText("Search") if isinstance(ex, NoAuthorError): self.Error.wrong_author(str(ex)) else: self.Error.api_error(str(ex)) def on_partial_result(self, _): pass @gui_require("api", "key_missing") def send_report(self): for task in self.api.search_history: self.report_items(task) if __name__ == "__main__": WidgetPreview(OWTwitter).run()
mime_data = src_model.mimeData(selected_items) # remove nodes from the source view src_model.remove_node_list(selected_items) dst_model.dropMimeData(mime_data, Qt.MoveAction, -1, -1) @staticmethod def _selected_rows(view: TreeView) -> List[QModelIndex]: """ Return the selected rows in the view. """ rows = view.selectionModel().selectedRows() return list(map(view.model().mapToSource, rows)) @classmethod def migrate_settings(cls, settings, version=0): def migrate_to_version_2(): settings["selected_source"] = settings.pop("selected_db_source", "") settings["selected_organism"] = settings.pop("selected_group", "") if "context_settings" in settings: for co in settings["context_settings"]: co.values["selected_genes"] = [g[0] + g[1] for g in co.values["selected_genes"]] if version < 2: migrate_to_version_2() if __name__ == "__main__": from orangewidget.utils.widgetpreview import WidgetPreview WidgetPreview(OWMarkerGenes).run()