fix "most" deprecation warnings (#275)

Summary:
X-link: facebookincubator/antlir#284

Pull Request resolved: #275

Fix most deprecation warnings introduced by `pyo3 = 0.24.2`

Reviewed By: dtolnay

Differential Revision: D76439928

fbshipit-source-id: 43b48d39bb95f880172f582dac92cc2ec0275984

Author: diliop

monarch_extension/src/client.rs

@@ -98,7 +98,7 @@ impl WorkerResponse {
     fn result(&self, py: Python<'_>) -> PyResult<PyObject> {
         if let Some(result) = &self.result {
             if result.is_err() {
-                Ok(PyNone::get_bound(py).into_py(py))
+                Ok(PyNone::get(py).into_py(py))
             } else {
                 // TODO: Use better shared error class
                 let rvalue = result
@@ -113,15 +113,15 @@ impl WorkerResponse {
                 Ok(unsafe { rvalue.try_to_object_unsafe(py)?.unbind() })
             }
         } else {
-            Ok(PyNone::get_bound(py).into_py(py))
+            Ok(PyNone::get(py).into_py(py))
         }
     }
 
     fn exception(&self, py: Python<'_>) -> PyResult<PyObject> {
         match self.result.as_ref() {
-            Some(Ok(_)) => Ok(PyNone::get_bound(py).into_py(py)),
+            Some(Ok(_)) => Ok(PyNone::get(py).into_py(py)),
             Some(Err(exc)) => Ok(PyException::exception_to_py(py, exc)?),
-            None => Ok(PyNone::get_bound(py).into_py(py)),
+            None => Ok(PyNone::get(py).into_py(py)),
         }
     }
 
@@ -145,13 +145,19 @@ pub struct PyWorldState {
 #[pymethods]
 impl PyWorldState {
     #[getter]
-    fn labels(self_: PyRef<Self>, py: Python) -> PyObject {
-        self_.inner.labels.clone().into_py_dict_bound(py).into()
+    fn labels(self_: PyRef<Self>, py: Python) -> PyResult<PyObject> {
+        Ok(self_
+            .inner
+            .labels
+            .clone()
+            .into_py_dict(py)?
+            .into_any()
+            .unbind())
     }
 
     #[getter]
     fn procs(self_: PyRef<Self>, py: Python) -> PyResult<PyObject> {
-        let proc_dict = PyDict::new_bound(py);
+        let proc_dict = PyDict::new(py);
         for (proc_id, proc_info) in self_.inner.procs.clone() {
             proc_dict.set_item(proc_id.to_string(), PyProcInfo::from(proc_info).into_py(py))?;
         }
@@ -203,23 +209,25 @@ impl PySystemSnapshotFilter {
     }
 
     #[getter]
-    fn world_labels(self_: PyRef<Self>, py: Python) -> PyObject {
-        self_
+    fn world_labels(self_: PyRef<Self>, py: Python) -> PyResult<PyObject> {
+        Ok(self_
             .inner
             .world_labels
             .clone()
-            .into_py_dict_bound(py)
-            .into()
+            .into_py_dict(py)?
+            .into_any()
+            .unbind())
     }
 
     #[getter]
-    fn proc_labels(self_: PyRef<Self>, py: Python) -> PyObject {
-        self_
+    fn proc_labels(self_: PyRef<Self>, py: Python) -> PyResult<PyObject> {
+        Ok(self_
             .inner
             .proc_labels
             .clone()
-            .into_py_dict_bound(py)
-            .into()
+            .into_py_dict(py)?
+            .into_any()
+            .unbind())
     }
 }
 
@@ -668,7 +676,7 @@ impl ClientActor {
                     action,
                 }
                 .into_py(py)),
-                Ok(None) => Ok(PyNone::get_bound(py).into_py(py)),
+                Ok(None) => Ok(PyNone::get(py).into_py(py)),
                 Err(err) => {
                     if let Some(ControllerError::Failed(controller_id, err_msg)) =
                         err.downcast_ref::<ControllerError>()
@@ -726,7 +734,7 @@ impl ClientActor {
                 .into_py(py),
             })
             .collect::<Vec<PyObject>>();
-        Ok(PyList::new_bound(py, messages))
+        PyList::new(py, messages)
     }
 
     /// Get the status of all the worlds from the system.
@@ -748,7 +756,7 @@ impl ClientActor {
                 .await
         })??;
         Python::with_gil(|py| {
-            let py_dict = PyDict::new_bound(py);
+            let py_dict = PyDict::new(py);
             for (world, status) in worlds {
                 py_dict.set_item(world.to_string(), status.to_string())?;
             }
@@ -782,7 +790,7 @@ impl ClientActor {
 
         // Convert the snapshot to a Python dictionary
         let result: PyResult<PyObject> = Python::with_gil(|py| {
-            let worlds_dict = PyDict::new_bound(py);
+            let worlds_dict = PyDict::new(py);
             for (world, status) in snapshot.worlds {
                 worlds_dict.set_item(
                     world.to_string(),

monarch_extension/src/convert.rs

@@ -46,7 +46,7 @@ struct MessageParser<'a> {
 fn create_function(obj: Bound<'_, PyAny>) -> PyResult<ResolvableFunction> {
     let cloudpickle = obj
         .py()
-        .import_bound("monarch.common.function")?
+        .import("monarch.common.function")?
         .getattr("ResolvableFromCloudpickle")?;
     if obj.is_instance(&cloudpickle)? {
         Ok(ResolvableFunction::Cloudpickle(Cloudpickle::new(
@@ -97,17 +97,17 @@ impl<'a> MessageParser<'a> {
         let tree_flatten = self
             .current
             .py()
-            .import_bound("torch.utils._pytree")?
+            .import("torch.utils._pytree")?
             .getattr("tree_flatten")?;
         let output_tuple: (Bound<'a, PyAny>, Bound<'a, PyAny>) =
             tree_flatten.call1((self.attr(name)?,))?.extract()?;
         let referenceable = self
             .current
             .py()
-            .import_bound("monarch.common.reference")?
+            .import("monarch.common.reference")?
             .getattr("Referenceable")?;
         let mut flat: Vec<Option<Ref>> = vec![];
-        for x in output_tuple.0.iter()? {
+        for x in output_tuple.0.try_iter()? {
             let v: Bound<'a, PyAny> = x?;
             if v.is_instance(&referenceable)? {
                 flat.push(Some(create_ref(v)?));
@@ -119,12 +119,10 @@ impl<'a> MessageParser<'a> {
         Ok(flat)
     }
     #[allow(non_snake_case)]
-
     fn parseRef(&self, name: &str) -> PyResult<Ref> {
         create_ref(self.attr(name)?)
     }
     #[allow(non_snake_case)]
-
     fn parseOptionalRef(&self, name: &str) -> PyResult<Option<Ref>> {
         let obj = self.attr(name)?;
         if obj.is_none() {
@@ -141,7 +139,7 @@ impl<'a> MessageParser<'a> {
     #[allow(non_snake_case)]
     fn parseRefList(&self, name: &str) -> PyResult<Vec<Ref>> {
         self.attr(name)?
-            .iter()?
+            .try_iter()?
             .map(|x| {
                 let v = x?;
                 let vr: PyResult<u64> = v.extract();
@@ -159,7 +157,6 @@ impl<'a> MessageParser<'a> {
         create_function(self.attr(name)?)
     }
     #[allow(non_snake_case)]
-
     fn parseOptionalFunction(&self, name: &str) -> PyResult<Option<ResolvableFunction>> {
         let f = self.attr(name)?;
         if f.is_none() {
@@ -179,7 +176,7 @@ impl<'a> MessageParser<'a> {
     }
     #[allow(non_snake_case)]
     fn parseWorkerMessageList(&self, name: &str) -> PyResult<Vec<WorkerMessage>> {
-        self.attr(name)?.iter()?.map(|x| convert(x?)).collect()
+        self.attr(name)?.try_iter()?.map(|x| convert(x?)).collect()
     }
     fn parse_error_reason(&self, name: &str) -> PyResult<Option<(Option<ActorId>, String)>> {
         let err = self.attr(name)?;
@@ -203,7 +200,7 @@ static CONVERT_MAP: OnceLock<HashMap<u64, FnType>> = OnceLock::new();
 
 fn create_map(py: Python) -> HashMap<u64, FnType> {
     let messages = py
-        .import_bound("monarch.common.messages")
+        .import("monarch.common.messages")
         .expect("import monarch.common.messages");
     let mut m: HashMap<u64, FnType> = HashMap::new();
     let key = |name: &str| {

monarch_extension/src/debugger.rs

@@ -62,7 +62,7 @@ pub fn get_bytes_from_write_action(
     action: DebuggerAction,
 ) -> PyResult<Bound<'_, PyBytes>> {
     if let DebuggerAction::Write { bytes } = action {
-        Ok(PyBytes::new_bound(py, &bytes))
+        Ok(PyBytes::new(py, &bytes))
     } else {
         Err(PyRuntimeError::new_err(format!(
             "Cannot extract bytes from non-write debugger action {:?}",
@@ -115,7 +115,7 @@ impl PdbActor {
             )?;
         match result {
             Ok(Some(DebuggerMessage::Action { action })) => Ok(action.into_py(py)),
-            Ok(None) => Ok(PyNone::get_bound(py).into_py(py)),
+            Ok(None) => Ok(PyNone::get(py).into_py(py)),
             Err(err) => Err(PyRuntimeError::new_err(err.to_string())),
         }
     }

monarch_extension/src/lib.rs

@@ -42,11 +42,11 @@ fn get_or_add_new_module<'py>(
         if let Some(submodule) = submodule {
             current_module = submodule.extract()?;
         } else {
-            let new_module = PyModule::new_bound(current_module.py(), part)?;
+            let new_module = PyModule::new(current_module.py(), part)?;
             current_module.add_submodule(&new_module)?;
             current_module
                 .py()
-                .import_bound("sys")?
+                .import("sys")?
                 .getattr("modules")?
                 .set_item(
                     format!("monarch._rust_bindings.{}", parts.join(".")),

monarch_extension/src/mesh_controller.rs

@@ -187,10 +187,10 @@ impl _Controller {
     ) -> PyResult<()> {
         let failures = self.history.add_invocation(
             seq.into(),
-            uses.iter()?
+            uses.try_iter()?
                 .map(|x| Ref::from_py_object(&x?))
                 .collect::<PyResult<Vec<Ref>>>()?,
-            defs.iter()?
+            defs.try_iter()?
                 .map(|x| Ref::from_py_object(&x?))
                 .collect::<PyResult<Vec<Ref>>>()?,
         );

monarch_extension/src/tensor_worker.rs

@@ -1265,7 +1265,7 @@ fn wire_values_to_args(py: Python<'_>, args: Vec<WireValue>) -> PyResult<PyObjec
             }
         })
         .collect::<Result<Vec<_>, PyErr>>()?;
-    Ok(PyTuple::new_bound(py, py_ags).to_object(py))
+    Ok(PyTuple::new(py, py_ags)?.into())
 }
 
 fn wire_values_to_kwargs(py: Python<'_>, kwargs: HashMap<String, WireValue>) -> PyResult<PyObject> {
@@ -1378,7 +1378,7 @@ pub(crate) fn worker_message_to_py(py: Python<'_>, message: &WorkerMessage) -> P
 /// during packaging.
 #[pyfunction]
 fn worker_main(py: Python<'_>) -> PyResult<()> {
-    let argv: Vec<String> = py.import_bound("sys")?.getattr("argv")?.extract()?;
+    let argv: Vec<String> = py.import("sys")?.getattr("argv")?.extract()?;
     Python::allow_threads(py, move || {
         let args = BinaryArgs::parse_from(argv);
 

monarch_hyperactor/src/actor.rs

@@ -86,7 +86,7 @@ impl PickledMessage {
 
     #[getter]
     fn message<'a>(&self, py: Python<'a>) -> Bound<'a, PyBytes> {
-        PyBytes::new_bound(py, self.message.as_ref())
+        PyBytes::new(py, self.message.as_ref())
     }
 
     fn serialize(&self) -> PyResult<PySerialized> {
@@ -144,7 +144,7 @@ impl PickledMessageClientActor {
             .into_iter()
             .map(|message| message.into_py(py))
             .collect::<Vec<PyObject>>();
-        Ok(PyList::new_bound(py, messages))
+        PyList::new(py, messages)
     }
 
     fn world_status<'py>(&mut self, py: Python<'py>) -> PyResult<PyObject> {
@@ -154,7 +154,7 @@ impl PickledMessageClientActor {
             instance.lock().await.world_status(Default::default()).await
         })??;
         Python::with_gil(|py| {
-            let py_dict = PyDict::new_bound(py);
+            let py_dict = PyDict::new(py);
             for (world, status) in worlds {
                 py_dict.set_item(world.to_string(), status.to_string())?;
             }
@@ -234,7 +234,7 @@ impl PythonMessage {
 
     #[getter]
     fn message<'a>(&self, py: Python<'a>) -> Bound<'a, PyBytes> {
-        PyBytes::new_bound(py, self.message.as_ref())
+        PyBytes::new(py, self.message.as_ref())
     }
 
     #[getter]
@@ -351,7 +351,7 @@ fn get_task_locals(py: Python) -> &'static pyo3_async_runtimes::TaskLocals {
             let (tx, rx) = std::sync::mpsc::channel();
             let _ = std::thread::spawn(move || {
                 Python::with_gil(|py| {
-                    let asyncio = Python::import_bound(py, "asyncio").unwrap();
+                    let asyncio = Python::import(py, "asyncio").unwrap();
                     let event_loop = asyncio.call_method0("new_event_loop").unwrap();
                     asyncio
                         .call_method1("set_event_loop", (event_loop.clone(),))
@@ -466,7 +466,7 @@ impl Handler<PythonMessage> for PythonActor {
                 inner: this.mailbox_for_py().clone(),
             };
             let awaitable = tokio::task::block_in_place(|| {
-                self.actor.call_method_bound(
+                self.actor.call_method(
                     py,
                     "handle",
                     (
@@ -519,7 +519,7 @@ impl Handler<Cast<PythonMessage>> for PythonActor {
             };
 
             let awaitable = tokio::task::block_in_place(|| {
-                self.actor.call_method_bound(
+                self.actor.call_method(
                     py,
                     "handle_cast",
                     (

monarch_hyperactor/src/mailbox.rs

@@ -54,10 +54,7 @@ impl PyMailbox {
                 inner: Arc::new(tokio::sync::Mutex::new(receiver)),
             },
         )?;
-        Ok(PyTuple::new_bound(
-            py,
-            vec![handle.into_any(), receiver.into_any()],
-        ))
+        PyTuple::new(py, vec![handle.into_any(), receiver.into_any()])
     }
 
     fn open_once_port<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyTuple>> {
@@ -74,10 +71,7 @@ impl PyMailbox {
                 inner: std::sync::Mutex::new(Some(receiver)),
             },
         )?;
-        Ok(PyTuple::new_bound(
-            py,
-            vec![handle.into_any(), receiver.into_any()],
-        ))
+        PyTuple::new(py, vec![handle.into_any(), receiver.into_any()])
     }
 
     pub(super) fn post<'py>(

monarch_hyperactor/src/ndslice.rs

@@ -120,7 +120,7 @@ impl PySlice {
                     );
                     i += step;
                 }
-                Ok(PyTuple::new_bound(py, result).into_py(py))
+                Ok(PyTuple::new(py, result)?.into_py(py))
             }
         }
     }
@@ -133,16 +133,16 @@ impl PySlice {
         self.inner.len()
     }
 
-    fn __getnewargs_ex__<'py>(&self, py: Python<'py>) -> Bound<'py, PyTuple> {
-        let kwargs = PyDict::new_bound(py);
+    fn __getnewargs_ex__<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyTuple>> {
+        let kwargs = PyDict::new(py);
         kwargs.set_item("offset", self.inner.offset()).unwrap();
         kwargs.set_item("sizes", self.inner.sizes()).unwrap();
         kwargs.set_item("strides", self.inner.strides()).unwrap();
 
-        PyTuple::new_bound(
+        PyTuple::new(
             py,
             vec![
-                PyTuple::empty_bound(py).unbind().into_any(),
+                PyTuple::empty(py).unbind().into_any(),
                 kwargs.unbind().into_any(),
             ],
         )
@@ -166,7 +166,7 @@ impl PySlice {
     #[staticmethod]
     fn from_list(py: Python<'_>, ranks: Vec<usize>) -> PyResult<PyObject> {
         if ranks.is_empty() {
-            return Ok(PyList::empty_bound(py).unbind().into_any());
+            return Ok(PyList::empty(py).unbind().into_any());
         }
         let mut ranks = ranks;
         ranks.sort();

monarch_hyperactor/src/proc.rs

@@ -125,7 +125,7 @@ impl PyProc {
             .collect::<Vec<_>>();
         // TODO: i don't think returning this list is of much use for
         // anything?
-        Ok(PyList::new_bound(py, aborted_actors))
+        PyList::new(py, aborted_actors)
     }
 
     #[pyo3(signature = (actor, name=None))]