move validation to type

Author: mathiasertl

structured_tutorials/models/tests.py

@@ -6,7 +6,7 @@
 import re
 from typing import Annotated, Literal
 
-from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, field_validator, model_validator
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, model_validator
 
 from structured_tutorials.models.base import CommandBaseModel, CommandType, TestSpecificationMixin
 from structured_tutorials.models.validators import validate_regex
@@ -42,16 +42,6 @@ class TestOutputModel(BaseModel):
     line_count: COUNT_TYPE = Field(default=None, description="Test for the given line count.")
     character_count: COUNT_TYPE = Field(default=None, description="Test for the given character count.")
 
-    @field_validator("line_count", "character_count", mode="after")
-    @classmethod
-    def validate_counts(cls, value: COUNT_TYPE) -> COUNT_TYPE:
-        if isinstance(value, tuple):
-            min, max = value
-            if min is not None and max is not None and min > max:
-                raise ValueError("Minimum is bigger then the maximum.")
-
-        return value
-
     @model_validator(mode="after")
     def validate_tests(self) -> Self:
         if not self.regex and not self.line_count and not self.character_count:

structured_tutorials/models/validators.py

@@ -6,9 +6,23 @@
 import re
 from typing import Any
 
+from pydantic import NonNegativeInt
+
 
 def validate_regex(value: Any) -> Any:
     """Validate and compile a regular expression."""
     if isinstance(value, str):
         return re.compile(value.encode())
     return value  # pragma: no cover
+
+
+def validate_count_tuple(
+    value: tuple[NonNegativeInt | None, NonNegativeInt | None],
+) -> tuple[NonNegativeInt | None, NonNegativeInt | None]:
+    """Validate that min is larger than max in a count tuple."""
+    count_min, count_max = value
+    if count_min is not None and count_max is not None and count_min > count_max:
+        raise ValueError(f"Minimum ({count_min}) is greater than maximum ({count_max}).")
+    if count_min is None and count_max is None:
+        raise ValueError("At least one of minimum or maximum must be specified.")
+    return value

structured_tutorials/typing.py

@@ -3,14 +3,24 @@
 
 """Module that re-exports some type hints."""
 
+from typing import Annotated
+
+from pydantic import AfterValidator, NonNegativeInt
+
+from structured_tutorials.models.validators import validate_count_tuple
+
 try:
     from typing import Self
 except ImportError:  # pragma: no cover
     # Note: only for py3.10
     from typing_extensions import Self
 
+COUNT_TUPLE = Annotated[
+    tuple[NonNegativeInt | None, NonNegativeInt | None], AfterValidator(validate_count_tuple)
+]
+COUNT_TYPE = NonNegativeInt | COUNT_TUPLE | None
 
 __all__ = [
+    "COUNT_TYPE",
     "Self",
 ]
-COUNT_TYPE = int | tuple[int | None, int | None] | None

tests/test_models.py

@@ -182,5 +182,12 @@ def test_output_model_with_empty_value() -> None:
 @pytest.mark.parametrize("field", ("line_count", "character_count"))
 def test_output_model_with_min_max_mismatch(field: str) -> None:
     """Test error for an TestOutputModel where min is bigger than max."""
-    with pytest.raises(ValueError, match=r"Minimum is bigger then the maximum\."):
+    with pytest.raises(ValueError, match=r"Minimum \(1\) is greater than maximum \(0\)\."):
         TestOutputModel.model_validate({field: [1, 0]})
+
+
+@pytest.mark.parametrize("field", ("line_count", "character_count"))
+def test_output_model_with_min_and_max_none(field: str) -> None:
+    """Test error for an TestOutputModel where min and max are both None."""
+    with pytest.raises(ValueError, match=r"At least one of minimum or maximum must be specified\."):
+        TestOutputModel.model_validate({field: [None, None]})