callback: Rename to progress_callback

Author: VesnaT

Orange/base.py

@@ -10,11 +10,12 @@
 from Orange.data import Table, Storage, Instance, Value
 from Orange.data.filter import HasClass
 from Orange.data.table import DomainTransformationError
-from Orange.data.util import one_hot, progress_callback, dummy_callback
+from Orange.data.util import one_hot
 from Orange.misc.wrapper_meta import WrapperMeta
 from Orange.preprocess import Continuize, RemoveNaNColumns, SklImpute, Normalize
 from Orange.statistics.util import all_nan
-from Orange.util import Reprable, OrangeDeprecationWarning
+from Orange.util import Reprable, OrangeDeprecationWarning, wrap_callback, \
+    dummy_callback
 
 __all__ = ["Learner", "Model", "SklLearner", "SklModel",
            "ReprableWithPreprocessors"]
@@ -102,7 +103,7 @@ def fit_storage(self, data):
         X, Y, W = data.X, data.Y, data.W if data.has_weights() else None
         return self.fit(X, Y, W)
 
-    def __call__(self, data, callback=None):
+    def __call__(self, data, progress_callback=None):
         if not self.check_learner_adequacy(data.domain):
             raise ValueError(self.learner_adequacy_err_msg)
 
@@ -112,33 +113,33 @@ def __call__(self, data, callback=None):
             data = Table(data.domain, [data])
         origdata = data
 
-        if callback is None:
-            callback = dummy_callback
-        callback(0, "Preprocessing...")
+        if progress_callback is None:
+            progress_callback = dummy_callback
+        progress_callback(0, "Preprocessing...")
         try:
-            cb = progress_callback(callback, end=0.1)
-            data = self.preprocess(data, callback=cb)
+            cb = wrap_callback(progress_callback, end=0.1)
+            data = self.preprocess(data, progress_callback=cb)
         except TypeError:
             data = self.preprocess(data)
-            warnings.warn("A keyword argument 'callback' has been added to the"
-                          " preprocess() signature. Implementing the method "
-                          "without the argument is deprecated and will result "
-                          "in an error in the future.",
+            warnings.warn("A keyword argument 'progress_callback' has been "
+                          "added to the preprocess() signature. Implementing "
+                          "the method without the argument is deprecated and "
+                          "will result in an error in the future.",
                           OrangeDeprecationWarning)
 
         if len(data.domain.class_vars) > 1 and not self.supports_multiclass:
             raise TypeError("%s doesn't support multiple class variables" %
                             self.__class__.__name__)
 
-        callback(0.1, "Fitting...")
+        progress_callback(0.1, "Fitting...")
         model = self._fit_model(data)
         model.used_vals = [np.unique(y).astype(int) for y in data.Y[:, None].T]
         model.domain = data.domain
         model.supports_multiclass = self.supports_multiclass
         model.name = self.name
         model.original_domain = origdomain
         model.original_data = origdata
-        callback(1)
+        progress_callback(1)
         return model
 
     def _fit_model(self, data):
@@ -148,15 +149,15 @@ def _fit_model(self, data):
             X, Y, W = data.X, data.Y, data.W if data.has_weights() else None
             return self.fit(X, Y, W)
 
-    def preprocess(self, data, callback=None):
+    def preprocess(self, data, progress_callback=None):
         """Apply the `preprocessors` to the data"""
-        if callback is None:
-            callback = dummy_callback
+        if progress_callback is None:
+            progress_callback = dummy_callback
         n_pps = len(list(self.active_preprocessors))
         for i, pp in enumerate(self.active_preprocessors):
-            callback(i / n_pps)
+            progress_callback(i / n_pps)
             data = pp(data)
-        callback(1)
+        progress_callback(1)
         return data
 
     @property
@@ -489,8 +490,8 @@ def _get_sklparams(self, values):
             raise TypeError("Wrapper does not define '__wraps__'")
         return params
 
-    def preprocess(self, data, callback=None):
-        data = super().preprocess(data, callback)
+    def preprocess(self, data, progress_callback=None):
+        data = super().preprocess(data, progress_callback)
 
         if any(v.is_discrete and len(v.values) > 2
                for v in data.domain.attributes):
@@ -499,8 +500,8 @@ def preprocess(self, data, callback=None):
 
         return data
 
-    def __call__(self, data, callback=None):
-        m = super().__call__(data, callback)
+    def __call__(self, data, progress_callback=None):
+        m = super().__call__(data, progress_callback)
         m.params = self.params
         return m
 

Orange/classification/outlier_detection.py

@@ -12,10 +12,10 @@
 from Orange.data import Table, Domain, DiscreteVariable, ContinuousVariable, \
     Variable
 from Orange.data.table import DomainTransformationError
-from Orange.data.util import get_unique_names, progress_callback, \
-    dummy_callback
+from Orange.data.util import get_unique_names
 from Orange.preprocess import AdaptiveNormalize
 from Orange.statistics.util import all_nan
+from Orange.util import wrap_callback, dummy_callback
 
 __all__ = ["LocalOutlierFactorLearner", "IsolationForestLearner",
            "EllipticEnvelopeLearner", "OneClassSVMLearner"]
@@ -32,43 +32,45 @@ def predict(self, X: np.ndarray) -> np.ndarray:
         pred[pred == -1] = 0
         return pred[:, None]
 
-    def __call__(self, data: Table, callback: Callable = None) -> Table:
+    def __call__(self, data: Table, progress_callback: Callable = None) \
+            -> Table:
         assert isinstance(data, Table)
         assert self.outlier_var is not None
 
         domain = Domain(data.domain.attributes, data.domain.class_vars,
                         data.domain.metas + (self.outlier_var,))
-        if callback is None:
-            callback = dummy_callback
-        callback(0, "Preprocessing...")
+        if progress_callback is None:
+            progress_callback = dummy_callback
+        progress_callback(0, "Preprocessing...")
         self._cached_data = self.data_to_model_domain(
-            data, progress_callback(callback, end=0.1))
-        callback(0.1, "Predicting...")
+            data, wrap_callback(progress_callback, end=0.1))
+        progress_callback(0.1, "Predicting...")
         metas = np.hstack((data.metas, self.predict(self._cached_data.X)))
