Refactor MappingTransform out from oweditdomain

Author: ales-erjavec

Orange/preprocess/tests/test_transformation.py

@@ -5,7 +5,8 @@
 
 from Orange.data import DiscreteVariable
 from Orange.preprocess.transformation import \
-    Transformation, _Indicator, Normalizer, Lookup, Indicator, Indicator1
+    Transformation, _Indicator, Normalizer, Lookup, Indicator, Indicator1, \
+    MappingTransform
 
 
 class TestTransformEquality(unittest.TestCase):
@@ -84,6 +85,29 @@ def test_lookup(self):
         self.assertNotEqual(t1, t1a)
         self.assertNotEqual(hash(t1), hash(t1a))
 
+    def test_mapping(self):
+        def test_equal(a, b):
+            self.assertEqual(a, b)
+            self.assertEqual(hash(a), hash(b))
+
+        t1 = MappingTransform(self.disc1, {"a": "1", "b": "2", "c":"3"})
+        t1a = MappingTransform(self.disc1a, {"a": "1", "b": "2", "c":"3"})
+        t2 = MappingTransform(self.disc2, {"a": "1", "b": "2", "c":"3"},
+                              unknown="")
+        test_equal(t1, t1a)
+        self.assertNotEqual(t1, t2)
+
+        t1 = MappingTransform(self.disc1, {"a": 1, "b": 2, "c": float("nan")},
+                              unknown=float("nan"))
+        t1_ = MappingTransform(self.disc1, {"a": 1, "b": 2, "c": float("nan")},
+                               unknown=float("nan"))
+        test_equal(t1, t1_)
+        t1_ = MappingTransform(self.disc1, {"a": 1, "b": float("nan"), "c": 2},
+                               unknown=float("nan"))
+        self.assertNotEqual(t1, t1_)
+        with self.assertRaises(ValueError):
+            MappingTransform(self.disc1, {float("nan"): 1})
+
 
 class TestIndicator(unittest.TestCase):
     def test_nan(self):

Orange/preprocess/transformation.py

@@ -1,9 +1,15 @@
+from typing import TYPE_CHECKING, Mapping, Optional
+
 import numpy as np
 import scipy.sparse as sp
 from pandas import isna
 
-from Orange.data import Instance, Table, Domain
-from Orange.util import Reprable
+from Orange.data import Instance, Table, Domain, Variable
+from Orange.misc.collections import DictMissingConst
+from Orange.util import Reprable, nan_eq, nan_hash_stand, frompyfunc
+
+if TYPE_CHECKING:
+    from numpy.typing import DTypeLike
 
 
 class Transformation(Reprable):
@@ -224,6 +230,75 @@ def __hash__(self):
                 # to avoid different hashes for the same array change to None
                 # issue: https://bugs.python.org/issue43475#msg388508
                 tuple(None if isna(x) else x for x in self.lookup_table),
-                self.unknown,
+                nan_hash_stand(self.unknown),
             )
         )
+
+
+class MappingTransform(Transformation):
+    """
+    Map values via a dictionary lookup.
+
+    Parameters
+    ----------
+    variable: Variable
+    mapping: Mapping
+        The mapping (for the non NA values).
+    dtype: Optional[DTypeLike]
+        The optional target dtype.
+    unknown: Any
+        The constant with whitch to replace unknown values in input.
+    """
+    def __init__(
+            self,
+            variable: Variable,
+            mapping: Mapping,
+            dtype: Optional['DTypeLike'] = None,
+            unknown=np.nan,
+    ) -> None:
+        super().__init__(variable)
+        if any(nan_eq(k, np.nan) for k in mapping.keys()):  # ill-defined mapping
+            raise ValueError("'nan' value in mapping.keys()")
+        self.mapping = mapping
+        self.dtype = dtype
+        self.unknown = unknown
+        self._mapper = self._make_dict_mapper(
+            DictMissingConst(unknown, mapping), dtype
+        )
+
+    @staticmethod
+    def _make_dict_mapper(mapping, dtype):
+        return frompyfunc(mapping.__getitem__, 1, 1, dtype)
+
+    def transform(self, c):
+        return self._mapper(c)
+
+    def __reduce_ex__(self, protocol):
+        return type(self), (self.variable, self.mapping, self.dtype, self.unknown)
+
+    def __eq__(self, other):
+        return super().__eq__(other) \
+               and nan_mapping_eq(self.mapping, other.mapping) \
+               and self.dtype == other.dtype \
+               and nan_eq(self.unknown, other.unknown)
+
+    def __hash__(self):
+        return hash((type(self), self.variable, nan_mapping_hash(self.mapping),
+                     self.dtype, nan_hash_stand(self.unknown)))
+
+
+def nan_mapping_hash(a: Mapping) -> int:
+    return hash(tuple((k, nan_hash_stand(v)) for k, v in a.items()))
+
+
+def nan_mapping_eq(a: Mapping, b: Mapping) -> bool:
+    if len(a) != len(b):
+        return False
+    try:
+        for k, va in a.items():
+            vb = b[k]
+            if not nan_eq(va, vb):
+                return False
+    except LookupError:
+        return False
+    return True

