Aligned with latest typing inspect.

Author: Sylvain MARIE

valid8/utils/typing_inspect.py

@@ -15,15 +15,19 @@
 if NEW_TYPING:
     import collections.abc
 
-
 if NEW_TYPING:
     from typing import (
         Generic, Callable, Union, TypeVar, ClassVar, Tuple, _GenericAlias
     )
+    # from typing_extensions import Literal
 else:
     from typing import (
         Callable, CallableMeta, Union, TupleMeta, TypeVar, GenericMeta,
     )
+    # try:  # python 3.6
+    #     from typing_extensions import _Literal
+    # except ImportError:  # python 2.7
+    #     from typing import _Literal
 
 
 def _gorg(cls):
@@ -116,15 +120,19 @@ class MyClass(Tuple[str, int]):
 
 
 def is_optional_type(tp):
-    """Returns `True` if the type is `type(None)`, or is a direct `Union` to `type(None)`, such as `Optional[T]`.
+    """Test if the type is type(None), or is a direct union with it, such as Optional[T].
 
-    WARNING: this method might return a misleading `False` if
+    NOTE: this method inspects nested `Union` arguments but not `TypeVar` definition
+    bounds and constraints. So it will return `False` if
      - `tp` is a `TypeVar` bound, or constrained to, an optional type
      - `tp` is a `Union` to a `TypeVar` bound or constrained to an optional type,
      - `tp` refers to a *nested* `Union` containing an optional type or one of the above.
+
+    Users wishing to check for optionality in types relying on type variables might wish
+    to use this method in combination with `get_constraints` and `get_bound`
     """
 
-    if tp is type(None):
+    if tp is type(None):  # noqa
         return True
     elif is_union_type(tp):
         # TODO should we force evaluate to be True here or set it as a parameter?
@@ -152,6 +160,13 @@ def is_union_type(tp):
         return type(tp) is Union or type(tp) is type(Union)  # not _Union
 
 
+# def is_literal_type(tp):
+#     if NEW_TYPING:
+#         return (tp is Literal or
+#                 isinstance(tp, _GenericAlias) and tp.__origin__ is Literal)
+#     return type(tp) is _Literal
+
+
 def is_typevar(tp):
     """Test if the type represents a type variable. Examples::
 
@@ -292,12 +307,13 @@ def _eval_args(args):
         if not isinstance(arg, tuple):
             res.append(arg)
         elif is_callable_type(arg[0]):
+            callable_args = _eval_args(arg[1:])
             if len(arg) == 2:
-                res.append(Callable[[], arg[1]])
+                res.append(Callable[[], callable_args[0]])
             elif arg[1] is Ellipsis:
-                res.append(Callable[..., arg[2]])
+                res.append(Callable[..., callable_args[1]])
             else:
-                res.append(Callable[list(arg[1:-1]), arg[-1]])
+                res.append(Callable[list(callable_args[:-1]), callable_args[-1]])
         else:
             res.append(type(arg[0]).__getitem__(arg[0], _eval_args(arg[1:])))
     return tuple(res)
@@ -333,15 +349,17 @@ def get_args(tp, evaluate=None):
             return res
         return ()
     if is_classvar(tp):
-        return (tp.__type__,)
+        return (tp.__type__,) if tp.__type__ is not None else ()
+    # if is_literal_type(tp):
+    #     return tp.__values__ or ()
     if (
         is_generic_type(tp) or is_union_type(tp) or
         is_callable_type(tp) or is_tuple_type(tp)
     ):
         try:
             tree = tp._subs_tree()
         except AttributeError:
-            # even older python!
+            # Old python typing module <= 3.5.3
             if is_union_type(tp):
                 return tp.__union_params__
             elif is_generic_type(tp):
@@ -362,8 +380,9 @@ def get_args(tp, evaluate=None):
 
 
 def get_bound(tp):
-    """Returns the type bound to a `TypeVar` if any. It the type is not a `TypeVar`, a `TypeError` is raised
+    """Returns the type bound to a `TypeVar` if any.
 
+    It the type is not a `TypeVar`, a `TypeError` is raised.
     Examples::
 
         get_bound(TypeVar('T')) == None
@@ -377,8 +396,9 @@ def get_bound(tp):
 
 
 def get_constraints(tp):
-    """Returns the constraints of a `TypeVar` if any. It the type is not a `TypeVar`, a `TypeError` is raised
+    """Returns the constraints of a `TypeVar` if any.
 
+    It the type is not a `TypeVar`, a `TypeError` is raised
     Examples::
 
         get_constraints(TypeVar('T')) == ()