-        callback(1)
+        progress_callback(1)
         return Table.from_numpy(domain, data.X, data.Y, metas)
 
-    def data_to_model_domain(self, data: Table, callback: Callable) -> Table:
+    def data_to_model_domain(self, data: Table, progress_callback: Callable) \
+            -> Table:
         if data.domain == self.domain:
             return data
 
-        callback(0)
+        progress_callback(0)
         if self.original_domain.attributes != data.domain.attributes \
                 and data.X.size \
                 and not all_nan(data.X):
-            callback(0.5)
+            progress_callback(0.5)
             new_data = data.transform(self.original_domain)
             if all_nan(new_data.X):
                 raise DomainTransformationError(
                     "domain transformation produced no defined values")
-            callback(0.75)
+            progress_callback(0.75)
             data = new_data.transform(self.domain)
-            callback(1)
+            progress_callback(1)
             return data
 
-        callback(0.5)
+        progress_callback(0.5)
         data = data.transform(self.domain)
-        callback(1)
+        progress_callback(1)
         return data
 
 
@@ -166,8 +168,9 @@ def mahalanobis(self, observations: np.ndarray) -> np.ndarray:
         """
         return self.skl_model.mahalanobis(observations)[:, None]
 
-    def __call__(self, data: Table, callback: Callable = None) -> Table:
-        pred = super().__call__(data, callback)
+    def __call__(self, data: Table, progress_callback: Callable = None) \
+            -> Table:
+        pred = super().__call__(data, progress_callback)
         domain = Domain(pred.domain.attributes, pred.domain.class_vars,
                         pred.domain.metas + (self.mahal_var,))
         metas = np.hstack((pred.metas, self.mahalanobis(self._cached_data.X)))

Orange/data/tests/test_util.py

@@ -2,7 +2,7 @@
 
 from Orange.data import Domain, ContinuousVariable
 from Orange.data.util import get_unique_names, get_unique_names_duplicates, \
-    get_unique_names_domain, progress_callback
+    get_unique_names_domain
 
 
 class TestGetUniqueNames(unittest.TestCase):
@@ -115,21 +115,5 @@ def test_get_unique_names_domain(self):
         self.assertEqual(renamed, [])
 
 
-class TestProgressCallback(unittest.TestCase):
-    def test_wrap(self):
-        def func(i):
-            return i
-
-        f = progress_callback(func, start=0, end=0.8)
-        self.assertEqual(f(0), 0)
-        self.assertEqual(round(f(0.1), 2), 0.08)
-        self.assertEqual(f(1), 0.8)
-
-        f = progress_callback(func, start=0.1, end=0.8)
-        self.assertEqual(f(0), 0.1)
-        self.assertEqual(f(0.1), 0.17)
-        self.assertEqual(f(1), 0.8)
-
-
 if __name__ == "__main__":
     unittest.main()

Orange/data/util.py

@@ -4,7 +4,6 @@
 import re
 from collections import Counter, defaultdict
 from itertools import chain
-from functools import wraps
 
 import numpy as np
 import bottleneck as bn
@@ -251,26 +250,3 @@ def get_unique_names_domain(attributes, class_vars=(), metas=()):
                                  for old, new in zip(all_names, unique_names)
                                  if new != old))
     return (attributes, class_vars, metas), renamed
-
-
-def progress_callback(callback, start=0, end=1):
-    """
-    Wraps a callback function to allocate it end-start proportion of
-    the progress.
-
-    :param callback: callable
-    :param start: float
-    :param end: float
-    :return: callable
-    """
-    @wraps(callback)
-    def func(i, *args, **kwargs):
-        x = start + i * (end - start)
-        return callback(x, *args, **kwargs)
-    return func
-
-
-def dummy_callback(*_, **__):
-    """ A dummy callable. """
-    return 1
-

Orange/modelling/base.py

@@ -41,8 +41,8 @@ def _fit_model(self, data):
             X, Y, W = data.X, data.Y, data.W if data.has_weights() else None
             return learner.fit(X, Y, W)
 
-    def preprocess(self, data, callback=None):
-        return self.get_learner(data).preprocess(data, callback)
+    def preprocess(self, data, progress_callback=None):
+        return self.get_learner(data).preprocess(data, progress_callback)
 
     def get_learner(self, problem_type):
         """Get the learner for a given problem type.

