def apply(self):
"""Output the transformed data."""
if not self.attribute:
self.send("Data", None)
return
domain = self.data.domain
rules = self.active_rules
# Transposition + stripping
valid_rules = [label or pattern or n_matches
for (label, pattern), n_matches in
zip(rules, self.match_counts)]
patterns = [pattern
for (_, pattern), valid in zip(rules, valid_rules)
if valid]
names = [name for name, valid in zip(self.class_labels(), valid_rules)
if valid]
transformer = self.TRANSFORMERS[type(self.attribute)]
compute_value = transformer(
self.attribute, patterns, self.case_sensitive, self.match_beginning)
new_class = DiscreteVariable(
self.class_name, names, compute_value=compute_value)
new_domain = Domain(
domain.attributes, new_class, domain.metas + domain.class_vars)
new_data = Table(new_domain, self.data)
self.send("Data", new_data)
def test_report_widgets_unsupervised_dist(self):
rep = OWReport.get_instance()
data = Table("zoo")
dist = Euclidean(data)
widgets = self.dist_widgets
self.assertEqual(len(widgets), 2)
self._create_report(widgets, rep, dist)
def test_report_widgets_visualize(self):
app = QApplication(sys.argv)
rep = OWReport.get_instance()
data = Table("zoo")
widgets = self.visu_widgets
self.assertEqual(len(widgets), 10)
self._create_report(widgets, rep, data, app)
def setUp(self) -> None:
test_data_path = os.path.join(os.path.dirname(__file__), 'datasets')
self.widget = self.create_widget(OWAsSurvivalData)
self.send_signal(self.widget.Inputs.data,
Table(f'{test_data_path}/toy_example.tab'))
self.assertEqual(self.widget.controls.time_var.count(), 1)
self.assertEqual(self.widget.controls.event_var.count(), 2)
def test_main():
app = QtGui.QApplication([])
data = Table("iris")
w = OWDataSampler()
w.set_data(data)
w.show()
return app.exec_()
def test_incorrect_input_data(self):
self.send_signal(self.widget.Inputs.data,
Table(f'{self.test_data_path}/toy_example.tab'))
self.assertTrue(self.widget.Error.missing_survival_data.is_shown())
self.assertIsNone(self.widget.data)
self.assertIsNone(self.widget.time_var)
self.assertIsNone(self.widget.event_var)
def setUp(self) -> None:
self.test_data_path = os.path.join(os.path.dirname(__file__),
'datasets')
# create widgets
self.as_survival = self.create_widget(OWAsSurvivalData)
self.widget = self.create_widget(OWKaplanMeier)
# handle survival data
self.send_signal(self.as_survival.Inputs.data,
Table(f'{self.test_data_path}/toy_example.tab'))
simulate.combobox_activate_item(
self.as_survival.controls.time_var,
self.as_survival._data.columns.Time.name)
simulate.combobox_activate_item(
self.as_survival.controls.event_var,
self.as_survival._data.columns.Event.name)
self.send_signal(self.widget.Inputs.data,
self.get_output(self.as_survival.Outputs.data))
# check survival data
time_var, event_var = get_survival_endpoints(self.widget.data.domain)
self.assertEqual(time_var.name, 'Time')
self.assertEqual(event_var.name, 'Event')
self.assertIn(time_var, self.widget.data.domain.class_vars)
self.assertIn(event_var, self.widget.data.domain.class_vars)
# check if missing data detected
self.assertTrue(self.widget.Warning.missing_values_detected.is_shown())
self.widget.auto_commit = True
# If we don't do this function ViewBox.mapSceneToView fails with num py.linalg.LinAlgError: Singular matrix
vb = self.widget.graph.getViewBox()
vb.resize(200, 200)
def __init__(self, parent=None, signalManager=None, settings=None):
super().__init__(parent, signalManager, settings)
self.data = None
self.undoStack = QtGui.QUndoStack(self)
self.plot = PaintDataPlot(self.mainArea, "Painted Plot", widget=self)
self.classValuesModel = ColoredListModel(
["Class-1", "Class-2"],
self,
self.plot,
flags=QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
| QtCore.Qt.ItemIsEditable)
self.classValuesModel.dataChanged.connect(self.classNameChange)
self.data = Table(
Domain([
ContinuousVariable(self.attr1),
ContinuousVariable(self.attr2)
], DiscreteVariable("Class", values=self.classValuesModel)))
self.toolsStackCache = {}
self.initUI()
self.initPlot()
self.updatePlot()
def sendData(self):
data = self.data
values = set([str(ex.get_class()) for ex in data])
if len(values) == 1:
# Remove the useless class variable.
domain = Domain(data.domain.attributes)
data = Table(domain, data)
self.send("Data", data)
def test_main():
a = QtGui.QApplication(sys.argv)
ow = OWDataTable()
iris = Table("iris")
brown = Table("brown-selected")
housing = Table("housing")
ow.show()
ow.raise_()
ow.set_dataset(iris, iris.name)
ow.set_dataset(brown, brown.name)
ow.set_dataset(housing, housing.name)
rval = a.exec()
# ow.saveSettings()
return rval
def test_report_widgets_visualize(self):
_warnings = warnings.catch_warnings()
_warnings.__enter__()
warnings.simplefilter("ignore", OrangeDeprecationWarning)
rep = OWReport.get_instance()
data = Table("zoo")
widgets = self.visu_widgets
self._create_report(widgets, rep, data)
_warnings.__exit__()
def main(): # pragma: no cover
"""Simple test for manual inspection of the widget"""
import sys
from AnyQt.QtWidgets import QApplication
a = QApplication(sys.argv)
table = Table("zoo")
ow = OWCreateClass()
ow.show()
ow.set_data(table)
a.exec()
ow.saveSettings()
def test_report_widgets_model(self):
rep = OWReport.get_instance()
data = Table("titanic")
widgets = self.model_widgets
w = self.create_widget(OWTreeGraph)
clf = TreeLearner(max_depth=3)(data)
clf.instances = data
w.ctree(clf)
w.create_report_html()
rep.make_report(w)
self._create_report(widgets, rep, data)
def test_report_widgets_regression(self):
rep = OWReport.get_instance()
data = Table("housing")
widgets = self.regr_widgets
w = self.create_widget(OWTreeGraph)
mod = RegressionTreeLearner(max_depth=3)(data)
mod.instances = data
w.ctree(mod)
w.create_report_html()
rep.make_report(w)
self._create_report(widgets, rep, data)
def test_report_widgets_regression(self):
rep = OWReport.get_instance()
data = Table("housing")
widgets = self.regr_widgets
w = OWRegressionTreeGraph()
mod = TreeRegressionLearner(max_depth=3)(data)
mod.instances = data
w.ctree(mod)
w.create_report_html()
rep.make_report(w)
self.assertEqual(len(widgets) + 1, 5)
self._create_report(widgets, rep, data)
def test_report_widgets_classify(self):
rep = OWReport.get_instance()
data = Table("zoo")
widgets = self.clas_widgets
w = OWClassificationTreeGraph()
clf = TreeLearner(max_depth=3)(data)
clf.instances = data
w.ctree(clf)
w.create_report_html()
rep.make_report(w)
self.assertEqual(len(widgets) + 1, 8)
self._create_report(widgets, rep, data)
def _create_table(words, scores: Mapping[str, np.array]) -> Table:
"""
Create an Orange table from the word scores
:param words: list of words
:param scores: mapping of {label: score_array}. Use ordereddict to preserve column order
:return: a Table object
"""
values = list(scores.values())
order = (-values[0]).argsort()
data = np.column_stack(values)[order]
words = np.array(words).reshape(len(words), 1)[order]
domain = Domain([ContinuousVariable(label) for label in scores],
metas=[StringVariable("term")])
return Table(domain, data, metas=words)
def test_report_widgets_evaluate(self):
rep = OWReport.get_instance()
data = Table("zoo")
widgets = self.eval_widgets
cv = CrossValidation(k=3, store_data=True)
results = cv(data, [LogisticRegressionLearner()])
results.learner_names = ["LR l2"]
w = self.create_widget(OWTestAndScore)
w.insert_learner(0, LogisticRegressionLearner())
w.set_train_data(data)
w.set_test_data(data)
w.create_report_html()
rep.make_report(w)
self._create_report(widgets, rep, results)
def test_disable_saving_empty(self):
"""Test if save and print buttons are disabled on empty report"""
rep = OWReport.get_instance()
self.assertFalse(rep.save_button.isEnabled())
self.assertFalse(rep.print_button.isEnabled())
table = OWDataTable()
table.set_dataset(Table("iris"))
table.create_report_html()
rep.make_report(table)
self.assertTrue(rep.save_button.isEnabled())
self.assertTrue(rep.print_button.isEnabled())
rep.clear()
self.assertFalse(rep.save_button.isEnabled())
self.assertFalse(rep.print_button.isEnabled())
def test_set_data(self):
variables = self.data.domain.variables
class_variables = self.data.domain.class_vars
continuous_variables = [var for var in variables if var.is_continuous]
self.widget.set_data(self.data)
self.assertEqual(self.data, self.widget.data)
self.assertEqual(continuous_variables, self.widget.x_var_model._list)
self.assertEqual(continuous_variables, self.widget.y_var_model._list)
self.assertEqual(self.widget.x_var_index, 0)
self.assertEqual(
self.widget.y_var_index,
len(continuous_variables) -
1 if len(class_variables) == 0 else len(continuous_variables) -
len(class_variables))
# check for none data
self.widget.set_data(None)
self.assertEqual(self.widget.data, None)
# data set with continuous class to check if nclass > 0
variables = self.data_housing.domain.variables
class_variables = self.data_housing.domain.class_vars
continuous_variables = [var for var in variables if var.is_continuous]
self.widget.set_data(self.data_housing)
self.assertEqual(self.data_housing, self.widget.data)
self.assertEqual(continuous_variables, self.widget.x_var_model._list)
self.assertEqual(continuous_variables, self.widget.y_var_model._list)
self.assertEqual(self.widget.x_var_index, 0)
self.assertEqual(
self.widget.y_var_index,
len(continuous_variables) -
1 if len(class_variables) == 0 else len(continuous_variables) -
len(class_variables))
# check with data with all none
data = Table(
Domain([ContinuousVariable('a'),
ContinuousVariable('b')]), [[None, None], [None, None]])
self.widget.set_data(data)
self.widget.apply()
self.assertIsNone(self.widget.plot_item)
self.assertIsNone(self.widget.scatterplot_item)
def main():
from Orange.modelling import TreeLearner
from AnyQt.QtWidgets import QApplication
import sys
app = QApplication(sys.argv)
ow = OWPythagorasTree()
data = Table(sys.argv[1] if len(sys.argv) > 1 else 'iris')
model = TreeLearner(max_depth=1000)(data)
model.instances = data
ow.set_tree(model)
ow.show()
ow.raise_()
ow.handleNewSignals()
app.exec_()
def test_report_widgets_evaluate(self):
rep = OWReport.get_instance()
data = Table("zoo")
widgets = self.eval_widgets
results = CrossValidation(data, [LogisticRegressionLearner()],
store_data=True)
results.learner_names = ["LR l2"]
w = self.create_widget(OWTestLearners)
set_learner = getattr(w, w.Inputs.learner.handler)
set_train = getattr(w, w.Inputs.train_data.handler)
set_test = getattr(w, w.Inputs.test_data.handler)
set_learner(LogisticRegressionLearner(), 0)
set_train(data)
set_test(data)
w.create_report_html()
rep.make_report(w)
self._create_report(widgets, rep, results)
def upload(filename):
annotations = {'tabular': {}, 'other': {}}
with urllib.request.urlopen(os.path.join(URL_REMOTE,
filename + '.info')) as url:
data = json.loads(url.read().decode())
annotations['tabular']['title'] = data['title']
annotations['tabular']['cells'] = data['instances']
annotations['tabular']['genes'] = data['num_of_genes']
annotations['tabular']['tax_id'] = data['taxid']
annotations['tabular'][
'target'] = data['target'] if data['target'] else ''
annotations['tabular']['tags'] = ', '.join(data['tags'])
annotations['other']['description'] = data['description']
annotations['other']['references'] = ' | '.join(data['references'])
annotations['other']['source'] = data['source']
annotations['other']['collection'] = data['collection']
annotations['other']['year'] = data['year']
annotations['other']['instances'] = data['instances']
annotations['other']['variables'] = data['variables']
data = Table(os.path.join(URL_REMOTE, filename))
if '.tab.gz' in filename:
filename = filename.replace('.tab.gz', '.pickle')
data.save(filename)
dataset = res.run('data-table-upload', input={'src': filename})
# dataset = res.data.get(id=1)
annotations['tabular']['file_name'] = filename
annotations['tabular']['file_size'] = os.stat(filename).st_size
# descriptor schema slug
dataset.descriptor_schema = 'data_info'
dataset.descriptor = annotations
dataset.save()
# cleanup
os.remove(filename)
def test_report_widgets_evaluate(self):
app = QApplication(sys.argv)
rep = OWReport.get_instance()
data = Table("zoo")
widgets = self.eval_widgets
results = CrossValidation(data, [LogisticRegressionLearner()],
store_data=True)
results.learner_names = ["LR l2"]
w = OWTestLearners()
set_learner = getattr(w, w.inputs[0].handler)
set_train = getattr(w, w.inputs[1].handler)
set_test = getattr(w, w.inputs[2].handler)
set_learner(LogisticRegressionLearner(), 0)
set_train(data)
set_test(data)
w.create_report_html()
rep.make_report(w)
self.assertEqual(len(widgets) + 1, 4)
self._create_report(widgets, rep, results, app)
def redo(self):
self.label = self.classValuesModel.pop(self.index)
examples = [
ex for ex in self.data if str(ex.get_class()) != self.label
]
newdomain = Domain([
ContinuousVariable(self.widget.attr1),
ContinuousVariable(self.widget.attr2)
], DiscreteVariable("Class", values=self.classValuesModel))
newdata = Table(newdomain)
for ex in examples:
if str(ex.get_class()) != self.label and \
str(ex.get_class()) in self.classValuesModel:
newdata.append(
Instance(newdomain,
[float(ex[a]) for a in ex.domain.attributes] +
[str(ex.get_class())]))
self.widget.data = newdata
self.widget.updatePlot()
self.widget.updateCursor()
def main():
from AnyQt.QtWidgets import QApplication
import sys
app = QApplication(sys.argv)
ow = OWPythagorasTree()
data = Table(sys.argv[1] if len(sys.argv) > 1 else 'iris')
if data.domain.has_discrete_class:
from Orange.classification.tree import SklTreeLearner as TreeLearner
else:
from Orange.regression.tree import SklTreeRegressionLearner as TreeLearner
model = TreeLearner(max_depth=1000)(data)
model.instances = data
ow.set_tree(model)
ow.show()
ow.raise_()
ow.handleNewSignals()
app.exec_()
def redo(self):
self.classValuesModel.append(self.newClassLabel)
newdomain = Domain([
ContinuousVariable(self.widget.attr1),
ContinuousVariable(self.widget.attr2)
], DiscreteVariable("Class", values=self.classValuesModel))
newdata = Table(newdomain)
instances = [
Instance(newdomain,
[float(ex[a])
for a in ex.domain.attributes] + [str(ex.get_class())])
for ex in self.data
]
newdata.extend(instances)
self.widget.data = newdata
self.widget.removeClassLabel.setEnabled(len(self.classValuesModel) > 1)
newindex = self.classValuesModel.index(len(self.classValuesModel) - 1)
self.widget.classValuesView.selectionModel().select(
newindex, QtGui.QItemSelectionModel.ClearAndSelect)
self.widget.updatePlot()
self.widget.updateCursor()
def redo(self):
newdomain = Domain([
ContinuousVariable(self.widget.attr1),
ContinuousVariable(self.widget.attr2)
], DiscreteVariable("Class", values=self.classValuesModel))
newdata = Table(newdomain)
for ex in self.data:
print(ex.get_class())
if str(ex.get_class()) not in self.classValuesModel:
self.oldLabelName = str(ex.get_class())
instance = Instance(
newdomain,
[float(ex[a])
for a in ex.domain.attributes] + [self.changedLabel])
newdata.append(instance)
else:
newdata.append(
Instance(newdomain,
[float(ex[a]) for a in ex.domain.attributes] +
[str(ex.get_class())]))
self.widget.data = newdata
self.widget.updatePlot()
def initial_start_dir(self):
if self.filename and os.path.exists(os.path.split(self.filename)[0]):
return self.filename
else:
data_name = getattr(self.data, 'name', '')
if data_name:
data_name += self.writer.EXTENSIONS[0]
return os.path.join(self.last_dir or _userhome, data_name)
def valid_filters(self):
if self.data is None or not self.data.is_sparse():
return self.get_filters()
else:
return {
filt: writer
for filt, writer in self.get_filters().items()
if writer.SUPPORT_SPARSE_DATA
}
def default_valid_filter(self):
valid = self.valid_filters()
if self.data is None or not self.data.is_sparse() \
or (self.filter in valid
and valid[self.filter].SUPPORT_SPARSE_DATA):
return self.filter
return next(iter(valid))
if __name__ == "__main__": # pragma: no cover
WidgetPreview(OWSave).run(Table("iris"))
def is_sortable(table):
if isinstance(table, SqlTable):
return False
elif isinstance(table, Orange.data.Table):
return True
else:
return False
def test_model():
app = QApplication([])
view = QTableView(
sortingEnabled=True
)
data = Orange.data.Table("lenses")
model = TableModel(data)
view.setModel(model)
view.show()
view.raise_()
return app.exec()
if __name__ == "__main__": # pragma: no cover
WidgetPreview(OWDataTable).run(
[(Table("iris"), "iris"),
(Table("brown-selected"), "brown-selected"),
(Table("housing"), "housing")])
