Programmatic generation of Literal options

Unfortunately, the answer is no.

According to the mypy documentation:

Literal types may contain one or more literal bools, ints, strs, bytes, and enum values. However, literal types cannot contain arbitrary expressions: types like Literal[my_string.trim()], Literal[x > 3], or Literal[3j + 4] are all illegal.

As @BrokenBenchmark notes, it is not possible to auto-generate Literal types. However, if the end goal is just to require specific values generated from some kind of function registry, we can hack it with enum.Enum.

To quote PEP 586

rather than entirely special-casing enums, we can instead treat them as being approximately equivalent to the union of their values... the Status enum could be treated as being approximately equivalent to Literal[Status.SUCCESS, Status.INVALID_DATA, Status.FATAL_ERROR]

Here, functions are "registered" by adding an enum value that is an exact uppercasing of the function name to the FuncNames enum. This is not a pretty or robust solution, but it runs, it supports single-location registration of a function for type-checked dispatch, and mypy handles the required enum values as expected.

from enum import Enum, auto

def f():
    return "f"

def g():
    return "g"

def h():
    return "h"

class Dispatcher():
    # Build the enum used to register the functions
    class FuncNames(Enum):
        """
        The enum names here _must_ be exact uppercase-ings of the function
        names. The names will be lowercased and evaluated to register their
        associated functions
        """
        F = auto()
        G = auto()
        H = auto()


    # NOTE: The functional syntax works just as well
    # FuncNames = Enum('FuncNames', 'F G H')


    # Comprehensions can't access names defined in the class block,
    # so use a standard for loop
    func_reg = dict()
    for name in list(FuncNames):
        func_reg[eval(f"FuncNames.{name.name}")] = eval(str(name.name).lower())


    @classmethod
    def dispatch(cls, func_name: FuncNames):
        """
        Prints the return from a registered function.
        Can only be called with an item from FuncNames
        """
        print(cls.func_reg[func_name]())

Dispatcher.dispatch(Dispatcher.FuncNames.F)
Dispatcher.dispatch(Dispatcher.FuncNames.G)
Dispatcher.dispatch(Dispatcher.FuncNames.H)
# Dispatcher.dispatch(Dispatcher.FuncNames.I) -> "FuncNames has no attribute I"
# Dispatcher.dispatch(Dispatcher2.FuncNames) -> "incompatible type"
# Dispatcher.dispatch('MyPy hates me!') -> "incompatible type"

Interestingly, though it feels cleaner to generate the enum itself from a list of the functions themselves, MyPy chokes on this.

class Dispatcher2():
    # Build an enum used to register these (the actual functions)
    funcs_to_register = [f, g, h]
    enum_names = [func.__name__.upper() for func in funcs_to_register]
    joined = ' '.join(enum_names)
    FuncNames = Enum('FuncNames', joined)

    func_reg = dict()
    for name in enum_names:
        func_reg[eval(f"FuncNames.{name}")] = eval(name.lower())


    @classmethod
    def dispatch(cls, func_name: FuncNames):
        """
        Prints the return from a registered function.
        Can only be called with an item from FuncNames
        """
        print(cls.func_reg[func_name]())

Dispatcher2.dispatch(Dispatcher2.FuncNames.F)
Dispatcher2.dispatch(Dispatcher2.FuncNames.G)
Dispatcher2.dispatch(Dispatcher2.FuncNames.H)

The above runs as expected, but mypy presumably can't infer the values present in the enum unless it is statically defined, so it errors.

> mypy enums_typing.py 
enums_typing.py:19: error: Enum() expects a string, tuple, list or dict literal as the second argument
enums_typing.py:36: error: "Type[FuncNames]" has no attribute "F"
enums_typing.py:37: error: "Type[FuncNames]" has no attribute "G"
enums_typing.py:38: error: "Type[FuncNames]" has no attribute "H"
Found 4 errors in 1 file (checked 1 source file)

TLDR: In order to define a fixed set of choices that MyPy can check against, you must define them statically. It may then be possible to use those statically-defined choices to programmatically build your function registry.