First pass at implementing support for by_alias and by_name in model validate functions

This approach has now been reverted in favor of a schema-build-time approach due to perf reasons
See the next commit for a more robust explanation :).

Author: sydney-runkle

python/pydantic_core/_pydantic_core.pyi

@@ -97,6 +97,8 @@ class SchemaValidator:
         context: Any | None = None,
         self_instance: Any | None = None,
         allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> Any:
         """
         Validate a Python object against the schema and return the validated object.
@@ -114,6 +116,8 @@ class SchemaValidator:
             allow_partial: Whether to allow partial validation; if `True` errors in the last element of sequences
                 and mappings are ignored.
                 `'trailing-strings'` means any final unfinished JSON string is included in the result.
+            by_alias: Whether to use the field's alias to match the input data to an attribute.
+            by_name: Whether to use the field's name to match the input data to an attribute.
 
         Raises:
             ValidationError: If validation fails.
@@ -130,6 +134,8 @@ class SchemaValidator:
         from_attributes: bool | None = None,
         context: Any | None = None,
         self_instance: Any | None = None,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> bool:
         """
         Similar to [`validate_python()`][pydantic_core.SchemaValidator.validate_python] but returns a boolean.
@@ -148,6 +154,8 @@ class SchemaValidator:
         context: Any | None = None,
         self_instance: Any | None = None,
         allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> Any:
         """
         Validate JSON data directly against the schema and return the validated Python object.
@@ -168,6 +176,8 @@ class SchemaValidator:
             allow_partial: Whether to allow partial validation; if `True` incomplete JSON will be parsed successfully
                 and errors in the last element of sequences and mappings are ignored.
                 `'trailing-strings'` means any final unfinished JSON string is included in the result.
+            by_alias: Whether to use the field's alias to match the input data to an attribute.
+            by_name: Whether to use the field's name to match the input data to an attribute.
 
         Raises:
             ValidationError: If validation fails or if the JSON data is invalid.
@@ -183,6 +193,8 @@ class SchemaValidator:
         strict: bool | None = None,
         context: Any | None = None,
         allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> Any:
         """
         Validate a string against the schema and return the validated Python object.
@@ -199,6 +211,8 @@ class SchemaValidator:
             allow_partial: Whether to allow partial validation; if `True` errors in the last element of sequences
                 and mappings are ignored.
                 `'trailing-strings'` means any final unfinished JSON string is included in the result.
+            by_alias: Whether to use the field's alias to match the input data to an attribute.
+            by_name: Whether to use the field's name to match the input data to an attribute.
 
         Raises:
             ValidationError: If validation fails or if the JSON data is invalid.
@@ -216,6 +230,8 @@ class SchemaValidator:
         strict: bool | None = None,
         from_attributes: bool | None = None,
         context: Any | None = None,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> dict[str, Any] | tuple[dict[str, Any], dict[str, Any] | None, set[str]]:
         """
         Validate an assignment to a field on a model.
@@ -230,6 +246,8 @@ class SchemaValidator:
                 If `None`, the value of [`CoreConfig.from_attributes`][pydantic_core.core_schema.CoreConfig] is used.
             context: The context to use for validation, this is passed to functional validators as
                 [`info.context`][pydantic_core.core_schema.ValidationInfo.context].
+            by_alias: Whether to use the field's alias to match the input data to an attribute.
+            by_name: Whether to use the field's name to match the input data to an attribute.
 
         Raises:
             ValidationError: If validation fails.

src/lookup_key.rs

@@ -580,19 +580,24 @@ fn py_get_attrs<'py>(obj: &Bound<'py, PyAny>, attr_name: &Py<PyString>) -> PyRes
 
 pub fn get_lookup_key(
     py: Python,
-    validation_alias: Option<Bound<'_, PyAny>>,
+    validation_alias: Option<&Py<PyAny>>,
     validate_by_name: bool,
     validate_by_alias: bool,
     field_name: &str,
 ) -> PyResult<LookupKey> {
-    let lookup_key = match (validation_alias, validate_by_name, validate_by_alias) {
-        (Some(va), true, true) => LookupKey::from_py(py, &va, Some(field_name))?,
-        (Some(_va), true, false) => LookupKey::from_string(py, field_name),
-        (Some(va), false, true) => LookupKey::from_py(py, &va, None)?,
-        (Some(_va), false, false) => {
-            return py_schema_err!("`validate_by_name` and `validate_by_alias` cannot both be set to `False`.")
+    match validation_alias {
+        Some(va) => {
+            let va_bound = va.into_bound_py_any(py)?;
+            let lookup_key = match (validate_by_name, validate_by_alias) {
+                (true, true) => LookupKey::from_py(py, &va_bound, Some(field_name))?,
+                (true, false) => LookupKey::from_string(py, field_name),
+                (false, true) => LookupKey::from_py(py, &va_bound, None)?,
+                (false, false) => {
+                    return py_schema_err!("`validate_by_name` and `validate_by_alias` cannot both be set to `False`.")
+                }
+            };
+            Ok(lookup_key)
         }
-        (None, _, _) => LookupKey::from_string(py, field_name),
-    };
-    Ok(lookup_key)
+        None => Ok(LookupKey::from_string(py, field_name)),
+    }
 }

src/url.rs

@@ -45,7 +45,7 @@ impl PyUrl {
     pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_URL
             .get_or_init(py, || build_schema_validator(py, "url"))
-            .validate_python(py, url, None, None, None, None, false.into())?;
+            .validate_python(py, url, None, None, None, None, false.into(), None, None)?;
         schema_obj.extract(py)
     }
 
@@ -225,7 +225,7 @@ impl PyMultiHostUrl {
     pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_MULTI_HOST_URL
             .get_or_init(py, || build_schema_validator(py, "multi-host-url"))
-            .validate_python(py, url, None, None, None, None, false.into())?;
+            .validate_python(py, url, None, None, None, None, false.into(), None, None)?;
         schema_obj.extract(py)
     }
 

src/validators/arguments.rs

@@ -11,7 +11,7 @@ use crate::build_tools::py_schema_err;
 use crate::build_tools::{schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidationMatch};
-use crate::lookup_key::{get_lookup_key, LookupKey};
+use crate::lookup_key::get_lookup_key;
 use crate::tools::SchemaDict;
 
 use super::validation_state::ValidationState;
@@ -42,9 +42,10 @@ impl FromStr for VarKwargsMode {
 struct Parameter {
     positional: bool,
     name: String,
-    kw_lookup_key: Option<LookupKey>,
     kwarg_key: Option<Py<PyString>>,
     validator: CombinedValidator,
+    alias: Option<Py<PyAny>>,
+    mode: String,
 }
 
 #[derive(Debug)]
@@ -56,6 +57,8 @@ pub struct ArgumentsValidator {
     var_kwargs_validator: Option<Box<CombinedValidator>>,
     loc_by_alias: bool,
     extra: ExtraBehavior,
+    validate_by_alias: bool,
+    validate_by_name: bool,
 }
 
 impl BuildValidator for ArgumentsValidator {
@@ -75,10 +78,6 @@ impl BuildValidator for ArgumentsValidator {
         let mut had_default_arg = false;
         let mut had_keyword_only = false;
 
-        let validate_by_name = schema_or_config_same(schema, config, intern!(py, "validate_by_name"))?.unwrap_or(false);
-        let validate_by_alias =
-            schema_or_config_same(schema, config, intern!(py, "validate_by_alias"))?.unwrap_or(true);
-
         for (arg_index, arg) in arguments_schema.iter().enumerate() {
             let arg = arg.downcast::<PyDict>()?;
 
@@ -99,19 +98,11 @@ impl BuildValidator for ArgumentsValidator {
                 had_keyword_only = true;
             }
 
-            let mut kw_lookup_key = None;
-            let mut kwarg_key = None;
-            if mode == "keyword_only" || mode == "positional_or_keyword" {
-                let validation_alias = arg.get_item(intern!(py, "alias"))?;
-                kw_lookup_key = Some(get_lookup_key(
-                    py,
-                    validation_alias,
-                    validate_by_name,
-                    validate_by_alias,
-                    name.as_str(),
-                )?);
-                kwarg_key = Some(py_name.unbind());
-            }
+            let kwarg_key = if mode == "keyword_only" || mode == "positional_or_keyword" {
+                Some(py_name.unbind())
+            } else {
+                None
+            };
 
             let schema = arg.get_as_req(intern!(py, "schema"))?;
 
@@ -138,9 +129,10 @@ impl BuildValidator for ArgumentsValidator {
             parameters.push(Parameter {
                 positional,
                 name,
-                kw_lookup_key,
                 kwarg_key,
                 validator,
+                alias: arg.get_item(intern!(py, "alias"))?.map(std::convert::Into::into),
+                mode: mode.to_string(),
             });
         }
 
@@ -171,6 +163,8 @@ impl BuildValidator for ArgumentsValidator {
             var_kwargs_validator,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
             extra: ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Forbid)?,
+            validate_by_alias: schema_or_config_same(schema, config, intern!(py, "validate_by_alias"))?.unwrap_or(true),
+            validate_by_name: schema_or_config_same(schema, config, intern!(py, "validate_by_name"))?.unwrap_or(false),
         }
         .into())
     }
@@ -199,7 +193,10 @@ impl Validator for ArgumentsValidator {
         let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
         let output_kwargs = PyDict::new(py);
         let mut errors: Vec<ValLineError> = Vec::new();
-        let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.parameters.len());
+        let mut used_kwargs: AHashSet<String> = AHashSet::with_capacity(self.parameters.len());
+
+        let validate_by_alias = state.validate_by_alias_or(self.validate_by_alias);
+        let validate_by_name = state.validate_by_name_or(self.validate_by_name);
 
         // go through arguments getting the value from args or kwargs and validating it
         for (index, parameter) in self.parameters.iter().enumerate() {
@@ -210,10 +207,21 @@ impl Validator for ArgumentsValidator {
                 }
             }
             let mut kw_value = None;
+            let mut kw_lookup_key = None;
+            if parameter.mode == "keyword_only" || parameter.mode == "positional_or_keyword" {
+                kw_lookup_key = Some(get_lookup_key(
+                    py,
+                    parameter.alias.as_ref(),
+                    validate_by_name,
+                    validate_by_alias,
+                    &parameter.name,
+                )?);
+            }
+
             if let Some(kwargs) = args.kwargs() {
-                if let Some(ref lookup_key) = parameter.kw_lookup_key {
+                if let Some(ref lookup_key) = kw_lookup_key {
                     if let Some((lookup_path, value)) = kwargs.get_item(lookup_key)? {
-                        used_kwargs.insert(lookup_path.first_key());
+                        used_kwargs.insert(lookup_path.first_key().to_string());
                         kw_value = Some((lookup_path, value));
                     }
                 }
@@ -257,7 +265,7 @@ impl Validator for ArgumentsValidator {
                         } else {
                             output_args.push(value);
                         }
-                    } else if let Some(ref lookup_key) = parameter.kw_lookup_key {
+                    } else if let Some(lookup_key) = kw_lookup_key {
                         let error_type = if parameter.positional {
                             ErrorTypeDefaults::MissingArgument
                         } else {

src/validators/dataclass.rs

@@ -12,7 +12,7 @@ use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValRes
 use crate::input::{
     input_as_python_instance, Arguments, BorrowInput, Input, InputType, KeywordArgs, PositionalArgs, ValidationMatch,
 };
-use crate::lookup_key::{get_lookup_key, LookupKey};
+use crate::lookup_key::get_lookup_key;
 use crate::tools::SchemaDict;
 use crate::validators::function::convert_err;
 
@@ -27,7 +27,7 @@ struct Field {
     py_name: Py<PyString>,
     init: bool,
     init_only: bool,
-    lookup_key: LookupKey,
+    alias: Option<Py<PyAny>>,
     validator: CombinedValidator,
     frozen: bool,
 }
@@ -42,6 +42,8 @@ pub struct DataclassArgsValidator {
     extra_behavior: ExtraBehavior,
     extras_validator: Option<Box<CombinedValidator>>,
     loc_by_alias: bool,
+    validate_by_alias: bool,
+    validate_by_name: bool,
 }
 
 impl BuildValidator for DataclassArgsValidator {
@@ -54,8 +56,6 @@ impl BuildValidator for DataclassArgsValidator {
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
-        let validate_by_name = config.get_as(intern!(py, "validate_by_name"))?.unwrap_or(false);
-        let validate_by_alias = config.get_as(intern!(py, "validate_by_alias"))?.unwrap_or(true);
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
         let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
@@ -75,9 +75,6 @@ impl BuildValidator for DataclassArgsValidator {
             let py_name: Bound<'_, PyString> = field.get_as_req(intern!(py, "name"))?;
             let name: String = py_name.extract()?;
 
-            let validation_alias = field.get_item(intern!(py, "validation_alias"))?;
-            let lookup_key = get_lookup_key(py, validation_alias, validate_by_name, validate_by_alias, name.as_str())?;
-
             let schema = field.get_as_req(intern!(py, "schema"))?;
 
             let validator = match build_validator(&schema, config, definitions) {
@@ -100,7 +97,9 @@ impl BuildValidator for DataclassArgsValidator {
                 kw_only,
                 name,
                 py_name: py_name.into(),
-                lookup_key,
+                alias: field
+                    .get_item(intern!(py, "validation_alias"))?
+                    .map(std::convert::Into::into),
                 validator,
                 init: field.get_as(intern!(py, "init"))?.unwrap_or(true),
                 init_only: field.get_as(intern!(py, "init_only"))?.unwrap_or(false),
@@ -125,6 +124,8 @@ impl BuildValidator for DataclassArgsValidator {
             extra_behavior,
             extras_validator,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
+            validate_by_alias: config.get_as(intern!(py, "validate_by_alias"))?.unwrap_or(true),
+            validate_by_name: config.get_as(intern!(py, "validate_by_name"))?.unwrap_or(false),
         }
         .into())
     }
@@ -150,9 +151,13 @@ impl Validator for DataclassArgsValidator {
         let mut init_only_args = self.init_only_count.map(Vec::with_capacity);
 
         let mut errors: Vec<ValLineError> = Vec::new();
-        let mut used_keys: AHashSet<&str> = AHashSet::with_capacity(self.fields.len());
+        let mut used_keys: AHashSet<String> = AHashSet::with_capacity(self.fields.len());
 
         let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
+
+        let validate_by_alias = state.validate_by_alias_or(self.validate_by_alias);
+        let validate_by_name = state.validate_by_name_or(self.validate_by_name);
+
         let mut fields_set_count: usize = 0;
 
         macro_rules! set_item {
@@ -195,10 +200,17 @@ impl Validator for DataclassArgsValidator {
                 }
             }
 
+            let lookup_key = get_lookup_key(
+                py,
+                field.alias.as_ref(),
+                validate_by_name,
+                validate_by_alias,
+                &field.name,
+            )?;
             let mut kw_value = None;
             if let Some(kwargs) = args.kwargs() {
-                if let Some((lookup_path, value)) = kwargs.get_item(&field.lookup_key)? {
-                    used_keys.insert(lookup_path.first_key());
+                if let Some((lookup_path, value)) = kwargs.get_item(&lookup_key)? {
+                    used_keys.insert(lookup_path.first_key().to_string());
                     kw_value = Some((lookup_path, value));
                 }
             }
@@ -248,7 +260,7 @@ impl Validator for DataclassArgsValidator {
                         }
                         Ok(None) => {
                             // This means there was no default value
-                            errors.push(field.lookup_key.error(
+                            errors.push(lookup_key.error(
                                 ErrorTypeDefaults::Missing,
                                 input,
                                 self.loc_by_alias,

src/validators/generator.rs

@@ -279,6 +279,8 @@ impl InternalValidator {
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
+            by_alias: None,
+            by_name: None,
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard, false.into());
         state.exactness = self.exactness;
@@ -314,6 +316,8 @@ impl InternalValidator {
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
+            by_alias: None,
+            by_name: None,
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard, false.into());
         state.exactness = self.exactness;