Is there a way to check a function's signature in Python?

Question

I'm looking for a way to check the number of arguments that a given function takes in Python. The purpose is to achieve a more robust method of patching my classes for tests. So, I want to do something like this:

class MyClass (object):
    def my_function(self, arg1, arg2):
        result = ... # Something complicated
        return result

def patch(object, func_name, replacement_func):
    import new

    orig_func = getattr(object, func_name)
    replacement_func = new.instancemethod(replacement_func, 
                           object, object.__class__)

    # ...
    # Verify that orig_func and replacement_func have the 
    # same signature.  If not, raise an error.
    # ...

    setattr(object, func_name, replacement_func)

my_patched_object = MyClass()
patch(my_patched_object, "my_function", lambda self, arg1: "dummy result")
# The above line should raise an error!

Thanks.

Answer 1

inspect.getargspec is deprecated in Python 3. Consider something like:

import inspect
len(inspect.signature(foo).parameters)

This will include args and kwargs as one parameter, each.

If you don't want to include args and kwargs, consider:

len(inspect.getfullargspec(foo)[0])

Answer 2

You can use:

import inspect
len(inspect.getargspec(foo_func)[0])

This won't acknowledge variable-length parameters, like:

def foo(a, b, *args, **kwargs):
    pass

Answer 3

You should use inspect.getargspec.

Answer 4

The inspect module allows you to examine a function's arguments. This has been asked a few times on Stack Overflow; try searching for some of those answers. For example:

Getting method parameter names in python

Answer 5

Using the accepted answer you can even construct the entire type like this:

import inspect
from typing import Callable, Any, Type, List

def ftype(func: Callable[[Any], Any]) -> Type[Callable[[Any], Any]]:
    assert callable(func)
    ret = inspect.signature(func).return_annotation
    params = list(inspect.signature(func).parameters.values())
    param_types: List[Type[Any]] = [param.annotation for param in params]
    return Callable[[*param_types], ret]

In your code you can then check the type with the is keyword like this:

def equal_strings(text1: str, text2: str) -> bool:
    return text1 == text2

# ...

>>> my_fuction is Callable[[str, str], bool] 
True

>>> ftype(equal_strings)
typing.Callable[[str, str], bool]

However mypy doesn't like any of this, which is probably what lead you here in the first place.

I just thought this piece of magic was interesting

Answer 6

I have written my own small library that solves this problem with less client code, it's called sigmatch.

Install it:

pip install sigmatch

And use:

from sigmatch import SignatureMatcher

def function(a, b, c=5, *d, **e):
    ...

matcher = SignatureMatcher('.', '.', 'c', '*', '**')
print(matcher.match(function))  # True

In this example, the expected parameters of the function are fixed in the SignatureMatcher object, and the match() method checks the function for compliance with them. That's what the SignatureMatcher initialization parameters mean:

• "." - corresponds to an ordinary positional arguments without a default value.
• "some_argument_name" - corresponds to an argument with a default value. The content of the string is the name of the argument.
• "*" - corresponds to packing multiple positional arguments without default values (*args).
• "**" - corresponds to packing several named arguments with default values (**kwargs).