Update to PyO3 0.23.

Author: m-ou-se

Cargo.toml

@@ -14,7 +14,7 @@ autoexamples = false
 
 [dependencies]
 inline-python-macros = { version = "=0.12.0", path = "./macros" }
-pyo3 = { version = "0.22", default-features = false, features = ["auto-initialize"] }
+pyo3 = { version = "0.23", default-features = false, features = ["auto-initialize"] }
 
 [workspace]
 members = ["examples", "ct-python"]

examples/Cargo.toml

@@ -17,4 +17,4 @@ path = "rust-fn.rs"
 
 [dependencies]
 inline-python = { path = ".." }
-pyo3 = "0.22"
+pyo3 = "0.23"

macros/Cargo.toml

@@ -16,7 +16,7 @@ proc_macro = true
 [dependencies]
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
 quote = "1.0"
-pyo3 = { version = "0.22", default-features = false, features = ["auto-initialize"] }
+pyo3 = { version = "0.23", default-features = false, features = ["auto-initialize"] }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.71"

macros/src/error.rs

@@ -1,20 +1,20 @@
 use proc_macro::Span;
 use proc_macro2::TokenStream;
-use pyo3::{prelude::*, types::PyTraceback, Bound, PyErr, PyResult, PyTypeInfo, Python, ToPyObject};
+use pyo3::{prelude::*, types::PyTraceback, Bound, PyErr, PyResult, PyTypeInfo, Python, IntoPyObject};
 use quote::{quote, quote_spanned};
 
 /// Format a nice error message for a python compilation error.
 pub fn compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) -> TokenStream {
-	let value = error.to_object(py);
+	let value = (&error).into_pyobject(py).unwrap();
 
-	if value.is_none(py) {
-		let error = format!("python: {}", error.get_type_bound(py).name().unwrap());
+	if value.is_none() {
+		let error = format!("python: {}", error.get_type(py).name().unwrap());
 		return quote!(compile_error! {#error});
 	}
 
-	if error.matches(py, pyo3::exceptions::PySyntaxError::type_object_bound(py)) {
-		let line: Option<usize> = value.getattr(py, "lineno").ok().and_then(|x| x.extract(py).ok());
-		let msg: Option<String> = value.getattr(py, "msg").ok().and_then(|x| x.extract(py).ok());
+	if let Ok(true) = error.matches(py, pyo3::exceptions::PySyntaxError::type_object(py)) {
+		let line: Option<usize> = value.getattr("lineno").ok().and_then(|x| x.extract().ok());
+		let msg: Option<String> = value.getattr("msg").ok().and_then(|x| x.extract().ok());
 		if let (Some(line), Some(msg)) = (line, msg) {
 			if let Some(span) = span_for_line(tokens.clone(), line) {
 				let error = format!("python: {}", msg);
@@ -23,10 +23,10 @@ pub fn compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) -> Token
 		}
 	}
 
-	if let Some(tb) = &error.traceback_bound(py) {
+	if let Some(tb) = &error.traceback(py) {
 		if let Ok((file, line)) = get_traceback_info(tb) {
 			if file == Span::call_site().source_file().path().to_string_lossy() {
-				if let Ok(msg) = value.bind(py).str() {
+				if let Ok(msg) = value.str() {
 					if let Some(span) = span_for_line(tokens, line) {
 						let error = format!("python: {}", msg);
 						return quote_spanned!(span.into() => compile_error!{#error});
@@ -36,7 +36,7 @@ pub fn compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) -> Token
 		}
 	}
 
-	let error = format!("python: {}", value.bind(py).str().unwrap());
+	let error = format!("python: {}", value.str().unwrap());
 	quote!(compile_error! {#error})
 }
 

macros/src/run.rs

@@ -14,7 +14,7 @@ fn ensure_libpython_symbols_loaded(py: Python) -> PyResult<()> {
 	// This function tries to (re)load the right version of libpython, but this
 	// time with RTLD_GLOBAL enabled.
 
-	let sysconfig = py.import_bound("sysconfig")?;
+	let sysconfig = py.import("sysconfig")?;
 	let libdir: String = sysconfig.getattr("get_config_var")?.call1(("LIBDIR",))?.extract()?;
 	let so_name: String = sysconfig.getattr("get_config_var")?.call1(("INSTSONAME",))?.extract()?;
 	let path = std::ffi::CString::new(format!("{}/{}", libdir, so_name)).unwrap();
@@ -28,10 +28,10 @@ fn run_and_capture(py: Python, code: PyObject) -> PyResult<String> {
 	#[cfg(unix)]
 	let _ = ensure_libpython_symbols_loaded(py);
 
-	let globals = py.import_bound("__main__")?.dict().copy()?;
+	let globals = py.import("__main__")?.dict().copy()?;
 
-	let sys = py.import_bound("sys")?;
-	let io = py.import_bound("io")?;
+	let sys = py.import("sys")?;
+	let io = py.import("io")?;
 
 	let stdout = io.getattr("StringIO")?.call0()?;
 	let original_stdout = sys.dict().get_item("stdout")?;

src/context.rs

@@ -3,7 +3,7 @@ use crate::PythonBlock;
 use pyo3::{
 	prelude::*,
 	types::{PyCFunction, PyDict},
-	FromPyObject, Py, PyResult, Python, ToPyObject,
+	FromPyObject, Py, PyResult, Python, IntoPyObject,
 };
 
 /// An execution context for Python code.
@@ -71,12 +71,12 @@ impl Context {
 
 	fn try_new(py: Python) -> PyResult<Self> {
 		Ok(Self {
-			globals: py.import_bound("__main__")?.dict().copy()?.into(),
+			globals: py.import("__main__")?.dict().copy()?.into(),
 		})
 	}
 
 	/// Get the globals as dictionary.
-	pub fn globals<'p>(&'p self, py: Python<'p>) -> &'p Bound<'p, PyDict> {
+	pub fn globals<'p>(&self, py: Python<'p>) -> &Bound<'p, PyDict> {
 		self.globals.bind(py)
 	}
 
@@ -112,14 +112,14 @@ impl Context {
 	/// If you already have the GIL, you can use [`Context::set_with_gil`] instead.
 	///
 	/// This function panics if the conversion fails.
-	pub fn set<T: ToPyObject>(&self, name: &str, value: T) {
+	pub fn set<T: for<'p> IntoPyObject<'p>>(&self, name: &str, value: T) {
 		Python::with_gil(|py| self.set_with_gil(py, name, value));
 	}
 
 	/// Set a global variable in the context.
 	///
 	/// This function panics if the conversion fails.
-	pub fn set_with_gil<'p, T: ToPyObject>(&self, py: Python<'p>, name: &str, value: T) {
+	pub fn set_with_gil<'p, T: IntoPyObject<'p>>(&self, py: Python<'p>, name: &str, value: T) {
 		match self.globals(py).set_item(name, value) {
 			Ok(()) => (),
 			Err(e) => {
@@ -165,7 +165,7 @@ impl Context {
 	pub fn add_wrapped_with_gil<'p>(&self, py: Python<'p>, wrapper: &impl Fn(Python) -> PyResult<Bound<'_, PyCFunction>>) {
 		let obj = wrapper(py).unwrap();
 		let name = obj.getattr("__name__").expect("Missing __name__");
-		self.set_with_gil(py, name.extract().unwrap(), obj)
+		self.set_with_gil(py, name.extract().unwrap(), obj);
 	}
 
 	/// Run Python code using this context.