Numpy 2.0 and Python 3.13 compatibility

Author: kno10

.github/workflows/build-wheels.sh

@@ -11,7 +11,7 @@ echo "[net]" >> "$HOME/.cargo/config.toml"
 echo "git-fetch-with-cli = true" >> "$HOME/.cargo/config.toml"
 
 # build wheels
-for PYBIN in /opt/python/cp3[89]*/bin /opt/python/cp31[012]*/bin; do
+for PYBIN in /opt/python/cp3[89]*/bin /opt/python/cp31[0123]-cp31[0123]/bin; do
     "${PYBIN}/pip" install -r requirements.txt -r requirements-dev.txt
     "${PYBIN}/maturin" build -i "${PYBIN}/python" --release --strip
 done
@@ -22,7 +22,7 @@ for wheel in target/wheels/*.whl; do
 done
 
 # test wheels
-for PYBIN in /opt/python/cp3[89]*/bin /opt/python/cp31[012]*/bin; do
+for PYBIN in /opt/python/cp3[89]*/bin /opt/python/cp31[0123]-cp31[0123]/bin; do
     "${PYBIN}/pip" install kmedoids --no-index --find-links wheelhouse
     cd tests && "${PYBIN}/python" -m unittest discover && cd ..
 done

.github/workflows/wheels.yml

@@ -51,7 +51,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -79,7 +79,7 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 For changes to the main Rust package, please see <https://github.com/kno10/rust-kmedoids/blob/main/CHANGELOG.md>
 
+## kmedoids 0.5.3 (2024-12-02)
+
+- no functionality changes
+- numpy 2.0 and Python 3.13 compatibility
+- update to pyo3 0.23, numpy 0.23
+
 ## kmedoids 0.5.2 (2024-09-10)
 
 - fix clippy warnings

CITATION.cff

@@ -10,8 +10,8 @@ authors:
 title: "Fast k-medoids Clustering in Rust and Python"
 journal: "J. Open Source Softw."
 doi: 10.21105/joss.04183
-version: 0.5.2
-date-released: 2024-09-10
+version: 0.5.3
+date-released: 2024-12-02
 license: GPL-3.0
 preferred-citation:
   title: "Fast k-medoids Clustering in Rust and Python"

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 edition = "2021"
 name = "kmedoids"
-version = "0.5.2"
+version = "0.5.3"
 authors = ["Erich Schubert <erich.schubert@tu-dortmund.de>", "Lars Lenssen <lars.lenssen@tu-dortmund.de>"]
 description = "k-Medoids clustering with the FasterPAM algorithm"
 homepage = "https://github.com/kno10/python-kmedoids"
@@ -14,13 +14,13 @@ name = "kmedoids"
 crate-type = ["cdylib"]
 
 [dependencies]
-rustkmedoids = { version = "0.5.2", package = "kmedoids", git = "https://github.com/kno10/rust-kmedoids" }
-numpy = "0.21"
-ndarray = "0.15"
+rustkmedoids = { version = "0.5.3", package = "kmedoids", git = "https://github.com/kno10/rust-kmedoids" }
+numpy = "0.23"
+ndarray = "0.16"
 rand = "0.8"
 rayon = "1.10"
 
 [dependencies.pyo3]
-version = "^0.21"
+version = "^0.23"
 features = ["extension-module"]
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "kmedoids"
-version = "0.5.2"
+version = "0.5.3"
 description = "k-Medoids Clustering in Python with FasterPAM"
 requires-dist = ["numpy"]
 classifier = [

src/lib.rs

@@ -1,5 +1,6 @@
 use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
+use pyo3::types::PyTuple;
 use numpy::{PyArray1, PyReadonlyArray1, PyReadonlyArray2, PyArrayMethods, PyUntypedArrayMethods};
 use rand::{rngs::StdRng, SeedableRng};
 
@@ -16,13 +17,13 @@ macro_rules! variant_call {
 /// :return: k-medoids clustering result
 /// :rtype: KMedoidsResult
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, meds: PyReadonlyArray1<'_, usize>, max_iter: usize) -> PyResult<Py<PyAny>> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, meds: PyReadonlyArray1<'py, usize>, max_iter: usize) -> PyResult<Py<PyTuple>> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let mut meds = meds.to_vec()?;
     let (loss, assi, n_iter, n_swap): ($ltype, _, _, _) = rustkmedoids::$variant(&dist.as_array(), &mut meds, max_iter);
-    Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-      Ok((loss, PyArray1::from_vec_bound(py, assi), PyArray1::from_vec_bound(py, meds), n_iter, n_swap).to_object(py))
+    Python::with_gil(|py| {
+        Ok((loss, PyArray1::from_vec(py, assi), PyArray1::from_vec(py, meds), n_iter, n_swap).into_pyobject(py)?.unbind())
     })
 }
 }}
