Example #1
0
    def test_argspec_for_functools_partial(self):

        # pylint: disable=unused-argument
        def test_function_for_partial1(arg1, arg2, kwarg1=1, kwarg2=2):
            pass

        def test_function_for_partial2(arg1, arg2, *my_args, **my_kwargs):
            pass

        # pylint: enable=unused-argument

        # pylint: disable=protected-access
        # Make sure everything works for regular functions.
        expected = inspect.ArgSpec(['arg1', 'arg2', 'kwarg1', 'kwarg2'], None,
                                   None, (1, 2))
        self.assertEqual(expected,
                         parser._get_arg_spec(test_function_for_partial1))

        # Make sure doing nothing works.
        expected = inspect.ArgSpec(['arg1', 'arg2', 'kwarg1', 'kwarg2'], None,
                                   None, (1, 2))
        partial = functools.partial(test_function_for_partial1)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        # Make sure setting args from the front works.
        expected = inspect.ArgSpec(['arg2', 'kwarg1', 'kwarg2'], None, None,
                                   (1, 2))
        partial = functools.partial(test_function_for_partial1, 1)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        expected = inspect.ArgSpec([
            'kwarg2',
        ], None, None, (2, ))
        partial = functools.partial(test_function_for_partial1, 1, 2, 3)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        # Make sure setting kwargs works.
        expected = inspect.ArgSpec(['arg1', 'arg2', 'kwarg2'], None, None,
                                   (2, ))
        partial = functools.partial(test_function_for_partial1, kwarg1=0)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        expected = inspect.ArgSpec(['arg1', 'arg2', 'kwarg1'], None, None,
                                   (1, ))
        partial = functools.partial(test_function_for_partial1, kwarg2=0)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        expected = inspect.ArgSpec(['arg1'], None, None, ())
        partial = functools.partial(test_function_for_partial1,
                                    arg2=0,
                                    kwarg1=0,
                                    kwarg2=0)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        # Make sure *args, *kwargs is accounted for.
        expected = inspect.ArgSpec([], 'my_args', 'my_kwargs', ())
        partial = functools.partial(test_function_for_partial2, 0, 1)
        self.assertEqual(expected, parser._get_arg_spec(partial))
Example #2
0
  def test_argspec_for_functools_partial(self):

    # pylint: disable=unused-argument
    def test_function_for_partial1(arg1, arg2, kwarg1=1, kwarg2=2):
      pass

    def test_function_for_partial2(arg1, arg2, *my_args, **my_kwargs):
      pass
    # pylint: enable=unused-argument

    # pylint: disable=protected-access
    # Make sure everything works for regular functions.
    expected = tf_inspect.ArgSpec(['arg1', 'arg2', 'kwarg1', 'kwarg2'], None,
                                  None, (1, 2))
    self.assertEqual(expected, parser._get_arg_spec(test_function_for_partial1))

    # Make sure doing nothing works.
    expected = tf_inspect.ArgSpec(['arg1', 'arg2', 'kwarg1', 'kwarg2'], None,
                                  None, (1, 2))
    partial = functools.partial(test_function_for_partial1)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    # Make sure setting args from the front works.
    expected = tf_inspect.ArgSpec(['arg2', 'kwarg1', 'kwarg2'], None, None,
                                  (1, 2))
    partial = functools.partial(test_function_for_partial1, 1)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    expected = tf_inspect.ArgSpec(['kwarg2',], None, None, (2,))
    partial = functools.partial(test_function_for_partial1, 1, 2, 3)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    # Make sure setting kwargs works.
    expected = tf_inspect.ArgSpec(['arg1', 'arg2', 'kwarg2'], None, None, (2,))
    partial = functools.partial(test_function_for_partial1, kwarg1=0)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    expected = tf_inspect.ArgSpec(['arg1', 'arg2', 'kwarg1'], None, None, (1,))
    partial = functools.partial(test_function_for_partial1, kwarg2=0)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    expected = tf_inspect.ArgSpec(['arg1'], None, None, ())
    partial = functools.partial(test_function_for_partial1,
                                arg2=0, kwarg1=0, kwarg2=0)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    # Make sure *args, *kwargs is accounted for.
    expected = tf_inspect.ArgSpec([], 'my_args', 'my_kwargs', ())
    partial = functools.partial(test_function_for_partial2, 0, 1)
    self.assertEqual(expected, parser._get_arg_spec(partial))
