fastquadtree 0.5.0__tar.gz → 0.5.1__tar.gz

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/.pre-commit-config.yaml

@@ -1,12 +1,15 @@
 repos:
-  # 0) Python formatter: black
-  - repo: https://github.com/psf/black
-    rev: 24.8.0
+  # 0) Python linter and formatter: Ruff
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.6.9
     hooks:
-      - id: black
-        name: black
-        language_version: python3
-        args: ["--line-length", "88"]
+      # Lint + autofix. If Ruff fixes something, the hook exits nonzero to force a re-run.
+      - id: ruff
+        name: ruff (lint + fix)
+        args: ["--fix", "--exit-non-zero-on-fix"]
+      # Code formatter (Black replacement)
+      - id: ruff-format
+        name: ruff (format)
 
   # Local hooks that run in sequence and do not receive file args
   - repo: local
@@ -28,10 +31,9 @@ repos:
         always_run: true
 
       # 3) Python tests under coverage
-      # This both runs pytest and generates .coverage data
       - id: pytest
         name: pytest (under coverage)
         entry: pytest
         language: system
         pass_filenames: false
-        always_run: true
+        always_run: true

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/Cargo.lock

@@ -22,7 +22,7 @@ checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
 
 [[package]]
 name = "fastquadtree"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "pyo3",
 ]

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fastquadtree"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 readme = "README.md"
 

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastquadtree
-Version: 0.5.0
+Version: 0.5.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Rust
@@ -11,6 +11,13 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: ruff>=0.6.0 ; extra == 'dev'
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1 ; extra == 'dev'
+Requires-Dist: coverage>=7.5 ; extra == 'dev'
+Requires-Dist: mypy>=1.10 ; extra == 'dev'
+Requires-Dist: build>=1.2.1 ; extra == 'dev'
+Provides-Extra: dev
 License-File: LICENSE
 Summary: Rust-accelerated quadtree for Python with fast inserts, range queries, and k-NN search.
 Keywords: quadtree,spatial-index,geometry,rust,pyo3,nearest-neighbor,k-nn
