fastquadtree 1.1.2__tar.gz → 1.2.1__tar.gz

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/.gitignore

@@ -210,4 +210,5 @@ __marimo__/
 
 
 *.exe 
-*.pdb
+*.pdb
+*.bin

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/Cargo.lock

@@ -8,12 +8,34 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
 [[package]]
 name = "fastquadtree"
-version = "1.1.2"
+version = "1.2.1"
 dependencies = [
+ "bincode",
  "numpy",
  "pyo3",
+ "serde",
  "smallvec",
 ]
 
@@ -224,6 +246,36 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -258,3 +310,15 @@ name = "unindent"
 version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fastquadtree"
-version = "1.1.2"
+version = "1.2.1"
 edition = "2021"
 readme = "README.md"
 
@@ -11,6 +11,8 @@ crate-type = ["rlib", "cdylib"]
 pyo3 = { version = "0.26", features = ["extension-module", "abi3-py38"] }
 smallvec = "1.15.1"
 numpy = "0.26"
+serde = { version = "1.0", features = ["derive"] }
+bincode = {version = "2.0.1", features = ["serde"]}
 
 [profile.release]
 opt-level = 3

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastquadtree
-Version: 1.1.2
+Version: 1.2.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Rust
@@ -70,6 +70,7 @@ Rust-optimized quadtree with a clean Python API
 - Support for [inserting bounding boxes](https://elan456.github.io/fastquadtree/api/rect_quadtree/) or points
 - Fast KNN and range queries
 - Optional object tracking for id ↔ object mapping
+- Fast [serialization](https://elan456.github.io/fastquadtree/benchmark/#serialization-vs-rebuild) to/from bytes
 - [100% test coverage](https://codecov.io/gh/Elan456/fastquadtree) and CI on GitHub Actions
 - Offers a drop-in [pyqtree shim](https://elan456.github.io/fastquadtree/benchmark/#pyqtree-drop-in-shim-performance-gains) that is 6.567x faster while keeping the same API
 

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/README.md

@@ -30,6 +30,7 @@ Rust-optimized quadtree with a clean Python API
 - Support for [inserting bounding boxes](https://elan456.github.io/fastquadtree/api/rect_quadtree/) or points
 - Fast KNN and range queries
 - Optional object tracking for id ↔ object mapping
+- Fast [serialization](https://elan456.github.io/fastquadtree/benchmark/#serialization-vs-rebuild) to/from bytes
 - [100% test coverage](https://codecov.io/gh/Elan456/fastquadtree) and CI on GitHub Actions
 - Offers a drop-in [pyqtree shim](https://elan456.github.io/fastquadtree/benchmark/#pyqtree-drop-in-shim-performance-gains) that is 6.567x faster while keeping the same API
 

fastquadtree-1.2.1/benchmarks/benchmark_serialization_vs_rebuild.py

@@ -0,0 +1,149 @@
+"""
+Benchmark: serialization/deserialization vs rebuild from NumPy array
+"""
+
+from __future__ import annotations
+
+import gc
+import statistics as stats
+from pathlib import Path
+from time import perf_counter as pc
+
+import numpy as np
+
+from fastquadtree import QuadTree
+
+CAPACITY = 64
+MAX_DEPTH = 10
+N = 1_000_000
+REPEATS = 7
+
+
+def timeit(fn, repeat=REPEATS):
+    # warmup
+    fn()
+    times = []
+    gc.disable()
+    try:
+        for _ in range(repeat):
+            t0 = pc()
+            fn()
+            times.append(pc() - t0)
+    finally:
+        gc.enable()
+    return times
+
+
+def make_points():
+    rng = np.random.default_rng(42)  # seed
+    # shape (N, 2), float32 to match native expectations
+    return rng.uniform(0.0, 1000.0, size=(N, 2)).astype(np.float32)
+
+
+def build_original(pts: np.ndarray) -> QuadTree:
+    qt = QuadTree((0, 0, 1000, 1000), capacity=CAPACITY, max_depth=MAX_DEPTH)
+    qt.insert_many(pts)
+    return qt
+
+
+def main():
+    pts = make_points()
+    original_qt = build_original(pts)
+
+    # correctness baseline
+    base_count = original_qt.count_items()
+    assert base_count == N
+
+    # serialize timing
+    ser_times = timeit(lambda: original_qt.to_bytes())
+    qt_bytes = original_qt.to_bytes()
+    print(f"Serialized size: {len(qt_bytes):,} bytes")
+
+    # write once for the file path
+    fname = "quadtree_serialization.bin"
+    with Path(fname).open("wb") as f:
+        f.write(qt_bytes)
+
+    def rebuild_points():
+        qt = QuadTree((0, 0, 1000, 1000), capacity=CAPACITY, max_depth=MAX_DEPTH)
+        qt.insert_many(pts)
+        assert qt.count_items() == base_count
+        _ = qt.query((100, 100, 200, 200))
+        return qt
+
+    def rebuild_from_mem():
+        qt = QuadTree.from_bytes(qt_bytes)
+        assert qt.count_items() == base_count
+        _ = qt.query((100, 100, 200, 200))
+        return qt
+
+    def rebuild_from_file():
+        with Path(fname).open("rb") as f:
+            data = f.read()
+        qt = QuadTree.from_bytes(data)
+        assert qt.count_items() == base_count
+        _ = qt.query((100, 100, 200, 200))
+        return qt
+
+    t_points = timeit(rebuild_points)
+    t_mem = timeit(rebuild_from_mem)
+    t_file = timeit(rebuild_from_file)
+
+    Path(fname).unlink(missing_ok=True)
+
+    def show(label, arr):
+        print(
+            f"{label:<28} mean={stats.mean(arr):.6f}s  stdev={stats.pstdev(arr):.6f}s "
+        )
+
+    show("serialize to bytes", ser_times)
+    show("rebuild from points", t_points)
+    show("rebuild from bytes", t_mem)
+    show("rebuild from file", t_file)
+
+    # ----- Markdown summary -----
+    def fmt(x: float) -> str:
+        return f"{x:.6f}"
+
+    m_ser = stats.mean(ser_times)
+    m_pts = stats.mean(t_points)
+    m_mem = stats.mean(t_mem)
+    m_file = stats.mean(t_file)
+
+    s_ser = stats.pstdev(ser_times)
+    s_pts = stats.pstdev(t_points)
+    s_mem = stats.pstdev(t_mem)
+    s_file = stats.pstdev(t_file)
+
+    speedup_mem = m_pts / m_mem if m_mem > 0 else float("inf")
+    speedup_file = m_pts / m_file if m_file > 0 else float("inf")
+
+    md = f"""
+## Serialization vs Rebuild
+
+### Configuration
+- Points: {N:,}
+- Capacity: {CAPACITY}
+- Max depth: {MAX_DEPTH}
+- Repeats: {REPEATS}
+
+### Results
+
+| Variant | Mean (s) | Stdev (s) |
+|---|---:|---:|
+| Serialize to bytes | {fmt(m_ser)} | {fmt(s_ser)} |
+| Rebuild from points | {fmt(m_pts)} | {fmt(s_pts)} |
+| Rebuild from bytes | {fmt(m_mem)} | {fmt(s_mem)} |
+| Rebuild from file | {fmt(m_file)} | {fmt(s_file)} |
+
+### Summary
+
+- Rebuild from bytes is **{fmt(speedup_mem)}x** faster than reinserting points.
+- Rebuild from file is **{fmt(speedup_file)}x** faster than reinserting points.
+- Serialized blob size is **{len(qt_bytes):,} bytes**.
+"""
+    print(md.strip())
+
+
+if __name__ == "__main__":
+    main()

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/docs/benchmark.md

@@ -107,6 +107,31 @@ If your data is already in a NumPy array, using the `insert_many` method directl
 
 ---------
 
+## Serialization vs Rebuild
+
+### Configuration
+- Points: 1,000,000
+- Capacity: 64
+- Max depth: 10
+- Repeats: 7
+
+### Results
+
+| Variant | Mean (s) | Stdev (s) |
+|---|---:|---:|
+| Serialize to bytes | 0.021356 | 0.000937 |
+| Rebuild from points | 0.106783 | 0.011430 |
+| Rebuild from bytes | 0.021754 | 0.001687 |
+| Rebuild from file | 0.024887 | 0.001846 |
+
+### Summary
+
+- Rebuild from bytes is **4.908747x** faster than reinserting points.
+- Rebuild from file is **4.290712x** faster than reinserting points.
+- Serialized blob size is **13,770,328 bytes**.
+
+----------------
+
 ## System Info
 - **OS**: Windows 11 AMD64
 - **Python**: CPython 3.12.2
@@ -127,6 +152,7 @@ Then run:
 python benchmarks/cross_library_bench.py
 python benchmarks/benchmark_native_vs_shim.py 
 python benchmarks/benchmark_np_vs_list.py 
+python benchmarks/benchmark_serialization_vs_rebuild.py
 ```
 
 Check the CLI arguments for the cross-library benchmark in `benchmarks/quadtree_bench/main.py`.

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/docs/future_features.md

@@ -7,7 +7,7 @@ If you have any suggestions or would like to contribute, please feel free to ope
 
 ## Planned Features
 
-### 1. Quadtree serialization
+### 1. [COMPLETE] Quadtree serialization
 
 By serializing the quadtree, we can save its state to a file and load it later. This will allow us to persist the quadtree structure and data across sessions. For example, you could pre build a quadtree with all the walls in your video game level, serialize it to a file, and then load it when the game starts. This will heavily reduce the game load time since you won't have to rebuild the quadtree from scratch every time.
 

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/docs/index.md

@@ -41,6 +41,7 @@
 - Support for [inserting bounding boxes](api/rect_quadtree.md) or points
 - Fast KNN and range queries
 - Optional object tracking for id ↔ object mapping
+- Fast [serialization](benchmark.md#serialization-vs-rebuild) to/from bytes
 - [100% test coverage](https://codecov.io/gh/Elan456/fastquadtree) and CI on GitHub Actions
 
 ## Examples

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/interactive/interactive_v2.py

@@ -1,6 +1,7 @@
 import math
 import random
 from collections import deque
+from pathlib import Path
 
 import pygame
 
@@ -240,6 +241,7 @@ def hud(text_lines):
 # ------------------------------
 def handle_events(running, paused, show_nodes, show_nn, show_trails, zoom_target):
     """Handle discrete events like key presses and mouse clicks."""
+    global qtree
     for ev in pygame.event.get():
         if ev.type == pygame.QUIT:
             running = False
@@ -258,6 +260,21 @@ def handle_events(running, paused, show_nodes, show_nn, show_trails, zoom_target
                 zoom_target = clamp(zoom_target * ZOOM_FACTOR, ZOOM_MIN, ZOOM_MAX)
             elif ev.key in (pygame.K_MINUS, pygame.K_KP_MINUS):
                 zoom_target = clamp(zoom_target / ZOOM_FACTOR, ZOOM_MIN, ZOOM_MAX)
+            elif ev.key == pygame.K_c:
+                # Save quadtree state
+                data = qtree.to_bytes()
+                with Path("quadtree_state.bin").open("wb") as f:
+                    f.write(data)
+                print("Quadtree state saved to quadtree_state.bin")
+            elif ev.key == pygame.K_v:
+                # Load quadtree state
+                try:
+                    with Path("quadtree_state.bin").open("rb") as f:
+                        data = f.read()
+                    qtree = QuadTree.from_bytes(data)
+                    print("Quadtree state loaded from quadtree_state.bin")
+                except Exception as e:  # noqa: BLE001
+                    print(f"Failed to load quadtree state: {e}")
 
         elif ev.type == pygame.MOUSEWHEEL:
             if ev.y != 0:
@@ -436,6 +453,7 @@ def main():
                 f"zoom: {zoom:.2f}  target: {zoom_target:.2f}",
                 "WASD to pan. Mouse wheel or +/- to zoom.",
                 "arrow keys to resize rectangle.",
+                "c to save current state, v to load.",
                 "1 nodes. 2 NN rays. 3 trails. SPACE pause. L-click add. R-click remove (shift to repeat)",
             ]
         )

{fastquadtree-1.1.2 → fastquadtree-1.2.1}/pysrc/fastquadtree/_base_quadtree.py

@@ -1,6 +1,7 @@
 # _abc_quadtree.py
 from __future__ import annotations
 
+import pickle
 from abc import ABC, abstractmethod
 from typing import (
     TYPE_CHECKING,
@@ -58,8 +59,9 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
     def _new_native(self, bounds: Bounds, capacity: int, max_depth: int | None) -> Any:
         """Create the native engine instance."""
 
+    @staticmethod
     @abstractmethod
-    def _make_item(self, id_: int, geom: G, obj: Any | None) -> ItemType:
+    def _make_item(id_: int, geom: G, obj: Any | None) -> ItemType:
         """Build an ItemType from id, geometry, and optional object."""
 
     # ---- ctor ----
@@ -84,6 +86,91 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         self._next_id = 0
         self._count = 0
 
+    # ---- serialization ----
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Serialize the quadtree to a dict suitable for JSON or other serialization.
+
+        Returns:
+            Includes a binary 'core' key for the native engine state, plus other metadata such as bounds and capacity and the obj store if tracking is enabled.
+
+        Example:
+            ```python
+            state = qt.to_dict()
+            assert "core" in state and "bounds" in state
+            ```
+        """
+
+        core_bytes = self._native.to_bytes()
+
+        return {
+            "core": core_bytes,
+            "store": self._store.to_dict() if self._store is not None else None,
+            "bounds": self._bounds,
+            "capacity": self._capacity,
+            "max_depth": self._max_depth,
+            "track_objects": self._track_objects,
+            "next_id": self._next_id,
+            "count": self._count,
+        }
+
+    def to_bytes(self) -> bytes:
+        """
+        Serialize the quadtree to bytes.
+
+        Returns:
+            Bytes representing the serialized quadtree. Can be saved as a file or loaded with `from_bytes()`.
+
+        Example:
+            ```python
+            blob = qt.to_bytes()
+            with open("tree.fqt", "wb") as f:
+                f.write(blob)
+            ```
+        """
+        return pickle.dumps(self.to_dict())
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> _BaseQuadTree[G, HitT, ItemType]:
+        """
+        Deserialize a quadtree from bytes.
+
+        Args:
+            data: Bytes representing the serialized quadtree from `to_bytes()`.
+
+        Returns:
+            A new quadtree instance with the same state as when serialized.
+
+        Example:
+            ```python
+            blob = qt.to_bytes()
+            qt2 = type(qt).from_bytes(blob)
+            assert qt2.count_items() == qt.count_items()
+            ```
+        """
+        in_dict = pickle.loads(data)
+        core_bytes = in_dict["core"]
+        store_dict = in_dict["store"]
+
+        qt = cls.__new__(cls)  # type: ignore[call-arg]
+        qt._native = cls._new_native_from_bytes(core_bytes)
+
+        if store_dict is not None:
+            qt._store = ObjStore.from_dict(store_dict, qt._make_item)
+        else:
+            qt._store = None
+
+        # Extract bounds, capacity, max_depth from native
+        qt._bounds = in_dict["bounds"]
+        qt._capacity = in_dict["capacity"]
+        qt._max_depth = in_dict["max_depth"]
+        qt._next_id = in_dict["next_id"]
+        qt._count = in_dict["count"]
+        qt._track_objects = in_dict["track_objects"]
+
+        return qt
+
     # ---- internal helper ----
 
     def _ids_to_objects(self, ids: Iterable[int]) -> list[Any]:
@@ -107,6 +194,13 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
 
         Raises:
             ValueError: If geometry is outside the tree bounds.
+
+        Example:
+            ```python
+            id0 = point_qt.insert((10.0, 20.0))  # for point trees
+            id1 = rect_qt.insert((0.0, 0.0, 5.0, 5.0), obj="box")  # for rect trees
+            assert isinstance(id0, int) and isinstance(id1, int)
+            ```
         """
         if self._store is not None:
             # Reuse a dense free slot if available, else append
@@ -152,6 +246,17 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
 
         Raises:
             ValueError: If any geometry is outside bounds.
+
+        Example:
+            ```python
+            n = qt.insert_many([(1.0, 1.0), (2.0, 2.0)])
+            assert n == 2
+
+            import numpy as np
+            arr = np.array([[3.0, 3.0], [4.0, 4.0]], dtype=np.float32)
+            n2 = qt.insert_many(arr)
+            assert n2 == 2
+            ```
         """
         if type(geoms) is list and len(geoms) == 0:
             return 0
@@ -216,8 +321,19 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         """
         Delete an item by id and exact geometry.
 
+        Args:
+            id_: The id of the item to delete.
+            geom: The geometry of the item to delete.
+
         Returns:
             True if the item was found and deleted.
+
+        Example:
+            ```python
+            i = qt.insert((1.0, 2.0))
+            ok = qt.delete(i, (1.0, 2.0))
+            assert ok is True
+            ```
         """
         deleted = self._native.delete(id_, geom)
         if deleted:
@@ -230,6 +346,17 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         """
         Attach or replace the Python object for an existing id.
         Tracking must be enabled.
+
+        Args:
+            id_: The id of the item to attach the object to.
+            obj: The Python object to attach.
+
+        Example:
+            ```python
+            i = qt.insert((2.0, 3.0), obj=None)
+            qt.attach(i, {"meta": 123})
+            assert qt.get(i) == {"meta": 123}
+            ```
         """
         if self._store is None:
             raise ValueError("Cannot attach objects when track_objects=False")
@@ -242,6 +369,16 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
     def delete_by_object(self, obj: Any) -> bool:
         """
         Delete an item by Python object identity. Tracking must be enabled.
+
+        Args:
+            obj: The Python object to delete.
+
+        Example:
+            ```python
+            i = qt.insert((3.0, 4.0), obj="tag")
+            ok = qt.delete_by_object("tag")
+            assert ok is True
+            ```
         """
         if self._store is None:
             raise ValueError("Cannot delete by object when track_objects=False")
@@ -256,6 +393,13 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
 
         If tracking is enabled, the id -> object mapping is also cleared.
         The ids are reset to start at zero again.
+
+        Example:
+            ```python
+            _ = qt.insert((5.0, 6.0))
+            qt.clear()
+            assert qt.count_items() == 0 and len(qt) == 0
+            ```
         """
         self._native = self._new_native(self._bounds, self._capacity, self._max_depth)
         self._count = 0
@@ -266,6 +410,14 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
     def get_all_objects(self) -> list[Any]:
         """
         Return all tracked Python objects in the tree.
+
+        Example:
+            ```python
+            _ = qt.insert((7.0, 8.0), obj="a")
+            _ = qt.insert((9.0, 1.0), obj="b")
+            objs = qt.get_all_objects()
+            assert set(objs) == {"a", "b"}
+            ```
         """
         if self._store is None:
             raise ValueError("Cannot get objects when track_objects=False")
@@ -274,6 +426,13 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
     def get_all_items(self) -> list[ItemType]:
         """
         Return all Item wrappers in the tree.
+
+         Example:
+            ```python
+            _ = qt.insert((1.0, 1.0), obj=None)
+            items = qt.get_all_items()
+            assert hasattr(items[0], "id_") and hasattr(items[0], "geom")
+            ```
         """
         if self._store is None:
             raise ValueError("Cannot get items when track_objects=False")
@@ -282,12 +441,25 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
     def get_all_node_boundaries(self) -> list[Bounds]:
         """
         Return all node boundaries in the tree. Useful for visualization.
+
+        Example:
+            ```python
+            bounds = qt.get_all_node_boundaries()
+            assert isinstance(bounds, list)
+            ```
         """
         return self._native.get_all_node_boundaries()
 
     def get(self, id_: int) -> Any | None:
         """
         Return the object associated with id, if tracking is enabled.
+
+        Example:
+            ```python
+            i = qt.insert((1.0, 2.0), obj={"k": "v"})
+            obj = qt.get(i)
+            assert obj == {"k": "v"}
+            ```
         """
         if self._store is None:
             raise ValueError("Cannot get objects when track_objects=False")
@@ -297,6 +469,13 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
     def count_items(self) -> int:
         """
         Return the number of items currently in the tree (native count).
+
+        Example:
+            ```python
+            before = qt.count_items()
+            _ = qt.insert((2.0, 2.0))
+            assert qt.count_items() == before + 1
+            ```
         """
         return self._native.count_items()