feat: add insert_many_points support to rust core

Author: Elan456

benchmarks/quadtree_bench/engines.py

@@ -101,8 +101,7 @@ def _create_fastquadtree_engine(
 
     def build(points):
         qt = RustQuadTree(bounds, max_points, max_depth=max_depth)
-        for p in points:
-            qt.insert(p)
+        qt.insert_many_points(points)
         return qt
 
     def query(qt, queries):

pysrc/fastquadtree/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Literal, Tuple, overload
+from typing import Any, Literal, Tuple, overload
 
 from ._bimap import BiMap  # type: ignore[attr-defined]
 from ._item import Item
@@ -103,37 +103,33 @@ def insert(self, xy: Point, *, id_: int | None = None, obj: Any = None) -> int:
         self._count += 1
         return id_
 
-    def insert_many_points(self, points: Iterable[Point]) -> int:
+    def insert_many_points(self, points: list[Point]) -> int:
         """
         Bulk insert points with auto-assigned ids.
 
         Args:
-            points: Iterable of (x, y) points.
+            points: List of (x, y) points.
 
         Returns:
-            Number of points successfully inserted.
-
-        Raises:
-            ValueError: If any point is outside tree bounds.
+            The number of points inserted
         """
-        ins = self._native.insert
-        nid = self._next_id
-        inserted = 0
-        bx0, by0, bx1, by1 = self._bounds
-        for xy in points:
-            id_ = nid
-            nid += 1
-            if not ins(id_, xy):
-                x, y = xy
-                raise ValueError(
-                    f"Point ({x}, {y}) is outside bounds ({bx0}, {by0}, {bx1}, {by1})"
-                )
-            inserted += 1
-            if self._items is not None:
-                self._items.add(Item(id_, xy[0], xy[1], None))
-        self._next_id = nid
-        self._count += inserted
-        return inserted
+        start_id = self._next_id
+        last_id = self._native.insert_many_points(start_id, points)
+
+        num_inserted = last_id - start_id + 1
+
+        if num_inserted < len(points):
+            raise ValueError("One or more points are outside tree bounds")
+
+        self._next_id = last_id + 1
+
+        # Update the item tracker if needed
+        if self._items is not None:
+            for i, id_ in enumerate(range(start_id, last_id + 1)):
+                x, y = points[i]
+                self._items.add(Item(id_, x, y, None))
+
+        return num_inserted
 
     def attach(self, id_: int, obj: Any) -> None:
         """

pysrc/fastquadtree/__init__.pyi

@@ -31,7 +31,6 @@ class QuadTree:
     # Inserts
     def insert(self, xy: Point, *, id_: int | None = ..., obj: Any = ...) -> int: ...
     def insert_many_points(self, points: Iterable[Point]) -> int: ...
-    def insert_many(self, items: Iterable[tuple[Point, Any]]) -> int: ...
     def attach(self, id_: int, obj: Any) -> None: ...
 
     # Deletions

src/lib.rs

@@ -36,6 +36,18 @@ impl PyQuadTree {
         self.inner.insert(Item { id, point: Point { x, y } })
     }
 
+    // Insert many points with auto ids starting at `start_id`: [(x, y), ...]
+    // Returns the last id used
+    pub fn insert_many_points(&mut self, start_id: u64, points: Vec<(f32, f32)>) -> u64 {
+        let mut id = start_id;
+        for (x, y) in points {
+            if self.inner.insert(Item { id, point: Point { x, y } }) {
+                id += 1;
+            }
+        }
+        id - 1  // -1 because id was incremented after last successful insert
+    }
+
     pub fn delete(&mut self, id: u64, xy: (f32, f32)) -> bool {
         let (x, y) = xy;
         self.inner.delete(id, Point { x, y })