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

rio_tiler/io/base.py

@@ -4,8 +4,9 @@ import abc
 import contextlib
 import re
 import warnings
+from collections.abc import Sequence
 from functools import cached_property
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, Union, cast
+from typing import Any, cast
 
 import attr
 import numpy
@@ -44,9 +45,9 @@ class SpatialMixin:
     bounds: BBox = attr.ib(init=False)
     crs: CRS = attr.ib(init=False)
 
-    transform: Optional[Affine] = attr.ib(default=None, init=False)
-    height: Optional[int] = attr.ib(default=None, init=False)
-    width: Optional[int] = attr.ib(default=None, init=False)
+    transform: Affine | None = attr.ib(default=None, init=False)
+    height: int | None = attr.ib(default=None, init=False)
+    width: int | None = attr.ib(default=None, init=False)
 
     def get_geographic_bounds(self, crs: CRS) -> BBox:
         """Return Geographic Bounds for a Geographic CRS."""
@@ -238,11 +239,11 @@ class BaseReader(SpatialMixin, metaclass=abc.ABCMeta):
         ...
 
     @abc.abstractmethod
-    def statistics(self) -> Dict[str, BandStatistics]:
+    def statistics(self) -> dict[str, BandStatistics]:
         """Return bands statistics from a dataset.
 
         Returns:
-            Dict[str, rio_tiler.models.BandStatistics]: bands statistics.
+            dict[str, rio_tiler.models.BandStatistics]: bands statistics.
 
         """
         ...
@@ -300,7 +301,7 @@ class BaseReader(SpatialMixin, metaclass=abc.ABCMeta):
         ...
 
     @abc.abstractmethod
-    def feature(self, shape: Dict) -> ImageData:
+    def feature(self, shape: dict) -> ImageData:
         """Read a Dataset for a GeoJSON feature.
 
         Args:
@@ -331,16 +332,16 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
     input: Any = attr.ib()
     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)
 
-    reader: Type[BaseReader] = attr.ib(init=False)
-    reader_options: Dict = attr.ib(factory=dict)
+    reader: type[BaseReader] = attr.ib(init=False)
+    reader_options: dict = attr.ib(factory=dict)
 
     assets: Sequence[str] = attr.ib(init=False)
-    default_assets: Optional[Sequence[str]] = attr.ib(init=False, default=None)
+    default_assets: Sequence[str] | None = attr.ib(init=False, default=None)
 
-    ctx: Type[contextlib.AbstractContextManager] = attr.ib(
+    ctx: type[contextlib.AbstractContextManager] = attr.ib(
         init=False, default=contextlib.nullcontext
     )
 
@@ -357,34 +358,15 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
         """Validate asset name and construct url."""
         ...
 
-    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 and options."""
         return self.reader, {}
 
-    def parse_expression(self, expression: str, asset_as_band: bool = False) -> Tuple:
-        """Parse rio-tiler band math expression."""
-        input_assets = "|".join(self.assets)
-
-        if asset_as_band:
-            _re = re.compile(rf"\b({input_assets})\b")
-        else:
-            _re = re.compile(rf"\b({input_assets})_b\d+\b")
-
-        assets = tuple(set(re.findall(_re, expression)))
-        if not assets:
-            raise InvalidExpression(
-                f"Could not find any valid assets in '{expression}' expression. Assets are: {self.assets}"
-                if asset_as_band
-                else f"Could not find any valid assets in '{expression}' expression, maybe try with `asset_as_band=True`. Assets are: {self.assets}"
-            )
-
-        return assets
-
     def _update_statistics(
         self,
         img: ImageData,
-        indexes: Optional[Indexes] = None,
-        statistics: Optional[Sequence[Tuple[float, float]]] = None,
+        indexes: Indexes | None = None,
+        statistics: Sequence[tuple[float, float]] | None = None,
     ):
         """Update ImageData Statistics from AssetInfo."""
         indexes = cast_to_sequence(indexes)
@@ -400,9 +382,9 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
 
     def info(
         self,
-        assets: Optional[Union[Sequence[str], str]] = None,
+        assets: Sequence[str] | str | None = None,
         **kwargs: Any,
-    ) -> Dict[str, Info]:
+    ) -> dict[str, Info]:
         """Return metadata from multiple assets.
 
         Args:
@@ -419,33 +401,26 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
             )
         assets = cast_to_sequence(assets or self.assets)
 
-        def _reader(asset: str, **kwargs: Any) -> Dict:
+        def _reader(asset: str, **kwargs: Any) -> dict:
             asset_info = self._get_asset_info(asset)
-            reader, options = self._get_reader(asset_info)
+            reader, reader_options = self._get_reader(asset_info)
 
+            options = {**self.reader_options, **reader_options}
             with self.ctx(**asset_info.get("env", {})):
-                with reader(
-                    asset_info["url"],
-                    tms=self.tms,
-                    **{**self.reader_options, **options},
-                ) as src:
-                    return src.info()
+                with reader(asset_info["url"], tms=self.tms, **options) as src:
+                    return src.info(**asset_info["method_options"])
 
         return multi_values(assets, _reader, **kwargs)
 
     def statistics(
         self,
-        assets: Optional[Union[Sequence[str], str]] = None,
-        asset_indexes: Optional[Dict[str, Indexes]] = None,
-        asset_expression: Optional[Dict[str, str]] = None,
+        assets: Sequence[str] | str | None = None,
         **kwargs: Any,
-    ) -> Dict[str, Dict[str, BandStatistics]]:
+    ) -> dict[str, dict[str, BandStatistics]]:
         """Return array statistics for multiple assets.
 
         Args:
             assets (sequence of str or str): assets to fetch info from.
