Correlations: Add progress bar

Author: VesnaT

Orange/widgets/data/owcorrelations.py

@@ -196,6 +196,32 @@ def stopped(self):
         header = self.rank_table.horizontalHeader()
         header.setSectionResizeMode(1, QHeaderView.Stretch)
 
+    def start(self, task, *args, **kwargs):
+        self.__set_state_ready()
+        super().start(task, *args, **kwargs)
+        self.master.progressBarInit()
+        self.master.setBlocking(True)
+
+    def cancel(self):
+        super().cancel()
+        self.__set_state_ready()
+
+    def _connect_signals(self, state):
+        super()._connect_signals(state)
+        state.progress_changed.connect(self.master.progressBarSet)
+
+    def _disconnect_signals(self, state):
+        super()._disconnect_signals(state)
+        state.progress_changed.disconnect(self.master.progressBarSet)
+
+    def _on_task_done(self, future):
+        super()._on_task_done(future)
+        self.__set_state_ready()
+
+    def __set_state_ready(self):
+        self.master.progressBarFinished()
+        self.master.setBlocking(False)
+
 
 class OWCorrelations(OWWidget):
     name = "Correlations"

Orange/widgets/data/tests/test_owcorrelations.py

@@ -229,6 +229,7 @@ def test_feature_combo(self):
                            if attr.is_continuous]
         self.assertEqual(len(feature_combo.model()), len(cont_attributes) + 1)
 
+        self.wait_until_stop_blocking()
         self.send_signal(self.widget.Inputs.data, Table("housing"))
         self.assertEqual(len(feature_combo.model()), 14)
 
@@ -281,6 +282,7 @@ def test_send_report(self):
         """Test report """
         self.send_signal(self.widget.Inputs.data, self.data_cont)
         self.widget.report_button.click()
+        self.wait_until_stop_blocking()
         self.send_signal(self.widget.Inputs.data, None)
         self.widget.report_button.click()
 

Orange/widgets/visualize/owlinearprojection.py

@@ -59,6 +59,7 @@ def __init__(self, master):
         gui.rubber(box)
         self.last_run_n_attrs = None
         self.attr_color = master.attr_color
+        self.attrs = []
 
     def initialize(self):
         super().initialize()
@@ -95,6 +96,8 @@ def check_preconditions(self):
 
     def state_count(self):
         n_all_attrs = len(self.attrs)
+        if not n_all_attrs:
+            return 0
         n_attrs = self.n_attrs
         return factorial(n_all_attrs) // (2 * factorial(n_all_attrs - n_attrs) * n_attrs)
 

Orange/widgets/visualize/tests/test_owlinearprojection.py

@@ -203,13 +203,15 @@ def setUp(self):
     def test_discrete_class(self):
         self.send_signal(self.widget.Inputs.data, self.data)
         run_vizrank(self.vizrank.compute_score,
-                    self.vizrank.iterate_states(None), [], Mock())
+                    self.vizrank.iterate_states(None),
+                    [], 0, self.vizrank.state_count(), Mock())
 
     def test_continuous_class(self):
         data = Table("housing")[::100]
         self.send_signal(self.widget.Inputs.data, data)
         run_vizrank(self.vizrank.compute_score,
-                    self.vizrank.iterate_states(None), [], Mock())
+                    self.vizrank.iterate_states(None),
+                    [], 0, self.vizrank.state_count(), Mock())
 
     def test_set_attrs(self):
         self.send_signal(self.widget.Inputs.data, self.data)

Orange/widgets/visualize/tests/test_vizrankdialog.py

@@ -31,7 +31,7 @@ def test_run_vizrank(self):
         # run through all states
         task.is_interruption_requested.return_value = False
         states = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
