VizRankDialog: Move state generation onto separate thread

Orange/widgets/data/owcorrelations.py

@@ -199,8 +199,7 @@ def stopped(self):
     def start(self, task, *args, **kwargs):
         self.__set_state_ready()
         super().start(task, *args, **kwargs)
-        self.master.progressBarInit()
-        self.master.setBlocking(True)
+        self.__set_state_busy()
 
     def cancel(self):
         super().cancel()
@@ -209,10 +208,12 @@ def cancel(self):
     def _connect_signals(self, state):
         super()._connect_signals(state)
         state.progress_changed.connect(self.master.progressBarSet)
+        state.status_changed.connect(self.master.setStatusMessage)
 
     def _disconnect_signals(self, state):
         super()._disconnect_signals(state)
         state.progress_changed.disconnect(self.master.progressBarSet)
+        state.status_changed.disconnect(self.master.setStatusMessage)
 
     def _on_task_done(self, future):
         super()._on_task_done(future)
@@ -221,6 +222,11 @@ def _on_task_done(self, future):
     def __set_state_ready(self):
         self.master.progressBarFinished()
         self.master.setBlocking(False)
+        self.master.setStatusMessage("")
+
+    def __set_state_busy(self):
+        self.master.progressBarInit()
+        self.master.setBlocking(True)
 
 
 class OWCorrelations(OWWidget):
@@ -276,7 +282,6 @@ def __init__(self):
 
         self.vizrank, _ = CorrelationRank.add_vizrank(
             None, self, None, self._vizrank_selection_changed)
-        self.vizrank.progressBar = self.progressBar
         self.vizrank.button.setEnabled(False)
         self.vizrank.threadStopped.connect(self._vizrank_stopped)
 

Orange/widgets/visualize/tests/test_owlinearprojection.py

@@ -203,14 +203,14 @@ 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),
+                    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),
+                    self.vizrank.iterate_states, None,
                     [], 0, self.vizrank.state_count(), Mock())
 
     def test_set_attrs(self):

Orange/widgets/visualize/tests/test_vizrankdialog.py

@@ -31,7 +31,8 @@ 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, 0, 6, task)
+        res = run_vizrank(compute_score, lambda initial: chain(states),
+                          None, scores, 0, 6, task)
 
         next_state = self.assertQueueEqual(
             res.queue, [0, 0, 0, 3, 2, 5], compute_score,
@@ -41,15 +42,16 @@ 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)
+        self.assertEqual(task.set_progress_value.call_count, 7)
 
     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, 0, 6, task)
+        res = run_vizrank(compute_score, lambda initial: chain(states),
+                          None, scores, 0, 6, task)
 
         next_state = self.assertQueueEqual(
             res.queue, [0, 0], compute_score, states[:2], states[1:3])
@@ -58,14 +60,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)
+        self.assertEqual(task.set_progress_value.call_count, 3)
         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, 2, 6, task)
+        res = run_vizrank(compute_score, lambda initial: chain(states[i:]),
+                          None, res_scores, 2, 6, task)
 
         next_state = self.assertQueueEqual(
             res.queue, [0, 3, 2, 5], compute_score, states[2:],
@@ -75,7 +77,7 @@ 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)
+        self.assertEqual(task.set_progress_value.call_count, 8)
         task.set_progress_value.assert_called_with(int(5 / 6 * 100))
 
     def assertQueueEqual(self, queue, positions, f, states, next_states):
@@ -101,7 +103,8 @@ def iterate_states(initial_state):
         def invoke_on_partial_result():
             widget.on_partial_result(run_vizrank(
                 widget.compute_score,
-                widget.iterate_states(widget.saved_state),
+                widget.iterate_states,
+                widget.saved_state,
                 widget.scores,
                 widget.saved_progress,
                 widget.state_count(),

Orange/widgets/visualize/utils/__init__.py

@@ -6,7 +6,7 @@
 from operator import attrgetter
 from queue import Queue, Empty
 from types import SimpleNamespace as namespace
-from typing import Optional, Iterable, List, Callable, Iterator
+from typing import Optional, Iterable, List, Callable
 
 from AnyQt.QtCore import Qt, QSize, pyqtSignal as Signal, QSortFilterProxyModel
 from AnyQt.QtGui import QStandardItemModel, QStandardItem, QColor, QBrush, QPen
@@ -366,7 +366,7 @@ 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")
@@ -383,8 +383,13 @@ def stopped(self):
         pass
 
 
-def run_vizrank(compute_score: Callable, states: Iterator, scores: List,
+def run_vizrank(compute_score: Callable, iterate_states: Callable,
+                saved_state: Optional[Iterable], scores: List,
                 saved_progress: int, state_count: int, task: TaskState):
+    task.set_status("Getting combinations...")
+    task.set_progress_value(0.1)
+    states = iterate_states(saved_state)
+    task.set_status("Getting scores...")
     res = Result(queue=Queue(), scores=None)
     scores = scores.copy()