From 48c3bb5b4a2dc69fed84e6c94becc3af4e52f733 Mon Sep 17 00:00:00 2001 From: Shar-jeel-Sajid Date: Tue, 11 Mar 2025 16:57:20 +0500 Subject: [PATCH] Removing Deprecation --- apis/python/operator/src/lib.rs | 7 ++++-- binaries/runtime/src/operator/python.rs | 23 +++++++++++-------- .../extensions/ros2-bridge/python/src/lib.rs | 6 ++--- .../ros2-bridge/python/src/typed/mod.rs | 21 ++++++++++------- 4 files changed, 34 insertions(+), 23 deletions(-) diff --git a/apis/python/operator/src/lib.rs b/apis/python/operator/src/lib.rs index 84212799..e73b625b 100644 --- a/apis/python/operator/src/lib.rs +++ b/apis/python/operator/src/lib.rs @@ -110,7 +110,10 @@ impl PyEvent { pydict.insert("_cleanup", cleanup.into_py(py)); } - Ok(pydict.into_py_dict_bound(py).unbind()) + Ok(pydict + .into_py_dict(py) + .context("Failed to create py_dict")? + .unbind()) } fn ty(event: &Event) -> &str { @@ -218,7 +221,7 @@ pub fn metadata_to_pydict<'a>( metadata: &'a Metadata, py: Python<'a>, ) -> Result> { - let dict = PyDict::new_bound(py); + let dict = PyDict::new(py); for (k, v) in metadata.parameters.iter() { match v { Parameter::Bool(bool) => dict diff --git a/binaries/runtime/src/operator/python.rs b/binaries/runtime/src/operator/python.rs index fd5e0b66..93e918bd 100644 --- a/binaries/runtime/src/operator/python.rs +++ b/binaries/runtime/src/operator/python.rs @@ -10,6 +10,7 @@ use dora_node_api::{merged::MergedEvent, Event, Parameter}; use dora_operator_api_python::PyEvent; use dora_operator_api_types::DoraStatus; use eyre::{bail, eyre, Context, Result}; +use pyo3::ffi::c_str; use pyo3::{ pyclass, types::{IntoPyDict, PyAnyMethods, PyDict, PyDictMethods, PyTracebackMethods}, @@ -75,9 +76,7 @@ pub fn run( let parent_path = parent_path .to_str() .ok_or_else(|| eyre!("module path is not valid utf8"))?; - let sys = py - .import_bound("sys") - .wrap_err("failed to import `sys` module")?; + let sys = py.import("sys").wrap_err("failed to import `sys` module")?; let sys_path = sys .getattr("path") .wrap_err("failed to import `sys.path` module")?; @@ -89,14 +88,16 @@ pub fn run( .wrap_err("failed to append module path to python search path")?; } - let module = py.import_bound(module_name).map_err(traceback)?; + let module = py.import(module_name).map_err(traceback)?; let operator_class = module .getattr("Operator") .wrap_err("no `Operator` class found in module")?; - let locals = [("Operator", operator_class)].into_py_dict_bound(py); + let locals = [("Operator", operator_class)] + .into_py_dict(py) + .context("Failed to create py_dict")?; let operator = py - .eval_bound("Operator()", None, Some(&locals)) + .eval(c_str!("Operator()"), None, Some(&locals)) .map_err(traceback)?; operator.setattr( "dataflow_descriptor", @@ -141,11 +142,11 @@ pub fn run( })?; // Reload module let module = py - .import_bound(module_name) + .import(module_name) .map_err(traceback) .wrap_err(format!("Could not retrieve {module_name} while reloading"))?; let importlib = py - .import_bound("importlib") + .import("importlib") .wrap_err("failed to import `importlib` module")?; let module = importlib .call_method("reload", (module,), None) @@ -155,9 +156,11 @@ pub fn run( .wrap_err("no `Operator` class found in module")?; // Create a new reloaded operator - let locals = [("Operator", reloaded_operator_class)].into_py_dict_bound(py); + let locals = [("Operator", reloaded_operator_class)] + .into_py_dict(py) + .context("Failed to create py_dict")?; let operator: Py = py - .eval_bound("Operator()", None, Some(&locals)) + .eval(c_str!("Operator()"), None, Some(&locals)) .map_err(traceback) .wrap_err("Could not initialize reloaded operator")? .into(); diff --git a/libraries/extensions/ros2-bridge/python/src/lib.rs b/libraries/extensions/ros2-bridge/python/src/lib.rs index b767ab78..a8c206b9 100644 --- a/libraries/extensions/ros2-bridge/python/src/lib.rs +++ b/libraries/extensions/ros2-bridge/python/src/lib.rs @@ -60,7 +60,7 @@ impl Ros2Context { pub fn new(ros_paths: Option>) -> eyre::Result { Python::with_gil(|py| -> Result<()> { let warnings = py - .import_bound("warnings") + .import("warnings") .wrap_err("failed to import `warnings` module")?; warnings .call_method1("warn", ("dora-rs ROS2 Bridge is unstable and may change at any point without it being considered a breaking change",)) @@ -333,7 +333,7 @@ impl Ros2Publisher { /// :rtype: None /// pub fn publish(&self, data: Bound<'_, PyAny>) -> eyre::Result<()> { - let pyarrow = PyModule::import_bound(data.py(), "pyarrow")?; + let pyarrow = PyModule::import(data.py(), "pyarrow")?; let data = if data.is_instance_of::() { // convert to arrow struct scalar @@ -344,7 +344,7 @@ impl Ros2Publisher { let data = if data.is_instance(&pyarrow.getattr("StructScalar")?)? { // convert to arrow array - let list = PyList::new_bound(data.py(), [data]); + let list = PyList::new(data.py(), [data]).context("Failed to create Py::List")?; pyarrow.getattr("array")?.call1((list,))? } else { data diff --git a/libraries/extensions/ros2-bridge/python/src/typed/mod.rs b/libraries/extensions/ros2-bridge/python/src/typed/mod.rs index e3b4133d..7f05aa72 100644 --- a/libraries/extensions/ros2-bridge/python/src/typed/mod.rs +++ b/libraries/extensions/ros2-bridge/python/src/typed/mod.rs @@ -37,6 +37,7 @@ mod tests { use arrow::pyarrow::ToPyArrow; use eyre::eyre; + use pyo3::ffi::c_str; use pyo3::types::IntoPyDict; use pyo3::types::PyAnyMethods; use pyo3::types::PyDict; @@ -65,13 +66,17 @@ mod tests { let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")); //.join("test_utils.py"); // Adjust this path as needed // Add the Python module's directory to sys.path - py.run_bound( - "import sys; sys.path.append(str(path))", - Some(&[("path", path)].into_py_dict_bound(py)), + py.run( + c_str!("import sys; sys.path.append(str(path))"), + Some( + &[("path", path)] + .into_py_dict(py) + .context("Failed to create py_dict")?, + ), None, )?; - let my_module = PyModule::import_bound(py, "test_utils")?; + let my_module = PyModule::import(py, "test_utils")?; let arrays = my_module.getattr("TEST_ARRAYS")?; let arrays = arrays @@ -108,16 +113,16 @@ mod tests { let out_pyarrow = out_value.to_pyarrow(py)?; - let test_utils = PyModule::import_bound(py, "test_utils")?; - let context = PyDict::new_bound(py); + let test_utils = PyModule::import(py, "test_utils")?; + let context = PyDict::new(py); context.set_item("test_utils", test_utils)?; context.set_item("in_pyarrow", in_pyarrow)?; context.set_item("out_pyarrow", out_pyarrow)?; let _ = py - .eval_bound( - "test_utils.is_subset(in_pyarrow, out_pyarrow)", + .eval( + c_str!("test_utils.is_subset(in_pyarrow, out_pyarrow)"), Some(&context), None, )