-        res = run_vizrank(compute_score, chain(states), scores, task)
+        res = run_vizrank(compute_score, chain(states), scores, 0, 6, task)
 
         next_state = self.assertQueueEqual(
             res.queue, [0, 0, 0, 3, 2, 5], compute_score,
@@ -41,14 +41,15 @@ def test_run_vizrank(self):
         self.assertListEqual(res.scores, res_scores)
         self.assertIsNot(scores, res.scores)
         self.assertEqual(task.set_partial_result.call_count, 6)
+        self.assertEqual(task.set_progress_value.call_count, 6)
 
     def test_run_vizrank_interrupt(self):
         scores, task = [], Mock()
         # interrupt calculation in third iteration
         task.is_interruption_requested.side_effect = lambda: \
             True if task.is_interruption_requested.call_count > 2 else False
         states = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
-        res = run_vizrank(compute_score, chain(states), scores, task)
+        res = run_vizrank(compute_score, chain(states), scores, 0, 6, task)
 
         next_state = self.assertQueueEqual(
             res.queue, [0, 0], compute_score, states[:2], states[1:3])
@@ -57,11 +58,14 @@ def test_run_vizrank_interrupt(self):
         self.assertListEqual(res.scores, res_scores)
         self.assertIsNot(scores, res.scores)
         self.assertEqual(task.set_partial_result.call_count, 2)
+        self.assertEqual(task.set_progress_value.call_count, 2)
+        task.set_progress_value.assert_called_with(int(1 / 6 * 100))
 
         # continue calculation through all states
         task.is_interruption_requested.side_effect = lambda: False
         i = states.index(next_state)
-        res = run_vizrank(compute_score, chain(states[i:]), res_scores, task)
+        res = run_vizrank(compute_score, chain(states[i:]),
+                          res_scores, 2, 6, task)
 
         next_state = self.assertQueueEqual(
             res.queue, [0, 3, 2, 5], compute_score, states[2:],
@@ -71,6 +75,8 @@ def test_run_vizrank_interrupt(self):
         self.assertListEqual(res.scores, res_scores)
         self.assertIsNot(scores, res.scores)
         self.assertEqual(task.set_partial_result.call_count, 6)
+        self.assertEqual(task.set_progress_value.call_count, 6)
+        task.set_progress_value.assert_called_with(int(5 / 6 * 100))
 
     def assertQueueEqual(self, queue, positions, f, states, next_states):
         self.assertIsInstance(queue, Queue)
@@ -96,7 +102,10 @@ def invoke_on_partial_result():
             widget.on_partial_result(run_vizrank(
                 widget.compute_score,
                 widget.iterate_states(widget.saved_state),
-                widget.scores, task
+                widget.scores,
+                widget.saved_progress,
+                widget.state_count(),
+                task
             ))
 
         task = Mock()
@@ -107,6 +116,7 @@ def invoke_on_partial_result():
         widget.compute_score = compute_score
         widget.iterate_states = iterate_states
         widget.row_for_state = lambda sc, _: [QStandardItem(str(sc))]
+        widget.state_count = lambda: len(states)
 
         # interrupt calculation in third iteration
         task.is_interruption_requested.side_effect = lambda: \
@@ -117,6 +127,7 @@ def invoke_on_partial_result():
                 sorted([compute_score(x) for x in states[:2]])):
             self.assertEqual(widget.rank_model.item(row, 0).text(), str(score))
         self.assertEqual(widget.saved_progress, 2)
+        task.set_progress_value.assert_called_with(int(1 / 6 * 100))
 
         # continue calculation through all states
         task.is_interruption_requested.side_effect = lambda: False
@@ -126,6 +137,7 @@ def invoke_on_partial_result():
                 sorted([compute_score(x) for x in states])):
             self.assertEqual(widget.rank_model.item(row, 0).text(), str(score))
         self.assertEqual(widget.saved_progress, 6)
+        task.set_progress_value.assert_called_with(int(5 / 6 * 100))
 
 
 if __name__ == "__main__":

Orange/widgets/visualize/utils/__init__.py

@@ -366,7 +366,8 @@ def toggle(self):
             self.progressBarInit()
             self.before_running()
             self.start(run_vizrank, self.compute_score,
-                       self.iterate_states(self.saved_state), self.scores)
+                       self.iterate_states(self.saved_state), self.scores,
+                       self.saved_progress, self.state_count())
         else:
             self.button.setText("Continue")
             self.button.repaint()
@@ -382,8 +383,8 @@ def stopped(self):
         pass
 
 
-def run_vizrank(compute_score: Callable, states: Iterator,
-                scores: List, task: TaskState):
+def run_vizrank(compute_score: Callable, states: Iterator, scores: List,
+                saved_progress: int, state_count: int, task: TaskState):
     res = Result(queue=Queue(), scores=None)
     scores = scores.copy()
 
@@ -402,10 +403,14 @@ def do_work(st, next_st):
 
     state = None
     next_state = next(states)
+    count = saved_progress
     try:
         while True:
             if task.is_interruption_requested():
                 return res
+            if state_count < 100 or count % (state_count // 100) == 0:
+                task.set_progress_value(int(count * 100 / max(1, state_count)))
+            count += 1
             state = copy.copy(next_state)
             next_state = copy.copy(next(states))
             do_work(state, next_state)