Orange/tests/test_util.py

@@ -6,7 +6,7 @@
 import scipy.sparse as sp
 
 from Orange.util import export_globals, flatten, deprecated, try_, deepgetattr, \
-    OrangeDeprecationWarning
+    OrangeDeprecationWarning, nan_eq, nan_hash_stand
 from Orange.data import Table
 from Orange.data.util import vstack, hstack, array_equal
 from Orange.statistics.util import stats
@@ -72,6 +72,21 @@ class a:
         self.assertTrue(deepgetattr(a, 'l.__nx__.__x__', 42), 42)
         self.assertRaises(AttributeError, lambda: deepgetattr(a, 'l.__nx__.__x__'))
 
+    def test_nan_eq(self):
+        self.assertTrue(nan_eq(float("nan"), float("nan")))
+        self.assertTrue(nan_eq(1, 1.0))
+        self.assertFalse(nan_eq(float("nan"), 1))
+        self.assertFalse(nan_eq(1, float("nan")))
+        self.assertFalse(nan_eq(float("inf"), float("nan")))
+        self.assertFalse(nan_eq(float("nan"), float("inf")))
+        self.assertFalse(nan_eq(1, 2))
+        self.assertFalse(nan_eq(None, 2))
+        self.assertFalse(nan_eq(2, None))
+
+    def test_nan_hash_stand(self):
+        self.assertEqual(hash(nan_hash_stand(float("nan"))),
+                         hash(nan_hash_stand(float("nan"))))
+
     def test_vstack(self):
         numpy = np.array([[1., 2.], [3., 4.]])
         csr = sp.csr_matrix(numpy)

Orange/util.py

@@ -3,7 +3,9 @@
 import os
 import inspect
 import datetime
+import math
 from contextlib import contextmanager
+from typing import TYPE_CHECKING, Callable
 
 import pkg_resources
 from enum import Enum as _Enum
@@ -17,9 +19,14 @@
 # Exposed here for convenience. Prefer patching to try-finally blocks
 from unittest.mock import patch  # pylint: disable=unused-import
 
+import numpy as np
+
 # Backwards-compat
 from Orange.data.util import scale  # pylint: disable=unused-import
 
+if TYPE_CHECKING:
+    from numpy.typing import DTypeLike
+
 
 log = logging.getLogger(__name__)
 
@@ -531,6 +538,78 @@ def utc_from_timestamp(timestamp) -> datetime.datetime:
            datetime.timedelta(seconds=float(timestamp))
 
 
+def frompyfunc(func: Callable, nin: int, nout: int, dtype: 'DTypeLike'):
+    """
+    Wrap an `func` callable into a ufunc-like function with `out`, `dtype`,
+    `where`, ... parameters. The `dtype` is uses as the default.
+
+    Unlike numpy.frompyfunc this function always returns output array of
+    the specified `dtype`. Note that the conversion is space efficient.
+    """
+    func_ = np.frompyfunc(func, nin, nout)
+
+    @wraps(func)
+    def funcv(*args, out=None, dtype=dtype, **kwargs):
+        if not args:
+            raise TypeError
+        args = [np.asanyarray(a) for a in args]
+        args = np.broadcast_arrays(*args)
+        shape = args[0].shape
+        have_out = out is not None
+        if out is None and dtype is not None:
+            out = np.empty(shape, dtype)
+
+        res = func_(*args, out, dtype=dtype, casting="unsafe", **kwargs)
+        if res.shape == () and not have_out:
+            return res.item()
+        else:
+            return res
+
+    return funcv
+
+
+_isnan = math.isnan
+
+
+def nan_eq(a, b) -> bool:
+    """
+    Same as `a == b` except where both `a` and `b` are  NaN values in which
+    case `True` is returned.
+
+    .. seealso:: nan_hash_stand
+    """
+    try:
+        both_nan = _isnan(a) and _isnan(b)
+    except TypeError:
+        return a == b
+    else:
+        return both_nan or a == b
+
+
+def nan_hash_stand(value):
+    """
+    If `value` is a NaN then return a singular global *standin* NaN instance,
+    otherwise return `value` unchanged.
+
+    Use this where a hash of `value` is needed and `value` might be a NaN
+    to account for distinct hashes of NaN instances.
+
+    E.g. the folowing `__eq__` and `__hash__` pairs would be ill-defined for
+    `A(float("nan"))` instances if `nan_hash_stand` and `nan_eq` were not
+    used.
+    >>> class A:
+    ...     def __init__(self, v): self.v = v
+    ...     def __hash__(self): return hash(nan_hash_stand(self.v))
+    ...     def __eq__(self, other): return nan_eq(self.v, other.v)
+    """
+    try:
+        if _isnan(value):
+            return math.nan
+    except TypeError:
+        pass
+    return value
+
+
 # For best result, keep this at the bottom
 __all__ = export_globals(globals(), __name__)
 

