Process __signature__ on callable objects if available.

[exhuma]

Python allows assigning to function.__signature__ to override the default signature for documentation and introspection. This is hugely useful for delegates. For example consider the following code:

import logging

def my_function(a: int, b: str = '') -> bool:
    print(a * b)
    return True

def logged(*args, **kwargs):
    logging.debug("calling my_function")
    my_function(*args, **kwargs)

logged now has no helpful signature. It only has *args, **kwargs making its usage a bit more cumbersome. But by simply adding the following remedies that:

import inspect

logged.__signature__ = inspect.signature(my_function)

Running natice tools like pydoc, python3 -m pydoc or the builtin function help(logged) shows that this works and is helpful.

Unfortunately, the VS-Code extension currently does not make use of this, so the code-insight is less useful than it could be.

[brettcannon]

I believe you're asking for hover details to take into account __signature__. In that case I will move this to the Pylance repo, but do note this is extremely hard to implement as it essentially requires executing arbitrary Python code to know which this has occurred.

[jakebailey]

Yeah, this is dynamic behavior that I don't think we're going to understand. You can obtain some of this with ParamSpec or maybe functools wrap; I wouldn't recommend doing something like this, personally...

[exhuma]

I wasn't aware of ParamSpec yet. After reading this, this seems like fits this problem like a glove. Incidentally, PEP-612 even uses the "logging" example except with a decorator. But the discussed issue is the same.

My initial research which brought me to __signature__ was done to find a solution to keep hover-details available even for decorators/delegators.

I am unfortunately not yet able to test Python 3.10 but I will keep this in the back of my mind.

I will see if I can set up a 3.10 environment and give this a go.

Is ParamSpec already supported by Pylance? And yes, Pylance would make a better home for this discussion. Should I open a new one? Or can the thread be moved in its entirety?

[erictraut]

Yes, PEP 612 is fully supported in Pylance. It's also supported in the latest versions of the typing_extensions library, so you should be able to use it in versions of Python older than 3.10.

[exhuma]

I had a deeper look into this. And while ParamSpec does not solve my problem at hand (or at least I can't figure out how), I think the usage of ParamSpec solves most issues, making my original idea concerning __signature__ less of an improvment.

ParamSpec also doesn't require the use of a dunder argument which I like more.

I still see a use for both (ParamSpec for type-checking, __signature__ for introspection/documentation) but considering that __signature__ only works at runtime and is thus really really hard (and risky) for the IDE to process I'm fine with closing this issue.

Unless someone else wants to keep it open for further discussion. But I consider my "need" to be addressed.

Thank you for pointing me to ParamSpec. It will give me many more areas to improve my type checking.

[exhuma]

... for reference, I currenlty have the following in my code-base (simplified):

class Wrapper:

    def __init__(self, token):
        self.token = token

    def request(self, *args, force_basic_auth=False, **kwargs):
        # <inject token into kwargs["headers"]>
        return requests.request(*args, **kwargs)

    def get(self, *args, **kwargs):
        return self.request("GET", *args, **kwargs)

I used a Generic with ParamSpec and adding a callable to __init__ which sort-of works:

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

class Wrapper(Generic[P, R]):

    def __init__(self, request: Callable[P, R], token):
        self.token = token
        self._request = request

    def request(self, *args: P.args, force_basic_auth=False, **kwargs: P.kwargs) -> R:
        <inject token into kwargs["headers"]>
        return self._request(*args, **kwargs)

    def get(self, *args: P.args, **kwargs: P.kwargs) -> R:
        return self.request("GET", *args, **kwargs)

But it does not properly type check the force_basic_auth argument in Wrapper.request. It also gives the wrong hover-info on Wrapper.get because using P.args there is wrong becuase the first argument is "pinned".

But this is more of a typing question in general and is off-topic in this discussion. I will accept (for now) that I won't have hover-info and type-checks on this.