Orange/tests/test_util.py

@@ -11,6 +11,7 @@
 from Orange.data.util import vstack, hstack, array_equal
 from Orange.statistics.util import stats
 from Orange.tests.test_statistics import dense_sparse
+from Orange.util import wrap_callback
 
 SOMETHING = 0xf00babe
 
@@ -158,3 +159,21 @@ def test_csc_unordered_array_equal(self):
         a1 = sp.csc_matrix(([1, 4, 5], [0, 0, 1], [0, 1, 1, 3]), shape=(2, 3))
         a2 = sp.csc_matrix(([1, 5, 4], [0, 1, 0], [0, 1, 1, 3]), shape=(2, 3))
         self.assertTrue(array_equal(a1, a2))
+
+    def test_wrap_callback(self):
+        def func(i):
+            return i
+
+        f = wrap_callback(func, start=0, end=0.8)
+        self.assertEqual(f(0), 0)
+        self.assertEqual(round(f(0.1), 2), 0.08)
+        self.assertEqual(f(1), 0.8)
+
+        f = wrap_callback(func, start=0.1, end=0.8)
+        self.assertEqual(f(0), 0.1)
+        self.assertEqual(f(0.1), 0.17)
+        self.assertEqual(f(1), 0.8)
+
+
+if __name__ == "__main__":
+    unittest.main()

Orange/util.py

@@ -416,6 +416,29 @@ def __repr__(self):
             name, ", ".join("{}={!r}".format(f, v) for f, _, v in self._reprable_items())
         )
 
+
+def wrap_callback(progress_callback, start=0, end=1):
+    """
+    Wraps a progress callback function to allocate it end-start proportion
+    of an execution time.
+
+    :param progress_callback: callable
+    :param start: float
+    :param end: float
+    :return: callable
+    """
+    @wraps(progress_callback)
+    def func(progress, *args, **kwargs):
+        adjusted_progress = start + progress * (end - start)
+        return progress_callback(adjusted_progress, *args, **kwargs)
+    return func
+
+
+def dummy_callback(*_, **__):
+    """ A dummy callable. """
+    return 1
+
+
 # For best result, keep this at the bottom
 __all__ = export_globals(globals(), __name__)
 

Orange/widgets/data/owoutliers.py

@@ -12,7 +12,7 @@
 from Orange.classification import OneClassSVMLearner, EllipticEnvelopeLearner,\
     LocalOutlierFactorLearner, IsolationForestLearner
 from Orange.data import Table
-from Orange.data.util import progress_callback
+from Orange.util import wrap_callback
 from Orange.widgets import gui
 from Orange.widgets.settings import Setting
 from Orange.widgets.utils.concurrent import TaskState, ConcurrentWidgetMixin
@@ -40,8 +40,8 @@ def callback(i: float, status=""):
             raise Exception
 
     callback(0, "Initializing...")
-    model = learner(data, progress_callback(callback, end=0.6))
-    pred = model(data, progress_callback(callback, start=0.6, end=0.99))
+    model = learner(data, wrap_callback(callback, end=0.6))
+    pred = model(data, wrap_callback(callback, start=0.6, end=0.99))
 
     col = pred.get_column_view(model.outlier_var)[0]
     inliers_ind = np.where(col == 1)[0]