update pyo3, add lint step, add make and pre commit

Author: collerek

.github/workflows/ci.yml

@@ -11,7 +11,19 @@ permissions:
   contents: read
 
 jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - name: Run lint checks
+        run: make check
+
   test:
+    needs: lint
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -40,9 +52,9 @@ jobs:
       - name: Install dependencies
         run: poetry install
       - name: Build with maturin
-        run: poetry run maturin develop
+        run: make build
       - name: Run tests
-        run: poetry run pytest tests/ -v
+        run: make test
 
   build:
     name: Build wheels

.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+repos:
+  - repo: https://github.com/rust-lang/rust-clippy
+    rev: v1.77.0
+    hooks:
+      - id: clippy
+        name: clippy
+        entry: cargo clippy -- -D warnings
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [commit]
+
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [commit]
+
+      - id: cargo-check
+        name: cargo check
+        entry: cargo check
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [commit]

Cargo.lock

@@ -10,7 +10,7 @@ name = "ormar_rust_utils"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.22", features = ["extension-module"] }
+pyo3 = { version = "0.23.5", features = ["extension-module"] }
 base64 = "0.22"
 serde_json = "1.0"
 indexmap = "2.0"

Cargo.toml

@@ -0,0 +1,27 @@
+.PHONY: fmt check test build clean
+
+fmt:
+	cargo fmt
+
+check:
+	cargo clippy -- -D warnings
+
+test:
+	poetry run pytest tests/ -v
+
+build:
+	poetry run maturin develop
+
+clean:
+	cargo clean
+	rm -rf target/
+
+.DEFAULT_GOAL := help
+
+help:
+	@echo "Available targets:"
+	@echo "  fmt       - Format code with rustfmt"
+	@echo "  check     - Run clippy linter with strict warnings"
+	@echo "  test      - Run tests with pytest"
+	@echo "  build     - Build the extension module with maturin"
+	@echo "  clean     - Clean build artifacts"

Makefile

@@ -46,6 +46,7 @@ python = "^3.10"
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.0"
 maturin = "^1.0"
+pre-commit = "^3.0"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

pyproject.toml

@@ -44,8 +44,8 @@ fn group_related_inner(py: Python<'_>, list_: &[String]) -> PyResult<PyObject> {
             let nested = group_related_inner(py, &children)?;
             result_items.push((key, nested));
         } else {
-            let py_list = PyList::new_bound(py, &children);
-            result_items.push((key, py_list.into()));
+            let py_list = PyList::new(py, &children)?;
+            result_items.push((key, py_list.unbind().into()));
         }
     }
 
@@ -56,10 +56,10 @@ fn group_related_inner(py: Python<'_>, list_: &[String]) -> PyResult<PyObject> {
         a_len.cmp(&b_len).then_with(|| a.0.cmp(&b.0))
     });
 
-    let dict = PyDict::new_bound(py);
+    let dict = PyDict::new(py);
     for (key, value) in &result_items {
         dict.set_item(key, value)?;
     }
 
-    Ok(dict.into())
+    Ok(dict.unbind().into())
 }

src/group_related.rs

@@ -45,11 +45,11 @@ fn hash_item_inner(py: Python<'_>, item: &Bound<'_, PyAny>) -> PyResult<PyObject
                 } else {
                     value.clone_ref(py)
                 };
-            let pair = PyTuple::new_bound(py, &[key.clone_ref(py), processed_value]);
-            result.push(pair.into());
+            let pair = PyTuple::new(py, &[key.clone_ref(py), processed_value])?;
+            result.push(pair.unbind().into());
         }
-        let tuple = PyTuple::new_bound(py, &result);
-        Ok(tuple.into())
+        let tuple = PyTuple::new(py, &result)?;
+        Ok(tuple.unbind().into())
     } else if let Ok(list) = item.downcast::<PyList>() {
         let mut result: Vec<PyObject> = Vec::with_capacity(list.len());
         for (idx, value) in list.iter().enumerate() {
@@ -59,12 +59,12 @@ fn hash_item_inner(py: Python<'_>, item: &Bound<'_, PyAny>) -> PyResult<PyObject
                 } else {
                     value.unbind()
                 };
-            let idx_obj = idx.to_object(py);
-            let pair = PyTuple::new_bound(py, &[idx_obj, processed_value]);
-            result.push(pair.into());
+            let idx_obj: PyObject = idx.into_pyobject(py)?.into_any().unbind();
+            let pair = PyTuple::new(py, &[idx_obj, processed_value])?;
+            result.push(pair.unbind().into());
         }
