fix for python 3.11

Author: samuelcolvin

src/input/input_abstract.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use pyo3::types::{PyDict, PyString, PyType};
+use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};
 
 use crate::errors::{InputValue, LocItem, ValResult};
@@ -40,11 +40,6 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
 
     fn is_none(&self) -> bool;
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn input_get_attr(&self, _name: &PyString) -> Option<PyResult<&PyAny>> {
-        None
-    }
-
     fn input_is_instance(&self, _class: &PyType) -> Option<&PyAny> {
         None
     }

src/input/input_python.rs

@@ -109,10 +109,6 @@ impl<'a> Input<'a> for PyAny {
         self.is_none()
     }
 
-    fn input_get_attr(&self, name: &PyString) -> Option<PyResult<&PyAny>> {
-        Some(self.getattr(name))
-    }
-
     fn input_is_instance(&self, class: &PyType) -> Option<&PyAny> {
         if self.is_instance(class).unwrap_or(false) {
             Some(self)

src/serializers/mod.rs

@@ -11,6 +11,7 @@ use config::SerializationConfig;
 pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValue};
 use extra::{CollectWarnings, SerRecursionGuard};
 pub(crate) use extra::{Extra, SerMode, SerializationState};
+pub(crate) use shared::slots_dc_dict;
 pub use shared::CombinedSerializer;
 use shared::{to_json_bytes, BuildSerializer, TypeSerializer};
 

src/serializers/shared.rs

@@ -3,7 +3,7 @@ use std::fmt::Debug;
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PySet, PyString, PyTuple};
+use pyo3::types::{PyDict, PySet, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
 use enum_dispatch::enum_dispatch;
@@ -331,16 +331,9 @@ pub(super) fn object_to_dict<'py>(value: &'py PyAny, is_model: bool, extra: &Ext
     let py = value.py();
     let attrs: &PyDict = match value.getattr(intern!(py, "__dict__")) {
         Ok(attr) => attr.downcast()?,
-        Err(_) => {
-            let slots: &PyTuple = value.getattr(intern!(py, "__slots__"))?.downcast()?;
-            let dict = PyDict::new(py);
-            for slot in slots {
-                let slot: &PyString = slot.downcast()?;
-                dict.set_item(slot, value.getattr(slot)?)?;
-            }
-            dict
-        }
+        Err(_) => return slots_dc_dict(value),
     };
+
     if is_model && extra.exclude_unset {
         let fields_set: &PySet = value.getattr(intern!(py, "__pydantic_fields_set__"))?.downcast()?;
 
@@ -355,3 +348,14 @@ pub(super) fn object_to_dict<'py>(value: &'py PyAny, is_model: bool, extra: &Ext
         Ok(attrs)
     }
 }
+
+pub(crate) fn slots_dc_dict(value: &PyAny) -> PyResult<&PyDict> {
+    let py = value.py();
+    let dc_fields: &PyDict = value.getattr(intern!(py, "__dataclass_fields__"))?.downcast()?;
+    let dict = PyDict::new(py);
+    for field in dc_fields.keys() {
+        let field: &PyString = field.downcast()?;
+        dict.set_item(field, value.getattr(field)?)?;
+    }
+    Ok(dict)
+}

src/validators/dataclass.rs

@@ -10,6 +10,7 @@ use crate::errors::{ErrorType, ValError, ValLineError, ValResult};
 use crate::input::{GenericArguments, Input};
 use crate::lookup_key::LookupKey;
 use crate::recursion_guard::RecursionGuard;
+use crate::serializers::slots_dc_dict;
 use crate::validators::function::convert_err;
 
 use super::arguments::{json_get, json_slice, py_get, py_slice};
@@ -490,17 +491,7 @@ impl Validator for DataclassValidator {
             if self.revalidate.should_revalidate(py_input, class) {
                 let input_dict = match py_input.getattr(intern!(py, "__dict__")) {
                     Ok(attr) => attr,
-                    Err(_) => {
-                        // we inspect `__slots__` to get the attributes instead of using `self.slots` as a
-                        // subclass could have `slots=True`
-                        let slots: &PyTuple = py_input.getattr(intern!(py, "__slots__"))?.downcast()?;
-                        let dict = PyDict::new(py);
-                        for slot in slots {
-                            let slot: &PyString = slot.downcast()?;
-                            dict.set_item(slot, py_input.getattr(slot)?)?;
-                        }
-                        dict
-                    }
+                    Err(_) => slots_dc_dict(py_input)?,
                 };
                 let val_output = self
                     .validator

src/validators/model.rs

@@ -211,7 +211,7 @@ impl Validator for ModelValidator {
 
         let (output, _, updated_fields_set): (&PyDict, &PyAny, &PySet) = output.extract(py)?;
 
-        if let Ok(fields_set) = model.input_get_attr(intern!(py, DUNDER_FIELDS_SET_KEY)).unwrap() {
+        if let Ok(fields_set) = model.getattr(intern!(py, DUNDER_FIELDS_SET_KEY)) {
             let fields_set: &PySet = fields_set.downcast()?;
             for field_name in updated_fields_set {
                 fields_set.add(field_name)?;

tests/serializers/test_any.py

@@ -484,3 +484,10 @@ class Foo:
 
     foo = Foo(1, 'a')
     assert any_serializer.to_python(foo) == IsStrictDict(a=1, b='a')
+
+    @dataclasses.dataclass(slots=True)
+    class Foo2(Foo):
+        pass
+
+    foo2 = Foo2(2, 'b')
+    assert any_serializer.to_python(foo2) == IsStrictDict(a=2, b='b')