Add enum error type

python/pydantic_core/core_schema.py

@@ -3811,6 +3811,7 @@ def definition_reference_schema(
     'string_too_short',
     'string_too_long',
     'string_pattern_mismatch',
+    'enum',
     'dict_type',
     'mapping_type',
     'list_type',

src/errors/types.rs

@@ -159,6 +159,11 @@ pub enum ErrorType {
         pattern: String,
     },
     // ---------------------
+    // enum errors
+    Enum {
+        expected: String,
+    },
+    // ---------------------
     // dict errors
     DictType,
     MappingType {
@@ -415,6 +420,7 @@ impl ErrorType {
             Self::IterationError { .. } => extract_context!(IterationError, ctx, error: String),
             Self::StringTooShort { .. } => extract_context!(StringTooShort, ctx, min_length: usize),
             Self::StringTooLong { .. } => extract_context!(StringTooLong, ctx, max_length: usize),
+            Self::Enum { .. } => extract_context!(Enum, ctx, expected: String),
             Self::StringPatternMismatch { .. } => extract_context!(StringPatternMismatch, ctx, pattern: String),
             Self::MappingType { .. } => extract_context!(Cow::Owned, MappingType, ctx, error: String),
             Self::BytesTooShort { .. } => extract_context!(BytesTooShort, ctx, min_length: usize),
@@ -492,6 +498,7 @@ impl ErrorType {
             Self::StringTooShort {..} => "String should have at least {min_length} characters",
             Self::StringTooLong {..} => "String should have at most {max_length} characters",
             Self::StringPatternMismatch {..} => "String should match pattern '{pattern}'",
+            Self::Enum {..} => "Input should be {expected}",
             Self::DictType => "Input should be a valid dictionary",
             Self::MappingType {..} => "Input should be a valid mapping, error: {error}",
             Self::ListType => "Input should be a valid list",
@@ -628,6 +635,7 @@ impl ErrorType {
             Self::StringTooShort { min_length } => to_string_render!(tmpl, min_length),
             Self::StringTooLong { max_length } => to_string_render!(tmpl, max_length),
             Self::StringPatternMismatch { pattern } => render!(tmpl, pattern),
+            Self::Enum { expected } => to_string_render!(tmpl, expected),
             Self::MappingType { error } => render!(tmpl, error),
             Self::BytesTooShort { min_length } => to_string_render!(tmpl, min_length),
             Self::BytesTooLong { max_length } => to_string_render!(tmpl, max_length),
@@ -687,6 +695,7 @@ impl ErrorType {
             Self::StringTooShort { min_length } => py_dict!(py, min_length),
             Self::StringTooLong { max_length } => py_dict!(py, max_length),
             Self::StringPatternMismatch { pattern } => py_dict!(py, pattern),
+            Self::Enum { expected } => py_dict!(py, expected),
             Self::MappingType { error } => py_dict!(py, error),
             Self::BytesTooShort { min_length } => py_dict!(py, min_length),
             Self::BytesTooLong { max_length } => py_dict!(py, max_length),

tests/test_errors.py

@@ -191,6 +191,7 @@ def f(input_value, info):
     ('invalid_key', 'Keys should be strings', None),
     ('get_attribute_error', 'Error extracting attribute: foo', {'error': 'foo'}),
     ('none_required', 'Input should be None', None),
+    ('enum', 'Input should be foo', {'expected': 'foo'}),
     ('greater_than', 'Input should be greater than 42.1', {'gt': 42.1}),
     ('greater_than', 'Input should be greater than 42.1', {'gt': '42.1'}),
     ('greater_than', 'Input should be greater than 2020-01-01', {'gt': '2020-01-01'}),