Handle type properly in pydantic type checking. Also improve error messages when incorrectly using generic type. (#471)

Signed-off-by: Pascal Tomecek <pascal.tomecek@cubistsystematic.com>

Author: ptomecek

csp/impl/types/pydantic_types.py

@@ -35,6 +35,14 @@ class CspTypeVarType(Generic[_T]):
     @classmethod
     def __get_pydantic_core_schema__(cls, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema:
         typ = _check_source_type(cls, source_type)
+        if not typ or not typ[0].isalpha():
+            if typ and typ[0] == "~":
+                raise SyntaxError(
+                    f"Invalid generic type: {typ}. The generic type annotation (i.e. `~T`) is only allowed at the top level (i.e. `value: '~T'`)."
+                )
+            raise SyntaxError(
+                f"Invalid generic type: {typ}. Generic types in csp must start with an alphabetic character."
+            )
 
         def _validator(v: Any, info: ValidationInfo) -> Any:
             # info.context should be an instance of TVarValidationContext, but we don't check for performance
@@ -55,6 +63,14 @@ class CspTypeVar(Generic[_T]):
     @classmethod
     def __get_pydantic_core_schema__(cls, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema:
         tvar = _check_source_type(cls, source_type)
+        if not tvar or not tvar[0].isalpha():
+            if tvar and tvar[0] == "~":
+                raise SyntaxError(
+                    f"Invalid generic type: {tvar}. The generic type annotation (i.e. `~T`) is only allowed at the top level (i.e. `value: '~T'`)."
+                )
+            raise SyntaxError(
+                f"Invalid generic type: {tvar}. Generic types in csp must start with an alphabetic character. "
+            )
 
         def _validator(v: Any, info: ValidationInfo) -> Any:
             # info.context should be an instance of TVarValidationContext, but we don't check for performance

csp/impl/types/typing_utils.py

@@ -99,9 +99,9 @@ class TsTypeValidator:
     For example, this is to make sure that:
         ts[List] can validate as ts[List[float]]
         ts[Dict[str, List[str]] won't validate as ts[Dict[str, List[float]]
-        ts["T"], ts[TypeVar("T")], ts[List["T"]], etc are allowed
-        ts[Optional[float]], ts[Union[float, int]], ts[Annotated[float, None]], etc are not allowed
-        etc
+    Notes:
+        ts["T"], ts[TypeVar("T")], ts[List["T"]], ts[Optional[float]], ts[Union[float, int]], ts[Any] are allowed
+        ts[Annotated[float, None]], are not allowed
     For validation of csp baskets, this piece becomes the bottleneck
     """
 
@@ -125,7 +125,7 @@ def __init__(self, source_type: type):
         self._source_is_union = CspTypingUtils.is_union_type(source_type)
         self._source_args = typing.get_args(source_type)
         self._source_adapter = None
-        if type(source_type) in (typing.ForwardRef, typing.TypeVar):
+        if type(source_type) in (typing.ForwardRef, typing.TypeVar) or source_type is typing.Any:
             pass  # Will handle these separately as part of type checking
         elif self._source_origin is None and isinstance(self._source_type, type):
             # self._source_adapter = TypeAdapter(typing.Type[source_type])
@@ -162,12 +162,19 @@ def validate(self, value_type, info=None):
         self._last_value_type = value_type
         self._last_context = info.context if info is not None else None
 
+        if value_type is typing.Any:
+            # https://docs.python.org/3/library/typing.html#the-any-type
+            # "Notice that no type checking is performed when assigning a value of type Any to a more precise type."
+            return value_type
+
         # Fast path because while we could use the source adapter in the next block to validate,
         # it's about 10x faster to do a simple validation with issubclass, and this adds up on baskets
         if self._source_origin is None:
             # Want to allow int to be passed for float (i.e. in resolution of TVars)
             if self._source_type is float and value_type is int:
                 return self._source_type
+            if self._source_type is typing.Any:
+                return value_type
             try:
                 if issubclass(value_type, self._source_type):
                     return value_type

csp/tests/impl/types/test_pydantic_type_resolver.py

@@ -91,6 +91,12 @@ def test_forced_tvar(self):
         context.resolve_tvars()
         self.assertDictEqual(context.tvars, {"T": float})
 
+    def test_bad_variable_name(self):
+        self.assertRaises(SyntaxError, lambda: CspTypeVar[""])
+        self.assertRaises(SyntaxError, TypeAdapter, CspTypeVar["~T"])
+        self.assertRaises(SyntaxError, TypeAdapter, CspTypeVar["1"])
+        _ = TypeAdapter(CspTypeVar["T1"])
+
 
 class TestPydanticTypeResolver_CspTypeVarType(TestCase):
     def test_one_value(self):
@@ -182,6 +188,12 @@ def test_TsType_nested(self):
         context.resolve_tvars()
         self.assertDictEqual(context.tvars, {"T": float})
 
+    def test_bad_variable_name(self):
+        self.assertRaises(SyntaxError, lambda: CspTypeVarType[""])
+        self.assertRaises(SyntaxError, TypeAdapter, CspTypeVarType["~T"])
+        self.assertRaises(SyntaxError, TypeAdapter, CspTypeVarType["1"])
+        _ = TypeAdapter(CspTypeVarType["T1"])
+
 
 T = TypeVar("T")
 

csp/tests/impl/types/test_tstype.py

@@ -2,7 +2,7 @@
 import pytest
 import sys
 from pydantic import TypeAdapter
-from typing import Dict, ForwardRef, Generic, List, Mapping, TypeVar, Union, get_args, get_origin
+from typing import Any, Dict, ForwardRef, Generic, List, Mapping, TypeVar, Union, get_args, get_origin
 from unittest import TestCase
 
 import csp
@@ -105,6 +105,18 @@ def test_allow_null(self):
         ta.validate_python(csp.null_ts(float), context=context)
         ta.validate_python(None, context=context)
 
+    def test_any(self):
+        ta = TypeAdapter(TsType[Any])
+        ta.validate_python(csp.null_ts(float))
+        ta.validate_python(csp.null_ts(object))
+        ta.validate_python(csp.null_ts(List[str]))
+        ta.validate_python(csp.null_ts(Dict[str, List[float]]))
+
+        # https://docs.python.org/3/library/typing.html#the-any-type
+        # "Notice that no type checking is performed when assigning a value of type Any to a more precise type."
+        ta = TypeAdapter(TsType[float])
+        ta.validate_python(csp.null_ts(Any))
+
 
 class TestOutputValidation(TestCase):
     def test_validation(self):