-            asset_indexes (dict, optional): Band indexes for each asset (e.g {"asset1": 1, "asset2": (1, 2,)}).
-            asset_expression (dict, optional): rio-tiler expression for each asset (e.g. {"asset1": "b1/b2+b3", "asset2": ...}).
             kwargs (optional): Options to forward to the `self.reader.statistics` method.
 
         Returns:
@@ -459,46 +434,35 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
             )
 
         assets = cast_to_sequence(assets or self.assets)
-        asset_indexes = asset_indexes or {}
-        asset_expression = asset_expression or {}
 
-        def _reader(asset: str, *args: Any, **kwargs: Any) -> Dict:
+        def _reader(asset: str, *args: Any, **kwargs: Any) -> dict:
             asset_info = self._get_asset_info(asset)
-            reader, options = self._get_reader(asset_info)
+            reader, reader_options = self._get_reader(asset_info)
 
+            options = {**self.reader_options, **reader_options}
             with self.ctx(**asset_info.get("env", {})):
-                with reader(
-                    asset_info["url"],
-                    tms=self.tms,
-                    **{**self.reader_options, **options},
-                ) as src:
-                    return src.statistics(
-                        *args,
-                        indexes=asset_indexes.get(asset, kwargs.pop("indexes", None)),
-                        expression=asset_expression.get(asset),
-                        **kwargs,
-                    )
+                with reader(asset_info["url"], tms=self.tms, **options) as src:
+                    method_options = {**asset_info["method_options"], **kwargs}
+                    return src.statistics(*args, **method_options)
 
         return multi_values(assets, _reader, **kwargs)
 
     def merged_statistics(
         self,
-        assets: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
-        asset_indexes: Optional[Dict[str, Indexes]] = None,
+        assets: Sequence[str] | str | None = None,
+        expression: str | None = None,
         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,
         **kwargs: Any,
-    ) -> Dict[str, BandStatistics]:
+    ) -> dict[str, BandStatistics]:
         """Return array statistics for multiple assets.
 
         Args:
             assets (sequence of str or str): assets to fetch info from.
-            expression (str, optional): rio-tiler expression for the asset list (e.g. asset1/asset2+asset3).
-            asset_indexes (dict, optional): Band indexes for each asset (e.g {"asset1": 1, "asset2": (1, 2,)}).
+            expression (str, optional): rio-tiler expression (e.g. b1/b2+b3).
             categorical (bool): treat input data as categorical data. Defaults to False.
             categories (list of numbers, optional): list of categories to return value for.
             percentiles (list of numbers, optional): list of percentile values to calculate. Defaults to `[2, 98]`.
@@ -511,18 +475,16 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
             Dict[str, rio_tiler.models.BandStatistics]: bands statistics.
 
         """
-        if not expression:
-            if not assets:
-                warnings.warn(
-                    "No `assets` option passed, will fetch statistics for all available assets.",
-                    UserWarning,
-                )
-            assets = cast_to_sequence(assets or self.assets)
+        if not assets:
+            warnings.warn(
+                "No `assets` option passed, will fetch statistics for all available assets.",
+                UserWarning,
+            )
+        assets = cast_to_sequence(assets or self.assets)
 
         data = self.preview(
             assets=assets,
             expression=expression,
-            asset_indexes=asset_indexes,
             max_size=max_size,
             **kwargs,
         )
@@ -538,9 +500,8 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
         tile_x: int,
         tile_y: int,
         tile_z: int,
-        assets: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
-        asset_indexes: Optional[Dict[str, Indexes]] = None,
+        assets: Sequence[str] | str | None = None,
+        expression: str | None = None,
         asset_as_band: bool = False,
         **kwargs: Any,
     ) -> ImageData:
@@ -551,87 +512,73 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
             tile_y (int): Tile's vertical index.
             tile_z (int): Tile's zoom level index.
             assets (sequence of str or str, optional): assets to fetch info from.
