How to make pyright not raise an error when using decorators that add additional function arguments?

[vamshiaruru-virgodesigns]

Hi all, I am very new to using type right, so pardon me if it is something obvious. I have a decorator like this:

def inject_client(url=None, auth_token=None):
    def wrap(function):
        @functools.wraps(function)
        async def wrapper(*args, **kwargs):
            async with Client(url, auth_token) as client:
                return await function(client=client, *args, **kwargs)

        return wrapper

    return wrap

and I use it like this:

@inject_client()
async def create_resources(
        param1: str, param2: str, client: "GraphqlClient"
) -> Any:
    pass
    
await create_resource(param1, param2)

and it works.
But pyright says this:

Argument missing for parameter "client"Pylance[reportGeneralTypeIssues](https://github.com/microsoft/pylance-release/blob/main/DIAGNOSTIC_SEVERITY_RULES.md#diagnostic-severity-rules)

Is there anyway to let pyright know that a decorator has added that parameter already? Or is there a work around or something?
TIA

[erictraut]

There is currently no way in the Python type system to indicate that a decorator removes or adds a keyword argument.

There is a way to indicate that positional arguments are prepended to (or removed from) the beginning of a parameter list using PEP 612's ParamSpec and Concatenate.

from typing import Any, Concatenate, ParamSpec, TypeVar

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

class Client: ...

def inject_client(
    url=None, auth_token=None
) -> Callable[[Callable[Concatenate[Client, P], R]], Callable[P, R]]:
    ...

@inject_client()
async def create_resources(client: Client, param1: str, param2: str) -> Any:
    pass

create_resources(param1, param2)

(For future inquiries, it's useful if you provide a self-contained and minimal code sample — one that doesn't refer to symbols outside of the sample.)

[vamshiaruru-virgodesigns]

Hi! Thank you for the response. Your type annotation works, but I noticed that it stopped working when the decorator is used in instance methods. So I added an overload like so:

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

@overload
def inject_client() -> Callable[[Callable[Concatenate[Self, Client, P], R]], Callable[P, R]]:
    ...

Now there is no error when defining the function itself. However, when using it, I get the following error.

class Test:
    @inject_client()
    def test(self, client: "Client", param1: str):
        return None

    def call(self):
        return self.test(param1)

and the error:

Could not bind method "(unnamed)" because "Test" is not assignable to parameter "param1"
  "Test" is incompatible with "str"

I am unable to figure out why this is happening.

As an addendum to this, if someone wants to define a function like this:

@inject_client
def test(param1, param2, *, client: Client):
  ...

The annotation would fail again. How would I handle that?

Thanks for the help :)

[erictraut]

Once again, it's really helpful if you can provide self-contained samples so I don't need to cobble together a working sample from various snippets.

Yeah, ParamSpec doesn't work well when used with regular functions and instance methods. This is a known limitation, and it's difficult to work around. You can define separate decorators for each purpose.

Incidentally, if you have general Python typing questions like this (as opposed to pyright-specific questions), the python/typing forum is a better place to ask. That way, you can draw upon the broader Python typing community, and everyone benefits from the answers.

from collections.abc import Callable
from typing import Any, Concatenate, ParamSpec, TypeVar, overload

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

class Client:
    ...

def inject_client() -> Callable[[Callable[Concatenate[Client, P], R]], Callable[P, R]]:
    ...

def inject_client_method() -> Callable[
    [Callable[Concatenate[Self, Client, P], R]], Callable[Concatenate[Self, P], R]
]:
    ...

@inject_client()
async def create_resources(client: Client, param1: str, param2: str) -> Any:
    pass

class Test:
    @inject_client_method()
    def test(self, client: "Client", param1: str):
        return None

    def call(self):
        return self.test("")

[vamshiaruru-virgodesigns]

Sorry about not providing self contained examples. That slipped my mind completely.
Thank you for your time, I'll checkout the typing discussions as well since it seems like this isn't about pyright anymore.