rio-tiler 6.8.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

rio_tiler/io/rasterio.py

@@ -19,7 +19,7 @@ from rasterio.io import DatasetReader, DatasetWriter, MemoryFile
 from rasterio.rio.overview import get_maximum_overview_level
 from rasterio.transform import from_bounds as transform_from_bounds
 from rasterio.vrt import WarpedVRT
-from rasterio.warp import calculate_default_transform, transform_geom
+from rasterio.warp import transform_geom
 from rasterio.windows import Window
 from rasterio.windows import from_bounds as window_from_bounds
 
@@ -35,7 +35,12 @@ 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.utils import _validate_shape_input, has_alpha_band, has_mask_band
+from rio_tiler.utils import (
+    CRS_to_uri,
+    _validate_shape_input,
+    has_alpha_band,
+    has_mask_band,
+)
 
 
 @attr.s
@@ -46,7 +51,6 @@ class Reader(BaseReader):
         input (str): dataset path.
         dataset (rasterio.io.DatasetReader or rasterio.io.DatasetWriter or rasterio.vrt.WarpedVRT, optional): Rasterio dataset.
         tms (morecantile.TileMatrixSet, optional): TileMatrixSet grid definition. Defaults to `WebMercatorQuad`.
-        geographic_crs (rasterio.crs.CRS, optional): CRS to use as geographic coordinate system. Defaults to WGS84.
         colormap (dict, optional): Overwrite internal colormap.
         options (dict, optional): Options to forward to low-level reader methods.
 
@@ -75,16 +79,13 @@ class Reader(BaseReader):
     )
 
     tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
-    geographic_crs: CRS = attr.ib(default=WGS84_CRS)
 
     colormap: Dict = attr.ib(default=None)
 
     options: reader.Options = attr.ib()
 
     # Context Manager to handle rasterio open/close
-    _ctx_stack = attr.ib(init=False, factory=contextlib.ExitStack)
-    _minzoom: int = attr.ib(init=False, default=None)
-    _maxzoom: int = attr.ib(init=False, default=None)
+    _ctx_stack: contextlib.ExitStack = attr.ib(init=False, factory=contextlib.ExitStack)
 
     @options.default
     def _options_default(self):
@@ -121,6 +122,10 @@ class Reader(BaseReader):
         self.bounds = tuple(self.dataset.bounds)
         self.crs = self.dataset.crs
 
+        self.transform = self.dataset.transform
+        self.height = self.dataset.height
+        self.width = self.dataset.width
+
         if self.colormap is None:
             self._get_colormap()
 
@@ -140,85 +145,15 @@ class Reader(BaseReader):
         """Support using with Context Managers."""
         self.close()
 
-    def _dst_geom_in_tms_crs(self):
-        """Return dataset info in TMS projection."""
-        tms_crs = self.tms.rasterio_crs
-        if self.crs != tms_crs:
-            dst_affine, w, h = calculate_default_transform(
-                self.crs,
-                tms_crs,
-                self.dataset.width,
-                self.dataset.height,
-                *self.dataset.bounds,
-            )
-        else:
-            dst_affine = list(self.dataset.transform)
-            w = self.dataset.width
-            h = self.dataset.height
-
-        return dst_affine, w, h
-
-    def get_minzoom(self) -> int:
-        """Define dataset minimum zoom level."""
-        if self._minzoom is None:
-            # We assume the TMS tilesize to be constant over all matrices
-            # ref: https://github.com/OSGeo/gdal/blob/dc38aa64d779ecc45e3cd15b1817b83216cf96b8/gdal/frmts/gtiff/cogdriver.cpp#L274
-            tilesize = self.tms.tileMatrices[0].tileWidth
-
-            try:
-                dst_affine, w, h = self._dst_geom_in_tms_crs()
-
-                # The minzoom is defined by the resolution of the maximum theoretical overview level
-                # We assume `tilesize`` is the smallest overview size
-                overview_level = get_maximum_overview_level(w, h, minsize=tilesize)
-
-                # Get the resolution of the overview
-                resolution = max(abs(dst_affine[0]), abs(dst_affine[4]))
-                ovr_resolution = resolution * (2**overview_level)
-
-                # Find what TMS matrix match the overview resolution
-                self._minzoom = self.tms.zoom_for_res(ovr_resolution)
-
-            except:  # noqa
-                # if we can't get max zoom from the dataset we default to TMS maxzoom
-                warnings.warn(
-                    "Cannot determine minzoom based on dataset information, will default to TMS minzoom.",
-                    UserWarning,
-                )
-                self._minzoom = self.tms.minzoom
-
-        return self._minzoom
-
-    def get_maxzoom(self) -> int:
-        """Define dataset maximum zoom level."""
-        if self._maxzoom is None:
-            try:
-                dst_affine, _, _ = self._dst_geom_in_tms_crs()
-
-                # The maxzoom is defined by finding the minimum difference between
-                # the raster resolution and the zoom level resolution
-                resolution = max(abs(dst_affine[0]), abs(dst_affine[4]))
-                self._maxzoom = self.tms.zoom_for_res(resolution)
-
-            except:  # noqa
-                # if we can't get min/max zoom from the dataset we default to TMS maxzoom
-                warnings.warn(
-                    "Cannot determine maxzoom based on dataset information, will default to TMS maxzoom.",
-                    UserWarning,
-                )
-                self._maxzoom = self.tms.maxzoom
-
-        return self._maxzoom
-
     @property
     def minzoom(self):
         """Return dataset minzoom."""
