fix borrows with lookup key

sydney-runkle · sydney-runkle · commit 8bc435034d1f · 2025-02-20T18:48:20.000-05:00
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
@@ -580,7 +580,7 @@ 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>>,
+    validation_alias: Option<&Py<PyAny>>,
     validate_by_name: bool,
     validate_by_alias: bool,
     field_name: &str,
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
@@ -4,7 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString, PyTuple};
 
-use ahash::{AHashSet, AHashMap};
+use ahash::AHashSet;
 use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::py_schema_err;
@@ -45,7 +45,7 @@ struct Parameter {
     kwarg_key: Option<Py<PyString>>,
     validator: CombinedValidator,
     alias: Option<Py<PyAny>>,
-    mode: String
+    mode: String,
 }
 
 #[derive(Debug)]
@@ -98,9 +98,10 @@ impl BuildValidator for ArgumentsValidator {
                 had_keyword_only = true;
             }
 
-            let kwarg_key = match mode == "keyword_only" || mode == "positional_or_keyword" {
-                true => Some(py_name.unbind()),
-                false => None,
+            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"))?;
@@ -130,8 +131,8 @@ impl BuildValidator for ArgumentsValidator {
                 name,
                 kwarg_key,
                 validator,
-                alias: arg.get_item(intern!(py, "alias"))?.map(|v| v.into()),
-                mode: mode.to_string()
+                alias: arg.get_item(intern!(py, "alias"))?.map(std::convert::Into::into),
+                mode: mode.to_string(),
             });
         }
 
@@ -192,20 +193,11 @@ 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);
 
-        let mut lookup_keys = AHashMap::with_capacity(self.parameters.len());
-        for param in &self.parameters {
-            if param.mode == "keyword_only" || param.mode == "positional_or_keyword" {
-                let param_name = param.name.as_str();
-                let lookup_key = get_lookup_key(py, &param.alias, validate_by_name, validate_by_alias, param_name)?;
-                lookup_keys.insert(param_name, lookup_key);
-            }
-        }
-
         // go through arguments getting the value from args or kwargs and validating it
         for (index, parameter) in self.parameters.iter().enumerate() {
             let mut pos_value = None;
@@ -215,12 +207,21 @@ impl Validator for ArgumentsValidator {
                 }
             }
             let mut kw_value = None;
-            let kw_lookup_key = lookup_keys.get(parameter.name.as_str());
+            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(lookup_key) = 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));
                     }
                 }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
@@ -3,7 +3,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString, PyTuple, PyType};
 
-use ahash::{AHashMap, AHashSet};
+use ahash::AHashSet;
 use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::py_schema_err;
@@ -97,7 +97,9 @@ impl BuildValidator for DataclassArgsValidator {
                 kw_only,
                 name,
                 py_name: py_name.into(),
-                alias: field.get_item(intern!(py, "validation_alias"))?.map(|a| a.into()),
+                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),
@@ -149,19 +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 lookup_keys = AHashMap::with_capacity(self.fields.len());
-        for field in &self.fields {
-            let lookup_key = get_lookup_key(py, &field.alias, validate_by_name, validate_by_alias, &field.name)?;
-            lookup_keys.insert(&field.name, lookup_key);
-        }
-
         let mut fields_set_count: usize = 0;
 
         macro_rules! set_item {
@@ -204,11 +200,17 @@ impl Validator for DataclassArgsValidator {
                 }
             }
 
-            let lookup_key = &lookup_keys[&field.name];
+            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(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));
                 }
             }
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
@@ -193,6 +193,7 @@ impl SchemaValidator {
         .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
     }
 
