update to PyO3 0.21 beta

Author: davidhewitt

Cargo.lock

@@ -27,7 +27,7 @@ include = [
 rust-version = "1.70"
 
 [dependencies]
-pyo3 = { version = "0.20.3", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.21.0-beta.0", features = ["generate-import-lib", "num-bigint", "gil-refs"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
@@ -44,7 +44,7 @@ base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.7.0"
-jiter = {version = "0.0.6", features = ["python"]}
+jiter = {version = "0.0.7", features = ["python"]}
 
 [lib]
 name = "_pydantic_core"
@@ -71,12 +71,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.20.3", features = ["auto-initialize"] }
+pyo3 = { version = "0.21.0-beta.0", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.20.2" }
+pyo3-build-config = { version = "0.21.0-beta.0" }
 
 [lints.clippy]
 dbg_macro = "warn"

Cargo.toml

@@ -14,8 +14,8 @@ use crate::ValidationError;
 pub fn schema_or_config<'py, T>(
     schema: &'py PyDict,
     config: Option<&'py PyDict>,
-    schema_key: &PyString,
-    config_key: &PyString,
+    schema_key: &Bound<'py, PyString>,
+    config_key: &Bound<'py, PyString>,
 ) -> PyResult<Option<T>>
 where
     T: FromPyObject<'py>,
@@ -32,7 +32,7 @@ where
 pub fn schema_or_config_same<'py, T>(
     schema: &'py PyDict,
     config: Option<&'py PyDict>,
-    key: &PyString,
+    key: &Bound<'py, PyString>,
 ) -> PyResult<Option<T>>
 where
     T: FromPyObject<'py>,

src/build_tools.rs

@@ -1,5 +1,5 @@
 use pyo3::exceptions::PyTypeError;
-use pyo3::once_cell::GILOnceCell;
+use pyo3::sync::GILOnceCell;
 use std::fmt;
 
 use pyo3::prelude::*;

src/errors/location.rs

@@ -14,7 +14,7 @@ pub use self::value_exception::{PydanticCustomError, PydanticKnownError, Pydanti
 
 pub fn py_err_string(py: Python, err: PyErr) -> String {
     let value = err.value(py);
-    match value.get_type().name() {
+    match value.get_type().qualname() {
         Ok(type_name) => match value.str() {
             Ok(py_str) => {
                 let str_cow = py_str.to_string_lossy();

src/errors/mod.rs

@@ -3,8 +3,8 @@ use std::borrow::Cow;
 use std::fmt;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError};
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyList};
 
 use ahash::AHashMap;

src/errors/types.rs

@@ -5,8 +5,8 @@ use std::str::from_utf8;
 use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
 use pyo3::ffi;
 use pyo3::intern;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyList, PyString};
 use serde::ser::{Error, SerializeMap, SerializeSeq};
 use serde::{Serialize, Serializer};
@@ -559,7 +559,7 @@ impl PyLineError {
             let input_str = safe_repr(input_value);
             truncate_input_value!(output, &input_str);
 
-            if let Ok(type_) = input_value.get_type().name() {
+            if let Ok(type_) = input_value.get_type().qualname() {
                 write!(output, ", input_type={type_}")?;
             }
         }

src/errors/validation_exception.rs

@@ -114,7 +114,7 @@ impl<'a> TryFrom<&'a PyAny> for EitherTimedelta<'a> {
     type Error = PyErr;
 
     fn try_from(value: &'a PyAny) -> PyResult<Self> {
-        if let Ok(dt) = <PyDelta as PyTryFrom>::try_from_exact(value) {
+        if let Ok(dt) = value.downcast_exact::<PyDelta>() {
             Ok(EitherTimedelta::PyExact(dt))
         } else {
             let dt = value.downcast::<PyDelta>()?;

src/input/datetime.rs

@@ -22,9 +22,9 @@ pub enum InputType {
 impl IntoPy<PyObject> for InputType {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
-            Self::Json => intern!(py, "json").into(),
-            Self::Python => intern!(py, "python").into(),
-            Self::String => intern!(py, "string").into(),
+            Self::Json => intern!(py, "json").into_py(py),
+            Self::Python => intern!(py, "python").into_py(py),
+            Self::String => intern!(py, "string").into_py(py),
         }
     }
 }

src/input/input_abstract.rs

@@ -340,7 +340,7 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
+        if let Ok(py_str) = self.downcast_exact() {
             Ok(EitherString::Py(py_str))
         } else {
             Err(ValError::new(ErrorTypeDefaults::IntType, self))
@@ -389,7 +389,7 @@ impl<'a> Input<'a> for PyAny {
 
         Err(ValError::new(
             ErrorType::IsInstanceOf {
-                class: decimal_type.name().unwrap_or("Decimal").to_string(),
+                class: decimal_type.qualname().unwrap_or_else(|_| "Decimal".to_owned()),
                 context: None,
             },
             self,
@@ -773,7 +773,7 @@ fn maybe_as_enum(v: &PyAny) -> Option<&PyAny> {
 }
 
 #[cfg(PyPy)]
-static DICT_KEYS_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_KEYS_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
 fn is_dict_keys_type(v: &PyAny) -> bool {
@@ -791,7 +791,7 @@ fn is_dict_keys_type(v: &PyAny) -> bool {
 }
 
 #[cfg(PyPy)]
-static DICT_VALUES_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_VALUES_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
 fn is_dict_values_type(v: &PyAny) -> bool {
@@ -809,7 +809,7 @@ fn is_dict_values_type(v: &PyAny) -> bool {
 }
 
 #[cfg(PyPy)]
-static DICT_ITEMS_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_ITEMS_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
 fn is_dict_items_type(v: &PyAny) -> bool {

src/input/input_python.rs

@@ -39,7 +39,12 @@ pub use validators::{validate_core_schema, PySome, SchemaValidator};
 use crate::input::Input;
 
 #[pyfunction(signature = (data, *, allow_inf_nan=true, cache_strings=true))]
-pub fn from_json(py: Python, data: &PyAny, allow_inf_nan: bool, cache_strings: bool) -> PyResult<PyObject> {
+pub fn from_json<'py>(
+    py: Python<'py>,
+    data: &PyAny,
+    allow_inf_nan: bool,
+    cache_strings: bool,
+) -> PyResult<Bound<'py, PyAny>> {
     let v_match = data
         .validate_bytes(false)
         .map_err(|_| PyTypeError::new_err("Expected bytes, bytearray or str"))?;

src/lib.rs

@@ -333,7 +333,10 @@ impl CollectWarnings {
 
     fn fallback_warning(&self, field_type: &str, value: &PyAny) {
         if self.active {
-            let type_name = value.get_type().name().unwrap_or("<unknown python object>");
+            let type_name = value
+                .get_type()
+                .qualname()
+                .unwrap_or_else(|_| "<unknown python object>".to_owned());
             self.add_warning(format!(
                 "Expected `{field_type}` but got `{type_name}` - serialized value may not be as expected"
             ));

src/serializers/extra.rs

@@ -23,7 +23,7 @@ fn map_negative_index(value: &PyAny, len: Option<usize>) -> PyResult<&PyAny> {
             .map_or_else(|_| value, |v| v)),
         None => {
             // check that it's not negative
-            let negative = value.call_method1(intern!(py, "__lt__"), (0,))?.is_true()?;
+            let negative = value.call_method1(intern!(py, "__lt__"), (0,))?.is_truthy()?;
             if negative {
                 Err(PyValueError::new_err(
                     "Negative indices cannot be used to exclude items on unsized iterables",
@@ -291,7 +291,7 @@ fn check_contains(obj: &PyAny, py_key: impl ToPyObject + Copy) -> PyResult<Optio
         Ok(contains_method) => {
             if let Ok(result) = contains_method.call1((py_key.to_object(py),)) {
                 Ok(Some(
-                    result.is_true()? || contains_method.call1((intern!(py, "__all__"),))?.is_true()?,
+                    result.is_truthy()? || contains_method.call1((intern!(py, "__all__"),))?.is_truthy()?,
                 ))
             } else {
                 Ok(None)
@@ -316,7 +316,7 @@ where
 
 /// detect both ellipsis and `True` to be compatible with pydantic V1
 fn is_ellipsis_like(v: &PyAny) -> bool {
-    v.is_ellipsis()
+    v.is(&v.py().Ellipsis())
         || match v.downcast::<PyBool>() {
             Ok(b) => b.is_true(),
             Err(_) => false,

src/serializers/filter.rs

@@ -548,7 +548,7 @@ fn unknown_type_error(value: &PyAny) -> PyErr {
 fn serialize_unknown(value: &PyAny) -> Cow<str> {
     if let Ok(s) = value.str() {
         s.to_string_lossy()
-    } else if let Ok(name) = value.get_type().name() {
+    } else if let Ok(name) = value.get_type().qualname() {
         format!("<Unserializable {name} object>").into()
     } else {
         "<Unserializable object>".into()

src/serializers/infer.rs

@@ -1,5 +1,5 @@
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
     PySet, PyString, PyTime, PyTuple, PyType,

src/serializers/ob_type.rs

@@ -2,8 +2,8 @@ use std::borrow::Cow;
 use std::fmt::Debug;
 
 use pyo3::exceptions::PyTypeError;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
 

src/serializers/shared.rs

@@ -95,9 +95,9 @@ impl FormatSerializer {
                 format!(
                     "Error calling `format(value, {})`: {}",
                     self.formatting_string
-                        .as_ref(py)
+                        .bind(py)
                         .repr()
-                        .unwrap_or_else(|_| intern!(py, "???")),
+                        .unwrap_or_else(|_| intern!(py, "???").clone()),
                     e
                 )
             })

src/serializers/type_serializers/format.rs

@@ -179,7 +179,7 @@ pub(crate) fn to_str_json_key(key: &PyAny) -> PyResult<Cow<str>> {
 build_simple_serializer!(IntSerializer, "int", Int, ObType::Int, to_str_json_key, true);
 
 pub(crate) fn bool_json_key(key: &PyAny) -> PyResult<Cow<str>> {
-    let v = if key.is_true().unwrap_or(false) {
+    let v = if key.is_truthy().unwrap_or(false) {
         "true"
     } else {
         "false"