Accessing the type of an argument at a specific position in a callback

[guacs]

Consider the following:

T = TypeVar("T")


def register(
    callback: Callable[[Connection, Channel, T], Coroutine[None, None, None] | None],
) -> None:
    # Parse the paylod_type.
    # I'm not sure if iterating over the dictionary returned by `get_type_hints` is guaranteed to return
    # the argument name and annotation in the order they are defined in the callback, but it is working for
    # now. This should be confirmed.
    values = list(get_type_hints(callback).values())
    payload_type: type[T] = values[2]

If I want to access the type hint of the third argument within the given callback, is this the correct way to do it?

Another way I had considered was using inspect.signature(callback).parameters. While this guarantees that the order of the parameters is in the same order as the definition of the arguments, the problem is that the returned Parameter doesn't resolve the annotation or strip it of the extra args if it's Annotated.

[Daverball]

It's also worth noting that Callable is too broad of a Protocol for typing.get_type_hints, since it also accepts lambdas (which don't have annotations) and any object that implements __call__ including type, which is also a valid argument for get_type_hints, but at that point you would be inspecting the attributes of the class and not the parameters of the __init__/__new__ method.

So you would need to use inspect.signature anyways to properly handle all the different kinds of callables with reasonable certainty, that you didn't miss some kind of corner case. There's some internal functions in the typing module that can give you an idea how to deal with things like Annotated and forward references within the annotations.

[guacs]

Oh I hadn't considered that point about lambdas. Thanks for pointing that out!