Update to PyO3 0.21.

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.20", default-features = false, features = ["auto-initialize"] }
+pyo3 = { version = "0.21", 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.20"
+pyo3 = "0.21"

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.20", default-features = false, features = ["auto-initialize"] }
+pyo3 = { version = "0.21", default-features = false, features = ["auto-initialize"] }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.71"

macros/src/error.rs

@@ -1,18 +1,18 @@
 use proc_macro::Span;
 use proc_macro2::TokenStream;
-use pyo3::{PyAny, PyErr, PyResult, PyTypeInfo, Python, ToPyObject};
+use pyo3::{prelude::*, types::PyTraceback, Bound, PyErr, PyResult, PyTypeInfo, Python, ToPyObject};
 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);
 
 	if value.is_none(py) {
-		let error = format!("python: {}", error.get_type(py).name().unwrap());
+		let error = format!("python: {}", error.get_type_bound(py).name().unwrap());
 		return quote!(compile_error! {#error});
 	}
 
-	if error.matches(py, pyo3::exceptions::PySyntaxError::type_object(py)) {
+	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 (Some(line), Some(msg)) = (line, msg) {
@@ -23,10 +23,10 @@ pub fn compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) -> Token
 		}
 	}
 
-	if let Some(tb) = &error.traceback(py) {
+	if let Some(tb) = &error.traceback_bound(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.as_ref(py).str() {
+				if let Ok(msg) = value.bind(py).str() {
 					if let Some(span) = span_for_line(tokens, line) {
 						let error = format!("python: {}", msg);
 						return quote_spanned!(span.into() => compile_error!{#error});
@@ -36,11 +36,11 @@ pub fn compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) -> Token
 		}
 	}
 
-	let error = format!("python: {}", value.as_ref(py).str().unwrap());
+	let error = format!("python: {}", value.bind(py).str().unwrap());
 	quote!(compile_error! {#error})
 }
 
-fn get_traceback_info(tb: &PyAny) -> PyResult<(String, usize)> {
+fn get_traceback_info(tb: &Bound<'_, PyTraceback>) -> PyResult<(String, usize)> {
 	let frame = tb.getattr("tb_frame")?;
 	let code = frame.getattr("f_code")?;
 	let file: String = code.getattr("co_filename")?.extract()?;

macros/src/lib.rs

@@ -7,7 +7,7 @@ extern crate proc_macro;
 use self::embed_python::EmbedPython;
 use proc_macro::{Span, TokenStream as TokenStream1};
 use proc_macro2::{Literal, TokenStream};
-use pyo3::{ffi, types::PyBytes, FromPyPointer, PyObject, Python};
+use pyo3::{ffi, Py, PyObject, Python};
 use quote::quote;
 use std::ffi::CString;
 
@@ -37,9 +37,9 @@ fn python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 				.map_err(|err| error::compile_error_msg(py, err, tokens))?;
 
 			Ok(Literal::byte_string(
-				PyBytes::from_owned_ptr_or_err(py, ffi::PyMarshal_WriteObjectToString(code.as_ptr(), pyo3::marshal::VERSION))
+				Py::from_owned_ptr_or_err(py, ffi::PyMarshal_WriteObjectToString(code.as_ptr(), pyo3::marshal::VERSION))
 					.map_err(|_e| quote!(compile_error! {"failed to generate python bytecode"}))?
-					.as_bytes(),
+					.as_bytes(py),
 			))
 		});
 		result?
@@ -53,9 +53,11 @@ fn python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 			#bytecode,
 			|globals| {
 				#(
-					globals
-						.set_item(#varname, #var)
-						.expect("Unable to convert variable to Python");
+					::inline_python::pyo3::prelude::PyDictMethods::set_item(
+						globals,
+						#varname,
+						#var
+					).expect("Unable to convert variable to Python");
 				)*
 			},
 		)

macros/src/run.rs

@@ -1,6 +1,6 @@
 use crate::error::compile_error_msg;
 use proc_macro2::TokenStream;
-use pyo3::{ffi, PyObject, PyResult, Python};
+use pyo3::{ffi, prelude::*, PyObject, PyResult, Python};
 use std::str::FromStr;
 
 #[cfg(unix)]
@@ -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("sysconfig")?;
+	let sysconfig = py.import_bound("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,14 +28,14 @@ fn run_and_capture(py: Python, code: PyObject) -> PyResult<String> {
 	#[cfg(unix)]
 	let _ = ensure_libpython_symbols_loaded(py);
 
-	let globals = py.import("__main__")?.dict().copy()?;
+	let globals = py.import_bound("__main__")?.dict().copy()?;
 
-	let sys = py.import("sys")?;
-	let io = py.import("io")?;
+	let sys = py.import_bound("sys")?;
+	let io = py.import_bound("io")?;
 
 	let stdout = io.getattr("StringIO")?.call0()?;
 	let original_stdout = sys.dict().get_item("stdout")?;
-	sys.dict().set_item("stdout", stdout)?;
+	sys.dict().set_item("stdout", &stdout)?;
 
 	let result =
 		unsafe { PyObject::from_owned_ptr_or_err(py, ffi::PyEval_EvalCode(code.as_ptr(), globals.as_ptr(), std::ptr::null_mut())) };

src/context.rs

@@ -1,6 +1,7 @@
 use crate::run::run_python_code;
 use crate::PythonBlock;
 use pyo3::{
+	prelude::*,
 	types::{PyCFunction, PyDict},
 	FromPyObject, Py, PyResult, Python, ToPyObject,
 };
@@ -70,13 +71,13 @@ impl Context {
 
 	fn try_new(py: Python) -> PyResult<Self> {
 		Ok(Self {
-			globals: py.import("__main__")?.dict().copy()?.into(),
+			globals: py.import_bound("__main__")?.dict().copy()?.into(),
 		})
 	}
 
 	/// Get the globals as dictionary.
-	pub fn globals<'p>(&'p self, py: Python<'p>) -> &'p PyDict {
-		self.globals.as_ref(py)
+	pub fn globals<'p>(&'p self, py: Python<'p>) -> &'p Bound<'p, PyDict> {
+		self.globals.bind(py)
 	}
 
 	/// Retrieve a global variable from the context.
@@ -95,7 +96,7 @@ impl Context {
 	pub fn get_with_gil<'p, T: FromPyObject<'p>>(&'p self, py: Python<'p>, name: &str) -> T {
 		match self.globals(py).get_item(name) {
 			Err(_) | Ok(None) => panic!("Python context does not contain a variable named `{}`", name),
-			Ok(Some(value)) => match FromPyObject::extract(value) {
+			Ok(Some(value)) => match FromPyObject::extract_bound(&value) {
 				Ok(value) => value,
 				Err(e) => {
 					e.print(py);
@@ -184,7 +185,7 @@ impl Context {
 	/// If you already have the GIL, you can use [`Context::run_with_gil`] instead.
 	///
 	/// This function panics if the Python code fails.
-	pub fn run<F: FnOnce(&PyDict)>(&self, code: PythonBlock<F>) {
+	pub fn run<F: FnOnce(&Bound<PyDict>)>(&self, code: PythonBlock<F>) {
 		Python::with_gil(|py| self.run_with_gil(py, code));
 	}
 
@@ -194,7 +195,7 @@ impl Context {
 	/// [`Context::run`].
 	///
 	/// This function panics if the Python code fails.
-	pub fn run_with_gil<F: FnOnce(&PyDict)>(&self, py: Python<'_>, code: PythonBlock<F>) {
+	pub fn run_with_gil<F: FnOnce(&Bound<PyDict>)>(&self, py: Python<'_>, code: PythonBlock<F>) {
 		(code.set_variables)(self.globals(py));
 		match run_python_code(py, self, code.bytecode) {
 			Ok(_) => (),

src/lib.rs

@@ -111,7 +111,7 @@
 //!
 //! Everything else should work fine.
 
-use pyo3::{types::PyDict, Python};
+use pyo3::{types::PyDict, Bound, Python};
 
 mod context;
 mod run;
@@ -138,21 +138,21 @@ pub use pyo3;
 pub use inline_python_macros::python;
 
 #[doc(hidden)]
-pub trait FromInlinePython<F: FnOnce(&PyDict)> {
+pub trait FromInlinePython<F: FnOnce(&Bound<PyDict>)> {
 	fn from_python_macro(bytecode: &'static [u8], set_variables: F) -> Self;
 }
 
 /// Converting a `python!{}` block to `()` will run the Python code.
 ///
 /// This happens when `python!{}` is used as a statement by itself.
-impl<F: FnOnce(&PyDict)> FromInlinePython<F> for () {
+impl<F: FnOnce(&Bound<PyDict>)> FromInlinePython<F> for () {
 	fn from_python_macro(bytecode: &'static [u8], set_variables: F) {
 		let _: Context = FromInlinePython::from_python_macro(bytecode, set_variables);
 	}
 }
 
 /// Assigning a `python!{}` block to a `Context` will run the Python code and capture the resulting context.
-impl<F: FnOnce(&PyDict)> FromInlinePython<F> for Context {
+impl<F: FnOnce(&Bound<PyDict>)> FromInlinePython<F> for Context {
 	fn from_python_macro(bytecode: &'static [u8], set_variables: F) -> Self {
 		Python::with_gil(|py| {
 			let context = Context::new_with_gil(py);
@@ -163,7 +163,7 @@ impl<F: FnOnce(&PyDict)> FromInlinePython<F> for Context {
 }
 
 /// Using a `python!{}` block as a `PythonBlock` object will not do anything yet.
-impl<F: FnOnce(&PyDict)> FromInlinePython<F> for PythonBlock<F> {
+impl<F: FnOnce(&Bound<PyDict>)> FromInlinePython<F> for PythonBlock<F> {
 	fn from_python_macro(bytecode: &'static [u8], set_variables: F) -> Self {
 		Self { bytecode, set_variables }
 	}