@@ -36,7 +43,8 @@ Project-URL: Issues, https://github.com/Elan456/fastquadtree/issues
 
 [![Rust core via PyO3](https://img.shields.io/badge/Rust-core%20via%20PyO3-orange)](https://pyo3.rs/)
 [![Built with maturin](https://img.shields.io/badge/Built%20with-maturin-1f6feb)](https://www.maturin.rs/)
-[![Code style: Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Lint and format: Ruff](https://img.shields.io/badge/Lint%20and%20format-Ruff-46a758?logo=ruff&logoColor=white)](https://docs.astral.sh/ruff/)
+
 
 
 ![Interactive_V2_Screenshot](https://raw.githubusercontent.com/Elan456/fastquadtree/main/assets/interactive_v2_screenshot.png)

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/README.md

@@ -13,7 +13,8 @@
 
 [![Rust core via PyO3](https://img.shields.io/badge/Rust-core%20via%20PyO3-orange)](https://pyo3.rs/)
 [![Built with maturin](https://img.shields.io/badge/Built%20with-maturin-1f6feb)](https://www.maturin.rs/)
-[![Code style: Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Lint and format: Ruff](https://img.shields.io/badge/Lint%20and%20format-Ruff-46a758?logo=ruff&logoColor=white)](https://docs.astral.sh/ruff/)
+
 
 
 ![Interactive_V2_Screenshot](https://raw.githubusercontent.com/Elan456/fastquadtree/main/assets/interactive_v2_screenshot.png)

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/benchmarks/benchmark_native_vs_shim.py

@@ -6,11 +6,11 @@ import gc
 import random
 import statistics as stats
 from time import perf_counter as now
+
 from tqdm import tqdm
 
-from fastquadtree._native import QuadTree as NativeQuadTree
 from fastquadtree import QuadTree as ShimQuadTree
-
+from fastquadtree._native import QuadTree as NativeQuadTree
 
 BOUNDS = (0.0, 0.0, 1000.0, 1000.0)
 CAPACITY = 20
@@ -68,9 +68,10 @@ def bench_shim(points, queries, *, track_objects: bool, with_objs: bool):
     return t_build, t_query
 
 
-def median_times(fn, points, queries, repeats: int):
+def median_times(fn, points, queries, repeats: int, desc: str = "Running"):
+    """Run benchmark multiple times and return median times."""
     builds, queries_t = [], []
-    for _ in tqdm(range(repeats)):
+    for _ in tqdm(range(repeats), desc=desc, unit="run"):
         gc.disable()
         b, q = fn(points, queries)
         gc.enable()
@@ -86,29 +87,47 @@ def main():
     ap.add_argument("--repeats", type=int, default=5)
     args = ap.parse_args()
 
+    print("Native vs Shim Benchmark")
+    print("=" * 50)
+    print("Configuration:")
+    print(f"  Points: {args.points:,}")
+    print(f"  Queries: {args.queries}")
+    print(f"  Repeats: {args.repeats}")
+    print()
+
     rng = random.Random(SEED)
     points = gen_points(args.points, rng)
     queries = gen_queries(args.queries, rng)
 
     # Warmup to load modules
+    print("Warming up...")
     _ = bench_native(points[:1000], queries[:50])
     _ = bench_shim(points[:1000], queries[:50], track_objects=False, with_objs=False)
+    print()
 
+    print("Running benchmarks...")
     n_build, n_query = median_times(
-        lambda pts, qs: bench_native(pts, qs), points, queries, args.repeats
+        lambda pts, qs: bench_native(pts, qs),
+        points,
+        queries,
+        args.repeats,
+        desc="Native",
     )
     s_build_no_map, s_query_no_map = median_times(
         lambda pts, qs: bench_shim(pts, qs, track_objects=False, with_objs=False),
         points,
         queries,
         args.repeats,
+        desc="Shim (no map)",
     )
     s_build_map, s_query_map = median_times(
         lambda pts, qs: bench_shim(pts, qs, track_objects=True, with_objs=True),
         points,
         queries,
         args.repeats,
+        desc="Shim (track+objs)",
     )
+    print()
 
     def fmt(x):
         return f"{x:.3f}"
@@ -131,7 +150,7 @@ def main():
 
 **Overhead vs Native**
 
-- No map: build {s_build_no_map / n_build:.2f}x, query {s_query_no_map / n_query:.2f}x, total {(s_build_no_map + s_query_no_map) / (n_build + n_query):.2f}x  
+- No map: build {s_build_no_map / n_build:.2f}x, query {s_query_no_map / n_query:.2f}x, total {(s_build_no_map + s_query_no_map) / (n_build + n_query):.2f}x
 - Track + objs: build {s_build_map / n_build:.2f}x, query {s_query_map / n_query:.2f}x, total {(s_build_map + s_query_map) / (n_build + n_query):.2f}x
 """
     print(md.strip())

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/benchmarks/quadtree_bench/__init__.py

@@ -6,8 +6,8 @@ implementations, including performance comparison, visualization, and analysis.
 """
 
 from .engines import Engine, get_engines
-from .runner import BenchmarkRunner, BenchmarkConfig
 from .plotting import PlotManager
+from .runner import BenchmarkConfig, BenchmarkRunner
 
 __version__ = "1.0.0"
-__all__ = ["Engine", "get_engines", "BenchmarkRunner", "BenchmarkConfig", "PlotManager"]
+__all__ = ["BenchmarkConfig", "BenchmarkRunner", "Engine", "PlotManager", "get_engines"]

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/benchmarks/quadtree_bench/engines.py

@@ -7,9 +7,11 @@ allowing fair comparison of their performance characteristics.
 
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
+from pyqtree import Index as PyQTree  # Pyqtree
+
 # Built-in engines (always available in this repo)
 from pyquadtree.quadtree import QuadTree as EPyQuadTree  # e-pyquadtree
-from pyqtree import Index as PyQTree  # Pyqtree
+
 from fastquadtree import QuadTree as RustQuadTree  # fastquadtree
 
 
@@ -67,7 +69,10 @@ def _create_e_pyquadtree_engine(
             _ = qt.query(q)
 
     return Engine(
-        "e-pyquadtree", "#1f77b4", build, query  # display name  # color (blue)
+        "e-pyquadtree",
+        "#1f77b4",
+        build,
+        query,  # display name  # color (blue)
     )
 
 
@@ -105,7 +110,10 @@ def _create_fastquadtree_engine(
             _ = qt.query(q)
 
     return Engine(
-        "fastquadtree", "#ff7f0e", build, query  # display name  # color (orange)
+        "fastquadtree",
+        "#ff7f0e",
+        build,
+        query,  # display name  # color (orange)
     )
 
 
@@ -165,7 +173,10 @@ def _create_nontree_engine(
             _ = tm.get_rect((xmin, ymin, xmax - xmin, ymax - ymin))
 
     return Engine(
-        "nontree-QuadTree", "#17becf", build, query  # display name  # color (cyan)
+        "nontree-QuadTree",
+        "#17becf",
+        build,
+        query,  # display name  # color (cyan)
     )
 
 
@@ -178,7 +189,7 @@ def _create_brute_force_engine(
         # Append each item as if they were being added separately
         out = []
         for p in points:
-            out.append(p)
+            out.append(p)  # noqa: PERF402
         return out
 
     def query(points, queries):
@@ -187,7 +198,10 @@ def _create_brute_force_engine(
             _ = [p for p in points if q[0] <= p[0] <= q[2] and q[1] <= p[1] <= q[3]]
 
     return Engine(
-        "Brute force", "#9467bd", build, query  # display name  # color (purple)
+        "Brute force",
+        "#9467bd",
+        build,
+        query,  # display name  # color (purple)
     )
 
 
@@ -213,8 +227,7 @@ def _create_rtree_engine(
         # Bulk stream loading is the fastest way to build
         # Keep the same 1x1 bbox convention used elsewhere for fairness
         stream = ((i, (x, y, x + 1, y + 1), None) for i, (x, y) in enumerate(points))
-        idx = rindex.Index(stream, properties=p)
-        return idx
+        return rindex.Index(stream, properties=p)
 
     def query(idx, queries):
         # Do not materialize results into a list, just consume the generator

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/benchmarks/quadtree_bench/main.py

@@ -10,8 +10,8 @@ import argparse
 from pathlib import Path
 
 from .engines import get_engines
-from .runner import BenchmarkRunner, BenchmarkConfig
 from .plotting import PlotManager
+from .runner import BenchmarkConfig, BenchmarkRunner
 
 
 def main():

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/benchmarks/quadtree_bench/plotting.py

@@ -5,7 +5,7 @@ This module handles creation of performance charts, graphs, and visualizations
 for benchmark results analysis.
 """
 
-from typing import Dict, Any, Tuple
+from typing import Any, Dict, Tuple
 
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
@@ -43,7 +43,7 @@ class PlotManager:
                         name=name,
                         legendgroup=name,
                         showlegend=show_legend,
-                        line=dict(color=color, width=3),
+                        line={"color": color, "width": 3},
                     ),
                     row=1,
                     col=col,
@@ -69,15 +69,15 @@ class PlotManager:
                 f"{self.config.n_queries} queries)"
             ),
             template="plotly_dark",
-            legend=dict(
-                orientation="v",
-                traceorder="normal",
-                xanchor="left",
-                x=0,
-                yanchor="top",
-                y=1,
-            ),
-            margin=dict(l=40, r=20, t=80, b=40),
+            legend={
+                "orientation": "v",
+                "traceorder": "normal",
+                "xanchor": "left",
+                "x": 0,
+                "yanchor": "top",
+                "y": 1,
+            },
+            margin={"l": 40, "r": 20, "t": 80, "b": 40},
             height=520,
         )
 
@@ -108,7 +108,7 @@ class PlotManager:
                         name=name,
                         legendgroup=name,
                         showlegend=False,
-                        line=dict(color=color, width=3),
+                        line={"color": color, "width": 3},
                     ),
                     row=1,
                     col=1,
@@ -122,7 +122,7 @@ class PlotManager:
                     name=name,
                     legendgroup=name,
                     showlegend=True,
-                    line=dict(color=color, width=3),
+                    line={"color": color, "width": 3},
                 ),
                 row=1,
                 col=2,
@@ -138,14 +138,14 @@ class PlotManager:
         fig.update_layout(
             title="Throughput",
             template="plotly_dark",
-            legend=dict(
-                orientation="h",
-                x=0,
-                xanchor="left",
-                y=1.08,  # above the subplots
-                yanchor="bottom",
-            ),
-            margin=dict(l=60, r=40, t=120, b=40),
+            legend={
+                "orientation": "h",
+                "x": 0,
+                "xanchor": "left",
+                "y": 1.08,  # above the subplots
+                "yanchor": "bottom",
+            },
+            margin={"l": 60, "r": 40, "t": 120, "b": 40},
             height=480,
         )
 
@@ -187,7 +187,7 @@ class PlotManager:
                 height=480,
             )
             print(f"Saved PNG images to {output_dir}/ with prefix '{output_prefix}'")
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001
             print(
                 f"Failed to save PNG images. Install kaleido to enable PNG export: {e}"
             )
@@ -227,7 +227,7 @@ class PlotManager:
                         x=config.experiments,
                         y=values,
                         name=f"{label} - {engine_name}",
-                        line=dict(color=color, width=3),
+                        line={"color": color, "width": 3},
                         mode="lines+markers",
                     )
                 )
@@ -237,7 +237,7 @@ class PlotManager:
             xaxis_title="Number of points",
             yaxis_title="Time (s)" if "rate" not in metric else "Ops/sec",
             template="plotly_dark",
-            legend=dict(orientation="v"),
+            legend={"orientation": "v"},
             height=600,
         )
 

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/benchmarks/quadtree_bench/runner.py

@@ -11,7 +11,7 @@ import random
 import statistics as stats
 from dataclasses import dataclass
 from time import perf_counter as now
-from typing import Dict, List, Tuple, Any
+from typing import Any, Dict, List, Tuple
 
 from tqdm import tqdm
 
@@ -35,8 +35,7 @@ class BenchmarkConfig:
         self.experiments = [2, 4, 8, 16]
         while self.experiments[-1] < self.max_experiment_points:
             self.experiments.append(int(self.experiments[-1] * 2))
-        if self.experiments[-1] > self.max_experiment_points:
-            self.experiments[-1] = self.max_experiment_points
+        self.experiments[-1] = min(self.experiments[-1], self.max_experiment_points)
 
 
 class BenchmarkRunner:
@@ -98,6 +97,44 @@ class BenchmarkRunner:
         cleaned = [x for x in vals if isinstance(x, (int, float)) and not math.isnan(x)]
         return stats.median(cleaned) if cleaned else math.nan
 
+    def _print_experiment_summary(
+        self, n: int, results: Dict[str, Any], exp_idx: int
+    ) -> None:
+        """Print a summary of results for the current experiment."""
+
+        def fmt(x):
+            return f"{x:.3f}" if not math.isnan(x) else "nan"
+
+        # Get the results for this experiment (last index)
+        total = results["total"]
+        build = results["build"]
+        query = results["query"]
+
+        # Find the fastest engine for this experiment
+        valid_engines = [
+            (name, total[name][exp_idx])
+            for name in total
+            if not math.isnan(total[name][exp_idx])
+        ]
+
+        if not valid_engines:
+            return
+
+        fastest = min(valid_engines, key=lambda x: x[1])
+
+        print(f"\n  📊 Results for {n:,} points:")
+        print(f"     Fastest: {fastest[0]} ({fmt(fastest[1])}s total)")
+
+        # Show top 3 performers
+        sorted_engines = sorted(valid_engines, key=lambda x: x[1])[:3]
+        for rank, (name, time) in enumerate(sorted_engines, 1):
+            b = build[name][exp_idx]
+            q = query[name][exp_idx]
+            print(
+                f"     {rank}. {name:15} build={fmt(b)}s, query={fmt(q)}s, total={fmt(time)}s"
+            )
+        print()
+
     def run_benchmark(self, engines: Dict[str, Engine]) -> Dict[str, Any]:
         """
         Run complete benchmark suite.
@@ -109,13 +146,11 @@ class BenchmarkRunner:
             Dictionary containing benchmark results
         """
         # Warmup on a small set to JIT caches, etc.
+        print("Warming up engines...")
         warmup_points = self.generate_points(2_000)
         warmup_queries = self.generate_queries(self.config.n_queries)
         for engine in engines.values():
-            try:
-                self.benchmark_engine_once(engine, warmup_points, warmup_queries)
-            except Exception:
-                pass  # Ignore warmup failures
+            self.benchmark_engine_once(engine, warmup_points, warmup_queries)
 
         # Initialize result containers
         results = {
@@ -127,9 +162,18 @@ class BenchmarkRunner:
         }
 
         # Run experiments
-        iterator = tqdm(self.config.experiments, desc="Experiments", unit="points")
-        for n in iterator:
-            iterator.set_postfix({"points": n})
+        print(
+            f"\nRunning {len(self.config.experiments)} experiments with {len(engines)} engines..."
+        )
+        experiment_bar = tqdm(
+            self.config.experiments, desc="Experiments", unit="exp", position=0
+        )
+
+        for exp_idx, n in enumerate(experiment_bar):
+            experiment_bar.set_description(
+                f"Experiment {exp_idx + 1}/{len(self.config.experiments)}"
+            )
+            experiment_bar.set_postfix({"points": f"{n:,}"})
 
             # Generate data for this experiment
             exp_rng = random.Random(10_000 + n)
@@ -139,24 +183,45 @@ class BenchmarkRunner:
             # Collect results across repeats
             engine_times = {name: {"build": [], "query": []} for name in engines}
 
+            # Progress bar for engines x repeats
+            total_iterations = len(engines) * self.config.repeats
+            engine_bar = tqdm(
+                total=total_iterations,
+                desc="  Testing engines",
+                unit="run",
+                position=1,
+                leave=False,
+            )
+
             for repeat in range(self.config.repeats):
                 gc.disable()
 
                 # Benchmark each engine
                 for name, engine in engines.items():
+                    engine_bar.set_description(
+                        f"  {name} (repeat {repeat + 1}/{self.config.repeats})"
+                    )
+
                     try:
                         build_time, query_time = self.benchmark_engine_once(
                             engine, points, queries
                         )
-                    except Exception:
+                    except Exception as e:  # noqa: BLE001
                         # Mark as failed for this repeat
+                        print(
+                            f"  {name} (repeat {repeat + 1}/{self.config.repeats}) failed: {e}"
+                        )
                         build_time, query_time = math.nan, math.nan
 
                     engine_times[name]["build"].append(build_time)
                     engine_times[name]["query"].append(query_time)
 
+                    engine_bar.update(1)
+
                 gc.enable()
 
+            engine_bar.close()
+
             # Calculate medians and derived metrics
             for name in engines:
                 build_median = self.median_or_nan(engine_times[name]["build"])
@@ -184,6 +249,11 @@ class BenchmarkRunner:
                 results["insert_rate"][name].append(insert_rate)
                 results["query_rate"][name].append(query_rate)
 
+            # Print intermediate results for this experiment
+            self._print_experiment_summary(n, results, exp_idx)
+
+        experiment_bar.close()
+
         # Add metadata to results
         results["engines"] = engines
         results["config"] = self.config
@@ -227,7 +297,7 @@ class BenchmarkRunner:
             t = total[name][i]
             if math.isnan(pyqt_total) or math.isnan(t) or t <= 0:
                 return "n/a"
-            return f"{(pyqt_total / t):.2f}×"
+            return f"{(pyqt_total / t):.2f}×"  # noqa: RUF001
 
         for name in ranked:
             b = build.get(name, [math.nan])[i] if name in build else math.nan

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/benchmarks/runner.py

@@ -6,14 +6,7 @@ This script can be run directly or imported as a module.
 """
 
 import sys
-from pathlib import Path
 
-# Add the benchmarks directory to Python path for imports
-benchmark_dir = Path(__file__).parent
-if str(benchmark_dir) not in sys.path:
-    sys.path.insert(0, str(benchmark_dir))
-
-# Now we can import the package
 from quadtree_bench.main import main, run_quick_benchmark
 
 if __name__ == "__main__":

{fastquadtree-0.5.0 → fastquadtree-0.5.1}/interactive/interactive.py

@@ -1,6 +1,9 @@
-from fastquadtree import QuadTree
-import pygame
 import random
+import sys
+
+import pygame
+
+from fastquadtree import QuadTree
 
 screen = pygame.display.set_mode((1000, 1000))
 
@@ -81,7 +84,7 @@ def interactive_test():
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 pygame.quit()
-                quit()
+                sys.exit()
 
             if event.type == pygame.MOUSEBUTTONDOWN:
                 x, y = pygame.mouse.get_pos()
@@ -90,9 +93,12 @@ def interactive_test():
                 qtree.insert((x, y), obj=Ball(x, y))
                 # print("New total number of nodes: ", len(qtree.get_all_bbox()))
 
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
-                if closest_to_mouse:
-                    qtree.delete_by_object(closest_to_mouse.obj)
+            if (
+                event.type == pygame.KEYDOWN
+                and event.key == pygame.K_SPACE
+                and closest_to_mouse
+            ):
+                qtree.delete_by_object(closest_to_mouse.obj)
 
         # If right arrow down, move the query area to the right
         if pygame.key.get_pressed()[pygame.K_RIGHT]: