rasterix 0.1a1__py3-none-any.whl

rasterix/__init__.py

@@ -0,0 +1,15 @@
+from .raster_index import RasterIndex
+
+
+def _get_version():
+    __version__ = "999"
+    try:
+        from ._version import __version__
+    except ImportError:
+        pass
+    return __version__
+
+
+__version__ = _get_version()
+
+__all__ = ["RasterIndex"]

rasterix/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1a1"

rasterix/raster_index.py

@@ -0,0 +1,405 @@
+import textwrap
+from collections.abc import Hashable, Mapping
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from affine import Affine
+from xarray import DataArray, Index, Variable
+from xarray.core.coordinate_transform import CoordinateTransform
+
+# TODO: import from public API once it is available
+from xarray.core.indexes import CoordinateTransformIndex, PandasIndex
+from xarray.core.indexing import IndexSelResult, merge_sel_results
+
+
+class AffineTransform(CoordinateTransform):
+    """Affine 2D transform wrapper."""
+
+    affine: Affine
+    xy_dims: tuple[str, str]
+
+    def __init__(
+        self,
+        affine: Affine,
+        width: int,
+        height: int,
+        x_coord_name: Hashable = "xc",
+        y_coord_name: Hashable = "yc",
+        x_dim: str = "x",
+        y_dim: str = "y",
+        dtype: Any = np.dtype(np.float64),
+    ):
+        super().__init__((x_coord_name, y_coord_name), {x_dim: width, y_dim: height}, dtype=dtype)
+        self.affine = affine
+
+        # array dimensions in reverse order (y = rows, x = cols)
+        self.xy_dims = self.dims[0], self.dims[1]
+        self.dims = self.dims[1], self.dims[0]
+
+    def forward(self, dim_positions):
+        positions = tuple(dim_positions[dim] for dim in self.xy_dims)
+        x_labels, y_labels = self.affine * positions
+
+        results = {}
+        for name, labels in zip(self.coord_names, [x_labels, y_labels]):
+            results[name] = labels
+
+        return results
+
+    def reverse(self, coord_labels):
+        labels = tuple(coord_labels[name] for name in self.coord_names)
+        x_positions, y_positions = ~self.affine * labels
+
+        results = {}
+        for dim, positions in zip(self.xy_dims, [x_positions, y_positions]):
+            results[dim] = positions
+
+        return results
+
+    def equals(self, other):
+        if not isinstance(other, AffineTransform):
+            return False
+        return self.affine == other.affine and self.dim_size == other.dim_size
+
+
+class AxisAffineTransform(CoordinateTransform):
+    """Axis-independent wrapper of an affine 2D transform with no skew/rotation."""
+
+    affine: Affine
+    is_xaxis: bool
+    coord_name: Hashable
+    dim: str
+    size: int
+
+    def __init__(
+        self,
+        affine: Affine,
+        size: int,
+        coord_name: Hashable,
+        dim: str,
+        is_xaxis: bool,
+        dtype: Any = np.dtype(np.float64),
+    ):
+        assert affine.is_rectilinear and (affine.b == affine.d == 0)
+
+        super().__init__((coord_name,), {dim: size}, dtype=dtype)
+        self.affine = affine
+        self.is_xaxis = is_xaxis
+        self.coord_name = coord_name
+        self.dim = dim
+        self.size = size
+
+    def forward(self, dim_positions: dict[str, Any]) -> dict[Hashable, Any]:
+        positions = np.asarray(dim_positions[self.dim])
+
+        if self.is_xaxis:
+            labels, _ = self.affine * (positions, np.zeros_like(positions))
+        else:
+            _, labels = self.affine * (np.zeros_like(positions), positions)
+
+        return {self.coord_name: labels}
+
+    def reverse(self, coord_labels: dict[Hashable, Any]) -> dict[str, Any]:
+        labels = np.asarray(coord_labels[self.coord_name])
+
+        if self.is_xaxis:
+            positions, _ = ~self.affine * (labels, np.zeros_like(labels))
+        else:
+            _, positions = ~self.affine * (np.zeros_like(labels), labels)
+
+        return {self.dim: positions}
+
+    def equals(self, other):
+        if not isinstance(other, AxisAffineTransform):
+            return False
+
+        # only compare the affine parameters of the relevant axis
+        if self.is_xaxis:
+            affine_match = self.affine.a == other.affine.a and self.affine.c == other.affine.c
+        else:
+            affine_match = self.affine.e == other.affine.e and self.affine.f == other.affine.f
+
+        return affine_match and self.size == other.size
+
+    def generate_coords(self, dims: tuple[str, ...] | None = None) -> dict[Hashable, Any]:
+        assert dims is None or dims == self.dims
+        return self.forward({self.dim: np.arange(self.size)})
+
+    def slice(self, slice: slice) -> "AxisAffineTransform":
+        start = max(slice.start or 0, 0)
+        stop = min(slice.stop or self.size, self.size)
+        step = slice.step or 1
+
+        # TODO: support reverse transform (i.e., start > stop)?
+        assert start < stop
+
+        size = (stop - start) // step
+        scale = float(step)
+
+        if self.is_xaxis:
+            affine = self.affine * Affine.translation(start, 0.0) * Affine.scale(scale, 1.0)
+        else:
+            affine = self.affine * Affine.translation(0.0, start) * Affine.scale(1.0, scale)
+
+        return type(self)(
+            affine,
+            size,
+            self.coord_name,
+            self.dim,
+            is_xaxis=self.is_xaxis,
+            dtype=self.dtype,
+        )
+
+
+class AxisAffineTransformIndex(CoordinateTransformIndex):
+    """Axis-independent Xarray Index for an affine 2D transform with no
+    skew/rotation.
+
+    For internal use only.
+
+    This Index class provides specific behavior on top of
+    Xarray's `CoordinateTransformIndex`:
+
+    - Data slicing computes a new affine transform and returns a new
+      `AxisAffineTransformIndex` object
+
+    - Otherwise data selection creates and returns a new Xarray
+      `PandasIndex` object for non-scalar indexers
+
+    - The index can be converted to a `pandas.Index` object (useful for Xarray
+      operations that don't work with Xarray indexes yet).
+
+    """
+
+    axis_transform: AxisAffineTransform
+    dim: str
+
+    def __init__(self, transform: AxisAffineTransform):
+        assert isinstance(transform, AxisAffineTransform)
+        super().__init__(transform)
+        self.axis_transform = transform
+        self.dim = transform.dim
+
+    def isel(  # type: ignore[override]
+        self, indexers: Mapping[Any, int | slice | np.ndarray | Variable]
+    ) -> "AxisAffineTransformIndex | PandasIndex | None":
+        idxer = indexers[self.dim]
+
+        # generate a new index with updated transform if a slice is given
+        if isinstance(idxer, slice):
+            return AxisAffineTransformIndex(self.axis_transform.slice(idxer))
+        # no index for vectorized (fancy) indexing with n-dimensional Variable
+        elif isinstance(idxer, Variable) and idxer.ndim > 1:
+            return None
+        # no index for scalar value
+        elif np.ndim(idxer) == 0:
+            return None
+        # otherwise return a PandasIndex with values computed by forward transformation
+        else:
+            values = self.axis_transform.forward({self.dim: idxer})[self.axis_transform.coord_name]
+            if isinstance(idxer, Variable):
+                new_dim = idxer.dims[0]
+            else:
+                new_dim = self.dim
+            return PandasIndex(values, new_dim, coord_dtype=values.dtype)
+
+    def sel(self, labels, method=None, tolerance=None):
+        coord_name = self.axis_transform.coord_name
+        label = labels[coord_name]
+
+        if isinstance(label, slice):
+            if label.step is None:
+                # continuous interval slice indexing (preserves the index)
+                pos = self.transform.reverse({coord_name: np.array([label.start, label.stop])})
+                pos = np.round(pos[self.dim]).astype("int")
+                new_start = max(pos[0], 0)
+                new_stop = min(pos[1], self.axis_transform.size)
+                return IndexSelResult({self.dim: slice(new_start, new_stop)})
+            else:
+                # otherwise convert to basic (array) indexing
+                label = np.arange(label.start, label.stop, label.step)
+
+        # support basic indexing (in the 1D case basic vs. vectorized indexing
+        # are pretty much similar)
+        unwrap_xr = False
+        if not isinstance(label, Variable | DataArray):
+            # basic indexing -> either scalar or 1-d array
+            try:
+                var = Variable("_", label)
+            except ValueError:
+                var = Variable((), label)
+            labels = {self.dim: var}
+            unwrap_xr = True
+
+        result = super().sel(labels, method=method, tolerance=tolerance)
+
+        if unwrap_xr:
+            dim_indexers = {self.dim: result.dim_indexers[self.dim].values}
+            result = IndexSelResult(dim_indexers)
+
+        return result
+
+    def to_pandas_index(self) -> "pd.Index":
+        import pandas as pd
+
+        values = self.transform.generate_coords()
+        return pd.Index(values[self.dim])
+
+
+# The types of Xarray indexes that may be wrapped by RasterIndex
+WrappedIndex = AxisAffineTransformIndex | PandasIndex | CoordinateTransformIndex
+WrappedIndexCoords = Hashable | tuple[Hashable, Hashable]
+
+
+def _filter_dim_indexers(index: WrappedIndex, indexers: Mapping) -> Mapping:
+    if isinstance(index, CoordinateTransformIndex):
+        dims = index.transform.dims
+    else:
+        # PandasIndex
+        dims = (str(index.dim),)
+
+    return {dim: indexers[dim] for dim in dims if dim in indexers}
+
+
+class RasterIndex(Index):
+    """Xarray index for raster coordinates.
+
+    RasterIndex is itself a wrapper around one or more Xarray indexes associated
+    with either the raster x or y axis coordinate or both, depending on the
+    affine transformation and prior data selection (if any):
+
+    - The affine transformation is not rectilinear or has rotation: this index
+      encapsulates a single `CoordinateTransformIndex` object for both the x and
+      y axis (2-dimensional) coordinates.
+
+    - The affine transformation is rectilinear ands has no rotation: this index
+      encapsulates one or two index objects for either the x or y axis or both
+      (1-dimensional) coordinates. The index type is either a subclass of
+      `CoordinateTransformIndex` that supports slicing or `PandasIndex` (e.g.,
+      after data selection at arbitrary locations).
+
+    """
+
+    _wrapped_indexes: dict[WrappedIndexCoords, WrappedIndex]
+
+    def __init__(self, indexes: Mapping[WrappedIndexCoords, WrappedIndex]):
+        idx_keys = list(indexes)
+        idx_vals = list(indexes.values())
+
+        # either one or the other configuration (dependent vs. independent x/y axes)
+        axis_dependent = (
+            len(indexes) == 1
+            and isinstance(idx_keys[0], tuple)
+            and isinstance(idx_vals[0], CoordinateTransformIndex)
+        )
+        axis_independent = len(indexes) in (1, 2) and all(
+            isinstance(idx, AxisAffineTransformIndex | PandasIndex) for idx in idx_vals
+        )
+        assert axis_dependent ^ axis_independent
+
+        self._wrapped_indexes = dict(indexes)
+
+    @classmethod
+    def from_transform(
+        cls, affine: Affine, width: int, height: int, x_dim: str = "x", y_dim: str = "y"
+    ) -> "RasterIndex":
+        indexes: dict[WrappedIndexCoords, AxisAffineTransformIndex | CoordinateTransformIndex]
+
+        # pixel centered coordinates
+        affine = affine * Affine.translation(0.5, 0.5)
+
+        if affine.is_rectilinear and affine.b == affine.d == 0:
+            x_transform = AxisAffineTransform(affine, width, "x", x_dim, is_xaxis=True)
+            y_transform = AxisAffineTransform(affine, height, "y", y_dim, is_xaxis=False)
+            indexes = {
+                "x": AxisAffineTransformIndex(x_transform),
+                "y": AxisAffineTransformIndex(y_transform),
+            }
+        else:
+            xy_transform = AffineTransform(affine, width, height, x_dim=x_dim, y_dim=y_dim)
+            indexes = {("x", "y"): CoordinateTransformIndex(xy_transform)}
+
+        return cls(indexes)
+
+    @classmethod
+    def from_variables(
+        cls,
+        variables: Mapping[Any, Variable],
+        *,
+        options: Mapping[str, Any],
+    ) -> "RasterIndex":
+        # TODO: compute bounds, resolution and affine transform from explicit coordinates.
+        raise NotImplementedError("Creating a RasterIndex from existing coordinates is not yet supported.")
+
+    def create_variables(self, variables: Mapping[Any, Variable] | None = None) -> dict[Hashable, Variable]:
+        new_variables: dict[Hashable, Variable] = {}
+
+        for index in self._wrapped_indexes.values():
+            new_variables.update(index.create_variables())
+
+        return new_variables
+
+    def isel(self, indexers: Mapping[Any, int | slice | np.ndarray | Variable]) -> "RasterIndex | None":
+        new_indexes: dict[WrappedIndexCoords, WrappedIndex] = {}
+
+        for coord_names, index in self._wrapped_indexes.items():
+            index_indexers = _filter_dim_indexers(index, indexers)
+            if not index_indexers:
+                # no selection to perform: simply propagate the index
+                # TODO: uncomment when https://github.com/pydata/xarray/issues/10063 is fixed
+                # new_indexes[coord_names] = index
+                ...
+            else:
+                new_index = index.isel(index_indexers)
+                if new_index is not None:
+                    new_indexes[coord_names] = new_index
+
+        if new_indexes:
+            # TODO: if there's only a single PandasIndex can we just return it?
+            # (maybe better to keep it wrapped if we plan to later make RasterIndex CRS-aware)
+            return RasterIndex(new_indexes)
+        else:
+            return None
+
+    def sel(self, labels: dict[Any, Any], method=None, tolerance=None) -> IndexSelResult:
+        results = []
+
+        for coord_names, index in self._wrapped_indexes.items():
+            if not isinstance(coord_names, tuple):
+                coord_names = (coord_names,)
+            index_labels = {k: v for k, v in labels if k in coord_names}
+            if index_labels:
+                results.append(index.sel(index_labels, method=method, tolerance=tolerance))
+
+        return merge_sel_results(results)
+
+    def equals(self, other: Index) -> bool:
+        if not isinstance(other, RasterIndex):
+            return False
+        if set(self._wrapped_indexes) != set(other._wrapped_indexes):
+            return False
+
+        return all(
+            index.equals(other._wrapped_indexes[k])  # type: ignore[arg-type]
+            for k, index in self._wrapped_indexes.items()
+        )
+
+    def to_pandas_index(self) -> "pd.Index":
+        # conversion is possible only if this raster index encapsulates
+        # exactly one AxisAffineTransformIndex or a PandasIndex associated
+        # to either the x or y axis (1-dimensional) coordinate.
+        if len(self._wrapped_indexes) == 1:
+            index = next(iter(self._wrapped_indexes.values()))
+            if isinstance(index, AxisAffineTransformIndex | PandasIndex):
+                return index.to_pandas_index()
+
+        raise ValueError("Cannot convert RasterIndex to pandas.Index")
+
+    def __repr__(self):
+        items: list[str] = []
+
+        for coord_names, index in self._wrapped_indexes.items():
+            items += [repr(coord_names) + ":", textwrap.indent(repr(index), "    ")]
+
+        return "RasterIndex\n" + "\n".join(items)

