fix: refactoring based on code review comment

removed try_validate_any function and instead try to create Python enum class.

Test case modifications and fixes.

Author: vai-mikkoleppanen

src/validators/enum_.rs

@@ -79,6 +79,7 @@ pub trait EnumValidateValue: std::fmt::Debug + Clone + Send + Sync {
         py: Python<'py>,
         input: &I,
         lookup: &LiteralLookup<PyObject>,
+        class: &Py<PyType>,
         strict: bool,
     ) -> ValResult<Option<PyObject>>;
 }
@@ -116,7 +117,7 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
                 },
                 input,
             ));
-        } else if let Some(v) = T::validate_value(py, input, &self.lookup, strict)? {
+        } else if let Some(v) = T::validate_value(py, input, &self.lookup, &self.class, strict)? {
             state.floor_exactness(Exactness::Lax);
             return Ok(v);
         } else if let Some(ref missing) = self.missing {
@@ -167,6 +168,7 @@ impl EnumValidateValue for PlainEnumValidator {
         py: Python<'py>,
         input: &I,
         lookup: &LiteralLookup<PyObject>,
+        class: &Py<PyType>,
         strict: bool,
     ) -> ValResult<Option<PyObject>> {
         match lookup.validate(py, input)? {
@@ -184,8 +186,8 @@ impl EnumValidateValue for PlainEnumValidator {
                             return Ok(lookup.validate_int(py, input, false)?.map(|v| v.clone_ref(py)));
                         }
                         if py_input.is_instance_of::<PyAny>() {
-                            if let Ok(Some(res)) = lookup.try_validate_any(input) {
-                                return Ok(Some(res.clone_ref(py)));
+                            if let Ok(res) = class.call1(py, (py_input,)) {
+                                return Ok(Some(res));
                             }
                         }
                     }
@@ -207,6 +209,7 @@ impl EnumValidateValue for IntEnumValidator {
         py: Python<'py>,
         input: &I,
         lookup: &LiteralLookup<PyObject>,
+        _class: &Py<PyType>,
         strict: bool,
     ) -> ValResult<Option<PyObject>> {
         Ok(lookup.validate_int(py, input, strict)?.map(|v| v.clone_ref(py)))
@@ -223,6 +226,7 @@ impl EnumValidateValue for StrEnumValidator {
         py: Python,
         input: &I,
         lookup: &LiteralLookup<PyObject>,
+        _class: &Py<PyType>,
         strict: bool,
     ) -> ValResult<Option<PyObject>> {
         Ok(lookup.validate_str(input, strict)?.map(|v| v.clone_ref(py)))
@@ -239,6 +243,7 @@ impl EnumValidateValue for FloatEnumValidator {
         py: Python<'py>,
         input: &I,
         lookup: &LiteralLookup<PyObject>,
+        _class: &Py<PyType>,
         strict: bool,
     ) -> ValResult<Option<PyObject>> {
         Ok(lookup.validate_float(py, input, strict)?.map(|v| v.clone_ref(py)))

src/validators/generator.rs

@@ -86,6 +86,7 @@ impl Validator for GeneratorValidator {
             hide_input_in_errors: self.hide_input_in_errors,
             validation_error_cause: self.validation_error_cause,
         };
+
         Ok(v_iterator.into_py(py))
     }
 

src/validators/literal.rs

@@ -218,51 +218,6 @@ impl<T: Debug> LiteralLookup<T> {
         }
         Ok(None)
     }
-
-    pub fn try_validate_any<'a, 'py, I: Input<'py> + ?Sized>(&self, input: &'a I) -> ValResult<Option<&T>> {
-        let Some(py_input) = input.as_python() else {
-            return Ok(None);
-        };
-
-        if let Some(expected_ints) = &self.expected_int {
-            let id = expected_ints
-                .iter()
-                .find(|(&k, _)| is_equal_to(py_input, k).unwrap_or(false));
-
-            if let Some((_, id)) = id {
-                return Ok(Some(&self.values[*id]));
-            }
-        };
-
-        let Some(expected_strings) = &self.expected_str else {
-            return Ok(None);
-        };
-
-        // try with raw strings
-        let id = expected_strings
-            .iter()
-            .find(|(k, _)| is_equal_to(py_input, k.as_str()).unwrap_or(false));
-
-        if let Some((_, id)) = id {
-            return Ok(Some(&self.values[*id]));
-        }
-
-        // try with converting to int
-        let id = expected_strings
-            .iter()
-            .filter_map(|(k, id)| k.parse::<i64>().ok().map(|k_as_int| (k_as_int, id)))
-            .find(|(k, _)| is_equal_to(py_input, *k).unwrap_or(false));
-
-        if let Some((_, id)) = id {
-            return Ok(Some(&self.values[*id]));
-        }
-        Ok(None)
-    }
-}
-
-fn is_equal_to<TValue: IntoPy<Py<PyAny>>>(input: &Bound<PyAny>, value: TValue) -> PyResult<bool> {
-    let equality = input.call_method1("__eq__", (value,))?;
-    equality.extract::<bool>()
 }
 
 impl<T: PyGcTraverse + Debug> PyGcTraverse for LiteralLookup<T> {

src/validators/model.rs

@@ -270,7 +270,6 @@ impl ModelValidator {
                     .map_err(|e| convert_err(py, e, input));
             }
         }
-
         let output = self.validator.validate(py, input, state)?;
 
         let instance = create_class(self.class.bind(py))?;

tests/validators/test_enums.py

@@ -410,7 +410,7 @@ class MyEnum(Enum):
     assert v.validate_python(AnyWrapper('Py03')) is MyEnum.THIRD_VALUE
 
 
-def test_enum_str_validation_should_succeed_for_decimal_with_strict_disabled():
+def test_enum_str_validation_should_fail_for_decimal_when_expecting_str_value():
     # GIVEN
     class MyEnum(Enum):
         VALUE = '1'
@@ -423,23 +423,6 @@ class MyEnum(Enum):
         )
     )
 
