statica 1.0.2__tar.gz → 1.1.0__tar.gz

{statica-1.0.2/statica.egg-info → statica-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statica
-Version: 1.0.2
+Version: 1.1.0
 Summary: A minimalistic data validation library
 Author-email: Marcel Kröker <kroeker.marcel@gmail.com>
 License: MIT License

{statica-1.0.2 → statica-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "statica"
-version = "1.0.2"
+version = "1.1.0"
 description = "A minimalistic data validation library"
 readme = "README.md"
 authors = [{ name = "Marcel Kröker", email = "kroeker.marcel@gmail.com" }]
@@ -59,18 +59,10 @@ ignore = [
 	"ANN202", # Missing return type annotation for private function
 	"ANN401", # Dynamically typed expressions (typing.Any) are disallowed
 	"D", # docstrings
-	"E501", # line length
 	"ERA001", # Found commented-out code
-	"FBT001", # Boolean-typed positional argument in function definition
-	"FIX002", # Line contains TODO, consider resolving the issue
 	"INP001", # File is part of an implicit namespace package. Add an `__init__.py`.
 	"S101", # Use of `assert` detected
 	"T201", # `print` found
-	"TD002", # Missing author in TODO; try: `# TODO(<author_name>): ...`
-	"TD003", # Missing issue link on the line following this TODO
-	"UP006", # use Dict (not possible in python 3.8)
-	"UP007", # use X | Y for union (not possible in python 3.8)
-	"UP035", # use typing Dict and List (not possible in python 3.8)
 	"W191", # indentation contains tabs
 	"PLR0913", # Too many arguments in function definition (6 > 5)
 ]

{statica-1.0.2 → statica-1.1.0}/statica/core.py

@@ -18,6 +18,8 @@ from typing import (
 )
 
 from statica.exceptions import ConstraintValidationError, TypeValidationError
+from statica.types_utils import get_expected_type
+from statica.validators import validate_constraints, validate_type
 
 if TYPE_CHECKING:
 	from collections.abc import Callable, Mapping
@@ -25,95 +27,6 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-########################################################################################
-#### MARK: Internal functions
-
-
-def _type_allows_none(expected_type: Any) -> bool:
-	"""
-	Check if the expected type allows None.
-
-	Examples:
-	.. code-block:: python
-		_allows_none(int | None)  # True
-		_allows_none(int)  # False
-	"""
-	if isinstance(expected_type, UnionType):
-		return type(None) in get_args(expected_type)
-	return expected_type is type(None) or expected_type is Any
-
-
-def _value_matches_type(value: Any | None, expected_type: Any) -> bool:
-	"""
-	Check if the value matches the expected type.
-	Handles basic types, Union types, and generic types.
-
-	Examples:
-	.. code-block:: python
-		_value_matches_type(1, int)  # True
-		_value_matches_type(None, int | None)  # True
-		_value_matches_type(None, int)  # False
-	"""
-	# If expected_type is e.g. int | None, pass if value is None
-	if _type_allows_none(expected_type) and value is None:
-		return True
-
-	# Basic types like int, str, etc.
-	if (origin := get_origin(expected_type)) is None:
-		return isinstance(value, expected_type)
-
-	# Handle Union types
-	if origin is UnionType or origin is type(None) or origin is Any:
-		types = get_args(expected_type)
-		return any(_value_matches_type(value, t) for t in types if t is not type(None))
-
-	# Handle generic types
-	return isinstance(value, origin)
-
-
-def _validate_type(value: Any, expected_type: type | UnionType) -> None:
-	"""
-	Validate that the value matches the expected type.
-	Throws TypeValidationError if the type does not match.
-
-	Examples:
-	.. code-block:: python
-		_validate_type(1, int)  # No exception
-		_validate_type("abc", str)  # No exception
-		_validate_type(1, str)  # Raises TypeValidationError
-		_validate_type(None, int | None)  # No exception
-		_validate_type(None, int)  # Raises TypeValidationError
-	"""
-	if not _value_matches_type(value, expected_type):
-		expected_type_str = str(expected_type) if type(expected_type) is UnionType else expected_type.__name__
-
-		msg = f"expected type '{expected_type_str}', got '{type(value).__name__}'"
-		raise TypeValidationError(msg)
-
-
-def _get_expected_type(cls: type, attr_name: str) -> Any:
-	"""
-	Get the expected type for a class attribute.
-	Handles type hints and Field descriptors.
-
-	Examples:
-	.. code-block:: python
-		class MyClass(Statica):
-			age: int | None
-			name: str = Field()
-
-		_get_expected_type(MyClass, "age")  # int | None
-		_get_expected_type(MyClass, "name")  # str
-	"""
-
-	expected_type = get_type_hints(cls).get(attr_name, Any)
-
-	if get_origin(expected_type) is FieldDescriptor:
-		return get_args(expected_type)[0]  # Get type from generic
-
-	return expected_type
-
-
 ########################################################################################
 #### MARK: Field descriptor
 
@@ -135,10 +48,14 @@ class FieldDescriptor(Generic[T]):
 	strip_whitespace: bool | None = None
 	cast_to: Callable[..., T] | None = None
 
+	alias: str | None = None
+	alias_for_parsing: str | None = None
+	alias_for_serialization: str | None = None
+
 	def __set_name__(self, owner: Any, name: str) -> None:
 		self.name = name
 		self.owner = owner
-		self.expected_type = _get_expected_type(owner, name)
+		self.expected_type = get_expected_type(owner, name)
 
 	@overload
 	def __get__(self, instance: None, owner: Any) -> FieldDescriptor[T]: ...
@@ -159,45 +76,49 @@ class FieldDescriptor(Generic[T]):
 			if self.cast_to is not None:
 				value = self.cast_to(value)
 
-			_validate_type(value, self.expected_type)
+			validate_type(value, self.expected_type)
 
 			if value is not None:
-				value = self._validate_constraints(value)
+				value = validate_constraints(
+					value,
+					min_length=self.min_length,
+					max_length=self.max_length,
+					min_value=self.min_value,
+					max_value=self.max_value,
+					strip_whitespace=self.strip_whitespace,
+				)
 
 		except TypeValidationError as e:
 			msg = f"{self.name}: {e!s}"
 			error_class = getattr(self.owner, "type_error_class", TypeValidationError)
 			raise error_class(msg) from e
+
 		except ConstraintValidationError as e:
 			msg = f"{self.name}: {e!s}"
 			error_class = getattr(self.owner, "constraint_error_class", ConstraintValidationError)
 			raise error_class(msg) from e
+
 		except ValueError as e:
 			msg = f"{self.name}: {e!s}"
 			raise TypeValidationError(msg) from e
+
 		return value
 
-	def _validate_constraints(self, value: Any) -> Any:
-		if self.strip_whitespace and isinstance(value, str):
-			value = value.strip()
-
-		if isinstance(value, str | list | tuple | dict):
-			if self.min_length is not None and len(value) < self.min_length:
-				msg = f"length must be at least {self.min_length}"
-				raise ConstraintValidationError(msg)
-			if self.max_length is not None and len(value) > self.max_length:
-				msg = f"length must be at most {self.max_length}"
-				raise ConstraintValidationError(msg)
-
-		if isinstance(value, int | float):
-			if self.min_value is not None and value < self.min_value:
-				msg = f"must be at least {self.min_value}"
-				raise ConstraintValidationError(msg)
-			if self.max_value is not None and value > self.max_value:
-				msg = f"must be at most {self.max_value}"
-				raise ConstraintValidationError(msg)
 
-		return value
+def get_field_descriptors(cls: type[Statica]) -> list[FieldDescriptor]:
+	"""
+	Get all Field descriptors for a class.
+	Returns a list of FieldDescriptor instances.
+	"""
+
+	descriptors = []
+
+	for field_name in cls.__annotations__:
+		field_descriptor = getattr(cls, field_name)
+		assert isinstance(field_descriptor, FieldDescriptor)
+		descriptors.append(field_descriptor)
+
+	return descriptors
 
 
 ########################################################################################
@@ -212,6 +133,9 @@ def Field(  # noqa: N802
 	max_value: float | None = None,
 	strip_whitespace: bool | None = None,
 	cast_to: Callable[..., T] | None = None,
+	alias: str | None = None,
+	alias_for_parsing: str | None = None,
+	alias_for_serialization: str | None = None,
 ) -> Any:
 	"""
 	Type-safe field function that returns the correct type for type checkers
@@ -225,6 +149,9 @@ def Field(  # noqa: N802
 		max_value=max_value,
 		strip_whitespace=strip_whitespace,
 		cast_to=cast_to,
+		alias=alias,
+		alias_for_parsing=alias_for_parsing,
+		alias_for_serialization=alias_for_serialization,
 	)
 
 	if TYPE_CHECKING:
@@ -248,8 +175,6 @@ class StaticaMeta(type):
 		already, but only for subclasses of Statica.
 		"""
 
-		print(f"__new__({name=}, {bases=}, {namespace=})")
-
 		if name == "Statica":
 			return super().__new__(cls, name, bases, namespace)
 
@@ -296,15 +221,36 @@ class StaticaMeta(type):
 class Statica(metaclass=StaticaMeta):
 	@classmethod
 	def from_map(cls, mapping: Mapping[str, Any]) -> Self:
-		instance = cls(**mapping)
+		mapping_key_to_field_keys = {}  # Maps alias to field name
+
+		for field_descriptor in get_field_descriptors(cls):
+			# Use alias for parsing if it exists
+			alias = field_descriptor.alias_for_parsing or field_descriptor.alias or field_descriptor.name
+			mapping_key_to_field_keys[alias] = field_descriptor.name
+
+		parsed_mapping = {mapping_key_to_field_keys[k]: v for k, v in mapping.items()}
+
+		instance = cls(**parsed_mapping)
 
 		# Go through type hints and set values
 		for attribute_name in get_type_hints(instance.__class__):
-			value = mapping.get(attribute_name)
+			value = parsed_mapping.get(attribute_name)
 			setattr(instance, attribute_name, value)  # Descriptor __set__ validates
 
 		return instance
 
+	def to_dict(self) -> dict[str, Any]:
+		"""
+		Convert the instance to a dictionary, using the field names as keys.
+		"""
+		result = {}
+		for field_descriptor in get_field_descriptors(self.__class__):
+			# Use alias for serialization if it exists
+			alias = field_descriptor.alias_for_serialization or field_descriptor.alias or field_descriptor.name
+			result[alias] = getattr(self, field_descriptor.name)
+
+		return result
+
 
 ########################################################################################
 #### MARK: Main
@@ -317,13 +263,13 @@ if __name__ == "__main__":
 		name: str = Field(min_length=3, max_length=50, strip_whitespace=True)
 		description: str | None = Field(max_length=200)
 		num: int | float
-		float_num: float | None
+		float_num: float | None = Field(alias="floatNum")
 
 	data = {
 		"name": "Test Payload",
 		"description": "ddf",
 		"num": 5,
-		"float_num": 5.5,
+		"floatNum": 5.5,
 	}
 
 	payload = Payload.from_map(data)
@@ -334,10 +280,3 @@ if __name__ == "__main__":
 		num=42,
 		float_num=3.14,
 	)
-
-	class ShortSyntax(Statica):
-		name: str = Field(min_length=3, max_length=5, strip_whitespace=True)
-
-	print("Testing ShortSyntax...")
-	short = ShortSyntax(name="test")
-	print(f"short.name = {short.name}")

statica-1.1.0/statica/types_utils.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from types import UnionType
+from typing import Any, get_args, get_origin, get_type_hints
+
+
+def type_allows_none(expected_type: Any) -> bool:
+	"""
+	Check if the expected type allows None.
+
+	Examples:
+	.. code-block:: python
+		_allows_none(int | None)  # True
+		_allows_none(int)  # False
+	"""
+	if isinstance(expected_type, UnionType):
+		return type(None) in get_args(expected_type)
+	return expected_type is type(None) or expected_type is Any
+
+
+def value_matches_type(value: Any | None, expected_type: Any) -> bool:
+	"""
+	Check if the value matches the expected type.
+	Handles basic types, Union types, and generic types.
+
+	Examples:
+	.. code-block:: python
+		_value_matches_type(1, int)  # True
+		_value_matches_type(None, int | None)  # True
+		_value_matches_type(None, int)  # False
+	"""
+	# If expected_type is e.g. int | None, pass if value is None
+	if type_allows_none(expected_type) and value is None:
+		return True
+
+	# Basic types like int, str, etc.
+	if (origin := get_origin(expected_type)) is None:
+		return isinstance(value, expected_type)
+
+	# Handle Union types
+	if origin is UnionType or origin is type(None) or origin is Any:
+		types = get_args(expected_type)
+		return any(value_matches_type(value, t) for t in types if t is not type(None))
+
+	# Handle generic types
+	return isinstance(value, origin)
+
+
+def get_expected_type(cls: type, attr_name: str) -> Any:
+	"""
+	Get the expected type for a class attribute.
+	Handles type hints and Field descriptors.
+
+	Examples:
+	.. code-block:: python
+		class MyClass(Statica):
+			age: int | None
+			name: str = Field()
+
+		_get_expected_type(MyClass, "age")  # int | None
+		_get_expected_type(MyClass, "name")  # str
+	"""
+
+	return get_type_hints(cls).get(attr_name, Any)

statica-1.1.0/statica/validators.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from types import UnionType
+from typing import Any
+
+from statica.exceptions import ConstraintValidationError, TypeValidationError
+from statica.types_utils import value_matches_type
+
+
+def validate_type(value: Any, expected_type: type | UnionType) -> None:
+	"""
+	Validate that the value matches the expected type.
+	Throws TypeValidationError if the type does not match.
+
+	Examples:
+	.. code-block:: python
+		_validate_type(1, int)  # No exception
+		_validate_type("abc", str)  # No exception
+		_validate_type(1, str)  # Raises TypeValidationError
+		_validate_type(None, int | None)  # No exception
+		_validate_type(None, int)  # Raises TypeValidationError
+	"""
+	if not value_matches_type(value, expected_type):
+		expected_type_str = str(expected_type) if type(expected_type) is UnionType else expected_type.__name__
+
+		msg = f"expected type '{expected_type_str}', got '{type(value).__name__}'"
+		raise TypeValidationError(msg)
+
+
+def validate_constraints(
+	value: Any,
+	min_length: int | None = None,
+	max_length: int | None = None,
+	min_value: float | None = None,
+	max_value: float | None = None,
+	strip_whitespace: bool | None = None,
+) -> Any:
+	"""
+	If the value is a string, strip the whitespace if `strip_whitespace` is True.
+
+	If the value is a string, list, tuple, or dict, check its length against
+	the `min_length` and `max_length` constraints.
+
+	If the value is an int or float, check its value against the `min_value`
+	and `max_value` constraints.
+
+	Throws ConstraintValidationError if any constraints are violated.
+	"""
+
+	if strip_whitespace and isinstance(value, str):
+		value = value.strip()
+
+	if isinstance(value, str | list | tuple | dict):
+		if min_length is not None and len(value) < min_length:
+			msg = f"length must be at least {min_length}"
+			raise ConstraintValidationError(msg)
+		if max_length is not None and len(value) > max_length:
+			msg = f"length must be at most {max_length}"
+			raise ConstraintValidationError(msg)
+
+	if isinstance(value, int | float):
+		if min_value is not None and value < min_value:
+			msg = f"must be at least {min_value}"
+			raise ConstraintValidationError(msg)
+		if max_value is not None and value > max_value:
+			msg = f"must be at most {max_value}"
+			raise ConstraintValidationError(msg)
+
+	return value

{statica-1.0.2 → statica-1.1.0/statica.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statica
-Version: 1.0.2
+Version: 1.1.0
 Summary: A minimalistic data validation library
 Author-email: Marcel Kröker <kroeker.marcel@gmail.com>
 License: MIT License

{statica-1.0.2 → statica-1.1.0}/statica.egg-info/SOURCES.txt

@@ -4,8 +4,13 @@ pyproject.toml
 statica/__init__.py
 statica/core.py
 statica/exceptions.py
+statica/types_utils.py
+statica/validators.py
 statica.egg-info/PKG-INFO
 statica.egg-info/SOURCES.txt
 statica.egg-info/dependency_links.txt
 statica.egg-info/top_level.txt
-tests/test_statica.py
+tests/test_aliasing.py
+tests/test_statica.py
+tests/test_types_utils.py
+tests/test_validators.py

statica-1.1.0/tests/test_aliasing.py

@@ -0,0 +1,163 @@
+import pytest
+
+from statica.core import Field, Statica, TypeValidationError
+from statica.exceptions import ConstraintValidationError
+
+INTEGER = 42
+FLOAT = 19.99
+STRING = "test string"
+
+
+def test_basic_alias() -> None:
+	class AliasTest(Statica):
+		full_name: str = Field(alias="fullName")
+		age: int = Field(alias="userAge")
+
+	# Test parsing with alias
+	data = {"fullName": "John Doe", "userAge": INTEGER}
+	instance = AliasTest.from_map(data)
+	assert instance.full_name == "John Doe"
+	assert instance.age == INTEGER
+	assert instance.to_dict() == data
+
+	# Test that original field names don't work when alias is used
+	with pytest.raises(KeyError):
+		AliasTest.from_map({"full_name": "John Doe", "age": INTEGER})
+
+
+def test_alias_for_parsing() -> None:
+	"""Test alias_for_parsing specifically."""
+
+	class ParseAliasTest(Statica):
+		user_name: str = Field(alias_for_parsing="userName")
+		user_id: int = Field(alias_for_parsing="userId")
+
+	# Test parsing with parsing alias
+	instance = ParseAliasTest.from_map({"userName": "alice", "userId": INTEGER})
+	assert instance.user_name == "alice"
+	assert instance.user_id == INTEGER
+
+
+def test_alias_priority() -> None:
+	"""Test that alias_for_parsing takes priority over general alias."""
+
+	class PriorityTest(Statica):
+		field_name: str = Field(alias="generalAlias", alias_for_parsing="parseAlias")
+
+	# Should use alias_for_parsing
+	instance = PriorityTest.from_map({"parseAlias": STRING})
+	assert instance.field_name == STRING
+
+	# General alias should not work when alias_for_parsing exists
+	with pytest.raises(KeyError):
+		PriorityTest.from_map({"generalAlias": STRING})
+
+
+def test_alias_with_optional_fields() -> None:
+	"""Test aliases with optional fields."""
+
+	class OptionalAliasTest(Statica):
+		required_field: str = Field(alias="reqField")
+		optional_field: str | None = Field(alias="optField")
+
+	# Test with both fields provided
+	instance = OptionalAliasTest.from_map({"reqField": "required", "optField": "optional"})
+	assert instance.required_field == "required"
+	assert instance.optional_field == "optional"
+
+	# Test with only required field
+	instance = OptionalAliasTest.from_map({"reqField": "required"})
+	assert instance.required_field == "required"
+	assert instance.optional_field is None
+
+	# Test missing required field should still raise error
+	with pytest.raises(TypeValidationError):
+		OptionalAliasTest.from_map({"optField": "optional"})
+
+
+def test_alias_with_constraints() -> None:
+	"""Test that aliases work with field constraints."""
+
+	class ConstraintAliasTest(Statica):
+		name: str = Field(alias="userName", min_length=3, max_length=10, strip_whitespace=True)
+		score: int = Field(alias="userScore", min_value=0, max_value=100)
+
+	# Test valid values
+	instance = ConstraintAliasTest.from_map({"userName": " Alice ", "userScore": INTEGER})
+	assert instance.name == "Alice"  # Whitespace should be stripped
+	assert instance.score == INTEGER
+
+	# Test constraint violations with aliases
+	with pytest.raises(ConstraintValidationError):  # Should be ConstraintValidationError
+		ConstraintAliasTest.from_map({"userName": "Al", "userScore": INTEGER})  # Too short
+
+	with pytest.raises(ConstraintValidationError):  # Should be ConstraintValidationError
+		ConstraintAliasTest.from_map({"userName": "Alice", "userScore": 150})  # Too high
+
+
+def test_alias_with_casting() -> None:
+	"""Test that aliases work with type casting."""
+
+	class CastAliasTest(Statica):
+		number: int = Field(alias="numStr", cast_to=int)
+		price: float = Field(alias="priceStr", cast_to=float)
+
+	instance = CastAliasTest.from_map({"numStr": "42", "priceStr": "19.99"})
+	assert instance.number == INTEGER
+	assert instance.price == FLOAT
+
+
+def test_mixed_alias_and_no_alias() -> None:
+	"""Test mixing fields with and without aliases."""
+
+	class MixedTest(Statica):
+		normal_field: str
+		aliased_field: str = Field(alias="aliasedField")
+		another_normal: int
+
+	instance = MixedTest.from_map(
+		{
+			"normal_field": "normal",
+			"aliasedField": "aliased",
+			"another_normal": INTEGER,
+		},
+	)
+	assert instance.normal_field == "normal"
+	assert instance.aliased_field == "aliased"
+	assert instance.another_normal == INTEGER
+
+
+def test_alias_serialization() -> None:
+	class SerializationTest(Statica):
+		field_name: str = Field(alias_for_serialization="serialAlias")
+
+	instance = SerializationTest(field_name=STRING)
+
+	assert instance.to_dict() == {"serialAlias": STRING}
+
+
+def test_all_alias_types_together() -> None:
+	"""Test a field with all three alias types."""
+
+	class AllAliasTest(Statica):
+		field_name: str = Field(
+			alias="generalAlias",
+			alias_for_parsing="parseAlias",
+			alias_for_serialization="serializeAlias",
+		)
+
+	# Should use alias_for_parsing for parsing
+	instance = AllAliasTest.from_map({"parseAlias": STRING})
+	assert instance.field_name == STRING
+	assert instance.to_dict() == {"serializeAlias": STRING}
+
+
+def test_empty_alias_mapping() -> None:
+	"""Test behavior when no matching aliases are found in the mapping."""
+
+	class EmptyMappingTest(Statica):
+		field_name: str = Field(alias="expectedAlias")
+
+	# Should raise KeyError when the aliased field is missing
+	with pytest.raises(KeyError):
+		EmptyMappingTest.from_map({"wrongAlias": "value"})

{statica-1.0.2 → statica-1.1.0}/tests/test_statica.py

@@ -1,50 +1,6 @@
 import pytest
 
-from statica.core import (
-	ConstraintValidationError,
-	Field,
-	Statica,
-	TypeValidationError,
-	_get_expected_type,
-	_type_allows_none,
-	_validate_type,
-	_value_matches_type,
-)
-
-
-def test_allows_none() -> None:
-	assert _type_allows_none(type(None))
-	assert _type_allows_none(int | None)
-	assert not _type_allows_none(int)
-
-
-def test_value_matches_type() -> None:
-	assert _value_matches_type(1, int)
-	assert _value_matches_type("abc", str)
-	assert not _value_matches_type(1, str)
-	assert _value_matches_type(None, int | None)
-	assert _value_matches_type(1, int | None)
-	assert not _value_matches_type(None, int)
-	assert _value_matches_type(1, int | None)
-	assert not _value_matches_type("abc", int | None)
-
-
-def test_validate_type() -> None:
-	# No exceptions should be raised for valid types
-	_validate_type(1, int)
-	_validate_type("abc", str)
-	_validate_type(None, int | None)
-	_validate_type(1, int | None)
-
-	# Exceptions should be raised for invalid types
-	with pytest.raises(TypeValidationError):
-		_validate_type(1, str)
-	with pytest.raises(TypeValidationError):
-		_validate_type("abc", int)
-	with pytest.raises(TypeValidationError):
-		_validate_type(None, int)
-	with pytest.raises(TypeValidationError):
-		_validate_type("abc", int | None)
+from statica.core import ConstraintValidationError, Field, Statica, TypeValidationError, get_expected_type
 
 
 def test_get_expected_type() -> None:
@@ -54,10 +10,10 @@ def test_get_expected_type() -> None:
 		required_with_field: str = Field()
 		optional_with_field: str | None = Field()
 
-	assert _get_expected_type(TestClass, "required_field") is str
-	assert _get_expected_type(TestClass, "optional_field") == str | None
-	assert _get_expected_type(TestClass, "required_with_field") is str
-	assert _get_expected_type(TestClass, "optional_with_field") == str | None
+	assert get_expected_type(TestClass, "required_field") is str
+	assert get_expected_type(TestClass, "optional_field") == str | None
+	assert get_expected_type(TestClass, "required_with_field") is str
+	assert get_expected_type(TestClass, "optional_with_field") == str | None
 
 
 def test_basic_syntax() -> None:
@@ -231,7 +187,3 @@ def test_cast() -> None:
 
 	with pytest.raises(TypeValidationError):
 		IntTest.from_map({"num": "5.5"})
-
-
-if __name__ == "__main__":
-	pytest.main([__file__])

statica-1.1.0/tests/test_types_utils.py

@@ -0,0 +1,33 @@
+from typing import Generic, TypeVar
+
+from statica.types_utils import type_allows_none, value_matches_type
+
+
+def test_allows_none() -> None:
+	assert type_allows_none(type(None))
+	assert type_allows_none(int | None)
+	assert not type_allows_none(int)
+
+
+def test_value_matches_type() -> None:
+	assert value_matches_type(1, int)
+	assert value_matches_type("abc", str)
+	assert not value_matches_type(1, str)
+	assert value_matches_type(None, int | None)
+	assert value_matches_type(1, int | None)
+	assert not value_matches_type(None, int)
+	assert value_matches_type(1, int | None)
+	assert not value_matches_type("abc", int | None)
+
+	# Test with generics
+
+	T = TypeVar("T")
+
+	class GenericTest(Generic[T]):
+		value: T
+
+		def __init__(self, value: T) -> None:
+			self.value = value
+
+	assert value_matches_type(GenericTest[int](1), GenericTest[int])
+	assert value_matches_type(GenericTest[int](1), GenericTest[str])  # Is this correct?

statica-1.1.0/tests/test_validators.py

@@ -0,0 +1,37 @@
+from typing import Generic, TypeVar
+
+import pytest
+
+from statica.core import TypeValidationError
+from statica.validators import validate_type
+
+
+def test_validate_type() -> None:
+	# No exceptions should be raised for valid types
+
+	validate_type(1, int)
+	validate_type("abc", str)
+	validate_type(None, int | None)
+	validate_type(1, int | None)
+
+	# Exceptions should be raised for invalid types
+
+	with pytest.raises(TypeValidationError):
+		validate_type(1, str)
+	with pytest.raises(TypeValidationError):
+		validate_type("abc", int)
+	with pytest.raises(TypeValidationError):
+		validate_type(None, int)
+	with pytest.raises(TypeValidationError):
+		validate_type("abc", int | None)
+
+	# Test with generics
+
+	T = TypeVar("T")
+
+	class GenericTest(Generic[T]):
+		value: T
+
+	validate_type(GenericTest[int](), GenericTest[int])
+
+	validate_type(GenericTest[str](), GenericTest[str])  # Is this correct?