temp refactor for model fields to experiment with perf

Author: sydney-runkle

src/lookup_key.rs

@@ -601,3 +601,47 @@ pub fn get_lookup_key(
         None => Ok(LookupKey::from_string(py, field_name)),
     }
 }
+
+#[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,
+            })
+        }
+    }
+
+    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/validators/model_fields.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,
@@ -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),
@@ -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,