-            expression (str, optional): rio-tiler expression for the asset list (e.g. asset1/asset2+asset3).
-            asset_indexes (dict, optional): Band indexes for each asset (e.g {"asset1": 1, "asset2": (1, 2,)}).
+            expression (str, optional): rio-tiler expression (e.g. b1/b2+b3).
+            asset_as_band (bool, optional): treat each asset as a separate band. Defaults to False.
             kwargs (optional): Options to forward to the `self.reader.tile` method.
 
         Returns:
             rio_tiler.models.ImageData: ImageData instance with data, mask and tile spatial info.
 
         """
+        if kwargs.pop("asset_indexes", None):
+            warnings.warn(
+                "`asset_indexes` parameter is deprecated in `tile` method and will be ignored.",
+                DeprecationWarning,
+            )
+
         if not self.tile_exists(tile_x, tile_y, tile_z):
             raise TileOutsideBounds(
                 f"Tile(x={tile_x}, y={tile_y}, z={tile_z}) is outside bounds"
             )
 
         assets = cast_to_sequence(assets)
-        if assets and expression:
-            warnings.warn(
-                "Both expression and assets passed; expression will overwrite assets parameter.",
-                ExpressionMixingWarning,
-            )
-
-        if expression:
-            assets = self.parse_expression(expression, asset_as_band=asset_as_band)
-
         if not assets and self.default_assets:
             warnings.warn(
-                f"No assets/expression passed, defaults to {self.default_assets}",
+                f"No assets passed, defaults to {self.default_assets}",
                 UserWarning,
             )
             assets = self.default_assets
 
         if not assets:
             raise MissingAssets(
-                "assets must be passed via `expression` or `assets` options, or via class-level `default_assets`."
+                "No Asset defined by `assets` option or class-level `default_assets`."
             )
 
-        asset_indexes = asset_indexes or {}
-
-        # We fall back to `indexes` if provided
-        indexes = kwargs.pop("indexes", None)
-
         def _reader(asset: str, *args: Any, **kwargs: Any) -> ImageData:
-            idx = asset_indexes.get(asset) or indexes
-
             asset_info = self._get_asset_info(asset)
-            reader, options = self._get_reader(asset_info)
+            asset_name = asset_info["name"]
+            reader, reader_options = self._get_reader(asset_info)
 
+            options = {**self.reader_options, **reader_options}
             with self.ctx(**asset_info.get("env", {})):
-                with reader(
-                    asset_info["url"],
-                    tms=self.tms,
-                    **{**self.reader_options, **options},
-                ) as src:
-                    data = src.tile(*args, indexes=idx, **kwargs)
+                with reader(asset_info["url"], tms=self.tms, **options) as src:
+                    method_options = {**asset_info["method_options"], **kwargs}
+                    data = src.tile(*args, **method_options)
 
                     self._update_statistics(
-                        data,
-                        indexes=idx,
-                        statistics=asset_info.get("dataset_statistics"),
+                        data, statistics=asset_info.get("dataset_statistics")
                     )
 
                     metadata = data.metadata or {}
                     if m := asset_info.get("metadata"):
                         metadata.update(m)
+                    data.metadata = {asset_name: metadata}
                     data.metadata = {asset: metadata}
 
+                    data.band_descriptions = [
+                        f"{asset_name}_{n}" for n in data.band_descriptions
+                    ]
                     if asset_as_band:
                         if len(data.band_names) > 1:
                             raise AssetAsBandError(
                                 "Can't use `asset_as_band` for multibands asset"
                             )
-                        data.band_names = [asset]
-                        data.band_descriptions = [asset]
-                    else:
-                        data.band_names = [f"{asset}_{n}" for n in data.band_names]
-                        data.band_descriptions = [
-                            f"{asset}_{n}" for n in data.band_descriptions
-                        ]
+                        data.band_descriptions = [asset_name]
 
                     return data
 
         img = multi_arrays(assets, _reader, tile_x, tile_y, tile_z, **kwargs)
+        img.band_names = [f"b{ix + 1}" for ix in range(img.count)]
         if expression:
             return img.apply_expression(expression)
 
@@ -640,9 +587,8 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
     def part(
         self,
         bbox: BBox,
-        assets: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
-        asset_indexes: Optional[Dict[str, Indexes]] = None,
+        assets: Sequence[str] | str | None = None,
+        expression: str | None = None,
         asset_as_band: bool = False,
         **kwargs: Any,
     ) -> ImageData:
@@ -651,24 +597,21 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
         Args:
             bbox (tuple): Output bounds (left, bottom, right, top) in target crs.
             assets (sequence of str or str, optional): assets to fetch info from.
-            expression (str, optional): rio-tiler expression for the asset list (e.g. asset1/asset2+asset3).
-            asset_indexes (dict, optional): Band indexes for each asset (e.g {"asset1": 1, "asset2": (1, 2,)}).
+            expression (str, optional): rio-tiler expression (e.g. b1/b2+b3).
+            asset_as_band (bool, optional): treat each asset as a separate band. Defaults to False.
             kwargs (optional): Options to forward to the `self.reader.part` method.
 
         Returns:
             rio_tiler.models.ImageData: ImageData instance with data, mask and tile spatial info.
 
         """