@@ -62,14 +63,14 @@ macro_rules! rand_call {
 /// :return: k-medoids clustering result
 /// :rtype: KMedoidsResult
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, meds: PyReadonlyArray1<'_, usize>, max_iter: usize, seed: u64) -> PyResult<Py<PyAny>> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, meds: PyReadonlyArray1<'py, usize>, max_iter: usize, seed: u64) -> PyResult<Py<PyTuple>> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let mut meds = meds.to_vec()?;
     let mut rnd = StdRng::seed_from_u64(seed);
     let (loss, assi, n_iter, n_swap): ($ltype, _, _, _) = rustkmedoids::$variant(&dist.as_array(), &mut meds, max_iter, &mut rnd);
-    Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-      Ok((loss, PyArray1::from_vec_bound(py, assi), PyArray1::from_vec_bound(py, meds), n_iter, n_swap).to_object(py))
+    Python::with_gil(|py| {
+        Ok((loss, PyArray1::from_vec(py, assi), PyArray1::from_vec(py, meds), n_iter, n_swap).into_pyobject(py)?.unbind())
     })
 }
 }}
@@ -95,7 +96,7 @@ macro_rules! par_call {
 /// :return: k-medoids clustering result
 /// :rtype: KMedoidsResult
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, meds: PyReadonlyArray1<'_, usize>, max_iter: usize, seed: u64, n_cpu: usize) -> PyResult<Py<PyAny>> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, meds: PyReadonlyArray1<'py, usize>, max_iter: usize, seed: u64, n_cpu: usize) -> PyResult<Py<PyTuple>> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let pool = rayon::ThreadPoolBuilder::new().num_threads(n_cpu).build().unwrap();
@@ -105,8 +106,8 @@ fn $name(dist: PyReadonlyArray2<'_, $type>, meds: PyReadonlyArray1<'_, usize>, m
         let mut rnd = StdRng::seed_from_u64(seed);
         rustkmedoids::$variant(&dist, &mut meds, max_iter, &mut rnd)
     });
-    Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-      Ok((loss, PyArray1::from_vec_bound(py, assi), PyArray1::from_vec_bound(py, meds), n_iter, n_swap).to_object(py))
+    Python::with_gil(|py| {
+        Ok((loss, PyArray1::from_vec(py, assi), PyArray1::from_vec(py, meds), n_iter, n_swap).into_pyobject(py)?.unbind())
     })
 }
 }}
@@ -126,12 +127,12 @@ macro_rules! pam_build_call {
 /// :return: k-medoids clustering result
 /// :rtype: KMedoidsResult
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, k: usize) -> PyResult<Py<PyAny>> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, k: usize) -> PyResult<Py<PyTuple>> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let (loss, assi, meds): ($ltype, _, _) = rustkmedoids::pam_build(&dist.as_array(), k);
-    Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-      Ok((loss, PyArray1::from_vec_bound(py, assi), PyArray1::from_vec_bound(py, meds), 1).to_object(py))
+    Python::with_gil(|py| {
+        Ok((loss, PyArray1::from_vec(py, assi), PyArray1::from_vec(py, meds), 1).into_pyobject(py)?.unbind())
     })
 }
 }}
@@ -153,13 +154,13 @@ macro_rules! alternating_call {
 /// :return: k-medoids clustering result
 /// :rtype: KMedoidsResult
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, meds: PyReadonlyArray1<'_, usize>, max_iter: usize) -> PyResult<Py<PyAny>> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, meds: PyReadonlyArray1<'py, usize>, max_iter: usize) -> PyResult<Py<PyTuple>> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let mut meds = meds.to_vec()?;
     let (loss, assi, n_iter): ($ltype, _, _) = rustkmedoids::alternating(&dist.as_array(), &mut meds, max_iter);