-        return self.get_minzoom()
+        return self._minzoom
 
     @property
     def maxzoom(self):
         """Return dataset maxzoom."""
-        return self.get_maxzoom()
+        return self._maxzoom
 
     def _get_colormap(self):
         """Retrieve the internal colormap."""
@@ -245,9 +180,8 @@ class Reader(BaseReader):
             nodata_type = "None"
 
         meta = {
-            "bounds": self.geographic_bounds,
-            "minzoom": self.minzoom,
-            "maxzoom": self.maxzoom,
+            "bounds": self.bounds,
+            "crs": CRS_to_uri(self.crs) or self.crs.to_wkt(),
             "band_metadata": [
                 (f"b{ix}", self.dataset.tags(ix)) for ix in self.dataset.indexes
             ],
@@ -346,13 +280,10 @@ class Reader(BaseReader):
                 f"Tile(x={tile_x}, y={tile_y}, z={tile_z}) is outside bounds"
             )
 
-        tile_bounds = self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z))
-        dst_crs = self.tms.rasterio_crs
-
         return self.part(
-            tile_bounds,
-            dst_crs=dst_crs,
-            bounds_crs=dst_crs,
+            tuple(self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z))),
+            dst_crs=self.tms.rasterio_crs,
+            bounds_crs=self.tms.rasterio_crs,
             height=tilesize,
             width=tilesize,
             max_size=None,
@@ -664,8 +595,6 @@ class ImageReader(Reader):
     tms: TileMatrixSet = attr.ib(init=False)
 
     crs: CRS = attr.ib(init=False, default=None)
-    geographic_crs: CRS = attr.ib(init=False, default=None)
-
     transform: Affine = attr.ib(init=False)
 
     def __attrs_post_init__(self):
@@ -676,23 +605,30 @@ class ImageReader(Reader):
 
         height, width = self.dataset.height, self.dataset.width
         self.bounds = (0, height, width, 0)
-        self.transform = transform_from_bounds(*self.bounds, width=width, height=height)
-
         self.tms = LocalTileMatrixSet(width=width, height=height)
-        self._minzoom = self.tms.minzoom
-        self._maxzoom = self.tms.maxzoom
+        self.transform = transform_from_bounds(*self.bounds, width=width, height=height)
+        self.height = height
+        self.width = width
 
         if self.colormap is None:
             self._get_colormap()
 
-        if min(
-            self.dataset.width, self.dataset.height
-        ) > 512 and not self.dataset.overviews(1):
+        if min(width, height) > 512 and not self.dataset.overviews(1):
             warnings.warn(
                 "The dataset has no Overviews. rio-tiler performances might be impacted.",
                 NoOverviewWarning,
             )
 
+    @property
+    def minzoom(self):
+        """Return dataset minzoom."""
+        return self.tms.minzoom
+
+    @property
+    def maxzoom(self):
+        """Return dataset maxzoom."""
+        return self.tms.maxzoom
+
     def tile(  # type: ignore
         self,
         tile_x: int,
@@ -731,10 +667,8 @@ class ImageReader(Reader):
                 f"Tile {tile_z}/{tile_x}/{tile_y} is outside {self.input} bounds"
             )
 
-        tile_bounds = self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z))
-
         return self.part(
-            tile_bounds,
+            tuple(self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z))),
             height=tilesize,
             width=tilesize,
             max_size=None,
