spatial-graph 0.0.1__py3-none-any.whl

spatial_graph/rtree/src/rtree.h

@@ -0,0 +1,97 @@
+// Copyright 2023 Joshua J Baker. All rights reserved.
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+
+#ifndef RTREE_H
+#define RTREE_H
+
+#include <stdlib.h>
+#include "config.h"
+
+// rtree_new returns a new rtree
+//
+// Returns NULL if the system is out of memory.
+struct rtree *rtree_new(void);
+
+
+// rtree_new returns a new rtree using a custom allocator
+//
+// Returns NULL if the system is out of memory.
+struct rtree *rtree_new_with_allocator(void *(*malloc)(size_t), void (*free)(void*));
+
+// rtree_free frees an rtree
+void rtree_free(struct rtree *tr);
+
+// rtree_clone makes an instant copy of the btree.
+//
+// This operation uses shadowing / copy-on-write.
+struct rtree *rtree_clone(struct rtree *tr);
+
+// rtree_insert inserts an item into the rtree.
+//
+// This operation performs a copy of the data that is pointed to in the second
+// and third arguments. The R-tree expects a rectangle, which is two arrays of
+// coord_ts. The first N values as the minimum corner of the rect, and the next
+// N values as the maximum corner of the rect, where N is the number of
+// dimensions.
+//
+// When inserting points, the max coordinates is optional (set to NULL).
+//
+// Returns false if the system is out of memory.
+bool rtree_insert(struct rtree *tr, const coord_t *min, const coord_t *max, const item_t item);
+
+
+// rtree_search searches the rtree and iterates over each item that intersect
+// the provided rectangle.
+//
+// Returning false from the iter will stop the search.
+void rtree_search(const struct rtree *tr, const coord_t *min, const coord_t *max,
+	bool (*iter)(const coord_t *min, const coord_t *max, const item_t item, void *udata),
+	void *udata);
+
+// Find the nearest neighbors to the given query point.
+//
+// Returning false from the iter will stop the search.
+bool rtree_nearest(struct rtree *tr, const coord_t *point,
+	bool (*iter)(const item_t item, coord_t distance, void *udata),
+	void *udata);
+
+// rtree_scan iterates over every item in the rtree.
+//
+// Returning false from the iter will stop the scan.
+void rtree_scan(const struct rtree *tr,
+	bool (*iter)(const coord_t *min, const coord_t *max, const item_t item, void *udata),
+	void *udata);
+
+// rtree_count returns the number of items in the rtree.
+size_t rtree_count(const struct rtree *tr);
+
+// query the total bounding box of the rtree
+void rtree_bb(const struct rtree *tr, coord_t* min, coord_t* max);
+
+// rtree_delete deletes an item from the rtree.
+//
+// This searches the tree for an item that is contained within the provided
+// rectangle, and perform a binary comparison of its data to the provided
+// data. The first item that is found is deleted.
+//
+// Returns the number of deleted items (0 or 1) or -1 if an OOM error occured.
+int rtree_delete(struct rtree *tr, const coord_t *min, const coord_t *max, const item_t item);
+
+// rtree_delete_with_comparator deletes an item from the rtree.
+// This searches the tree for an item that is contained within the provided
+// rectangle, and perform a comparison of its data to the provided data using
+// a compare function. The first item that is found is deleted.
+//
+// Returns false if the system is out of memory.
+bool rtree_delete_with_comparator(struct rtree *tr, const coord_t *min,
+	const coord_t *max, const item_t item,
+	int (*compare)(const item_t a, const item_t b, void *udata),
+	void *udata);
+
+// rtree_opt_relaxed_atomics activates memory_order_relaxed for all atomic
+// loads. This may increase performance for single-threaded programs.
+// Optionally, define RTREE_NOATOMICS to disbale all atomics.
+void rtree_opt_relaxed_atomics(struct rtree *tr);
+
+#endif // RTREE_H

spatial_graph/rtree/wrapper_template.pyx

