Hello,

I have a function which has no parameters other than kwargs which are to be passed onto a third party library call.

Here is a simplified example

def third_party_func(*, a: int, b: int):
    return 1.0

def run(**kwargs):
    return third_party_func(**kwargs)

I'd like to type kwargs so I can get both completion suggestions and better safety. I could create a TypedDict with all the parameters of the function call but that potentially breaks whenever the 3rd party is updated.

What I'd like to do is have a type checker consider the function signature of one function as the same as another.

Given I'm just passing the parameters through from one function to another, I considered pretending my function is akin to a decorator, so I could somehow use Paramspec to capture the kwargs of the function and pass them along

Something like the following:

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

# 3rd party function I have no control over
def third_party_func(*, a: int, b: int):
    return 1.0

# Function wrappers to capture parameters and pass through
def wrapper(f: Callable[P, R]) -> Callable[..., Callable[P, R]]:
    def inner(e: Callable[P, R]) -> Callable[P, R]:
        def inside(*args: P.args, **kwargs: P.kwargs) -> R:
            return e(*args, **kwargs)
        return inside
    return inner

# Capture parameters of third_party_func
wrapped = wrapper(third_party_func)

# Decorate run function with wrapped
@wrapped
def run(**kwargs: Any):
    return third_party_func(**kwargs)

reveal_type(wrapped)
# mypy: Revealed type is "def (*Any, **Any) -> def (*, a: builtins.int, b: builtins.int) -> Any"
# pyright: Type of "wrapped" is "(...) -> ((*, a: int, b: int) -> float)"

reveal_type(run)
# mypy: Revealed type is "def (*, a: builtins.int, b: builtins.int) -> Any"
# pyright: Type of "wrapped_run" is "(*, a: int, b: int) -> float"

This "works" in so far as I can get completions (in vscode) and if I purely rely on my wrapped_run I should get warnings. But kwargs is still untyped (it be a dict[str, Any]) and I feel this isn't the intention of Paramspec and I'm risking this breaking in the future. Also, the fact mypy can't infer the return type (even with --new-type-inference) makes me think I'm on the wrong track.

I also thought over if I could use Unpack but you can't unpack P.kwargs nor can I find a way to statically create a TypedDict from a function signature.

Is there another way to accomplish this?