Remove SpatialIndexItem

It was only used in one location, and not used much at that. This is
backwards incompatible, but not for something important.

Author: mx-moth

docs/api/conventions/interface.rst

@@ -24,9 +24,6 @@ the :class:`~emsarray.conventions.Convention` interface.
    .. automethod:: unpack_index
    .. automethod:: pack_index
 
-.. autoclass:: emsarray.conventions.SpatialIndexItem
-   :members:
-
 .. type:: GridKind
 
     Some type that can enumerate the different :ref:`grid types <grids>`

src/emsarray/conventions/__init__.py

@@ -13,9 +13,7 @@
 Convention instances can be instantiated directly in this case.
 Refer to each Convention implementation for details.
 """
-from ._base import (
-    Convention, DimensionConvention, SpatialIndexItem, Specificity
-)
+from ._base import Convention, DimensionConvention, Specificity
 from ._registry import get_dataset_convention, register_convention
 from ._utils import open_dataset
 from .arakawa_c import ArakawaC
@@ -25,7 +23,7 @@
 
 __all__ = [
     "Convention", "DimensionConvention",
-    "SpatialIndexItem", "Specificity",
+    "Specificity",
     "get_dataset_convention", "register_convention",
     "open_dataset",
     "ArakawaC",

src/emsarray/conventions/_base.py

@@ -1,5 +1,4 @@
 import abc
-import dataclasses
 import enum
 import hashlib
 import logging
@@ -35,43 +34,6 @@
 logger = logging.getLogger(__name__)
 
 
-@dataclasses.dataclass
-class SpatialIndexItem[Index]:
-    """Information about an item in the :class:`~shapely.strtree.STRtree`
-    spatial index for a dataset.
-
-    See Also
-    --------
-    Convention.spatial_index
-    """
-
-    #: The linear index of this cell
-    linear_index: int
-
-    #: The native index of this cell
-    index: Index
-
-    #: The geographic shape of this cell
-    polygon: Polygon
-
-    def __repr__(self) -> str:
-        items = {
-            'index': f'{self.index}/{self.linear_index}',
-            'polygon': self.polygon.wkt,
-        }
-        item_str = ' '.join(f'{key}: {value}' for key, value in items.items())
-        return f'<{type(self).__name__} {item_str}>'
-
-    def __lt__(self, other: Any) -> bool:
-        if not isinstance(other, SpatialIndexItem):
-            return NotImplemented
-
-        # SpatialIndexItems are only for cells / polygons, so we only need to
-        # compare the linear indexes. The polygon attribute is not orderable,
-        # so comparing on that is going to be unpleasant.
-        return self.linear_index < other.linear_index
-
-
 class Specificity(enum.IntEnum):
     """
     How specific a match is when autodetecting a convention.
@@ -1180,44 +1142,6 @@ def strtree(self) -> STRtree:
         """
         return STRtree(self.polygons)
 
-    def get_index_for_point(
-        self,
-        point: Point,
-    ) -> SpatialIndexItem[Index] | None:
-        """
-        Find the index for a :class:`~shapely.Point` in the dataset.
-
-        Parameters
-        ----------
-        point : shapely.Point
-            The geographic point to query
-
-        Returns
-        -------
-        :class:`SpatialIndexItem`, optional
-            The :class:`SpatialIndexItem` for the point queried.
-            This indicates the polygon that intersected the point
-            and the index of that polygon in the dataset.
-
-            If the point does not intersect the dataset, None is returned.
-
-        Notes
-        -----
-        In the case where the point intersects multiple cells
-        the cell with the lowest linear index is returned.
-        This can happen if the point is exactly one of the cell vertices,
-        or falls on a cell edge,
-        or if the geometry of the dataset contains overlapping polygons.
-        """
-        hits = numpy.sort(self.strtree.query(point, predicate='intersects'))
-        if len(hits) > 0:
-            linear_index = hits[0]
-            return SpatialIndexItem(
-                linear_index=linear_index,
-                index=self.wind_index(linear_index),
-                polygon=self.polygons[linear_index])
-        return None
-
     def selector_for_index(self, index: Index) -> xarray.Dataset:
         """
         Convert a convention native index into a selector

tests/conventions/test_base.py

@@ -364,54 +364,6 @@ def test_strtree():
     assert set(items) == expected_intersections
 
 
-def test_get_index_for_point_centre():
-    dataset = xarray.Dataset({
-        'temp': (['t', 'z', 'y', 'x'], numpy.random.standard_normal((5, 5, 10, 20))),
-        'botz': (['y', 'x'], numpy.random.standard_normal((10, 20)) - 10),
-    })
-    convention = SimpleConvention(dataset)
-
-    # Polygons for this simple convetion is box(x, y, x+1, y+1):w
-    index = convention.get_index_for_point(Point(1.5, 1.5))
-    assert index.index == SimpleGridIndex(1, 1)
-
-    index = convention.get_index_for_point(Point(2.5, 2.5))
-    assert index.index == SimpleGridIndex(2, 2)
-
-
-def test_get_index_for_point_vertex():
-    dataset = xarray.Dataset({
-        'temp': (['t', 'z', 'y', 'x'], numpy.random.standard_normal((5, 5, 10, 20))),
-        'botz': (['y', 'x'], numpy.random.standard_normal((10, 20)) - 10),
-    })
-    convention = SimpleConvention(dataset)
-
-    point = Point(2, 2)
-
-    # There should be four cells intersecting this point
-    intersections = convention.strtree.query(point, predicate='intersects')
-    assert len(intersections) == 4
-
-    # `get_index_for_point` should still return a single item in this case
-    index = convention.get_index_for_point(point)
-    assert index.index == SimpleGridIndex(1, 1)
-
-    # The point should be the first of the hits in index order
-    assert index.linear_index == min(intersections)
-
-
-def test_get_index_for_point_miss():
-    dataset = xarray.Dataset({
-        'temp': (['t', 'z', 'y', 'x'], numpy.random.standard_normal((5, 5, 10, 20))),
-        'botz': (['y', 'x'], numpy.random.standard_normal((10, 20)) - 10),
-    })
-    convention = SimpleConvention(dataset)
-
-    point = Point(-1, -1)
-
-    assert convention.get_index_for_point(point) is None
-
-
 def test_selector_for_point():
     dataset = xarray.Dataset({
         'temp': (['t', 'z', 'y', 'x'], numpy.random.standard_normal((5, 5, 10, 20))),
@@ -473,7 +425,8 @@ def test_select_point():
     # The underlying implementation does this, and the individual methods are
     # tested in detail elsewhere
     point = Point(3.5, 5.5)
-    index = convention.get_index_for_point(point).index
+    # TODO Fix this
+    index = ...
     expected = convention.select_index(index)
     actual = convention.select_point(point)
     assert actual == expected