Outliers: Refactor

Author: VesnaT

Orange/classification/tests/test_outlier_detection.py

@@ -5,9 +5,10 @@
 import unittest
 
 import numpy as np
-from Orange.data import Table, Domain, ContinuousVariable
+
 from Orange.classification import EllipticEnvelopeLearner, \
     IsolationForestLearner, LocalOutlierFactorLearner, OneClassSVMLearner
+from Orange.data import Table, Domain, ContinuousVariable
 
 
 class _TestDetector(unittest.TestCase):

Orange/widgets/data/owoutliers.py

@@ -9,7 +9,7 @@
 
 from Orange.classification import OneClassSVMLearner, EllipticEnvelopeLearner,\
     LocalOutlierFactorLearner, IsolationForestLearner
-from Orange.data import Table, DiscreteVariable
+from Orange.data import Table
 from Orange.widgets import gui
 from Orange.widgets.settings import Setting
 from Orange.widgets.utils.sql import check_sql_input
@@ -238,44 +238,40 @@ def enable_controls(self):
             self.method_combo.model().item(self.Covariance).setEnabled(False)
             self.Warning.disabled_cov()
 
-    def _get_outliers(self) -> Tuple[Table, Table, Table]:
+    def commit(self):
+        inliers, outliers, data = self.detect_outliers()
+        summary = len(inliers) if inliers else self.info.NoOutput
+        self.info.set_output_summary(summary)
+        self.Outputs.inliers.send(inliers)
+        self.Outputs.outliers.send(outliers)
+        self.Outputs.data.send(data)
+
+    def detect_outliers(self) -> Tuple[Table, Table, Table]:
+        self.n_inliers = self.n_outliers = None
         self.Error.singular_cov.clear()
         self.Error.memory_error.clear()
+        if not self.data:
+            return None, None, None
         try:
-            pred, outlier_var = self.detect_outliers()
+            learner_class = self.METHODS[self.outlier_method]
+            kwargs = self.current_editor.get_parameters()
+            learner = learner_class(**kwargs)
+            model = learner(self.data)
+            pred = model(self.data)
         except ValueError:
             self.Error.singular_cov()
             return None, None, None
         except MemoryError:
             self.Error.memory_error()
             return None, None, None
         else:
-            col = pred[:, outlier_var].metas
+            col = pred[:, model.outlier_var].metas
             inliers_ind = np.where(col == 1)[0]
             outliers_ind = np.where(col == 0)[0]
             self.n_inliers = len(inliers_ind)
             self.n_outliers = len(outliers_ind)
             return self.data[inliers_ind], self.data[outliers_ind], pred
 
-    def commit(self):
-        inliers = outliers = data = None
-        self.n_inliers = self.n_outliers = None
-        if self.data:
-            inliers, outliers, data = self._get_outliers()
-
-        summary = len(inliers) if inliers else self.info.NoOutput
-        self.info.set_output_summary(summary)
-        self.Outputs.inliers.send(inliers)
-        self.Outputs.outliers.send(outliers)
-        self.Outputs.data.send(data)
-
-    def detect_outliers(self) -> Tuple[Table, DiscreteVariable]:
-        learner_class = self.METHODS[self.outlier_method]
-        kwargs = self.current_editor.get_parameters()
-        learner = learner_class(**kwargs)
-        model = learner(self.data)
-        return model(self.data), model.outlier_var
-
     def send_report(self):
         if self.n_outliers is None or self.n_inliers is None:
             return

Orange/widgets/data/tests/test_owoutliers.py

@@ -68,22 +68,20 @@ def callback():
             self.assertIsNotNone(self.get_output(self.widget.Outputs.outliers))
             self.assertIsNotNone(self.get_output(self.widget.Outputs.data))
 
-        self.send_signal(self.widget.Inputs.data, self.iris)
+        self.send_signal(self.widget.Inputs.data, self.heart_disease)
         simulate.combobox_run_through_all(self.widget.method_combo,
                                           callback=callback)
 
-    def test_memory_error(self):
+    @patch("Orange.classification.outlier_detection._OutlierModel.predict")
+    def test_memory_error(self, mocked_predict: Mock):
         """
         Handling memory error.
         GH-2374
         """
-        data = Table("iris")[::3]
         self.assertFalse(self.widget.Error.memory_error.is_shown())
-        with unittest.mock.patch(
-                "Orange.widgets.data.owoutliers.OWOutliers.detect_outliers",
-                side_effect=MemoryError):
-            self.send_signal("Data", data)
-            self.assertTrue(self.widget.Error.memory_error.is_shown())
+        mocked_predict.side_effect = MemoryError
+        self.send_signal(self.widget.Inputs.data, self.iris)
+        self.assertTrue(self.widget.Error.memory_error.is_shown())
 
     def test_nans(self):
         """Widget does not crash with nans"""