What do typing.get_origin and typing.get_args return for dict[str, int]?

### What a subscripted annotation actually is When you write `dict[str, int]`, Python does not create a new class. It calls the container class's subscription hook and gets back an *alias object* — for a builtin container, an instance of `types.GenericAlias`. That object remembers two things: the class that was subscripted (the **origin**) and the tuple of things it was subscripted with (the **arguments**). An annotation is just an ordinary expression evaluated to an ordinary object, so at runtime `dict[str, int]` is a value you can pass around, store in a registry, and inspect. `typing.get_origin` and `typing.get_args` are the supported way to inspect it. `get_origin` answers "what container is this?" and `get_args` answers "what was it parameterized with?": ```python from typing import get_args, get_origin get_origin(dict[str, int]) # <class 'dict'> get_args(dict[str, int]) # (<class 'str'>, <class 'int'>) get_origin(list[int]) # <class 'list'> get_args(list[int]) # (<class 'int'>,) ``` Note the shapes: the origin is a **class**, not another alias, and the arguments are always a **tuple**, even when there is exactly one — `(int,)`, with the trailing comma. Code that expects a list, or that forgets the one-element case, breaks immediately. ### Why the helpers exist rather than direct attribute access Alias objects do expose their origin and argument tuple as attributes, and you could read them. You should not, for two reasons. First, Python has several alias flavours that all mean the same thing: `list[int]` is a `types.GenericAlias`, the older `typing.List[int]` is a typing-internal alias, and `collections.abc.Sequence[int]` is a third. `get_origin` normalizes across all of them — `get_origin(typing.List[int])` is the runtime class `list`, which is what you want if you are about to construct something. Second, the helpers degrade gracefully on things that are not aliases at all, returning `None` and `()` rather than raising `AttributeError`, so a dispatch function can lead with them. ### The unsubscripted case is the branch that matters `get_origin(int)` is `None`, `get_origin(str)` is `None`, and `get_origin(list)` — the bare container class, with no subscription — is also `None`, with `get_args(list) == ()`. That is not a defect; a bare `list` in an annotation genuinely carries no element information. Runtime code that builds values from declared shapes almost always uses `origin is None` as its "this is a plain class, just call it" branch: ```python def build(ann, raw): origin = get_origin(ann) if origin is None: return ann(raw) # int('42'), Decimal('1200.50') if origin is list: (item,) = get_args(ann) return [build(item, part) for part in raw.split(';')] raise TypeError(f'unsupported annotation: {ann!r}') ``` That shape — check the origin, then recurse over the arguments — is the whole pattern, and it is why the two functions are almost always used together. ### Arguments are shallow, and order is written order `get_args` returns one level. `get_args(dict[str, list[int]])` is `(str, list[int])`; the second element is still an alias, and getting `int` out of it takes another `get_origin`/`get_args` pair. Recursion is the caller's job. Order is the order you wrote: for a mapping that means key type first, value type second, so `dict[str, int]` and `dict[int, str]` are distinguishable, as they must be. ### Where the sharp edges are A few results surprise people. Subscripted `collections.abc.Callable` reports origin `collections.abc.Callable` and returns its parameter list as the first argument and the return type as the last. `typing.Literal['a', 'b']` reports origin `typing.Literal` and returns the *values*, not types, as its arguments — `get_args` is not promised to hand you classes. And a union reports a union origin rather than a container class, which is its own topic. ### Versions `get_origin` and `get_args` arrived in 3.8. Subscripting builtins directly — `list[int]`, `dict[str, int]` — is 3.9 and later (PEP 585); before that you needed `typing.List[int]`, which still works and still normalizes to origin `list`. Everything described here holds on 3.14.