Data info displayed in the status bar

Author: aturanjanin

Orange/widgets/data/owfeaturestatistics.py

@@ -25,11 +25,11 @@
     ContinuousVariable, TimeVariable, Domain, Variable
 from Orange.widgets import widget, gui
 from Orange.widgets.data.utils.histogram import Histogram
-from Orange.widgets.report import plural
 from Orange.widgets.settings import ContextSetting, DomainContextHandler
 from Orange.widgets.utils.itemmodels import DomainModel, AbstractSortTableModel
 from Orange.widgets.utils.signals import Input, Output
 from Orange.widgets.utils.widgetpreview import WidgetPreview
+from Orange.widgets.utils.state_summary import format_summary_details
 
 
 def _categorical_entropy(x):
@@ -723,15 +723,6 @@ def __init__(self):
 
         self.data = None  # type: Optional[Table]
 
-        # Information panel
-        info_box = gui.vBox(self.controlArea, 'Info')
-        info_box.setMinimumWidth(200)
-        self.info_summary = gui.widgetLabel(info_box, wordWrap=True)
-        self.info_attr = gui.widgetLabel(info_box, wordWrap=True)
-        self.info_class = gui.widgetLabel(info_box, wordWrap=True)
-        self.info_meta = gui.widgetLabel(info_box, wordWrap=True)
-        self.set_info()
-
         # TODO: Implement filtering on the model
         # filter_box = gui.vBox(self.controlArea, 'Filter')
         # self.filter_text = gui.lineEdit(
@@ -756,6 +747,9 @@ def __init__(self):
         gui.rubber(self.controlArea)
         gui.auto_send(self.buttonsArea, self, "auto_commit")
 
+        self.info.set_input_summary(self.info.NoInput)
+        self.info.set_output_summary(self.info.NoOutput)
+
         # Main area
         self.model = FeatureStatisticsTableModel(parent=self)
         self.table_view = FeatureStatisticsTableView(self.model, parent=self)
@@ -792,11 +786,14 @@ def set_data(self, data):
         self.data = data
 
         if data is not None:
+            self.info.set_input_summary(len(data),
+                                        format_summary_details(data))
             self.color_var_model.set_domain(data.domain)
             self.color_var = None
             if self.data.domain.class_vars:
                 self.color_var = self.data.domain.class_vars[0]
         else:
+            self.info.set_input_summary(self.info.NoInput)
             self.color_var_model.set_domain(None)
             self.color_var = None
         self.model.set_data(data)
@@ -807,7 +804,6 @@ def set_data(self, data):
         # self._filter_table_variables()
         self.__color_var_changed()
 
-        self.set_info()
         self.commit()
 
     def __restore_selection(self):
@@ -843,62 +839,6 @@ def __color_var_changed(self, *_):
         if self.model is not None:
             self.model.set_target_var(self.color_var)
 
-    def _format_variables_string(self, variables):
-        agg = []
-        for var_type_name, var_type in [
-                ('categorical', DiscreteVariable),
-                ('numeric', ContinuousVariable),
-                ('time', TimeVariable),
-                ('string', StringVariable)
-        ]:
-            # Disable pylint here because a `TimeVariable` is also a
-            # `ContinuousVariable`, and should be labelled as such. That is why
-            # it is necessary to check the type this way instead of using
-            # `isinstance`, which would fail in the above case
-            var_type_list = [v for v in variables if type(v) is var_type]  # pylint: disable=unidiomatic-typecheck
-            if var_type_list:
-                shown = var_type in self.model.HIDDEN_VAR_TYPES
-                agg.append((
-                    '%d %s%s' % (len(var_type_list), var_type_name, ['', ' (not shown)'][shown]),
-                    len(var_type_list)
-                ))
-
-        if not agg:
-            return 'No variables'
-
-        attrs, counts = list(zip(*agg))
-        if len(attrs) > 1:
-            var_string = ', '.join(attrs[:-1]) + ' and ' + attrs[-1]
-        else:
-            var_string = attrs[0]
-        return plural('%s variable{s}' % var_string, sum(counts))
-
-    def set_info(self):
-        if self.data is not None:
-            self.info_summary.setText('<b>%s</b> contains %s with %s' % (
-                self.data.name,
-                plural('{number} instance{s}', self.model.n_instances),
-                plural('{number} feature{s}', self.model.n_attributes)
-            ))
-
-            self.info_attr.setText(
-                '<b>Attributes:</b><br>%s' %
-                self._format_variables_string(self.data.domain.attributes)
-            )
-            self.info_class.setText(
-                '<b>Class variables:</b><br>%s' %
-                self._format_variables_string(self.data.domain.class_vars)
-            )
-            self.info_meta.setText(
-                '<b>Metas:</b><br>%s' %
-                self._format_variables_string(self.data.domain.metas)
-            )
-        else:
-            self.info_summary.setText('No data on input.')
-            self.info_attr.setText('')
-            self.info_class.setText('')
-            self.info_meta.setText('')
-
     def on_select(self):
         self.selected_rows = list(self.model.mapToSourceRows([
             i.row() for i in self.table_view.selectionModel().selectedRows()
@@ -909,12 +849,15 @@ def commit(self):
         # self.selected_rows can be list or numpy.array, thus
         # pylint: disable=len-as-condition
         if not len(self.selected_rows):
+            self.info.set_output_summary(self.info.NoOutput)
             self.Outputs.reduced_data.send(None)
             self.Outputs.statistics.send(None)
             return
 
         # Send a table with only selected columns to output
         variables = self.model.variables[self.selected_rows]
+        self.info.set_output_summary(len(self.data[:, variables]),
+                                     format_summary_details(self.data[:, variables]))
         self.Outputs.reduced_data.send(self.data[:, variables])
 
         # Send the statistics of the selected variables to ouput

Orange/widgets/data/tests/test_owfeaturestatistics.py

@@ -1,9 +1,11 @@
+#pylint: disable=unsubscriptable-object
 import datetime
 import unittest
 from collections import namedtuple
 from functools import partial
 from itertools import chain
 from typing import List
+from unittest.mock import Mock
 
 import numpy as np
 from AnyQt.QtCore import QItemSelection, QItemSelectionRange, \
@@ -15,6 +17,7 @@
 from Orange.widgets.tests.utils import simulate, table_dense_sparse
 from Orange.widgets.data.owfeaturestatistics import \
     OWFeatureStatistics
+from Orange.widgets.utils.state_summary import format_summary_details
 
 VarDataPair = namedtuple('VarDataPair', ['variable', 'data'])
 
@@ -463,6 +466,37 @@ def test_restores_previous_selection(self):
         self.send_signal(self.widget.Inputs.data, self.data1)
         self.assertEqual(len(self.widget.selected_rows), 2)
 
+class TestSummary(WidgetTest):
+    def setUp(self):
+        self.widget = self.create_widget(OWFeatureStatistics)
+        self.data = make_table(
+            [continuous_full, continuous_missing],
+            target=[rgb_full, rgb_missing], metas=[ints_full, ints_missing]
+        )
+        self.select_rows = partial(select_rows, widget=self.widget)
+
+    def test_summary(self):
+        """Check if the status bar is updated when data is received"""
+        data = self.data
+        input_sum = self.widget.info.set_input_summary = Mock()
+        output_sum = self.widget.info.set_output_summary = Mock()
+
+        self.send_signal(self.widget.Inputs.data, data)
+        input_sum.assert_called_with(len(data), format_summary_details(data))
+
+        self.select_rows([0, 2])
+        self.widget.unconditional_commit()
+        output = self.get_output(self.widget.Outputs.reduced_data)
+        output_sum.assert_called_with(len(output), format_summary_details(output))
+
+        input_sum.reset_mock()
+        output_sum.reset_mock()
+        self.send_signal(self.widget.Inputs.data, None)
+        input_sum.assert_called_once()
+        self.assertEqual(input_sum.call_args[0][0].brief, "")
+        output_sum.assert_called_once()
+        self.assertEqual(output_sum.call_args[0][0].brief, "")
+
 
 if __name__ == "__main__":
     unittest.main()