Merge pull request #4974 from ales-erjavec/test-cleanup

[FIX] Tests: PyQt5 5.15 compatible cleanup

Author: markotoplak

Orange/widgets/data/owpythonscript.py

@@ -4,8 +4,8 @@
 import keyword
 import itertools
 import unicodedata
+import weakref
 from functools import reduce
-from collections import defaultdict
 from unittest.mock import patch
 
 from typing import Optional, List, TYPE_CHECKING
@@ -437,7 +437,7 @@ class Outputs:
     # anyway. If this causes any problems in the future, replace this with
     # shared_namespaces = {} and thus use a common namespace for all instances
     # of # PythonScript even if they are in different schemata.
-    shared_namespaces = defaultdict(dict)
+    shared_namespaces = weakref.WeakKeyDictionary()
 
     class Error(OWWidget.Error):
         pass
@@ -727,7 +727,7 @@ def saveScript(self):
             f.close()
 
     def initial_locals_state(self):
-        d = self.shared_namespaces[self.signalManager].copy()
+        d = self.shared_namespaces.setdefault(self.signalManager, {}).copy()
         for name in self.signal_names:
             value = getattr(self, name)
             all_values = list(value.values())
@@ -740,7 +740,7 @@ def update_namespace(self, namespace):
         not_saved = reduce(set.union,
                            ({f"in_{name}s", f"in_{name}", f"out_{name}"}
                             for name in self.signal_names))
