rio-tiler 7.9.2__tar.gz → 8.0.0__tar.gz

{rio_tiler-7.9.2 → rio_tiler-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rio-tiler
-Version: 7.9.2
+Version: 8.0.0
 Summary: User friendly Rasterio plugin to read raster datasets.
 Project-URL: Homepage, https://cogeotiff.github.io/rio-tiler/
 Project-URL: Documentation, https://cogeotiff.github.io/rio-tiler/
@@ -43,54 +43,30 @@ Keywords: COGEO,Cloud Optimized Geotiff,STAC,rasterio,slippy-map
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: GIS
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Requires-Dist: attrs
 Requires-Dist: cachetools
 Requires-Dist: color-operations
 Requires-Dist: httpx
-Requires-Dist: morecantile<7.0,>=5.0
+Requires-Dist: morecantile<8.0,>=5.0
 Requires-Dist: numexpr
 Requires-Dist: numpy
 Requires-Dist: pydantic~=2.0
 Requires-Dist: pystac<2.0,>=1.9
 Requires-Dist: rasterio>=1.4.0
 Requires-Dist: typing-extensions
-Provides-Extra: benchmark
-Requires-Dist: pytest; extra == 'benchmark'
-Requires-Dist: pytest-benchmark; extra == 'benchmark'
-Provides-Extra: dev
-Requires-Dist: bump-my-version; extra == 'dev'
-Requires-Dist: pre-commit; extra == 'dev'
-Provides-Extra: docs
-Requires-Dist: griffe-inherited-docstrings>=1.0.0; extra == 'docs'
-Requires-Dist: mkdocs-jupyter>=0.24.5; extra == 'docs'
-Requires-Dist: mkdocs-material[imaging]>=9.5; extra == 'docs'
-Requires-Dist: mkdocs>=1.4.3; extra == 'docs'
-Requires-Dist: mkdocstrings[python]>=0.25.1; extra == 'docs'
-Requires-Dist: pygments; extra == 'docs'
 Provides-Extra: s3
 Requires-Dist: boto3; extra == 's3'
-Provides-Extra: test
-Requires-Dist: boto3; extra == 'test'
-Requires-Dist: h5netcdf; extra == 'test'
-Requires-Dist: morecantile<7.0,>=6.0; extra == 'test'
-Requires-Dist: pytest; extra == 'test'
-Requires-Dist: pytest-cov; extra == 'test'
-Requires-Dist: rioxarray; extra == 'test'
-Requires-Dist: vsifile>=0.2; extra == 'test'
-Requires-Dist: xarray; extra == 'test'
-Provides-Extra: tilebench
-Requires-Dist: pytest; extra == 'tilebench'
-Requires-Dist: tilebench; extra == 'tilebench'
 Provides-Extra: xarray
 Requires-Dist: rioxarray; extra == 'xarray'
 Requires-Dist: xarray; extra == 'xarray'
+Provides-Extra: zarr
+Requires-Dist: obstore; extra == 'zarr'
+Requires-Dist: zarr~=3.0; extra == 'zarr'
 Description-Content-Type: text/markdown
 
 # rio-tiler
@@ -264,17 +240,17 @@ At the low level, `rio-tiler` is *just* a wrapper around the [rasterio](https://
 You can install `rio-tiler` using pip
 
 ```bash
-$ python -m pip install -U pip
-$ python -m pip install -U rio-tiler
+python -m pip install -U pip
+python -m pip install -U rio-tiler
 ```
 
 or install from source:
 
 ```bash
-$ git clone https://github.com/cogeotiff/rio-tiler.git
-$ cd rio-tiler
-$ python -m pip install -U pip
-$ python -m pip install -e .
+git clone https://github.com/cogeotiff/rio-tiler.git
+cd rio-tiler
+python -m pip install -U pip
+python -m pip install -e .
 ```
 
 ## Plugins

{rio_tiler-7.9.2 → rio_tiler-8.0.0}/README.md

@@ -169,17 +169,17 @@ At the low level, `rio-tiler` is *just* a wrapper around the [rasterio](https://
 You can install `rio-tiler` using pip
 
 ```bash
-$ python -m pip install -U pip
-$ python -m pip install -U rio-tiler
+python -m pip install -U pip
+python -m pip install -U rio-tiler
 ```
 
 or install from source:
 
 ```bash
-$ git clone https://github.com/cogeotiff/rio-tiler.git
-$ cd rio-tiler
-$ python -m pip install -U pip
-$ python -m pip install -e .
+git clone https://github.com/cogeotiff/rio-tiler.git
+cd rio-tiler
+python -m pip install -U pip
+python -m pip install -e .
 ```
 
 ## Plugins

{rio_tiler-7.9.2 → rio_tiler-8.0.0}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "rio-tiler"
 description = "User friendly Rasterio plugin to read raster datasets."
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.11"
 license = {file = "LICENSE"}
 authors = [
     {name = "Vincent Sarago", email = "vincent@developmentseed.com"},
@@ -12,8 +12,6 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: BSD License",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -26,7 +24,7 @@ dependencies = [
     "httpx",
     "numexpr",
     "numpy",
-    "morecantile>=5.0,<7.0",
+    "morecantile>=5.0,<8.0",
     "pydantic~=2.0",
     "pystac>=1.9,<2.0",
     "rasterio>=1.4.0",
@@ -34,10 +32,11 @@ dependencies = [
     "typing-extensions",
 ]
 
-[project.optional-dependencies]
-test = [
+[dependency-groups]
+dev = [
     "pytest",
     "pytest-cov",
+    "pytest-benchmark",
     # XarrayReader
     "xarray",
     "rioxarray",
@@ -45,25 +44,34 @@ test = [
     # S3
     "boto3",
     # Some tests will fail with 5.0
-    "morecantile>=6.0,<7.0",
+    "morecantile>=6.0,<8.0",
     # Experimental
     "vsifile>=0.2",
+    "zarr~=3.0",
+    "obstore",
+    "tilebench",
+    "pre-commit",
+    "bump-my-version",
 ]
 
-benchmark = [
-    "pytest",
+performance = [
     "pytest-benchmark",
-]
-
-tilebench = [
-    "pytest",
     "tilebench",
 ]
 
-dev = [
-    "pre-commit",
-    "bump-my-version",
+docs = [
+    "mkdocs>=1.4.3",
+    "mkdocs-jupyter>=0.24.5",
+    "mkdocs-material[imaging]>=9.5",
+    "griffe-inherited-docstrings>=1.0.0",
+    "mkdocstrings[python]>=0.25.1",
+    "pygments",
 ]
+deploy = [
+    "hatch",
+]
+
+[project.optional-dependencies]
 s3 = [
     "boto3",
 ]
@@ -71,13 +79,9 @@ xarray = [
     "xarray",
     "rioxarray",
 ]
-docs = [
-    "mkdocs>=1.4.3",
-    "mkdocs-jupyter>=0.24.5",
-    "mkdocs-material[imaging]>=9.5",
-    "griffe-inherited-docstrings>=1.0.0",
-    "mkdocstrings[python]>=0.25.1",
-    "pygments",
+zarr = [
+    "zarr~=3.0",
+    "obstore",
 ]
 
 [project.urls]
@@ -87,28 +91,18 @@ Issues = "https://github.com/cogeotiff/rio-tiler/issues"
 Source = "https://github.com/cogeotiff/rio-tiler"
 Changelog = "https://cogeotiff.github.io/rio-tiler/release-notes/"
 
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
 [tool.hatch.version]
 path = "rio_tiler/__init__.py"
 
 [tool.hatch.build.targets.sdist]
-exclude = [
-  "/tests",
-  "/docs",
-  ".github",
-  ".history",
-  ".bumpversion.cfg",
-  ".flake8",
-  ".gitignore",
-  ".pre-commit-config.yaml",
-  "AUTHORS.txt",
-  "CHANGES.md",
-  "CONTRIBUTING.md",
-]
+only-include = ["rio_tiler/"]
 
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+[tool.hatch.build.targets.wheel]
+only-include = ["rio_tiler/"]
 
 [tool.coverage.run]
 branch = true
@@ -161,7 +155,7 @@ exclude = [
 max-complexity = 14
 
 [tool.bumpversion]
-current_version = "7.9.2"
+current_version = "8.0.0"
 parse = """(?x)
     (?P<major>\\d+)\\.
     (?P<minor>\\d+)\\.
@@ -191,3 +185,8 @@ tag_name = "{new_version}"
 filename = "rio_tiler/__init__.py"
 search = '__version__ = "{current_version}"'
 replace = '__version__ = "{new_version}"'
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore::rio_tiler.errors.RioTilerExperimentalWarning",
+]

{rio_tiler-7.9.2 → rio_tiler-8.0.0}/rio_tiler/__init__.py

@@ -1,6 +1,6 @@
 """rio-tiler."""
 
-__version__ = "7.9.2"
+__version__ = "8.0.0"
 
 from . import (  # noqa
     colormap,

{rio_tiler-7.9.2 → rio_tiler-8.0.0}/rio_tiler/colormap.py

@@ -1,5 +1,6 @@
 """rio-tiler colormap functions and classes."""
 
+import itertools
 import json
 import os
 import pathlib
@@ -166,9 +167,10 @@ def apply_discrete_cmap(
 
     data = numpy.transpose(res, [2, 0, 1])
 
-    # If the output data has values between 0-255
+    # If colormap values are between 0-255
     # we cast the output array to Uint8
-    if data.min() >= 0 and data.max() <= 255:
+    cmap_v = list(itertools.chain(*colormap.values()))
+    if min(cmap_v) >= 0 and max(cmap_v) <= 255:
         data = data.astype("uint8")
 
     return data[:-1], data[-1]
@@ -206,9 +208,10 @@ def apply_intervals_cmap(
 
     data = numpy.transpose(res, [2, 0, 1])
 
-    # If the output data has values between 0-255
+    # If colormap values are between 0-255
     # we cast the output array to Uint8
-    if data.min() >= 0 and data.max() <= 255:
+    cmap_v = list(itertools.chain(*[v for k, v in colormap]))
+    if min(cmap_v) >= 0 and max(cmap_v) <= 255:
         data = data.astype("uint8")
 
     return data[:-1], data[-1]

{rio_tiler-7.9.2 → rio_tiler-8.0.0}/rio_tiler/errors.py

@@ -95,3 +95,11 @@ class InvalidGeographicBounds(RioTilerError):
 
 class RioTilerExperimentalWarning(UserWarning):
     """A rio-tiler specific experimental functionality warning."""
+
+
+class MaxArraySizeError(RioTilerError):
+    """Trying to load to many pixels in memory."""
+
+
+class NoAssetFoundError(RioTilerError):
+    """No Asset found"""

rio_tiler-8.0.0/rio_tiler/experimental/zarr.py

@@ -0,0 +1,366 @@
+"""rio_tiler experimental ZarrReaders."""
+
+from __future__ import annotations
+
+import contextlib
+from functools import cache
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from urllib.parse import urlparse
+
+import attr
+from morecantile import TileMatrixSet
+from rasterio.crs import CRS
+
+from rio_tiler.constants import WEB_MERCATOR_TMS, WGS84_CRS
+from rio_tiler.errors import InvalidGeographicBounds
+from rio_tiler.io.base import BaseReader
+from rio_tiler.io.xarray import XarrayReader
+from rio_tiler.models import BandStatistics, ImageData, Info, PointData
+from rio_tiler.types import BBox
+
+try:
+    import obstore
+    from zarr.storage import ObjectStore
+except ImportError:  # pragma: nocover
+    ObjectStore = None  # type: ignore
+    obstore = None  # type: ignore
+
+try:
+    import rioxarray
+    import xarray
+except ImportError:  # pragma: nocover
+    xarray = None  # type: ignore
+    rioxarray = None  # type: ignore
+
+sel_methods = Literal["nearest", "pad", "ffill", "backfill", "bfill"]
+
+
+@cache
+def open_dataset(src_path: str, **kwargs: Any) -> xarray.Dataset:
+    """Open Xarray dataset
+
+    Args:
+        src_path (str): dataset path.
+
+    Returns:
+        xarray.DataTree
+
+    """
+    parsed = urlparse(src_path)
+    if not parsed.scheme:
+        src_path = str(Path(src_path).resolve())
+        src_path = "file://" + src_path
+    store = obstore.store.from_url(src_path, **kwargs)
+    zarr_store = ObjectStore(store=store, read_only=True)
+    ds = xarray.open_dataset(
+        zarr_store,
+        decode_times=True,
+        decode_coords="all",
+        consolidated=True,
+        engine="zarr",
+    )
+    return ds
+
+
+@attr.s
+class ZarrReader(BaseReader):
+    """Zarr dataset Reader.
+
+    Attributes:
+        input (str): dataset path.
+        dataset (xarray.Dataset): Xarray dataset.
+        tms (morecantile.TileMatrixSet, optional): TileMatrixSet grid definition. Defaults to `WebMercatorQuad`.
+        opener (Callable): Xarray dataset opener. Defaults to `open_dataset`.
+        opener_options (dict): Options to forward to the opener callable.
+
+    Examples:
+        >>> with ZarrReader(
+                "s3://mur-sst/zarr-v1",
+                opener_options={
+                    "skip_signature": True,
+                    "region": "us-west-2",
+                }
+            ) as src:
+                print(src)
+                print(src.variables)
+                img = src.tile(x, y, z, tmax)
+
+    """
+
+    input: str = attr.ib()
+    dataset: xarray.Dataset = attr.ib(default=None)
+
+    tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
+
+    opener: Callable[..., xarray.Dataset] = attr.ib(default=open_dataset)
+    opener_options: Dict = attr.ib(factory=dict)
+    _ctx_stack: contextlib.ExitStack = attr.ib(init=False, factory=contextlib.ExitStack)
+
+    def __attrs_post_init__(self):
+        """Set bounds and CRS."""
+        assert xarray is not None, "xarray must be installed to use XarrayReader"
+        assert rioxarray is not None, "rioxarray must be installed to use XarrayReader"
+
+        if not self.dataset:
+            self.dataset = self._ctx_stack.enter_context(
+                self.opener(self.input, **self.opener_options)
+            )
+
+        # NOTE: rioxarray returns **ordered** bounds in form of (minx, miny, maxx, maxx)
+        self.bounds = tuple(self.dataset.rio.bounds())
+        # Make sure we have a valid CRS
+        self.dataset = self.dataset.rio.write_crs(
+            self.dataset.rio.crs or "epsg:4326",
+        )
+
+        self.crs = self.dataset.rio.crs
+
+        # adds half x/y resolution on each values
+        # https://github.com/corteva/rioxarray/issues/645#issuecomment-1461070634
+        xres, yres = map(abs, self.dataset.rio.resolution())
+        if self.crs == WGS84_CRS and (
+            self.bounds[0] + xres / 2 < -180
+            or self.bounds[1] + yres / 2 < -90
+            or self.bounds[2] - xres / 2 > 180
+            or self.bounds[3] - yres / 2 > 90
+        ):
+            raise InvalidGeographicBounds(
+                f"Invalid geographic bounds: {self.bounds}. Must be within (-180, -90, 180, 90)."
+            )
+
+        self.transform = self.dataset.rio.transform()
+        self.height = self.dataset.rio.height
+        self.width = self.dataset.rio.width
+
+    def close(self):
+        """Close xarray dataset."""
+        self._ctx_stack.close()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Support using with Context Managers."""
+        self.close()
+
+    @property
+    def variables(self) -> List[str]:
+        """Return dataset variable names"""
+        return list(self.dataset.data_vars)
+
+    def _arrange_dims(self, da: xarray.DataArray) -> xarray.DataArray:
+        """Arrange coordinates and time dimensions.
+
+        An rioxarray.exceptions.InvalidDimensionOrder error is raised if the coordinates are not in the correct order time, y, and x.
+        See: https://github.com/corteva/rioxarray/discussions/674
+
+        We conform to using x and y as the spatial dimension names..
+
+        """
+        if "x" not in da.dims and "y" not in da.dims:
+            try:
+                latitude_var_name = next(
+                    name
+                    for name in ["lat", "latitude", "LAT", "LATITUDE", "Lat"]
+                    if name in da.dims
+                )
+                longitude_var_name = next(
+                    name
+                    for name in ["lon", "longitude", "LON", "LONGITUDE", "Lon"]
+                    if name in da.dims
+                )
+            except StopIteration as e:
+                raise ValueError(f"Couldn't find X/Y dimensions in {da.dims}") from e
+
+            da = da.rename({latitude_var_name: "y", longitude_var_name: "x"})
+
+        if "TIME" in da.dims:
+            da = da.rename({"TIME": "time"})
+
+        if extra_dims := [d for d in da.dims if d not in ["x", "y"]]:
+            da = da.transpose(*extra_dims, "y", "x")
+        else:
+            da = da.transpose("y", "x")
+
+        # If min/max values are stored in `valid_range` we add them in `valid_min/valid_max`
+        vmin, vmax = da.attrs.get("valid_min"), da.attrs.get("valid_max")
+        if "valid_range" in da.attrs and not (vmin is not None and vmax is not None):
+            valid_range = da.attrs.get("valid_range")
+            da.attrs.update({"valid_min": valid_range[0], "valid_max": valid_range[1]})
+
+        return da
+
+    def _get_variable(
+        self,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+    ) -> xarray.DataArray:
+        """Get DataArray from xarray Dataset."""
+        da = self.dataset[variable]
+
+        if sel:
+            _idx: Dict[str, List] = {}
+            for s in sel:
+                val: Union[str, slice]
+                dim, val = s.split("=")
+
+                # cast string to dtype of the dimension
+                if da[dim].dtype != "O":
+                    val = da[dim].dtype.type(val)
+
+                if dim in _idx:
+                    _idx[dim].append(val)
+                else:
+                    _idx[dim] = [val]
+
+            sel_idx = {k: v[0] if len(v) < 2 else v for k, v in _idx.items()}
+            da = da.sel(sel_idx, method=method)
+
+        da = self._arrange_dims(da)
+
+        # Make sure we have a valid CRS
+        crs = da.rio.crs or "epsg:4326"
+        da = da.rio.write_crs(crs)
+
+        if crs == "epsg:4326" and (da.x > 180).any():
+            # Adjust the longitude coordinates to the -180 to 180 range
+            da = da.assign_coords(x=(da.x + 180) % 360 - 180)
+
+            # Sort the dataset by the updated longitude coordinates
+            da = da.sortby(da.x)
+
+        assert len(da.dims) in [
+            2,
+            3,
+        ], "rio_tiler.io.xarray.DatasetReader can only work with 2D or 3D DataArray"
+
+        return da
+
+    def spatial_info(  # type: ignore
+        self,
+        *,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+    ):
+        """Return xarray.DataArray info."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+        ) as da:
+            return {
+                "crs": da.crs,
+                "bounds": da.bounds,
+                "minzoom": da.minzoom,
+                "maxzoom": da.maxzoom,
+            }
+
+    def get_geographic_bounds(  # type: ignore
+        self,
+        crs: CRS,
+        *,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+    ) -> BBox:
+        """Return Geographic Bounds for a Geographic CRS."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+        ) as da:
+            return da.get_geographic_bounds(crs)
+
+    def info(  # type: ignore
+        self,
+        *,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+    ) -> Info:
+        """Return xarray.DataArray info."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+        ) as da:
+            return da.info()
+
+    def statistics(  # type: ignore
+        self,
+        *args: Any,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+        **kwargs: Any,
+    ) -> Dict[str, BandStatistics]:
+        """Return statistics from a dataset."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+        ) as da:
+            return da.statistics(*args, **kwargs)
+
+    def tile(  # type: ignore
+        self,
+        *args: Any,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+        **kwargs: Any,
+    ) -> ImageData:
+        """Read a Web Map tile from a dataset."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+            tms=self.tms,
+        ) as da:
+            return da.tile(*args, **kwargs)
+
+    def part(  # type: ignore
+        self,
+        *args: Any,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+        **kwargs: Any,
+    ) -> ImageData:
+        """Read part of a dataset."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+        ) as da:
+            return da.part(*args, **kwargs)
+
+    def preview(  # type: ignore
+        self,
+        *args: Any,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+        **kwargs: Any,
+    ) -> ImageData:
+        """Return a preview of a dataset."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+        ) as da:
+            return da.preview(*args, **kwargs)
+
+    def point(  # type: ignore
+        self,
+        *args: Any,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+        **kwargs: Any,
+    ) -> PointData:
+        """Read a pixel value from a dataset."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+        ) as da:
+            return da.point(*args, **kwargs)
+
+    def feature(  # type: ignore
+        self,
+        *args: Any,
+        variable: str,
+        sel: Optional[List[str]] = None,
+        method: Optional[sel_methods] = None,
+        **kwargs: Any,
+    ) -> ImageData:
+        """Read part of a dataset defined by a geojson feature."""
+        with XarrayReader(
+            self._get_variable(variable, sel=sel, method=method),
+        ) as da:
+            return da.feature(*args, **kwargs)