Upload 50 random repository samples

9d3c8f5 verified about 1 year ago

11.5 kB

import sys
from random import random
import unittest
from inspect import signature, Signature, Parameter

# Assuming we are importing the target objects from main.py
from main import create_function, add_signature_parameters, remove_signature_parameters, with_signature, wraps, create_wrapper


class TestDynamicFunctionGeneration(unittest.TestCase):

    @unittest.expectedFailure
    def test_ex_nihilo(self):
        """ First example from the documentation: tests that we can generate a function from a string """

        # Parameterize types and decorators
        for decorator in [False, True]:
            for type in ['str', 'Signature']:
                # (1) define the signature.
                if type == 'str':
                    func_sig = "foo(b, a=0)"
                    func_name = None
                else:
                    parameters = [
                        Parameter('b', kind=Parameter.POSITIONAL_OR_KEYWORD),
                        Parameter('a', kind=Parameter.POSITIONAL_OR_KEYWORD, default=0),
                    ]
                    func_sig = Signature(parameters)
                    func_name = 'foo'

                # (2) define the function implementation
                def func_impl(*args, **kwargs):
                    """This docstring will be used in the generated function by default"""
                    print("func_impl called !")
                    return args, kwargs

                # (3) create the dynamic function
                if decorator:
                    gen_func = with_signature(func_sig, func_name=func_name)(func_impl)
                else:
                    gen_func = create_function(func_sig, func_impl, func_name=func_name)

                # first check the source code
                ref_src = "def foo(b, a=0):\n    return _func_impl_(b=b, a=a)\n"
                print("Generated Source:\n" + gen_func.__source__)
                self.assertEqual(gen_func.__source__, ref_src)

                # then the behaviour
                args, kwargs = gen_func(2)
                self.assertEqual(args, ())
                self.assertEqual(kwargs, {'a': 0, 'b': 2})

    @unittest.skipIf(sys.version_info < (3, 0), reason="keyword-only signatures require python 3+")
    def test_ex_nihilo_kw_only(self):
        """Same as ex nihilo but keyword only"""

        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(b, *, a=0, **kwargs)"
        gen_func = create_function(func_sig, func_impl)

        ref_src = "def foo(b, *, a=0, **kwargs):\n    return _func_impl_(b=b, a=a, **kwargs)\n"
        print(gen_func.__source__)
        self.assertEqual(gen_func.__source__, ref_src)

    def test_from_sig_wrapper(self):
        """ Tests that we can create a function from a Signature object """

        def foo(b, a=0):
            print("foo called: b=%s, a=%s" % (b, a))
            return b, a

        # capture the name and signature of existing function `foo`
        func_name = foo.__name__
        original_func_sig = signature(foo)
        print("Original Signature: %s" % original_func_sig)

        # modify the signature to add a new parameter
        params = list(original_func_sig.parameters.values())
        params.insert(0, Parameter('z', kind=Parameter.POSITIONAL_OR_KEYWORD))
        func_sig = original_func_sig.replace(parameters=params)
        print("New Signature: %s" % func_sig)

        # define the implementation
        def func_impl(z, *args, **kwargs):
            print("func_impl called ! z=%s" % z)
            # call the foo function
            output = foo(*args, **kwargs)
            # return augmented output
            return z, output

        # create the dynamic function
        gen_func = wraps(foo, new_sig=func_sig)(func_impl)

        # check the source code
        ref_src = "def foo(z, b, a=0):\n    return _func_impl_(z=z, b=b, a=a)\n"
        print("Generated Source:\n" + gen_func.__source__)
        self.assertEqual(gen_func.__source__, ref_src)

        # then the behaviour
        self.assertEqual(gen_func(3, 2), (3, (2, 0)))

    def test_helper_functions(self):
        """ Tests that the signature modification helpers work """
        def foo(b, c, a=0):
            pass

        # original signature
        foo_sig = signature(foo)
        print("original signature: %s" % foo_sig)

        # let's modify it
        new_sig = add_signature_parameters(foo_sig,
                                           first=Parameter('z', kind=Parameter.POSITIONAL_OR_KEYWORD),
                                           last=Parameter('o', kind=Parameter.POSITIONAL_OR_KEYWORD,
                                                          default=True)
                                           )
        new_sig = remove_signature_parameters(new_sig, 'b', 'a')
        print("modified signature: %s" % new_sig)
        self.assertEqual(str(new_sig), '(z, c, o=True)')

    def test_injection(self):
        """ Tests that the function can be injected as first argument when inject_as_first_arg=True """
        def generic_handler(f, *args, **kwargs):
            print("This is generic handler called by %s" % f.__name__)
            # here you could use f.__name__ in a if statement to determine what to do
            if f.__name__ == "func1":
                print("called from func1 !")
            return args, kwargs

        # generate 2 functions
        func1 = create_function("func1(a, b)", generic_handler, inject_as_first_arg=True)
        func2 = create_function("func2(a, d)", generic_handler, inject_as_first_arg=True)

        func1(1, 2)
        func2(1, 2)

    def test_var_length(self):
        """Demonstrates how variable-length arguments are passed to the handler """

        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__)
        self.assertEqual(gen_func(0, 1, 2), ((0, 1, 2), {}))
        self.assertEqual(gen_func(0, b=1), ((0, 1), {}))
        self.assertEqual(gen_func(b=1, a=0), ((0, 1), {}))

        with self.assertRaises(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__)

        self.assertEqual(gen_func(1, 0), ((1, 0), {}))
        self.assertEqual(gen_func(b=1), ((1,), {}))

        with self.assertRaises(TypeError):
            gen_func(1, b=0)

    def test_positional_only(self):
        """Tests that as of today positional-only signatures translate to bad strings """

        params = [Parameter('a', kind=Parameter.POSITIONAL_ONLY),
                  Parameter('b', kind=Parameter.POSITIONAL_OR_KEYWORD)]

        self.assertIn(str(Signature(parameters=params)), {"(<a>, b)", "(a, /, b)"})

    def test_with_signature(self):
        """ Tests that @with_signature works as expected """
        @with_signature("foo(a)")
        def foo(**kwargs):
            return 'hello'

        with self.assertRaises(TypeError):
            foo()

        self.assertEqual(str(signature(foo)), "(a)")
        self.assertEqual(foo('dummy'), 'hello')

    def test_with_signature_none(self):
        """ Test that using None works """
        def foo(a):
            return a

        new = with_signature(None, func_name='f')(foo)

        self.assertEqual(new('hello'), 'hello')
        self.assertEqual(str(signature(new)), "(a)")

        # check that the object was not wrapped
        self.assertIs(new, foo)
        self.assertEqual(new.__name__, 'f')

    def test_wraps(self):
        """ """
        # we want to wrap this function f to add some prints before calls
        def foo(a, b=1):
            return a + b

        # create our wrapper: it will have the same signature than f
        @wraps(foo)
        def enhanced_foo(*args, **kwargs):
            print('hello!')
            print('b=%s' % kwargs['b'])
            # then call f as usual
            return foo(*args, **kwargs)

        self.assertEqual(enhanced_foo(1, 2), 3)
        self.assertEqual(enhanced_foo(b=0, a=1), 1)
        self.assertEqual(enhanced_foo(1), 2)

        with self.assertRaises(TypeError):
            # does not print anything in case of error
            enhanced_foo()

    def test_wraps_functools(self):
        """ same with functools.wraps """

        from functools import wraps

        # we want to wrap this function f to add some prints before calls
        def foo(a, b=1):
            return a + b

        # create our wrapper: it will have the same signature than f
        @wraps(foo)
        def enhanced_foo(*args, **kwargs):
            print('hello!')
            print('b=%s' % kwargs['b'])
            return foo(*args, **kwargs)

        self.assertEqual(enhanced_foo(b=0, a=1), 1)

        with self.assertRaises(KeyError):
            enhanced_foo()

    def test_wraps_remove(self):
        def inject_random_a(f):
            """
            A decorator that injects a random number inside the `a` argument,
            removing it from the exposed signature
            """
            @wraps(f, remove_args='a')
            def my_wrapper(*args, **kwargs):
                kwargs['a'] = random()
                return f(*args, **kwargs)

            return my_wrapper

        @inject_random_a
        def summer(a, b):
            return a + b

        self.assertGreaterEqual(summer(b=12), 12)
        self.assertLessEqual(summer(b=12), 13)

    def test_wraps_add_doc(self):
        def foo(b, a=0):
            print("foo called: b=%s, a=%s" % (b, a))
            return b, a

        @wraps(foo, prepend_args='z')
        def foo_wrapper(z, *args, **kwargs):
            print("foo_wrapper called ! z=%s" % z)
            output = foo(*args, **kwargs)
            return z, output

        # call it
        self.assertEqual(foo_wrapper(3, 2), (3, (2, 0)))

    @unittest.parametrize("prepend", [True, False], ids="prepend={}".format)
    def test_wraps_add(self, prepend):

        def add_a_to_result(f):
            """
            A decorator that injects a random number inside the `a` argument,
            removing it from the exposed signature
            """
            decorator = wraps(f, prepend_args='a') if prepend else wraps(f, append_args='a')

            def my_wrapper(*args, **kwargs):
                a = kwargs.pop('a')
                return a + f(*args, **kwargs)

            my_wrapper = decorator(my_wrapper)

            return my_wrapper

        @add_a_to_result
        def identity(b):
            return b

        self.assertEqual(identity(b=12, a=0.5), 12.5)

        ref_str = "(a, b)" if prepend else "(b, a)"
        self.assertEqual(str(signature(identity)), ref_str)