+    #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, by_alias=None, by_name=None))]
     pub fn isinstance_python(
         &self,
@@ -226,6 +227,7 @@ impl SchemaValidator {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (input, *, strict=None, context=None, self_instance=None, allow_partial=PartialMode::Off, by_alias=None, by_name=None))]
     pub fn validate_json(
         &self,
@@ -256,6 +258,7 @@ impl SchemaValidator {
         r.map_err(|e| self.prepare_validation_err(py, e, InputType::Json))
     }
 
+    #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (input, *, strict=None, context=None, allow_partial=PartialMode::Off, by_alias=None, by_name=None))]
     pub fn validate_strings(
         &self,
@@ -684,6 +687,7 @@ pub struct Extra<'a, 'py> {
 }
 
 impl<'a, 'py> Extra<'a, 'py> {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         strict: Option<bool>,
         from_attributes: Option<bool>,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
@@ -3,7 +3,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PySet, PyString, PyType};
 
-use ahash::{AHashMap, AHashSet};
+use ahash::AHashSet;
 use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::py_schema_err;
@@ -81,7 +81,9 @@ impl BuildValidator for ModelFieldsValidator {
 
             fields.push(Field {
                 name: field_name.to_string(),
-                alias: field_info.get_item(intern!(py, "validation_alias"))?.map(|a| a.into()),
+                alias: field_info
+                    .get_item(intern!(py, "validation_alias"))?
+                    .map(std::convert::Into::into),
                 name_py: field_name_py.into(),
                 validator,
                 frozen: field_info.get_as::<bool>(intern!(py, "frozen"))?.unwrap_or(false),
@@ -153,15 +155,9 @@ impl Validator for ModelFieldsValidator {
         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 lookup_keys = AHashMap::with_capacity(self.fields.len());
-        for field in &self.fields {
-            let lookup_key = get_lookup_key(py, &field.alias, validate_by_name, validate_by_alias, &field.name)?;
-            lookup_keys.insert(&field.name, lookup_key);
-        }
-
         // 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<&str>> =
+        let mut used_keys: Option<AHashSet<String>> =
             if self.extra_behavior == ExtraBehavior::Ignore || dict.is_py_get_attr() {
                 None
             } else {
@@ -172,8 +168,14 @@ 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 = &lookup_keys[&field.name];
-                let op_key_value = match dict.get_item(lookup_key) {
+                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) {
                     Ok(v) => v,
                     Err(ValError::LineErrors(line_errors)) => {
                         for err in line_errors {
@@ -187,7 +189,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());
+                        used_keys.insert(lookup_path.first_key().to_string());
                     }
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
@@ -238,7 +240,7 @@ impl Validator for ModelFieldsValidator {
         if let Some(used_keys) = used_keys {
             struct ValidateToModelExtra<'a, 's, 'py> {
                 py: Python<'py>,
-                used_keys: AHashSet<&'a str>,
+                used_keys: AHashSet<String>,
                 errors: &'a mut Vec<ValLineError>,
                 fields_set_vec: &'a mut Vec<Py<PyString>>,
                 extra_behavior: ExtraBehavior,
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
@@ -1,4 +1,3 @@
-use ahash::AHashMap;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
@@ -112,7 +111,9 @@ impl BuildValidator for TypedDictValidator {
 
             fields.push(TypedDictField {
                 name: field_name.to_string(),
-                alias: field_info.get_item(intern!(py, "validation_alias"))?.map(|a| a.into()),
+                alias: field_info
+                    .get_item(intern!(py, "validation_alias"))?
+                    .map(std::convert::Into::into),
                 name_py: field_name_py.into(),
                 validator,
                 required,
@@ -159,15 +160,9 @@ impl Validator for TypedDictValidator {
         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 lookup_keys = AHashMap::with_capacity(self.fields.len());
-        for field in &self.fields {
-            let lookup_key = get_lookup_key(py, &field.alias, validate_by_name, validate_by_alias, &field.name)?;
-            lookup_keys.insert(&field.name, lookup_key);
-        }
-
         // 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<&str>> =
+        let mut used_keys: Option<AHashSet<String>> =
             if self.extra_behavior == ExtraBehavior::Ignore || dict.is_py_get_attr() {
                 None
             } else {
@@ -180,8 +175,14 @@ impl Validator for TypedDictValidator {
             let mut fields_set_count: usize = 0;
 
             for field in &self.fields {
-                let lookup_key = &lookup_keys[&field.name];
-                let op_key_value = match dict.get_item(lookup_key) {
+                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) {
                     Ok(v) => v,
                     Err(ValError::LineErrors(line_errors)) => {
                         let field_loc: LocItem = field.name.clone().into();
@@ -198,7 +199,7 @@ impl Validator for TypedDictValidator {
                     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());
+                        used_keys.insert(lookup_path.first_key().to_string());
                     }
                     let is_last_partial = if let Some(ref last_key) = partial_last_key {
                         let first_key_loc: LocItem = lookup_path.first_key().into();
@@ -264,7 +265,7 @@ impl Validator for TypedDictValidator {
         if let Some(used_keys) = used_keys {
             struct ValidateExtras<'a, 's, 'py> {
                 py: Python<'py>,
-                used_keys: AHashSet<&'a str>,
+                used_keys: AHashSet<String>,
                 errors: &'a mut Vec<ValLineError>,
                 extras_validator: Option<&'a CombinedValidator>,
                 output_dict: &'a Bound<'py, PyDict>,
diff --git a/tests/test.rs b/tests/test.rs
@@ -136,7 +136,7 @@ json_input = '{"a": "something"}'
             let json_input = locals.get_item("json_input").unwrap().unwrap();
             let binding = SchemaValidator::py_new(py, &schema, None)
                 .unwrap()
-                .validate_json(py, &json_input, None, None, None, false.into())
+                .validate_json(py, &json_input, None, None, None, false.into(), None, None)
                 .unwrap();
             let validation_result: Bound<'_, PyAny> = binding.extract(py).unwrap();
             let repr = format!("{}", validation_result.repr().unwrap());

Original file line number	Diff line number	Diff line change
`@@ -193,6 +193,7 @@ impl SchemaValidator {`
`193`	`193`	`.map_err(\|e\| self.prepare_validation_err(py, e, InputType::Python))`
`194`	`194`	`}`
`195`	`195`
	`196`	`+ #[allow(clippy::too_many_arguments)]`
`196`	`197`	`#[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, by_alias=None, by_name=None))]`
`197`	`198`	`pub fn isinstance_python(`
`198`	`199`	`&self,`
`@@ -226,6 +227,7 @@ impl SchemaValidator {`
`226`	`227`	`}`
`227`	`228`	`}`
`228`	`229`
	`230`	`+ #[allow(clippy::too_many_arguments)]`
`229`	`231`	`#[pyo3(signature = (input, *, strict=None, context=None, self_instance=None, allow_partial=PartialMode::Off, by_alias=None, by_name=None))]`
`230`	`232`	`pub fn validate_json(`
`231`	`233`	`&self,`
`@@ -256,6 +258,7 @@ impl SchemaValidator {`
`256`	`258`	`r.map_err(\|e\| self.prepare_validation_err(py, e, InputType::Json))`
`257`	`259`	`}`
`258`	`260`
	`261`	`+ #[allow(clippy::too_many_arguments)]`
`259`	`262`	`#[pyo3(signature = (input, *, strict=None, context=None, allow_partial=PartialMode::Off, by_alias=None, by_name=None))]`
`260`	`263`	`pub fn validate_strings(`
`261`	`264`	`&self,`
`@@ -684,6 +687,7 @@ pub struct Extra<'a, 'py> {`
`684`	`687`	`}`
`685`	`688`
`686`	`689`	`impl<'a, 'py> Extra<'a, 'py> {`
	`690`	`+ #[allow(clippy::too_many_arguments)]`
`687`	`691`	`pub fn new(`
`688`	`692`	`strict: Option<bool>,`
`689`	`693`	`from_attributes: Option<bool>,`