rio-tiler 8.0.4__py3-none-any.whl → 9.0.0a1__py3-none-any.whl

rio_tiler/io/rasterio.py

@@ -2,7 +2,8 @@
 
 import contextlib
 import warnings
-from typing import Any, Callable, Dict, List, Optional, Sequence, Union, cast
+from collections.abc import Callable
+from typing import Any, cast
 
 import attr
 import numpy
@@ -34,7 +35,7 @@ from rio_tiler.errors import (
 from rio_tiler.expression import parse_expression
 from rio_tiler.io.base import BaseReader
 from rio_tiler.models import BandStatistics, ImageData, Info, PointData
-from rio_tiler.types import BBox, Indexes, NumType, RIOResampling
+from rio_tiler.types import BBox, Indexes, RIOResampling
 from rio_tiler.utils import (
     CRS_to_uri,
     _validate_shape_input,
@@ -73,14 +74,14 @@ class Reader(BaseReader):
 
     """
 
-    input: str = attr.ib()
-    dataset: Union[DatasetReader, DatasetWriter, MemoryFile, WarpedVRT] = attr.ib(
+    input: str | None = attr.ib()
+    dataset: DatasetReader | DatasetWriter | MemoryFile | WarpedVRT | None = attr.ib(
         default=None
     )
 
     tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
 
-    colormap: Dict = attr.ib(default=None)
+    colormap: dict | None = attr.ib(default=None)
 
     options: reader.Options = attr.ib()
 
@@ -168,7 +169,7 @@ class Reader(BaseReader):
 
         def _get_descr(ix):
             """Return band description."""
-            return self.dataset.descriptions[ix - 1] or ""
+            return self.dataset.descriptions[ix - 1] or f"b{ix}"
 
         if self.options.get("nodata", self.dataset.nodata) is not None:
             nodata_type = "Nodata"
@@ -214,14 +215,14 @@ class Reader(BaseReader):
     def statistics(
         self,
         categorical: bool = False,
-        categories: Optional[List[float]] = None,
-        percentiles: Optional[List[int]] = None,
-        hist_options: Optional[Dict] = None,
+        categories: list[float] | None = None,
+        percentiles: list[int] | None = None,
+        hist_options: dict | None = None,
         max_size: int = 1024,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
         **kwargs: Any,
-    ) -> Dict[str, BandStatistics]:
+    ) -> dict[str, BandStatistics]:
         """Return bands statistics from a dataset.
 
         Args:
@@ -253,10 +254,10 @@ class Reader(BaseReader):
         tile_x: int,
         tile_y: int,
         tile_z: int,
-        tilesize: int = 256,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
-        buffer: Optional[float] = None,
+        tilesize: int | None = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
+        buffer: float | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read a Web Map tile from a Dataset.
@@ -265,7 +266,7 @@ class Reader(BaseReader):
             tile_x (int): Tile's horizontal index.
             tile_y (int): Tile's vertical index.
             tile_z (int): Tile's zoom level index.
-            tilesize (int, optional): Output image size. Defaults to `256`.
+            tilesize (int, optional): Output image size.
             indexes (int or sequence of int, optional): Band indexes.
             expression (str, optional): rio-tiler expression (e.g. b1/b2+b3).
             buffer (float, optional): Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * tile_buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).
@@ -280,12 +281,18 @@ class Reader(BaseReader):
                 f"Tile(x={tile_x}, y={tile_y}, z={tile_z}) is outside bounds"
             )
 
+        matrix = self.tms.matrix(tile_z)
+        bbox = cast(
+            BBox,
+            self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z)),
+        )
+
         return self.part(
-            cast(BBox, self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z))),
+            bbox,
             dst_crs=self.tms.rasterio_crs,
             bounds_crs=self.tms.rasterio_crs,
-            height=tilesize,
-            width=tilesize,
+            height=tilesize or matrix.tileHeight,
+            width=tilesize or matrix.tileWidth,
             max_size=None,
             indexes=indexes,
             expression=expression,
