type alias to union is invalid in runtime context

[glyph]

As of MyPy 0.620:

# aliases.py
from typing import Union
x = Union[int, str]
def y() -> None:
    print(x)

This produces the error:

aliases.py:5: error: The type alias to Union is invalid in runtime context

However, type variables are quite useful in "runtime context" in order to implement things like serialization; for example, https://github.com/Tinche/cattrs makes heavy use of introspecting Union objects to determine which types are valid.

Those of us hacking around code like this have known that the current API for enumerating the members of a Union was private & internal, and not for public consumption, so we've been keeping pace with implementation details while waiting for a public API to get this information to emerge. These errors are super annoying because they imply the only future-looking direction for this type of code will involve manually re-typing the same list of types for every union alias defined anywhere.

Can this change be backed out? If not, is there any guidance for how to define a Union such that it is introspectable?

[glyph]

I guess this was a result of #5221 ?

[ilevkivskyi]

From mypy's point of view it is hard to distinguish whether this is intentional or a mistake. The point is that this change discovered actual errors in real code, so I am not so keen to revert this change even though it was unintentional.

On the other hand, such aliases will likely fail at runtime in most scenarios where it is an error quite soon. So the value of discovering them statically is not so big.

One possible way is to turn the type aliases into variables by giving them explicit types:

X: Type[Any] = Union[A, B, C]
print(X)  # OK

but then X can't be used in annotations. I would like to see more input here before making a decision here.

[glyph]

I can see your point as far as this being a useful thing to check most of the time. And given that we're relying on private implementation details of typing I know it's my own responsibility to keep up with such changes :). Mainly what I'm looking for here is a non-horrible way forward that translates to something that will be close to a one-day public API. For example, I'm very curious what you mean by

such aliases will likely fail at runtime in most scenarios where it is an error quite soon

what will make this the case?

(previous complaint Type[Any] approach deleted, that was an error that was fixed in 0.620)

[glyph]

OK, now that I'm actually testing on the correct version:

x = Union[int, str]
z: Type[Any] = x

still says "The type alias to Union is invalid in runtime context", which means any type I want to use in this way needs to be fully typed out twice.

[glyph]

Is this a workable way to express this for the time being?

x = Union[int, str]
x_runtime: Type[Any]
if not TYPE_CHECKING:
    x_runtime = x

[JelleZijlstra]

What if you do x: Type[Any] = Union[int, str]?

[ilevkivskyi]

After a discussion with @JukkaL I think it is OK to allow the original example. This is however relatively low priority since there are workarounds like using Type[Any] and/or # type: ignore and/or if TYPE_CHECKING: ....