-        self.shared_namespaces[self.signalManager].update(
+        self.shared_namespaces.setdefault(self.signalManager, {}).update(
             {name: value for name, value in namespace.items()
              if name not in not_saved})
 

Orange/widgets/data/tests/test_owpythonscript.py

@@ -20,6 +20,11 @@ def setUp(self):
         self.learner = LogisticRegressionLearner()
         self.model = self.learner(self.iris)
 
+    def tearDown(self):
+        # clear sys.last_*, these are set/used by interactive interpreter
+        sys.last_type = sys.last_value = sys.last_traceback = None
+        super().tearDown()
+
     def test_inputs(self):
         """Check widget's inputs"""
         for input_, data in (("Data", self.iris),

Orange/widgets/tests/test_gui.py

@@ -28,6 +28,10 @@ def setUp(self):
         self.view = gui.listView(
             self.widget.controlArea, self.widget, "foo", model=self.attrs)
 
+    def tearDown(self) -> None:
+        self.widget.deleteLater()
+        del self.widget
+
     def test_select_callback(self):
         widget = self.widget
         view = self.view

Orange/widgets/unsupervised/owsom.py

@@ -4,7 +4,8 @@
 import numpy as np
 import scipy.sparse as sp
 
-from AnyQt.QtCore import Qt, QRectF, pyqtSignal as Signal, QObject, QThread
+from AnyQt.QtCore import Qt, QRectF, pyqtSignal as Signal, QObject, QThread, \
+    pyqtSlot as Slot
 from AnyQt.QtGui import QTransform, QPen, QBrush, QColor, QPainter, \
     QPainterPath, QKeyEvent
 from AnyQt.QtWidgets import \
@@ -498,6 +499,7 @@ def redraw_selection(self, marks=None):
     def restart_som_pressed(self):
         if self._optimizer_thread is not None:
             self.stop_optimization = True
+            self._optimizer.stop_optimization = True
         else:
             self.start_som()
 
@@ -678,26 +680,29 @@ def _recompute_som(self):
         if self.cont_x is None:
             return
 
+        som = SOM(
+            self.size_x, self.size_y,
+            hexagonal=self.hexagonal,
+            pca_init=self.initialization == 0,
+            random_seed=0 if self.initialization == 2 else None
+        )
+
         class Optimizer(QObject):
             update = Signal(float, np.ndarray, np.ndarray)
             done = Signal(SOM)
             stopped = Signal()
+            stop_optimization = False
 
-            def __init__(self, data, widget):
+            def __init__(self, data, som):
                 super().__init__()
-                self.som = SOM(
-                    widget.size_x, widget.size_y,
-                    hexagonal=widget.hexagonal,
-                    pca_init=widget.initialization == 0,
-                    random_seed=0 if widget.initialization == 2 else None)
+                self.som = som
                 self.data = data
-                self.widget = widget
 
             def callback(self, progress):
                 self.update.emit(
                     progress,
                     self.som.weights.copy(), self.som.ssum_weights.copy())
-                return not self.widget.stop_optimization
+                return not self.stop_optimization
 
             def run(self):
                 try:
@@ -708,44 +713,47 @@ def run(self):
                     self.done.emit(self.som)
                     self.stopped.emit()
 
-        def update(_progress, weights, ssum_weights):
-            progressbar.advance()
-            self._assign_instances(weights, ssum_weights)
-            self._redraw()
-
-        def done(som):
-            self.enable_controls(True)
-            progressbar.finish()
-            self._assign_instances(som.weights, som.ssum_weights)
-            self._redraw()
-            # This is the first time we know what was selected (assuming that
-            # initialization is not set to random)
-            if self.__pending_selection is not None:
-                self.on_selection_change(self.__pending_selection)
-                self.__pending_selection = None
-            self.update_output()
-
         def thread_finished():
             self._optimizer = None
             self._optimizer_thread = None
 
-        progressbar = gui.ProgressBar(self, N_ITERATIONS)
+        self.progressBarInit()
 
-        self._optimizer = Optimizer(self.cont_x, self)
+        self._optimizer = Optimizer(self.cont_x, som)
         self._optimizer_thread = QThread()
         self._optimizer_thread.setStackSize(5 * 2 ** 20)
-        self._optimizer.update.connect(update)
-        self._optimizer.done.connect(done)
+        self._optimizer.update.connect(self.__update)
+        self._optimizer.done.connect(self.__done)
         self._optimizer.stopped.connect(self._optimizer_thread.quit)
         self._optimizer.moveToThread(self._optimizer_thread)
         self._optimizer_thread.started.connect(self._optimizer.run)
         self._optimizer_thread.finished.connect(thread_finished)
         self.stop_optimization = False
         self._optimizer_thread.start()
 
+    @Slot(float, object, object)
+    def __update(self, _progress, weights, ssum_weights):
+        self.progressBarSet(_progress)
+        self._assign_instances(weights, ssum_weights)
+        self._redraw()
+
+    @Slot(object)
+    def __done(self, som):
+        self.enable_controls(True)
+        self.progressBarFinished()
+        self._assign_instances(som.weights, som.ssum_weights)
+        self._redraw()
+        # This is the first time we know what was selected (assuming that
+        # initialization is not set to random)
+        if self.__pending_selection is not None:
+            self.on_selection_change(self.__pending_selection)
+            self.__pending_selection = None
+        self.update_output()
+
     def stop_optimization_and_wait(self):
         if self._optimizer_thread is not None:
             self.stop_optimization = True
+            self._optimizer.stop_optimization = True
             self._optimizer_thread.quit()
             self._optimizer_thread.wait()
             self._optimizer_thread = None

Orange/widgets/visualize/tests/test_owscatterplotbase.py

@@ -46,15 +46,31 @@ def get_palette(self):
         else:
             return colorpalettes.DefaultDiscretePalette
 
+    @staticmethod
+    def reset_mocks():
+        for m in MockWidget.__dict__.values():
+            if isinstance(m, Mock):
+                m.reset_mock()
+
 
 class TestOWScatterPlotBase(WidgetTest):
     def setUp(self):
+        super().setUp()
         self.master = MockWidget()
         self.graph = OWScatterPlotBase(self.master)
 
         self.xy = (np.arange(10, dtype=float), np.arange(10, dtype=float))
         self.master.get_coordinates_data = lambda: self.xy
 
+    def tearDown(self):
+        self.master.onDeleteWidget()
+        self.master.deleteLater()
+        # Clear mocks as they keep ref to widget instance when called
+        MockWidget.reset_mocks()
+        del self.master
+        del self.graph
+        super().tearDown()
+
     # pylint: disable=keyword-arg-before-vararg
     def setRange(self, rect=None, *_, **__):
         if isinstance(rect, QRectF):