Upload type_utils.py with huggingface_hub

type_utils.py

@@ -5,8 +5,7 @@ import typing
 
 
 def isoftype(object, type):
-    """
-    Checks if an object is of a certain typing type, including nested types.
+    """Checks if an object is of a certain typing type, including nested types.
 
     This function supports simple types (like `int`, `str`), typing types
     (like `List[int]`, `Tuple[str, int]`, `Dict[str, int]`), and nested typing
@@ -29,21 +28,27 @@ def isoftype(object, type):
         >>> isoftype([[1, 2], [3, 4]], typing.List[typing.List[int]])
         True
     """
-
     if hasattr(type, "__origin__"):
         origin = type.__origin__
         type_args = typing.get_args(type)
 
         if origin is list or origin is set:
             return all(isoftype(element, type_args[0]) for element in object)
-        elif origin is dict:
-            return all(isoftype(key, type_args[0]) and isoftype(value, type_args[1]) for key, value in object.items())
-        elif origin is tuple:
-            return all(isoftype(element, type_arg) for element, type_arg in zip(object, type_args))
-    else:
-        if type == typing.Any:
-            return True
-        return isinstance(object, type)
+        if origin is dict:
+            return all(
+                isoftype(key, type_args[0]) and isoftype(value, type_args[1])
+                for key, value in object.items()
+            )
+        if origin is tuple:
+            return all(
+                isoftype(element, type_arg)
+                for element, type_arg in zip(object, type_args)
+            )
+        return None
+
+    if type == typing.Any:
+        return True
+    return isinstance(object, type)
 
 
 # copied from: https://github.com/bojiang/typing_utils/blob/main/typing_utils/__init__.py
@@ -51,9 +56,9 @@ def isoftype(object, type):
 
 
 if hasattr(typing, "ForwardRef"):  # python3.8
-    ForwardRef = getattr(typing, "ForwardRef")
+    ForwardRef = typing.ForwardRef
 elif hasattr(typing, "_ForwardRef"):  # python3.6
-    ForwardRef = getattr(typing, "_ForwardRef")
+    ForwardRef = typing._ForwardRef
 else:
     raise NotImplementedError()
 
@@ -131,11 +136,11 @@ def _normalize_aliases(type_: Type) -> Type:
 
 def get_origin(type_):
     """Get the unsubscripted version of a type.
+
     This supports generic types, Callable, Tuple, Union, Literal, Final and ClassVar.
     Return None for unsupported types.
 
     Examples:
-
     ```python
         from typing_utils import get_origin
 
@@ -149,7 +154,7 @@ def get_origin(type_):
     ```
     """
     if hasattr(typing, "get_origin"):  # python 3.8+
-        _getter = getattr(typing, "get_origin")
+        _getter = typing.get_origin
         ori = _getter(type_)
     elif hasattr(typing.List, "_special"):  # python 3.7
         if isinstance(type_, GenericClass) and not type_._special:
@@ -176,10 +181,10 @@ def get_origin(type_):
 
 def get_args(type_) -> typing.Tuple:
     """Get type arguments with all substitutions performed.
+
     For unions, basic simplifications used by Union constructor are performed.
 
     Examples:
-
     ```python
         from typing_utils import get_args
 
@@ -191,10 +196,12 @@ def get_args(type_) -> typing.Tuple:
     ```
     """
     if hasattr(typing, "get_args"):  # python 3.8+
-        _getter = getattr(typing, "get_args")
+        _getter = typing.get_args
         res = _getter(type_)
     elif hasattr(typing.List, "_special"):  # python 3.7
-        if isinstance(type_, GenericClass) and not type_._special:  # backport for python 3.8
+        if (
+            isinstance(type_, GenericClass) and not type_._special
+        ):  # backport for python 3.8
             res = type_.__args__
             if get_origin(type_) is collections.abc.Callable and res[0] is not Ellipsis:
                 res = (list(res[:-1]), res[-1])
@@ -211,29 +218,25 @@ def get_args(type_) -> typing.Tuple:
 
 
 def eval_forward_ref(ref, forward_refs=None):
-    """
-    eval forward_refs in all cPython versions
-    """
+    """Eval forward_refs in all cPython versions."""
     localns = forward_refs or {}
 
     if hasattr(typing, "_eval_type"):  # python3.8 & python 3.9
-        _eval_type = getattr(typing, "_eval_type")
+        _eval_type = typing._eval_type
         return _eval_type(ref, globals(), localns)
 
     if hasattr(ref, "_eval_type"):  # python3.6
-        _eval_type = getattr(ref, "_eval_type")
+        _eval_type = ref._eval_type
         return _eval_type(globals(), localns)
 
     raise NotImplementedError()
 
 
 class NormalizedType(typing.NamedTuple):
-    """
-    Normalized type, made it possible to compare, hash between types.
-    """
+    """Normalized type, made it possible to compare, hash between types."""
 
     origin: Type
-    args: typing.Union[tuple, frozenset] = tuple()
+    args: typing.Union[tuple, frozenset] = ()
 
     def __eq__(self, other):
         if isinstance(other, NormalizedType):
@@ -268,9 +271,7 @@ def _normalize_args(tps: TypeArgs):
 
 
 def normalize(type_: Type) -> NormalizedType:
-    """
-    convert types to NormalizedType instances.
-    """
+    """Convert types to NormalizedType instances."""
     args = get_args(type_)
     origin = get_origin(type_)
     if not origin:
@@ -288,7 +289,11 @@ def _is_origin_subtype(left: OriginType, right: OriginType) -> bool:
     if left is right:
         return True
 
-    if left is not None and left in STATIC_SUBTYPE_MAPPING and right == STATIC_SUBTYPE_MAPPING[left]:
+    if (
+        left is not None
+        and left in STATIC_SUBTYPE_MAPPING
+        and right == STATIC_SUBTYPE_MAPPING[left]
+    ):
         return True
 
     if hasattr(left, "mro"):
@@ -324,22 +329,37 @@ def _is_origin_subtype_args(
             return True
 
         # Union[list, int] <> Union[typing.Sequence, int]
-        return all(any(_is_normal_subtype(e, r, forward_refs) for r in right) for e in excluded)
+        return all(
+            any(_is_normal_subtype(e, r, forward_refs) for r in right) for e in excluded
+        )
 
-    if isinstance(left, collections.abc.Sequence) and not isinstance(left, NormalizedType):
-        if not isinstance(right, collections.abc.Sequence) or isinstance(right, NormalizedType):
+    if isinstance(left, collections.abc.Sequence) and not isinstance(
+        left, NormalizedType
+    ):
+        if not isinstance(right, collections.abc.Sequence) or isinstance(
+            right, NormalizedType
+        ):
             return False
 
-        if left and left[-1].origin is not Ellipsis and right and right[-1].origin is Ellipsis:
+        if (
+            left
+            and left[-1].origin is not Ellipsis
+            and right
+            and right[-1].origin is Ellipsis
+        ):
             # Tuple[type, type] <> Tuple[type, ...]
-            return all(_is_origin_subtype_args(l, right[0], forward_refs) for l in left)
+            return all(
+                _is_origin_subtype_args(lft, right[0], forward_refs) for lft in left
+            )
 
         if len(left) != len(right):
             return False
 
         return all(
-            l is not None and r is not None and _is_origin_subtype_args(l, r, forward_refs)
-            for l, r in itertools.zip_longest(left, right)
+            lft is not None
+            and rgt is not None
+            and _is_origin_subtype_args(lft, rgt, forward_refs)
+            for lft, rgt in itertools.zip_longest(left, right)
         )
 
     assert isinstance(left, NormalizedType)
@@ -367,12 +387,18 @@ def _is_normal_subtype(
     if right.origin is typing.Union and left.origin is typing.Union:
         return _is_origin_subtype_args(left.args, right.args, forward_refs)
     if right.origin is typing.Union:
-        return optional_any(_is_normal_subtype(left, a, forward_refs) for a in right.args)
+        return optional_any(
+            _is_normal_subtype(left, a, forward_refs) for a in right.args
+        )
     if left.origin is typing.Union:
-        return optional_all(_is_normal_subtype(a, right, forward_refs) for a in left.args)
+        return optional_all(
+            _is_normal_subtype(a, right, forward_refs) for a in left.args
+        )
 
     # TypeVar
-    if isinstance(left.origin, typing.TypeVar) and isinstance(right.origin, typing.TypeVar):
+    if isinstance(left.origin, typing.TypeVar) and isinstance(
+        right.origin, typing.TypeVar
+    ):
         if left.origin is right.origin:
             return True
 
@@ -380,7 +406,9 @@ def _is_normal_subtype(
         right_bound = getattr(right.origin, "__bound__", None)
         if right_bound is None or left_bound is None:
             return unknown
-        return _is_normal_subtype(normalize(left_bound), normalize(right_bound), forward_refs)
+        return _is_normal_subtype(
+            normalize(left_bound), normalize(right_bound), forward_refs
+        )
     if isinstance(right.origin, typing.TypeVar):
         return unknown
     if isinstance(left.origin, typing.TypeVar):
@@ -407,11 +435,11 @@ def issubtype(
     forward_refs: typing.Optional[dict] = None,
 ) -> typing.Optional[bool]:
     """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:
-
     ```python
         from typing_utils import issubtype