resolve deprecations

Author: davidhewitt

Cargo.lock

@@ -27,7 +27,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.26", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.27", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.11.1"
 strum = { version = "0.27", features = ["derive"] }
 strum_macros = "0.27"
@@ -68,12 +68,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.26", features = ["auto-initialize"] }
+pyo3 = { version = "0.27", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.26" }
+pyo3-build-config = { version = "0.27" }
 
 [lints.clippy]
 dbg_macro = "warn"
@@ -107,6 +107,6 @@ unused_self = "allow"
 used_underscore_binding = "allow"
 
 [patch.crates-io]
-pyo3 = { git = "https://github.com/pyo3/pyo3.git" }
-pyo3-build-config = { git = "https://github.com/pyo3/pyo3.git" }
+pyo3 = { git = "https://github.com/pyo3/pyo3.git", branch = "release-0.27.0" }
+pyo3-build-config = { git = "https://github.com/pyo3/pyo3.git", branch = "release-0.27.0" }
 jiter = { git = "https://github.com/pydantic/jiter.git", branch = "dh/pyo3-0.27" }

Cargo.toml

@@ -2,8 +2,8 @@ use std::convert::Infallible;
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
-use pyo3::DowncastError;
-use pyo3::DowncastIntoError;
+use pyo3::CastError;
+use pyo3::CastIntoError;
 
 use jiter::JsonValue;
 
@@ -45,15 +45,15 @@ impl From<PyErr> for ValError {
     }
 }
 
-impl From<DowncastError<'_, '_>> for ValError {
-    fn from(py_downcast: DowncastError) -> Self {
-        Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
+impl From<CastError<'_, '_>> for ValError {
+    fn from(py_cast: CastError) -> Self {
+        Self::InternalErr(PyTypeError::new_err(py_cast.to_string()))
     }
 }
 
-impl From<DowncastIntoError<'_>> for ValError {
-    fn from(py_downcast: DowncastIntoError) -> Self {
-        Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
+impl From<CastIntoError<'_>> for ValError {
+    fn from(py_cast: CastIntoError) -> Self {
+        Self::InternalErr(PyTypeError::new_err(py_cast.to_string()))
     }
 }
 

src/errors/line_error.rs

@@ -176,9 +176,9 @@ impl TryFrom<Option<&Bound<'_, PyAny>>> for Location {
     /// Thus this expects the location to *not* be reversed and reverses it before storing it.
     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>() {
+            let mut loc_vec: Vec<LocItem> = if let Ok(tuple) = location.cast::<PyTuple>() {
                 tuple.iter().map(Into::into).collect()
-            } else if let Ok(list) = location.downcast::<PyList>() {
+            } else if let Ok(list) = location.cast::<PyList>() {
                 list.iter().map(Into::into).collect()
             } else {
                 return Err(PyTypeError::new_err(

src/errors/location.rs

@@ -127,7 +127,7 @@ macro_rules! error_types {
                                 dict.set_item(stringify!($key), $key)?;
                             )*
                             if let Some(ctx) = context {
-                                dict.update(ctx.bind(py).downcast::<PyMapping>()?)?;
+                                dict.update(ctx.bind(py).cast::<PyMapping>()?)?;
                                 Ok(true)
                             } else {
                                 Ok(false)

src/errors/types.rs

@@ -433,14 +433,14 @@ impl TryFrom<&Bound<'_, PyAny>> for PyLineError {
     type Error = PyErr;
 
     fn try_from(value: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let dict = value.downcast::<PyDict>()?;
+        let dict = value.cast::<PyDict>()?;
         let py = value.py();
 
         let type_raw = dict
             .get_item(intern!(py, "type"))?
             .ok_or_else(|| PyKeyError::new_err("type"))?;
 
-        let error_type = if let Ok(type_str) = type_raw.downcast::<PyString>() {
+        let error_type = if let Ok(type_str) = type_raw.cast::<PyString>() {
             let context: Option<Bound<'_, PyDict>> = dict.get_as(intern!(py, "ctx"))?;
             ErrorType::new(py, type_str.to_str()?, context)?
         } else if let Ok(custom_error) = type_raw.extract::<PydanticCustomError>() {

src/errors/validation_exception.rs

@@ -120,8 +120,8 @@ impl PydanticCustomError {
         let mut message = message_template.to_string();
         if let Some(ctx) = context {
             for (key, value) in ctx.iter() {
-                let key = key.downcast::<PyString>()?;
-                if let Ok(py_str) = value.downcast::<PyString>() {
+                let key = key.cast::<PyString>()?;
+                if let Ok(py_str) = value.cast::<PyString>() {
                     message = message.replace(&format!("{{{}}}", key.to_str()?), py_str.to_str()?);
                 } else if let Some(value_int) = extract_i64(&value) {
                     message = message.replace(&format!("{{{}}}", key.to_str()?), &value_int.to_string());

src/errors/value_exception.rs

@@ -226,10 +226,10 @@ impl<'py> TryFrom<&'_ Bound<'py, PyAny>> for EitherTimedelta<'py> {
     type Error = PyErr;
 
     fn try_from(value: &Bound<'py, PyAny>) -> PyResult<Self> {
-        if let Ok(dt) = value.downcast_exact() {
+        if let Ok(dt) = value.cast_exact() {
             Ok(EitherTimedelta::PyExact(dt.clone()))
         } else {
-            let dt = value.downcast()?;
+            let dt = value.cast()?;
             Ok(EitherTimedelta::PySubclass(dt.clone()))
         }
     }
@@ -344,7 +344,7 @@ fn time_as_tzinfo<'py>(py: Python<'py>, time: &Time) -> PyResult<Option<Bound<'p
     match time.tz_offset {
         Some(offset) => {
             let tz_info: TzInfo = offset.try_into()?;
-            Ok(Some(Bound::new(py, tz_info)?.into_any().downcast_into()?))
+            Ok(Some(Bound::new(py, tz_info)?.into_any().cast_into()?))
         }
         None => Ok(None),
     }