statica 1.1.0__tar.gz → 1.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statica
-Version: 1.1.0
+Version: 1.2.0
 Summary: A minimalistic data validation library
 Author-email: Marcel Kröker <kroeker.marcel@gmail.com>
 License: MIT License
@@ -31,7 +31,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <3.14,>=3.11
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 
 # Statica
@@ -44,13 +44,13 @@ Statica is a Python library for defining and validating structured data with typ
 
 ## Why Statica?
 
-Statica was created to address the need for a lightweight, flexible, and dependency-free alternative to libraries like pydantic. 
+Statica was created to address the need for a lightweight, flexible, and dependency-free alternative to libraries like pydantic.
 While pydantic is a powerful tool for data validation and parsing, Statica offers some distinct advantages in specific situations:
 
 1. **Lightweight**: Statica does not rely on any third-party dependencies, making it ideal for projects where minimizing external dependencies is a priority.
-2. **Customizable Validation**: Statica allows fine-grained control over type and constraint validation through customizable field descriptors (`Field`) and error classes.
+2. **Performance**: For use cases where performance is critical. Pydantic needs `3x` more memory than Statica for the same models.
 3. **Ease of Use**: With its simple, Pythonic design, Statica is intuitive for developers already familiar with Python's `dataclasses` and type hinting. It avoids much of the magic that pydantic employs.
-4. **Performance**: For use cases where performance, especially memory usage, is critical, Statica avoids some of the overhead introduced by the advanced features of pydantic.
+4. **Customizable Validation**: Statica allows fine-grained control over type and constraint validation through customizable field descriptors (`Field`) and error classes.
 
 ## Features
 

{statica-1.1.0 → statica-1.2.0}/README.md

@@ -8,13 +8,13 @@ Statica is a Python library for defining and validating structured data with typ
 
 ## Why Statica?
 
-Statica was created to address the need for a lightweight, flexible, and dependency-free alternative to libraries like pydantic. 
+Statica was created to address the need for a lightweight, flexible, and dependency-free alternative to libraries like pydantic.
 While pydantic is a powerful tool for data validation and parsing, Statica offers some distinct advantages in specific situations:
 
 1. **Lightweight**: Statica does not rely on any third-party dependencies, making it ideal for projects where minimizing external dependencies is a priority.
-2. **Customizable Validation**: Statica allows fine-grained control over type and constraint validation through customizable field descriptors (`Field`) and error classes.
+2. **Performance**: For use cases where performance is critical. Pydantic needs `3x` more memory than Statica for the same models.
 3. **Ease of Use**: With its simple, Pythonic design, Statica is intuitive for developers already familiar with Python's `dataclasses` and type hinting. It avoids much of the magic that pydantic employs.
-4. **Performance**: For use cases where performance, especially memory usage, is critical, Statica avoids some of the overhead introduced by the advanced features of pydantic.
+4. **Customizable Validation**: Statica allows fine-grained control over type and constraint validation through customizable field descriptors (`Field`) and error classes.
 
 ## Features
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "statica"
-version = "1.1.0"
+version = "1.2.0"
 description = "A minimalistic data validation library"
 readme = "README.md"
 authors = [{ name = "Marcel Kröker", email = "kroeker.marcel@gmail.com" }]
@@ -13,7 +13,7 @@ classifiers=[
 	"Programming Language :: Python",
 	"Topic :: Software Development :: Libraries :: Python Modules"
 ]
-requires-python = ">=3.11, <3.14"
+requires-python = ">=3.10, <3.14"
 
 
 ########################################################################################
@@ -26,6 +26,7 @@ dependencies = []
 [dependency-groups]
 dev = [
 	"mypy ~= 1.16.0",
+	"pyinstrument>=5.0.2",
 	"pytest-cov ~= 6.1.0",
 	"ruff ~= 0.11.0",
 ]
@@ -77,6 +78,9 @@ quote-style = "double"
 #### MARK: Testing
 
 [tool.coverage.report]
+omit = [
+    "benchmark_*.py",
+]
 exclude_also = [
 	"if TYPE_CHECKING:",
 	'if __name__ == "__main__":',

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

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from dataclasses import field as dataclass_field
-from types import UnionType
 from typing import (
 	TYPE_CHECKING,
 	Any,
@@ -11,14 +10,11 @@ from typing import (
 	TypeVar,
 	cast,
 	dataclass_transform,
-	get_args,
-	get_origin,
 	get_type_hints,
 	overload,
 )
 
 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:
@@ -55,7 +51,7 @@ class FieldDescriptor(Generic[T]):
 	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 = owner.__annotations__.get(name)
 
 	@overload
 	def __get__(self, instance: None, owner: Any) -> FieldDescriptor[T]: ...
@@ -78,7 +74,13 @@ class FieldDescriptor(Generic[T]):
 
 			validate_type(value, self.expected_type)
 
-			if value is not None:
+			if (
+				self.min_length is not None
+				or self.max_length is not None
+				or self.min_value is not None
+				or self.max_value is not None
+				or self.strip_whitespace is not None
+			):
 				value = validate_constraints(
 					value,
 					min_length=self.min_length,
@@ -182,20 +184,15 @@ class StaticaMeta(type):
 
 		# Generate custom __init__ method
 
-		def custom_init(self: Statica, **kwargs: Any) -> None:
+		def statica_init(self: Statica, **kwargs: Any) -> None:
 			for field_name, field_type in annotations.items():
-				# If it is union type with none continuation, skip it
-				if get_origin(field_type) is UnionType and type(None) in get_args(field_type):
-					if field_name not in kwargs:
-						setattr(self, field_name, None)
-					continue
-
-				if field_name not in kwargs:
+				if field_name not in kwargs and not isinstance(None, field_type):
 					msg = f"Missing required field: {field_name}"
 					raise TypeValidationError(msg)
-				setattr(self, field_name, kwargs[field_name])
 
-		namespace["__init__"] = custom_init
+				setattr(self, field_name, kwargs.get(field_name))
+
+		namespace["__init__"] = statica_init
 
 		# Set up Field descriptors for type-hinted attributes
 

{statica-1.1.0 → statica-1.2.0}/statica/validators.py

@@ -4,7 +4,6 @@ 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:
@@ -20,11 +19,12 @@ def validate_type(value: Any, expected_type: type | UnionType) -> None:
 		_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__
+	if isinstance(value, expected_type):
+		return
 
-		msg = f"expected type '{expected_type_str}', got '{type(value).__name__}'"
-		raise TypeValidationError(msg)
+	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(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statica
-Version: 1.1.0
+Version: 1.2.0
 Summary: A minimalistic data validation library
 Author-email: Marcel Kröker <kroeker.marcel@gmail.com>
 License: MIT License
@@ -31,7 +31,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <3.14,>=3.11
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 
 # Statica
@@ -44,13 +44,13 @@ Statica is a Python library for defining and validating structured data with typ
 
 ## Why Statica?
 
-Statica was created to address the need for a lightweight, flexible, and dependency-free alternative to libraries like pydantic. 
+Statica was created to address the need for a lightweight, flexible, and dependency-free alternative to libraries like pydantic.
 While pydantic is a powerful tool for data validation and parsing, Statica offers some distinct advantages in specific situations:
 
 1. **Lightweight**: Statica does not rely on any third-party dependencies, making it ideal for projects where minimizing external dependencies is a priority.
-2. **Customizable Validation**: Statica allows fine-grained control over type and constraint validation through customizable field descriptors (`Field`) and error classes.
+2. **Performance**: For use cases where performance is critical. Pydantic needs `3x` more memory than Statica for the same models.
 3. **Ease of Use**: With its simple, Pythonic design, Statica is intuitive for developers already familiar with Python's `dataclasses` and type hinting. It avoids much of the magic that pydantic employs.
-4. **Performance**: For use cases where performance, especially memory usage, is critical, Statica avoids some of the overhead introduced by the advanced features of pydantic.
+4. **Customizable Validation**: Statica allows fine-grained control over type and constraint validation through customizable field descriptors (`Field`) and error classes.
 
 ## Features
 

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

@@ -4,7 +4,6 @@ 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
@@ -12,5 +11,4 @@ statica.egg-info/dependency_links.txt
 statica.egg-info/top_level.txt
 tests/test_aliasing.py
 tests/test_statica.py
-tests/test_types_utils.py
 tests/test_validators.py

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

@@ -1,19 +1,6 @@
 import pytest
 
-from statica.core import ConstraintValidationError, Field, Statica, TypeValidationError, get_expected_type
-
-
-def test_get_expected_type() -> None:
-	class TestClass(Statica):
-		required_field: str
-		optional_field: str | 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
+from statica.core import ConstraintValidationError, Field, Statica, TypeValidationError
 
 
 def test_basic_syntax() -> None:

{statica-1.1.0 → statica-1.2.0}/tests/test_validators.py

@@ -1,5 +1,3 @@
-from typing import Generic, TypeVar
-
 import pytest
 
 from statica.core import TypeValidationError
@@ -24,14 +22,3 @@ def test_validate_type() -> None:
 		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?

statica-1.1.0/statica/types_utils.py

@@ -1,64 +0,0 @@
-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/tests/test_types_utils.py

@@ -1,33 +0,0 @@
-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?