How to use Literal

[elbaro]

from typing import NewType, Literal

ABC = NewType('ABC', Literal['A', 'B'])

var = ABC('XYZ')

Hi, I am new to python typing.

1. Why does this have no error?
2. Is Literal the best way to specify a set of allowed values?

[erictraut]

There are a few problems here. First, the expression Literal["A", "B"] is shorthand for Union[Literal["A"], Literal["B"]], and you cannot use union types in a NewType call. Pyright should generate an error in this circumstance.

Second, even if you remove the NewType and simplify the Literal, you cannot instantiate it because a literal is an object, not a class. So Pyright should generate an error for the expression Literal["A"]("A").

The correct way to use literals is in a type annotation like this:

LetterGrade = Literal["A", "B", "C", "D"]
def foo(grade: LetterGrade):
    print(grade)

foo("A") # Allowed
foo("F") # Generates error

[elbaro]

I actually want NewType with some constraints (but no runtime overhead).

This is the hack that worked for me.

from typing import TYPE_CHECKING, NewType, Literal


def ABCNewType(name, tp):
    def new_type(x: Literal['A', 'B', 'C']):
        print('this should not run in runtime')
        return x
    new_type.__name__ = name
    new_type.__supertype__ = tp
    return new_type


print('TYPE_CHECKING', TYPE_CHECKING)

if TYPE_CHECKING:  # this is evaluated once in runtime
    ABC = ABCNewType('ABC', str)
else:
    ABC = NewType('ABC', str)

a = ABC('x')

  20:9 - error: Argument of type "Literal['a']" cannot be assigned to parameter "x" of type "Literal['A', 'B', 'C']" in function "new_type"
    Type "Literal['a']" cannot be assigned to type "Literal['A', 'B', 'C']"
      "Literal['a']" cannot be assigned to type "Literal['A']"
      "Literal['a']" cannot be assigned to type "Literal['B']"
      "Literal['a']" cannot be assigned to type "Literal['C']" (reportGeneralTypeIssues)
1 error, 0 warnings, 0 infos 
Completed in 0.482sec

[erictraut]

You can do this, but I generally advise against changing the behavior of your code based on TYPE_CHECKING. It inevitably leads to divergences between the code that the type checker sees and the code that the runtime sees, leaving you vulnerable to uncaught bugs.

The runtime overhead you are avoiding here with this hack is close to zero. If you're that sensitive to runtime overhead, then Python is probably a bad language choice to begin with.

Here's a simpler approach that might meet your needs:

from typing import Literal, Type, TypeVar

_T = TypeVar("_T", bound="ConstrainedStr")

class ConstrainedStr(str):
    def __new__(cls: Type[_T], x: Literal["A", "B", "C"]) -> _T:
        return super().__new__(cls, x)

a = ConstrainedStr("A")