Merge pull request #32 from neo4j/bump-dependencies

Bump dependencies

Author: robsdedude

Cargo.lock

@@ -2,11 +2,12 @@
 name = "neo4j-rust-ext"
 version = "0.1.0"
 edition = "2021"
+rust-version = "1.77"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
 name = "neo4j_rust_ext"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = "0.22.4"
+pyo3 = "0.24.2"

Cargo.toml

@@ -31,7 +31,7 @@ For that, simply make sure you haven't installed `neo4j-rust-ext` but *only* `ne
 For many operating systems and architectures, the pre-built wheels will work out of the box.
 If they don't, pip (or any other Python packaging front-end) will try to build the extension from source.
 Here's what you'll need for this:
- * Rust 1.67.0 or later:  
+ * Rust 1.77 or later:  
    https://www.rust-lang.org/tools/install
  * Further build tools (depending on the platform).  
    E.g., `gcc` on Ubuntu: `sudo apt install gcc`

README.md

@@ -58,7 +58,7 @@ pandas = ["neo4j[pandas]"]
 pyarrow = ["neo4j[pyarrow]"]
 
 [build-system]
-requires = ["maturin ~= 1.6.0"]
+requires = ["maturin ~= 1.8.3"]
 build-backend = "maturin"
 
 [tool.maturin]

driver

@@ -19,16 +19,17 @@ use pyo3::basic::CompareOp;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyTuple};
+use pyo3::IntoPyObjectExt;
 
