Fixed yet another nasty varpositional-related bug :). Fixes #38

Author: Sylvain MARIE

makefun/main.py

@@ -184,16 +184,18 @@ def create_function(func_signature,             # type: Union[str, Signature]
         raise TypeError("Invalid type for `func_signature`: %s" % type(func_signature))
 
     # extract all information needed from the `Signature`
-    posonly_names, kwonly_names, varpos_names, varkw_names, unrestricted_names = get_signature_params(func_signature)
-    params_names = posonly_names + unrestricted_names + varpos_names + kwonly_names + varkw_names
+    params_to_kw_assignment_mode = get_signature_params(func_signature)
+    params_names = list(params_to_kw_assignment_mode.keys())
 
     # Note: in decorator the annotations were extracted using getattr(func_impl, '__annotations__') instead.
     # This seems equivalent but more general (provided by the signature, not the function), but to check
     annotations, defaults, kwonlydefaults = get_signature_details(func_signature)
 
     # create the body of the function to compile
-    assignments = posonly_names + [("%s=%s" % (k, k)) if k[0] != '*' else k
-                                   for k in unrestricted_names + varpos_names + kwonly_names + varkw_names]
+    # The generated function body should dispatch its received arguments to the inner function.
+    # For this we will pass as much as possible the arguments as keywords.
+    # However if there are varpositional arguments we cannot
+    assignments = [("%s=%s" % (k, k)) if is_kw else k for k, is_kw in params_to_kw_assignment_mode.items()]
     params_str = ', '.join(assignments)
     if inject_as_first_arg:
         params_str = "%s, %s" % (func_name, params_str)
@@ -433,22 +435,26 @@ def get_signature_params(s):
     :param s:
     :return:
     """
-    posonly_names, kwonly_names, varpos_names, varkw_names, unrestricted_names = [], [], [], [], []
+    # this ordered dictionary will contain parameters and True/False whether we should use keyword assignment or not
+    params_to_assignment_mode = OrderedDict()
     for p_name, p in s.parameters.items():
         if p.kind is Parameter.POSITIONAL_ONLY:
-            posonly_names.append(p_name)
+            params_to_assignment_mode[p_name] = False
         elif p.kind is Parameter.KEYWORD_ONLY:
-            kwonly_names.append(p_name)
+            params_to_assignment_mode[p_name] = True
         elif p.kind is Parameter.POSITIONAL_OR_KEYWORD:
-            unrestricted_names.append(p_name)
+            params_to_assignment_mode[p_name] = True
         elif p.kind is Parameter.VAR_POSITIONAL:
-            varpos_names.append("*" + p_name)
+            # We have to pass all the arguments that were here in previous positions, as positional too.
+            for k in params_to_assignment_mode.keys():
+                params_to_assignment_mode[k] = False
+            params_to_assignment_mode["*" + p_name] = False
         elif p.kind is Parameter.VAR_KEYWORD:
-            varkw_names.append("**" + p_name)
+            params_to_assignment_mode["**" + p_name] = False
         else:
             raise ValueError("Unknown kind: %s" % p.kind)
 
-    return posonly_names, kwonly_names, varpos_names, varkw_names, unrestricted_names
+    return params_to_assignment_mode
 
 
 def get_signature_details(s):

makefun/tests/test_create_from_string_cases.py

@@ -40,8 +40,10 @@ def case_simple_with_star_args1():
     # param_names = ['b', 'a']
 
     inputs = "12"
-    args = ()
-    kwargs = {'a': 0, 'b': 12}
+    # args = ()
+    # kwargs = {'a': 0, 'b': 12}
+    args = (12,)
+    kwargs = {'a': 0}
     return params_str, inputs, (args, kwargs)
 
 

makefun/tests/test_doc.py

@@ -151,15 +151,50 @@ def test_var_length():
     """Demonstrates how variable-length arguments are passed to the handler """
 
     # define the handler that should be called
-    def func_impl(*args, **kwargs):
-        """This docstring will be used in the generated function by default"""
-        print("func_impl called !")
-        return args, kwargs
 
-    func_sig = "foo(a=0, *args, **kwargs)"
-    gen_func = create_function(func_sig, func_impl)
+    def generate_function(func_sig, dummy_call):
+        def func_impl(*args, **kwargs):
+            """This docstring will be used in the generated function by default"""
+            print("func_impl called !")
+            dummy_call(*args, **kwargs)
+            return args, kwargs
+
+        return create_function(func_sig, func_impl)
+
+    func_sig = "foo(a, b=0, *args, **kwargs)"
+
+    def dummy_call(a, b=0, *args, **kwargs):
+        print()
+
+    gen_func = generate_function(func_sig, dummy_call)
+
     print(gen_func.__source__)
-    assert gen_func(0, 1) == ((1,), {'a': 0})
+    # unfortunately we can not have this because as soon as users provide a bit more positional args they there
+    # are TypeErrors "got multiple values for argument 'a'"
+    # assert gen_func(0, 1, 2) == ((2), {'a': 0, 'b': 1})
+    assert gen_func(0, 1, 2) == ((0, 1, 2), {})
+    assert gen_func(0, b=1) == ((0, 1), {})
+    # checks that the order is correctly set
+    assert gen_func(b=1, a=0) == ((0, 1), {})
+
+    with pytest.raises(TypeError):
+        gen_func(2, a=0, b=1)
+    # --
+
+    func_sig = "foo(b=0, *args, **kwargs)"
+
+    def dummy_call(b=0, *args, **kwargs):
+        print()
+
+    gen_func = generate_function(func_sig, dummy_call)
+
+    print(gen_func.__source__)
+
+    assert gen_func(1, 0) == ((1, 0), {})
+    assert gen_func(b=1) == ((1, ), {})
+
+    with pytest.raises(TypeError):
+        gen_func(1, b=0)
 
 
 def test_positional_only():

makefun/tests/test_issues.py

@@ -18,6 +18,17 @@ def foo(*args, **kwargs):
     foo('hello', 12)
 
 
+def test_varpositional2():
+    """ test for https://github.com/smarie/python-makefun/issues/38 """
+
+    @with_signature("(a, *args)")
+    def foo(a, *args):
+        assert a == 'hello'
+        assert args == (12, )
+
+    foo('hello', 12)
+
+
 def test_invalid_signature_str():
     """Test for https://github.com/smarie/python-makefun/issues/36"""
 
@@ -36,3 +47,19 @@ def test_invalid_signature_str_py3():
     @with_signature(sig)
     def foo(a):
         pass
+
+
+def test_init_replaced():
+
+    class Foo(object):
+        @with_signature("(self, a)")
+        def __init__(self, *args, **kwargs):
+            pass
+
+    f = Foo(1)
+
+    class Bar(Foo):
+        def __init__(self, *args, **kwargs):
+            super(Bar, self).__init__(*args, **kwargs)
+
+    b = Bar(2)