Add labels to combo when data comes from matrix

Author: janezd

Orange/widgets/unsupervised/owmds.py

@@ -216,8 +216,10 @@ def __init__(self):
         g = self.graph.gui
         box = g.point_properties_box(self.controlArea)
         self.models = g.points_models
-        self.models[2].order = \
-            self.models[2].order[:1] + ("Stress", ) + self.models[2].order[1:]
+        self.size_model = self.models[2]
+        self.label_model = self.models[3]
+        self.size_model.order = \
+            self.size_model.order[:1] + ("Stress", ) + self.models[2].order[1:]
 
         gui.hSlider(box, self, "connected_pairs", label="Show similar pairs:", minValue=0,
                     maxValue=20, createLabel=False, callback=self._on_connected_changed)
@@ -265,13 +267,18 @@ def update_regression_line(self):
         self.update_graph(reset_view=False)
 
     def init_attr_values(self):
-        domain = self.data and len(self.data) and self.data.domain or None
+        domain = self.data.domain if self.data and len(self.data) else None
         for model in self.models:
             model.set_domain(domain)
         self.graph.attr_color = self.data.domain.class_var if domain else None
         self.graph.attr_shape = None
         self.graph.attr_size = None
         self.graph.attr_label = None
+        if domain is not None:
+            for var in domain.metas:
+                if var.is_string:
+                    self.graph.attr_label = var
+                    break
 
     def prepare_data(self):
         pass
@@ -326,10 +333,7 @@ def set_disimilarity(self, matrix):
             self.Error.matrix_too_small.clear()
 
         self.matrix = matrix
-        if matrix is not None and matrix.row_items:
-            self.matrix_data = matrix.row_items
-        if matrix is None:
-            self.matrix_data = None
+        self.matrix_data = matrix.row_items if matrix is not None else None
         self._invalidated = True
 
     @Inputs.data_subset

Orange/widgets/unsupervised/tests/test_owmds.py

@@ -1,10 +1,15 @@
 # Test methods with long descriptive names can omit docstrings
 # pylint: disable=missing-docstring
+import os
+from itertools import chain
+import unittest
 from unittest.mock import patch, Mock
 
 import numpy as np
 from AnyQt.QtCore import QRectF, QPointF
 
+from Orange.data import Table
+from Orange.misc import DistMatrix
 from Orange.distance import Euclidean
 from Orange.widgets.settings import Context
 from Orange.widgets.unsupervised.owmds import OWMDS
@@ -22,6 +27,10 @@ def setUpClass(cls):
         cls.signal_data = Euclidean(cls.data)
         cls.same_input_output_domain = False
 
+        my_dir = os.path.dirname(__file__)
+        datasets_dir = os.path.join(my_dir, '..', '..', '..', 'datasets')
+        cls.datasets_dir = os.path.realpath(datasets_dir)
+
     def setUp(self):
         self.widget = self.create_widget(
             OWMDS, stored_settings={
@@ -30,6 +39,9 @@ def setUp(self):
                 "initialization": OWMDS.PCA,
             }
         )  # type: OWMDS
+        self.towns = DistMatrix.from_file(
+            os.path.join(self.datasets_dir, "slovenian-towns.dst"))
+
 
     def tearDown(self):
         self.widget.onDeleteWidget()
@@ -174,3 +186,106 @@ def test_migrate_settings_from_version_1(self):
                          (g.jitter_size, 0.5)):
             self.assertTrue(a, value)
         self.assertFalse(w.auto_commit)