-        assets = cast_to_sequence(assets)
-        if assets and expression:
+        if kwargs.pop("asset_indexes", None):
             warnings.warn(
-                "Both expression and assets passed; expression will overwrite assets parameter.",
-                ExpressionMixingWarning,
+                "`asset_indexes` parameter is deprecated in `tile` method and will be ignored.",
+                DeprecationWarning,
             )
 
-        if expression:
-            assets = self.parse_expression(expression, asset_as_band=asset_as_band)
-
+        assets = cast_to_sequence(assets)
         if not assets and self.default_assets:
             warnings.warn(
                 f"No assets/expression passed, defaults to {self.default_assets}",
@@ -678,55 +621,44 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         if not assets:
             raise MissingAssets(
-                "assets must be passed via `expression` or `assets` options, or via class-level `default_assets`."
+                "No Asset defined by `assets` option or class-level `default_assets`."
             )
 
-        asset_indexes = asset_indexes or {}
-
-        # We fall back to `indexes` if provided
-        indexes = kwargs.pop("indexes", None)
-
         def _reader(asset: str, *args: Any, **kwargs: Any) -> ImageData:
-            idx = asset_indexes.get(asset) or indexes
-
             asset_info = self._get_asset_info(asset)
-            reader, options = self._get_reader(asset_info)
+            asset_name = asset_info["name"]
+            reader, reader_options = self._get_reader(asset_info)
 
+            options = {**self.reader_options, **reader_options}
             with self.ctx(**asset_info.get("env", {})):
-                with reader(
-                    asset_info["url"],
-                    tms=self.tms,
-                    **{**self.reader_options, **options},
-                ) as src:
-                    data = src.part(*args, indexes=idx, **kwargs)
+                with reader(asset_info["url"], tms=self.tms, **options) as src:
+                    method_options = {**asset_info["method_options"], **kwargs}
+                    data = src.part(*args, **method_options)
 
                     self._update_statistics(
                         data,
-                        indexes=idx,
                         statistics=asset_info.get("dataset_statistics"),
                     )
 
                     metadata = data.metadata or {}
                     if m := asset_info.get("metadata"):
                         metadata.update(m)
-                    data.metadata = {asset: metadata}
+                    data.metadata = {asset_name: metadata}
 
+                    data.band_descriptions = [
+                        f"{asset_name}_{n}" for n in data.band_descriptions
+                    ]
                     if asset_as_band:
                         if len(data.band_names) > 1:
                             raise AssetAsBandError(
                                 "Can't use `asset_as_band` for multibands asset"
                             )
-                        data.band_names = [asset]
-                        data.band_descriptions = [asset]
-                    else:
-                        data.band_names = [f"{asset}_{n}" for n in data.band_names]
-                        data.band_descriptions = [
-                            f"{asset}_{n}" for n in data.band_descriptions
-                        ]
+                        data.band_descriptions = [asset_name]
 
                     return data
 
         img = multi_arrays(assets, _reader, bbox, **kwargs)
+        img.band_names = [f"b{ix + 1}" for ix in range(img.count)]
         if expression:
             return img.apply_expression(expression)
 
@@ -734,9 +666,8 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
 
     def preview(
         self,
-        assets: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
-        asset_indexes: Optional[Dict[str, Indexes]] = None,
+        assets: Sequence[str] | str | None = None,
+        expression: str | None = None,
         asset_as_band: bool = False,
         **kwargs: Any,
     ) -> ImageData:
@@ -744,82 +675,68 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         Args:
             assets (sequence of str or str, optional): assets to fetch info from.
-            expression (str, optional): rio-tiler expression for the asset list (e.g. asset1/asset2+asset3).
-            asset_indexes (dict, optional): Band indexes for each asset (e.g {"asset1": 1, "asset2": (1, 2,)}).
+            expression (str, optional): rio-tiler expression (e.g. b1/b2+b3).
+            asset_as_band (bool, optional): treat each asset as a separate band. Defaults to False.
             kwargs (optional): Options to forward to the `self.reader.preview` method.
 
         Returns:
             rio_tiler.models.ImageData: ImageData instance with data, mask and tile spatial info.
 
         """
-        assets = cast_to_sequence(assets)
-        if assets and expression:
+        if kwargs.pop("asset_indexes", None):
             warnings.warn(
-                "Both expression and assets passed; expression will overwrite assets parameter.",
-                ExpressionMixingWarning,
+                "`asset_indexes` parameter is deprecated in `tile` method and will be ignored.",
+                DeprecationWarning,
             )
 
-        if expression:
-            assets = self.parse_expression(expression, asset_as_band=asset_as_band)
-
+        assets = cast_to_sequence(assets)
         if not assets and self.default_assets:
             warnings.warn(
-                f"No assets/expression passed, defaults to {self.default_assets}",
+                f"No assets passed, defaults to {self.default_assets}",
                 UserWarning,
             )
             assets = self.default_assets
 
         if not assets:
             raise MissingAssets(
-                "assets must be passed via `expression` or `assets` options, or via class-level `default_assets`."
+                "No Asset defined by `assets` option or class-level `default_assets`."
             )
 
-        asset_indexes = asset_indexes or {}
-
-        # We fall back to `indexes` if provided
-        indexes = kwargs.pop("indexes", None)
-
         def _reader(asset: str, **kwargs: Any) -> ImageData:
-            idx = asset_indexes.get(asset) or indexes
-
             asset_info = self._get_asset_info(asset)
-            reader, options = self._get_reader(asset_info)
+            asset_name = asset_info["name"]
+            reader, reader_options = self._get_reader(asset_info)
 
+            options = {**self.reader_options, **reader_options}
             with self.ctx(**asset_info.get("env", {})):
-                with reader(
-                    asset_info["url"],
-                    tms=self.tms,
-                    **{**self.reader_options, **options},
-                ) as src:
-                    data = src.preview(indexes=idx, **kwargs)
+                with reader(asset_info["url"], tms=self.tms, **options) as src:
+                    method_options = {**asset_info["method_options"], **kwargs}
+                    data = src.preview(**method_options)
 
                     self._update_statistics(
                         data,
-                        indexes=idx,
                         statistics=asset_info.get("dataset_statistics"),
                     )
 
                     metadata = data.metadata or {}
                     if m := asset_info.get("metadata"):
                         metadata.update(m)
-                    data.metadata = {asset: metadata}
+                    data.metadata = {asset_name: metadata}
 
+                    data.band_descriptions = [
+                        f"{asset_name}_{n}" for n in data.band_descriptions
+                    ]
                     if asset_as_band:
                         if len(data.band_names) > 1:
                             raise AssetAsBandError(
                                 "Can't use `asset_as_band` for multibands asset"
                             )
-                        data.band_names = [asset]
-                        data.band_descriptions = [asset]
-                    else:
-                        data.band_names = [f"{asset}_{n}" for n in data.band_names]
-                        data.band_descriptions = [
-                            f"{asset}_{n}" for n in data.band_descriptions
-                        ]
+                        data.band_descriptions = [asset_name]
 
                     return data
 
         img = multi_arrays(assets, _reader, **kwargs)
+        img.band_names = [f"b{ix + 1}" for ix in range(img.count)]
         if expression:
             return img.apply_expression(expression)
 
@@ -829,9 +746,8 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
         self,
         lon: float,
         lat: float,
-        assets: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
-        asset_indexes: Optional[Dict[str, Indexes]] = None,
+        assets: Sequence[str] | str | None = None,
+        expression: str | None = None,
         asset_as_band: bool = False,
         **kwargs: Any,
     ) -> PointData:
@@ -841,76 +757,63 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
             lon (float): Longitude.
             lat (float): Latitude.
             assets (sequence of str or str, optional): assets to fetch info from.
-            expression (str, optional): rio-tiler expression for the asset list (e.g. asset1/asset2+asset3).
-            asset_indexes (dict, optional): Band indexes for each asset (e.g {"asset1": 1, "asset2": (1, 2,)}).
+            expression (str, optional): rio-tiler expression (e.g. b1/b2+b3).
+            asset_as_band (bool, optional): treat each asset as a separate band. Defaults to False.
             kwargs (optional): Options to forward to the `self.reader.point` method.
 
         Returns:
             PointData
 
         """
-        assets = cast_to_sequence(assets)
-        if assets and expression:
+        if kwargs.pop("asset_indexes", None):
             warnings.warn(
-                "Both expression and assets passed; expression will overwrite assets parameter.",
-                ExpressionMixingWarning,
+                "`asset_indexes` parameter is deprecated in `tile` method and will be ignored.",
+                DeprecationWarning,
             )
 
-        if expression:
-            assets = self.parse_expression(expression, asset_as_band=asset_as_band)
-
+        assets = cast_to_sequence(assets)
         if not assets and self.default_assets:
             warnings.warn(
-                f"No assets/expression passed, defaults to {self.default_assets}",
+                f"No assets passed, defaults to {self.default_assets}",
                 UserWarning,
             )
             assets = self.default_assets
 
         if not assets:
             raise MissingAssets(
-                "assets must be passed via `expression` or `assets` options, or via class-level `default_assets`."
+                "No Asset defined by `assets` option or class-level `default_assets`."
             )
 
-        asset_indexes = asset_indexes or {}
-
-        # We fall back to `indexes` if provided
-        indexes = kwargs.pop("indexes", None)
-
         def _reader(asset: str, *args: Any, **kwargs: Any) -> PointData:
-            idx = asset_indexes.get(asset) or indexes
-
             asset_info = self._get_asset_info(asset)
-            reader, options = self._get_reader(asset_info)
+            asset_name = asset_info["name"]
+            reader, reader_options = self._get_reader(asset_info)
 
+            options = {**self.reader_options, **reader_options}
             with self.ctx(**asset_info.get("env", {})):
-                with reader(
-                    asset_info["url"],
-                    tms=self.tms,
-                    **{**self.reader_options, **options},
-                ) as src:
-                    data = src.point(*args, indexes=idx, **kwargs)
+                with reader(asset_info["url"], tms=self.tms, **options) as src:
+                    method_options = {**asset_info["method_options"], **kwargs}
+                    data = src.point(*args, **method_options)
 
                     metadata = data.metadata or {}
                     if m := asset_info.get("metadata"):
                         metadata.update(m)
-                    data.metadata = {asset: metadata}
+                    data.metadata = {asset_name: metadata}
 
+                    data.band_descriptions = [
+                        f"{asset_name}_{n}" for n in data.band_descriptions
+                    ]
                     if asset_as_band:
                         if len(data.band_names) > 1:
                             raise AssetAsBandError(
                                 "Can't use `asset_as_band` for multibands asset"
                             )
-                        data.band_names = [asset]
-                        data.band_descriptions = [asset]
-                    else:
-                        data.band_names = [f"{asset}_{n}" for n in data.band_names]
-                        data.band_descriptions = [
-                            f"{asset}_{n}" for n in data.band_descriptions
-                        ]
+                        data.band_descriptions = [asset_name]
 
                     return data
 
         data = multi_points(assets, _reader, lon, lat, **kwargs)
+        data.band_names = [f"b{ix + 1}" for ix in range(data.count)]
         if expression:
             return data.apply_expression(expression)
 
@@ -918,10 +821,9 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
 
     def feature(
         self,
-        shape: Dict,
-        assets: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
-        asset_indexes: Optional[Dict[str, Indexes]] = None,
+        shape: dict,
+        assets: Sequence[str] | str | None = None,
+        expression: str | None = None,
         asset_as_band: bool = False,
         **kwargs: Any,
     ) -> ImageData:
@@ -930,24 +832,21 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
         Args:
             shape (dict): Valid GeoJSON feature.
             assets (sequence of str or str, optional): assets to fetch info from.
-            expression (str, optional): rio-tiler expression for the asset list (e.g. asset1/asset2+asset3).
-            asset_indexes (dict, optional): Band indexes for each asset (e.g {"asset1": 1, "asset2": (1, 2,)}).
+            expression (str, optional): rio-tiler expression (e.g. b1/b2+b3).
+            asset_as_band (bool, optional): treat each asset as a separate band. Defaults to False.
             kwargs (optional): Options to forward to the `self.reader.feature` method.
 
         Returns:
             rio_tiler.models.ImageData: ImageData instance with data, mask and tile spatial info.
 
         """
-        assets = cast_to_sequence(assets)
-        if assets and expression:
+        if kwargs.pop("asset_indexes", None):
             warnings.warn(
-                "Both expression and assets passed; expression will overwrite assets parameter.",
-                ExpressionMixingWarning,
+                "`asset_indexes` parameter is deprecated in `tile` method and will be ignored.",
+                DeprecationWarning,
             )
 
-        if expression:
-            assets = self.parse_expression(expression, asset_as_band=asset_as_band)
-
+        assets = cast_to_sequence(assets)
         if not assets and self.default_assets:
             warnings.warn(
                 f"No assets/expression passed, defaults to {self.default_assets}",
@@ -957,55 +856,44 @@ class MultiBaseReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         if not assets:
             raise MissingAssets(
-                "assets must be passed via `expression` or `assets` options, or via class-level `default_assets`."
+                "No Asset defined by `assets` option or class-level `default_assets`."
             )
 
-        asset_indexes = asset_indexes or {}
-
-        # We fall back to `indexes` if provided
-        indexes = kwargs.pop("indexes", None)
-
         def _reader(asset: str, *args: Any, **kwargs: Any) -> ImageData:
-            idx = asset_indexes.get(asset) or indexes
-
             asset_info = self._get_asset_info(asset)
-            reader, options = self._get_reader(asset_info)
+            asset_name = asset_info["name"]
+            reader, reader_options = self._get_reader(asset_info)
 
+            options = {**self.reader_options, **reader_options}
             with self.ctx(**asset_info.get("env", {})):
-                with reader(
-                    asset_info["url"],
-                    tms=self.tms,
-                    **{**self.reader_options, **options},
-                ) as src:
-                    data = src.feature(*args, indexes=idx, **kwargs)
+                with reader(asset_info["url"], tms=self.tms, **options) as src:
+                    method_options = {**asset_info["method_options"], **kwargs}
+                    data = src.feature(*args, **method_options)
 
                     self._update_statistics(
                         data,
-                        indexes=idx,
                         statistics=asset_info.get("dataset_statistics"),
                     )
 
                     metadata = data.metadata or {}
                     if m := asset_info.get("metadata"):
                         metadata.update(m)
-                    data.metadata = {asset: metadata}
+                    data.metadata = {asset_name: metadata}
 
+                    data.band_descriptions = [
+                        f"{asset_name}_{n}" for n in data.band_descriptions
+                    ]
                     if asset_as_band:
                         if len(data.band_names) > 1:
                             raise AssetAsBandError(
                                 "Can't use `asset_as_band` for multibands asset"
                             )
-                        data.band_names = [asset]
-                        data.band_descriptions = [asset]
-                    else:
-                        data.band_names = [f"{asset}_{n}" for n in data.band_names]
-                        data.band_descriptions = [
-                            f"{asset}_{n}" for n in data.band_descriptions
-                        ]
+                        data.band_descriptions = [asset_name]
 
                     return data
 
         img = multi_arrays(assets, _reader, shape, **kwargs)
+        img.band_names = [f"b{ix + 1}" for ix in range(img.count)]
         if expression:
             return img.apply_expression(expression)
 
@@ -1030,14 +918,22 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
     input: Any = attr.ib()
     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)
 
-    reader: Type[BaseReader] = attr.ib(init=False)
-    reader_options: Dict = attr.ib(factory=dict)
+    reader: type[BaseReader] = attr.ib(init=False)
+    reader_options: dict = attr.ib(factory=dict)
 
     bands: Sequence[str] = attr.ib(init=False)
-    default_bands: Optional[Sequence[str]] = attr.ib(init=False, default=None)
+    default_bands: Sequence[str] | None = attr.ib(init=False, default=None)
+
+    def __attrs_post_init__(self):
+        """deprecation warning."""
+        warnings.warn(
+            "MultiBandReader is deprecated and will be removed in a future release. "
+            "Please use MultiBaseReader instead.",
+            DeprecationWarning,
+        )
 
     def __enter__(self):
         """Support using with Context Managers."""
@@ -1052,7 +948,7 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
         """Validate band name and construct url."""
         ...
 
-    def parse_expression(self, expression: str) -> Tuple:
+    def parse_expression(self, expression: str) -> tuple:
         """Parse rio-tiler band math expression."""
         input_bands = "|".join([rf"\b{band}\b" for band in self.bands])
         _re = re.compile(input_bands.replace("\\\\", "\\"))
@@ -1065,9 +961,16 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         return bands
 
+    def _expression_to_bidx(self, bands: Sequence[str], expression: str) -> str:
+        mapexpr = {b: f"b{idx + 1}" for idx, b in enumerate(bands)}
+        for b in bands:
+            _re = re.compile(rf"\b{b}\b")
+            expression = _re.sub(mapexpr[b], expression)
+        return expression
+
     def info(
         self,
-        bands: Optional[Union[Sequence[str], str]] = None,
+        bands: Sequence[str] | str | None = None,
         **kwargs: Any,
     ) -> Info:
         """Return metadata from multiple bands.
@@ -1089,11 +992,7 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         def _reader(band: str, **kwargs: Any) -> Info:
             url = self._get_band_url(band)
-            with self.reader(
-                url,
-                tms=self.tms,
-                **self.reader_options,
-            ) as src:
+            with self.reader(url, tms=self.tms, **self.reader_options) as src:
                 return src.info()
 
         bands_metadata = multi_values(bands, _reader, **kwargs)
@@ -1121,15 +1020,15 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
 
     def statistics(
         self,
-        bands: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
+        bands: Sequence[str] | str | None = None,
+        expression: str | None = None,
         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,
         **kwargs: Any,
-    ) -> Dict[str, BandStatistics]:
+    ) -> dict[str, BandStatistics]:
         """Return array statistics for multiple assets.
 
         Args:
@@ -1172,8 +1071,8 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
         tile_x: int,
         tile_y: int,
         tile_z: int,
-        bands: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
+        bands: Sequence[str] | str | None = None,
+        expression: str | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read and merge Web Map tiles multiple bands.
@@ -1219,24 +1118,19 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         def _reader(band: str, *args: Any, **kwargs: Any) -> ImageData:
             url = self._get_band_url(band)
-            with self.reader(
-                url,
-                tms=self.tms,
-                **self.reader_options,
-            ) as src:
+            with self.reader(url, tms=self.tms, **self.reader_options) as src:
                 data = src.tile(*args, **kwargs)
-
                 if data.metadata:
                     data.metadata = {band: data.metadata}
 
-                # use `band` as name instead of band index
-                data.band_names = [band]
-
+                # use `band` as name/description instead of band index
+                data.band_descriptions = [band]
                 return data
 
         img = multi_arrays(bands, _reader, tile_x, tile_y, tile_z, **kwargs)
-
+        img.band_names = [f"b{ix + 1}" for ix in range(img.count)]
         if expression:
+            expression = self._expression_to_bidx(img.band_descriptions, expression)
             return img.apply_expression(expression)
 
         return img
@@ -1244,8 +1138,8 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
     def part(
         self,
         bbox: BBox,
-        bands: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
+        bands: Sequence[str] | str | None = None,
+        expression: str | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read and merge parts from multiple bands.
@@ -1284,32 +1178,27 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         def _reader(band: str, *args: Any, **kwargs: Any) -> ImageData:
             url = self._get_band_url(band)
-            with self.reader(
-                url,
-                tms=self.tms,
-                **self.reader_options,
-            ) as src:
+            with self.reader(url, tms=self.tms, **self.reader_options) as src:
                 data = src.part(*args, **kwargs)
-
                 if data.metadata:
                     data.metadata = {band: data.metadata}
 
-                # use `band` as name instead of band index
-                data.band_names = [band]
-
+                # use `band` as name/description instead of band index
+                data.band_descriptions = [band]
                 return data
 
         img = multi_arrays(bands, _reader, bbox, **kwargs)
-
+        img.band_names = [f"b{ix + 1}" for ix in range(img.count)]
         if expression:
+            expression = self._expression_to_bidx(img.band_descriptions, expression)
             return img.apply_expression(expression)
 
         return img
 
     def preview(
         self,
-        bands: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
+        bands: Sequence[str] | str | None = None,
+        expression: str | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read and merge previews from multiple bands.
@@ -1347,24 +1236,19 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         def _reader(band: str, **kwargs: Any) -> ImageData:
             url = self._get_band_url(band)
-            with self.reader(
-                url,
-                tms=self.tms,
-                **self.reader_options,
-            ) as src:
+            with self.reader(url, tms=self.tms, **self.reader_options) as src:
                 data = src.preview(**kwargs)
-
                 if data.metadata:
                     data.metadata = {band: data.metadata}
 
-                # use `band` as name instead of band index
-                data.band_names = [band]
-
+                # use `band` as name/description instead of band index
+                data.band_descriptions = [band]
                 return data
 
         img = multi_arrays(bands, _reader, **kwargs)
-
+        img.band_names = [f"b{ix + 1}" for ix in range(img.count)]
         if expression:
+            expression = self._expression_to_bidx(img.band_descriptions, expression)
             return img.apply_expression(expression)
 
         return img
@@ -1373,8 +1257,8 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
         self,
         lon: float,
         lat: float,
-        bands: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
+        bands: Sequence[str] | str | None = None,
+        expression: str | None = None,
         **kwargs: Any,
     ) -> PointData:
         """Read a pixel values from multiple bands.