@@ -822,8 +756,8 @@ class ImageReader(Reader):
         """Read a pixel value from an Image.
 
         Args:
-            lon (float): X coordinate.
-            lat (float): Y coordinate.
+            x (float): X coordinate.
+            y (float): Y coordinate.
             indexes (sequence of int or int, optional): Band indexes.
             expression (str, optional): rio-tiler expression (e.g. b1/b2+b3).
             unscale (bool, optional): Apply 'scales' and 'offsets' on output data value. Defaults to `False`.

rio_tiler/io/stac.py

@@ -3,7 +3,7 @@
 import json
 import os
 import warnings
-from typing import Any, Dict, Iterator, Optional, Set, Tuple, Type, Union
+from typing import Any, Dict, Iterator, Optional, Sequence, Set, Tuple, Type, Union
 from urllib.parse import urlparse
 
 import attr
@@ -13,7 +13,7 @@ import rasterio
 from cachetools import LRUCache, cached
 from cachetools.keys import hashkey
 from morecantile import TileMatrixSet
-from rasterio.crs import CRS
+from rasterio.transform import array_bounds
 
 from rio_tiler.constants import WEB_MERCATOR_TMS, WGS84_CRS
 from rio_tiler.errors import InvalidAssetName, MissingAssets
@@ -175,7 +175,7 @@ def _to_pystac_item(item: Union[None, Dict, pystac.Item]) -> Union[None, pystac.
     """Attr converter to convert to Dict to pystac.Item
 
     Args:
-        stac_item (Union[Dict, pystac.Item]): STAC Item.
+        item (Union[Dict, pystac.Item]): STAC Item.
 
     Returns
         pystac.Item: pystac STAC item object.
@@ -197,11 +197,11 @@ class STACReader(MultiBaseReader):
         tms (morecantile.TileMatrixSet, optional): TileMatrixSet grid definition. Defaults to `WebMercatorQuad`.
         minzoom (int, optional): Set minzoom for the tiles.
         maxzoom (int, optional): Set maxzoom for the tiles.
-        geographic_crs (rasterio.crs.CRS, optional): CRS to use as geographic coordinate system. Defaults to WGS84.
         include_assets (set of string, optional): Only Include specific assets.
         exclude_assets (set of string, optional): Exclude specific assets.
         include_asset_types (set of string, optional): Only include some assets base on their type.
         exclude_asset_types (set of string, optional): Exclude some assets base on their type.
+        default_assets (list of string, optional): Default assets to use if none are defined.
         reader (rio_tiler.io.BaseReader, optional): rio-tiler Reader. Defaults to `rio_tiler.io.Reader`.
         reader_options (dict, optional): Additional option to forward to the Reader. Defaults to `{}`.
         fetch_options (dict, optional): Options to pass to `rio_tiler.io.stac.fetch` function fetching the STAC Items. Defaults to `{}`.
@@ -229,10 +229,8 @@ class STACReader(MultiBaseReader):
     item: pystac.Item = attr.ib(default=None, converter=_to_pystac_item)
 
     tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
-    minzoom: int = attr.ib()
-    maxzoom: int = attr.ib()
-
-    geographic_crs: CRS = attr.ib(default=WGS84_CRS)
+    minzoom: int = attr.ib(default=None)
+    maxzoom: int = attr.ib(default=None)
 
     include_assets: Optional[Set[str]] = attr.ib(default=None)
     exclude_assets: Optional[Set[str]] = attr.ib(default=None)
@@ -240,12 +238,15 @@ class STACReader(MultiBaseReader):
     include_asset_types: Set[str] = attr.ib(default=DEFAULT_VALID_TYPE)
     exclude_asset_types: Optional[Set[str]] = attr.ib(default=None)
 
+    assets: Sequence[str] = attr.ib(init=False)
+    default_assets: Optional[Sequence[str]] = attr.ib(default=None)
+
     reader: Type[BaseReader] = attr.ib(default=Reader)
     reader_options: Dict = attr.ib(factory=dict)
 
     fetch_options: Dict = attr.ib(factory=dict)
 
-    ctx: Any = attr.ib(default=rasterio.Env)
+    ctx: rasterio.Env = attr.ib(default=rasterio.Env)
 
     def __attrs_post_init__(self):
         """Fetch STAC Item and get list of valid assets."""
@@ -253,10 +254,25 @@ class STACReader(MultiBaseReader):
             fetch(self.input, **self.fetch_options), self.input
         )
 
-        # TODO: get bounds/crs using PROJ extension if available
-        self.bounds = self.item.bbox
+        self.bounds = tuple(self.item.bbox)
         self.crs = WGS84_CRS
 