-        let tuple = PyTuple::new_bound(py, &result);
-        Ok(tuple.into())
+        let tuple = PyTuple::new(py, &result)?;
+        Ok(tuple.unbind().into())
     } else {
         Err(pyo3::exceptions::PyTypeError::new_err(
             "hash_item expects a dict or list",

src/hash_item.rs

@@ -13,11 +13,11 @@ pub fn group_by_pk(py: Python<'_>, pks: Vec<PyObject>) -> PyResult<PyObject> {
         groups.entry(hash).or_default().push(idx);
     }
 
-    let result = PyList::empty_bound(py);
+    let result = PyList::empty(py);
     for (_hash, indices) in &groups {
-        let py_indices = PyList::new_bound(py, indices);
-        result.append(py_indices)?;
+        let py_indices = PyList::new(py, indices)?;
+        result.append(&py_indices)?;
     }
 
-    Ok(result.into())
+    Ok(result.unbind().into())
 }

src/merge_instances.rs

@@ -1,7 +1,7 @@
 use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
 use base64::Engine;
 use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyString};
+use pyo3::types::{PyBytes, PyString, PyDict};
 
 /// Encode bytes to string representation.
 /// If represent_as_string is true, uses base64 encoding.
@@ -21,11 +21,11 @@ pub fn encode_bytes(
 
     if represent_as_string {
         let encoded = BASE64_STANDARD.encode(bytes_val);
-        Ok(PyString::new_bound(py, &encoded).into())
+        Ok(PyString::new(py, &encoded).into())
     } else {
         let s = std::str::from_utf8(bytes_val)
             .map_err(|e| pyo3::exceptions::PyUnicodeDecodeError::new_err(e.to_string()))?;
-        Ok(PyString::new_bound(py, s).into())
+        Ok(PyString::new(py, s).into())
     }
 }
 
@@ -49,17 +49,17 @@ pub fn decode_bytes(
         let decoded = BASE64_STANDARD
             .decode(s)
             .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
-        Ok(PyBytes::new_bound(py, &decoded).into())
+        Ok(PyBytes::new(py, &decoded).into())
     } else {
-        Ok(PyBytes::new_bound(py, s.as_bytes()).into())
+        Ok(PyBytes::new(py, s.as_bytes()).into())
     }
 }
 
 /// Encode a value to JSON string.
 /// Handles datetime objects by calling .isoformat() first.
 #[pyfunction]
 pub fn encode_json(py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<PyObject> {
-    let datetime_mod = py.import_bound("datetime")?;
+    let datetime_mod = py.import("datetime")?;
     let date_type = datetime_mod.getattr("date")?;
     let datetime_type = datetime_mod.getattr("datetime")?;
     let time_type = datetime_mod.getattr("time")?;
@@ -84,7 +84,7 @@ pub fn encode_json(py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<PyObjec
             Ok(parsed) => {
                 let result = serde_json::to_string(&parsed)
                     .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
-                return Ok(PyString::new_bound(py, &result).into());
+                return Ok(PyString::new(py, &result).into());
             }
             Err(_) => {
                 // Not valid JSON, return as-is
@@ -95,8 +95,8 @@ pub fn encode_json(py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<PyObjec
 
     // For other types, use Python's json.dumps
     let json_mod = py
-        .import_bound("orjson")
-        .or_else(|_| py.import_bound("json"))?;
+        .import("orjson")
+        .or_else(|_| py.import("json"))?;
 
     // Check if using orjson (which is always compact) or standard json
     let is_orjson = json_mod.getattr("__name__")?.extract::<String>()? == "orjson";
@@ -106,7 +106,7 @@ pub fn encode_json(py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<PyObjec
         json_mod.call_method1("dumps", (val_bound,))?
     } else {
         // Standard json: use separators to match orjson's compact format
-        let kwargs = PyDict::new_bound(py);
+        let kwargs = PyDict::new(py);
         kwargs.set_item("separators", (",", ":"))?;
         json_mod.call_method("dumps", (val_bound,), Some(&kwargs))?
     };
@@ -116,7 +116,7 @@ pub fn encode_json(py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<PyObjec
         let bytes_val: &[u8] = dumped.downcast::<PyBytes>()?.as_bytes();
         let s = std::str::from_utf8(bytes_val)
             .map_err(|e| pyo3::exceptions::PyUnicodeDecodeError::new_err(e.to_string()))?;
-        Ok(PyString::new_bound(py, s).into())
+        Ok(PyString::new(py, s).into())
     } else {
         Ok(dumped.unbind())
     }