Support a method of copying function signature

[KotlinIsland]

Feature
Capability to copy a functions signature, related to typing.ParamSpec.

def foo(a: str) -> None:
    ...


# pseudo code
def bar(*args: foo.args, **kwargs: foo.kwargs) -> foo.return_type:
    return foo(*args, **kwargs)

Pitch
If I want to forward a call to another method in a type safe way it requires duplicating type definitions which can rapidly become unwieldy and error prone(especially if the function is in a third party module). I would love a way to just say that one functions signature is the same as another functions signature (with support for typing.Concatenate)

Maybe

extend functionality of ParamSpec to be generic to a Callable?

def bar(*args: ParamSpec[foo].args, **kwargs: ParamSpec[foo].kwargs) -> None:
    return foo(*args, **kwargs)

• basedmypy Functionality to copy and enforce signatures of function declarations KotlinIsland/basedmypy#257

[erictraut]

Perhaps one of these approaches would meet your needs using the existing functionality?

from typing import Callable, TypeVar
from typing_extensions import ParamSpec

P = ParamSpec("P")
R = TypeVar("R")

def foo(a: str) -> None:
    ...

def wrap_func(fn: Callable[P, R]) -> Callable[P, R]:
    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
        # Add code here as desired
        return fn(*args, **kwargs)
    return inner

bar = wrap_func(foo)

Or if you want to externalize the wrapper logic, wrap_func could take a wrapper function as an input parameter:

def wrap_func(
    wrapper: Callable[Concatenate[Callable[P, R], P], R], fn: Callable[P, R]
) -> Callable[P, R]:
    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
        return wrapper(fn, *args, **kwargs)
    return inner

def bar_wrapper(fn: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
    # Add code here as desired
    return fn(*args, *kwargs)

bar = wrap_func(bar_wrapper, foo)

[indigoviolet]

Both approaches above require passing the wrapped function fn or foo as an argument to the wrapping function. But a fairly common case is writing a particular function that invokes another function (say from a library, to create slightly better ergonomics or specialize some arguments). In that case, there doesn't appear to be a DRY method to describe the wrapper function's signature in terms of the wrapped function's signature (+/- some params).

See also #13617, #2003

[ligix]

Or if you want to externalize the wrapper logic, wrap_func could take a wrapper function as an input parameter:

def wrap_func(
    wrapper: Callable[Concatenate[Callable[P, R], P], R], fn: Callable[P, R]
) -> Callable[P, R]:
    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
        return wrapper(fn, *args, **kwargs)
    return inner

def bar_wrapper(fn: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
    # Add code here as desired
    return fn(*args, *kwargs)

bar = wrap_func(bar_wrapper, foo)

A slightly different version that works as a decorator:

def wraps_function(
    fun: Callable[P, T]
) -> Callable[[Callable[Concatenate[Callable[P, T], P], T]], Callable[P, T]]:
    def decorator(
        wrapper: Callable[Concatenate[Callable[P, T], P], T]
    ) -> Callable[P, T]:
        def decorated(*args: P.args, **kwargs: P.kwargs) -> T:
            return wrapper(fun, *args, **kwargs)
        return decorated
    return decorator

@wraps_function(myfun)
def bar(myfun: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
    # Add code here as desired
    return myfun(*args, **kwargs)