rasterix 0.1a4__py3-none-any.whl → 0.1.1__py3-none-any.whl

rasterix/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.1a4'
-__version_tuple__ = version_tuple = (0, 1, 'a4')
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
+
+__commit_id__ = commit_id = None

rasterix/lib.py

@@ -0,0 +1,106 @@
+"""Shared library utilities for rasterix."""
+
+import logging
+
+from affine import Affine
+
+# Define TRACE level (lower than DEBUG)
+TRACE = 5
+logging.addLevelName(TRACE, "TRACE")
+
+
+class TraceLogger(logging.Logger):
+    """Logger with trace level support."""
+
+    def trace(self, message, *args, **kwargs):
+        """Log a message with severity 'TRACE'."""
+        if self.isEnabledFor(TRACE):
+            self._log(TRACE, message, args, **kwargs)
+
+
+# Set the custom logger class
+logging.setLoggerClass(TraceLogger)
+
+# Create logger for the rasterix package
+logger = logging.getLogger("rasterix")
+
+
+def affine_from_tiepoint_and_scale(
+    tiepoint: list[float] | tuple[float, ...],
+    scale: list[float] | tuple[float, ...],
+) -> Affine:
+    """Create an Affine transform from GeoTIFF tiepoint and pixel scale.
+
+    Parameters
+    ----------
+    tiepoint : list or tuple
+        GeoTIFF model tiepoint in format [I, J, K, X, Y, Z]
+        where (I, J, K) are pixel coords and (X, Y, Z) are world coords.
+    scale : list or tuple
+        GeoTIFF model pixel scale in format [ScaleX, ScaleY, ScaleZ].
+
+    Returns
+    -------
+    Affine
+        Affine transformation matrix.
+
+    Raises
+    ------
+    AssertionError
+        If ScaleZ is not 0 (only 2D rasters are supported).
+
+    Examples
+    --------
+    >>> tiepoint = [0.0, 0.0, 0.0, 323400.0, 4265400.0, 0.0]
+    >>> scale = [30.0, 30.0, 0.0]
+    >>> affine = affine_from_tiepoint_and_scale(tiepoint, scale)
+    """
+    if len(tiepoint) < 6:
+        raise ValueError(f"tiepoint must have at least 6 elements, got {len(tiepoint)}")
+    if len(scale) < 3:
+        raise ValueError(f"scale must have at least 3 elements, got {len(scale)}")
+
+    i, j, k, x, y, z = tiepoint[:6]
+    scale_x, scale_y, scale_z = scale[:3]
+
+    # We only support 2D rasters
+    assert scale_z == 0, f"Z pixel scale must be 0 for 2D rasters, got {scale_z}"
+
+    # The tiepoint gives us the world coordinates at pixel (I, J)
+    # Affine transform: x_world = c + i * a, y_world = f + j * e
+    # So: c = x - i * scale_x, f = y - j * scale_y
+    c = x - i * scale_x
+    f = y - j * scale_y
+
+    return Affine.translation(c, f) * Affine.scale(scale_x, scale_y)
+
+
+def affine_from_stac_proj_metadata(metadata: dict) -> Affine | None:
+    """Extract Affine transform from STAC projection metadata.
+
+    Parameters
+    ----------
+    metadata : dict
+        Dictionary containing STAC metadata. Should contain a 'proj:transform' key.
+
+    Returns
+    -------
+    Affine or None
+        Affine transformation matrix if 'proj:transform' is found, None otherwise.
+
+    Examples
+    --------
+    >>> metadata = {"proj:transform": [30.0, 0.0, 323400.0, 0.0, 30.0, 4268400.0]}
+    >>> affine = affine_from_stac_proj_metadata(metadata)
+    """
+    if "proj:transform" not in metadata:
+        return None
+
+    transform = metadata["proj:transform"]
+    # proj:transform is a 3x3 matrix in row-major order, but typically only 6 elements
+    # [a, b, c, d, e, f, 0, 0, 1] where the affine is constructed from first 6 elements
+    if len(transform) < 6:
+        raise ValueError(f"proj:transform must have at least 6 elements, got {len(transform)}")
+
+    a, b, c, d, e, f = transform[:6]
+    return Affine(a, b, c, d, e, f)

