The typing module provides a function get_args which retrieves the arguments with which your Literal was initialized.

>>> from typing import Literal, get_args
>>> l = Literal['add', 'mul']
>>> get_args(l)
('add', 'mul')

However, I don't think you gain anything by using a Literal for what you propose.

Unfortunately, mypy does not narrow the type of input_string to Literal["best"]. You can help it with a proper type annotation:

input_string: Literal["best"] = "best"
literal_func(string_input=input_string)

Perhaps worth mentioning that pyright works just fine with your example.

Alternatively, the same can be achieved by annotating the input_string as Final:

from typing import Final, Literal

...

input_string: Final = "best"
literal_func(string_input=input_string)

After asking around a bit more (thanks @21305238/insync), I've found that what I actually want are TypeExprs.

In the discussion for its PEP, TypeExprs are described as follows:

They are similar to type[] class objects, but additionally allow matching TypedDicts, generic lists, unions, literals, and other complex types.

When TypeExprs land, hopefully in Python 3.14, it'll be perfect for what I want to do, but unfortunately I haven't found a decent workaround for right now.

Union[x, y] means "either x or y". Literal[5, 6] means "literally 5 or literally 6" (not some variable that's equal to any of those, but literally 5 or 6).

The difference is that the arguments of Union must be types. The arguments to Literal are literals. Type names (like int, float, MyClass) are not literals (but they do represent types), so they can't be used in Literal. Literals (like 5, 'Hello!' and [1,2,3]) are not types, so they cannot be used in Union.

For example, these types are not correct:

Literal[str, float]  # none of the arguments are literals
Union[5, 6] # none of the arguments are types

In response to your comment, None is both a literal and a type.

None is defined as a literal in Python's grammar:

atom: ('(' [yield_expr|testlist_comp] ')' |
       '[' [testlist_comp] ']' | # maybe list literal
       '{' [dictorsetmaker] '}' | # maybe dict/set literal
       NAME |  # NOT a literal
       NUMBER | # int/float literal
       STRING+ | # string literal
       '...' | # Ellipsis literal
       'None' | # None literal!
       'True' | 'False')

Here, None is a literal, thus, it can be used in Literal. However, it's not a class:

>>> import inspect
>>> inspect.isclass(None)
False
>>> inspect.isclass(5)
False
>>> inspect.isclass(str)
True

So, it can't be used in Union. BUT it actually is used in Union: Union[str, None] means "type str or nothing". From the docs on Union:

You can use Optional[X] as a shorthand for Union[X, None]