Python inspect.Signature from typing.Callable

Question

How can I convert a typing.Callable type hint into a inspect.Signature function signature object?

Use case

Let's say I have a custom type hint for a function signature hint :

hint = typing.Callable[[int], float]

I want to use it both for type hinting as well as finding functions which conform to the signature of hint . To achieve the latter, I could compare inspect.Signature objects from the functions in question to hint if I had a way of converting the type hint into a signature.

Answer 1

This is an interesting question. I think there are two possible approaches, one of which I would recommend.

Construct Signature from Callable

This is possible, but I would not recommend this.

The problem is that the Callable annotation contains only a subset of the information that a Signature object can hold. Information not available on a specified Callable type includes:

1. Parameter names
2. Parameter kinds (eg positional only or keyword-only etc.)
3. Default values

This means you have to make a lot of arbitrary choices, when you construct a Parameter from a type.

Here is an example implementation:

from collections.abc import Callable
from inspect import Parameter, Signature, signature
from typing import get_args


def callable_type_to_signature(callable_type: type) -> Signature:
    params, ret = get_args(callable_type)
    params = [
        Parameter(f"arg{i}", Parameter.POSITIONAL_ONLY, annotation=param)
        for i, param in enumerate(params)
    ]
    return Signature(params, return_annotation=ret)


def foo(x: int, y: str, z: dict[str, bool]) -> float:
    return NotImplemented


if __name__ == '__main__':
    hint_foo = Callable[[int, str, dict[str, bool]], float]
    sig = callable_type_to_signature(hint_foo)
    print(sig)
    print(signature(foo))

Output:

(arg0: int, arg1: str, arg2: dict[str, bool], /) -> float
(x: int, y: str, z: dict[str, bool]) -> float

Notice that I chose to define all parameters as positional only and give them all names like argX .

You could still use this to compare some function signatures with the output of this callable_type_to_signature , but you would have to take care to not compare apples to oranges.

I think there is a better way.

Compare Signature to Callable

Since you wanted to compare signatures to type hints anyway, I think you don't need that extra step of creating another "fake" Signature . We can try and compare the two objects directly. Here is a working example:

from collections.abc import Callable
from inspect import Parameter, Signature, signature
from typing import get_args, get_origin


def param_matches_type_hint(
    param: Parameter,
    type_hint: type,
    strict: bool = False,
) -> bool:
    """
    Returns `True` if the parameter annotation matches the type hint.

    For this to be the case:
    In `strict` mode, both must be exactly equal.
    If both are specified generic types, they must be exactly equal.
    If the parameter annotation is a specified generic type and
    the type hint is an unspecified generic type,
    the parameter type's origin must be that generic type.
    """
    param_origin = get_origin(param.annotation)
    type_hint_origin = get_origin(type_hint)
    if (
        strict or
        (param_origin is None and type_hint_origin is None) or
        (param_origin is not None and type_hint_origin is not None)
    ):
        return param.annotation == type_hint
    if param_origin is None and type_hint_origin is not None:
        return False
    return param_origin == type_hint


def signature_matches_type_hint(
    sig: Signature,
    type_hint: type,
    strict: bool = False,
) -> bool:
    """
    Returns `True` if the function signature and `Callable` type hint match.

    For details about parameter comparison, see `param_matches_type_hint`.
    """
    if get_origin(type_hint) != Callable:
        raise TypeError("type_hint must be a `Callable` type")
    type_params, return_type = get_args(type_hint)
    if sig.return_annotation != return_type:
        return False
    if len(sig.parameters) != len(type_params):
        return False
    return all(
        param_matches_type_hint(sig_param, type_param, strict=strict)
        for sig_param, type_param
        in zip(sig.parameters.values(), type_params)
    )


def foo(x: int, y: str, z: dict[str, bool]) -> float:
    return NotImplemented


def bar(x: dict[str, int]) -> bool:
    return NotImplemented


def baz(x: list) -> bool:
    return NotImplemented


if __name__ == '__main__':
    hint_foo = Callable[[int, str, dict], float]
    hint_bar = Callable[[dict], bool]
    hint_baz = Callable[[list[str]], bool]
    print(signature_matches_type_hint(signature(foo), hint_foo))
    print(signature_matches_type_hint(signature(bar), hint_bar))
    print(signature_matches_type_hint(signature(baz), hint_baz))
    print(signature_matches_type_hint(signature(bar), hint_bar, strict=True))

Output:

True
True
False
False

Details and caveats :

This is a rather simplistic implementation. For one thing, it doesn't handle more "exotic" signatures, such as those that contain arbitrary keyword arguments ( **kwargs ). It is not entirely clear how that should be annotated anyway.

This assumes that a more general function signature like that of baz is not compatible with the more specific type hint hint_baz . The other way around however, the more specific function signature like that of bar is compatible with the more general type hint hint_bar .

If you only want exact matches regarding types, you can use strict=True .

Hope this helps a bit and puts you on the right track. Maybe if I find the time, I'll try to extend this and test it a bit.