feat: add shim support for multiple dtypes

Author: Elan456

pysrc/fastquadtree/_base_quadtree.py

@@ -48,6 +48,7 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         "_bounds",
         "_capacity",
         "_count",
+        "_dtype",
         "_max_depth",
         "_native",
         "_next_id",
@@ -62,7 +63,7 @@ def _new_native(self, bounds: Bounds, capacity: int, max_depth: int | None) -> A
         """Create the native engine instance."""
 
     @classmethod
-    def _new_native_from_bytes(cls, data: bytes) -> Any:
+    def _new_native_from_bytes(cls, data: bytes, dtype: str) -> Any:
         """Create the native engine instance from serialized bytes."""
 
     @staticmethod
@@ -79,10 +80,12 @@ def __init__(
         *,
         max_depth: int | None = None,
         track_objects: bool = False,
+        dtype: str = "f32",
     ):
         self._bounds = bounds
         self._max_depth = max_depth
         self._capacity = capacity
+        self._dtype = dtype
         self._native = self._new_native(bounds, capacity, max_depth)
 
         self._track_objects = bool(track_objects)
@@ -138,12 +141,13 @@ def to_bytes(self) -> bytes:
         return pickle.dumps(self.to_dict())
 
     @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
+    def from_bytes(cls, data: bytes, dtype: str = "f32") -> Self:
         """
-        Deserialize a quadtree from bytes.
+        Deserialize a quadtree from bytes. Specifiy the dtype if the original tree that was serialized used a non-default dtype.
 
         Args:
             data: Bytes representing the serialized quadtree from `to_bytes()`.
+            dtype: The data type used in the native engine ('f32', 'f64', 'i32', 'i64') when saved to bytes.
 
         Returns:
             A new quadtree instance with the same state as when serialized.
@@ -160,7 +164,15 @@ def from_bytes(cls, data: bytes) -> Self:
         store_dict = in_dict["store"]
 
         qt = cls.__new__(cls)  # type: ignore[call-arg]
-        qt._native = cls._new_native_from_bytes(core_bytes)
+        try:
+            qt._native = cls._new_native_from_bytes(core_bytes, dtype=dtype)
+        except ValueError as ve:
+            raise ValueError(
+                "Failed to deserialize quadtree native core. "
+                "This may be due to a dtype mismatch. "
+                "Ensure the dtype used in from_bytes() matches the original tree. "
+                "Error details: " + str(ve)
+            ) from ve
 
         if store_dict is not None:
             qt._store = ObjStore.from_dict(store_dict, qt._make_item)

pysrc/fastquadtree/_item.py

@@ -3,10 +3,10 @@
 
 from typing import Any, Tuple
 
-Bounds = Tuple[float, float, float, float]
+Bounds = Tuple[float | int, float | int, float | int, float | int]
 """Axis-aligned rectangle as (min_x, min_y, max_x, max_y)."""
 
-Point = Tuple[float, float]
+Point = Tuple[float | int, float | int]
 """2D point as (x, y)."""
 
 

pysrc/fastquadtree/point_quadtree.py

@@ -5,10 +5,17 @@
 
 from ._base_quadtree import Bounds, _BaseQuadTree
 from ._item import Point, PointItem
-from ._native import QuadTree as _RustQuadTree  # native point tree
+from ._native import QuadTree as QuadTreeF32, QuadTreeF64, QuadTreeI32, QuadTreeI64
 
 _IdCoord = Tuple[int, float, float]
 
+DTYPE_MAP = {
+    "f32": QuadTreeF32,
+    "f64": QuadTreeF64,
+    "i32": QuadTreeI32,
+    "i64": QuadTreeI64,
+}
+
 
 class QuadTree(_BaseQuadTree[Point, _IdCoord, PointItem]):
     """
@@ -29,6 +36,7 @@ class QuadTree(_BaseQuadTree[Point, _IdCoord, PointItem]):
         capacity: Max number of points per node before splitting.
         max_depth: Optional max tree depth. If omitted, engine decides.
         track_objects: Enable id <-> object mapping inside Python.
+        dtype: Data type for coordinates and ids in the native engine. Default is 'f32'. Options are 'f32', 'f64', 'i32', 'i64'.
 
     Raises:
         ValueError: If parameters are invalid or inserts are out of bounds.
@@ -41,12 +49,14 @@ def __init__(
         *,
         max_depth: int | None = None,
         track_objects: bool = False,
+        dtype: str = "f32",
     ):
         super().__init__(
             bounds,
             capacity,
             max_depth=max_depth,
             track_objects=track_objects,
+            dtype=dtype,
         )
 
     @overload
