annotated_data: Add functions for lazy tables

Author: janezd

Orange/widgets/utils/annotated_data.py

@@ -1,5 +1,10 @@
+from typing import Union
+
 import numpy as np
-from Orange.data import Domain, DiscreteVariable
+
+from orangewidget.utils.signals import LazyValue
+
+from Orange.data import Domain, DiscreteVariable, Table
 from Orange.data.util import get_unique_names
 
 ANNOTATED_DATA_SIGNAL_NAME = "Data"
@@ -30,16 +35,26 @@ def add_columns(domain, attributes=(), class_vars=(), metas=()):
     return Domain(attributes, class_vars, metas)
 
 
+def domain_with_annotation_column(
+        data: Union[Table, Domain],
+        values=("No", "Yes"),
+        var_name=ANNOTATED_DATA_FEATURE_NAME):
+    domain = data if isinstance(data, Domain) else data.domain
+    var = DiscreteVariable(get_unique_names(domain, var_name), values)
+    class_vars, metas = domain.class_vars, domain.metas
+    if not domain.class_vars:
+        class_vars += (var, )
+    else:
+        metas += (var, )
+    return Domain(domain.attributes, class_vars, metas), var
+
+
 def _table_with_annotation_column(data, values, column_data, var_name):
-    var = DiscreteVariable(get_unique_names(data.domain, var_name), values)
-    class_vars, metas = data.domain.class_vars, data.domain.metas
+    domain, var = domain_with_annotation_column(data, values, var_name)
     if not data.domain.class_vars:
-        class_vars += (var, )
         column_data = column_data.reshape((len(data), ))
     else:
-        metas += (var, )
         column_data = column_data.reshape((len(data), 1))
-    domain = Domain(data.domain.attributes, class_vars, metas)
     table = data.transform(domain)
     with table.unlocked(table.Y if not data.domain.class_vars else table.metas):
         table[:, var] = column_data
@@ -65,17 +80,20 @@ def create_annotated_table(data, selected_indices):
         data, ("No", "Yes"), annotated, ANNOTATED_DATA_FEATURE_NAME)
 
 
+def lazy_annotated_table(data, selected_indices):
+    domain, _ = domain_with_annotation_column(data)
+    return LazyValue[Table](
+        lambda: create_annotated_table(data, selected_indices),
+        length=len(data), domain=domain)
+
+
 def create_groups_table(data, selection,
                         include_unselected=True,
                         var_name=ANNOTATED_DATA_FEATURE_NAME,
                         values=None):
     if data is None:
         return None
-    max_sel = np.max(selection)
-    if values is None:
-        values = ["G{}".format(i + 1) for i in range(max_sel)]
-        if include_unselected:
-            values.append("Unselected")
+    values, max_sel = group_values(selection, include_unselected, values)
     if include_unselected:
         # Place Unselected instances in the "last group", so that the group
         # colors and scatter diagram marker colors will match
@@ -88,3 +106,24 @@ def create_groups_table(data, selection,
         data = data[mask]
         selection = selection[mask] - 1
     return _table_with_annotation_column(data, values, selection, var_name)
+
+
+def lazy_groups_table(data, selection, include_unselected=True,
+                      var_name=ANNOTATED_DATA_FEATURE_NAME, values=None):
+    length = len(data) if include_unselected else np.sum(selection != 0)
+    values, _ = group_values(selection, include_unselected, values)
+    domain, _ = domain_with_annotation_column(data, values, var_name)
+    return LazyValue[Table](
+        lambda: create_groups_table(data, selection, include_unselected,
+                                    var_name, values),
+        length=length, domain=domain
+    )
+
+
+def group_values(selection, include_unselected, values):
+    max_sel = np.max(selection)
+    if values is None:
+        values = ["G{}".format(i + 1) for i in range(max_sel)]
+        if include_unselected:
+            values.append("Unselected")
+    return values, max_sel

Orange/widgets/utils/tests/test_annotated_data.py

@@ -1,12 +1,16 @@
+from unittest.mock import patch
+
 import random
 import unittest
 
 import numpy as np
 
-from Orange.data import Table, Domain, StringVariable, DiscreteVariable
+from Orange.data import Table, Domain, StringVariable, DiscreteVariable, \
+    ContinuousVariable
 from Orange.data.filter import SameValue
 from Orange.widgets.utils.annotated_data import (
-    create_annotated_table, create_groups_table, ANNOTATED_DATA_FEATURE_NAME
+    create_annotated_table, create_groups_table, ANNOTATED_DATA_FEATURE_NAME,
+    lazy_annotated_table, lazy_groups_table, domain_with_annotation_column
 )
 
 
@@ -15,6 +19,42 @@ def setUp(self):
         random.seed(42)
         self.zoo = Table("zoo")
 
+    def test_domain_with_annotation_column(self):
+        a, b, c = (ContinuousVariable(x) for x in "abc")
+
+        x = [[1, 2, 3], [4, 5, 6]]
+
+        for data in (dabc := Domain([a, b, c]), Table.from_list(dabc, x)):
+            dom, var = domain_with_annotation_column(data)
+            self.assertEqual(dom.attributes, (a, b, c))
+            self.assertIs(dom.class_var, var)
+            self.assertEqual(var.name, ANNOTATED_DATA_FEATURE_NAME)
+            self.assertEqual(var.values, ("No", "Yes"))
+
+            dom, var = domain_with_annotation_column(
+                data, values=tuple("xyz"), var_name="d")
+            self.assertEqual(dom.attributes, (a, b, c))
+            self.assertIs(dom.class_var, var)
+            self.assertEqual(var.name, "d")
+            self.assertEqual(var.values, tuple("xyz"))
+
+        for data in (dabc := Domain([a, b], c), Table.from_list(dabc, x)):
+            dom, var = domain_with_annotation_column(
+                data, values=tuple("xyz"), var_name="d")
+            self.assertEqual(dom.attributes, (a, b))
+            self.assertIs(dom.class_var, c)
+            self.assertEqual(dom.metas, (var, ))
+            self.assertEqual(var.name, "d")
+            self.assertEqual(var.values, tuple("xyz"))
+
+            dom, var = domain_with_annotation_column(
+                data, values=tuple("xyz"), var_name="c")
+            self.assertEqual(dom.attributes, (a, b))
+            self.assertIs(dom.class_var, c)
+            self.assertEqual(dom.metas, (var, ))
+            self.assertEqual(var.name, "c (1)")
+            self.assertEqual(var.values, tuple("xyz"))
+
     def test_create_annotated_table(self):
         annotated = create_annotated_table(self.zoo, list(range(10)))
 
@@ -129,3 +169,52 @@ def test_create_groups_table_set_values(self):
         values = ("this", "that", "rest")
         table = create_groups_table(self.zoo, selection, values=values)
         self.assertEqual(tuple(table.domain["Selected"].values), values)
+
+    @patch("Orange.widgets.utils.annotated_data.create_annotated_table")
+    def test_lazy_annotated_table(self, creator):
+        selected_indices = np.array([1, 2, 3])
+        lazy_table = lazy_annotated_table(self.zoo, selected_indices)
+        self.assertEqual(lazy_table.length, len(self.zoo))
+        self.assertEqual(lazy_table.domain.attributes, self.zoo.domain.attributes)
+        self.assertEqual(lazy_table.domain.class_var, self.zoo.domain.class_var)
+        self.assertEqual(len(lazy_table.domain.metas), 2)
+        var = lazy_table.domain.metas[1]
+        self.assertIsInstance(var, DiscreteVariable)
+        self.assertEqual(var.name, ANNOTATED_DATA_FEATURE_NAME)
+        creator.assert_not_called()
+        self.assertIs(lazy_table.get_value(), creator.return_value)
+
+    @patch("Orange.widgets.utils.annotated_data.create_groups_table")
+    def test_lazy_groups_table(self, creator):
+        group_indices = np.zeros(len(self.zoo), dtype=int)
+        group_indices[10:15] = 1
+
+        lazy_table = lazy_groups_table(self.zoo, group_indices)
+        self.assertEqual(lazy_table.length, len(self.zoo))
+        self.assertEqual(lazy_table.domain.attributes, self.zoo.domain.attributes)
+        self.assertEqual(lazy_table.domain.class_var, self.zoo.domain.class_var)
+        self.assertEqual(len(lazy_table.domain.metas), 2)
+        var = lazy_table.domain.metas[1]
+        self.assertIsInstance(var, DiscreteVariable)
+        self.assertEqual(var.name, ANNOTATED_DATA_FEATURE_NAME)
+        creator.assert_not_called()
+        self.assertIs(lazy_table.get_value(), creator.return_value)
+        creator.reset_mock()
+
+        lazy_table = lazy_groups_table(
+            self.zoo, group_indices, include_unselected=False, var_name="foo",
+            values=("bar", "baz"))
+        self.assertEqual(lazy_table.length, 5)
+        self.assertEqual(lazy_table.domain.attributes, self.zoo.domain.attributes)
+        self.assertEqual(lazy_table.domain.class_var, self.zoo.domain.class_var)
+        self.assertEqual(len(lazy_table.domain.metas), 2)
+        var = lazy_table.domain.metas[1]
+        self.assertIsInstance(var, DiscreteVariable)
+        self.assertEqual(var.name, "foo")
+        self.assertEqual(var.values, ("bar", "baz"))
+        creator.assert_not_called()
+        self.assertIs(lazy_table.get_value(), creator.return_value)
+
+
+if __name__ == "__main__":
+    unittest.main()