Add fail-fast for dicts

python/pydantic_core/core_schema.py

@@ -96,6 +96,8 @@ class CoreConfig(TypedDict, total=False):
     validate_default: bool
     # used on typed-dicts and arguments
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
+    # stop validation on a first error, used with typed-dict, model-fields, and dataclass fields
+    fail_fast: bool
     # fields related to string fields only
     str_max_length: int
     str_min_length: int
@@ -1885,6 +1887,7 @@ class DictSchema(TypedDict, total=False):
     values_schema: CoreSchema  # default: AnySchema
     min_length: int
     max_length: int
+    fail_fast: bool
     strict: bool
     ref: str
     metadata: Dict[str, Any]
@@ -1897,6 +1900,7 @@ def dict_schema(
     *,
     min_length: int | None = None,
     max_length: int | None = None,
+    fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: Dict[str, Any] | None = None,
@@ -1920,6 +1924,7 @@ def dict_schema(
         values_schema: The value must be a dict with values that match this schema
         min_length: The value must be a dict with at least this many items
         max_length: The value must be a dict with at most this many items
+        fail_fast: Stop validation on the first error
         strict: Whether the keys and values should be validated with strict mode
         ref: optional unique identifier of the schema, used to reference the schema in other places
         metadata: Any other information you want to include with the schema, not used by pydantic-core
@@ -1931,6 +1936,7 @@ def dict_schema(
         values_schema=values_schema,
         min_length=min_length,
         max_length=max_length,
+        fail_fast=fail_fast,
         strict=strict,
         ref=ref,
         metadata=metadata,
@@ -2868,6 +2874,7 @@ class TypedDictSchema(TypedDict, total=False):
     extra_behavior: ExtraBehavior
     total: bool  # default: True
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
+    fail_fast: bool  # default: False
     ref: str
     metadata: Dict[str, Any]
     serialization: SerSchema
@@ -2884,6 +2891,7 @@ def typed_dict_schema(
     extra_behavior: ExtraBehavior | None = None,
     total: bool | None = None,
     populate_by_name: bool | None = None,
+    fail_fast: bool | None = None,
     ref: str | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
@@ -2918,6 +2926,7 @@ class MyTypedDict(TypedDict):
         extra_behavior: The extra behavior to use for the typed dict
         total: Whether the typed dict is total, otherwise uses `typed_dict_total` from config
         populate_by_name: Whether the typed dict should populate by name
+        fail_fast: Stop validation on the first error
         serialization: Custom serialization schema
     """
     return _dict_not_none(
@@ -2930,6 +2939,7 @@ class MyTypedDict(TypedDict):
         extra_behavior=extra_behavior,
         total=total,
         populate_by_name=populate_by_name,
+        fail_fast=fail_fast,
         ref=ref,
         metadata=metadata,
         serialization=serialization,
@@ -2994,6 +3004,7 @@ class ModelFieldsSchema(TypedDict, total=False):
     # all these values can be set via config, equivalent fields have `typed_dict_` prefix
     extra_behavior: ExtraBehavior
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
+    fail_fast: bool  # default: False
     from_attributes: bool
     ref: str
     metadata: Dict[str, Any]
@@ -3010,6 +3021,7 @@ def model_fields_schema(
     extra_behavior: ExtraBehavior | None = None,
     populate_by_name: bool | None = None,
     from_attributes: bool | None = None,
+    fail_fast: bool | None = None,
     ref: str | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
@@ -3039,6 +3051,7 @@ def model_fields_schema(
         extra_behavior: The extra behavior to use for the typed dict
         populate_by_name: Whether the typed dict should populate by name
         from_attributes: Whether the typed dict should be populated from attributes
+        fail_fast: Stop validation on the first error
         serialization: Custom serialization schema
     """
     return _dict_not_none(
@@ -3051,6 +3064,7 @@ def model_fields_schema(
         extra_behavior=extra_behavior,
         populate_by_name=populate_by_name,
         from_attributes=from_attributes,
+        fail_fast=fail_fast,
         ref=ref,
         metadata=metadata,
         serialization=serialization,
@@ -3234,6 +3248,7 @@ class DataclassArgsSchema(TypedDict, total=False):
     fields: Required[List[DataclassField]]
     computed_fields: List[ComputedField]
     populate_by_name: bool  # default: False
+    fail_fast: bool  # default: False
     collect_init_only: bool  # default: False
     ref: str
     metadata: Dict[str, Any]
@@ -3247,6 +3262,7 @@ def dataclass_args_schema(
     *,
     computed_fields: List[ComputedField] | None = None,
     populate_by_name: bool | None = None,
+    fail_fast: bool | None = None,
     collect_init_only: bool | None = None,
     ref: str | None = None,
     metadata: Dict[str, Any] | None = None,
@@ -3275,6 +3291,7 @@ def dataclass_args_schema(
         fields: The fields to use for the dataclass
         computed_fields: Computed fields to use when serializing the dataclass
         populate_by_name: Whether to populate by name
+        fail_fast: Stop validation on the first error
         collect_init_only: Whether to collect init only fields into a dict to pass to `__post_init__`
         ref: optional unique identifier of the schema, used to reference the schema in other places
         metadata: Any other information you want to include with the schema, not used by pydantic-core
@@ -3287,6 +3304,7 @@ def dataclass_args_schema(
         fields=fields,
         computed_fields=computed_fields,
         populate_by_name=populate_by_name,
+        fail_fast=fail_fast,
         collect_init_only=collect_init_only,
         ref=ref,
         metadata=metadata,

src/validators/dataclass.rs

@@ -40,6 +40,7 @@ pub struct DataclassArgsValidator {
     validator_name: String,
     extra_behavior: ExtraBehavior,
     extras_validator: Option<Box<CombinedValidator>>,
+    fail_fast: bool,
     loc_by_alias: bool,
 }
 
@@ -54,6 +55,7 @@ impl BuildValidator for DataclassArgsValidator {
         let py = schema.py();
 
         let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
+        let fail_fast = schema_or_config_same(schema, config, intern!(py, "fail_fast"))?.unwrap_or(false);
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
@@ -128,6 +130,7 @@ impl BuildValidator for DataclassArgsValidator {
             validator_name,
             extra_behavior,
             extras_validator,
+            fail_fast,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
         }
         .into())
@@ -174,6 +177,10 @@ impl Validator for DataclassArgsValidator {
 
         // go through fields getting the value from args or kwargs and validating it
         for (index, field) in self.fields.iter().enumerate() {
+            if self.fail_fast && !errors.is_empty() {
+                break;
+            }
+
             if !field.init {
                 match field.validator.default_value(py, Some(field.name.as_str()), state) {
                     Ok(Some(value)) => {
@@ -291,6 +298,10 @@ impl Validator for DataclassArgsValidator {
         if let Some(kwargs) = args.kwargs() {
             if kwargs.len() != used_keys.len() {
                 for result in kwargs.iter() {
+                    if self.fail_fast && !errors.is_empty() {
+                        break;
+                    }
+
                     let (raw_key, value) = result?;
                     match raw_key
                         .borrow_input()

src/validators/dict.rs

@@ -21,6 +21,7 @@ pub struct DictValidator {
     value_validator: Box<CombinedValidator>,
     min_length: Option<usize>,
     max_length: Option<usize>,
+    fail_fast: bool,
     name: String,
 }
 
@@ -53,6 +54,7 @@ impl BuildValidator for DictValidator {
             value_validator,
             min_length: schema.get_as(intern!(py, "min_length"))?,
             max_length: schema.get_as(intern!(py, "max_length"))?,
+            fail_fast: schema.get_as(intern!(py, "fail_fast"))?.unwrap_or(false),
             name,
         }
         .into())
@@ -78,6 +80,7 @@ impl Validator for DictValidator {
             input,
             min_length: self.min_length,
             max_length: self.max_length,
+            fail_fast: self.fail_fast,
             key_validator: &self.key_validator,
             value_validator: &self.value_validator,
             state,
@@ -94,6 +97,7 @@ struct ValidateToDict<'a, 's, 'py, I: Input<'py> + ?Sized> {
     input: &'a I,
     min_length: Option<usize>,
     max_length: Option<usize>,
+    fail_fast: bool,
     key_validator: &'a CombinedValidator,
     value_validator: &'a CombinedValidator,
     state: &'a mut ValidationState<'s, 'py>,
@@ -111,6 +115,12 @@ where
         let mut errors: Vec<ValLineError> = Vec::new();
         let allow_partial = self.state.allow_partial;
 
+        macro_rules! should_fail_fast {
+            () => {
+                self.fail_fast && !errors.is_empty()
+            };
+        }
+
         for (_, is_last_partial, item_result) in self.state.enumerate_last_partial(iterator) {
             self.state.allow_partial = false.into();
             let (key, value) = item_result?;
@@ -130,6 +140,11 @@ where
                 true => allow_partial,
                 false => false.into(),
             };
+
+            if should_fail_fast!() {
+                break;
+            }
+
             let output_value = match self.value_validator.validate(self.py, value.borrow_input(), self.state) {
                 Ok(value) => value,
                 Err(ValError::LineErrors(line_errors)) => {
@@ -141,6 +156,11 @@ where
                 Err(ValError::Omit) => continue,
                 Err(err) => return Err(err),
             };
+
+            if should_fail_fast!() {
+                break;
+            }
+
             if let Some(key) = output_key {
                 output.set_item(key, output_value)?;
             }

src/validators/model_fields.rs

@@ -36,6 +36,7 @@ pub struct ModelFieldsValidator {
     strict: bool,
     from_attributes: bool,
     loc_by_alias: bool,
+    fail_fast: bool,
 }
 
 impl BuildValidator for ModelFieldsValidator {
@@ -51,6 +52,7 @@ impl BuildValidator for ModelFieldsValidator {
 
         let from_attributes = schema_or_config_same(schema, config, intern!(py, "from_attributes"))?.unwrap_or(false);
         let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
+        let fail_fast = schema_or_config_same(schema, config, intern!(py, "fail_fast"))?.unwrap_or(false);
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
@@ -102,6 +104,7 @@ impl BuildValidator for ModelFieldsValidator {
             extras_validator,
             strict,
             from_attributes,
+            fail_fast,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
         }
         .into())
@@ -168,6 +171,10 @@ impl Validator for ModelFieldsValidator {
             let state = &mut state.rebind_extra(|extra| extra.data = Some(model_dict.clone()));
 
             for field in &self.fields {
+                if self.fail_fast && !errors.is_empty() {
+                    break;
+                }
+
                 let op_key_value = match dict.get_item(&field.lookup_key) {
                     Ok(v) => v,
                     Err(ValError::LineErrors(line_errors)) => {

src/validators/typed_dict.rs

@@ -34,6 +34,7 @@ pub struct TypedDictValidator {
     extra_behavior: ExtraBehavior,
     extras_validator: Option<Box<CombinedValidator>>,
     strict: bool,
+    fail_fast: bool,
     loc_by_alias: bool,
 }
 
@@ -56,6 +57,7 @@ impl BuildValidator for TypedDictValidator {
         let total =
             schema_or_config(schema, config, intern!(py, "total"), intern!(py, "typed_dict_total"))?.unwrap_or(true);
         let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
+        let fail_fast = schema_or_config_same(schema, config, intern!(py, "fail_fast"))?.unwrap_or(false);
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
@@ -129,6 +131,7 @@ impl BuildValidator for TypedDictValidator {
             extra_behavior,
             extras_validator,
             strict,
+            fail_fast,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
         }
         .into())
@@ -174,6 +177,10 @@ impl Validator for TypedDictValidator {
             let mut fields_set_count: usize = 0;
 
             for field in &self.fields {
+                if self.fail_fast && !errors.is_empty() {
+                    break;
+                }
+
                 let op_key_value = match dict.get_item(&field.lookup_key) {
                     Ok(v) => v,
                     Err(ValError::LineErrors(line_errors)) => {
@@ -265,6 +272,7 @@ impl Validator for TypedDictValidator {
                 extra_behavior: ExtraBehavior,
                 partial_last_key: Option<LocItem>,
                 allow_partial: PartialMode,
+                fail_fast: bool,
             }
 
             impl<'py, Key, Value> ConsumeIterator<ValResult<(Key, Value)>> for ValidateExtras<'_, '_, 'py>
@@ -275,6 +283,10 @@ impl Validator for TypedDictValidator {
                 type Output = ValResult<()>;
                 fn consume_iterator(self, iterator: impl Iterator<Item = ValResult<(Key, Value)>>) -> ValResult<()> {
                     for item_result in iterator {
+                        if self.fail_fast && !self.errors.is_empty() {
+                            break;
+                        }
+
                         let (raw_key, value) = item_result?;
                         let either_str = match raw_key
                             .borrow_input()
@@ -354,6 +366,7 @@ impl Validator for TypedDictValidator {
                 extra_behavior: self.extra_behavior,
                 partial_last_key,
                 allow_partial,
+                fail_fast: self.fail_fast,
             })??;
         }