@@ -0,0 +1,356 @@
+from libc.stdint cimport *
+import numpy as np
+
+
+ctypedef int bool
+
+cdef extern from *:
+    """
+    typedef int bool;
+    #define false 0
+    #define true 1
+
+    %if $c_distance_function
+    #define KNN_USE_EXACT_DISTANCE
+    %end if
+    #define DIMS $dims
+
+    typedef $coord_dtype.to_pyxtype() coord_t;
+    typedef $item_dtype.base_c_type item_base_t;
+    %if $item_dtype.is_array
+    typedef item_base_t pyx_item_t[$item_dtype.size];
+    %else
+    typedef item_base_t pyx_item_t;
+    %end if
+    typedef pyx_item_t* pyx_items_t;
+
+    %if $c_item_t_declaration
+    $c_item_t_declaration
+    %else
+    %if $item_dtype.is_array
+    typedef struct item_t {
+        item_base_t data[$item_dtype.size];
+    } item_t;
+    %else
+    typedef item_base_t item_t;
+    %end if
+    %end if
+
+    %if $c_equal_function
+    $c_equal_function
+    %else
+    inline bool equal(const item_t a, const item_t b) {
+    %if $item_dtype.is_array
+        return memcmp(&a, &b, sizeof(item_t));
+    %else
+        return a == b;
+    %end if
+    }
+    %end if
+
+    #include "src/rtree.h"
+    #include "src/rtree.c"
+
+    %if $c_converter_functions
+    $c_converter_functions
+    %else
+    %if $item_dtype.is_array
+    inline item_t convert_pyx_to_c_item(pyx_item_t *pyx_item, coord_t *min, coord_t *max) {
+        item_t c_item;
+        memcpy(&c_item, *pyx_item, sizeof(item_t));
+        return c_item;
+    }
+    inline void copy_c_to_pyx_item(const item_t c_item, pyx_item_t *pyx_item) {
+        memcpy(pyx_item, &c_item, sizeof(item_t));
+    }
+    %else
+    // default PYX<->C converters, just casting
+    inline item_t convert_pyx_to_c_item(pyx_item_t *pyx_item, coord_t *min, coord_t *max) {
+        return (item_t)*pyx_item;
+    }
+    inline void copy_c_to_pyx_item(const item_t c_item, pyx_item_t *pyx_item) {
+        memcpy(pyx_item, &c_item, sizeof(item_t));
+    }
+    %end if
+    %end if
+
+    %if $c_distance_function
+    $c_distance_function
+    %end if
+    """
+    cdef enum:
+        DIMS = $dims
+    ctypedef $coord_dtype.to_pyxtype() coord_t
+    ctypedef $item_dtype.base_c_type item_base_t
+    %if $item_dtype.is_array
+    ctypedef item_base_t pyx_item_t[$item_dtype.size]
+    %else
+    ctypedef item_base_t pyx_item_t
+    %end if
+    ctypedef pyx_item_t* pyx_items_t
+
+    %if $pyx_item_t_declaration
+    $pyx_item_t_declaration
+    %else
+    %if $item_dtype.is_array
+    # item_t can't be an array in rtree, arrays can't be assigned to (and this
+    # is needed inside rtree). So we make item_t a struct with field `data` to
+    # hold the array.
+    cdef struct item_t:
+        item_base_t data[$item_dtype.size]
+    %else
+    ctypedef item_base_t item_t
+    %end if
+    %end if
+
+    # PYX <-> C converters
+    cdef item_t convert_pyx_to_c_item(pyx_item_t *pyx_item, coord_t *min, coord_t* max)
+    cdef void copy_c_to_pyx_item(const item_t c_item, pyx_item_t *pyx_item)
+
+    # rtree API
+    cdef struct rtree
+    cdef rtree *rtree_new()
+    cdef void rtree_free(rtree *tr)
+    cdef bool rtree_insert(
+        rtree *tr,
+        const coord_t *min,
+        const coord_t *max,
+        const item_t item)
+    cdef void rtree_search(
+        const rtree *tr,
+        const coord_t *min,
+        const coord_t *max,
+        bool (*iter)(
+            const coord_t *min,
+            const coord_t *max,
+            const item_t item,
+            void *udata),
+        void *udata)
+    cdef bool rtree_nearest(
+        rtree *tr,
+        const coord_t *point,
+        bool (*iter)(
+            const item_t item,
+            coord_t distance,
+            void *udata),
+        void *udata)
+    cdef int rtree_delete(
+        rtree *tr,
+        const coord_t *min,
+        const coord_t *max,
+        const item_t item)
+    cdef size_t rtree_count(const rtree *tr)
+    cdef void rtree_bb(const rtree *tr, coord_t *min, coord_t *max)
+
+
+cdef pyx_items_t memview_to_pyx_items_t($item_dtype.to_pyxtype(add_dim=True) items):
+    # implementation depends on dimension of item
+    %if $item_dtype.is_array
+    return <pyx_items_t>&items[0, 0]
+    %else
+    return <pyx_items_t>&items[0]
+    %end if
+
+
+cdef bint count_iterator(
+        const coord_t* bb_min,
+        const coord_t* bb_max,
+        const item_t item,
+        void* udata
+    ) noexcept:
+
+    cdef size_t* count = <size_t*>udata
+    count[0] = count[0] + 1
+    return True
+
+
+cdef struct search_results:
+    size_t size
+    pyx_items_t items
+
+
+cdef init_search_results_from_memview(search_results* r, $item_dtype.to_pyxtype(add_dim=True) items):
+    r.size = 0
+    r.items = memview_to_pyx_items_t(items)
+
+
+cdef bint search_iterator(
+        const coord_t* bb_min,
+        const coord_t* bb_max,
+        const item_t item,
+        void* udata
+    ) noexcept:
+
+    cdef search_results* results = <search_results*>udata
+    copy_c_to_pyx_item(item, &results.items[results.size])
+    results.size += 1
+    return True
+
+
+cdef struct nearest_results:
+    size_t size
+    size_t max_size
+    pyx_items_t items
+    coord_t *distances
+
+
+cdef init_nearest_results_from_memview(nearest_results* r,
+                                       $item_dtype.to_pyxtype(add_dim=True) items,
+                                       coord_t[::1] distances):
+    r.size = 0
+    r.max_size = len(items)
+    r.items = memview_to_pyx_items_t(items)
+    r.distances = &distances[0] if distances is not None else NULL
+
+
+cdef bint nearest_iterator(
+        const item_t item,
+        coord_t distance,
+        void* udata
+    ) noexcept:
+
+    cdef nearest_results* results = <nearest_results*>udata
+    copy_c_to_pyx_item(item, &results.items[results.size])
+    if results.distances != NULL:
+        results.distances[results.size] = distance
+    results.size += 1
+    return results.size < results.max_size
+
+
+cdef class RTree:
+
+    cdef rtree* _rtree
+
+    def __cinit__(self):
+        self._rtree = rtree_new()
+
+    def __dealloc__(self):
+        rtree_free(self._rtree)
+
+    def insert_point_items(
+            self,
+            $item_dtype.to_pyxtype(add_dim=True) items,
+            coord_t[:, ::1] points
+    ):
+
+        cdef pyx_items_t pyx_items = memview_to_pyx_items_t(items)
+
+        for i in range(len(items)):
+            rtree_insert(
+                self._rtree,
+                &points[i, 0],
+                NULL,
+                convert_pyx_to_c_item(&pyx_items[i], &points[i, 0], NULL))
+
+    def insert_bb_items(
+            self,
+            $item_dtype.to_pyxtype(add_dim=True) items,
+            coord_t[:, ::1] bb_mins,
+            coord_t[:, ::1] bb_maxs
+    ):
+
+        cdef pyx_items_t pyx_items = memview_to_pyx_items_t(items)
+
+        for i in range(len(items)):
+            rtree_insert(
+                self._rtree,
+                &bb_mins[i, 0],
+                &bb_maxs[i, 0],
+                convert_pyx_to_c_item(&pyx_items[i], &bb_mins[i, 0], &bb_maxs[i, 0]))
+
+    def count(self, coord_t[::1] bb_min, coord_t[::1] bb_max):
+
+        cdef size_t num = 0
+        rtree_search(
+            self._rtree,
+            &bb_min[0],
+            &bb_max[0],
+            &count_iterator,
+            &num)
+
+        return num
+
+    def bounding_box(self):
+        bb_min = np.empty(($dims,), dtype="$coord_dtype.base")
+        bb_max = np.empty(($dims,), dtype="$coord_dtype.base")
+        cdef coord_t[::1] _bb_min = bb_min
+        cdef coord_t[::1] _bb_max = bb_max
+        rtree_bb(self._rtree, &_bb_min[0], &_bb_max[0])
+        return (bb_min, bb_max)
+
+    def search(self, coord_t[::1] bb_min, coord_t[::1] bb_max):
+
+        cdef search_results results
+        cdef size_t num_results = self.count(bb_min, bb_max)
+
+        items = np.zeros((num_results, $item_dtype.size), dtype="$item_dtype.base")
+        if num_results == 0:
+            return items
+        init_search_results_from_memview(&results, items)
+
+        rtree_search(
+            self._rtree,
+            &bb_min[0],
+            &bb_max[0],
+            &search_iterator,
+            &results)
+
+        return items
+
+    def nearest(self, coord_t[::1] point, size_t k, return_distances=False):
+
+        cdef nearest_results results
+
+        items = np.zeros((k, $item_dtype.size), dtype="$item_dtype.base")
+        if return_distances:
+            distances = np.zeros((k,), dtype="$coord_dtype.base")
+        else:
+            distances = None
+        if k == 0:
+            return items
+        init_nearest_results_from_memview(&results, items, distances)
+
+        all_good = rtree_nearest(
+            self._rtree,
+            &point[0],
+            &nearest_iterator,
+            &results)
+
+        if not all_good:
+            raise RuntimeError("RTree nearest neighbor search ran out of memory.")
+
+        if return_distances:
+            return items[:results.size], distances[:results.size]
+        else:
+            return items[:results.size]
+
+    def delete_items(
+            self,
+            $item_dtype.to_pyxtype(add_dim=True) items,
+            coord_t[:, ::1] bb_mins,
+            coord_t[:, ::1] bb_maxs=None
+        ):
+
+        if bb_maxs is None:
+            bb_maxs = bb_mins
+
+        cdef pyx_items_t pyx_items = memview_to_pyx_items_t(items)
+
+        total_deleted = 0
+        for i in range(len(items)):
+            num_deleted = rtree_delete(
+                self._rtree,
+                &bb_mins[i, 0],
+                &bb_maxs[i, 0],
+                convert_pyx_to_c_item(&pyx_items[i], &bb_mins[i, 0], &bb_maxs[i, 0]))
+            if num_deleted == -1:
+                raise RuntimeError("RTree delete ran out of memory.")
+            if num_deleted == 0:
+                print(f"Item {pyx_items[i]} not deleted!")
+            total_deleted += num_deleted
+
+        return total_deleted
+
+    def __len__(self):
+
+        return rtree_count(self._rtree)