-    # THEN
-    assert v.validate_python(Decimal(1)) is MyEnum.VALUE
-
-
-def test_enum_str_validation_should_fail_for_decimal_with_strict_enabled():
-    # GIVEN
-    class MyEnum(Enum):
-        VALUE = '1'
-
-    # WHEN
-    v = SchemaValidator(
-        core_schema.with_default_schema(
-            schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True),
-            default=MyEnum.VALUE,
-        )
-    )
-
     # THEN
     with pytest.raises(ValidationError):
         v.validate_python(Decimal(1))
@@ -450,9 +433,6 @@ def test_enum_int_validation_should_fail_for_incorrect_decimal_value():
     class MyEnum(Enum):
         VALUE = 1
 
-    class MyStrEnum(Enum):
-        VALUE = '2'
-
     # WHEN
     v = SchemaValidator(
         core_schema.with_default_schema(
@@ -461,13 +441,6 @@ class MyStrEnum(Enum):
         )
     )
 
-    v_str = SchemaValidator(
-        core_schema.with_default_schema(
-            schema=core_schema.enum_schema(MyStrEnum, list(MyStrEnum.__members__.values())),
-            default=MyStrEnum.VALUE,
-        )
-    )
-
     # THEN
     with pytest.raises(ValidationError):
         v.validate_python(Decimal(2))
@@ -478,12 +451,6 @@ class MyStrEnum(Enum):
     with pytest.raises(ValidationError):
         v.validate_python(Decimal(1.1))
 
-    with pytest.raises(ValidationError):
-        v_str.validate_python(Decimal(1))
-
-    with pytest.raises(ValidationError):
-        v_str.validate_python(Decimal(2.1))
-
 
 def test_enum_int_validation_should_fail_for_plain_type_without_eq_checking():
     # GIVEN

tests/validators/test_model.py

@@ -1323,7 +1323,6 @@ class EnumClass(Enum):
         enum_value = 1
         enum_value_2 = 2
         enum_value_3 = 3
-        enum_value_4 = '4'
 
     class IntWrappable:
         def __init__(self, value: int):
@@ -1356,26 +1355,20 @@ class MyModel:
                     'enum_field_3': core_schema.model_field(
                         core_schema.enum_schema(EnumClass, list(EnumClass.__members__.values()))
                     ),
-                    'enum_field_4': core_schema.model_field(
-                        core_schema.enum_schema(EnumClass, list(EnumClass.__members__.values()))
-                    ),
                 }
             ),
         )
     )
 
     # THEN
-    v.validate_json('{"enum_field": 1, "enum_field_2": 2, "enum_field_3": 3, "enum_field_4": "4"}')
+    v.validate_json('{"enum_field": 1, "enum_field_2": 2, "enum_field_3": 3}')
     m = v.validate_python(
         {
             'enum_field': Decimal(1),
             'enum_field_2': Decimal(2),
             'enum_field_3': IntWrappable(3),
-            'enum_field_4': IntWrappable(4),
         }
     )
     v.validate_assignment(m, 'enum_field', Decimal(1))
     v.validate_assignment(m, 'enum_field_2', Decimal(2))
     v.validate_assignment(m, 'enum_field_3', IntWrappable(3))
-    v.validate_assignment(m, 'enum_field_4', Decimal(4))
-    v.validate_assignment(m, 'enum_field_4', IntWrappable(4))