Closes #15

Author: sg495

test/test_00_validate.py

@@ -370,3 +370,21 @@ def test_numpy_array_error() -> None:
         validate(val, npt.NDArray[typing.Union[np.uint16,np.float32]])
     with pytest.raises(TypeError):
         validate(val, npt.NDArray[np.str_])
+
+
+def test_typevar() -> None:
+    T = typing.TypeVar("T")
+    validate(10, T)
+    validate(None, T)
+    validate([0, "hello"], T)
+    IntT = typing.TypeVar("IntT", bound=int)
+    validate(10, IntT)
+    with pytest.raises(TypeError):
+        validate(None, IntT)
+    with pytest.raises(TypeError):
+        validate([0, 1], IntT)
+    IntStrSeqT = typing.TypeVar("IntStrSeqT", bound=typing.Sequence[int|str])
+    validate([0, "hello"], IntStrSeqT)
+    validate("Hello", IntStrSeqT)
+    with pytest.raises(TypeError):
+        validate(0, IntStrSeqT)

test/test_01_can_validate.py

@@ -90,11 +90,11 @@ def test_numpy_array() -> None:
     # pylint: disable = import-outside-toplevel
     import numpy as np
     import numpy.typing as npt
-    can_validate(npt.NDArray[np.uint8])
-    can_validate(npt.NDArray[typing.Union[np.uint8, np.float32]])
-    can_validate(npt.NDArray[typing.Union[typing.Any, np.float32]])
-    can_validate(npt.NDArray[typing.Any])
-    can_validate(npt.NDArray[
+    assert can_validate(npt.NDArray[np.uint8])
+    assert can_validate(npt.NDArray[typing.Union[np.uint8, np.float32]])
+    assert can_validate(npt.NDArray[typing.Union[typing.Any, np.float32]])
+    assert can_validate(npt.NDArray[typing.Any])
+    assert can_validate(npt.NDArray[
         typing.Union[
             np.float32,
             typing.Union[
@@ -103,3 +103,11 @@ def test_numpy_array() -> None:
             ]
         ]
     ])
+
+def test_typevar() -> None:
+    T = typing.TypeVar("T")
+    assert can_validate(T)
+    IntT = typing.TypeVar("IntT", bound=int)
+    assert can_validate(IntT)
+    IntStrSeqT = typing.TypeVar("IntStrSeqT", bound=typing.Sequence[int|str])
+    assert can_validate(IntStrSeqT)

typing_validation/inspector.py

@@ -9,7 +9,7 @@
 import collections.abc as collections_abc
 import sys
 import typing
-from typing import Any, Optional, Union, get_type_hints
+from typing import Any, Optional, TypeVar, Union, get_type_hints
 
 if sys.version_info[1] >= 8:
     from typing import Literal
@@ -34,6 +34,7 @@
         typing.Tuple[Literal["collection"], None],
         typing.Tuple[Literal["mapping"], None],
         typing.Tuple[Literal["typed-dict"], type],
+        typing.Tuple[Literal["typevar"], TypeVar],
         typing.Tuple[Literal["union"], int],
         typing.Tuple[Literal["tuple"], Optional[int]],
         typing.Tuple[Literal["user-class"], Optional[int]],
@@ -253,6 +254,9 @@ def _record_type(self, t: type) -> None:
     def _record_typed_dict(self, t: type) -> None:
         self._append_constructor_args(("typed-dict", t))
 
+    def _record_typevar(self, t: TypeVar) -> None:
+        self._append_constructor_args(("typevar", t))
+
     def _record_pending_type_generic(self, t: type) -> None:
         assert self._pending_generic_type_constr is None
         self._pending_generic_type_constr = ("type", t)
@@ -323,6 +327,20 @@ def _repr(
             return [
                 indent + f"Literal[{', '.join(repr(p) for p in param)}]"
             ], idx
+        if tag == "typevar":
+            assert isinstance(param, TypeVar)
+            name = param.__name__
+            bound = param.__bound__
+            if bound is None:
+                lines = [indent+f"TypeVar({name!r})"]
+            else:
+                bound_lines, idx = self._repr(idx + 1, level + 1)
+                lines = [
+                    indent+f"TypeVar({name!r}, bound=",
+                    *bound_lines,
+                    indent+")"
+                ]
+            return lines, idx
         if tag == "union":
             assert isinstance(param, int)
             lines = [indent + "Union["]
@@ -355,7 +373,6 @@ def _repr(
             return lines, idx
         pending_type = None
         if tag == "type":
-            # if isinstance(param, type):
             if not isinstance(param, tuple):
                 param_name = (
                     param.__name__ if isinstance(param, type) else str(param)

typing_validation/validation.py

@@ -10,11 +10,12 @@
 from keyword import iskeyword
 import sys
 import typing
-from typing import Any, ForwardRef, Hashable, Optional, Union, get_type_hints
+from typing import Any, ForwardRef, Hashable, Optional, TypeVar, Union, get_type_hints
 import typing_extensions
 
 from .validation_failure import (
     InvalidNumpyDTypeValidationFailure,
+    TypeVarBoundValidationFailure,
     ValidationFailureAtIdx,
     ValidationFailureAtKey,
     MissingKeysValidationFailure,
@@ -219,6 +220,14 @@ def _type_error(
     setattr(error, "validation_failure", validation_failure)
     return error
 
+def _typevar_error(val: Any, t: Any, bound_error: TypeError) -> TypeError:
+    assert hasattr(bound_error, "validation_failure"), bound_error
+    cause = getattr(bound_error, "validation_failure")
+    assert isinstance(cause, ValidationFailure), cause
+    validation_failure = TypeVarBoundValidationFailure(val, t, cause)
+    error = TypeError(str(validation_failure))
+    setattr(error, "validation_failure", validation_failure)
+    return error
 
 def _idx_type_error(
     val: Any, t: Any, idx_error: TypeError, *, idx: int, ordered: bool
@@ -533,7 +542,6 @@ def _extract_dtypes(t: Any) -> typing.Sequence[Any]:
         return [t]
     raise TypeError()
 
-
 def _validate_numpy_array(val: Any, t: Any) -> None:
     import numpy as np  # pylint: disable = import-outside-toplevel
     if not isinstance(val, TypeInspector):
@@ -569,6 +577,17 @@ def _validate_numpy_array(val: Any, t: Any) -> None:
     raise _numpy_dtype_error(val, t)
 
 
+def _validate_typevar(val: Any, t: TypeVar) -> None:
+    if isinstance(val, TypeInspector):
+        val._record_typevar(t)
+        pass
+    bound = t.__bound__
+    if bound is not None:
+        try:
+            validate(val, bound)
+        except TypeError as e:
+            raise _typevar_error(val, t, e) from None
+
 # def _validate_callable(val: Any, t: Any) -> None:
 #     """
 #         Callable validation
@@ -618,16 +637,16 @@ def validate(val: Any, t: Any) -> Literal[True]:
 
     For structured types, the error message keeps track of the chain of validation failures, e.g.
 
-    >>> from typing import *
-    >>> from typing_validation import validate
-    >>> validate([[0, 1, 2], {"hi": 0}], list[Union[Collection[int], dict[str, str]]])
-    TypeError: Runtime validation error raised by validate(val, t), details below.
-    For type list[typing.Union[typing.Collection[int], dict[str, str]]], invalid value at idx: 1
-    For union type typing.Union[typing.Collection[int], dict[str, str]], invalid value: {'hi': 0}
-        For member type typing.Collection[int], invalid value at idx: 0
-        For type <class 'int'>, invalid value: 'hi'
-        For member type dict[str, str], invalid value at key: 'hi'
-        For type <class 'str'>, invalid value: 0
+        >>> from typing import *
+        >>> from typing_validation import validate
+        >>> validate([[0, 1, 2], {"hi": 0}], list[Union[Collection[int], dict[str, str]]])
+        TypeError: Runtime validation error raised by validate(val, t), details below.
+        For type list[typing.Union[typing.Collection[int], dict[str, str]]], invalid value at idx: 1
+        For union type typing.Union[typing.Collection[int], dict[str, str]], invalid value: {'hi': 0}
+            For member type typing.Collection[int], invalid value at idx: 0
+            For type <class 'int'>, invalid value: 'hi'
+            For member type dict[str, str], invalid value at key: 'hi'
+            For type <class 'str'>, invalid value: 0
 
     **Note.** For Python 3.7 and 3.8, use :obj:`~typing.Dict` and :obj:`~typing.List` instead of :obj:`dict` and :obj:`list` for the above examples.
 
@@ -670,6 +689,9 @@ def validate(val: Any, t: Any) -> Literal[True]:
             val._record_any()
             return True
         return True
+    if isinstance(t, TypeVar):
+        _validate_typevar(val, t)
+        return True
     if UnionType is not None and isinstance(t, UnionType):
         _validate_union(val, t, union_type=True)
         return True

typing_validation/validation_failure.py

@@ -6,7 +6,7 @@
 
 import sys
 import typing
-from typing import Any, Mapping, Optional
+from typing import Any, Mapping, Optional, TypeVar
 
 if sys.version_info[1] >= 8:
     from typing import Protocol
@@ -24,16 +24,6 @@
     from typing_extensions import Self
 
 
-# def _indent(msg: str, level: int = 1, *,
-#             allow_newlines: bool = False) -> str:
-#     """ Indent a block of text (possibly with newlines) """
-#     ind = " "*2*level
-#     if allow_newlines:
-#         return ind+msg.replace("\n", "\n"+ind)
-#     assert "\n" not in msg
-#     return ind+msg
-
-
 def _indent_lines(lines: Sequence[str], level: int = 1) -> list[str]:
     """Indent all given blocks of text."""
     if any("\n" in line for line in lines):
@@ -206,7 +196,11 @@ def __repr__(self) -> str:
         return f"{type(self).__name__}({repr(self.val)}, {repr(self.t)}{causes_str})"
 
     def _str_type_descr(self, type_quals: tuple[str, ...] = ()) -> str:
-        descr = "type alias" if isinstance(self.t, str) else "type"
+        descr = (
+            "type alias" if isinstance(self.t, str)
+            else "type variable" if isinstance(self.t, TypeVar)
+            else "type"
+        )
         if type_quals:
             descr = " ".join(type_quals) + " " + descr
         return descr
@@ -437,6 +431,32 @@ def _str_main_msg(self, type_quals: tuple[str, ...] = ()) -> str:
         )
 
 
+class TypeVarBoundValidationFailure(ValidationFailure):
+    """
+    Validation failures arising from the bound of a type variable.
+    """
+
+    def __new__(
+        cls,
+        val: Any,
+        t: Any,
+        bound_cause: ValidationFailure,
+        *,
+        type_aliases: Optional[Mapping[str, Any]] = None,
+    ) -> Self:
+        # pylint: disable = too-many-arguments
+        instance = super().__new__(
+            cls, val, t, bound_cause, type_aliases=type_aliases
+        )
+        return instance
+
+    def _str_main_msg(self, type_quals: tuple[str, ...] = ()) -> str:
+        return (
+            f"For {self._str_type_descr(type_quals)} {repr(self.t)}, "
+            f"value is not valid for upper bound."
+        )
+
+
 def get_validation_failure(err: TypeError) -> ValidationFailure:
     """
     Programmatic access to the validation failure tree for the latest validation call.