@@ -1414,32 +1298,28 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         def _reader(band: str, *args: Any, **kwargs: Any) -> PointData:
             url = self._get_band_url(band)
-            with self.reader(
-                url,
-                tms=self.tms,
-                **self.reader_options,
-            ) as src:
+            with self.reader(url, tms=self.tms, **self.reader_options) as src:
                 data = src.point(*args, **kwargs)
-
                 if data.metadata:
                     data.metadata = {band: data.metadata}
 
-                # use `band` as name instead of band index
-                data.band_names = [band]
-
+                # use `band` as name/description instead of band index
+                data.band_descriptions = [band]
                 return data
 
         data = multi_points(bands, _reader, lon, lat, **kwargs)
+        data.band_names = [f"b{ix + 1}" for ix in range(data.count)]
         if expression:
+            expression = self._expression_to_bidx(data.band_descriptions, expression)
             return data.apply_expression(expression)
 
         return data
 
     def feature(
         self,
-        shape: Dict,
-        bands: Optional[Union[Sequence[str], str]] = None,
-        expression: Optional[str] = None,
+        shape: dict,
+        bands: Sequence[str] | str | None = None,
+        expression: str | None = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read and merge parts defined by geojson feature from multiple bands.
@@ -1478,24 +1358,19 @@ class MultiBandReader(SpatialMixin, metaclass=abc.ABCMeta):
 
         def _reader(band: str, *args: Any, **kwargs: Any) -> ImageData:
             url = self._get_band_url(band)
-            with self.reader(
-                url,
-                tms=self.tms,
-                **self.reader_options,
-            ) as src:
+            with self.reader(url, tms=self.tms, **self.reader_options) as src:
                 data = src.feature(*args, **kwargs)
-
                 if data.metadata:
                     data.metadata = {band: data.metadata}
 
-                # use `band` as name instead of band index
-                data.band_names = [band]
-
+                # use `band` as name/description instead of band index
+                data.band_descriptions = [band]
                 return data
 
         img = multi_arrays(bands, _reader, shape, **kwargs)
-
+        img.band_names = [f"b{ix + 1}" for ix in range(img.count)]
         if expression:
+            expression = self._expression_to_bidx(img.band_descriptions, expression)
             return img.apply_expression(expression)
 
         return img