rasterix-0.1a1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: rasterix
+Version: 0.1a1
+Summary: Raster extensions for Xarray
+License-Expression: Apache-2.0
+Keywords: xarray
+Classifier: Development Status :: 4 - Beta
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: affine
+Requires-Dist: pandas>=2
+Requires-Dist: numpy>=2
+Requires-Dist: xarray>=2025
+Dynamic: license-file
+
+# rasterix: Raster tricks for Xarray
+
+<img src="rasterix.png" width="400">

rasterix-0.1a1.dist-info/RECORD

@@ -0,0 +1,8 @@
+rasterix/__init__.py,sha256=3-ipA2RgFW3FZ_uOr0_CagEw8p8JTMWepIIg3tZCSjY,253
+rasterix/_version.py,sha256=oixvE9DVoe4z2vLWfAweh5smrXr9lPfc9uA5ZFJvxvo,21
+rasterix/raster_index.py,sha256=Lq-X2F5Zrz5dR2odKvUuG-zYk0nwZ6bBnT-pkRVxJVQ,14976
+rasterix-0.1a1.dist-info/licenses/LICENSE,sha256=QFnsASMx8_yBNbrS7GVOhJ5CglGsLMj83Rn61uWyMs8,10265
+rasterix-0.1a1.dist-info/METADATA,sha256=0HsuR9lB_sx5wDg7nMWcGcc-ryDajKLGsnAQKQrl8FU,798
+rasterix-0.1a1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+rasterix-0.1a1.dist-info/top_level.txt,sha256=xrxwvEojFP_KT72cB7W-Bax_gPoV4e7Jw_4c41uiaj0,9
+rasterix-0.1a1.dist-info/RECORD,,

rasterix-0.1a1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rasterix-0.1a1.dist-info/licenses/LICENSE

@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright 2014-2025 Deepak Cherian
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

rasterix-0.1a1.dist-info/top_level.txt

@@ -0,0 +1 @@
+rasterix