Example #3
0
    def test_argspec_for_functools_partial(self):
        # pylint: disable=unused-argument
        def test_function_for_partial1(arg1, arg2, kwarg1=1, kwarg2=2):
            pass

        def test_function_for_partial2(arg1, arg2, *my_args, **my_kwargs):
            pass

        # pylint: enable=unused-argument

        # pylint: disable=protected-access
        # Make sure everything works for regular functions.
        expected = tf_inspect.FullArgSpec(
            args=['arg1', 'arg2', 'kwarg1', 'kwarg2'],
            varargs=None,
            varkw=None,
            defaults=(1, 2),
            kwonlyargs=[],
            kwonlydefaults=None,
            annotations={})
        self.assertEqual(expected,
                         parser._get_arg_spec(test_function_for_partial1))

        # Make sure doing nothing works.
        expected = tf_inspect.FullArgSpec(
            args=['arg1', 'arg2', 'kwarg1', 'kwarg2'],
            varargs=None,
            varkw=None,
            defaults=(1, 2),
            kwonlyargs=[],
            kwonlydefaults=None,
            annotations={})
        partial = functools.partial(test_function_for_partial1)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        # Make sure setting args from the front works.
        expected = tf_inspect.FullArgSpec(args=['arg2', 'kwarg1', 'kwarg2'],
                                          varargs=None,
                                          varkw=None,
                                          defaults=(1, 2),
                                          kwonlyargs=[],
                                          kwonlydefaults=None,
                                          annotations={})
        partial = functools.partial(test_function_for_partial1, 1)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        expected = tf_inspect.FullArgSpec(args=['kwarg2'],
                                          varargs=None,
                                          varkw=None,
                                          defaults=(2, ),
                                          kwonlyargs=[],
                                          kwonlydefaults=None,
                                          annotations={})
        partial = functools.partial(test_function_for_partial1, 1, 2, 3)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        # Make sure setting kwargs works.
        expected = tf_inspect.FullArgSpec(args=['arg1', 'arg2', 'kwarg2'],
                                          varargs=None,
                                          varkw=None,
                                          defaults=(2, ),
                                          kwonlyargs=[],
                                          kwonlydefaults=None,
                                          annotations={})
        partial = functools.partial(test_function_for_partial1, kwarg1=0)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        expected = tf_inspect.FullArgSpec(args=['arg1', 'arg2', 'kwarg1'],
                                          varargs=None,
                                          varkw=None,
                                          defaults=(1, ),
                                          kwonlyargs=[],
                                          kwonlydefaults=None,
                                          annotations={})
        partial = functools.partial(test_function_for_partial1, kwarg2=0)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        expected = tf_inspect.FullArgSpec(args=['arg1'],
                                          varargs=None,
                                          varkw=None,
                                          defaults=(),
                                          kwonlyargs=[],
                                          kwonlydefaults=None,
                                          annotations={})
        partial = functools.partial(test_function_for_partial1,
                                    arg2=0,
                                    kwarg1=0,
                                    kwarg2=0)
        self.assertEqual(expected, parser._get_arg_spec(partial))

        # Make sure *args, *kwargs is accounted for.
        expected = tf_inspect.FullArgSpec(args=[],
                                          varargs='my_args',
                                          varkw='my_kwargs',
                                          defaults=(),
                                          kwonlyargs=[],
                                          kwonlydefaults=None,
                                          annotations={})
        partial = functools.partial(test_function_for_partial2, 0, 1)
        self.assertEqual(expected, parser._get_arg_spec(partial))
Example #4
0
  def test_argspec_for_functools_partial(self):
    # pylint: disable=unused-argument
    def test_function_for_partial1(arg1, arg2, kwarg1=1, kwarg2=2):
      pass

    def test_function_for_partial2(arg1, arg2, *my_args, **my_kwargs):
      pass
    # pylint: enable=unused-argument

    # pylint: disable=protected-access
    # Make sure everything works for regular functions.
    expected = tf_inspect.FullArgSpec(
        args=['arg1', 'arg2', 'kwarg1', 'kwarg2'],
        varargs=None,
        varkw=None,
        defaults=(1, 2),
        kwonlyargs=[],
        kwonlydefaults=None,
        annotations={})
    self.assertEqual(expected, parser._get_arg_spec(test_function_for_partial1))

    # Make sure doing nothing works.
    expected = tf_inspect.FullArgSpec(
        args=['arg1', 'arg2', 'kwarg1', 'kwarg2'],
        varargs=None,
        varkw=None,
        defaults=(1, 2),
        kwonlyargs=[],
        kwonlydefaults=None,
        annotations={})
    partial = functools.partial(test_function_for_partial1)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    # Make sure setting args from the front works.
    expected = tf_inspect.FullArgSpec(
        args=['arg2', 'kwarg1', 'kwarg2'],
        varargs=None,
        varkw=None,
        defaults=(1, 2),
        kwonlyargs=[],
        kwonlydefaults=None,
        annotations={})
    partial = functools.partial(test_function_for_partial1, 1)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    expected = tf_inspect.FullArgSpec(
        args=['kwarg2'],
        varargs=None,
        varkw=None,
        defaults=(2,),
        kwonlyargs=[],
        kwonlydefaults=None,
        annotations={})
    partial = functools.partial(test_function_for_partial1, 1, 2, 3)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    # Make sure setting kwargs works.
    expected = tf_inspect.FullArgSpec(
        args=['arg1', 'arg2', 'kwarg2'],
        varargs=None,
        varkw=None,
        defaults=(2,),
        kwonlyargs=[],
        kwonlydefaults=None,
        annotations={})
    partial = functools.partial(test_function_for_partial1, kwarg1=0)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    expected = tf_inspect.FullArgSpec(
        args=['arg1', 'arg2', 'kwarg1'],
        varargs=None,
        varkw=None,
        defaults=(1,),
        kwonlyargs=[],
        kwonlydefaults=None,
        annotations={})
    partial = functools.partial(test_function_for_partial1, kwarg2=0)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    expected = tf_inspect.FullArgSpec(
        args=['arg1'],
        varargs=None,
        varkw=None,
        defaults=(),
        kwonlyargs=[],
        kwonlydefaults=None,
        annotations={})
    partial = functools.partial(test_function_for_partial1,
                                arg2=0, kwarg1=0, kwarg2=0)
    self.assertEqual(expected, parser._get_arg_spec(partial))

    # Make sure *args, *kwargs is accounted for.
    expected = tf_inspect.FullArgSpec(
        args=[],
        varargs='my_args',
        varkw='my_kwargs',
        defaults=(),
        kwonlyargs=[],
        kwonlydefaults=None,
        annotations={})
    partial = functools.partial(test_function_for_partial2, 0, 1)
    self.assertEqual(expected, parser._get_arg_spec(partial))