@@ -148,14 +158,19 @@ def nearest_neighbors(self, xy: Point, k: int, *, as_items: bool = False):
         return out
 
     def _new_native(self, bounds: Bounds, capacity: int, max_depth: int | None) -> Any:
-        if max_depth is None:
-            return _RustQuadTree(bounds, capacity)
-        return _RustQuadTree(bounds, capacity, max_depth=max_depth)
+        """Create the native engine instance."""
+        rust_cls = DTYPE_MAP.get(self._dtype)
+        if rust_cls is None:
+            raise ValueError(f"Unsupported dtype: {self._dtype}")
+        return rust_cls(bounds, capacity, max_depth)
 
     @classmethod
-    def _new_native_from_bytes(cls, data: bytes) -> Any:
+    def _new_native_from_bytes(cls, data: bytes, dtype: str = "f32") -> Any:
         """Create a new native engine instance from serialized bytes."""
-        return _RustQuadTree.from_bytes(data)
+        rust_cls = DTYPE_MAP.get(dtype)
+        if rust_cls is None:
+            raise ValueError(f"Unsupported dtype: {dtype}")
+        return rust_cls.from_bytes(data)
 
     @staticmethod
     def _make_item(id_: int, geom: Point, obj: Any | None) -> PointItem:

pysrc/fastquadtree/rect_quadtree.py

@@ -5,10 +5,21 @@
 
 from ._base_quadtree import Bounds, _BaseQuadTree
 from ._item import RectItem
-from ._native import RectQuadTree as _RustRectQuadTree  # native rect tree
+from ._native import (
+    RectQuadTree as RectQuadTreeF32,
+    RectQuadTreeF64,
+    RectQuadTreeI32,
+    RectQuadTreeI64,
+)
 
-_IdRect = Tuple[int, float, float, float, float]
-Point = Tuple[float, float]  # only for type hints in docstrings
+_IdRect = Tuple[int, float | int, float | int, float | int, float | int]
+
+DTYPE_MAP = {
+    "f32": RectQuadTreeF32,
+    "f64": RectQuadTreeF64,
+    "i32": RectQuadTreeI32,
+    "i64": RectQuadTreeI64,
+}
 
 
 class RectQuadTree(_BaseQuadTree[Bounds, _IdRect, RectItem]):
@@ -30,6 +41,7 @@ class RectQuadTree(_BaseQuadTree[Bounds, _IdRect, RectItem]):
         capacity: Max number of points per node before splitting.
         max_depth: Optional max tree depth. If omitted, engine decides.
         track_objects: Enable id <-> object mapping inside Python.
+        dtype: Data type for coordinates and ids in the native engine. Default is 'f32'. Options are 'f32', 'f64', 'i32', 'i64'.
 
     Raises:
         ValueError: If parameters are invalid or inserts are out of bounds.
@@ -42,12 +54,14 @@ def __init__(
         *,
         max_depth: int | None = None,
         track_objects: bool = False,
+        dtype: str = "f32",
     ):
         super().__init__(
             bounds,
             capacity,
             max_depth=max_depth,
             track_objects=track_objects,
+            dtype=dtype,
         )
 
     @overload
@@ -84,14 +98,19 @@ def query(
         return self._store.get_many_by_ids(self._native.query_ids(rect))
 
     def _new_native(self, bounds: Bounds, capacity: int, max_depth: int | None) -> Any:
-        if max_depth is None:
-            return _RustRectQuadTree(bounds, capacity)
-        return _RustRectQuadTree(bounds, capacity, max_depth=max_depth)
+        """Create the native engine instance."""
+        rust_cls = DTYPE_MAP.get(self._dtype)
+        if rust_cls is None:
+            raise ValueError(f"Unsupported dtype: {self._dtype}")
+        return rust_cls(bounds, capacity, max_depth)
 
     @classmethod
-    def _new_native_from_bytes(cls, data: bytes) -> Any:
+    def _new_native_from_bytes(cls, data: bytes, dtype: str = "f32") -> Any:
         """Create a new native engine instance from serialized bytes."""
-        return _RustRectQuadTree.from_bytes(data)
+        rust_cls = DTYPE_MAP.get(dtype)
+        if rust_cls is None:
+            raise ValueError(f"Unsupported dtype: {dtype}")
+        return rust_cls.from_bytes(data)
 
     @staticmethod
     def _make_item(id_: int, geom: Bounds, obj: Any | None) -> RectItem: