Implement support for by_alias and by_name for model validation functions

* This approach (2nd attempt) emphasizes building lookup keys at schema build time for performance reasons
* We avoid any LookupKey builds at validation time to avoid perf bottlenecks + redundant builds
* We store potentially up to 3 LookupKey instances via LookupKeyCollection, representing
name, alias, and alias_then_name lookups based on the combination of config and runtime alias settings.
* Adding parametrized tests to check various alias config / runtime setting combinations

Author: sydney-runkle

benches/main.rs

@@ -578,26 +578,46 @@ fn py_get_attrs<'py>(obj: &Bound<'py, PyAny>, attr_name: &Py<PyString>) -> PyRes
     }
 }
 
-pub fn get_lookup_key(
-    py: Python,
-    validation_alias: Option<&Py<PyAny>>,
-    validate_by_name: bool,
-    validate_by_alias: bool,
-    field_name: &str,
-) -> PyResult<LookupKey> {
-    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)
+#[derive(Debug)]
+#[allow(clippy::struct_field_names)]
+pub struct LookupKeyCollection {
+    by_name: LookupKey,
+    by_alias: Option<LookupKey>,
+    by_alias_then_name: Option<LookupKey>,
+}
+
+impl LookupKeyCollection {
+    pub fn new(py: Python, validation_alias: Option<Bound<'_, PyAny>>, field_name: &str) -> PyResult<Self> {
+        let by_name = LookupKey::from_string(py, field_name);
+
+        if let Some(va) = validation_alias {
+            let by_alias = Some(LookupKey::from_py(py, &va, None)?);
+            let by_alias_then_name = Some(LookupKey::from_py(py, &va, Some(field_name))?);
+            Ok(Self {
+                by_name,
+                by_alias,
+                by_alias_then_name,
+            })
+        } else {
+            Ok(Self {
+                by_name,
+                by_alias: None,
+                by_alias_then_name: None,
+            })
         }
-        None => Ok(LookupKey::from_string(py, field_name)),
+    }
+
+    pub fn select(&self, validate_by_alias: bool, validate_by_name: bool) -> PyResult<&LookupKey> {
+        let lookup_key_selection = match (validate_by_alias, validate_by_name) {
+            (true, true) => self.by_alias_then_name.as_ref().unwrap_or(&self.by_name),
+            (true, false) => self.by_alias.as_ref().unwrap_or(&self.by_name),
+            (false, true) => &self.by_name,
+            (false, false) => {
+                // Note: we shouldn't hit this branch much, as this is enforced in `pydantic` with a `PydanticUserError`
+                // at config creation time / validation function call time.
+                return py_schema_err!("`validate_by_name` and `validate_by_alias` cannot both be set to `False`.");
+            }
+        };
+        Ok(lookup_key_selection)
     }
 }

src/lookup_key.rs

@@ -400,7 +400,7 @@ impl PyMultiHostUrl {
                     username: username.map(Into::into),
                     password: password.map(Into::into),
                     host: host.map(Into::into),
-                    port: port.map(Into::into),
+                    port,
                 };
                 format!("{scheme}://{url_host}")
             } else {

src/url.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;
+use crate::lookup_key::LookupKeyCollection;
 use crate::tools::SchemaDict;
 
 use super::validation_state::ValidationState;
@@ -44,7 +44,7 @@ struct Parameter {
     name: String,
     kwarg_key: Option<Py<PyString>>,
     validator: CombinedValidator,
-    alias: Option<Py<PyAny>>,
+    lookup_key_collection: LookupKeyCollection,
     mode: String,
 }
 
@@ -57,8 +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,
+    validate_by_alias: Option<bool>,
+    validate_by_name: Option<bool>,
 }
 
 impl BuildValidator for ArgumentsValidator {
@@ -126,12 +126,16 @@ impl BuildValidator for ArgumentsValidator {
             } else if has_default {
                 had_default_arg = true;
             }
+
+            let validation_alias = arg.get_item(intern!(py, "alias"))?;
+            let lookup_key_collection = LookupKeyCollection::new(py, validation_alias, name.as_str())?;
+
             parameters.push(Parameter {
                 positional,
                 name,
                 kwarg_key,
                 validator,
-                alias: arg.get_item(intern!(py, "alias"))?.map(std::convert::Into::into),
+                lookup_key_collection,
                 mode: mode.to_string(),
             });
         }
@@ -163,8 +167,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),
+            validate_by_alias: schema_or_config_same(schema, config, intern!(py, "validate_by_alias"))?,
+            validate_by_name: schema_or_config_same(schema, config, intern!(py, "validate_by_name"))?,
         }
         .into())
     }
@@ -193,7 +197,7 @@ 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<String> = AHashSet::with_capacity(self.parameters.len());
+        let mut used_kwargs: AHashSet<&str> = 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);
@@ -209,19 +213,17 @@ 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,
-                )?);
+                kw_lookup_key = Some(
+                    parameter
+                        .lookup_key_collection
+                        .select(validate_by_alias, validate_by_name)?,
+                );
             }
 
             if let Some(kwargs) = args.kwargs() {
-                if let Some(ref lookup_key) = kw_lookup_key {
+                if let Some(lookup_key) = kw_lookup_key {
                     if let Some((lookup_path, value)) = kwargs.get_item(lookup_key)? {
-                        used_kwargs.insert(lookup_path.first_key().to_string());
+                        used_kwargs.insert(lookup_path.first_key());
                         kw_value = Some((lookup_path, value));
                     }
                 }

src/validators/arguments.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;
+use crate::lookup_key::LookupKeyCollection;
 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,
-    alias: Option<Py<PyAny>>,
+    lookup_key_collection: LookupKeyCollection,
     validator: CombinedValidator,
     frozen: bool,
 }
@@ -42,8 +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,
+    validate_by_alias: Option<bool>,
+    validate_by_name: Option<bool>,
 }
 
 impl BuildValidator for DataclassArgsValidator {
@@ -93,13 +93,14 @@ impl BuildValidator for DataclassArgsValidator {
                 positional_count += 1;
             }
 
+            let validation_alias = field.get_item(intern!(py, "validation_alias"))?;
+            let lookup_key_collection = LookupKeyCollection::new(py, validation_alias, name.as_str())?;
+
             fields.push(Field {
                 kw_only,
                 name,
                 py_name: py_name.into(),
-                alias: field
-                    .get_item(intern!(py, "validation_alias"))?
-                    .map(std::convert::Into::into),
+                lookup_key_collection,
                 validator,
                 init: field.get_as(intern!(py, "init"))?.unwrap_or(true),
                 init_only: field.get_as(intern!(py, "init_only"))?.unwrap_or(false),
@@ -124,8 +125,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),
+            validate_by_alias: config.get_as(intern!(py, "validate_by_alias"))?,
+            validate_by_name: config.get_as(intern!(py, "validate_by_name"))?,
         }
         .into())
     }
@@ -151,7 +152,7 @@ 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<String> = AHashSet::with_capacity(self.fields.len());
+        let mut used_keys: AHashSet<&str> = AHashSet::with_capacity(self.fields.len());
 
         let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
 
@@ -200,17 +201,14 @@ impl Validator for DataclassArgsValidator {
                 }
             }
 
-            let lookup_key = get_lookup_key(
-                py,
-                field.alias.as_ref(),
-                validate_by_name,
-                validate_by_alias,
-                &field.name,
-            )?;
+            let lookup_key = field
+                .lookup_key_collection
+                .select(validate_by_alias, validate_by_name)?;
+
             let mut kw_value = None;
             if let Some(kwargs) = args.kwargs() {
-                if let Some((lookup_path, value)) = kwargs.get_item(&lookup_key)? {
-                    used_keys.insert(lookup_path.first_key().to_string());
+                if let Some((lookup_path, value)) = kwargs.get_item(lookup_key)? {
+                    used_keys.insert(lookup_path.first_key());
                     kw_value = Some((lookup_path, value));
                 }
             }

src/validators/dataclass.rs

@@ -12,15 +12,15 @@ use crate::errors::LocItem;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::ConsumeIterator;
 use crate::input::{BorrowInput, Input, ValidatedDict, ValidationMatch};
-use crate::lookup_key::get_lookup_key;
+use crate::lookup_key::LookupKeyCollection;
 use crate::tools::SchemaDict;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug)]
 struct Field {
     name: String,
-    alias: Option<Py<PyAny>>,
+    lookup_key_collection: LookupKeyCollection,
     name_py: Py<PyString>,
     validator: CombinedValidator,
     frozen: bool,
@@ -37,8 +37,8 @@ pub struct ModelFieldsValidator {
     strict: bool,
     from_attributes: bool,
     loc_by_alias: bool,
-    validate_by_alias: bool,
-    validate_by_name: bool,
+    validate_by_alias: Option<bool>,
+    validate_by_name: Option<bool>,
 }
 
 impl BuildValidator for ModelFieldsValidator {
@@ -52,9 +52,11 @@ impl BuildValidator for ModelFieldsValidator {
         let py = schema.py();
 
         let strict = is_strict(schema, config)?;
-        let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
+
         let from_attributes = schema_or_config_same(schema, config, intern!(py, "from_attributes"))?.unwrap_or(false);
 
+        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) {
             (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(&v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
@@ -79,11 +81,12 @@ impl BuildValidator for ModelFieldsValidator {
                 Err(err) => return py_schema_err!("Field \"{}\":\n  {}", field_name, err),
             };
 
+            let validation_alias = field_info.get_item(intern!(py, "validation_alias"))?;
+            let lookup_key_collection = LookupKeyCollection::new(py, validation_alias, field_name)?;
+
             fields.push(Field {
                 name: field_name.to_string(),
-                alias: field_info
-                    .get_item(intern!(py, "validation_alias"))?
-                    .map(std::convert::Into::into),
+                lookup_key_collection,
                 name_py: field_name_py.into(),
                 validator,
                 frozen: field_info.get_as::<bool>(intern!(py, "frozen"))?.unwrap_or(false),
@@ -98,8 +101,8 @@ impl BuildValidator for ModelFieldsValidator {
             strict,
             from_attributes,
             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),
+            validate_by_alias: config.get_as(intern!(py, "validate_by_alias"))?,
+            validate_by_name: config.get_as(intern!(py, "validate_by_name"))?,
         }
         .into())
     }
@@ -157,7 +160,7 @@ impl Validator for ModelFieldsValidator {
 
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
-        let mut used_keys: Option<AHashSet<String>> =
+        let mut used_keys: Option<AHashSet<&str>> =
             if self.extra_behavior == ExtraBehavior::Ignore || dict.is_py_get_attr() {
                 None
             } else {
@@ -168,14 +171,10 @@ impl Validator for ModelFieldsValidator {
             let state = &mut state.rebind_extra(|extra| extra.data = Some(model_dict.clone()));
 
             for field in &self.fields {
-                let lookup_key = get_lookup_key(
-                    py,
-                    field.alias.as_ref(),
-                    validate_by_name,
-                    validate_by_alias,
-                    &field.name,
-                )?;
-                let op_key_value = match dict.get_item(&lookup_key) {
+                let lookup_key = field
+                    .lookup_key_collection
+                    .select(validate_by_alias, validate_by_name)?;
+                let op_key_value = match dict.get_item(lookup_key) {
                     Ok(v) => v,
                     Err(ValError::LineErrors(line_errors)) => {
                         for err in line_errors {
@@ -189,7 +188,7 @@ impl Validator for ModelFieldsValidator {
                     if let Some(ref mut used_keys) = used_keys {
                         // key is "used" whether or not validation passes, since we want to skip this key in
                         // extra logic either way
-                        used_keys.insert(lookup_path.first_key().to_string());
+                        used_keys.insert(lookup_path.first_key());
                     }
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
@@ -240,7 +239,7 @@ impl Validator for ModelFieldsValidator {
         if let Some(used_keys) = used_keys {
             struct ValidateToModelExtra<'a, 's, 'py> {
                 py: Python<'py>,
-                used_keys: AHashSet<String>,
+                used_keys: AHashSet<&'a str>,
                 errors: &'a mut Vec<ValLineError>,
                 fields_set_vec: &'a mut Vec<Py<PyString>>,
                 extra_behavior: ExtraBehavior,