Orange/widgets/data/oweditdomain.py

@@ -5,7 +5,6 @@
 A widget for manual editing of a domain's attributes.
 
 """
-import math
 import warnings
 from xml.sax.saxutils import escape
 from itertools import zip_longest, repeat, chain
@@ -39,8 +38,11 @@
 
 import Orange.data
 
-from Orange.preprocess.transformation import Transformation, Identity, Lookup
+from Orange.preprocess.transformation import (
+    Transformation, Identity, Lookup, MappingTransform
+)
 from Orange.misc.collections import DictMissingConst
+from Orange.util import frompyfunc
 from Orange.widgets import widget, gui, settings
 from Orange.widgets.utils import itemmodels, ftry
 from Orange.widgets.utils.buttons import FixedSizeButton
@@ -2640,14 +2642,7 @@ def make_dict_mapper(
     `make_dict_mapper` it is used as a the default return dtype,
     otherwise the default dtype is `object`.
     """
-    _vmapper = np.frompyfunc(mapping.__getitem__, 1, 1)
-
-    def mapper(arr, out=None, dtype=dtype, **kwargs):
-        arr = np.asanyarray(arr)
-        if out is None and dtype is not None and arr.shape != ():
-            out = np.empty_like(arr, dtype)
-        return _vmapper(arr, out, dtype=dtype, casting="unsafe", **kwargs)
-    return mapper
+    return frompyfunc(mapping.__getitem__, 1, 1, dtype)
 
 
 as_string = np.frompyfunc(str, 1, 1)
@@ -2855,82 +2850,8 @@ def transform(self, c):
         return np.nan
 
 
-class LookupMappingTransform(Transformation):
-    """
-    Map values via a dictionary lookup.
-    """
-    def __init__(
-            self,
-            variable: Orange.data.Variable,
-            mapping: Mapping,
-            dtype: Optional[DType] = None,
-            unknown=np.nan,
-    ) -> None:
-        super().__init__(variable)
-        self.mapping = mapping
-        self.dtype = dtype
-        self.unknown = unknown
-        self._mapper = make_dict_mapper(
-            DictMissingConst(unknown, mapping), dtype
-        )
-
-    def transform(self, c):
-        return self._mapper(c)
-
-    def __reduce_ex__(self, protocol):
-        return type(self), (self.variable, self.mapping, self.dtype, self.unknown)
-
-    def __eq__(self, other):
-        return self.variable == other.variable \
-               and self.mapping == other.mapping \
-               and self.dtype == other.dtype \
-               and nan_eq(self.unknown, other.unknown)
-
-    def __hash__(self):
-        return hash((type(self), self.variable, frozenset(self.mapping.items()),
-                     self.dtype, nan_hash_stand(self.unknown)))
-
-
-_isnan = math.isnan
-
-
-def nan_eq(a, b) -> bool:
-    """
-    Same as `a == b` except where both `a` and `b` are  NaN values in which
-    case `True` is returned.
-
-    .. seealso:: nan_hash_stand
-    """
-    try:
-        both_nan = _isnan(a) and _isnan(b)
-    except TypeError:
-        return a == b
-    else:
-        return both_nan or a == b
-
-
-def nan_hash_stand(value):
-    """
-    If `value` is a NaN then return a singular global *standin* NaN instance,
-    otherwise return `value` unchanged.
-
-    Use this where a hash of `value` is needed and `value` might be a NaN
-    to account for distinct hashes of NaN instances.
-
-    E.g. the folowing `__eq__` and `__hash__` pairs would be ill-defined for
-    `A(float("nan"))` instances if `nan_hash_stand` and `nan_eq` were not
-    used.
-    >>> class A:
-    ...     def __init__(self, v): self.v = v
-    ...     def __hash__(self): return hash(nan_hash_stand(self.v))
-    ...     def __eq__(self, other): return nan_eq(self.v, other.v)
-    """
-    try:
-        if _isnan(value):
-            return math.nan
-    except TypeError:
-        pass
-    return value
+# Alias for back compatibility (unpickling transforms)
+LookupMappingTransform = MappingTransform
 
 
 @singledispatch