fixes #9 and fixes #10

Author: sg495

test/test_00_validate.py

@@ -148,11 +148,18 @@ def test_specific_invalid_cases(val: typing.Any, ts: typing.List[typing.Any]) ->
         except TypeError:
             pass
 
+_union_cases: typing.Tuple[typing.Tuple[typing.Any, typing.List[typing.Any]], ...]
 _union_cases = (
     (0, [typing.Union[str, int], typing.Union[int, str], typing.Optional[int]]),
     ("hello", [typing.Union[str, int], typing.Union[int, str], typing.Optional[str]]),
 )
 
+if sys.version_info[1] >= 10:
+    _union_cases += (
+        (0, [str|int, int|str, int|None]),
+        ("hello", [str|int, int|str, str|None]),
+    )
+
 @pytest.mark.parametrize("val, ts", _union_cases)
 def test_union_cases(val: typing.Any, ts: typing.List[typing.Any]) -> None:
     for t in ts:
@@ -303,3 +310,29 @@ def test_invalid_typed_dict_cases(t: typing.Any, vals: typing.List[typing.Any])
             assert False, f"For type {repr(t)}, the following value shouldn't have been an instance: {repr(val)}"
         except TypeError:
             pass
+
+
+S = typing.TypeVar("S", bound=str)
+T = typing.TypeVar("T")
+U_co = typing.TypeVar("U_co", covariant=True)
+
+class A:
+    ...
+class B(typing.Generic[T]):
+    def __init__(self, t: T) -> None:
+        ...
+
+class C(typing.Generic[S, T, U_co]):
+    def __init__(self, s: S, t: T, u: U_co) -> None:
+        ...
+
+_user_class_cases = (
+    (A(), [A]),
+    (B(10), [B, B[int]]),
+    (C("hello", 20, 30), [C, C[str, int, typing.Union[int, str]]]),
+)
+
+@pytest.mark.parametrize("val, ts", _user_class_cases)
+def test_user_class_cases(val: typing.Any, ts: typing.List[typing.Any]) -> None:
+    for t in ts:
+        validate(val, t)

test/test_01_can_validate.py

@@ -8,7 +8,7 @@
 from typing_validation.inspector import _typing_equiv
 from typing_validation.validation import _pseudotypes_dict
 
-from .test_00_validate import _test_cases, _union_cases, _literal_cases, _alias_cases,_typed_dict_cases, _validation_aliases
+from .test_00_validate import _test_cases, _union_cases, _literal_cases, _alias_cases,_typed_dict_cases, _user_class_cases, _validation_aliases
 
 def assert_recorded_type(t: typing.Any) -> None:
     _t = can_validate(t).recorded_type
@@ -74,3 +74,14 @@ def test_typed_dict_cases(t: typing.Any) -> None:
         assert can_validate(typing.Optional[t]), f"Should be able to validate {typing.Optional[t]}"
         str(can_validate(t))
         assert_recorded_type(t)
+
+_user_class_cases_ts = sorted({
+    t for _, ts in _user_class_cases for t in typing.cast(typing.Any, ts)
+}, key=repr)
+
+@pytest.mark.parametrize("t", _user_class_cases_ts)
+def test_user_class_cases(t: typing.Any) -> None:
+    assert can_validate(t), f"Should be able to validate {t}"
+    assert can_validate(typing.Optional[t]), f"Should be able to validate {typing.Optional[t]}"
+    str(can_validate(t))
+    assert_recorded_type(t)

typing_validation/inspector.py

@@ -39,6 +39,7 @@
         typing.Tuple[Literal["typed-dict"], type],
         typing.Tuple[Literal["union"], int],
         typing.Tuple[Literal["tuple"], Optional[int]],
+        typing.Tuple[Literal["user-class"], Optional[int]],
         typing.Tuple[Literal["alias"], str],
         typing.Tuple[Literal["unsupported"], Any],
     ]
@@ -180,6 +181,17 @@ def _recorded_type(self, idx: int) -> typing.Tuple[Any, int]:
                 item_ts = [tuple()]
             t = pending_type[tuple(item_ts)] if pending_type is not None else typing.Tuple[tuple(item_ts)]
             return t, idx
+        if tag == "user-class":
+            assert isinstance(param, int)
+            assert pending_type is not None
+            item_ts = []
+            for _ in range(param):
+                item_t, idx = self._recorded_type(idx+1)
+                item_ts.append(item_t)
+            if not item_ts:
+                item_ts = [tuple()]
+            t = pending_type[tuple(item_ts)]
+            return t, idx
         assert False, f"Invalid type constructor tag: {repr(tag)}"
 
     def _append_constructor_args(self, args: TypeConstructorArgs) -> None:
@@ -190,7 +202,7 @@ def _append_constructor_args(self, args: TypeConstructorArgs) -> None:
         pending_tag, pending_param = pending_generic_type_constr
         args_tag, args_param = args
         assert pending_tag == "type" and isinstance(pending_param, type)
-        assert args_tag in ("tuple", "mapping", "collection"), f"Found unexpected tag '{args_tag}' with type constructor {pending_generic_type_constr} pending."
+        assert args_tag in ("tuple", "mapping", "collection", "user-class"), f"Found unexpected tag '{args_tag}' with type constructor {pending_generic_type_constr} pending."
         if sys.version_info[1] >= 9:
             self._recorded_constructors.append(typing.cast(TypeConstructorArgs, ("type", (pending_param, args_tag, args_param))))
         else:
