1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
|
# Test methods with long descriptive names can omit docstrings
# pylint: disable=missing-docstring, protected-access
import unittest
from unittest.mock import patch
import numpy as np
from AnyQt.QtCore import QItemSelectionModel
from Orange.data import Table, ContinuousVariable, StringVariable, Domain, \
DiscreteVariable
from Orange.widgets.visualize.owboxplot import OWBoxPlot, FilterGraphicsRectItem
from Orange.widgets.tests.base import WidgetTest, WidgetOutputsTestMixin
from Orange.tests import test_filename
class TestOWBoxPlot(WidgetTest, WidgetOutputsTestMixin):
@classmethod
def setUpClass(cls):
super().setUpClass()
WidgetOutputsTestMixin.init(cls)
cls.iris = Table("iris")
cls.zoo = Table("zoo")
cls.housing = Table("housing")
cls.titanic = Table("titanic")
cls.heart = Table("heart_disease")
cls.data = cls.iris
cls.signal_name = OWBoxPlot.Inputs.data
cls.signal_data = cls.data
def setUp(self):
self.widget = self.create_widget(OWBoxPlot)
def test_input_data(self):
"""Check widget's data"""
self.send_signal(self.widget.Inputs.data, self.iris)
self.assertEqual(len(self.widget.attrs), 5)
self.assertEqual(len(self.widget.group_vars), 2)
self.assertFalse(self.widget.display_box.isHidden())
self.assertTrue(self.widget.stretching_box.isHidden())
self.send_signal(self.widget.Inputs.data, None)
self.assertEqual(len(self.widget.attrs), 0)
self.assertEqual(len(self.widget.group_vars), 1)
self.assertTrue(self.widget.display_box.isHidden())
self.assertTrue(self.widget.stretching_box.isHidden())
def test_dont_show_hidden_attrs(self):
"""Check widget's data"""
iris = Table("iris")
iris.domain["iris"].attributes["hidden"] = True
iris.domain["petal length"].attributes["hidden"] = True
self.send_signal(self.widget.Inputs.data, iris)
self.assertEqual(len(self.widget.attrs), 3)
self.assertEqual(len(self.widget.group_vars), 1)
def test_primitive_metas(self):
new_domain = Domain(attributes=[], class_vars=[], metas=(
self.data.domain.attributes + self.data.domain.class_vars))
attrs_as_metas = self.data.transform(new_domain)
self.send_signal(self.widget.Inputs.data, attrs_as_metas)
self.assertTrue(self.widget.display_box.isEnabled())
def test_input_data_missings_cont_group_var(self):
"""Check widget with continuous data with missing values and group variable"""
data = self.iris.copy()
with data.unlocked():
data.X[:, 0] = np.nan
self.send_signal(self.widget.Inputs.data, data)
# used to crash, see #1568
def test_input_data_missings_cont_no_group_var(self):
"""Check widget with continuous data with missing values and no group variable"""
data = self.housing
with data.unlocked():
data.X[:, 0] = np.nan
self.send_signal(self.widget.Inputs.data, data)
# used to crash, see #1568
def test_input_data_missings_disc_group_var(self):
"""Check widget with discrete data with missing values and group variable"""
data = self.zoo
with data.unlocked():
data.X[:, 1] = np.nan
# This is a test and does it at its own risk:
# pylint: disable=protected-access
data.domain.attributes[1]._values = []
self.send_signal(self.widget.Inputs.data, data)
self.widget.controls.order_by_importance.setChecked(True)
self._select_list_items(self.widget.attr_list)
self._select_list_items(self.widget.group_list)
def test_input_data_missings_disc_no_group_var(self):
"""Check widget discrete data with missing values and no group variable"""
data = self.zoo
data.domain.class_var = ContinuousVariable("cls")
with data.unlocked():
data.X[:, 1] = np.nan
# This is a test and does it at its own risk:
# pylint: disable=protected-access
data.domain.attributes[1]._values = []
self.send_signal(self.widget.Inputs.data, data)
self._select_list_items(self.widget.attr_list)
self._select_list_items(self.widget.group_list)
def test_no_attribute_or_group_values(self):
attrs = [DiscreteVariable(n, values=tuple("xyz"[:i]))
for i, n in enumerate("abc")]
n = np.nan
data = Table.from_numpy(Domain(attrs),
[[n, n, n],
[n, n, 0],
[n, 0, 1]])
self.send_signal(data)
for self.widget.attribute in attrs:
for self.widget.group_var in attrs:
self.widget.update_graph()
def test_attribute_combinations(self):
self.send_signal(self.widget.Inputs.data, self.heart)
group_list = self.widget.group_list
m = group_list.selectionModel()
for i in range(len(group_list.model().sourceModel())):
m.setCurrentIndex(group_list.model().index(i, 0), m.ClearAndSelect)
self._select_list_items(self.widget.attr_list)
@staticmethod
def model_order(model):
return [model.index(i, 0).data() for i in range(model.rowCount())]
def test_apply_sorting_group(self):
w = self.widget
order_check = w.controls.order_by_importance
model = w.attr_list.model()
def select_group(i):
group_selection = w.group_list.selectionModel()
group_selection.select(
w.group_list.model().index(i, 0),
group_selection.ClearAndSelect)
w.grouping_changed(group_selection.selection())
data = self.titanic
self.send_signal(self.widget.Inputs.data, data)
select_group(2) # First attribute
order_check.setChecked(False)
self.assertEqual(
self.model_order(model),
[var.name
for var in data.domain.class_vars + data.domain.attributes])
order_check.setChecked(True)
self.assertEqual(self.model_order(model),
['sex', 'survived', 'age', 'status'])
select_group(1) # Class
self.widget.apply_attr_sorting()
self.assertEqual(self.model_order(model),
['sex', 'status', 'age', 'survived'])
data = self.heart
self.send_signal(self.widget.Inputs.data, data)
select_group(1) # Class
order_check.setChecked(True)
self.assertEqual(self.model_order(model),
['thal',
'chest pain',
'major vessels colored',
'ST by exercise',
'max HR',
'exerc ind ang',
'slope peak exc ST',
'gender',
'age',
'rest ECG',
'rest SBP',
'cholesterol',
'fasting blood sugar > 120',
'diameter narrowing'])
def test_apply_sorting_vars(self):
controls = self.widget.controls
attr_list = self.widget.attrs
order_check = controls.order_grouping_by_importance
groups = self.widget.group_vars
model = self.widget.group_list.model()
def select_attr(i):
attr_selection = self.widget.attr_list.selectionModel()
attr_selection.setCurrentIndex(
attr_list.index(i),
attr_selection.ClearAndSelect)
data = self.titanic
self.send_signal(self.widget.Inputs.data, data)
select_attr(1) # First attribute
order_check.setChecked(False)
self.assertEqual(
self.model_order(model),
["None"] +
[var.name
for var in data.domain.class_vars + data.domain.attributes])
order_check.setChecked(True)
self.assertIsNone(groups[0])
self.assertEqual(self.model_order(model),
['None', 'sex', 'survived', 'age', 'status'])
select_attr(0) # Class
self.assertIsNone(groups[0])
self.assertEqual(self.model_order(model),
['None', 'sex', 'status', 'age', 'survived'])
data = self.heart
self.send_signal(self.widget.Inputs.data, data)
select_attr(0) # Class
self.assertIsNone(groups[0])
self.assertEqual(self.model_order(model),
['None',
'thal',
'chest pain',
'exerc ind ang',
'slope peak exc ST',
'gender',
'rest ECG',
'fasting blood sugar > 120',
'diameter narrowing'])
def test_box_order_when_missing_stats(self):
self.widget.compare = 1
# The widget can't do anything smart here, but shouldn't crash
self.send_signal(self.widget.Inputs.data, self.iris[49:51])
def test_saved_selection(self):
self.send_signal(self.widget.Inputs.data, self.data)
selected_indices = self._select_data()
self.send_signal(self.widget.Inputs.data, self.zoo)
self.assertIsNone(self.get_output(self.widget.Outputs.selected_data))
self.send_signal(self.widget.Inputs.data, self.data)
np.testing.assert_array_equal(self.get_output(self.widget.Outputs.selected_data).X,
self.data.X[selected_indices])
def test_continuous_metas(self):
domain = self.iris.domain
metas = domain.attributes[:-1] + (StringVariable("str"),)
domain = Domain([], domain.class_var, metas)
data = Table.from_table(domain, self.iris)
self.send_signal(self.widget.Inputs.data, data)
def test_label_overlap(self):
self.send_signal(self.widget.Inputs.data, self.heart)
self.widget.stretched = False
self.__select_variable("chest pain")
self.__select_group("gender")
self.widget.adjustSize()
self.widget.layout().activate()
self.widget.grab() # ensure that the painting code is run
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])
with table.unlocked():
table.X = table.X[use_indexes]
self.send_signal(self.widget.Inputs.data, table)
self.assertEqual(2, len(self.widget.boxes))
def test_sorting_disc_group_var(self):
"""Test if subgroups are sorted by their size"""
table = Table("heart_disease")
self.send_signal(self.widget.Inputs.data, table)
self.__select_variable("gender")
self.__select_group("chest pain")
# checkbox not checked - preserve original order of selected grouping attribute
self.assertListEqual(self.widget.order, [0, 1, 2, 3])
# checkbox checked - sort by frequencies
self.widget.controls.sort_freqs.setChecked(True)
self.assertListEqual(self.widget.order, [0, 2, 1, 3])
def _select_data(self):
items = [item for item in self.widget.box_scene.items()
if isinstance(item, FilterGraphicsRectItem)]
items[0].setSelected(True)
return [100, 103, 104, 108, 110, 111, 112, 115, 116,
120, 123, 124, 128, 132, 133, 136, 137, 139,
140, 141, 143, 144, 145, 146, 147]
def _select_list_items(self, _list):
for name in _list.model().sourceModel():
self.__select_value(_list, name)
def __select_variable(self, name, widget=None):
if widget is None:
widget = self.widget
self.__select_value(widget.attr_list, name)
def __select_group(self, name, widget=None):
if widget is None:
widget = self.widget
self.__select_value(widget.group_list, name)
def __select_value(self, list, value):
m = list.model()
for i in range(m.rowCount()):
idx = m.index(i, 0)
if m.data(idx) == value:
list.selectionModel().setCurrentIndex(
idx, QItemSelectionModel.ClearAndSelect)
def test_unconditional_commit_on_new_signal(self):
with patch.object(self.widget, 'commit') as apply:
apply.reset_mock()
self.send_signal(self.widget.Inputs.data, self.zoo)
apply.assert_called()
def test_stretching(self):
self.send_signal(self.widget.Inputs.data, self.heart)
enabled = self.widget.controls.stretched.isEnabled
self.__select_variable("chest pain")
self.__select_group("gender")
self.assertTrue(enabled())
self.__select_variable("gender")
self.__select_group("gender")
self.assertFalse(enabled())
self.__select_variable("gender")
self.__select_group("chest pain")
self.assertTrue(enabled())
def test_value_all_missing_for_group(self):
"""
This is one of the extreme cases when we have a subgroup value
where all values in selected variable are missing. Box plot should
handle this.
"""
data = Table.from_list(
Domain([DiscreteVariable("a", values=("v1", "v2", "v3")),
DiscreteVariable("b", values=("v3", "v4"))]),
[[0., 0.],
[0., 1.],
[1., np.nan],
[1., np.nan],
[2., 0.],
[2., 0.]])
self.send_signal(self.widget.Inputs.data, data)
self.__select_variable("b")
self.__select_group("a")
self.assertTupleEqual(self.widget.conts.shape, (3, 2))
def test_valid_data_range(self):
self.send_signal(self.widget.Inputs.data, self.iris)
self.__select_variable("petal width")
self.__select_group("iris")
for box in self.widget.box_scene.items():
if isinstance(box, FilterGraphicsRectItem):
box.setSelected(True)
if __name__ == '__main__':
unittest.main()
|
