def test_read_nonutf8_encoding(self):
with self.assertRaises(ValueError) as cm:
data = Table(test_filename('binary-blob.tab'))
self.assertIn('NULL byte', cm.exception.args[0])
with self.assertRaises(ValueError):
with warnings.catch_warnings():
warnings.filterwarnings('error')
data = Table(test_filename('invalid_characters.tab'))
def test_csv_sniffer(self):
# GH-2785
reader = CSVReader(test_filename('test_asn_data_working.csv'))
data = reader.read()
self.assertEqual(len(data), 8)
self.assertEqual(
len(data.domain.variables) + len(data.domain.metas), 15)
def test_calendar_dates(self):
data = Table(test_filename("datasets/cyber-security-breaches.tab"))
self.send_signal(self.widget.Inputs.data, data)
simulate.combobox_activate_item(self.widget.cond_list.cellWidget(0, 0),
"Date_Posted_or_Updated",
delay=0)
value_combo = self.widget.cond_list.cellWidget(0, 2).children()[1]
self.assertIsInstance(value_combo, DateTimeWidget)
# first displayed date is min date
self.assertEqual(value_combo.date(), QDate(2014, 1, 23))
self.assertEqual(len(self.get_output("Matching Data")), 691)
self.widget.remove_all_button.click()
self.enterFilter("Date_Posted_or_Updated", "is below",
QDate(2014, 4, 17))
self.assertEqual(len(self.get_output("Matching Data")), 840)
self.enterFilter("Date_Posted_or_Updated", "is greater than",
QDate(2014, 6, 30))
self.assertIsNone(self.get_output("Matching Data"))
self.widget.remove_all_button.click()
# date is in range min-max date
self.enterFilter("Date_Posted_or_Updated", "equals", QDate(2013, 1, 1))
self.assertEqual(self.widget.conditions[0][2][0], QDate(2014, 1, 23))
self.enterFilter("Date_Posted_or_Updated", "equals", QDate(2015, 1, 1))
self.assertEqual(self.widget.conditions[1][2][0], QDate(2014, 6, 30))
self.widget.remove_all_button.click()
# no date crossings
self.enterFilter("Date_Posted_or_Updated", "is between",
QDate(2014, 4, 17), QDate(2014, 1, 23))
self.assertEqual(self.widget.conditions[0][2],
(QDate(2014, 4, 17), QDate(2014, 4, 17)))
self.widget.remove_all_button.click()
self.enterFilter("Date_Posted_or_Updated", "is between",
QDate(2014, 4, 17), QDate(2014, 4, 30))
self.assertEqual(len(self.get_output("Matching Data")), 58)
def test_results_one_vs_rest(self):
data = Table(test_filename("datasets/lenses.tab"))
learners = [MajorityLearner()]
res = TestOnTestData()(data[1::2], data[::2], learners=learners)
r1 = results_one_vs_rest(res, pos_index=0)
r2 = results_one_vs_rest(res, pos_index=1)
r3 = results_one_vs_rest(res, pos_index=2)
np.testing.assert_almost_equal(np.sum(r1.probabilities, axis=2), 1.0)
np.testing.assert_almost_equal(np.sum(r2.probabilities, axis=2), 1.0)
np.testing.assert_almost_equal(np.sum(r3.probabilities, axis=2), 1.0)
np.testing.assert_almost_equal(
r1.probabilities[:, :, 1] +
r2.probabilities[:, :, 1] +
r3.probabilities[:, :, 1],
1.0
)
self.assertEqual(r1.folds, res.folds)
self.assertEqual(r2.folds, res.folds)
self.assertEqual(r3.folds, res.folds)
np.testing.assert_equal(r1.row_indices, res.row_indices)
np.testing.assert_equal(r2.row_indices, res.row_indices)
np.testing.assert_equal(r3.row_indices, res.row_indices)
def test_results_one_vs_rest(self):
data = Table(test_filename("datasets/lenses.tab"))
learners = [MajorityLearner()]
res = TestOnTestData(data[1::2], data[::2], learners=learners)
r1 = results_one_vs_rest(res, pos_index=0)
r2 = results_one_vs_rest(res, pos_index=1)
r3 = results_one_vs_rest(res, pos_index=2)
np.testing.assert_almost_equal(np.sum(r1.probabilities, axis=2), 1.0)
np.testing.assert_almost_equal(np.sum(r2.probabilities, axis=2), 1.0)
np.testing.assert_almost_equal(np.sum(r3.probabilities, axis=2), 1.0)
np.testing.assert_almost_equal(
r1.probabilities[:, :, 1] +
r2.probabilities[:, :, 1] +
r3.probabilities[:, :, 1],
1.0
)
self.assertEqual(r1.folds, res.folds)
self.assertEqual(r2.folds, res.folds)
self.assertEqual(r3.folds, res.folds)
np.testing.assert_equal(r1.row_indices, res.row_indices)
np.testing.assert_equal(r2.row_indices, res.row_indices)
np.testing.assert_equal(r3.row_indices, res.row_indices)
def setUpClass(cls):
super().setUpClass()
cls.data = Table("heart_disease")
cls.nb_cls = NaiveBayesLearner()(cls.data)
cls.lr_cls = LogisticRegressionLearner()(cls.data)
cls.titanic = Table("titanic")
cls.lenses = Table(test_filename("datasets/lenses.tab"))
def test_SimpleTree_to_string_cls_decimals(self):
data = Table(test_filename("datasets/lenses.tab"))
lrn = SimpleTreeReg(min_instances=1)
cls = lrn(data)
cls_str = cls.to_string()
res = ' astigmatic ([4.0, 3.0, 5.0])'
self.assertEqual(cls_str.split("\n")[3], res)
def test_SimpleTree_to_string_cls_decimals(self):
data = Table(test_filename("datasets/lenses.tab"))
lrn = SimpleTreeReg(min_instances=1)
cls = lrn(data)
cls_str = cls.to_string()
res = ' astigmatic ([4.0, 3.0, 5.0])'
self.assertEqual(cls_str.split("\n")[3], res)
def setUpClass(cls):
super().setUpClass()
cls.data = Table("heart_disease")
cls.nb_cls = NaiveBayesLearner()(cls.data)
cls.lr_cls = LogisticRegressionLearner()(cls.data)
cls.titanic = Table("titanic")
cls.lenses = Table(test_filename("datasets/lenses.tab"))
def test_remove_unused_values_metas(self):
data = Table(test_filename("test9.tab"))
subset = data[:4]
res = Remove(subset, attr_flags=Remove.RemoveUnusedValues, meta_flags=Remove.RemoveUnusedValues)
self.assertEqual(res.domain["b"].values, res.domain["c"].values)
self.assertEqual(res.domain["d"].values, ["1", "2"])
self.assertEqual(res.domain["f"].values, ["1", "hey"])
def test_remove_unused_values_metas(self):
data = Table(test_filename("test9.tab"))
subset = data[:4]
res = Remove(attr_flags=Remove.RemoveUnusedValues,
meta_flags=Remove.RemoveUnusedValues)(subset)
self.assertEqual(res.domain["b"].values, res.domain["c"].values)
self.assertEqual(res.domain["d"].values, ["1", "2"])
self.assertEqual(res.domain["f"].values, ['1', 'hey'])
def test_adequacy_all_learners_multiclass(self):
for learner in self.all_learners():
try:
learner = learner()
table = Table(test_filename("test8.tab"))
self.assertRaises(ValueError, learner, table)
except TypeError as err:
traceback.print_exc()
continue
def test_adequacy_all_learners_multiclass(self):
for learner in self.all_learners():
try:
learner = learner()
table = Table(test_filename("datasets/test8.tab"))
self.assertRaises(ValueError, learner, table)
except TypeError:
traceback.print_exc()
continue
def setUpClass(cls):
super().setUpClass()
cls.lenses = data = Table(test_filename("datasets/lenses.tab"))
test_on_test = Orange.evaluation.TestOnTestData(store_data=True)
cls.res = test_on_test(
data=data[::2], test_data=data[1::2],
learners=[Orange.classification.MajorityLearner(),
Orange.classification.KNNLearner()]
)
def test_scorer_feature(self):
np.random.seed(42)
data = Table(test_filename('datasets/test4.tab'))
learner = RandomForestLearner()
scores = learner.score_data(data)
for i, attr in enumerate(data.domain.attributes):
np.random.seed(42)
score = learner.score_data(data, attr)
np.testing.assert_array_almost_equal(score, scores[:, i])
def test_scorer_feature(self):
np.random.seed(42)
data = Table(test_filename('test4.tab'))
learner = RandomForestLearner()
scores = learner.score_data(data)
for i, attr in enumerate(data.domain.attributes):
np.random.seed(42)
score = learner.score_data(data, attr)
np.testing.assert_array_almost_equal(score, scores[:, i])
def test_adequacy_all_learners_multiclass(self):
for learner in all_learners():
# calibration, threshold learners' __init__ require arguments
if learner in (ThresholdLearner, CalibratedLearner):
continue
with self.subTest(learner.__name__):
learner = learner()
table = Table(test_filename("datasets/test8.tab"))
self.assertRaises(ValueError, learner, table)
def setUpClass(cls):
super().setUpClass()
cls.lenses = data = Table(test_filename("datasets/lenses.tab"))
cls.res = Orange.evaluation.TestOnTestData(
train_data=data[::2], test_data=data[1::2],
learners=[Orange.classification.MajorityLearner(),
Orange.classification.KNNLearner()],
store_data=True,
)
def test_filter_disc(self):
lenses = Table(test_filename("datasets/lenses.tab"))
self.widget.auto_commit = False
self.widget.set_data(lenses)
for i, (op, _) in enumerate(OWSelectRows.Operators[DiscreteVariable]):
self.widget.remove_all()
self.widget.add_row(0, i, DFValues[op])
self.widget.conditions_changed()
self.widget.unconditional_commit()
def test_datetime_normalization(self):
data = Table(test_filename("datasets/test10.tab"))
normalizer = Normalize(zero_based=False,
norm_type=Normalize.NormalizeBySD,
transform_class=False)
data_norm = normalizer(data)
solution = [[0., '1995-01-21', 'a', 'a', '?', 'a', 1.225, 'a', 'a', 2],
[0., '2003-07-23', 'a', 'b', -1., '?', 0., 'b', 'b', 0],
[0., '1967-03-12', 'a', 'b', 1., 'b', -1.225, 'c', 'c', 1]]
self.compare_tables(data_norm, solution)
def test_missing_class(self):
table = Table(test_filename("datasets/imports-85.tab"))
for learner in self.all_learners():
try:
learner = learner()
model = learner(table)
model(table)
except TypeError:
traceback.print_exc()
continue
def test_datetime_normalization(self):
data = Table(test_filename("datasets/test10.tab"))
normalizer = Normalize(zero_based=False,
norm_type=Normalize.NormalizeBySD,
transform_class=False)
data_norm = normalizer(data)
solution = [[0., '1995-01-21', 'a', 'a', '?', 'a', 1.225, 'a', '?', 'a', 2],
[0., '2003-07-23', 'a', 'b', -1., '?', 0., 'b', '?', 'b', 0],
[0., '1967-03-12', 'a', 'b', 1., 'b', -1.225, 'c', '?', 'c', 1]]
self.compare_tables(data_norm, solution)
def test_filter_disc(self):
lenses = Table(test_filename("datasets/lenses.tab"))
self.widget.auto_commit = False
self.widget.set_data(lenses)
for i, (op, _) in enumerate(OWSelectRows.Operators[DiscreteVariable]):
self.widget.remove_all()
self.widget.add_row(0, i, DFValues[op])
self.widget.conditions_changed()
self.widget.unconditional_commit()
def test_missing_class(self):
table = Table(test_filename("datasets/imports-85.tab"))
for learner in all_learners():
try:
learner = learner()
model = learner(table)
model(table)
except TypeError:
traceback.print_exc()
continue
def test_group_table_indices(self):
table = Table(test_filename("test9.tab"))
dd = defaultdict(list)
dd[("1",)] = [0, 1]
dd[("huh",)] = [2]
dd[("hoy",)] = [3]
dd[("?",)] = [4]
dd[("2",)] = [5]
dd[("oh yeah",)] = [6]
dd[("3",)] = [7]
self.assertEqual(dd, group_table_indices(table, ["g"]))
def test_group_table_indices(self):
table = Table(test_filename("test9.tab"))
dd = defaultdict(list)
dd["1"] = [0, 1]
dd["huh"] = [2]
dd["hoy"] = [3]
dd["?"] = [4]
dd["2"] = [5]
dd["oh yeah"] = [6]
dd["3"] = [7]
self.assertEqual(dd, group_table_indices(table, "g"))
def test_group_table_indices(self):
table = Table(test_filename("test9.tab"))
dd = defaultdict(list)
dd[("1", )] = [0, 1]
dd[("huh", )] = [2]
dd[("hoy", )] = [3]
dd[("?", )] = [4]
dd[("2", )] = [5]
dd[("oh yeah", )] = [6]
dd[("3", )] = [7]
self.assertEqual(dd, group_table_indices(table, ["g"]))
def test_group_table_indices(self):
table = Table(test_filename("test9.tab"))
dd = defaultdict(list)
dd["1"] = [0, 1]
dd["huh"] = [2]
dd["hoy"] = [3]
dd["?"] = [4]
dd["2"] = [5]
dd["oh yeah"] = [6]
dd["3"] = [7]
self.assertEqual(dd, group_table_indices(table, "g"))
def test_auc_on_multiclass_data_returns_1d_array(self):
titanic = Table('titanic')[:100]
lenses = Table(test_filename('datasets/lenses.tab'))[:100]
majority = MajorityLearner()
results = TestOnTrainingData(lenses, [majority])
auc = AUC(results)
self.assertEqual(auc.ndim, 1)
results = TestOnTrainingData(titanic, [majority])
auc = AUC(results)
self.assertEqual(auc.ndim, 1)
def test_missing_class(self):
table = Table(test_filename("adult_sample_missing"))
for learner in LearnerAccessibility().all_learners():
try:
learner = learner()
if isinstance(learner, NuSVMLearner):
learner.params["nu"] = 0.01
model = learner(table)
model(table)
except TypeError:
traceback.print_exc()
continue
def test_missing_class(self):
table = Table(test_filename("adult_sample_missing"))
for learner in LearnerAccessibility().all_learners():
try:
learner = learner()
if isinstance(learner, NuSVMLearner):
learner.params["nu"] = 0.01
model = learner(table)
model(table)
except TypeError:
traceback.print_exc()
continue
def test_compute_distributions_metas(self):
d = data.Table(test_filename("test9.tab"))
variable = d.domain[-2]
dist, _ = d._compute_distributions([variable])[0]
np.testing.assert_almost_equal(dist, [3, 3, 2])
# repeat with nan values
assert d.metas.dtype.kind == "O"
assert d.metas[0, 1] == 0
d.metas[0, 1] = np.nan
dist, nanc = d._compute_distributions([variable])[0]
np.testing.assert_almost_equal(dist, [2, 3, 2])
self.assertEqual(nanc, 1)
def test_compute_distributions_metas(self):
d = data.Table(test_filename("datasets/test9.tab"))
variable = d.domain[-2]
dist, _ = d._compute_distributions([variable])[0]
assert_dist_equal(dist, [3, 3, 2])
# repeat with nan values
assert d.metas.dtype.kind == "O"
assert d.metas[0, 1] == 0
d.metas[0, 1] = np.nan
dist, nanc = d._compute_distributions([variable])[0]
assert_dist_equal(dist, [2, 3, 2])
self.assertEqual(nanc, 1)
def test_empty_groups(self):
"""Test if groups with zero elements are not shown"""
table = Table(test_filename("datasets/cyber-security-breaches.tab"))
self.send_signal(self.widget.Inputs.data, table)
self.__select_variable("US State")
self.__select_group("US State")
self.assertEqual(52, len(self.widget.boxes))
# select rows with US State equal to TX or MO
use_indexes = np.array([0, 1, 25, 26, 27])
table.X = table.X[use_indexes]
self.send_signal(self.widget.Inputs.data, table)
self.assertEqual(2, len(self.widget.boxes))
def test_best_match(self):
"""Check default merging attributes setup"""
widget = self.widget
indices = list(range(101))
indices.pop(26)
zoo = Table("zoo")[indices]
zoo_images = Table(test_filename("datasets/zoo-with-images.tab"))
self.send_signal(widget.Inputs.data, zoo)
self.send_signal(widget.Inputs.extra_data, zoo_images)
for i in range(3):
self.assertEqual(widget.attr_boxes.current_state(),
[(zoo.domain[-1], zoo_images.domain[-1])],
f"wrong attributes chosen for merge_type={i}")
def test_empty_groups(self):
"""Test if groups with zero elements are not shown"""
table = Table(test_filename("datasets/cyber-security-breaches.tab"))
self.send_signal(self.widget.Inputs.data, table)
self.__select_variable("US State")
self.__select_group("US State")
self.assertEqual(52, len(self.widget.boxes))
# select rows with US State equal to TX or MO
use_indexes = np.array([0, 1, 25, 26, 27])
table.X = table.X[use_indexes]
self.send_signal(self.widget.Inputs.data, table)
self.assertEqual(2, len(self.widget.boxes))
def setUpClass(cls):
unittest.TestCase.setUpClass()
TestTree.setUpClass()
cls.data = Table("housing")
imports = Table(test_filename("datasets/imports-85.tab"))
new_domain = Domain([attr for attr in imports.domain.attributes
if attr.is_continuous or len(attr.values) <= 16],
imports.domain.class_var)
cls.data_mixed = Table(new_domain, imports)
cls.class_var = ContinuousVariable("y")
cls.blind_prediction = 0
cls.prediction_on_0_1 = 0.5
def test_all_components_continuous(self):
data = Table(test_filename("datasets/cyber-security-breaches.tab"))
# GH-2329 only occurred on TimeVariables when normalize=False
self.assertTrue(any(isinstance(a, TimeVariable)
for a in data.domain.attributes))
self.widget.normalize = False
self.widget._update_normalize() # pylint: disable=protected-access
self.widget.set_data(data)
components = self.get_output(self.widget.Outputs.components)
self.assertTrue(all(type(a) is ContinuousVariable # pylint: disable=unidiomatic-typecheck
for a in components.domain.attributes),
"Some variables aren't of type ContinuousVariable")
def test_best_match(self):
"""Check default merging attributes setup"""
indices = list(range(101))
indices.pop(26)
zoo = Table("zoo")[indices]
zoo_images = Table(test_filename("datasets/zoo-with-images.tab"))
self.send_signal(self.widget.Inputs.data, zoo)
self.send_signal(self.widget.Inputs.extra_data, zoo_images)
self.assertEqual(self.widget.attr_augment_data, zoo.domain[-1])
self.assertEqual(self.widget.attr_augment_extra, zoo_images.domain[-1])
self.assertEqual(self.widget.attr_merge_data, zoo.domain[-1])
self.assertEqual(self.widget.attr_merge_extra, zoo_images.domain[-1])
self.assertEqual(self.widget.attr_combine_data, zoo.domain[-1])
self.assertEqual(self.widget.attr_combine_extra, zoo_images.domain[-1])
def test_all_components_continuous(self):
data = Table(test_filename("datasets/cyber-security-breaches.tab"))
# GH-2329 only occurred on TimeVariables when normalize=False
self.assertTrue(any(isinstance(a, TimeVariable)
for a in data.domain.attributes))
self.widget.normalize = False
self.widget._update_normalize() # pylint: disable=protected-access
self.widget.set_data(data)
components = self.get_output(self.widget.Outputs.components)
self.assertTrue(all(type(a) is ContinuousVariable # pylint: disable=unidiomatic-typecheck
for a in components.domain.attributes),
"Some variables aren't of type ContinuousVariable")
def test_best_match(self):
"""Check default merging attributes setup"""
indices = list(range(101))
indices.pop(26)
zoo = Table("zoo")[indices]
zoo_images = Table(test_filename("datasets/zoo-with-images.tab"))
self.send_signal(self.widget.Inputs.data, zoo)
self.send_signal(self.widget.Inputs.extra_data, zoo_images)
self.assertEqual(self.widget.attr_augment_data, zoo.domain[-1])
self.assertEqual(self.widget.attr_augment_extra, zoo_images.domain[-1])
self.assertEqual(self.widget.attr_merge_data, zoo.domain[-1])
self.assertEqual(self.widget.attr_merge_extra, zoo_images.domain[-1])
self.assertEqual(self.widget.attr_combine_data, zoo.domain[-1])
self.assertEqual(self.widget.attr_combine_extra, zoo_images.domain[-1])
def test_feature_type(self):
widget = self.widget
data = Table(test_filename("datasets/test_asn_data_working.csv"))
metas = data.domain.metas
widget.feature_type = widget.GENERIC
self.send_signal(widget.Inputs.data, data)
# By default, the widget switches from GENERIC to the first meta
self.assertEqual(widget.feature_type, widget.FROM_VAR)
self.assertIs(widget.feature_names_column, metas[0])
output = self.get_output(widget.Outputs.data)
self.assertListEqual([a.name for a in output.domain.attributes],
[metas[0].to_val(m) for m in data.metas[:, 0]])
# Test that the widget takes the correct column
widget.feature_names_column = metas[4]
widget.commit.now()
output = self.get_output(widget.Outputs.data)
self.assertTrue(
all(
a.name.startswith(metas[1].to_val(m))
for a, m in zip(output.domain.attributes, data.metas[:, 4])))
# Switch to generic
self.assertEqual(widget.DEFAULT_PREFIX, "Feature")
widget.feature_type = widget.GENERIC
widget.commit.now()
output = self.get_output(widget.Outputs.data)
self.assertTrue(
all(
x.name.startswith(widget.DEFAULT_PREFIX)
for x in output.domain.attributes))
# Check that the widget uses the supplied name
widget.feature_name = "Foo"
widget.commit.now()
output = self.get_output(widget.Outputs.data)
self.assertTrue(
all(x.name.startswith("Foo ") for x in output.domain.attributes))
# Check that the widget uses default when name is not given
widget.feature_name = ""
widget.commit.now()
output = self.get_output(widget.Outputs.data)
self.assertTrue(
all(
x.name.startswith(widget.DEFAULT_PREFIX)
for x in output.domain.attributes))
def setUpClass(cls):
super().setUpClass()
cls.lenses = data = Table(test_filename("datasets/lenses.tab"))
totd = Orange.evaluation.TestOnTestData(store_data=True, )
cls.res = totd(data=data[::2],
test_data=data[1::2],
learners=[
Orange.classification.MajorityLearner(),
Orange.classification.KNNLearner()
])
try:
# 'mouseRateLimit' interferes with mouse move tests
pg.setConfigOption("mouseRateLimit", -1)
except KeyError:
pass
def test_time_variable_preservation(self):
"""Test if time variables preserve format specific attributes"""
table = Table(test_filename("datasets/cyber-security-breaches.tab"))
self.send_signal(self.widget.Inputs.data, table)
output = self.get_output(self.widget.Outputs.data)
self.assertEqual(str(table[0, 4]), str(output[0, 4]))
view = self.widget.variables_view
view.setCurrentIndex(view.model().index(4))
editor = self.widget.editor_stack.findChild(TimeVariableEditor)
editor.name_edit.setText("Date")
editor.variable_changed.emit()
self.widget.commit()
output = self.get_output(self.widget.Outputs.data)
self.assertEqual(str(table[0, 4]), str(output[0, 4]))
def test_missing_class(self):
table = Table(test_filename("datasets/adult_sample_missing"))
for learner in all_learners():
# calibration, threshold learners' __init__ require arguments
if learner in (ThresholdLearner, CalibratedLearner):
continue
# Skip slow tests
if isinstance(learner, _RuleLearner):
continue
with self.subTest(learner.__name__):
learner = learner()
if isinstance(learner, NuSVMLearner):
learner.params["nu"] = 0.01
model = learner(table)
model(table)
def test_missing_class(self):
table = Table(test_filename("datasets/adult_sample_missing"))
for learner in all_learners():
try:
learner = learner()
if isinstance(learner, NuSVMLearner):
learner.params["nu"] = 0.01
# Skip slow tests
if isinstance(learner, _RuleLearner):
continue
model = learner(table)
model(table)
except TypeError:
traceback.print_exc()
continue
def test_time_variable_preservation(self):
"""Test if time variables preserve format specific attributes"""
table = Table(test_filename("datasets/cyber-security-breaches.tab"))
self.send_signal(self.widget.Inputs.data, table)
output = self.get_output(self.widget.Outputs.data)
self.assertEqual(str(table[0, 4]), str(output[0, 4]))
view = self.widget.variables_view
view.setCurrentIndex(view.model().index(4))
editor = self.widget.findChild(TimeVariableEditor)
editor.name_edit.setText("Date")
editor.variable_changed.emit()
self.widget.commit()
output = self.get_output(self.widget.Outputs.data)
self.assertEqual(str(table[0, 4]), str(output[0, 4]))
def test_widget_state(self):
"""Check if widget clears its state when the input is disconnected"""
editor = self.widget.findChild(ContinuousVariableEditor)
self.send_signal(self.widget.Inputs.data, self.iris)
self.assertEqual(editor.name_edit.text(), "sepal length")
self.send_signal(self.widget.Inputs.data, None)
self.assertEqual(editor.name_edit.text(), "")
self.assertEqual(
self.widget.variables_model.index(0).data(Qt.EditRole), None)
editor = self.widget.findChild(DiscreteVariableEditor)
self.send_signal(self.widget.Inputs.data, self.iris)
index = self.widget.domain_view.model().index(4)
self.widget.variables_view.setCurrentIndex(index)
self.assertEqual(editor.name_edit.text(), "iris")
self.assertEqual(editor.labels_model.get_dict(), {})
self.assertNotEqual(
self.widget.variables_model.index(0).data(Qt.EditRole), None)
model = editor.values_edit.selectionModel().model()
self.assertEqual(model.index(0).data(Qt.EditRole), "Iris-setosa")
self.send_signal(self.widget.Inputs.data, None)
self.assertEqual(editor.name_edit.text(), "")
self.assertEqual(editor.labels_model.get_dict(), {})
self.assertEqual(model.index(0).data(Qt.EditRole), None)
self.assertEqual(
self.widget.variables_model.index(0).data(Qt.EditRole), None)
editor = self.widget.findChild(TimeVariableEditor)
table = Table(test_filename("datasets/cyber-security-breaches.tab"))
self.send_signal(self.widget.Inputs.data, table)
index = self.widget.domain_view.model().index(4)
self.widget.variables_view.setCurrentIndex(index)
self.assertEqual(editor.name_edit.text(), "Date_Posted_or_Updated")
self.send_signal(self.widget.Inputs.data, None)
self.assertEqual(editor.name_edit.text(), "")
self.assertEqual(
self.widget.variables_model.index(0).data(Qt.EditRole), None)
editor = self.widget.findChild(VariableEditor)
self.send_signal(self.widget.Inputs.data, table)
index = self.widget.domain_view.model().index(8)
self.widget.variables_view.setCurrentIndex(index)
self.assertEqual(editor.var.name, "Business_Associate_Involved")
self.send_signal(self.widget.Inputs.data, None)
self.assertEqual(editor.var, None)
self.assertEqual(
self.widget.variables_model.index(0).data(Qt.EditRole), None)
def test_feature_type(self):
widget = self.widget
data = Table(test_filename("datasets/test_asn_data_working.csv"))
metas = data.domain.metas
widget.feature_type = widget.GENERIC
self.send_signal(widget.Inputs.data, data)
# By default, the widget switches from GENERIC to the first meta
self.assertEqual(widget.feature_type, widget.FROM_VAR)
self.assertIs(widget.feature_names_column, metas[0])
output = self.get_output(widget.Outputs.data)
self.assertListEqual(
[a.name for a in output.domain.attributes],
[metas[0].to_val(m) for m in data.metas[:, 0]])
# Test that the widget takes the correct column
widget.feature_names_column = metas[4]
widget.apply()
output = self.get_output(widget.Outputs.data)
self.assertTrue(
all(a.name.startswith(metas[1].to_val(m))
for a, m in zip(output.domain.attributes, data.metas[:, 4])))
# Switch to generic
self.assertEqual(widget.DEFAULT_PREFIX, "Feature")
widget.feature_type = widget.GENERIC
widget.apply()
output = self.get_output(widget.Outputs.data)
self.assertTrue(
all(x.name.startswith(widget.DEFAULT_PREFIX)
for x in output.domain.attributes))
# Check that the widget uses the supplied name
widget.feature_name = "Foo"
widget.apply()
output = self.get_output(widget.Outputs.data)
self.assertTrue(
all(x.name.startswith("Foo ") for x in output.domain.attributes))
# Check that the widget uses default when name is not given
widget.feature_name = ""
widget.apply()
output = self.get_output(widget.Outputs.data)
self.assertTrue(
all(x.name.startswith(widget.DEFAULT_PREFIX)
for x in output.domain.attributes))
def setUpClass(cls):
cls.ionosphere = Table(test_filename('datasets/ionosphere.tab'))
cls.iris = Table('iris')
cls.zoo = Table('zoo')
def setUpClass(cls):
cls.test5 = Table(test_filename('test5.tab'))
def test_compute_contingency_metas(self):
d = data.Table(test_filename("test9.tab"))
var1, var2 = d.domain[-2], d.domain[-4]
cont, _ = d._compute_contingency([var1], var2)[0][0]
assert_dist_equal(cont, [[3, 0, 0], [0, 2, 0],
[0, 0, 2], [0, 1, 0]])
def setUpClass(cls):
cls.zoo = Table("zoo") # disc. features, disc. class
cls.housing = Table("housing") # cont. features, cont. class
cls.breast = Table(test_filename(
"datasets/breast-cancer-wisconsin.tab"))
cls.lenses = Table(test_filename("datasets/lenses.tab"))
def setUpClass(cls):
cls.test8 = Table(test_filename('datasets/test8.tab'))
def test_compute_distributions_metas(self):
d = data.Table(test_filename("test9.tab"))
variable = d.domain[-2]
dist, _ = d._compute_distributions([variable])[0]
np.testing.assert_almost_equal(dist, [3, 3, 2])
def test_varying_between_missing_vals(self):
data = Table(test_filename("test9.tab"))
self.assertEqual(6, len(varying_between(data, [data.domain[0]])))
def setUpClass(cls):
cls.data = Table(test_filename("datasets/breast-cancer-wisconsin"))
cls.heuristic = KMeansCorrelationHeuristic(cls.data)