@@ -228,6 +240,9 @@ def _record_variadic_tuple(self, item_t: Any) -> None:
     def _record_fixed_tuple(self, *item_ts: Any) -> None:
         self._append_constructor_args(("tuple", len(item_ts)))
 
+    def _record_user_class(self, *item_ts: Any) -> None:
+        self._append_constructor_args(("user-class", len(item_ts)))
+
     def _record_literal(self, *literals: Any) -> None:
         self._append_constructor_args(("literal", literals))
 
@@ -338,4 +353,16 @@ def _repr(self, idx: int = 0, level: int = 0) -> typing.Tuple[typing.List[str],
                 lines.append("tuple()")
             lines.append(indent+"]")
             return lines, idx
+        if tag == "user-class":
+            assert isinstance(param, int)
+            assert pending_type is not None
+            lines = [indent+f"{pending_type.__name__}["]
+            for _ in range(param):
+                item_lines, idx = self._repr(idx+1, level+1)
+                item_lines[-1] += ","
+                lines.extend(item_lines)
+            if len(lines) == 1:
+                lines.append("tuple()")
+            lines.append(indent+"]")
+            return lines, idx
         assert False, f"Invalid type constructor tag: {repr(tag)}"

typing_validation/validation.py

@@ -29,9 +29,10 @@ def issoftkeyword(s: str) -> bool:
         return s == "_"
 
 if sys.version_info[1] >= 10:
-    from types import NoneType
+    from types import NoneType, UnionType
 else:
     NoneType = type(None)
+    UnionType = None
 
 _validation_aliases: typing.Dict[str, Any] = {}
 r"""
@@ -292,7 +293,7 @@ def _validate_tuple(val: Any, t: Any) -> None:
             except TypeError as e:
                 raise _idx_type_error(val, t, e, idx=idx, ordered=True) from None
 
-def _validate_union(val: Any, t: Any) -> None:
+def _validate_union(val: Any, t: Any, *, union_type: bool = False) -> None:
     """
         Union type validation. Each type ``u`` listed in the union type ``t`` is checked:
 
@@ -387,6 +388,18 @@ def _validate_typed_dict(val: Any, t: type) -> None:
             except TypeError as e:
                 raise _key_type_error(val, t, e, key=k) from None
 
+def _validate_user_class(val: Any, t: Any) -> None:
+    assert hasattr(t, "__args__"), _missing_args_msg(t)
+    assert isinstance(t.__args__, tuple), f"For type {repr(t)}, expected '__args__' to be a tuple."
+    if isinstance(val, TypeInspector):
+        val._record_pending_type_generic(t.__origin__)
+        val._record_user_class(*t.__args__)
+        for arg in t.__args__:
+            validate(val, arg)
+        return
+    _validate_type(val, t.__origin__)
+    # Generic type arguments cannot be validated
+
 # def _validate_callable(val: Any, t: Any) -> None:
 #     """
 #         Callable validation
@@ -471,6 +484,9 @@ def validate(val: Any, t: Any) -> None:
             val._record_any()
             return
         return
+    if UnionType is not None and isinstance(t, UnionType):
+        _validate_union(val, t, union_type=True)
+        return
     if hasattr(t, "__origin__"): # parametric types
         if t.__origin__ is Union:
             _validate_union(val, t)
@@ -483,22 +499,26 @@ def validate(val: Any, t: Any) -> None:
                 val._record_pending_type_generic(t.__origin__)
             else:
                 _validate_type(val, t.__origin__)
-        if t.__origin__ in _collection_origins:
-            ordered = t.__origin__ in _ordered_collection_origins
-            _validate_collection(val, t, ordered)
-            return
-        if t.__origin__ in _mapping_origins:
-            _validate_mapping(val, t)
-            return
-        if t.__origin__ == tuple:
-            _validate_tuple(val, t)
-            return
-        if t.__origin__ in _iterator_origins:
-            if isinstance(val, TypeInspector):
+            if t.__origin__ in _collection_origins:
+                ordered = t.__origin__ in _ordered_collection_origins
+                _validate_collection(val, t, ordered)
+                return
+            if t.__origin__ in _mapping_origins:
+                _validate_mapping(val, t)
+                return
+            if t.__origin__ == tuple:
+                _validate_tuple(val, t)
+                return
+            if t.__origin__ in _iterator_origins:
+                if isinstance(val, TypeInspector):
+                    _validate_collection(val, t, ordered=False)
+                # Item type cannot be validated for iterators (use validated_iter)
+                return
+            if t.__origin__ in _maybe_collection_origins and isinstance(val, typing.Collection):
                 _validate_collection(val, t, ordered=False)
-            return
-        if t.__origin__ in _maybe_collection_origins and isinstance(val, typing.Collection):
-            _validate_collection(val, t, ordered=False)
+                return
+        elif isinstance(t.__origin__, type):
+            _validate_user_class(val, t)
             return
     elif isinstance(t, type):
         # The `isinstance(t, type)` case goes after the `hasattr(t, "__origin__")` case: