Support Pydantic validators (#101)

* Remove comment

* Add validators

* Test validators

* Remove validation functions for numeric types

* Test validation

* Split test function in several functions

Author: AdrienVannson

src/betterproto2/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__all__ = ["__version__", "check_compiler_version", "unwrap", "MessagePool"]
+__all__ = ["__version__", "check_compiler_version", "unwrap", "MessagePool", "validators"]
 
 import dataclasses
 import enum as builtin_enum
@@ -20,6 +20,7 @@
 
 from typing_extensions import Self
 
+import betterproto2.validators as validators
 from betterproto2.message_pool import MessagePool
 from betterproto2.utils import unwrap
 
@@ -1068,7 +1069,6 @@ def to_dict(
 
     @classmethod
     def _from_dict_init(cls, mapping: Mapping[str, Any] | Any) -> Mapping[str, Any]:
-        # TODO restructure using other function
         init_kwargs: dict[str, Any] = {}
         for key, value in mapping.items():
             field_name = safe_snake_case(key)

src/betterproto2/validators/__init__.py

@@ -0,0 +1,3 @@
+from .proto_types import validate_float32, validate_string
+
+__all__ = ["validate_float32", "validate_string"]

src/betterproto2/validators/proto_types.py

@@ -0,0 +1,30 @@
+"""
+Pydantic validators for Protocol Buffer standard types.
+
+This module provides validator functions that can be used with Pydantic
+to validate Protocol Buffer standard types (int32, int64, sfixed32, etc.)
+to ensure they conform to their respective constraints.
+
+These validators are designed to be used as "after validators", meaning the value
+will already be of the correct type and only bounds checking is needed.
+"""
+
+import struct
+
+
+def validate_float32(v: float) -> float:
+    try:
+        packed = struct.pack("!f", v)
+        struct.unpack("!f", packed)
+    except (struct.error, OverflowError):
+        raise ValueError(f"Value cannot be encoded as a float: {v}")
+
+    return v
+
+
+def validate_string(v: str) -> str:
+    try:
+        v.encode("utf-8").decode("utf-8")
+    except UnicodeError:
+        raise ValueError("String contains invalid UTF-8 characters")
+    return v

tests/test_validation.py

@@ -0,0 +1,172 @@
+import pydantic
+import pytest
+
+
+def test_int32_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(int32_value=1)
+    Message(int32_value=-(2**31))
+    Message(int32_value=(2**31 - 1))
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(int32_value=2**31)
+    with pytest.raises(pydantic.ValidationError):
+        Message(int32_value=-(2**31) - 1)
+
+
+def test_int64_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(int64_value=1)
+    Message(int64_value=-(2**63))
+    Message(int64_value=(2**63 - 1))
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(int64_value=2**63)
+    with pytest.raises(pydantic.ValidationError):
+        Message(int64_value=-(2**63) - 1)
+
+
+def test_uint32_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(uint32_value=0)
+    Message(uint32_value=2**32 - 1)
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(uint32_value=-1)
+    with pytest.raises(pydantic.ValidationError):
+        Message(uint32_value=2**32)
+
+
+def test_uint64_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(uint64_value=0)
+    Message(uint64_value=2**64 - 1)
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(uint64_value=-1)
+    with pytest.raises(pydantic.ValidationError):
+        Message(uint64_value=2**64)
+
+
+def test_sint32_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(sint32_value=1)
+    Message(sint32_value=-(2**31))
+    Message(sint32_value=(2**31 - 1))
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(sint32_value=2**31)
+    with pytest.raises(pydantic.ValidationError):
+        Message(sint32_value=-(2**31) - 1)
+
+
+def test_sint64_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(sint64_value=1)
+    Message(sint64_value=-(2**63))
+    Message(sint64_value=(2**63 - 1))
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(sint64_value=2**63)
+    with pytest.raises(pydantic.ValidationError):
+        Message(sint64_value=-(2**63) - 1)
+
+
+def test_fixed32_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(fixed32_value=0)
+    Message(fixed32_value=2**32 - 1)
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(fixed32_value=-1)
+    with pytest.raises(pydantic.ValidationError):
+        Message(fixed32_value=2**32)
+
+
+def test_fixed64_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(fixed64_value=0)
+    Message(fixed64_value=2**64 - 1)
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(fixed64_value=-1)
+    with pytest.raises(pydantic.ValidationError):
+        Message(fixed64_value=2**64)
+
+
+def test_sfixed32_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(sfixed32_value=1)
+    Message(sfixed32_value=-(2**31))
+    Message(sfixed32_value=(2**31 - 1))
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(sfixed32_value=2**31)
+    with pytest.raises(pydantic.ValidationError):
+        Message(sfixed32_value=-(2**31) - 1)
+
+
+def test_sfixed64_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(sfixed64_value=1)
+    Message(sfixed64_value=-(2**63))
+    Message(sfixed64_value=(2**63 - 1))
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(sfixed64_value=2**63)
+    with pytest.raises(pydantic.ValidationError):
+        Message(sfixed64_value=-(2**63) - 1)
+
+
+def test_float_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(float_value=0.0)
+    Message(float_value=3.14)
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(float_value=3.5e38)
+
+
+def test_string_validation():
+    from .output_betterproto_pydantic.validation import Message
+
+    # Test valid values
+    Message(string_value="")
+    Message(string_value="Hello World")
+
+    # Test invalid values
+    with pytest.raises(pydantic.ValidationError):
+        Message(string_value="Hello \udc00 World")