ignoring_none

Author: Tinche

src/cattrs/v/__init__.py

@@ -8,17 +8,18 @@
     IterableValidationError,
 )
 from ._fluent import V, customize
-from ._validators import between, greater_than, is_unique, len_between
+from ._validators import between, greater_than, ignoring_none, is_unique, len_between
 
 __all__ = [
+    "between",
     "customize",
     "format_exception",
-    "transform_error",
-    "V",
-    "between",
     "greater_than",
-    "len_between",
+    "ignoring_none",
     "is_unique",
+    "len_between",
+    "transform_error",
+    "V",
 ]
 
 
@@ -109,21 +110,21 @@ def transform_error(
         with_notes, without = exc.group_exceptions()
         for exc, note in with_notes:
             p = f"{path}.{note.name}"
-            if isinstance(exc, (ClassValidationError, IterableValidationError)):
+            if isinstance(exc, ExceptionGroup):
                 errors.extend(transform_error(exc, p, format_exception))
-            elif isinstance(exc, ExceptionGroup):
-                # A bare ExceptionGroup is now used to group all validator failures.
-                errors.extend(
-                    [
-                        line
-                        for inner in exc.exceptions
-                        for line in transform_error(inner, p, format_exception)
-                    ]
-                )
             else:
                 errors.append(f"{format_exception(exc, note.type)} @ {p}")
         for exc in without:
             errors.append(f"{format_exception(exc, None)} @ {path}")
+    elif isinstance(exc, ExceptionGroup):
+        # Likely from a nested validator, needs flattening.
+        errors.extend(
+            [
+                line
+                for inner in exc.exceptions
+                for line in transform_error(inner, path, format_exception)
+            ]
+        )
     else:
         errors.append(f"{format_exception(exc, None)} @ {path}")
     return errors

src/cattrs/v/_fluent.py

@@ -8,16 +8,25 @@
 except ImportError:
     from typing_extensions import assert_never
 
+try:
+    from typing import TypeGuard
+except ImportError:
+    from typing_extensions import TypeGuard
+
+from inspect import signature
+
 from attrs import Attribute, AttrsInstance, define
 from attrs import fields as f
 
-from cattrs import BaseConverter
-from cattrs._compat import ExceptionGroup
-from cattrs.dispatch import StructureHook
-from cattrs.gen import make_dict_structure_fn, override
+from .. import BaseConverter
+from .._compat import ExceptionGroup, TypeAlias
+from ..dispatch import StructureHook
+from ..gen import make_dict_structure_fn, override
 
 T = TypeVar("T")
 
+ValidatorFactory: TypeAlias = Callable[[bool], Callable[[T], None]]
+
 
 @define
 class VOmitted:
@@ -33,16 +42,16 @@ class VOmitted:
 class VRenamed(Generic[T]):
     """This attribute has been renamed.
 
-    This class has no `omit` and no `rename`..
+    This class has no `omit` and no `rename`.
     """
 
     attr: Attribute[T]
     new_name: str
 
     def ensure(
         self: VRenamed[T],
-        validator: Callable[[T], None | bool],
-        *validators: Callable[[T], None | bool],
+        validator: Callable[[T], None | bool] | ValidatorFactory[T],
+        *validators: Callable[[T], None | bool] | ValidatorFactory[T],
     ) -> VCustomized[T]:
         return VCustomized(self.attr, self.new_name, (validator, *validators))
 
@@ -56,7 +65,7 @@ class VCustomized(Generic[T]):
 
     attr: Attribute[T]
     new_name: str | None
-    hooks: tuple[Callable[[T], None | bool], ...] = ()
+    validators: tuple[Callable[[T], None | bool] | ValidatorFactory[T], ...] = ()
 
 
 @define
@@ -73,18 +82,17 @@ class V(Generic[T]):
 
     def __init__(self, attr: Attribute[T]) -> None:
         self.attr = attr
-        self.hooks = ()
+        self.validators = ()
 
     attr: Attribute[T]
-    hooks: tuple[Callable[[T], None], ...] = ()
+    validators: tuple[Callable[[T], None | bool] | ValidatorFactory[T], ...] = ()
 
     def ensure(
         self: V[T],
-        validator: Callable[[T], None | bool],
-        *validators: Callable[[T], None],
+        validator: Callable[[T], None | bool] | ValidatorFactory[T],
+        *validators: Callable[[T], None] | ValidatorFactory[T],
     ) -> VCustomized[T]:
-        hooks = (*self.hooks, validator, *validators)
-        return VCustomized(self.attr, None, hooks)
+        return VCustomized(self.attr, None, (*self.validators, validator, *validators))
 
     def rename(self: V[T], new_name: str) -> VRenamed[T]:
         """Rename the attribute after processing."""
@@ -94,32 +102,11 @@ def omit(self) -> VOmitted:
         """Omit the attribute."""
         return VOmitted(self.attr)
 
-    def replace_with(self, value: T) -> VOmitted:
+    def replace_on_structure(self, value: T) -> VOmitted:
         """This attribute should be replaced with a value when structuring."""
         return VOmitted(self.attr)
 
 
-def ignoring_none(*validators: Callable[[T], None]) -> Callable[[T | None], None]:
-    """
-    A validator for (f.e.) strings cannot be applied to `str | None`, but it can
-    be wrapped with this to adapt it so it can.
-    """
-
-    def skip_none(val: T | None) -> None:
-        if val is None:
-            return
-        errors = []
-        for validator in validators:
-            try:
-                validator(val)
-            except Exception as exc:
-                errors.append(exc)
-        if errors:
-            raise ExceptionGroup("", errors)
-
-    return skip_none
-
-
 def all_elements_must(
     validator: Callable[[T], None | bool], *validators: Callable[[T], None | bool]
 ) -> Callable[[Iterable[T]], None | bool]:
@@ -145,9 +132,22 @@ def assert_all_elements(val: Iterable[T]) -> None:
     return assert_all_elements
 
 
+def _is_validator_factory(
+    validator: Callable[[Any], None | bool] | ValidatorFactory[T]
+) -> TypeGuard[ValidatorFactory[T]]:
+    """Figure out if this is a validator factory or not."""
+    sig = signature(validator)
+    ra = sig.return_annotation
+    return (
+        callable(ra)
+        or isinstance(ra, str)
+        and sig.return_annotation.startswith("Callable")
+    )
+
+
 def _compose_validators(
     base_structure: StructureHook,
-    validators: Sequence[Callable[[Any], None | bool]],
+    validators: Sequence[Callable[[Any], None | bool] | ValidatorFactory],
     detailed_validation: bool,
 ) -> Callable[[Any, Any], Any]:
     """Produce a hook composing the base structuring hook and additional validators.
@@ -157,11 +157,17 @@ def _compose_validators(
     The new hook will raise an ExceptionGroup.
     """
     bs = base_structure
+    final_validators = []
+    for val in validators:
+        if _is_validator_factory(val):
+            final_validators.append(val(detailed_validation))
+        else:
+            final_validators.append(val)
 
     if detailed_validation:
 
         def structure_hook(
-            val: dict[str, Any], t: Any, _hooks=validators, _bs=bs
+            val: dict[str, Any], t: Any, _hooks=final_validators, _bs=bs
         ) -> Any:
             res = _bs(val, t)
             errors: list[Exception] = []
@@ -177,7 +183,7 @@ def structure_hook(
     else:
 
         def structure_hook(
-            val: dict[str, Any], t: Any, _hooks=validators, _bs=bs
+            val: dict[str, Any], t: Any, _hooks=final_validators, _bs=bs
         ) -> Any:
             res = _bs(val, t)
             for hook in _hooks:
@@ -221,7 +227,7 @@ def customize(
             overrides[field.attr.name] = override(rename=field.new_name)
         elif isinstance(field, VCustomized):
             base_hook = converter._structure_func.dispatch(field.attr.type)
-            hook = _compose_validators(base_hook, field.hooks, detailed_validation)
+            hook = _compose_validators(base_hook, field.validators, detailed_validation)
             overrides[field.attr.name] = override(
                 rename=field.new_name, struct_hook=hook
             )

src/cattrs/v/_validators.py

@@ -3,6 +3,8 @@
 from collections.abc import Hashable
 from typing import Callable, Collection, Protocol, Sized, TypeVar
 
+from ._fluent import ValidatorFactory
+
 T = TypeVar("T")
 
 
@@ -52,3 +54,42 @@ def is_unique(val: Collection[Hashable]) -> None:
         raise ValueError(
             f"Collection ({length} elem(s)) not unique, only {unique_length} unique elem(s)"
         )
+
+
+def ignoring_none(
+    validator: Callable[[T], None], *validators: Callable[[T], None]
+) -> ValidatorFactory[T | None]:
+    """
+    Wrap validators with this so they can be applied to types that include `None`.
+
+    Values that are equal to `None` are passed through.
+    """
+
+    validators = (validator, *validators)
+
+    def factory(detailed_validation: bool) -> Callable[[T | None], None]:
+        if detailed_validation:
+
+            def skip_none(val: T | None, _validators=validators) -> None:
+                if val is None:
+                    return
+                errors = []
+                for validator in _validators:
+                    try:
+                        validator(val)
+                    except Exception as exc:
+                        errors.append(exc)
+                if errors:
+                    raise ExceptionGroup("", errors)
+
+        else:
+
+            def skip_none(val: T | None, _validators=validators) -> None:
+                if val is None:
+                    return
+                for validator in _validators:
+                    validator(val)
+
+        return skip_none
+
+    return factory

tests/v/test_mypy.yml tests/v/test_typing_fluent.ymltests/v/test_mypy.yml renamed to tests/v/test_typing_fluent.yml

@@ -48,4 +48,4 @@
 
     c = Converter()
 
-    v.customize(c, A, v.V(f(A).a).ensure(v.len_between(0, 10)))  # E: Argument 1 to "ensure" of "V" has incompatible type "Callable[[Sized], None]"; expected "Callable[[int], bool | None]"  [arg-type]
+    v.customize(c, A, v.V(f(A).a).ensure(v.len_between(0, 10)))  # E: Argument 1 to "ensure" of "V" has incompatible type "Callable[[Sized], None]"; expected "Callable[[int], bool | None] | Callable[[bool], Callable[[int], None]]"  [arg-type]

tests/v/test_validators_mypy.yml tests/v/test_typing_validators.ymltests/v/test_validators_mypy.yml renamed to tests/v/test_typing_validators.yml

@@ -61,4 +61,31 @@
 
     c = Converter()
 
-    v.customize(c, A, v.V(fields(A).a).ensure(v.is_unique))  # E: Argument 1 to "ensure" of "V" has incompatible type "Callable[[Collection[Hashable]], None]"; expected "Callable[[list[dict[Any, Any]]], bool | None]"  [arg-type]
+    v.customize(c, A, v.V(fields(A).a).ensure(v.is_unique))  # E: Argument 1 to "ensure" of "V" has incompatible type "Callable[[Collection[Hashable]], None]"; expected "Callable[[list[dict[Any, Any]]], bool | None] | Callable[[bool], Callable[[list[dict[Any, Any]]], None]]"  [arg-type]
+
+- case: ignoring_none
+  main: |
+    from attrs import define, fields
+    from cattrs import v, Converter
+
+    @define
+    class A:
+      a: int | None
+
+    c = Converter()
+
+    v.customize(c, A, v.V(fields(A).a).ensure(v.ignoring_none(v.greater_than(5))))
+
+- case: ignoring_none_missing
+  main: |
+    from attrs import define, fields
+    from cattrs import v, Converter
+
+    @define
+    class A:
+      a: int | None
+
+    c = Converter()
+
+    v.customize(c, A, v.V(fields(A).a).ensure(v.greater_than(5)))  # E: Argument 1 to "ensure" of "V" has incompatible type "Callable[[int], None]"; expected "Callable[[int | None], bool | None] | Callable[[bool], Callable[[int | None], None]]"  [arg-type]
+    v.customize(c, A, v.V(fields(A).a).ensure(v.ignoring_none(v.len_between(0, 5))))  # E: Argument 1 to "ignoring_none" has incompatible type "Callable[[Sized], None]"; expected "Callable[[int], None]"  [arg-type]