if __name__ == '__main__':
    unittest.main()

	import sys
	from random import random
	import unittest
	from inspect import signature, Signature, Parameter

	# Assuming we are importing the target objects from main.py
	from main import create_function, add_signature_parameters, remove_signature_parameters, with_signature, wraps, create_wrapper


	class TestDynamicFunctionGeneration(unittest.TestCase):

	@unittest.expectedFailure
	def test_ex_nihilo(self):
	""" First example from the documentation: tests that we can generate a function from a string """

	# Parameterize types and decorators
	for decorator in [False, True]:
	for type in ['str', 'Signature']:
	# (1) define the signature.
	if type == 'str':
	func_sig = "foo(b, a=0)"
	func_name = None
	else:
	parameters = [
	Parameter('b', kind=Parameter.POSITIONAL_OR_KEYWORD),
	Parameter('a', kind=Parameter.POSITIONAL_OR_KEYWORD, default=0),
	]
	func_sig = Signature(parameters)
	func_name = 'foo'

	# (2) define the function implementation
	def func_impl(args, *kwargs):
	"""This docstring will be used in the generated function by default"""
	print("func_impl called !")
	return args, kwargs

	# (3) create the dynamic function
	if decorator:
	gen_func = with_signature(func_sig, func_name=func_name)(func_impl)
	else:
	gen_func = create_function(func_sig, func_impl, func_name=func_name)

	# first check the source code
	ref_src = "def foo(b, a=0):\n return _func_impl_(b=b, a=a)\n"
	print("Generated Source:\n" + gen_func.__source__)
	self.assertEqual(gen_func.__source__, ref_src)

	# then the behaviour
	args, kwargs = gen_func(2)
	self.assertEqual(args, ())
	self.assertEqual(kwargs, {'a': 0, 'b': 2})

	@unittest.skipIf(sys.version_info < (3, 0), reason="keyword-only signatures require python 3+")
	def test_ex_nihilo_kw_only(self):
	"""Same as ex nihilo but keyword only"""

	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(b, , a=0, *kwargs)"
	gen_func = create_function(func_sig, func_impl)

	ref_src = "def foo(b, , a=0, kwargs):\n return _func_impl_(b=b, a=a, *kwargs)\n"
	print(gen_func.__source__)
	self.assertEqual(gen_func.__source__, ref_src)

	def test_from_sig_wrapper(self):
	""" Tests that we can create a function from a Signature object """

	def foo(b, a=0):
	print("foo called: b=%s, a=%s" % (b, a))
	return b, a

	# capture the name and signature of existing function `foo`
	func_name = foo.__name__
	original_func_sig = signature(foo)
	print("Original Signature: %s" % original_func_sig)

	# modify the signature to add a new parameter
	params = list(original_func_sig.parameters.values())
	params.insert(0, Parameter('z', kind=Parameter.POSITIONAL_OR_KEYWORD))
	func_sig = original_func_sig.replace(parameters=params)
	print("New Signature: %s" % func_sig)

	# define the implementation
	def func_impl(z, args, *kwargs):
	print("func_impl called ! z=%s" % z)
	# call the foo function
	output = foo(args, *kwargs)
	# return augmented output
	return z, output

	# create the dynamic function
	gen_func = wraps(foo, new_sig=func_sig)(func_impl)

	# check the source code
	ref_src = "def foo(z, b, a=0):\n return _func_impl_(z=z, b=b, a=a)\n"
	print("Generated Source:\n" + gen_func.__source__)
	self.assertEqual(gen_func.__source__, ref_src)

	# then the behaviour
	self.assertEqual(gen_func(3, 2), (3, (2, 0)))

	def test_helper_functions(self):
	""" Tests that the signature modification helpers work """
	def foo(b, c, a=0):
	pass

	# original signature
	foo_sig = signature(foo)
	print("original signature: %s" % foo_sig)

	# let's modify it
	new_sig = add_signature_parameters(foo_sig,
	first=Parameter('z', kind=Parameter.POSITIONAL_OR_KEYWORD),
	last=Parameter('o', kind=Parameter.POSITIONAL_OR_KEYWORD,
	default=True)
	)
	new_sig = remove_signature_parameters(new_sig, 'b', 'a')
	print("modified signature: %s" % new_sig)
	self.assertEqual(str(new_sig), '(z, c, o=True)')

	def test_injection(self):
	""" Tests that the function can be injected as first argument when inject_as_first_arg=True """
	def generic_handler(f, args, *kwargs):
	print("This is generic handler called by %s" % f.__name__)
	# here you could use f.__name__ in a if statement to determine what to do
	if f.__name__ == "func1":
	print("called from func1 !")
	return args, kwargs

	# generate 2 functions
	func1 = create_function("func1(a, b)", generic_handler, inject_as_first_arg=True)
	func2 = create_function("func2(a, d)", generic_handler, inject_as_first_arg=True)

	func1(1, 2)
	func2(1, 2)

	def test_var_length(self):
	"""Demonstrates how variable-length arguments are passed to the handler """

	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__)
	self.assertEqual(gen_func(0, 1, 2), ((0, 1, 2), {}))
	self.assertEqual(gen_func(0, b=1), ((0, 1), {}))
	self.assertEqual(gen_func(b=1, a=0), ((0, 1), {}))

	with self.assertRaises(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__)

	self.assertEqual(gen_func(1, 0), ((1, 0), {}))
	self.assertEqual(gen_func(b=1), ((1,), {}))

	with self.assertRaises(TypeError):
	gen_func(1, b=0)

	def test_positional_only(self):
	"""Tests that as of today positional-only signatures translate to bad strings """

	params = [Parameter('a', kind=Parameter.POSITIONAL_ONLY),
	Parameter('b', kind=Parameter.POSITIONAL_OR_KEYWORD)]

	self.assertIn(str(Signature(parameters=params)), {"(<a>, b)", "(a, /, b)"})

	def test_with_signature(self):
	""" Tests that @with_signature works as expected """
	@with_signature("foo(a)")
	def foo(**kwargs):
	return 'hello'

	with self.assertRaises(TypeError):
	foo()

	self.assertEqual(str(signature(foo)), "(a)")
	self.assertEqual(foo('dummy'), 'hello')

	def test_with_signature_none(self):
	""" Test that using None works """
	def foo(a):
	return a

	new = with_signature(None, func_name='f')(foo)

	self.assertEqual(new('hello'), 'hello')
	self.assertEqual(str(signature(new)), "(a)")

	# check that the object was not wrapped
	self.assertIs(new, foo)
	self.assertEqual(new.__name__, 'f')

	def test_wraps(self):
	""" """
	# we want to wrap this function f to add some prints before calls
	def foo(a, b=1):
	return a + b

	# create our wrapper: it will have the same signature than f
	@wraps(foo)
	def enhanced_foo(args, *kwargs):
	print('hello!')
	print('b=%s' % kwargs['b'])
	# then call f as usual
	return foo(args, *kwargs)

	self.assertEqual(enhanced_foo(1, 2), 3)
	self.assertEqual(enhanced_foo(b=0, a=1), 1)
	self.assertEqual(enhanced_foo(1), 2)

	with self.assertRaises(TypeError):
	# does not print anything in case of error
	enhanced_foo()

	def test_wraps_functools(self):
	""" same with functools.wraps """

	from functools import wraps

	# we want to wrap this function f to add some prints before calls
	def foo(a, b=1):
	return a + b

	# create our wrapper: it will have the same signature than f
	@wraps(foo)
	def enhanced_foo(args, *kwargs):
	print('hello!')
	print('b=%s' % kwargs['b'])
	return foo(args, *kwargs)

	self.assertEqual(enhanced_foo(b=0, a=1), 1)

	with self.assertRaises(KeyError):
	enhanced_foo()

	def test_wraps_remove(self):
	def inject_random_a(f):
	"""
	A decorator that injects a random number inside the `a` argument,
	removing it from the exposed signature
	"""
	@wraps(f, remove_args='a')
	def my_wrapper(args, *kwargs):
	kwargs['a'] = random()
	return f(args, *kwargs)

	return my_wrapper

	@inject_random_a
	def summer(a, b):
	return a + b

	self.assertGreaterEqual(summer(b=12), 12)
	self.assertLessEqual(summer(b=12), 13)

	def test_wraps_add_doc(self):
	def foo(b, a=0):
	print("foo called: b=%s, a=%s" % (b, a))
	return b, a

	@wraps(foo, prepend_args='z')
	def foo_wrapper(z, args, *kwargs):
	print("foo_wrapper called ! z=%s" % z)
	output = foo(args, *kwargs)
	return z, output

	# call it
	self.assertEqual(foo_wrapper(3, 2), (3, (2, 0)))

	@unittest.parametrize("prepend", [True, False], ids="prepend={}".format)
	def test_wraps_add(self, prepend):

	def add_a_to_result(f):
	"""
	A decorator that injects a random number inside the `a` argument,
	removing it from the exposed signature
	"""
	decorator = wraps(f, prepend_args='a') if prepend else wraps(f, append_args='a')

	def my_wrapper(args, *kwargs):
	a = kwargs.pop('a')
	return a + f(args, *kwargs)

	my_wrapper = decorator(my_wrapper)

	return my_wrapper

	@add_a_to_result
	def identity(b):
	return b

	self.assertEqual(identity(b=12, a=0.5), 12.5)

	ref_str = "(a, b)" if prepend else "(b, a)"
	self.assertEqual(str(signature(identity)), ref_str)

	if __name__ == '__main__':
	unittest.main()