typing-utils
Backport Python3.8+ typing utils & issubtype & more
Install
pip install typing_utils
API
issubtype
Check that the left argument is a subtype of the right.
For unions, check if the type arguments of the left is a subset of the right. Also works for nested types including ForwardRefs.
Examples:
from typing_utils import issubtype
issubtype(typing.List, typing.Any) == True
issubtype(list, list) == True
issubtype(list, typing.List) == True
issubtype(list, typing.Sequence) == True
issubtype(typing.List[int], list) == True
issubtype(typing.List[typing.List], list) == True
issubtype(list, typing.List[int]) == False
issubtype(list, typing.Union[typing.Tuple, typing.Set]) == False
issubtype(typing.List[typing.List], typing.List[typing.Sequence]) == True
JSON = typing.Union[
int, float, bool, str, None, typing.Sequence["JSON"],
typing.Mapping[str, "JSON"]
]
issubtype(str, JSON, forward_refs={'JSON': JSON}) == True
issubtype(typing.Dict[str, str], JSON, forward_refs={'JSON': JSON}) == True
issubtype(typing.Dict[str, bytes], JSON, forward_refs={'JSON': JSON}) == False
get_origin
Get the unsubscripted version of a type.
This supports generic types, Callable, Tuple, Union, Literal, Final and ClassVar. Return None for unsupported types.
Examples:
from typing_utils import get_origin
get_origin(Literal[42]) is Literal
get_origin(int) is None
get_origin(ClassVar[int]) is ClassVar
get_origin(Generic) is Generic
get_origin(Generic[T]) is Generic
get_origin(Union[T, int]) is Union
get_origin(List[Tuple[T, T]][int]) == list
get_args
Get type arguments with all substitutions performed.
For unions, basic simplifications used by Union constructor are performed.
Examples:
from typing_utils import get_args
get_args(Dict[str, int]) == (str, int)
get_args(int) == ()
get_args(Union[int, Union[T, int], str][int]) == (int, str)
get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
get_args(Callable[[], T][int]) == ([], int)
get_type_hints
Return type hints for an object.
This is often the same as obj.annotations, but it handles forward references encoded as string literals, and if necessary adds Optional[t] if a default value equal to None is set.
The argument may be a module, class, method, or function. The annotations are returned as a dictionary. For classes, annotations include also inherited members.
TypeError is raised if the argument is not of a type that can contain annotations, and an empty dictionary is returned if no annotations are present.
BEWARE -- the behavior of globalns and localns is counterintuitive (unless you are familiar with how eval() and exec() work). The search order is locals first, then globals.
-
If no dict arguments are passed, an attempt is made to use the globals from obj (or the respective module's globals for classes), and these are also used as the locals. If the object does not appear to have globals, an empty dictionary is used.
-
If one dict argument is passed, it is used for both globals and locals.
-
If two dict arguments are passed, they specify globals and locals, respectively.
7 Aug 07, 2022
1 Feb 12, 2022
22 Aug 27, 2022
6.2k Jan 04, 2023
42 Sep 25, 2022
12 Jul 14, 2020
8 Nov 30, 2022
118 Jan 05, 2023
6 Mar 26, 2021
967 Jan 07, 2023
36 Nov 24, 2022
473 Dec 28, 2022
41 Dec 28, 2022
139 Nov 08, 2022
25 Dec 26, 2022
19 Dec 27, 2022
238 Dec 27, 2022
8 Feb 06, 2022
67 Dec 16, 2022
62 Nov 22, 2022