push model_fields over to Py2

Author: davidhewitt

src/errors/location.rs

@@ -128,7 +128,7 @@ impl ToPyObject for Location {
         match self {
             Self::List(loc) => PyTuple::new(py, loc.iter().rev()).to_object(py),
             Self::Empty => EMPTY_TUPLE
-                .get_or_init(py, || PyTuple::empty(py).to_object(py))
+                .get_or_init(py, || PyTuple::empty2(py).to_object(py))
                 .clone_ref(py),
         }
     }

src/input/return_enums.rs

@@ -460,8 +460,10 @@ pub struct DictGenericIterator<'py> {
 }
 
 impl<'py> DictGenericIterator<'py> {
-    pub fn new(dict: &'py PyDict) -> ValResult<Self> {
-        Ok(Self { dict_iter: dict.iter() })
+    pub fn new(dict: &Py2<'py, PyDict>) -> ValResult<Self> {
+        Ok(Self {
+            dict_iter: dict.clone().into_gil_ref().iter(),
+        })
     }
 }
 
@@ -490,15 +492,18 @@ fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) ->
 }
 
 impl<'py> MappingGenericIterator<'py> {
-    pub fn new(mapping: &'py PyMapping) -> ValResult<Self> {
+    pub fn new(mapping: &Py2<'py, PyMapping>) -> ValResult<Self> {
         let py = mapping.py();
-        let input: &PyAny = mapping;
+        let input: &PyAny = (**mapping).clone().into_gil_ref();
         let iter = mapping
             .items()
             .map_err(|e| mapping_err(e, py, input))?
             .iter()
             .map_err(|e| mapping_err(e, py, input))?;
-        Ok(Self { input, iter })
+        Ok(Self {
+            input,
+            iter: unsafe { mapping.py().from_owned_ptr(iter.into_ptr()) },
+        })
     }
 }
 
@@ -528,8 +533,10 @@ pub struct StringMappingGenericIterator<'py> {
 }
 
 impl<'py> StringMappingGenericIterator<'py> {
-    pub fn new(dict: &'py PyDict) -> ValResult<Self> {
-        Ok(Self { dict_iter: dict.iter() })
+    pub fn new(dict: &Py2<'py, PyDict>) -> ValResult<Self> {
+        Ok(Self {
+            dict_iter: dict.clone().into_gil_ref().iter(),
+        })
     }
 }
 
@@ -562,10 +569,11 @@ pub struct AttributesGenericIterator<'py> {
 }
 
 impl<'py> AttributesGenericIterator<'py> {
-    pub fn new(py_any: &'py PyAny) -> ValResult<Self> {
+    pub fn new(py_any: &Py2<'py, PyAny>) -> ValResult<Self> {
+        let attributes_iterator = py_any.dir().into_gil_ref().into_iter();
         Ok(Self {
-            object: py_any,
-            attributes_iterator: py_any.dir().into_iter(),
+            object: py_any.clone().into_gil_ref(),
+            attributes_iterator,
         })
     }
 }
@@ -713,14 +721,17 @@ impl GenericJsonIterator {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub struct PyArgs<'a> {
-    pub args: Option<&'a PyTuple>,
-    pub kwargs: Option<&'a PyDict>,
+pub struct PyArgs<'py> {
+    pub args: Option<Py2<'py, PyTuple>>,
+    pub kwargs: Option<Py2<'py, PyDict>>,
 }
 
 impl<'a> PyArgs<'a> {
     pub fn new(args: Option<&'a PyTuple>, kwargs: Option<&'a PyDict>) -> Self {
-        Self { args, kwargs }
+        Self {
+            args: args.map(|args| Py2::borrowed_from_gil_ref(&args).clone()),
+            kwargs: kwargs.map(|kwargs| Py2::borrowed_from_gil_ref(&kwargs).clone()),
+        }
     }
 }
 

src/lookup_key.rs

@@ -108,10 +108,10 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_dict_item<'data, 's>(
+    pub fn py_get_dict_item<'py, 's>(
         &'s self,
-        dict: &'data PyDict,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        dict: &Py2<'py, PyDict>,
+    ) -> ValResult<Option<(&'s LookupPath, Py2<'py, PyAny>)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key)? {
                 Some(value) => Ok(Some((path, value))),
@@ -134,7 +134,7 @@ impl LookupKey {
                 for path in path_choices {
                     // iterate over the path and plug each value into the py_any from the last step, starting with dict
                     // this could just be a loop but should be somewhat faster with a functional design
-                    if let Some(v) = path.iter().try_fold(dict as &PyAny, |d, loc| loc.py_get_item(d)) {
+                    if let Some(v) = path.iter().try_fold((**dict).clone(), |d, loc| loc.py_get_item(&d)) {
                         // Successfully found an item, return it
                         return Ok(Some((path, v)));
                     }
@@ -145,22 +145,22 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_string_mapping_item<'data, 's>(
+    pub fn py_get_string_mapping_item<'py, 's>(
         &'s self,
-        dict: &'data PyDict,
-    ) -> ValResult<Option<(&'s LookupPath, StringMapping<'data>)>> {
+        dict: &Py2<'py, PyDict>,
+    ) -> ValResult<Option<(&'s LookupPath, StringMapping<'py>)>> {
         if let Some((path, py_any)) = self.py_get_dict_item(dict)? {
-            let value = StringMapping::new_value(py_any)?;
+            let value = StringMapping::new_value(py_any.into_gil_ref())?;
             Ok(Some((path, value)))
         } else {
             Ok(None)
         }
     }
 
-    pub fn py_get_mapping_item<'data, 's>(
+    pub fn py_get_mapping_item<'py, 's>(
         &'s self,
-        dict: &'data PyMapping,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        dict: &Py2<'py, PyMapping>,
+    ) -> ValResult<Option<(&'s LookupPath, Py2<'py, PyAny>)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key) {
                 Ok(value) => Ok(Some((path, value))),
@@ -183,7 +183,7 @@ impl LookupKey {
                 for path in path_choices {
                     // iterate over the path and plug each value into the py_any from the last step, starting with dict
                     // this could just be a loop but should be somewhat faster with a functional design
-                    if let Some(v) = path.iter().try_fold(dict as &PyAny, |d, loc| loc.py_get_item(d)) {
+                    if let Some(v) = path.iter().try_fold((**dict).clone(), |d, loc| loc.py_get_item(&d)) {
                         // Successfully found an item, return it
                         return Ok(Some((path, v)));
                     }
@@ -194,28 +194,28 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_attr<'data, 's>(
+    pub fn py_get_attr<'py, 's>(
         &'s self,
-        obj: &'data PyAny,
-        kwargs: Option<&'data PyDict>,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        obj: &Py2<'py, PyAny>,
+        kwargs: Option<&Py2<'py, PyDict>>,
+    ) -> ValResult<Option<(&'s LookupPath, Py2<'py, PyAny>)>> {
         match self._py_get_attr(obj, kwargs) {
             Ok(v) => Ok(v),
             Err(err) => {
                 let error = py_err_string(obj.py(), err);
                 Err(ValError::new(
                     ErrorType::GetAttributeError { error, context: None },
-                    obj,
+                    obj.as_gil_ref(),
                 ))
             }
         }
     }
 
-    pub fn _py_get_attr<'data, 's>(
+    pub fn _py_get_attr<'py, 's>(
         &'s self,
-        obj: &'data PyAny,
-        kwargs: Option<&'data PyDict>,
-    ) -> PyResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        obj: &Py2<'py, PyAny>,
+        kwargs: Option<&Py2<'py, PyDict>>,
+    ) -> PyResult<Option<(&'s LookupPath, Py2<'py, PyAny>)>> {
         if let Some(dict) = kwargs {
             if let Ok(Some(item)) = self.py_get_dict_item(dict) {
                 return Ok(Some(item));
@@ -244,9 +244,9 @@ impl LookupKey {
                 'outer: for path in path_choices {
                     // similar to above, but using `py_get_attrs`, we can't use try_fold because of the extra Err
                     // so we have to loop manually
-                    let mut v = obj;
+                    let mut v = obj.clone();
                     for loc in path.iter() {
-                        v = match loc.py_get_attrs(v) {
+                        v = match loc.py_get_attrs(&v) {
                             Ok(Some(v)) => v,
                             Ok(None) => {
                                 continue 'outer;
@@ -446,7 +446,7 @@ impl PathItem {
         }
     }
 
-    pub fn py_get_item<'a>(&self, py_any: &'a PyAny) -> Option<&'a PyAny> {
+    pub fn py_get_item<'py>(&self, py_any: &Py2<'py, PyAny>) -> Option<Py2<'py, PyAny>> {
         // we definitely don't want to index strings, so explicitly omit this case
         if py_any.downcast::<PyString>().is_ok() {
             None
@@ -463,7 +463,7 @@ impl PathItem {
         }
     }
 
-    pub fn py_get_attrs<'a>(&self, obj: &'a PyAny) -> PyResult<Option<&'a PyAny>> {
+    pub fn py_get_attrs<'py>(&self, obj: &Py2<'py, PyAny>) -> PyResult<Option<Py2<'py, PyAny>>> {
         match self {
             Self::S(_, py_key) => {
                 // if obj is a dict, we want to use get_item, not getattr
@@ -506,7 +506,7 @@ impl PathItem {
 
 /// wrapper around `getattr` that returns `Ok(None)` for attribute errors, but returns other errors
 /// We don't check `try_from_attributes` because that check was performed on the top level object before we got here
-fn py_get_attrs<'a>(obj: &'a PyAny, attr_name: &Py<PyString>) -> PyResult<Option<&'a PyAny>> {
+fn py_get_attrs<'py>(obj: &Py2<'py, PyAny>, attr_name: &Py<PyString>) -> PyResult<Option<Py2<'py, PyAny>>> {
     match obj.getattr(attr_name.extract::<&PyString>(obj.py())?) {
         Ok(attr) => Ok(Some(attr)),
         Err(err) => {

src/validators/arguments.rs

@@ -7,7 +7,7 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::schema_or_config_same;
 use crate::errors::{AsLocItem, ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{GenericArguments, Input, ValidationMatch};
+use crate::input::{BorrowInput, GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
 
 use crate::tools::SchemaDict;
@@ -179,15 +179,15 @@ impl Validator for ArgumentsValidator {
                 // 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;
-                    if let Some(args) = $args.args {
+                    if let Some(args) = &$args.args {
                         if parameter.positional {
                             pos_value = $get_macro!(args, index);
                         }
                     }
                     let mut kw_value = None;
-                    if let Some(kwargs) = $args.kwargs {
+                    if let Some(kwargs) = &$args.kwargs {
                         if let Some(ref lookup_key) = parameter.kw_lookup_key {
-                            if let Some((lookup_path, value)) = lookup_key.$get_method(kwargs)? {
+                            if let Some((lookup_path, value)) = lookup_key.$get_method(&kwargs)? {
                                 used_kwargs.insert(lookup_path.first_key());
                                 kw_value = Some((lookup_path, value));
                             }
@@ -198,12 +198,12 @@ impl Validator for ArgumentsValidator {
                         (Some(_), Some((_, kw_value))) => {
                             errors.push(ValLineError::new_with_loc(
                                 ErrorTypeDefaults::MultipleArgumentValues,
-                                kw_value,
+                                kw_value.borrow_input(),
                                 parameter.name.clone(),
                             ));
                         }
                         (Some(pos_value), None) => {
-                            match parameter.validator.validate(py, pos_value, state)
+                            match parameter.validator.validate(py, pos_value.borrow_input(), state)
                             {
                                 Ok(value) => output_args.push(value),
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -213,7 +213,7 @@ impl Validator for ArgumentsValidator {
                             }
                         }
                         (None, Some((lookup_path, kw_value))) => {
-                            match parameter.validator.validate(py, kw_value, state)
+                            match parameter.validator.validate(py, kw_value.borrow_input(), state)
                             {
                                 Ok(value) => output_kwargs.set_item(parameter.kwarg_key.as_ref().unwrap(), value)?,
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -255,7 +255,7 @@ impl Validator for ArgumentsValidator {
                     if len > self.positional_params_count {
                         if let Some(ref validator) = self.var_args_validator {
                             for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
-                                match validator.validate(py, item, state) {
+                                match validator.validate(py, item.borrow_input(), state) {
                                     Ok(value) => output_args.push(value),
                                     Err(ValError::LineErrors(line_errors)) => {
                                         errors.extend(
@@ -271,7 +271,7 @@ impl Validator for ArgumentsValidator {
                             for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
                                 errors.push(ValLineError::new_with_loc(
                                     ErrorTypeDefaults::UnexpectedPositionalArgument,
-                                    item,
+                                    item.borrow_input(),
                                     index + self.positional_params_count,
                                 ));
                             }
@@ -282,6 +282,9 @@ impl Validator for ArgumentsValidator {
                 if let Some(kwargs) = $args.kwargs {
                     if kwargs.len() > used_kwargs.len() {
                         for (raw_key, value) in kwargs.iter() {
+                            // FIXME workaround for Py2 not having input yet
+                            let raw_key = raw_key.borrow_input();
+                            let value = value.borrow_input();
                             let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
                                 Ok(k) => k,
                                 Err(ValError::LineErrors(line_errors)) => {