@@ -296,14 +303,14 @@ class Reader(BaseReader):
     def part(
         self,
         bbox: BBox,
-        dst_crs: Optional[CRS] = None,
+        dst_crs: CRS | None = None,
         bounds_crs: CRS = WGS84_CRS,
-        indexes: Optional[Union[int, Sequence]] = None,
-        expression: Optional[str] = None,
-        max_size: Optional[int] = None,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        buffer: Optional[float] = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
+        max_size: int | None = None,
+        height: int | None = None,
+        width: int | None = None,
+        buffer: float | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read part of a Dataset.
@@ -359,11 +366,11 @@ class Reader(BaseReader):
 
     def preview(
         self,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
         max_size: int = 1024,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
+        height: int | None = None,
+        width: int | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Return a preview of a Dataset.
@@ -394,8 +401,8 @@ class Reader(BaseReader):
         lon: float,
         lat: float,
         coord_crs: CRS = WGS84_CRS,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
         **kwargs: Any,
     ) -> PointData:
         """Read a pixel value from a Dataset.
@@ -435,15 +442,15 @@ class Reader(BaseReader):
 
     def feature(
         self,
-        shape: Dict,
-        dst_crs: Optional[CRS] = None,
+        shape: dict,
+        dst_crs: CRS | None = None,
         shape_crs: CRS = WGS84_CRS,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
-        max_size: Optional[int] = None,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        buffer: Optional[NumType] = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
+        max_size: int | None = None,
+        height: int | None = None,
+        width: int | None = None,
+        buffer: float | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read part of a Dataset defined by a geojson feature.
@@ -514,8 +521,8 @@ class Reader(BaseReader):
 
     def read(
         self,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read the Dataset.
@@ -560,7 +567,7 @@ class LocalTileMatrixSet:
     minzoom: int = attr.ib(init=False, default=0)
     maxzoom: int = attr.ib(init=False)
 
-    rasterio_crs: CRS = attr.ib(init=False, default=None)
+    rasterio_crs: CRS | None = attr.ib(init=False, default=None)
 
     @maxzoom.default
     def _maxzoom(self):
@@ -592,9 +599,9 @@ class LocalTileMatrixSet:
 class ImageReader(Reader):
     """Non Geo Image Reader"""
 
-    tms: TileMatrixSet = attr.ib(init=False)
+    tms: LocalTileMatrixSet = attr.ib(init=False)  # type: ignore[assignment]
 
-    crs: CRS = attr.ib(init=False, default=None)
+    crs: CRS | None = attr.ib(init=False, default=None)
     transform: Affine = attr.ib(init=False)
 
     def __attrs_post_init__(self):
@@ -634,15 +641,14 @@ class ImageReader(Reader):
         tile_x: int,
         tile_y: int,
         tile_z: int,
-        tilesize: int = 256,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
-        out_dtype: Optional[Union[str, numpy.dtype]] = None,
+        tilesize: int | None = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
+        out_dtype: str | numpy.dtype | None = None,
         resampling_method: RIOResampling = "nearest",
         unscale: bool = False,
-        post_process: Optional[
-            Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]
-        ] = None,
+        post_process: Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]
+        | None = None,
     ) -> ImageData:
         """Read a Web Map tile from an Image.
 
@@ -666,10 +672,15 @@ class ImageReader(Reader):
                 f"Tile {tile_z}/{tile_x}/{tile_y} is outside {self.input} bounds"
             )
 
+        bbox = cast(
+            BBox,
+            self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z)),
+        )
+
         return self.part(
-            cast(BBox, self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z))),
-            height=tilesize,
-            width=tilesize,
+            bbox,
+            height=tilesize or self.tms.tile_size,
+            width=tilesize or self.tms.tile_size,
             max_size=None,
             indexes=indexes,
             expression=expression,
@@ -682,17 +693,16 @@ class ImageReader(Reader):
     def part(  # type: ignore
         self,
         bbox: BBox,
-        indexes: Optional[Union[int, Sequence]] = None,
-        expression: Optional[str] = None,
-        max_size: Optional[int] = None,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        out_dtype: Optional[Union[str, numpy.dtype]] = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
+        max_size: int | None = None,
+        height: int | None = None,
+        width: int | None = None,
+        out_dtype: str | numpy.dtype | None = None,
         resampling_method: RIOResampling = "nearest",
         unscale: bool = False,
-        post_process: Optional[
-            Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]
-        ] = None,
+        post_process: Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]
+        | None = None,
     ) -> ImageData:
         """Read part of an Image.
 
@@ -744,14 +754,13 @@ class ImageReader(Reader):
         self,
         x: float,
         y: float,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
-        out_dtype: Optional[Union[str, numpy.dtype]] = None,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
+        out_dtype: str | numpy.dtype | None = None,
         resampling_method: RIOResampling = "nearest",
         unscale: bool = False,
-        post_process: Optional[
-            Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]
-        ] = None,
+        post_process: Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]
+        | None = None,
     ) -> PointData:
         """Read a pixel value from an Image.
 
