Merge pull request #221 from weka-io/add-ensure_same_defaults

Add `ensure_same_defaults`

Author: idanarye

CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- `ensure_same_defaults` decorator for setting one function's defaults as source of truth for other function
+
 ## [0.4.0] - 2019-11-14
 
 ### Changed

easypy/decorations.py

@@ -5,6 +5,9 @@
 from functools import wraps, partial, update_wrapper
 from operator import attrgetter
 from abc import ABCMeta, abstractmethod
+import inspect
+
+from easypy.exceptions import TException
 
 
 def parametrizeable_decorator(deco):
@@ -138,3 +141,50 @@ def foo(self):
     def wrapper(func):
         return LazyDecoratorDescriptor(decorator_factory, func, cached)
     return wrapper
+
+
+class DefaultsMismatch(TException):
+    template = 'The defaults of {func} differ from those of {source_of_truth} in params {param_names}'
+
+
+def ensure_same_defaults(source_of_truth, ignore=()):
+    """
+    Ensure the decorated function has the same default as the source of truth in optional parameters shared by both
+
+    :param source_of_truth: A function to check the defaults against.
+    :param ignore: A list of parameters to ignore even if they exist and have defaults in both functions.
+    :raises DefaultsMismatch: When the defaults are different.
+
+    >>> def foo(a=1, b=2, c=3):
+    ...     ...
+    >>> @ensure_same_defaults(foo)
+    ... def bar(a=1, b=2, c=3):  # these defaults are verified by the decorator
+    ...         ...
+    """
+
+    sot_signature = inspect.signature(source_of_truth)
+    params_with_defaults = [
+        param for param in sot_signature.parameters.values()
+        if param.default is not param.empty
+        and param.name not in ignore]
+
+    def gen_mismatches(func):
+        signature = inspect.signature(func)
+        for sot_param in params_with_defaults:
+            param = signature.parameters.get(sot_param.name)
+            if param is None:
+                continue
+            if param.default is param.empty:
+                continue
+            if sot_param.default != param.default:
+                yield sot_param.name
+
+    def wrapper(func):
+        mismatches = list(gen_mismatches(func))
+        if mismatches:
+            raise DefaultsMismatch(
+                func=func,
+                source_of_truth=source_of_truth,
+                param_names=mismatches)
+        return func
+    return wrapper

tests/test_decorations.py

@@ -3,6 +3,7 @@
 from functools import wraps
 
 from easypy.decorations import lazy_decorator
+from easypy.decorations import ensure_same_defaults, DefaultsMismatch
 from easypy.misc import kwargs_resilient
 
 
@@ -136,3 +137,56 @@ def counter(self):
     foo2.ts += 1
     assert [foo1.inc(), foo2.inc()] == [2, 2]
     assert [foo1.counter, foo2.counter] == [1, 2]  # foo1 was not updated since last sync - only foo2
+
+
+def test_ensure_same_defaults():
+    def foo(a=1, b=2, c=3):
+        return a, b, c
+
+
+    @ensure_same_defaults(foo)
+    def bar(a=1, b=2, c=3):
+        return a, b, c
+
+    # Test we did not change the actual function
+    assert foo() == bar()
+    assert foo(4, 5, 6) == bar(4, 5, 6)
+
+
+    with pytest.raises(DefaultsMismatch) as exc:
+        @ensure_same_defaults(foo)
+        def baz(a=1, b=3, c=2):
+            pass
+    assert exc.value.param_names == ['b', 'c']
+
+
+def test_ensure_same_defaults_skipping_params_with_no_default():
+    @ensure_same_defaults(lambda a=1, b=2: ...)
+    def foo(a, b=2):
+        pass
+
+    @ensure_same_defaults(lambda a, b=2: ...)
+    def foo(a=1, b=2):
+        pass
+
+    @ensure_same_defaults(lambda a, b=2: ...)
+    def foo(a=1, c=3):
+        pass
+
+    with pytest.raises(DefaultsMismatch) as exc:
+        @ensure_same_defaults(lambda a, b=2: ...)
+        def foo(a, b=4):
+            pass
+    assert exc.value.param_names == ['b']
+
+
+def test_ensure_same_defaults_ignore():
+    @ensure_same_defaults(lambda a=1, b=2: ..., ignore=('b',))
+    def foo(a=1, b=3):
+        pass
+
+    with pytest.raises(DefaultsMismatch) as exc:
+        @ensure_same_defaults(lambda a=1, b=2: ..., ignore=('b',))
+        def foo(a=2, b=3):
+            pass
+    assert exc.value.param_names == ['a']