-/// A Python module implemented in Rust.
-#[pymodule]
+#[pymodule(gil_used = false)]
 #[pyo3(name = "_rust")]
 fn packstream(m: &Bound<PyModule>) -> PyResult<()> {
     let py = m.py();
 
     m.add_class::<Structure>()?;
 
-    let mod_v1 = PyModule::new_bound(py, "v1")?;
+    let mod_v1 = PyModule::new(py, "v1")?;
+    mod_v1.gil_used(false)?;
     v1::register(&mod_v1)?;
     m.add_submodule(&mod_v1)?;
     register_package(&mod_v1, "v1")?;
@@ -40,9 +41,9 @@ fn packstream(m: &Bound<PyModule>) -> PyResult<()> {
 // https://github.com/PyO3/pyo3/issues/1517#issuecomment-808664021
 fn register_package(m: &Bound<PyModule>, name: &str) -> PyResult<()> {
     let py = m.py();
-    let module_name = format!("neo4j._codec.packstream._rust.{name}").into_py(py);
+    let module_name = format!("neo4j._codec.packstream._rust.{name}").into_pyobject(py)?;
 
-    py.import_bound("sys")?
+    py.import("sys")?
         .getattr("modules")?
         .set_item(&module_name, m)?;
     m.setattr("__name__", &module_name)?;
@@ -73,12 +74,12 @@ impl Structure {
 
     #[getter(tag)]
     fn read_tag<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
-        PyBytes::new_bound(py, &[self.tag])
+        PyBytes::new(py, &[self.tag])
     }
 
     #[getter(fields)]
-    fn read_fields<'py>(&self, py: Python<'py>) -> Bound<'py, PyTuple> {
-        PyTuple::new_bound(py, &self.fields)
+    fn read_fields<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyTuple>> {
+        PyTuple::new(py, &self.fields)
     }
 
     fn eq(&self, other: &Self, py: Python<'_>) -> PyResult<bool> {
@@ -100,8 +101,8 @@ impl Structure {
 
     fn __richcmp__(&self, other: &Self, op: CompareOp, py: Python<'_>) -> PyResult<PyObject> {
         Ok(match op {
-            CompareOp::Eq => self.eq(other, py)?.into_py(py),
-            CompareOp::Ne => (!self.eq(other, py)?).into_py(py),
+            CompareOp::Eq => self.eq(other, py)?.into_py_any(py)?,
+            CompareOp::Ne => (!self.eq(other, py)?).into_py_any(py)?,
             _ => py.NotImplemented(),
         })
     }

pyproject.toml

@@ -17,10 +17,10 @@ use std::borrow::Cow;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 use pyo3::exceptions::{PyImportError, PyOverflowError, PyTypeError, PyValueError};
-use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyBytes, PyDict, PyString, PyType};
+use pyo3::{intern, IntoPyObjectExt};
 
 use super::{
     BYTES_16, BYTES_32, BYTES_8, FALSE, FLOAT_64, INT_16, INT_32, INT_64, INT_8, LIST_16, LIST_32,
@@ -68,31 +68,31 @@ impl TypeMappings {
                 .ok_or_else(|| {
                     PyErr::new::<PyValueError, _>("Type mappings are missing INT_TYPES.")
                 })?
-                .into_py(py),
+                .into_py_any(py)?,
             float_types: locals
                 .get_item("FLOAT_TYPES")?
                 .ok_or_else(|| {
                     PyErr::new::<PyValueError, _>("Type mappings are missing FLOAT_TYPES.")
                 })?
-                .into_py(py),
+                .into_py_any(py)?,
             sequence_types: locals
                 .get_item("SEQUENCE_TYPES")?
                 .ok_or_else(|| {
                     PyErr::new::<PyValueError, _>("Type mappings are missing SEQUENCE_TYPES.")
                 })?
-                .into_py(py),
+                .into_py_any(py)?,
             mapping_types: locals
                 .get_item("MAPPING_TYPES")?
                 .ok_or_else(|| {
                     PyErr::new::<PyValueError, _>("Type mappings are missing MAPPING_TYPES.")
                 })?
-                .into_py(py),
+                .into_py_any(py)?,
             bytes_types: locals
                 .get_item("BYTES_TYPES")?
                 .ok_or_else(|| {
                     PyErr::new::<PyValueError, _>("Type mappings are missing BYTES_TYPES.")
                 })?
-                .into_py(py),
+                .into_py_any(py)?,
         })
     }
 }
@@ -103,9 +103,9 @@ static TYPE_MAPPINGS_INIT: AtomicBool = AtomicBool::new(false);
 fn get_type_mappings(py: Python<'_>) -> PyResult<&'static TypeMappings> {
     let mappings = TYPE_MAPPINGS.get_or_try_init(py, || {
         fn init(py: Python<'_>) -> PyResult<TypeMappings> {
-            let locals = PyDict::new_bound(py);
-            py.run_bound(
-                "from neo4j._codec.packstream.v1.types import *",
+            let locals = PyDict::new(py);
+            py.run(
+                c"from neo4j._codec.packstream.v1.types import *",
                 None,
                 Some(&locals),
             )?;
@@ -132,7 +132,7 @@ pub(super) fn pack<'py>(
     let type_mappings = get_type_mappings(py)?;
     let mut encoder = PackStreamEncoder::new(dehydration_hooks, type_mappings);
     encoder.write(value)?;
-    Ok(PyBytes::new_bound(py, &encoder.buffer))
+    Ok(PyBytes::new(py, &encoder.buffer))
 }
 
 struct PackStreamEncoder<'a> {
@@ -176,7 +176,7 @@ impl<'a> PackStreamEncoder<'a> {
             return self.write_int(value);
         }
 
-        if value.is_instance(&PyType::new_bound::<PyString>(py))? {
+        if value.is_instance(&PyType::new::<PyString>(py))? {
             return self.write_string(value.extract::<&str>()?);
         }
 
@@ -187,14 +187,14 @@ impl<'a> PackStreamEncoder<'a> {
         if value.is_instance(self.type_mappings.sequence_types.bind(py))? {
             let size = Self::usize_to_u64(value.len()?)?;
             self.write_list_header(size)?;
-            return value.iter()?.try_for_each(|item| self.write(&item?));
+            return value.try_iter()?.try_for_each(|item| self.write(&item?));
         }
 
         if value.is_instance(self.type_mappings.mapping_types.bind(py))? {
             let size = Self::usize_to_u64(value.getattr(intern!(py, "keys"))?.call0()?.len()?)?;
             self.write_dict_header(size)?;
             let items = value.getattr(intern!(py, "items"))?.call0()?;
-            return items.iter()?.try_for_each(|item| {
+            return items.try_iter()?.try_for_each(|item| {
                 let (key, value) = item?.extract::<(Bound<PyAny>, Bound<PyAny>)>()?;
                 let key = match key.extract::<&str>() {
                     Ok(key) => key,