is_unique validator

Author: Tinche

src/cattrs/v/__init__.py

@@ -8,7 +8,7 @@
     IterableValidationError,
 )
 from ._fluent import V, customize
-from ._validators import between, greater_than, len_between
+from ._validators import between, greater_than, is_unique, len_between
 
 __all__ = [
     "customize",
@@ -18,6 +18,7 @@
     "between",
     "greater_than",
     "len_between",
+    "is_unique",
 ]
 
 

src/cattrs/v/_fluent.py

@@ -108,15 +108,6 @@ def replace_with(self, value: T) -> VOmitted:
         return VOmitted(self.attr)
 
 
-def is_unique(val: Collection[Any]) -> None:
-    """Ensure all elements in a collection are unique.
-
-    Takes a value that implements Collection.
-    """
-    if len(val) != len(set(val)):
-        raise ValueError(f"Value ({val}) not unique")
-
-
 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

src/cattrs/v/_validators.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Callable, Protocol, Sized, TypeVar
+from collections.abc import Hashable
+from typing import Callable, Collection, Protocol, Sized, TypeVar
 
 T = TypeVar("T")
 
@@ -43,3 +44,11 @@ def assert_len_between(val: Sized, _min: int = min, _max: int = max) -> None:
             raise ValueError(f"length ({length}) not between {_min} and {_max}")
 
     return assert_len_between
+
+
+def is_unique(val: Collection[Hashable]) -> None:
+    """Ensure all elements in a collection are unique."""
+    if (length := len(val)) != (unique_length := len(set(val))):
+        raise ValueError(
+            f"Collection ({length} elem(s)) not unique, only {unique_length} unique elem(s)"
+        )

tests/v/test_validators.py

@@ -6,7 +6,15 @@
 
 from cattrs import BaseConverter
 from cattrs.errors import ClassValidationError
-from cattrs.v import V, between, customize, greater_than, len_between, transform_error
+from cattrs.v import (
+    V,
+    between,
+    customize,
+    greater_than,
+    is_unique,
+    len_between,
+    transform_error,
+)
 
 
 @define
@@ -104,3 +112,31 @@ def test_len_between(converter: BaseConverter):
             converter.structure({"a": [1, 2]}, WithList)
 
         assert repr(exc_info.value) == "ValueError('length (2) not between 1 and 2')"
+
+
+def test_unique(converter: BaseConverter):
+    """The `is_unique` validator works."""
+
+    @define
+    class A:
+        a: list[int]
+
+    customize(converter, A, V(f(A).a).ensure(is_unique))
+
+    assert converter.structure({"a": [1]}, A) == A([1])
+
+    if converter.detailed_validation:
+        with raises(ClassValidationError) as exc_info:
+            converter.structure({"a": [1, 1]}, A)
+
+        assert transform_error(exc_info.value) == [
+            "invalid value (Collection (2 elem(s)) not unique, only 1 unique elem(s)) @ $.a"
+        ]
+    else:
+        with raises(ValueError) as exc_info:
+            converter.structure({"a": [1, 1]}, A)
+
+        assert (
+            repr(exc_info.value)
+            == "ValueError('Collection (2 elem(s)) not unique, only 1 unique elem(s)')"
+        )

tests/v/test_validators_mypy.yml

@@ -35,4 +35,30 @@
 
     c = Converter()
 
-    v.customize(c, A, v.V(fields(A).a).ensure(v.len_between(5, 10)))
+    v.customize(c, A, v.V(fields(A).a).ensure(v.len_between(5, 10)))
+
+- case: unique
+  main: |
+    from attrs import define, fields
+    from cattrs import v, Converter
+
+    @define
+    class A:
+      a: list[int]
+
+    c = Converter()
+
+    v.customize(c, A, v.V(fields(A).a).ensure(v.is_unique))
+
+- case: unique_error_not_hashable
+  main: |
+    from attrs import define, fields
+    from cattrs import v, Converter
+
+    @define
+    class A:
+      a: list[dict]
+
+    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]