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])
