Repository navigation
No (public) way to dynamically introspect if an annotation is a TypedDict #751
Description
I want to know the Origin of an annotation. This works fine for basically everything, but there is no way to check if an annotation is a TypedDict subclass without resorting to (semantically) private API (by checking if it is an instance of _TypedDictMeta), because issubclass(x, TypedDict) fails. I believe this is because you don't want people thinking isinstance(x, TypedDict) will work to actually validate the keys on a dict. However, I don't think there's any reason to prevent issubclass on it
https://github.com/python/cpython/blob/1b4552c/Lib/typing.py#L1901
Here is an example use-case:
from typing import Dict, get_origin
def validate(data, annotation) -> bool:
"""check if `data` conforms to the type given in `annotation`"""
# this works
if get_origin(annotation) is Dict:
return isinstance(data, dict)
# but this doesn't...
elif is_a_typed_dict(annotation):
return isinstance(data, dict) and validate_typeddict_keys(data, annotation)
...This could be solved in one of the following ways:
- allow
issubclassonTypedDicts- or allow it only on
TypedDictitself and not subclasses of it, e.g. using a_rootclassvar likeNamedTupledoes for its magic- although I see no reason not to allow it in that case either
- or allow it only on
- make
_TypedDictMetapublic API (rename toTypedDictMeta) - make
get_originwork onTypedDicts (not ideal because it isn't really a type)
Activity
[-]No (public) way to dynamically introspect if an object is a TypedDict[/-][+]No (public) way to dynamically introspect if an annotation is a TypedDict[/+]gvanrossum commentedon Sep 14, 2020
This is reasonable. Can you show us a function that when added to typing.py would solve your problem? (E.g. is_typed_dict() -- how should it be implemented?)
pxeger commentedon Sep 14, 2020
Simply:
would do. Is there a reason that we can't just allow
issubclassonTypedDicts though?gvanrossum commentedon Sep 14, 2020
PEP 589 explicitly rejects supporting
isinstanceorissubclassforTypedDict, so let's not go there.Are you willing to make a contribution? There would actually have to be several -- this should be added to typing.py in the CPython 3.10 stdlib, to typing.py and typing_extensions in the typing repo. (Hm, maybe only to typing_extensions? typing.py there is only relevant for Python versions that are no longer supported, like 2.7 and 3.4.)
pxeger commentedon Sep 14, 2020
https://github.com/python/typing/#workflow-for-cpython-changes says:
Is that note out of date then?
gvanrossum commentedon Sep 14, 2020
Ouch, yes. That is totally out of date. The "master" copy of those files now lives in the CPython repo and the version here is only maintained (or at least not killed) for the benefit of Python 2.7 users of mypy and pytype.
pxeger commentedon Sep 15, 2020
Should I create a BPO for this? It seems like the CPython pull request workflow is heavily centered around using those issue numbers.Done, see bpo-41792
bpo-41792: Add is_typeddict function to typing.py (pythonGH-22254)
septatrix commentedon Jun 8, 2021
While the given reason is valid for
isinstanceI think the given reason does not really apply toissubclassand more likely due toTypedDictnot having an MRO (as discussed here https://bugs.python.org/issue41249).Therefore a subclass check would need to manually inspect annotations and totality. With a MRO or other access to the bases this would not be a problem at all as it is already possible for e.g. NamedTuple and subclassing generic types from collection.abc.
The reasoning given mainly regards generic aliases like
issubclass(Mapping[str, int], dict).bpo-41792: Add is_typeddict function to typing.py (GH-22254)
Ark-kun commentedon Sep 17, 2025
I know my comment is too late, but I do not think the
is_typeddictshould go into the root of thetypingmodule. I think such class-specific methods are too spammy for the module scope. Should we also havetyping.is_namedtuple,typing.is_mutablemapping,typing.is_typevaretc? I don't think so.I think we either need a single solution that is similar to
isinstanceorissubclassbut works for typing constructs or we should put such class-specific methods into the class itself:typing.TypedDict.is_typeddict(annotation).It would be also a great place to put introspection methods (e.g.
typing.TypedDict.get_required_keys(annotation),typing.TypedDict.get_optional_keys(annotation)etc).