spatial_graph/spatial_graph.py

@@ -0,0 +1,95 @@
+from .graph import Graph
+from .rtree import PointRTree, LineRTree
+from .dtypes import DType
+import numpy as np
+
+
+class SpatialGraph(Graph):
+    edge_inclusion_values = ["incident", "leaving", "entering"]
+
+    def __init__(
+        self,
+        ndims,
+        node_dtype,
+        node_attr_dtypes,
+        edge_attr_dtypes,
+        position_attr,
+        directed=False,
+    ):
+        if position_attr not in node_attr_dtypes:
+            raise ValueError(
+                f"position attribute {position_attr!r} not defined in 'node_attr_dtypes'"
+            )
+        super().__init__(node_dtype, node_attr_dtypes, edge_attr_dtypes, directed)
+
+        self.ndims = ndims
+        self.position_attr = position_attr
+        self.coord_dtype = DType(node_attr_dtypes[position_attr]).base
+        self._node_rtree = PointRTree(node_dtype, self.coord_dtype, ndims)
+        self._edge_rtree = LineRTree(f"{node_dtype}[2]", self.coord_dtype, ndims)
+
+    def add_node(self, node, **kwargs):
+        position = self._get_position(kwargs)
+        self._node_rtree.insert_point_item(node, position)
+        super().add_node(node, **kwargs)
+
+    def add_nodes(self, nodes, **kwargs):
+        positions = self._get_position(kwargs)
+        self._node_rtree.insert_point_items(nodes, positions)
+        super().add_nodes(nodes, **kwargs)
+
+    def add_edge(self, edge, **kwargs):
+        edge = np.array(edge, dtype=self.node_dtype)
+        position_u = getattr(self.node_attrs[edge[0]], self.position_attr)
+        position_v = getattr(self.node_attrs[edge[1]], self.position_attr)
+        self._edge_rtree.insert_line(edge, position_u, position_v)
+        super().add_edge(edge, **kwargs)
+
+    def add_edges(self, edges, **kwargs):
+        starts = getattr(self.node_attrs[edges[:, 0]], self.position_attr)
+        ends = getattr(self.node_attrs[edges[:, 1]], self.position_attr)
+        self._edge_rtree.insert_lines(edges, starts, ends)
+        super().add_edges(edges, **kwargs)
+
+    @property
+    def roi(self):
+        return self._node_rtree.bounding_box()
+
+    def query_nodes_in_roi(self, roi):
+        return self._node_rtree.search(roi[0], roi[1])
+
+    def query_edges_in_roi(self, roi):
+        return self._edge_rtree.search(roi[0], roi[1])
+
+    def query_nearest_nodes(self, point, k, return_distances=False):
+        return self._node_rtree.nearest(point, k, return_distances)
+
+    def query_nearest_edges(self, point, k, return_distances=False):
+        return self._edge_rtree.nearest(point, k, return_distances)
+
+    @property
+    def nodes(self):
+        return super().nodes()
+
+    @property
+    def edges(self):
+        return self.query_edges_in_roi(self.roi)
+
+    def remove_nodes(self, nodes):
+        positions = getattr(self.node_attrs[nodes], self.position_attr)
+        self._node_rtree.delete_items(nodes, positions)
+        if not self.directed:
+            edges = self.edges_by_nodes(nodes)
+        else:
+            edges = np.concatenate(
+                self.in_edges_by_nodes(nodes), self.out_edges_by_nodes(nodes)
+            )
+        positions_u = getattr(self.node_attrs[edges[:, 0]], self.position_attr)
+        positions_v = getattr(self.node_attrs[edges[:, 1]], self.position_attr)
+        self._edge_rtree.delete_items(edges, positions_u, positions_v)
+        super().remove_nodes(nodes)
+
+    def _get_position(self, kwargs):
+        if self.position_attr in kwargs:
+            return kwargs[self.position_attr]
+        raise RuntimeError(f"position attribute '{self.position_attr}' not given")

spatial_graph-0.0.1.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: spatial-graph
+Version: 0.0.1
+Summary: A spatial graph datastructure for python.
+Project-URL: homepage, https://github.com/funkelab/spatial_graph
+Project-URL: repository, https://github.com/funkelab/spatial_graph
+Author-email: Jan Funke <funkej@janelia.hhmi.org>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: cheetah3
+Requires-Dist: numpy
+Requires-Dist: setuptools>=75.8.0
+Requires-Dist: witty>=v0.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# spatial_graph
+
+[![CI](https://github.com/funkelab/spatial_graph/actions/workflows/ci.yaml/badge.svg)](https://github.com/funkelab/spatial_graph/actions/workflows/ci.yaml)
+
+`spatial_graph` provides a data structure for directed and undirected graphs,
+where each node has an nD position (in time or space).
+
+Design Principles
+=================
+
+Goals
+-----
+
+* support for arbitrary number of dimensions
+* typed node identifiers and attributes
+    * any fixed-length type that is supported by `numpy`
+* efficient node/edge queries by
+    * ROI
+    * kNN (by points / lines)
+* numpy-like interface for efficient:
+    * graph population and manipulation
+    * query results
+    * attribute access
+* minimal memory footprint
+* minimal dependencies
+    * `cython` / `witty` / `cheetah3` for runtime compilation
+    * numpy for array interfaces
+* PYX API for graph algorithms in C/C++
+
+Non-Goals
+---------
+
+* graph algorithms
+* I/O
+* non-typed arguments
+* non-spatial graphs
+* out-of-memory support
+* networkx compatibility
+
+Python API
+==========
+
+Graph creation:
+
+```python
+graph = sg.SpatialGraph(
+    ndims=3,
+    node_dtype="uint64",
+    node_attr_dtypes={"position": "double[3]"},
+    edge_attr_dtypes={"score": "float32"},
+    position_attr="position",
+    directed=False,
+)
+```
+
+Adding nodes/edges:
+
+```python
+graph.add_nodes(
+    np.array([1, 2, 3, 4, 5], dtype="uint64"),
+    position=np.array(
+        [
+            [0.1, 0.1, 0.1],
+            [0.2, 0.2, 0.2],
+            [0.3, 0.3, 0.3],
+            [0.4, 0.4, 0.4],
+            [0.5, 0.5, 0.5],
+        ],
+        dtype="double",
+    ),
+)
+
+graph.add_edges(
+    np.array([[1, 2], [3, 4], [5, 1]], dtype="uint64"),
+    score=np.array([0.2, 0.3, 0.4], dtype="float32"),
+)
+```
+
+Query nodes/edges in ROI:
+
+```python
+# nodes/edges will be numpy arrays of dtype uint64 and shape (n,)/(n, 2)
+nodes = graph.query_nodes_in_roi(np.array([[0.0, 0.0, 0.0], [0.25, 0.25, 0.25]]))
+edges = graph.query_edges_in_roi(np.array([[0.0, 0.0, 0.0], [0.25, 0.25, 0.25]]))
+```
+
+Query nodes/edges by position:
+
+```python
+nodes = graph.query_nearest_nodes(np.array([0.3, 0.3, 0.3]), k=3)
+edges = graph.query_nearest_edges(np.array([0.3, 0.3, 0.3]), k=3)
+```
+
+Access node/edge attributes:
+
+```python
+node_positions = graph.node_attrs[nodes].position
+edge_scores = graph.edge_attrs[edges].score
+```
+
+Delete nodes/edges:
+
+```python
+graph.remove_nodes(nodes[:1000])
+```
+
+Implementation Details
+======================
+
+A `SpatialGraph` consists of three data structures:
+* The `Graph` itself, holding nodes, edges, and their attributes ([graphlite](https://github.com/haasdo95/graphlite)).
+* Two R-trees for spatial node and edge queries (based on [rtree.c](https://github.com/tidwall/rtree.c)).

spatial_graph-0.0.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+spatial_graph/__init__.py,sha256=pxk-5VDpsCozjvu7hxBODsfOktnslCoHz2ZDFkMjgj4,358
+spatial_graph/dtypes.py,sha256=doDBC6ytT0maH8xL4mxDGhZj_MaTGWDoismuKA7zxDw,4110
+spatial_graph/spatial_graph.py,sha256=yFf_7fucdwPBSVY0NvRZQAbK4hr8q3Gqzx16spl3Qzg,3528
+spatial_graph/graph/__init__.py,sha256=IiYvwf3SFD6a8CM-EuVPf-ljAAQp-iFyjIx3bMxvuAs,46
+spatial_graph/graph/graph.py,sha256=yrHiWu_MwAjksQQ_JNg5wz32RUig-uDfPDfrr0jE_Ho,8050
+spatial_graph/graph/wrapper_template.pyx,sha256=P9yXWFKOm0cF8Gyc_arMaGHIPHKItOmWf3SLymY2sMo,20065
+spatial_graph/graph/src/LICENSE.txt,sha256=VGv2QnX5wQ9uezPVb1HoLKPGpwSa3gN3TnCH16moz6k,1050
+spatial_graph/graph/src/graph_lite.h,sha256=DYQbILPOyfHRJK8Bo5uuQ2ST1o99axWHLZLhqcXuxQQ,67913
+spatial_graph/rtree/__init__.py,sha256=WQlRnGUdl0PqBuce0tetIRHAEjegH3QW9ZUTD7420KQ,110
+spatial_graph/rtree/line_rtree.py,sha256=tx31eCzULcJ35N1XEu4448p8qLylv_zuNFs8bn3kFEQ,4260
+spatial_graph/rtree/point_rtree.py,sha256=o5acJoSFYWNoJGTBFhGs24zIK4bVHUgRgKxmTVs_RxQ,102
+spatial_graph/rtree/rtree.py,sha256=sR2L7f0hhpk9HLJ8xLMGM6FmYGENfyd13RuhOq77NDE,4238
+spatial_graph/rtree/wrapper_template.pyx,sha256=FVooO-EE8oxDvnhTtDOkvYH3FYGJuAQNpl_KArYabhs,9683
+spatial_graph/rtree/src/ARCHITECTURE.md,sha256=TwQruizoeGjjcdxhz_H-a9jh3XvvRG7QfouSvdEKt6o,4712
+spatial_graph/rtree/src/LICENSE,sha256=5eZvRGXb-y4p7Wev7djIMtc_q-5j_SdL6pjbNNF-lUE,1081
+spatial_graph/rtree/src/config.h,sha256=65s3NLcvpBXGgnRYjigWs4cExN5T6gm7Vu7CsxDvD08,348
+spatial_graph/rtree/src/rtree.c,sha256=ykXltnXOVx4Rqxgu0Yq2ATZWVk_4k6RZNgp417vQN9g,25135
+spatial_graph/rtree/src/rtree.h,sha256=melC2Fl6o-72c0I6S4Z22op2U6NpnA6hgGK81GT1hI0,3663
+spatial_graph-0.0.1.dist-info/METADATA,sha256=G6lm2a7WnRjmBabfPJ66Oh4Qvfho8uUEokovWuafalk,3284
+spatial_graph-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+spatial_graph-0.0.1.dist-info/licenses/LICENSE,sha256=51KA-SVg7xhkZxV512EmrwJninM0t0h_UqqDf653NSk,1066
+spatial_graph-0.0.1.dist-info/RECORD,,

spatial_graph-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any