Misunderstanding wrapping functions that use Self@Class

[elGatoMantocko]

I have a convenience wrapper in my codebase that does some introspection on self, but I'm getting an unexpected type error as of pyright@1.1.338 (python@3.10).

---

Consider the following code.

"""Test pyright@1.1.338 with functools.wraps."""

from collections.abc import Callable
from functools import wraps
from typing import Concatenate, ParamSpec, TypeAlias, TypeVar

from typing_extensions import Self

T = TypeVar("T")
P = ParamSpec("P")
GreeterMethod: TypeAlias = Callable[Concatenate["Greeter", P], T]


def decorator(func: GreeterMethod[P, T]) -> GreeterMethod[P, T]:
    """Decorator func."""

    @wraps(func)
    def wrapper(self: Greeter, *args: P.args, **kwargs: P.kwargs) -> T:
        # do something with `self.foo`
        return func(self, *args, **kwargs)

    return wrapper


class Greeter:
    """A dummy class."""

    @property
    def foo(self: Self) -> str:
        """Get some data."""
        ...

    @decorator
    def hello_world(self) -> None:
        """A `hello_world` func that requires some check of `foo` first."""
        ...

Before 1.1.338, this passed our typechecks, but now I'm getting a type error.

./test_self_wrapper.py
  ./test_self_wrapper.py:33:6 - error: Argument of type "(self: Self@Greeter) -> None" cannot be assigned to parameter "func" of type "GreeterMethod[P@decorator, T@decorator]" in function "decorator"
    Type "(self: Self@Greeter) -> None" cannot be assigned to type "GreeterMethod[P@decorator, T@decorator]"
      Parameter 1: type "Greeter" cannot be assigned to type "Self@Greeter"
        Type "Greeter" cannot be assigned to type "Self@Greeter" (reportGeneralTypeIssues)
1 error, 0 warnings, 0 informations

---

It seems that this new error could be related to the following that I noticed in the 1.1.338 release notes.

Fixed bug that produces a false negative when attempting to assign a method to a Callable type where the first parameter of the method is typed as Self, but the callback requires the class itself.

I think I understand why this is an error - because there is no guarantee that the self parameter is an instance of a Greeter, it could be a sub-class or something else that is not covariant.

However, this code does do what I expect at runtime, so what I don't know or understand is the right way to type this decorator so that it knows how to access class Greeter's properties.

Any help would be much appreciated! Thanks!

[erictraut]

Your understanding of the error is correct. The pre-decorated method is not expecting to receive a Greeter for the self parameter; it's expecting to receive an appropriate subtype of Greeter. If you were to create a subclass of Greeter called SpecialGreeter, then the self parameter must receive a SpecialGreeter instance, but your decorator type indicates that it's allowed to call the callable with any Greeter instance. The decorator wrapper could therefore violate the assumptions of the decorated function.

I see a couple of straightforward ways to fix this. The first is to use Any rather than Greeter in your definition of GreeterMethod. This admittedly removes some type safety and would allow you to apply your decorator to methods in classes other than Greeter, but that's probably not a likely coding error.

GreeterMethod: TypeAlias = Callable[Concatenate[Any, P], T]

If you want to protect against that coding error, you could define GreeterMethod with another type variable that has an upper bound of Greeter.

G = TypeVar("G", bound="Greeter")
GreeterMethod: TypeAlias = Callable[Concatenate[G, P], T]

def decorator(func: GreeterMethod[G, P, T]) -> GreeterMethod[G, P, T]:
    ...

This will preserve the Self@Greeter type associated with the self parameter.

[elGatoMantocko]

Thank you so much! That's exactly what I was looking for!