deactivate gil-refs

Author: davidhewitt

Cargo.toml

@@ -27,7 +27,7 @@ include = [
 rust-version = "1.70"
 
 [dependencies]
-pyo3 = { version = "0.21.0-beta.0", features = ["generate-import-lib", "num-bigint", "gil-refs"] }
+pyo3 = { version = "0.21.0-beta.0", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"

benches/main.rs

@@ -15,9 +15,9 @@ pub struct ArgsKwargs {
 
 impl ArgsKwargs {
     fn eq(&self, py: Python, other: &Self) -> PyResult<bool> {
-        if self.args.as_ref(py).eq(other.args.as_ref(py))? {
+        if self.args.bind(py).eq(other.args.bind(py))? {
             match (&self.kwargs, &other.kwargs) {
-                (Some(d1), Some(d2)) => d1.as_ref(py).eq(d2.as_ref(py)),
+                (Some(d1), Some(d2)) => d1.bind(py).eq(d2.bind(py)),
                 (None, None) => Ok(true),
                 _ => Ok(false),
             }
@@ -55,9 +55,9 @@ impl ArgsKwargs {
     }
 
     pub fn __repr__(&self, py: Python) -> String {
-        let args = safe_repr(self.args.as_ref(py));
+        let args = safe_repr(self.args.bind(py));
         match self.kwargs {
-            Some(ref d) => format!("ArgsKwargs({args}, {})", safe_repr(d.as_ref(py))),
+            Some(ref d) => format!("ArgsKwargs({args}, {})", safe_repr(d.bind(py))),
             None => format!("ArgsKwargs({args})"),
         }
     }

src/argument_markers.rs

@@ -12,8 +12,8 @@ use crate::tools::SchemaDict;
 use crate::ValidationError;
 
 pub fn schema_or_config<'py, T>(
-    schema: &'py PyDict,
-    config: Option<&'py PyDict>,
+    schema: &Bound<'py, PyDict>,
+    config: Option<&Bound<'py, PyDict>>,
     schema_key: &Bound<'py, PyString>,
     config_key: &Bound<'py, PyString>,
 ) -> PyResult<Option<T>>
@@ -30,8 +30,8 @@ where
 }
 
 pub fn schema_or_config_same<'py, T>(
-    schema: &'py PyDict,
-    config: Option<&'py PyDict>,
+    schema: &Bound<'py, PyDict>,
+    config: Option<&Bound<'py, PyDict>>,
     key: &Bound<'py, PyString>,
 ) -> PyResult<Option<T>>
 where
@@ -40,7 +40,7 @@ where
     schema_or_config(schema, config, key, key)
 }
 
-pub fn is_strict(schema: &PyDict, config: Option<&PyDict>) -> PyResult<bool> {
+pub fn is_strict(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<bool> {
     let py = schema.py();
     Ok(schema_or_config_same(schema, config, intern!(py, "strict"))?.unwrap_or(false))
 }
@@ -90,7 +90,7 @@ impl SchemaError {
                     ValidationError::new(line_errors, "Schema".to_object(py), InputType::Python, false);
                 let schema_error = SchemaError(SchemaErrorEnum::ValidationError(validation_error));
                 match Py::new(py, schema_error) {
-                    Ok(err) => PyErr::from_value(err.into_ref(py)),
+                    Ok(err) => PyErr::from_value_bound(err.into_bound(py).into_any()),
                     Err(err) => err,
                 }
             }
@@ -124,7 +124,7 @@ impl SchemaError {
 
     fn errors(&self, py: Python) -> PyResult<Py<PyList>> {
         match &self.0 {
-            SchemaErrorEnum::Message(_) => Ok(PyList::empty(py).into_py(py)),
+            SchemaErrorEnum::Message(_) => Ok(PyList::empty_bound(py).unbind()),
             SchemaErrorEnum::ValidationError(error) => error.errors(py, false, false, true),
         }
     }
@@ -174,18 +174,18 @@ pub(crate) enum ExtraBehavior {
 impl ExtraBehavior {
     pub fn from_schema_or_config(
         py: Python,
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         default: Self,
     ) -> PyResult<Self> {
-        let extra_behavior = schema_or_config::<Option<&str>>(
+        let extra_behavior = schema_or_config::<Option<Bound<'_, PyString>>>(
             schema,
             config,
             intern!(py, "extra_behavior"),
             intern!(py, "extra_fields_behavior"),
         )?
         .flatten();
-        let res = match extra_behavior {
+        let res = match extra_behavior.as_ref().map(|s| s.to_str()).transpose()? {
             Some("allow") => Self::Allow,
             Some("ignore") => Self::Ignore,
             Some("forbid") => Self::Forbid,

src/build_tools.rs

@@ -1,6 +1,7 @@
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
-use pyo3::PyDowncastError;
+use pyo3::DowncastError;
+use pyo3::DowncastIntoError;
 
 use jiter::JsonValue;
 
@@ -35,8 +36,14 @@ impl From<PyErr> for ValError {
     }
 }
 
-impl From<PyDowncastError<'_>> for ValError {
-    fn from(py_downcast: PyDowncastError) -> Self {
+impl From<DowncastError<'_, '_>> for ValError {
+    fn from(py_downcast: DowncastError) -> Self {
+        Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
+    }
+}
+
+impl From<DowncastIntoError<'_>> for ValError {
+    fn from(py_downcast: DowncastIntoError) -> Self {
         Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
     }
 }

src/errors/line_error.rs

@@ -126,9 +126,9 @@ static EMPTY_TUPLE: GILOnceCell<PyObject> = GILOnceCell::new();
 impl ToPyObject for Location {
     fn to_object(&self, py: Python<'_>) -> PyObject {
         match self {
-            Self::List(loc) => PyTuple::new(py, loc.iter().rev()).to_object(py),
+            Self::List(loc) => PyTuple::new_bound(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::empty_bound(py).to_object(py))
                 .clone_ref(py),
         }
     }
@@ -193,12 +193,12 @@ impl Serialize for Location {
     }
 }
 
-impl TryFrom<Option<&PyAny>> for Location {
+impl TryFrom<Option<&Bound<'_, PyAny>>> for Location {
     type Error = PyErr;
 
     /// Only ever called by ValidationError -> PyLineError to convert user input to our internal Location
     /// Thus this expects the location to *not* be reversed and reverses it before storing it.
-    fn try_from(location: Option<&PyAny>) -> PyResult<Self> {
+    fn try_from(location: Option<&Bound<'_, PyAny>>) -> PyResult<Self> {
         if let Some(location) = location {
             let mut loc_vec: Vec<LocItem> = if let Ok(tuple) = location.downcast::<PyTuple>() {
                 tuple.iter().map(Into::into).collect()

src/errors/location.rs

@@ -13,7 +13,7 @@ pub use self::validation_exception::ValidationError;
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
 
 pub fn py_err_string(py: Python, err: PyErr) -> String {
-    let value = err.value(py);
+    let value = err.value_bound(py);
     match value.get_type().qualname() {
         Ok(type_name) => match value.str() {
             Ok(py_str) => {

src/errors/mod.rs

@@ -18,11 +18,11 @@ use crate::tools::{extract_i64, py_err, py_error_type};
 use super::PydanticCustomError;
 
 #[pyfunction]
-pub fn list_all_errors(py: Python) -> PyResult<&PyList> {
-    let mut errors: Vec<&PyDict> = Vec::with_capacity(100);
+pub fn list_all_errors(py: Python) -> PyResult<Bound<'_, PyList>> {
+    let mut errors: Vec<Bound<'_, PyDict>> = Vec::with_capacity(100);
     for error_type in ErrorType::iter() {
         if !matches!(error_type, ErrorType::CustomError { .. }) {
-            let d = PyDict::new(py);
+            let d = PyDict::new_bound(py);
             d.set_item("type", error_type.to_string())?;
             let message_template_python = error_type.message_template_python();
             d.set_item("message_template_python", message_template_python)?;
@@ -39,7 +39,7 @@ pub fn list_all_errors(py: Python) -> PyResult<&PyList> {
             errors.push(d);
         }
     }
-    Ok(PyList::new(py, errors))
+    Ok(PyList::new_bound(py, errors))
 }
 
 fn field_from_context<'py, T: FromPyObject<'py>>(
@@ -121,15 +121,16 @@ macro_rules! error_types {
                 }
             }
 
-            fn py_dict_update_ctx(&self, py: Python, dict: &PyDict) -> PyResult<bool> {
+            fn py_dict_update_ctx(&self, py: Python, dict: &Bound<'_, PyDict>) -> PyResult<bool> {
+                use pyo3::types::PyMapping;
                 match self {
                     $(
                         Self::$item { context, $($key,)* } => {
                             $(
                                 dict.set_item::<&str, Py<PyAny>>(stringify!($key), $key.to_object(py))?;
                             )*
                             if let Some(ctx) = context {
-                                dict.update(ctx.as_ref(py).downcast()?)?;
+                                dict.update(ctx.bind(py).downcast::<PyMapping>()?)?;
                                 Ok(true)
                             } else {
                                 Ok(false)
@@ -669,20 +670,20 @@ impl ErrorType {
             Self::ValueError { error, .. } => {
                 let error = &error
                     .as_ref()
-                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.as_ref(py).to_string()));
+                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.bind(py).to_string()));
                 render!(tmpl, error)
             }
             Self::AssertionError { error, .. } => {
                 let error = &error
                     .as_ref()
-                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.as_ref(py).to_string()));
+                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.bind(py).to_string()));
                 render!(tmpl, error)
             }
             Self::CustomError {
                 message_template,
                 context,
                 ..
-            } => PydanticCustomError::format_message(message_template, context.as_ref().map(|c| c.as_ref(py))),
+            } => PydanticCustomError::format_message(message_template, context.as_ref().map(|c| c.bind(py))),
             Self::LiteralError { expected, .. } => render!(tmpl, expected),
             Self::DateParsing { error, .. } => render!(tmpl, error),
             Self::DateFromDatetimeParsing { error, .. } => render!(tmpl, error),
@@ -729,8 +730,8 @@ impl ErrorType {
     }
 
     pub fn py_dict(&self, py: Python) -> PyResult<Option<Py<PyDict>>> {
-        let dict = PyDict::new(py);
-        let custom_ctx_used = self.py_dict_update_ctx(py, dict)?;
+        let dict = PyDict::new_bound(py);
+        let custom_ctx_used = self.py_dict_update_ctx(py, &dict)?;
 
         if let Self::CustomError { .. } = self {
             if custom_ctx_used {
@@ -785,7 +786,7 @@ impl From<Int> for Number {
 }
 
 impl FromPyObject<'_> for Number {
-    fn extract(obj: &PyAny) -> PyResult<Self> {
+    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
         if let Some(int) = extract_i64(obj) {
             Ok(Number::Int(int))
         } else if let Ok(float) = obj.extract::<f64>() {

src/errors/types.rs

@@ -73,7 +73,7 @@ impl ValidationError {
                                 return cause_problem;
                             }
                         }
-                        PyErr::from_value(err.as_ref(py))
+                        PyErr::from_value_bound(err.into_bound(py).into_any())
                     }
                     Err(err) => err,
                 }
@@ -202,9 +202,9 @@ fn include_url_env(py: Python) -> bool {
         match std::env::var_os("PYDANTIC_ERRORS_OMIT_URL") {
             Some(val) => {
                 // We don't care whether warning succeeded or not, hence the assignment
-                let _ = PyErr::warn(
+                let _ = PyErr::warn_bound(
                     py,
-                    py.get_type::<pyo3::exceptions::PyDeprecationWarning>(),
+                    &py.get_type_bound::<pyo3::exceptions::PyDeprecationWarning>(),
                     "PYDANTIC_ERRORS_OMIT_URL is deprecated, use PYDANTIC_ERRORS_INCLUDE_URL instead",
                     1,
                 );
@@ -253,14 +253,17 @@ impl ValidationError {
     fn from_exception_data(
         py: Python,
         title: PyObject,
-        line_errors: &PyList,
+        line_errors: Bound<'_, PyList>,
         input_type: &str,
         hide_input: bool,
     ) -> PyResult<Py<Self>> {
         Py::new(
             py,
             Self {
-                line_errors: line_errors.iter().map(PyLineError::try_from).collect::<PyResult<_>>()?,
+                line_errors: line_errors
+                    .iter()
+                    .map(|error| PyLineError::try_from(&error))
+                    .collect::<PyResult<_>>()?,
                 title,
                 input_type: InputType::try_from(input_type)?,
                 hide_input,
@@ -287,7 +290,7 @@ impl ValidationError {
     ) -> PyResult<Py<PyList>> {
         let url_prefix = get_url_prefix(py, include_url);
         let mut iteration_error = None;
-        let list = PyList::new(
+        let list = PyList::new_bound(
             py,
             // PyList::new takes ExactSizeIterator, so if an error occurs during iteration we
             // fill the list with None before returning the error; the list will then be thrown
@@ -318,7 +321,7 @@ impl ValidationError {
         include_url: bool,
         include_context: bool,
         include_input: bool,
-    ) -> PyResult<&'py PyString> {
+    ) -> PyResult<Bound<'py, PyString>> {
         let state = SerializationState::new("iso8601", "utf8", "constants")?;
         let extra = state.extra(py, &SerMode::Json, true, false, false, true, None, None);
         let serializer = ValidationErrorSerializer {
@@ -347,7 +350,7 @@ impl ValidationError {
             }
         };
         let s = from_utf8(&bytes).map_err(json_py_err)?;
-        Ok(PyString::new(py, s))
+        Ok(PyString::new_bound(py, s))
     }
 
     fn __repr__(&self, py: Python) -> String {
@@ -358,12 +361,12 @@ impl ValidationError {
         self.__repr__(py)
     }
 
-    fn __reduce__(slf: &PyCell<Self>) -> PyResult<(&PyAny, PyObject)> {
+    fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyAny>, PyObject)> {
         let py = slf.py();
         let callable = slf.getattr("from_exception_data")?;
         let borrow = slf.try_borrow()?;
         let args = (
-            borrow.title.as_ref(py),
+            borrow.title.bind(py),
             borrow.errors(py, include_url_env(py), true, true)?,
             borrow.input_type.into_py(py),
             borrow.hide_input,
@@ -463,11 +466,11 @@ impl From<PyLineError> for ValLineError {
     }
 }
 
-impl TryFrom<&PyAny> for PyLineError {
+impl TryFrom<&Bound<'_, PyAny>> for PyLineError {
     type Error = PyErr;
 
-    fn try_from(value: &PyAny) -> PyResult<Self> {
-        let dict: &PyDict = value.downcast()?;
+    fn try_from(value: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let dict = value.downcast::<PyDict>()?;
         let py = value.py();
 
         let type_raw = dict
@@ -485,7 +488,7 @@ impl TryFrom<&PyAny> for PyLineError {
             ));
         };
 
-        let location = Location::try_from(dict.get_item("loc")?)?;
+        let location = Location::try_from(dict.get_item("loc")?.as_ref())?;
 
         let input_value = match dict.get_item("input")? {
             Some(i) => i.into_py(py),
@@ -513,7 +516,7 @@ impl PyLineError {
         input_type: InputType,
         include_input: bool,
     ) -> PyResult<PyObject> {
-        let dict = PyDict::new(py);
+        let dict = PyDict::new_bound(py);
         dict.set_item("type", self.error_type.type_string())?;
         dict.set_item("loc", self.location.to_object(py))?;
         dict.set_item("msg", self.error_type.render_message(py, input_type)?)?;
@@ -555,9 +558,9 @@ impl PyLineError {
         write!(output, "  {message} [type={}", self.error_type.type_string())?;
 
         if !hide_input {
-            let input_value = self.input_value.as_ref(py);
+            let input_value = self.input_value.bind(py);
             let input_str = safe_repr(input_value);
-            truncate_input_value!(output, &input_str);
+            truncate_input_value!(output, &input_str.to_cow());
 
             if let Ok(type_) = input_value.get_type().qualname() {
                 write!(output, ", input_type={type_}")?;
@@ -663,13 +666,13 @@ impl<'py> Serialize for PyLineErrorSerializer<'py> {
         if self.include_input {
             map.serialize_entry(
                 "input",
-                &self.extra.serialize_infer(self.line_error.input_value.as_ref(py)),
+                &self.extra.serialize_infer(self.line_error.input_value.bind(py)),
             )?;
         }
 
         if self.include_context {
             if let Some(context) = self.line_error.error_type.py_dict(py).map_err(py_err_json::<S>)? {
-                map.serialize_entry("ctx", &self.extra.serialize_infer(context.as_ref(py)))?;
+                map.serialize_entry("ctx", &self.extra.serialize_infer(context.bind(py)))?;
             }
         }
         if let Some(url_prefix) = self.url_prefix {