Raise validation error when unhashable items added to a set

python/pydantic_core/core_schema.py

@@ -4037,6 +4037,7 @@ def definition_reference_schema(
     'list_type',
     'tuple_type',
     'set_type',
+    'set_item_not_hashable',
     'bool_type',
     'bool_parsing',
     'int_type',

src/errors/types.rs

@@ -268,6 +268,7 @@ error_types! {
     // ---------------------
     // set errors
     SetType {},
+    SetItemNotHashable {},
     // ---------------------
     // bool errors
     BoolType {},
@@ -513,6 +514,7 @@ impl ErrorType {
             Self::ListType {..} => "Input should be a valid list",
             Self::TupleType {..} => "Input should be a valid tuple",
             Self::SetType {..} => "Input should be a valid set",
+            Self::SetItemNotHashable {..} => "Set items should be hashable",
             Self::BoolType {..} => "Input should be a valid boolean",
             Self::BoolParsing {..} => "Input should be a valid boolean, unable to interpret input",
             Self::IntType {..} => "Input should be a valid integer",

src/input/return_enums.rs

@@ -194,6 +194,22 @@ impl BuildSet for Bound<'_, PyFrozenSet> {
     }
 }
 
+fn validate_hashable<'py>(
+    py: Python<'py>,
+    item: &(impl Input<'py> + ?Sized),
+    state: &mut ValidationState<'_, 'py>,
+    validator: &CombinedValidator,
+) -> ValResult<PyObject> {
+    let result: PyObject = validator.validate(py, item, state)?;
+
+    let bound_result: &Bound<'_, PyAny> = result.bind(py);
+
+    match bound_result.hash() {
+        Ok(_) => Ok(result),
+        Err(_) => Err(ValError::new(ErrorTypeDefaults::SetItemNotHashable, item)),
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn validate_iter_to_set<'py>(
     py: Python<'py>,
@@ -216,7 +232,7 @@ pub(crate) fn validate_iter_to_set<'py>(
             false => PartialMode::Off,
         };
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
-        match validator.validate(py, item.borrow_input(), state) {
+        match validate_hashable(py, item.borrow_input(), state, validator) {
             Ok(item) => {
                 set.build_add(item)?;
                 if let Some(max_length) = max_length {

tests/test_errors.py

@@ -306,6 +306,7 @@ def f(input_value, info):
     ('iteration_error', 'Error iterating over object, error: foobar', {'error': 'foobar'}),
     ('list_type', 'Input should be a valid list', None),
     ('tuple_type', 'Input should be a valid tuple', None),
+    ('set_item_not_hashable', 'Set items should be hashable', None),
     ('set_type', 'Input should be a valid set', None),
     ('bool_type', 'Input should be a valid boolean', None),
     ('bool_parsing', 'Input should be a valid boolean, unable to interpret input', None),

tests/validators/test_set.py

@@ -104,6 +104,23 @@ def test_set_multiple_errors():
     ]
 
 
+def test_list_with_unhashable_items():
+    v = SchemaValidator({'type': 'set'})
+
+    class Unhashable:
+        def __hash__(self):
+            raise TypeError('unhashable type')
+
+    unhashable = Unhashable()
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python([{'a': 'b'}, unhashable])
+    assert exc_info.value.errors(include_url=False) == [
+        {'type': 'set_item_not_hashable', 'loc': (0,), 'msg': 'Set items should be hashable', 'input': {'a': 'b'}},
+        {'type': 'set_item_not_hashable', 'loc': (1,), 'msg': 'Set items should be hashable', 'input': unhashable},
+    ]
+
+
 def generate_repeats():
     for i in 1, 2, 3:
         yield i