Scoped alias with Self

[benoitLemoine]

Upgrading to Python3.11 recently, I gave Self a try. I defined a scoped alias using Self (see code snippet).

With python on version 3.11.7 and mypy on 1.7.1, mypy gave me the following error :

error: Self type cannot be used in type alias target

So I took a look to the PEP defining Self (https://peps.python.org/pep-0673/), but aside of forbidding all aliases containing Self, I found no reason to prevent scoped aliases using Self.
Is there a reason for preventing such case or is it a side effect of banning aliases with Self ?

I do some search on similar discussions, but I found nothing related (#1526 is close but not quite the same).

Here is the code snippet

from typing import Dict, Callable, Self


class Foo:
    VisitorFn = Callable[[Self], "Foo"] # <--- mypy raise the same error here
    _visitors: Dict[str, VisitorFn] = {}

    def __init_subclass__(cls) -> None:
        cls._visitors = {}

    @classmethod
    def register(cls, name: str) -> Callable[[VisitorFn], VisitorFn]:
        def inner_register(fn: Foo.VisitorFn) -> Foo.VisitorFn:
            cls._visitors[name] = fn
            return fn

        return inner_register

    @classmethod
    def visitors(cls) -> Dict[str, VisitorFn]:
        return cls._visitors


class Bar1(Foo):
    ...


class Bar2(Foo):
    ...


class Bar3(Bar1):
    ...


@Bar1.register("visitor_bar1")
def visitor_bar1(bar: Bar1) -> Bar2:  # this should work
    return Bar2()


@Bar2.register("visitor_bar2")
def visitor_bar2(bar: Bar2) -> Bar1:  # this should work
    return Bar1()


@Bar1.register("wrong_visitor_bar1")  # this should not work as Bar2 is not a parent class of Bar1
def wrong_visitor_bar1(bar: Bar2) -> Bar1:
    return Bar1()


@Bar3.register("inherited_visitor_bar3")  # this should work
def inherited_visitor_bar3(bar: Bar1) -> Bar2:
    return Bar2()

[erictraut]

You can think of Self as a type variable scoped to the class. Just as it's illegal to define a type alias that uses a class-scoped type variable, it's illegal to define a type alias using Self.

class Bar(Generic[T]):
    MyAlias1: TypeAlias = list[T]  # Not allowed because T is a TypeVar bound to the class scope
    MyAlias2: TypeAlias = list[Self]  # Similarly not allowed because Self is a TypeVar bound to the class scope

If you want to define a generic type alias within your class, it needs to use its own type variable. Here's a modified version of your code sample that shows how this might work.

from typing import Callable, Self, TypeVar, TypeAlias

T = TypeVar("T")

class Foo:
    VisitorFn: TypeAlias = Callable[[T], "Foo"]
    _visitors: dict[str, VisitorFn] = {}

    def __init_subclass__(cls) -> None:
        cls._visitors = {}

    @classmethod
    def register(cls, name: str) -> Callable[[VisitorFn[Self]], VisitorFn[Self]]:
        def inner_register(fn: Foo.VisitorFn[Self]) -> Foo.VisitorFn[Self]:
            cls._visitors[name] = fn
            return fn

        return inner_register

    @classmethod
    def visitors(cls) -> dict[str, VisitorFn[Self]]:
        return cls._visitors

Or if you're using Python 3.12, you can use the new PEP 695 syntax:

class Foo:
    type VisitorFn[T] = Callable[[T], "Foo"]
    ...

[benoitLemoine]

Looking at your answer, I just found out I missed to explain another need of my code ...

I chose to define VisitorFn as :

class Foo:
    VisitorFn = Callable[[Self], "Foo"]

in order to reference it later, for instance :

@dataclass
class FooPipeline:
    steps: List[Foo.VisitorFn]

With your answer, this code become :

@dataclass
class FooPipeline:
    steps: List[Foo.VisitorFn[Foo]]

which is, i think, a bit clunkier.

I really though defining a scoped alias with Self would be well-defined outside the scope of its defining class, as the alias is tied to its class, thus I see no reason to make it illegal.
In my case, I don't want VisitorFn of Foo being anything else than Foo.VisitorFn[Foo]. That's why I though using Self could be a good idea, alleviating subclassing aswell.