+
+    def test_attr_label_from_dist_matrix_from_file(self):
+        w = self.widget
+        # Don't run the MDS optimization to save time and to prevent the
+        # widget be in a blocking state when trying to send the next signal
+        w.start = Mock()
+        row_items = self.towns.row_items
+
+        # Distance matrix with labels
+        self.send_signal(w.Inputs.distances, self.towns)
+        self.assertIs(w.graph.attr_label, row_items.domain["label"])
+
+        # Distances matrix without labels
+        self.towns.row_items = None
+        self.send_signal(w.Inputs.distances, self.towns)
+        self.assertIsNone(w.graph.attr_label)
+
+        # No data
+        self.send_signal(w.Inputs.distances, None)
+        self.assertIsNone(w.graph.attr_label)
+
+        # Distances matrix with labels again
+        self.towns.row_items = row_items
+        self.send_signal(w.Inputs.distances, self.towns)
+        self.assertIs(w.graph.attr_label, row_items.domain["label"])
+
+        # Followed by no data
+        self.towns.row_items = None
+        self.send_signal(w.Inputs.distances, self.towns)
+        self.assertIsNone(w.graph.attr_label)
+
+    def test_attr_label_from_dist_matrix_from_data(self):
+        w = self.widget
+        # Don't run the MDS optimization to save time and to prevent the
+        # widget be in a blocking state when trying to send the next signal
+        w.start = Mock()
+
+        data = Table("zoo")
+        dist = Euclidean(data)
+        self.send_signal(w.Inputs.distances, dist)
+        self.send_signal(w.Inputs.data, data)
+        self.assertTrue(set(chain(data.domain.variables, data.domain.metas))
+                        < set(w.label_model))
+        self.assertIs(w.graph.attr_label, data.domain.metas[0])
+
+    def test_attr_label_from_data(self):
+        w = self.widget
+        # Don't run the MDS optimization to save time and to prevent the
+        # widget be in a blocking state when trying to send the next signal
+        w.start = Mock()
+
+        # Data with string attribute: all attributes present, string selected
+        data = Table("zoo")
+        dist = Euclidean(data)
+        self.send_signal(w.Inputs.distances, dist)
+        self.assertTrue(set(chain(data.domain.variables, data.domain.metas))
+                        < set(w.label_model))
+        self.assertIs(w.graph.attr_label, data.domain.metas[0])
+
+        # Data without string attribute: all attributes present, none selected
+        data = Table("iris")
+        dist = Euclidean(data)
+        self.send_signal(w.Inputs.distances, dist)
+        self.assertTrue(set(chain(data.domain.variables, data.domain.metas))
+                        < set(w.label_model))
+        self.assertIsNone(w.graph.attr_label)
+
+    def test_attr_label_matrix_and_data(self):
+        w = self.widget
+        # Don't run the MDS optimization to save time and to prevent the
+        # widget be in a blocking state when trying to send the next signal
+        w.start = Mock()
+
+        # Data and matrix
+        data = Table("zoo")
+        dist = Euclidean(data)
+        self.send_signal(w.Inputs.distances, dist)
+        self.send_signal(w.Inputs.data, data)
+        self.assertTrue(set(chain(data.domain.variables, data.domain.metas))
+                        < set(w.label_model))
+        self.assertIs(w.graph.attr_label, data.domain.metas[0])
+
+        # Has data, but receives a signal without data: has to keep the label
+        dist.row_items = None
+        self.send_signal(w.Inputs.distances, dist)
+        self.assertTrue(set(chain(data.domain.variables, data.domain.metas))
+                        < set(w.label_model))
+        self.assertIs(w.graph.attr_label, data.domain.metas[0])
+
+        # Has matrix without data, and loses the data: remove the label
+        self.send_signal(w.Inputs.data, None)
+        self.assertEqual(len(w.label_model), 1)  # just None
+        self.assertIsNone(w.graph.attr_label)
+
+        # Has matrix without data, receives data: add attrs to combo, select
+        self.send_signal(w.Inputs.data, data)
+        self.assertTrue(set(chain(data.domain.variables, data.domain.metas))
+                        < set(w.label_model))
+        self.assertIs(w.graph.attr_label, data.domain.metas[0])
+
+
+if __name__ == "__main__":
+    unittest.main()