-    Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-      Ok((loss, PyArray1::from_vec_bound(py, assi), PyArray1::from_vec_bound(py, meds), n_iter).to_object(py))
+    Python::with_gil(|py| {
+        Ok((loss, PyArray1::from_vec(py, assi), PyArray1::from_vec(py, meds), n_iter).into_pyobject(py)?.unbind())
     })
 }
 }}
@@ -181,15 +182,15 @@ macro_rules! dynmsc_call {
 /// :return: k-medoids clustering result
 /// :rtype: DynkResult
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, meds: PyReadonlyArray1<'_, usize>, minimum_k: usize, max_iter: usize) -> PyResult<Py<PyAny>> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, meds: PyReadonlyArray1<'py, usize>, minimum_k: usize, max_iter: usize) -> PyResult<Py<PyTuple>> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let mut meds = meds.to_vec()?;
     let maxk = meds.len() + 1;
     let (loss, assi, n_iter, n_swap, best_meds, losses): ($ltype, _, _, _, _, _) = rustkmedoids::dynmsc(&dist.as_array(), &mut meds, minimum_k, max_iter);
     let bestk = best_meds.len();
-    Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-      Ok((loss, PyArray1::from_vec_bound(py, assi), PyArray1::from_vec_bound(py, best_meds), bestk, PyArray1::from_vec_bound(py, losses), (minimum_k..maxk).collect::<Vec<usize>>(), n_iter, n_swap).to_object(py))
+    Python::with_gil(|py| {
+        Ok((loss, PyArray1::from_vec(py, assi), PyArray1::from_vec(py, best_meds), bestk, PyArray1::from_vec(py, losses), PyArray1::from_vec(py, (minimum_k..maxk).collect::<Vec<usize>>()), n_iter, n_swap).into_pyobject(py)?.unbind())
     })
 }
 }}
@@ -209,12 +210,12 @@ macro_rules! silhouette_call {
 /// :return: Silhouette evaluation result
 /// :rtype: pair of Silhouette score and Silhouette coefficients per point
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, assi: PyReadonlyArray1<'_, usize>, samples: bool) -> PyResult<Py<PyAny>> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, assi: PyReadonlyArray1<'py, usize>, samples: bool) -> PyResult<Py<PyTuple>> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let (sil, sils): (f64, _) = rustkmedoids::silhouette(&dist.as_array(), &assi.to_vec()?, samples);
-    Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-      Ok((sil, PyArray1::from_vec_bound(py, sils)).to_object(py))
+    Python::with_gil(|py| {
+        Ok((sil, PyArray1::from_vec(py, sils)).into_pyobject(py)?.unbind())
     })
 }
 }}
@@ -236,7 +237,7 @@ macro_rules! par_silhouette_call {
 /// :return: Silhouette evaluation result
 /// :rtype: Silhouette score
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, assi: PyReadonlyArray1<'_, usize>, n_cpu: usize) -> PyResult<f64> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, assi: PyReadonlyArray1<'py, usize>, n_cpu: usize) -> PyResult<f64> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let pool = rayon::ThreadPoolBuilder::new().num_threads(n_cpu).build().unwrap();
@@ -264,12 +265,12 @@ macro_rules! medoid_silhouette_call {
 /// :return: Medoid Silhouette evaluation result
 /// :rtype: pair of Medoid Silhouette score and Medoid Silhouette coefficients per point
 #[pyfunction]
-fn $name(dist: PyReadonlyArray2<'_, $type>, meds: PyReadonlyArray1<'_, usize>, samples: bool) -> PyResult<Py<PyAny>> {
+fn $name<'py>(dist: PyReadonlyArray2<'py, $type>, meds: PyReadonlyArray1<'py, usize>, samples: bool) -> PyResult<Py<PyTuple>> {
     assert_eq!(dist.ndim(), 2);
     assert_eq!(dist.shape()[0], dist.shape()[1]);
     let (sil, sils): (f64, _) = rustkmedoids::medoid_silhouette(&dist.as_array(), &meds.to_vec()?, samples);
-    Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-      Ok((sil, PyArray1::from_vec_bound(py, sils)).to_object(py))
+    Python::with_gil(|py| {
+        Ok((sil, PyArray1::from_vec(py, sils)).into_pyobject(py)?.unbind())
     })
 }
 }}