rasterix/raster_index.py

@@ -14,7 +14,7 @@ from xarray import Coordinates, DataArray, Dataset, Index, Variable, get_options
 from xarray.core.coordinate_transform import CoordinateTransform
 
 # TODO: import from public API once it is available
-from xarray.core.indexes import CoordinateTransformIndex
+from xarray.core.indexes import CoordinateTransformIndex, PandasIndex
 from xarray.core.indexing import IndexSelResult, merge_sel_results
 from xarray.core.types import JoinOptions
 from xproj.typing import CRSAwareIndex
@@ -310,17 +310,20 @@ class AxisAffineTransformIndex(CoordinateTransformIndex):
     def sel(self, labels, method=None, tolerance=None):
         coord_name = self.axis_transform.coord_name
         label = labels[coord_name]
-
+        transform = self.axis_transform
         if isinstance(label, slice):
-            if label.start is None:
-                label = slice(0, label.stop, label.step)
+            label = slice(
+                label.start or transform.forward({coord_name: 0})[coord_name],
+                label.stop or transform.forward({coord_name: transform.size})[coord_name],
+                label.step,
+            )
             if label.step is None:
                 # continuous interval slice indexing (preserves the index)
                 pos = self.transform.reverse({coord_name: np.array([label.start, label.stop])})
                 # np.round rounds to even, this way we round upwards
                 pos = np.floor(pos[self.dim] + 0.5).astype("int")
                 new_start = max(pos[0], 0)
-                new_stop = min(pos[1], self.axis_transform.size)
+                new_stop = min(pos[1] + 1, self.axis_transform.size)
                 return IndexSelResult({self.dim: slice(new_start, new_stop)})
             else:
                 # otherwise convert to basic (array) indexing
@@ -572,6 +575,147 @@ class RasterIndex(Index, xproj.ProjIndexMixin):
 
         return cls(index, crs=crs)
 
+    @classmethod
+    def from_tiepoint_and_scale(
+        cls,
+        *,
+        tiepoint: list[float] | tuple[float, ...],
+        scale: list[float] | tuple[float, ...],
+        width: int,
+        height: int,
+        x_dim: str = "x",
+        y_dim: str = "y",
+        x_coord_name: str = "xc",
+        y_coord_name: str = "yc",
+        crs: CRS | Any | None = None,
+    ) -> RasterIndex:
+        """Create a RasterIndex from GeoTIFF tiepoint and pixel scale metadata.
+
+        Parameters
+        ----------
+        tiepoint : list or tuple
+            GeoTIFF model tiepoint in format [I, J, K, X, Y, Z]
+            where (I, J, K) are pixel coords and (X, Y, Z) are world coords.
+        scale : list or tuple
+            GeoTIFF model pixel scale in format [ScaleX, ScaleY, ScaleZ].
+        width : int
+            Number of pixels in the x direction.
+        height : int
+            Number of pixels in the y direction.
+        x_dim : str, optional
+            Name for the x dimension.
+        y_dim : str, optional
+            Name for the y dimension.
+        x_coord_name : str, optional
+            Name for the x coordinate. For non-rectilinear transforms only.
+        y_coord_name : str, optional
+            Name for the y coordinate. For non-rectilinear transforms only.
+        crs : :class:`pyproj.crs.CRS` or any, optional
+            The coordinate reference system. Any value accepted by
+            :meth:`pyproj.crs.CRS.from_user_input`.
+
+        Returns
+        -------
+        RasterIndex
+            A new RasterIndex object with appropriate internal structure.
+
+        Raises
+        ------
+        AssertionError
+            If ScaleZ is not 0 (only 2D rasters are supported).
+
+        Examples
+        --------
+        Create an index from GeoTIFF metadata:
+
+        >>> tiepoint = [0.0, 0.0, 0.0, 323400.0, 4265400.0, 0.0]
+        >>> scale = [30.0, 30.0, 0.0]
+        >>> index = RasterIndex.from_tiepoint_and_scale(tiepoint=tiepoint, scale=scale, width=100, height=100)
+        """
+        from rasterix.lib import affine_from_tiepoint_and_scale
+
+        affine = affine_from_tiepoint_and_scale(tiepoint, scale)
+        return cls.from_transform(
+            affine,
+            width=width,
+            height=height,
+            x_dim=x_dim,
+            y_dim=y_dim,
+            x_coord_name=x_coord_name,
+            y_coord_name=y_coord_name,
+            crs=crs,
+        )
+
+    @classmethod
+    def from_stac_proj_metadata(
+        cls,
+        metadata: dict,
+        *,
+        width: int,
+        height: int,
+        x_dim: str = "x",
+        y_dim: str = "y",
+        x_coord_name: str = "xc",
+        y_coord_name: str = "yc",
+        crs: CRS | Any | None = None,
+    ) -> RasterIndex:
+        """Create a RasterIndex from STAC projection metadata.
+
+        Parameters
+        ----------
+        metadata : dict
+            Dictionary containing STAC metadata. Must contain a 'proj:transform' key
+            with the affine transformation as a flat array.
+        width : int
+            Number of pixels in the x direction.
+        height : int
+            Number of pixels in the y direction.
+        x_dim : str, optional
+            Name for the x dimension.
+        y_dim : str, optional
+            Name for the y dimension.
+        x_coord_name : str, optional
+            Name for the x coordinate. For non-rectilinear transforms only.
+        y_coord_name : str, optional
+            Name for the y coordinate. For non-rectilinear transforms only.
+        crs : :class:`pyproj.crs.CRS` or any, optional
+            The coordinate reference system. Any value accepted by
+            :meth:`pyproj.crs.CRS.from_user_input`.
+
+        Returns
+        -------
+        RasterIndex
+            A new RasterIndex object with appropriate internal structure.
+
+        Raises
+        ------
+        ValueError
+            If 'proj:transform' is not found in metadata or has invalid format.
+
+        Examples
+        --------
+        Create an index from STAC metadata:
+
+        >>> metadata = {"proj:transform": [30.0, 0.0, 323400.0, 0.0, 30.0, 4268400.0]}
+        >>> index = RasterIndex.from_stac_proj_metadata(metadata, width=100, height=100)
+        """
+        from rasterix.lib import affine_from_stac_proj_metadata
+
+        affine = affine_from_stac_proj_metadata(metadata)
+        if affine is None:
+            raise ValueError("metadata must contain 'proj:transform' key")
+
+        return cls.from_transform(
+            affine,
+            width=width,
+            height=height,
+            x_dim=x_dim,
+            y_dim=y_dim,
+            x_coord_name=x_coord_name,
+            y_coord_name=y_coord_name,
+            crs=crs,
+        )
+
     @classmethod
     def from_variables(
         cls,
@@ -696,6 +840,23 @@ class RasterIndex(Index, xproj.ProjIndexMixin):
             y = self._xy_indexes[YAXIS].axis_transform.affine
             return Affine(x.a, x.b, x.c, y.d, y.e, y.f)
 
+    def _as_pandas_index(self) -> dict[str, PandasIndex]:
+        """Convert RasterIndex to equivalent PandasIndex objects.
+
+        Returns a dict mapping dimension names to PandasIndex instances.
+        For internal/testing use.
+        """
+        result = {}
+        if self._axis_independent:
+            for idx in self._xy_indexes:
+                dim = idx.axis_transform.dim
+                values = idx.to_pandas_index()
+                result[dim] = PandasIndex(values, dim)
+        else:
+            raise NotImplementedError("_as_pandas_index not supported for non-rectilinear grids")
+
+        return result
+
     @property
     def bbox(self) -> BoundingBox:
         """Bounding Box for index.

rasterix/strategies.py

@@ -0,0 +1,165 @@
+"""Hypothesis strategies for generating label-based indexers."""
+
+from collections.abc import Hashable
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+from hypothesis import note
+from hypothesis import strategies as st
+from xarray.core.indexes import Indexes
+from xarray.testing.strategies import (
+    basic_indexers,
+    outer_array_indexers,
+    vectorized_indexers,
+)
+
+
+def pos_to_label_indexer(idx: pd.Index, idxr: int | slice | np.ndarray, *, use_scalar: bool = True) -> Any:
+    """Convert a positional indexer to a label-based indexer.
+
+    Parameters
+    ----------
+    idx : pd.Index
+        The pandas Index to use for label lookup.
+    idxr : int | slice | np.ndarray
+        The positional indexer (integer, slice, or array of integers).
+    use_scalar : bool, optional
+        If True, attempt to convert scalar values to Python scalars. Default is True.
+
+    Returns
+    -------
+    Any
+        The label-based indexer (scalar, slice, or array of labels).
+    """
+    if isinstance(idxr, slice):
+        return slice(
+            None if idxr.start is None else idx[idxr.start],
+            # FIXME: This will never go past the label range
+            None if idxr.stop is None else idx[min(idxr.stop, idx.size - 1)],
+        )
+    elif isinstance(idxr, np.ndarray):
+        # Convert array of position indices to array of label values
+        return idx[idxr].values
+    else:
+        val = idx[idxr]
+        if use_scalar:
+            try:
+                # pass python scalars occasionally
+                val = val.item()
+            except Exception:
+                note(f"casting {val!r} to item() failed")
+                pass
+        return val
+
+
+@st.composite
+def basic_label_indexers(draw, /, *, indexes: Indexes) -> dict[Hashable, float | slice]:
+    """Generate label-based indexers by converting position indexers to labels.
+
+    This works in label space by using the coordinate Index values.
+
+    Parameters
+    ----------
+    draw : callable
+        The Hypothesis draw function (automatically provided by @st.composite).
+    indexes : Indexes
+        Dictionary mapping dimension names to their associated indexes
+
+    Returns
+    -------
+    dict[Hashable, float | slice]
+        Label-based indexers as a dict with keys from sizes.keys().
+        Values are either float (for scalar labels) or slice (for label ranges).
+    """
+    idxs = indexes.get_unique()
+    assert all(isinstance(idx, xr.indexes.PandasIndex) for idx in idxs)
+
+    # FIXME: this should be indexes.sizes!
+    sizes = indexes.dims
+
+    pos_indexer = draw(basic_indexers(sizes=sizes))
+    pdindexes = indexes.to_pandas_indexes()
+
+    label_indexer = {
+        dim: pos_to_label_indexer(pdindexes[dim], idx, use_scalar=draw(st.booleans()))
+        for dim, idx in pos_indexer.items()
+    }
+    return label_indexer
+
+
+@st.composite
+def outer_array_label_indexers(draw, /, *, indexes: Indexes) -> dict[Hashable, np.ndarray]:
+    """Generate label-based outer array indexers by converting position indexers to labels.
+
+    This works in label space by using the coordinate Index values.
+
+    Parameters
+    ----------
+    draw : callable
+        The Hypothesis draw function (automatically provided by @st.composite).
+    indexes : Indexes
+        Dictionary mapping dimension names to their associated indexes
+
+    Returns
+    -------
+    dict[Hashable, np.ndarray]
+        Label-based indexers as a dict with keys from indexes.
+        Values are numpy arrays of label values for each dimension.
+    """
+    idxs = indexes.get_unique()
+    assert all(isinstance(idx, xr.indexes.PandasIndex) for idx in idxs)
+
+    # FIXME: this should be indexes.sizes!
+    sizes = indexes.dims
+
+    pos_indexer = draw(outer_array_indexers(sizes=sizes))
+    pdindexes = indexes.to_pandas_indexes()
+
+    label_indexer = {
+        dim: pos_to_label_indexer(pdindexes[dim], idx, use_scalar=False) for dim, idx in pos_indexer.items()
+    }
+    return label_indexer
+
+
+@st.composite
+def vectorized_label_indexers(draw, /, *, indexes: Indexes, **kwargs) -> dict[Hashable, xr.DataArray]:
+    """Generate label-based vectorized indexers by converting position indexers to labels.
+
+    This works in label space by using the coordinate Index values.
+
+    Parameters
+    ----------
+    draw : callable
+        The Hypothesis draw function (automatically provided by @st.composite).
+    indexes : Indexes
+        Dictionary mapping dimension names to their associated indexes
+    **kwargs : dict
+        Additional keyword arguments to pass to vectorized_indexers
+
+    Returns
+    -------
+    dict[Hashable, xr.DataArray]
+        Label-based indexers as a dict with keys from indexes.
+        Values are DataArrays of label values for each dimension.
+    """
+    idxs = indexes.get_unique()
+    assert all(isinstance(idx, xr.indexes.PandasIndex) for idx in idxs)
+
+    # FIXME: this should be indexes.sizes!
+    sizes = indexes.dims
+
+    pos_indexer = draw(vectorized_indexers(sizes=sizes, **kwargs))
+    pdindexes = indexes.to_pandas_indexes()
+
+    label_indexer = {}
+    for dim, idx_array in pos_indexer.items():
+        # Convert each position in the array to its corresponding label
+        # Flatten, index, then reshape back to original shape
+        flat_indices = idx_array.values.ravel()
+        flat_labels = pdindexes[dim][flat_indices].values
+        label_values = flat_labels.reshape(idx_array.shape)
+        label_indexer[dim] = xr.DataArray(label_values, dims=idx_array.dims)
+
+    return label_indexer

rasterix/utils.py

@@ -1,6 +1,8 @@
 import xarray as xr
 from affine import Affine
 
+from rasterix.lib import affine_from_stac_proj_metadata, affine_from_tiepoint_and_scale, logger
+
 
 def get_grid_mapping_var(obj: xr.Dataset | xr.DataArray) -> xr.DataArray | None:
     grid_mapping_var = None
@@ -31,8 +33,9 @@ def get_affine(
     Grabs an affine transform from an Xarray object.
 
     This method will first look for the ``"GeoTransform"`` attribute on a variable named
-    ``"spatial_ref"``. If not, it will auto-guess the transform from the provided ``x_dim``,
-    and ``y_dim``.
+    ``"spatial_ref"``. If not, it will look for STAC ``proj:transform`` attribute, then
+    GeoTIFF metadata (``model_tiepoint`` and ``model_pixel_scale``). Finally, it will
+    auto-guess the transform from the provided ``x_dim`` and ``y_dim``.
 
     Parameters
     ----------
@@ -42,7 +45,7 @@ def get_affine(
     y_dim: str, optional
         Name of the Y dimension coordinate variable.
     clear_transform: bool
-       Whether to delete the ``GeoTransform`` attribute if detected.
+       Whether to delete the transform attributes if detected.
 
     Returns
     -------
@@ -50,18 +53,56 @@ def get_affine(
     """
     grid_mapping_var = get_grid_mapping_var(obj)
     if grid_mapping_var is not None and (transform := grid_mapping_var.attrs.get("GeoTransform")):
+        logger.trace("Creating affine from GeoTransform attribute")
         if clear_transform:
             del grid_mapping_var.attrs["GeoTransform"]
         return Affine.from_gdal(*map(float, transform.split(" ")))
-    else:
-        x = obj.coords[x_dim]
-        y = obj.coords[y_dim]
-        if x.ndim != 1:
-            raise ValueError(f"Coordinate variable {x_dim=!r} must be 1D.")
-        if y.ndim != 1:
-            raise ValueError(f"Coordinate variable {y_dim=!r} must be 1D.")
-        dx = (x[1] - x[0]).item()
-        dy = (y[1] - y[0]).item()
-        return Affine.translation(
-            x[0].item() - dx / 2, (y[0] if dy < 0 else y[-1]).item() - dy / 2
-        ) * Affine.scale(dx, dy)
+
+    # Check for STAC and GeoTIFF metadata in DataArray attrs
+    attrs = obj.attrs if isinstance(obj, xr.DataArray) else {}
+
+    # Try to extract affine from STAC proj:transform
+    if affine := affine_from_stac_proj_metadata(attrs):
+        logger.trace("Creating affine from STAC proj:transform attribute")
+        if clear_transform:
+            del attrs["proj:transform"]
+        return affine
+
+    # Try to extract affine from GeoTIFF model_tiepoint and model_pixel_scale
+    if "model_tiepoint" in attrs and "model_pixel_scale" in attrs:
+        logger.trace("Creating affine from GeoTIFF model_tiepoint and model_pixel_scale attributes")
+        affine = affine_from_tiepoint_and_scale(attrs["model_tiepoint"], attrs["model_pixel_scale"])
+
+        # Clean up GeoTIFF metadata attributes after using them
+        if clear_transform:
+            del attrs["model_tiepoint"]
+            del attrs["model_pixel_scale"]
+
+        return affine
+
+    # Fall back to computing from coordinate arrays
+    logger.trace(f"Creating affine from coordinate arrays {x_dim=!r} and {y_dim=!r}")
+    if x_dim not in obj.coords or y_dim not in obj.coords:
+        raise ValueError(
+            f"Cannot create affine transform: dimensions {x_dim=!r} and {y_dim=!r} "
+            f"do not have explicit coordinate values and no transform metadata found."
+        )
+
+    x = obj.coords[x_dim]
+    y = obj.coords[y_dim]
+    if x.ndim != 1:
+        raise ValueError(f"Coordinate variable {x_dim=!r} must be 1D.")
+    if y.ndim != 1:
+        raise ValueError(f"Coordinate variable {y_dim=!r} must be 1D.")
+
+    # Check that coordinates have actual values (not just dimension placeholders)
+    if len(x) == 0 or len(y) == 0:
+        raise ValueError(
+            f"Cannot create affine transform from empty coordinate arrays for {x_dim=!r} and {y_dim=!r}."
+        )
+
+    dx = (x[1] - x[0]).item()
+    dy = (y[1] - y[0]).item()
+    return Affine.translation(
+        x[0].item() - dx / 2, (y[0] if dy < 0 else y[-1]).item() - dy / 2
+    ) * Affine.scale(dx, dy)

{rasterix-0.1a4.dist-info → rasterix-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rasterix
-Version: 0.1a4
+Version: 0.1.1
 Summary: Raster extensions for Xarray
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -45,15 +45,6 @@ Requires-Dist: exactextract; extra == 'exactextract'
 Requires-Dist: sparse; extra == 'exactextract'
 Provides-Extra: rasterize
 Requires-Dist: rasterio; extra == 'rasterize'
-Provides-Extra: test
-Requires-Dist: dask-geopandas; extra == 'test'
-Requires-Dist: exactextract; extra == 'test'
-Requires-Dist: geodatasets; extra == 'test'
-Requires-Dist: hypothesis; extra == 'test'
-Requires-Dist: netcdf4; extra == 'test'
-Requires-Dist: pooch; extra == 'test'
-Requires-Dist: rasterio; extra == 'test'
-Requires-Dist: sparse; extra == 'test'
 Description-Content-Type: text/markdown
 
 # rasterix: Raster tricks for Xarray

rasterix-0.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+rasterix/__init__.py,sha256=iSC54A4b-7zgxtKV0CUok0O2-ApGtzVA-6hWG3a5AAA,283
+rasterix/_version.py,sha256=m8HxkqoKGw_wAJtc4ZokpJKNLXqp4zwnNhbnfDtro7w,704
+rasterix/lib.py,sha256=nuX3DFdx8smK8jc41Y6xQ2BaGkMdIBTIpOhk__YkTJw,3236
+rasterix/odc_compat.py,sha256=MxjctCH0zV6VSSQymatJreHYUnUo3qkB1oIKbOxEK4A,19099
+rasterix/raster_index.py,sha256=UhpfqGwKPLSo5-OhnTu43rkwVXi2TB2QyXC2r2VZnVs,38333
+rasterix/rioxarray_compat.py,sha256=o32UBkWBpNhmC35ar0Ozn2QszpWdPvdDDXif3Mq2ZKg,12428
+rasterix/strategies.py,sha256=gCc-BWU3oJsaSQalkbad1T8HYBk91079wlkEhwc2mzc,5525
+rasterix/utils.py,sha256=PMcfOfutDiH5aE2XKl486fZR4qMAU7h6AzUNwMmEAFQ,4295
+rasterix/rasterize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rasterix/rasterize/exact.py,sha256=UPB9zXpj7ZgkDy-x4vcNwY3J8DTrOTkRcIBMkhPQ04s,10558
+rasterix/rasterize/rasterio.py,sha256=gtdQxM9CiosalYk3rLKGkp0UmhZVO5parAVsR7IINoE,12883
+rasterix/rasterize/utils.py,sha256=iIuyTdigpFnts_-bUfas6FMsgix5lMqMQTxQaEBlyXM,3521
+rasterix-0.1.1.dist-info/METADATA,sha256=cqTlelh4_8aeAXuDnkozCtsWXBEsXsSLxSO0eqfIfWs,3044
+rasterix-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rasterix-0.1.1.dist-info/licenses/LICENSE,sha256=QFnsASMx8_yBNbrS7GVOhJ5CglGsLMj83Rn61uWyMs8,10265
+rasterix-0.1.1.dist-info/RECORD,,

{rasterix-0.1a4.dist-info → rasterix-0.1.1.dist-info}/WHEEL

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

rasterix-0.1a4.dist-info/RECORD

@@ -1,14 +0,0 @@
-rasterix/__init__.py,sha256=iSC54A4b-7zgxtKV0CUok0O2-ApGtzVA-6hWG3a5AAA,283
-rasterix/_version.py,sha256=Rlam12WbDAQ2TzSYxzdnw4SLFERCr6sX8OCMwKNxEX4,514
-rasterix/odc_compat.py,sha256=MxjctCH0zV6VSSQymatJreHYUnUo3qkB1oIKbOxEK4A,19099
-rasterix/raster_index.py,sha256=uwEDjjmnESWpyqsJwAnZvpWrjnKDeg0m1qNNH9mYTWY,32808
-rasterix/rioxarray_compat.py,sha256=o32UBkWBpNhmC35ar0Ozn2QszpWdPvdDDXif3Mq2ZKg,12428
-rasterix/utils.py,sha256=y2N-3d9-D8tBKjeZXv4vcjY_fs_dbbx5SfBBkQibLNs,2441
-rasterix/rasterize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rasterix/rasterize/exact.py,sha256=UPB9zXpj7ZgkDy-x4vcNwY3J8DTrOTkRcIBMkhPQ04s,10558
-rasterix/rasterize/rasterio.py,sha256=gtdQxM9CiosalYk3rLKGkp0UmhZVO5parAVsR7IINoE,12883
-rasterix/rasterize/utils.py,sha256=iIuyTdigpFnts_-bUfas6FMsgix5lMqMQTxQaEBlyXM,3521
-rasterix-0.1a4.dist-info/METADATA,sha256=K5l2PDTNLvmdA6TVGvy2tg5-YRevdmhV5mYX_Os3Rbw,3402
-rasterix-0.1a4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rasterix-0.1a4.dist-info/licenses/LICENSE,sha256=QFnsASMx8_yBNbrS7GVOhJ5CglGsLMj83Rn61uWyMs8,10265
-rasterix-0.1a4.dist-info/RECORD,,