@@ -793,18 +802,17 @@ class ImageReader(Reader):
 
     def feature(  # type: ignore
         self,
-        shape: Dict,
-        indexes: Optional[Indexes] = None,
-        expression: Optional[str] = None,
-        max_size: Optional[int] = None,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        out_dtype: Optional[Union[str, numpy.dtype]] = None,
+        shape: dict,
+        indexes: Indexes | None = None,
+        expression: str | None = None,
+        max_size: int | None = None,
+        height: int | None = None,
+        width: int | None = None,
+        out_dtype: str | numpy.dtype | None = None,
         resampling_method: RIOResampling = "nearest",
         unscale: bool = False,
-        post_process: Optional[
-            Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]
-        ] = None,
+        post_process: Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]
+        | None = None,
     ) -> ImageData:
         """Read part of an Image defined by a geojson feature."""
         bbox = featureBounds(shape)

rio_tiler/io/stac.py

@@ -3,18 +3,8 @@
 import json
 import os
 import warnings
-from typing import (
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
-    Union,
-)
+from collections.abc import Iterator, Sequence
+from typing import Any
 from urllib.parse import urlparse
 
 import attr
@@ -111,7 +101,7 @@ def aws_get_object(
     LRUCache(maxsize=512),
     key=lambda filepath, **kargs: hashkey(filepath, json.dumps(kargs)),
 )
-def fetch(filepath: str, **kwargs: Any) -> Dict:
+def fetch(filepath: str, **kwargs: Any) -> dict:
     """Fetch STAC items.
 
     A LRU cache is set on top of this function.
@@ -142,11 +132,11 @@ def fetch(filepath: str, **kwargs: Any) -> Dict:
 
 def _get_assets(
     stac_item: pystac.Item,
-    include: Optional[Set[str]] = None,
-    exclude: Optional[Set[str]] = None,
-    include_asset_types: Optional[Set[str]] = None,
-    exclude_asset_types: Optional[Set[str]] = None,
-) -> Iterator:
+    include: set[str] | None = None,
+    exclude: set[str] | None = None,
+    include_asset_types: set[str] | None = None,
+    exclude_asset_types: set[str] | None = None,
+) -> Iterator[str]:
     """Get valid asset list.
 
     Args:
@@ -183,7 +173,7 @@ def _get_assets(
         yield asset
 
 
-def _to_pystac_item(item: Union[None, Dict, pystac.Item]) -> Union[None, pystac.Item]:
+def _to_pystac_item(item: dict | pystac.Item | None) -> pystac.Item | None:
     """Attr converter to convert to Dict to pystac.Item
 
     Args:
@@ -193,7 +183,7 @@ def _to_pystac_item(item: Union[None, Dict, pystac.Item]) -> Union[None, pystac.
         pystac.Item: pystac STAC item object.
 
     """
-    if isinstance(item, Dict):
+    if isinstance(item, dict):
         return pystac.Item.from_dict(item)
 
     return item
@@ -237,26 +227,26 @@ class STACReader(MultiBaseReader):
 
     """
 
-    input: str = attr.ib()
-    item: pystac.Item = attr.ib(default=None, converter=_to_pystac_item)
+    input: str | None = attr.ib()
+    item: pystac.Item | None = attr.ib(default=None, converter=_to_pystac_item)
 
     tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
-    minzoom: int = attr.ib(default=None)
-    maxzoom: int = attr.ib(default=None)
+    minzoom: int | None = attr.ib(default=None)
+    maxzoom: int | None = attr.ib(default=None)
 
-    include_assets: Optional[Set[str]] = attr.ib(default=None)
-    exclude_assets: Optional[Set[str]] = attr.ib(default=None)
+    include_assets: set[str] | None = attr.ib(default=None)
+    exclude_assets: set[str] | None = attr.ib(default=None)
 
-    include_asset_types: Set[str] = attr.ib(default=DEFAULT_VALID_TYPE)
-    exclude_asset_types: Optional[Set[str]] = attr.ib(default=None)
+    include_asset_types: set[str] = attr.ib(default=DEFAULT_VALID_TYPE)
+    exclude_asset_types: set[str] | None = attr.ib(default=None)
 
     assets: Sequence[str] = attr.ib(init=False)
-    default_assets: Optional[Sequence[str]] = attr.ib(default=None)
+    default_assets: Sequence[str] | None = attr.ib(default=None)
 
-    reader: Type[BaseReader] = attr.ib(default=Reader)
-    reader_options: Dict = attr.ib(factory=dict)
+    reader: type[BaseReader] = attr.ib(default=Reader)
+    reader_options: dict = attr.ib(factory=dict)
 
-    fetch_options: Dict = attr.ib(factory=dict)
+    fetch_options: dict = attr.ib(factory=dict)
 
     ctx: rasterio.Env = attr.ib(default=rasterio.Env)
 
@@ -289,7 +279,7 @@ class STACReader(MultiBaseReader):
         if not self.assets:
             raise MissingAssets("No valid asset found. Asset's media types not supported")
 
-    def get_asset_list(self) -> List[str]:
+    def get_asset_list(self) -> list[str]:
         """Get valid asset list"""
         return list(
             _get_assets(
@@ -301,11 +291,11 @@ class STACReader(MultiBaseReader):
             )
         )
 
-    def _get_reader(self, asset_info: AssetInfo) -> Tuple[Type[BaseReader], Dict]:
+    def _get_reader(self, asset_info: AssetInfo) -> tuple[type[BaseReader], dict]:
         """Get Asset Reader."""
         return self.reader, {}
 
-    def _parse_vrt_asset(self, asset: str) -> Tuple[str, Optional[str]]:
+    def _parse_vrt_asset(self, asset: str) -> tuple[str, str | None]:
         if asset.startswith("vrt://") and asset not in self.assets:
             parsed = urlparse(asset)
             if not parsed.netloc:
@@ -333,33 +323,52 @@ class STACReader(MultiBaseReader):
 
         """
         asset, vrt_options = self._parse_vrt_asset(asset)
+
+        method_options: dict[str, Any] = {}
+
+        # NOTE: asset can be in form of
+        # "{asset_name}|some_option=some_value&another_option=another_value"
+        if "|" in asset:
+            asset, params = asset.split("|", 1)
+            # NOTE: Construct method options from params
+            if params:
+                for param in params.split("&"):
+                    key, value = param.split("=", 1)
+                    if key == "indexes":
+                        method_options["indexes"] = list(map(int, value.split(",")))
+                    elif key == "expression":
+                        method_options["expression"] = value
+
         if asset not in self.assets:
             raise InvalidAssetName(
                 f"'{asset}' is not valid, should be one of {self.assets}"
             )
 
+        asset_modified = "expression" in method_options or vrt_options
+
         asset_info = self.item.assets[asset]
         extras = asset_info.extra_fields
 
         info = AssetInfo(
             url=asset_info.get_absolute_href() or asset_info.href,
-            metadata=extras if not vrt_options else None,
+            name=asset,
+            media_type=asset_info.media_type,
+            method_options=method_options,
         )
 
+        if not asset_modified:
+            info["metadata"] = extras
+
         if STAC_ALTERNATE_KEY and extras.get("alternate"):
             if alternate := extras["alternate"].get(STAC_ALTERNATE_KEY):
                 info["url"] = alternate["href"]
 
-        if asset_info.media_type:
-            info["media_type"] = asset_info.media_type
-
         # https://github.com/stac-extensions/file
         if head := extras.get("file:header_size"):
             info["env"] = {"GDAL_INGESTED_BYTES_AT_OPEN": head}
 
         # https://github.com/stac-extensions/raster
-        if extras.get("raster:bands") and not vrt_options:
-            bands = extras.get("raster:bands")
+        if (bands := extras.get("raster:bands", [])) and not asset_modified:
             stats = [
                 (b["statistics"]["minimum"], b["statistics"]["maximum"])
                 for b in bands