Merge branch 'main' into tkp/ruffclean

Author: timkpaine

CMakeLists.txt

@@ -2,7 +2,7 @@
 # Project Configuration #
 #########################
 cmake_minimum_required(VERSION 3.20.0)
-project(csp VERSION "0.0.10")
+project(csp VERSION "0.0.11")
 set(CMAKE_CXX_STANDARD 20)
 
 ###################################################################################################################################################

csp/__init__.py

@@ -31,7 +31,7 @@
 
 from . import stats
 
-__version__ = "0.0.10"
+__version__ = "0.0.11"
 
 
 def get_include_path():

csp/impl/types/pydantic_types.py

@@ -36,6 +36,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
@@ -56,6 +64,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

@@ -100,9 +100,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
     """
 
@@ -126,7 +126,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])
@@ -163,12 +163,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

@@ -92,6 +92,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):
@@ -183,6 +189,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

@@ -1,5 +1,5 @@
 import sys
-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 numpy as np
@@ -106,6 +106,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):

pyproject.toml

@@ -16,7 +16,7 @@ name = "csp"
 authors = [{name = "the csp authors", email = "[email protected]"}]
 description="csp is a high performance reactive stream processing library, written in C++ and Python"
 readme = "README.md"
-version = "0.0.10"
+version = "0.0.11"
 requires-python = ">=3.9"
 
 dependencies = [
@@ -116,7 +116,7 @@ slack = [
 ]
 
 [tool.bumpversion]
-current_version = "0.0.10"
+current_version = "0.0.11"
 commit = false
 tag = false
 commit_args = "-s"

setup.py

@@ -122,7 +122,7 @@
 
 setup(
     name="csp",
-    version="0.0.10",
+    version="0.0.11",
     packages=["csp"],
     cmake_install_dir="csp",
     cmake_args=cmake_args,