Allowing TypeAlias in ClassVar?

[tmke8]

There was previously a discussion on whether TypeAliases should be allowed within classes. The consensus was to allow this, and indeed the following works fine with mypy and pyright (I haven't checked other type checkers):

from typing import TypeAlias, List

class A:
    T: TypeAlias = List

    def __init__(self, xs: T):
        self.xs = xs

However, this doesn't work in dataclasses, because the dataclass thinks the type alias is a field (because it has a type annotation that is not ClassVar).

So, an obvious idea would be to wrap TypeAlias in ClassVar:

from dataclasses import dataclass
from enum import Enum, auto
from typing import ClassVar, TypeAlias

class LongEnumName(Enum):
    x = auto()
    y = auto()

@dataclass
class A:
    ShortName: ClassVar[TypeAlias] = LongEnumName

    var: ShortName = ShortName.x

a = A(var=A.ShortName.y)

However, this currently fails (python 3.10):

Traceback (most recent call last):
  File "typealias_in_classvar.py", line 10, in <module>
    class A:
  File "typealias_in_classvar.py", line 11, in A
    ShortName: ClassVar[TypeAlias] = LongEnumName
  File "/home/tmk/.conda/envs/py10/lib/python3.10/typing.py", line 309, in inner
    return func(*args, **kwds)
  File "/home/tmk/.conda/envs/py10/lib/python3.10/typing.py", line 400, in __getitem__
    return self._getitem(self, parameters)
  File "/home/tmk/.conda/envs/py10/lib/python3.10/typing.py", line 455, in ClassVar
    item = _type_check(parameters, f'{self} accepts only single type.')
  File "/home/tmk/.conda/envs/py10/lib/python3.10/typing.py", line 169, in _type_check
    raise TypeError(f"Plain {arg} is not valid as type argument")
TypeError: Plain typing.TypeAlias is not valid as type argument

I did also open an issue on bugs.python.org in order to support TypeAlias directly in dataclasses (i.e., making @dataclass ignore fields with a TypeAlias annotation):

from dataclasses import dataclass
from enum import Enum, auto
from typing import TypeAlias

class LongEnumName(Enum):
    x = auto()
    y = auto()

@dataclass
class A:
    ShortName: TypeAlias = LongEnumName

    var: ShortName = ShortName.x

But there was no enthusiasm for this idea.

So, are TypeAliases just not possible in dataclasses? (By the way, leaving out the annotation entirely to write ShortName = LongEnumName doesn't work in mypy because mypy doesn't recognize it as a type alias, but it does seem to work in pyright.)

[AlexWaygood]

Fun, your snippet of code above caused me to stumble upon a mypy crash.

[AlexWaygood]

In answer to your question: I see no reason to explicitly disallow TypeAlias inside ClassVar in the way the runtime currently does. It doesn't look particularly pretty, but it seems like implementing this change would probably be easier than changing the annotations-parsing logic in dataclasses.py.

[erictraut]

I'd really prefer not to support TypeAlias inside of ClassVar. Semantically, this doesn't make sense because TypeAlias is not a ClassVar. Plus, there's already a bunch of special-case code needed to support non-type type annotations (i.e. type annotations that are not referring to a type but rather some other properties of the field or statement) like ClassVar and TypeAlias. These don't compose well because they're already special cases.

[Conchylicultor]

On a similar note, I'm writing a typing parsing & manipulation library. The natural type for my function input/output would be TypeAlias. However this also doesn't seem to be supported:

def parse_type_hints(type_hints: Dict[str, TypeAlias]):
  ...


parse_type_hints(typing.get_type_hints(cls))

But Dict[str, TypeAlias] fail with:

TypeError: Plain typing.TypeAlias is not valid as type argument

[AlexWaygood]

I think you might be looking for TypeForm (doesn't exist yet) -- see python/mypy#9773