+        if hasattr(self.item, "ext") and self.item.ext.has("proj"):
+            if all(
+                [
+                    self.item.ext.proj.transform,
+                    self.item.ext.proj.shape,
+                    self.item.ext.proj.crs_string,
+                ]
+            ):
+                self.height, self.width = self.item.ext.proj.shape
+                self.transform = self.item.ext.proj.transform
+                self.bounds = array_bounds(self.height, self.width, self.transform)
+                self.crs = rasterio.crs.CRS.from_string(self.item.ext.proj.crs_string)
+
+        self.minzoom = self.minzoom if self.minzoom is not None else self._minzoom
+        self.maxzoom = self.maxzoom if self.maxzoom is not None else self._maxzoom
+
         self.assets = list(
             _get_assets(
                 self.item,
@@ -269,13 +285,9 @@ class STACReader(MultiBaseReader):
         if not self.assets:
             raise MissingAssets("No valid asset found. Asset's media types not supported")
 
-    @minzoom.default
-    def _minzoom(self):
-        return self.tms.minzoom
-
-    @maxzoom.default
-    def _maxzoom(self):
-        return self.tms.maxzoom
+    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]]:
         if asset.startswith("vrt://") and asset not in self.assets:
@@ -322,12 +334,16 @@ class STACReader(MultiBaseReader):
             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 (bands := extras.get("raster:bands")) and not vrt_options:
+        if extras.get("raster:bands") and not vrt_options:
+            bands = extras.get("raster:bands")
             stats = [
                 (b["statistics"]["minimum"], b["statistics"]["maximum"])
                 for b in bands

rio_tiler/io/xarray.py

@@ -2,14 +2,12 @@
 
 from __future__ import annotations
 
-import warnings
 from typing import Any, Dict, List, Optional
 
 import attr
 from morecantile import Tile, TileMatrixSet
 from rasterio.crs import CRS
 from rasterio.enums import Resampling
-from rasterio.rio.overview import get_maximum_overview_level
 from rasterio.transform import from_bounds, rowcol
 from rasterio.warp import calculate_default_transform
 from rasterio.warp import transform as transform_coords
@@ -24,7 +22,7 @@ from rio_tiler.errors import (
 from rio_tiler.io.base import BaseReader
 from rio_tiler.models import BandStatistics, ImageData, Info, PointData
 from rio_tiler.types import BBox, NoData, WarpResampling
-from rio_tiler.utils import _validate_shape_input
+from rio_tiler.utils import CRS_to_uri, _validate_shape_input
 
 try:
     import xarray
@@ -44,7 +42,6 @@ class XarrayReader(BaseReader):
     Attributes:
         dataset (xarray.DataArray): Xarray DataArray dataset.
         tms (morecantile.TileMatrixSet, optional): TileMatrixSet grid definition. Defaults to `WebMercatorQuad`.
-        geographic_crs (rasterio.crs.CRS, optional): CRS to use as geographic coordinate system. Defaults to WGS84.
 
     Examples:
         >>> ds = xarray.open_dataset(
@@ -63,10 +60,6 @@ class XarrayReader(BaseReader):
     input: xarray.DataArray = attr.ib()
 
     tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
-    geographic_crs: CRS = attr.ib(default=WGS84_CRS)
-
-    _minzoom: int = attr.ib(init=False, default=None)
-    _maxzoom: int = attr.ib(init=False, default=None)
 
     _dims: List = attr.ib(init=False, factory=list)
 
@@ -84,100 +77,34 @@ class XarrayReader(BaseReader):
             )
 
         if self.crs == WGS84_CRS and (
-            self.bounds[0] < -180
-            or self.bounds[1] < -90
-            or self.bounds[2] > 180
-            or self.bounds[3] > 90
+            round(self.bounds[0]) < -180
+            or round(self.bounds[1]) < -90
+            or round(self.bounds[2]) > 180
+            or round(self.bounds[3]) > 90
         ):
             raise InvalidGeographicBounds(
                 f"Invalid geographic bounds: {self.bounds}. Must be within (-180, -90, 180, 90)."
             )
 
+        self.transform = self.input.rio.transform()
+        self.height = self.input.rio.height
+        self.width = self.input.rio.width
+
         self._dims = [
             d
             for d in self.input.dims
             if d not in [self.input.rio.x_dim, self.input.rio.y_dim]
         ]
 
-    def _dst_geom_in_tms_crs(self):
-        """Return dataset info in TMS projection."""
-        tms_crs = self.tms.rasterio_crs
-        if self.crs != tms_crs:
-            dst_affine, w, h = calculate_default_transform(
-                self.crs,
-                tms_crs,
-                self.input.rio.width,
-                self.input.rio.height,
-                *self.bounds,
-            )
-        else:
-            dst_affine = list(self.input.rio.transform())
-            w = self.input.rio.width
-            h = self.input.rio.height
-
-        return dst_affine, w, h
-
-    def get_minzoom(self) -> int:
-        """Define dataset minimum zoom level."""
-        if self._minzoom is None:
-            # We assume the TMS tilesize to be constant over all matrices
-            # ref: https://github.com/OSGeo/gdal/blob/dc38aa64d779ecc45e3cd15b1817b83216cf96b8/gdal/frmts/gtiff/cogdriver.cpp#L274
-            tilesize = self.tms.tileMatrices[0].tileWidth
-
-            try:
-                dst_affine, w, h = self._dst_geom_in_tms_crs()
-
-                # The minzoom is defined by the resolution of the maximum theoretical overview level
-                # We assume `tilesize`` is the smallest overview size
-                overview_level = get_maximum_overview_level(w, h, minsize=tilesize)
-
-                # Get the resolution of the overview
-                resolution = max(abs(dst_affine[0]), abs(dst_affine[4]))
-                ovr_resolution = resolution * (2**overview_level)
-
-                # Find what TMS matrix match the overview resolution
-                self._minzoom = self.tms.zoom_for_res(ovr_resolution)
-
-            except:  # noqa
-                # if we can't get min/max zoom from the dataset we default to TMS maxzoom
-                warnings.warn(
-                    "Cannot determine maxzoom based on dataset information, will default to TMS maxzoom.",
-                    UserWarning,
-                )
-                self._minzoom = self.tms.maxzoom
-
-        return self._minzoom
-
-    def get_maxzoom(self) -> int:
-        """Define dataset maximum zoom level."""
-        if self._maxzoom is None:
-            try:
-                dst_affine, _, _ = self._dst_geom_in_tms_crs()
-
-                # The maxzoom is defined by finding the minimum difference between
-                # the raster resolution and the zoom level resolution
-                resolution = max(abs(dst_affine[0]), abs(dst_affine[4]))
-                self._maxzoom = self.tms.zoom_for_res(resolution)
-
-            except:  # noqa
-                # if we can't get min/max zoom from the dataset we default to TMS maxzoom
-                warnings.warn(
-                    "Cannot determine maxzoom based on dataset information, will default to TMS maxzoom.",
-                    UserWarning,
-                )
-                self._maxzoom = self.tms.maxzoom
-
-        return self._maxzoom
-
     @property
     def minzoom(self):
         """Return dataset minzoom."""
-        return self.get_minzoom()
+        return self._minzoom
 
     @property
     def maxzoom(self):
         """Return dataset maxzoom."""
-        return self.get_maxzoom()
+        return self._maxzoom
 
     @property
     def band_names(self) -> List[str]:
@@ -190,9 +117,8 @@ class XarrayReader(BaseReader):
         metadata = [band.attrs for d in self._dims for band in self.input[d]]
 
         meta = {
-            "bounds": self.geographic_bounds,
-            "minzoom": self.minzoom,
-            "maxzoom": self.maxzoom,
+            "bounds": self.bounds,
+            "crs": CRS_to_uri(self.crs),
             "band_metadata": [(f"b{ix}", v) for ix, v in enumerate(metadata, 1)],
             "band_descriptions": [(f"b{ix}", v) for ix, v in enumerate(bands, 1)],
             "dtype": str(self.input.dtype),
@@ -223,7 +149,6 @@ class XarrayReader(BaseReader):
         tile_y: int,
         tile_z: int,
         tilesize: int = 256,
-        resampling_method: Optional[WarpResampling] = None,
         reproject_method: WarpResampling = "nearest",
         auto_expand: bool = True,
         nodata: Optional[NoData] = None,
@@ -235,7 +160,6 @@ class XarrayReader(BaseReader):
             tile_y (int): Tile's vertical index.
             tile_z (int): Tile's zoom level index.
             tilesize (int, optional): Output image size. Defaults to `256`.
-            resampling_method (WarpResampling, optional): **DEPRECATED**, WarpKernel resampling algorithm. Defaults to `nearest`.
             reproject_method (WarpResampling, optional): WarpKernel resampling algorithm. Defaults to `nearest`.
             auto_expand (boolean, optional): When True, rioxarray's clip_box will expand clip search if only 1D raster found with clip. When False, will throw `OneDimensionalRaster` error if only 1 x or y data point is found. Defaults to True.
             nodata (int or float, optional): Overwrite dataset internal nodata value.
@@ -244,13 +168,6 @@ class XarrayReader(BaseReader):
             rio_tiler.models.ImageData: ImageData instance with data, mask and tile spatial info.
 
         """
-        if resampling_method:
-            warnings.warn(
-                "`resampling_method` is deprecated and will be removed in rio-tiler 7.0, please use `reproject_method`",
-                DeprecationWarning,
-            )
-            reproject_method = resampling_method
-
         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"
@@ -260,7 +177,7 @@ class XarrayReader(BaseReader):
         if nodata is not None:
             ds = ds.rio.write_nodata(nodata)
 
-        tile_bounds = self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z))
+        tile_bounds = tuple(self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z)))
         dst_crs = self.tms.rasterio_crs
 
         # Create source array by clipping the xarray dataset to extent of the tile.
@@ -299,7 +216,6 @@ class XarrayReader(BaseReader):
         bbox: BBox,
         dst_crs: Optional[CRS] = None,
         bounds_crs: CRS = WGS84_CRS,
-        resampling_method: Optional[WarpResampling] = None,
         reproject_method: WarpResampling = "nearest",
         auto_expand: bool = True,
         nodata: Optional[NoData] = None,
@@ -310,7 +226,6 @@ class XarrayReader(BaseReader):
             bbox (tuple): Output bounds (left, bottom, right, top) in target crs ("dst_crs").
             dst_crs (rasterio.crs.CRS, optional): Overwrite target coordinate reference system.
             bounds_crs (rasterio.crs.CRS, optional): Bounds Coordinate Reference System. Defaults to `epsg:4326`.
-            resampling_method (WarpResampling, optional): **DEPRECATED**, WarpKernel resampling algorithm. Defaults to `nearest`.
             reproject_method (WarpResampling, optional): WarpKernel resampling algorithm. Defaults to `nearest`.
             auto_expand (boolean, optional): When True, rioxarray's clip_box will expand clip search if only 1D raster found with clip. When False, will throw `OneDimensionalRaster` error if only 1 x or y data point is found. Defaults to True.
             nodata (int or float, optional): Overwrite dataset internal nodata value.
@@ -319,13 +234,6 @@ class XarrayReader(BaseReader):
             rio_tiler.models.ImageData: ImageData instance with data, mask and input spatial info.
 
         """
-        if resampling_method:
-            warnings.warn(
-                "`resampling_method` is deprecated and will be removed in rio-tiler 7.0, please use `reproject_method`",
-                DeprecationWarning,
-            )
-            reproject_method = resampling_method
-
         dst_crs = dst_crs or bounds_crs
 
         ds = self.input
@@ -438,7 +346,6 @@ class XarrayReader(BaseReader):
         shape: Dict,
         dst_crs: Optional[CRS] = None,
         shape_crs: CRS = WGS84_CRS,
-        resampling_method: Optional[WarpResampling] = None,
         reproject_method: WarpResampling = "nearest",
         nodata: Optional[NoData] = None,
     ) -> ImageData:
@@ -448,7 +355,6 @@ class XarrayReader(BaseReader):
             shape (dict): Valid GeoJSON feature.
             dst_crs (rasterio.crs.CRS, optional): Overwrite target coordinate reference system.
             shape_crs (rasterio.crs.CRS, optional): Input geojson coordinate reference system. Defaults to `epsg:4326`.
-            resampling_method (WarpResampling, optional): **DEPRECATED**, WarpKernel resampling algorithm. Defaults to `nearest`.
             reproject_method (WarpResampling, optional): WarpKernel resampling algorithm. Defaults to `nearest`.
             nodata (int or float, optional): Overwrite dataset internal nodata value.
 
@@ -456,13 +362,6 @@ class XarrayReader(BaseReader):
             rio_tiler.models.ImageData: ImageData instance with data, mask and input spatial info.
 
         """
-        if resampling_method:
-            warnings.warn(
-                "`resampling_method` is deprecated and will be removed in rio-tiler 7.0, please use `reproject_method`",
-                DeprecationWarning,
-            )
-            reproject_method = resampling_method
-
         if not dst_crs:
             dst_crs = shape_crs