def test_data_chunks(self): self.assertEqual( list(WidgetPreview._data_chunks(42)), [(42, )]) self.assertEqual( list(WidgetPreview._data_chunks((42, 1))), [(42, 1)]) self.assertEqual( list(WidgetPreview._data_chunks([(42, 1), (65, 3)])), [(42, 1), (65, 3)])
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_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_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)
def test_create_widget(self): previewer = WidgetPreview(self.widgetClass) self.assertIsNone(previewer.widget) previewer.create_widget() self.assertIsInstance(previewer.widget, self.widgetClass)
return [self(inst) for inst in instance] else: args = [str(instance[var]) if instance.domain[var].is_string else instance[var] for _, var in self.args] y = self.func(*args) if self.cast: y = self.cast(y) return y def __reduce__(self): return type(self), (self.expression, self.args, self.extra_env, self.cast) def __repr__(self): return "{0.__name__}{1!r}".format(*self.__reduce__()) def unique(seq): seen = set() unique_el = [] for el in seq: if el not in seen: unique_el.append(el) seen.add(el) return unique_el if __name__ == "__main__": # pragma: no cover WidgetPreview(OWFeatureConstructor).run(Orange.data.Table("iris"))
k_neighbors=self.nearest_neighbours, n_jobs=None) X_res, y_res = sm.fit_resample(self.X_input, self.y_input) numberOfOutputInstances = len(y_res) self.infoc.setText( "%d instances in output data set" % numberOfOutputInstances) oversampling_percentage = ( (numberOfOutputInstances - self.numberOfInputInstances) / self.numberOfInputInstances) * 100 self.infod.setText("{:.2f}% oversampling".format(oversampling_percentage)) if oversampling_percentage == 0: self.infoe.setText("Attention! Input dataset is allready balanced.") else: self.infoe.setText('Input dataset is imbalanced.') self.balancedDataset = Table(self.dataset.domain, X_res, y_res) def commit(self): self.Outputs.balancedDataset.send(self.balancedDataset) return def checkCommit(self): if self.commitOnChange: self.commit() if __name__ == "__main__": WidgetPreview(SMOTE_w).run(Table("iris-imbalanced"))
Scale.NormalizeBySpan_ZeroBased } params["method"] = \ migratable.get((center, scale), Scale.NormalizeBySD) def onDeleteWidget(self): self.data = None self.set_model(None) super().onDeleteWidget() @Slot() def __update_size_constraint(self): # Update minimum width constraint on the scroll area containing # the 'instantiated' preprocessor list (to avoid the horizontal # scroll bar). sh = self.flow_view.minimumSizeHint() scroll_width = self.scroll_area.verticalScrollBar().width() self.scroll_area.setMinimumWidth( min(max(sh.width() + scroll_width + 2, self.controlArea.width()), 520)) def send_report(self): pp = [(self.controler.model().index(i, 0).data(Qt.DisplayRole), w) for i, w in enumerate(self.controler.view.widgets())] if pp: self.report_items("Settings", pp) if __name__ == "__main__": # pragma: no cover WidgetPreview(OWPreprocess).run(Orange.data.Table("brown-selected"))
(N, ) = self.__data.shape if not N: return spacing = self.__spacing rect = self.contentsRect() w = rect.width() if rect.height() - (spacing * (N - 1)) <= 0: spacing = 0 h = (rect.height() - (spacing * (N - 1))) / N xmin, xmax = self.__range span = xmax - xmin if span < 1e-9: span = 1 scalef = w * 1 / span base = 0 base = (base - xmin) * scalef datascaled = (self.__data - xmin) * scalef for i, (v, item) in enumerate(zip(datascaled, self.__items)): item.setRect( QRectF(base, rect.top() + i * (h + spacing), v - base, h).normalized()) if __name__ == "__main__": # pragma: no cover WidgetPreview(OWSilhouettePlot).run(Orange.data.Table("iris"))
feature_name=self.feature_name or self.DEFAULT_PREFIX) if variable: names = self.data.get_column_view(variable)[0] if len(names) != len(set(names)): self.Warning.duplicate_names(variable) if self.data.domain.has_discrete_attributes(): self.Warning.discrete_attrs() self.info.set_output_summary( len(transposed), format_summary_details(transposed)) except ValueError as e: self.Error.value_error(e) else: self.info.set_output_summary(self.info.NoOutput) self.Outputs.data.send(transposed) def send_report(self): if self.feature_type == self.GENERIC: names = self.feature_name or self.DEFAULT_PREFIX else: names = "from variable" if self.feature_names_column: names += " '{}'".format(self.feature_names_column.name) self.report_items("", [("Feature names", names)]) if self.data: self.report_data("Data", self.data) if __name__ == "__main__": # pragma: no cover WidgetPreview(OWTranspose).run(Table("iris"))
self.clear() self.data = None self.shutdown() super().onDeleteWidget() @classmethod def migrate_settings(cls, settings, version): if version < 3: if "selection_indices" in settings: settings["selection"] = settings["selection_indices"] if version < 4: settings.pop("max_iter", None) @classmethod def migrate_context(cls, context, version): if version < 3: values = context.values values["attr_color"] = values["graph"]["attr_color"] values["attr_size"] = values["graph"]["attr_size"] values["attr_shape"] = values["graph"]["attr_shape"] values["attr_label"] = values["graph"]["attr_label"] if __name__ == "__main__": import sys data = Table(sys.argv[1] if len(sys.argv) > 1 else "iris") WidgetPreview(OWtSNE).run( set_data=data, set_subset_data=data[np.random.choice(len(data), 10)], )
else: weights = numpy.asarray(weights) weights = weights[sort_ind] n = numpy.sum(weights) k = numpy.cumsum(weights, axis) # plotting positions for the known n knots pk = (k - alphap * weights) / (n + 1 - alphap * weights - betap * weights) # m = alphap + prob * (1 - alphap - betap) return numpy.interp(prob, pk, a, left=a[0], right=a[-1]) def shape_reduce_keep_dims(shape, axis): if shape is None: return () shape = list(shape) if isinstance(axis, collections.Sequence): for ax in axis: shape[ax] = 1 else: shape[axis] = 1 return tuple(shape) if __name__ == "__main__": # pragma: no cover WidgetPreview(OWDistributions).run(Orange.data.Table("heart_disease.tab"))
# self.output_list = pipline_in[0] # self.ancestors_path = pipline_in[1] # self.primitive_info.ancestors['inputs'] = self.ancestors_path # self.Outputs.pipline_out.send([self.output_list + [self.primitive_info], self.python_path]) # else: # self.primitive_info.ancestors = {} # self.Outputs.pipline_out.send(None) # def settings_changed(self): # self.commit() # def commit(self): # self.hyperparameter['use_columns'] = self.use_columns # self.hyperparameter['exclude_columns'] = self.exclude_columns # self.hyperparameter['return_result'] = self.return_result # self.hyperparameter['add_index_columns'] = self.add_index_columns # self.hyperparameter['parse_categorical_target_columns'] = self.parse_categorical_target_columns # self.hyperparameter['replace_index_columns'] = self.replace_index_columns # self.hyperparameter['fuzzy_time_parsing'] = self.fuzzy_time_parsing # self.primitive_info.hyperparameter = self.hyperparameter # if self.Inputs.pipline_in is not None: # self.Outputs.pipline_out.send([self.output_list + [self.primitive_info], self.python_path]) if __name__ == "__main__": WidgetPreview(OWColumnParser).run(Orange.data.Table("iris"))
box = gui.widgetBox(self.controlArea, "Info") self.infoa = gui.widgetLabel( box, 'No data on input yet, waiting to get something.') self.infob = gui.widgetLabel(box, '') # [end-snippet-1] # [start-snippet-2] @Inputs.data def set_data(self, dataset): if dataset is not None: self.infoa.setText('%d instances in input dataset' % len(dataset)) indices = numpy.random.permutation(len(dataset)) indices = indices[:int(numpy.ceil(len(dataset) * 0.1))] sample = dataset[indices] self.infob.setText('%d sampled instances' % len(sample)) self.Outputs.sample.send(sample) else: self.infoa.setText( 'No data on input yet, waiting to get something.') self.infob.setText('') self.Outputs.sample.send("Sampled Data") # [end-snippet-2] # [start-snippet-3] if __name__ == "__main__": WidgetPreview(OWDataSamplerA).run(Orange.data.Table("iris")) # [end-snippet-3]
idom = iris.domain dom = Domain( idom.attributes, DiscreteVariable(idom.class_var.name, idom.class_var.values[1::-1])) iris2 = iris[:100].transform(dom) def pred_error(data, *args, **kwargs): raise ValueError pred_error.domain = iris.domain pred_error.name = "To err is human" if iris.domain.has_discrete_class: predictors_ = [ Orange.classification.SVMLearner(probability=True)(iris2), Orange.classification.LogisticRegressionLearner()(iris), pred_error ] elif iris.domain.has_continuous_class: predictors_ = [ Orange.regression.RidgeRegressionLearner(alpha=1.0)(iris), Orange.regression.LinearRegressionLearner()(iris), pred_error ] else: predictors_ = [pred_error] WidgetPreview(OWPredictions).run(set_data=iris2, set_predictor=[ (pred, i) for i, pred in enumerate(predictors_) ])
if isinstance(headerState, bytes): hview = QHeaderView(Qt.Horizontal) hview.restoreState(headerState) column, order = hview.sortIndicatorSection() - 1, hview.sortIndicatorOrder() settings["sorting"] = (column, order) @classmethod def migrate_context(cls, context, version): if version is None or version < 2: # Old selection was saved as sorted indices. New selection is original indices. # Since we can't devise the latter without first computing the ranks, # just reset the selection to avoid confusion. context.values['selected_rows'] = [] if __name__ == "__main__": # pragma: no cover from Orange.classification import RandomForestLearner previewer = WidgetPreview(OWRank) previewer.run(Table("heart_disease.tab"), no_exit=True) previewer.send_signals( set_learner=(RandomForestLearner(), (3, 'Learner', None))) previewer.run() # pylint: disable=pointless-string-statement """ WidgetPreview(OWRank).run( set_learner=(RandomForestLearner(), (3, 'Learner', None)), set_data=Table("heart_disease.tab")) """
return "{} vs {}".format(self.attr_x.name, self.attr_y.name) return None @classmethod def migrate_settings(cls, settings, version): if version < 2 and "selection" in settings and settings["selection"]: settings["selection_group"] = [(a, 1) for a in settings["selection"]] if version < 3: if "auto_send_selection" in settings: settings["auto_commit"] = settings["auto_send_selection"] if "selection_group" in settings: settings["selection"] = settings["selection_group"] @classmethod def migrate_context(cls, context, version): values = context.values if version < 3: values["attr_color"] = values["graph"]["attr_color"] values["attr_size"] = values["graph"]["attr_size"] values["attr_shape"] = values["graph"]["attr_shape"] values["attr_label"] = values["graph"]["attr_label"] if version < 4: if values["attr_x"][1] % 100 == 1 or values["attr_y"][1] % 100 == 1: raise IncompatibleContext() if __name__ == "__main__": # pragma: no cover data = Table("iris") WidgetPreview(OWScatterPlot).run(set_data=data, set_subset_data=data[:30])