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

rio_tiler/io/xarray.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import math
 import os
 import warnings
-from typing import Any, Dict, List, Tuple, cast
+from typing import Any, cast
 
 import attr
 import numpy
@@ -81,7 +81,7 @@ class XarrayReader(BaseReader):
 
     tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
 
-    _dims: List = attr.ib(init=False, factory=list)
+    _dims: list = attr.ib(init=False, factory=list)
 
     def __attrs_post_init__(self):
         """Set bounds and CRS."""
@@ -138,7 +138,7 @@ class XarrayReader(BaseReader):
         return self._maxzoom
 
     @property
-    def band_descriptions(self) -> List[str]:
+    def band_descriptions(self) -> list[str]:
         """
         Return list of `band descriptions` in DataArray.
 
@@ -160,7 +160,7 @@ class XarrayReader(BaseReader):
             if coords_name:
                 return [str(self.input.coords[coords_name[0]].data)]
 
-            return [self.input.name or ""]  # type: ignore
+            return [self.input.name or "b1"]  # type: ignore
 
         return [str(band) for d in self._dims for band in self.input[d].values]
 
@@ -173,7 +173,8 @@ class XarrayReader(BaseReader):
             "crs": CRS_to_uri(self.crs) or self.crs.to_wkt(),
             "band_metadata": [(f"b{ix}", v) for ix, v in enumerate(metadata, 1)],
             "band_descriptions": [
-                (f"b{ix}", v) for ix, v in enumerate(self.band_descriptions, 1)
+                (f"b{ix}", v or f"b{ix}")
+                for ix, v in enumerate(self.band_descriptions, 1)
             ],
             "dtype": str(self.input.dtype),
             "nodata_type": "Nodata" if self.input.rio.nodata is not None else "None",
@@ -193,11 +194,10 @@ class XarrayReader(BaseReader):
     def _sel_indexes(
         self,
         indexes: Indexes | None = None,
-    ) -> Tuple[xarray.DataArray, List[str], List[str]]:
+    ) -> tuple[xarray.DataArray, list[str]]:
         """Select `band` indexes in DataArray."""
         da = self.input
         band_descriptions = self.band_descriptions
-        band_names = [f"b{ix + 1}" for ix in range(self.input.rio.count)]
 
         if indexes := cast_to_sequence(indexes):
             assert all(v > 0 for v in indexes), "Indexes value must be >= 1"
@@ -207,30 +207,29 @@ class XarrayReader(BaseReader):
                         f"Invalid indexes {indexes} for array of shape {da.shape}"
                     )
 
-                return da, band_names, band_descriptions
+                return da, band_descriptions
 
             indexes = [idx - 1 for idx in indexes]
 
             da = da[indexes]
             band_descriptions = [band_descriptions[idx] for idx in indexes]
-            band_names = [band_names[idx] for idx in indexes]
 
-        return da, band_names, band_descriptions
+        return da, band_descriptions
 
     def statistics(
         self,
         categorical: bool = False,
-        categories: List[float] | None = None,
-        percentiles: List[int] | None = None,
-        hist_options: Dict | None = None,
+        categories: list[float] | None = None,
+        percentiles: list[int] | None = None,
+        hist_options: dict | None = None,
         nodata: NoData | None = None,
         indexes: Indexes | None = None,
         **kwargs: Any,
-    ) -> Dict[str, BandStatistics]:
+    ) -> dict[str, BandStatistics]:
         """Return statistics from a dataset."""
         hist_options = hist_options or {}
 
-        da, band_names, _ = self._sel_indexes(indexes)
+        da, band_descriptions = self._sel_indexes(indexes)
 
         if nodata is not None:
             da = da.rio.write_nodata(nodata)
@@ -246,14 +245,20 @@ class XarrayReader(BaseReader):
             **hist_options,
         )
 
-        return {band_names[ix]: BandStatistics(**val) for ix, val in enumerate(stats)}
+        return {
+            f"b{ix +1}": BandStatistics(
+                **val,
+                description=band_descriptions[ix],
+            )
+            for ix, val in enumerate(stats)
+        }
 
     def tile(
         self,
         tile_x: int,
         tile_y: int,
         tile_z: int,
-        tilesize: int = 256,
+        tilesize: int | None = None,
         reproject_method: WarpResampling = "nearest",
         auto_expand: bool = True,
         nodata: NoData | None = None,
@@ -281,16 +286,22 @@ class XarrayReader(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,
             reproject_method=reproject_method,
             auto_expand=auto_expand,
             nodata=nodata,
             indexes=indexes,
-            height=tilesize,
-            width=tilesize,
+            height=tilesize or matrix.tileHeight,
+            width=tilesize or matrix.tileWidth,
             out_dtype=out_dtype,
             **kwargs,
         )
@@ -338,7 +349,7 @@ class XarrayReader(BaseReader):
 
         dst_crs = dst_crs or bounds_crs
 
-        da, band_names, band_descriptions = self._sel_indexes(indexes)
+        da, band_descriptions = self._sel_indexes(indexes)
 
         if nodata is not None:
             da = da.rio.write_nodata(nodata)
@@ -448,7 +459,6 @@ class XarrayReader(BaseReader):
             bounds=bbox,
             crs=da.rio.crs,
             dataset_statistics=stats,
-            band_names=band_names,
             band_descriptions=band_descriptions,
             nodata=da.rio.nodata,
         )
@@ -488,7 +498,7 @@ class XarrayReader(BaseReader):
             )
             max_size = None
 
-        da, band_names, band_descriptions = self._sel_indexes(indexes)
+        da, band_descriptions = self._sel_indexes(indexes)
 
         if da.nbytes > MAX_ARRAY_SIZE:
             raise MaxArraySizeError(
@@ -578,7 +588,6 @@ class XarrayReader(BaseReader):
             bounds=da.rio.bounds(),
             crs=da.rio.crs,
             dataset_statistics=stats,
-            band_names=band_names,
             band_descriptions=band_descriptions,
             nodata=da.rio.nodata,
         )
@@ -628,7 +637,7 @@ class XarrayReader(BaseReader):
         ):
             raise PointOutsideBounds("Point is outside dataset bounds")
 
-        da, band_names, band_descriptions = self._sel_indexes(indexes)
+        da, band_descriptions = self._sel_indexes(indexes)
 
         if nodata is not None:
             da = da.rio.write_nodata(nodata)
@@ -648,7 +657,6 @@ class XarrayReader(BaseReader):
             arr,
             coordinates=(lon, lat),
             crs=coord_crs,
-            band_names=band_names,
             band_descriptions=band_descriptions,
             pixel_location=(x, y),
             nodata=da.rio.nodata,
@@ -656,7 +664,7 @@ class XarrayReader(BaseReader):
 
     def feature(
         self,
-        shape: Dict,
+        shape: dict,
         dst_crs: CRS | None = None,
         shape_crs: CRS = WGS84_CRS,
         reproject_method: WarpResampling = "nearest",

rio_tiler/models.py

@@ -1,8 +1,10 @@
 """rio-tiler models."""
 
 import itertools
+import re
 import warnings
-from typing import Any, Dict, List, Literal, Optional, Sequence, Tuple, Union, cast
+from collections.abc import Sequence
+from typing import Any, Literal, cast
 
 import attr
 import numpy
@@ -34,7 +36,6 @@ from rio_tiler.types import (
     GDALColorMapType,
     IntervalTuple,
     NoData,
-    NumType,
     RIOResampling,
     WarpResampling,
 )
@@ -58,14 +59,14 @@ class Bounds(BaseModel):
 class Info(Bounds):
     """Dataset Info."""
 
-    band_metadata: List[Tuple[str, Dict]]
-    band_descriptions: List[Tuple[str, str]]
+    band_metadata: list[tuple[str, dict]]
+    band_descriptions: list[tuple[str, str]]
     dtype: str
     nodata_type: Literal["Alpha", "Mask", "Internal", "Nodata", "None"]
-    colorinterp: Optional[List[str]] = None
-    scales: Optional[List[float]] = None
-    offsets: Optional[List[float]] = None
-    colormap: Optional[GDALColorMapType] = None
+    colorinterp: list[str] | None = None
+    scales: list[float] | None = None
+    offsets: list[float] | None = None
+    colormap: GDALColorMapType | None = None
 
     model_config = {"extra": "allow"}
 
@@ -83,15 +84,16 @@ class BandStatistics(BaseModel):
     majority: float
     minority: float
     unique: float
-    histogram: List[List[NumType]]
+    histogram: list[list[float | int]]
     valid_percent: float
     masked_pixels: float
     valid_pixels: float
+    description: str
 
     model_config = {"extra": "allow"}
 
 
-def to_coordsbbox(bbox) -> Optional[BoundingBox]:
+def to_coordsbbox(bbox) -> BoundingBox | None:
     """Convert bbox to CoordsBbox nameTuple."""
     return BoundingBox(*bbox) if bbox else None
 
@@ -100,7 +102,7 @@ def rescale_image(
     array: numpy.ma.MaskedArray,
     in_range: Sequence[IntervalTuple],
     out_range: Sequence[IntervalTuple] = ((0, 255),),
-    out_dtype: Union[str, numpy.number] = "uint8",
+    out_dtype: str | numpy.number = "uint8",
 ) -> numpy.ma.MaskedArray:
     """Rescale image data in-place."""
     if len(array.shape) < 3:
@@ -156,16 +158,16 @@ class PointData:
     """
 
     array: numpy.ma.MaskedArray = attr.ib(converter=to_masked)
-    band_names: List[str] = attr.ib(kw_only=True)
-    band_descriptions: List[str] = attr.ib(kw_only=True)
-    coordinates: Optional[Tuple[float, float]] = attr.ib(default=None, kw_only=True)
-    crs: Optional[CRS] = attr.ib(default=None, kw_only=True)
-    assets: Optional[List] = attr.ib(default=None, kw_only=True)
-    metadata: Optional[Dict] = attr.ib(factory=dict, kw_only=True)
-    nodata: Optional[NoData] = attr.ib(default=None, kw_only=True)
-    scales: List[NumType] = attr.ib(kw_only=True)
-    offsets: List[NumType] = attr.ib(kw_only=True)
-    pixel_location: Optional[Tuple[NumType, NumType]] = attr.ib(
+    band_names: list[str] = attr.ib(kw_only=True)
+    band_descriptions: list[str] = attr.ib(kw_only=True)
+    coordinates: tuple[float, float] | None = attr.ib(default=None, kw_only=True)
+    crs: CRS | None = attr.ib(default=None, kw_only=True)
+    assets: list | None = attr.ib(default=None, kw_only=True)
+    metadata: dict | None = attr.ib(factory=dict, kw_only=True)
+    nodata: NoData | None = attr.ib(default=None, kw_only=True)
+    scales: list[float | int] = attr.ib(kw_only=True)
+    offsets: list[float | int] = attr.ib(kw_only=True)
+    pixel_location: tuple[float | int, float | int] | None = attr.ib(
         default=None, kw_only=True
     )
 
@@ -187,7 +189,7 @@ class PointData:
 
     @band_descriptions.default
     def _default_band_descriptions(self):
-        return ["" for ix in range(self.count)]
+        return ["" or f"b{ix + 1}" for ix in range(self.count)]
 
     @scales.default
     def _default_scales(self):
@@ -290,14 +292,20 @@ class PointData:
         # Using numexpr do not preserve mask info
         data.mask = False
 
-        # TODO: Update band descriptions
+        mapexpr = {
+            self.band_names[idx]: desc for idx, desc in enumerate(self.band_descriptions)
+        }
+        _re = re.compile(r"\bb[0-9A-Z]+\b")
+        band_descriptions = [
+            _re.sub(lambda x: mapexpr[x.group()], block) for block in blocks
+        ]
 
         return PointData(
             data,
             assets=self.assets,
             crs=self.crs,
             coordinates=self.coordinates,
-            band_names=blocks,
+            band_descriptions=band_descriptions,
             metadata=self.metadata,
             pixel_location=self.pixel_location,
         )
@@ -340,22 +348,22 @@ class ImageData:
     """
 
     array: numpy.ma.MaskedArray = attr.ib(converter=masked_and_3d)
-    assets: Optional[List] = attr.ib(default=None, kw_only=True)
-    bounds: Optional[BoundingBox] = attr.ib(
+    assets: list | None = attr.ib(default=None, kw_only=True)
+    bounds: BoundingBox | None = attr.ib(
         default=None, converter=to_coordsbbox, kw_only=True
     )
-    crs: Optional[CRS] = attr.ib(default=None, kw_only=True)
-    metadata: Optional[Dict] = attr.ib(factory=dict, kw_only=True)
-    nodata: Optional[NoData] = attr.ib(default=None, kw_only=True)
-    scales: List[NumType] = attr.ib(kw_only=True)
-    offsets: List[NumType] = attr.ib(kw_only=True)
-    band_names: List[str] = attr.ib(kw_only=True)
-    band_descriptions: List[str] = attr.ib(kw_only=True)
-    dataset_statistics: Optional[Sequence[Tuple[float, float]]] = attr.ib(
+    crs: CRS | None = attr.ib(default=None, kw_only=True)
+    metadata: dict | None = attr.ib(factory=dict, kw_only=True)
+    nodata: NoData | None = attr.ib(default=None, kw_only=True)
+    scales: list[float | int] = attr.ib(kw_only=True)
+    offsets: list[float | int] = attr.ib(kw_only=True)
+    band_names: list[str] = attr.ib(kw_only=True)
+    band_descriptions: list[str] = attr.ib(kw_only=True)
+    dataset_statistics: Sequence[tuple[float, float]] | None = attr.ib(
         default=None, kw_only=True
     )
-    cutline_mask: Optional[numpy.ndarray] = attr.ib(default=None)
-    alpha_mask: Optional[numpy.ndarray] = attr.ib(default=None)
+    cutline_mask: numpy.ndarray | None = attr.ib(default=None)
+    alpha_mask: numpy.ndarray | None = attr.ib(default=None)
 
     @band_names.default
     def _default_band_names(self):
@@ -363,7 +371,7 @@ class ImageData:
 
     @band_descriptions.default
     def _default_band_descriptions(self):
-        return ["" for ix in range(self.count)]
+        return ["" or f"b{ix + 1}" for ix in range(self.count)]
 
     @scales.default
     def _default_scales(self):
@@ -596,7 +604,7 @@ class ImageData:
         self,
         in_range: Sequence[IntervalTuple],
         out_range: Sequence[IntervalTuple] = ((0, 255),),
-        out_dtype: Union[str, numpy.number] = "uint8",
+        out_dtype: str | numpy.number = "uint8",
     ) -> Self:
         """Rescale data in place."""
         self.array = rescale_image(
@@ -618,7 +626,7 @@ class ImageData:
 
         return self
 
-    def apply_color_formula(self, color_formula: Optional[str]) -> Self:
+    def apply_color_formula(self, color_formula: str | None) -> Self:
         """Apply color-operations formula in place."""
         out = self.array.data
         out[out < 0] = 0
@@ -691,14 +699,20 @@ class ImageData:
         # NOTE: We use dataset mask when mixing bands
         data.mask = numpy.logical_or.reduce(self.array.mask)
 
-        # TODO: update band descriptions
+        mapexpr = {
+            self.band_names[idx]: desc for idx, desc in enumerate(self.band_descriptions)
+        }
+        _re = re.compile(r"\bb[0-9A-Z]+\b")
+        band_descriptions = [
+            _re.sub(lambda x: mapexpr[x.group()], block) for block in blocks
+        ]
 
         return ImageData(
             data,
             assets=self.assets,
             crs=self.crs,
             bounds=self.bounds,
-            band_names=blocks,
+            band_descriptions=band_descriptions,
             metadata=self.metadata,
             dataset_statistics=stats,
             alpha_mask=self.alpha_mask,
@@ -759,9 +773,9 @@ class ImageData:
 
     def post_process(
         self,
-        in_range: Optional[Sequence[IntervalTuple]] = None,
-        out_dtype: Union[str, numpy.number] = "uint8",
-        color_formula: Optional[str] = None,
+        in_range: Sequence[IntervalTuple] | None = None,
+        out_dtype: str | numpy.number = "uint8",
+        color_formula: str | None = None,
         **kwargs: Any,
     ) -> "ImageData":
         """Post-process image data.
@@ -803,7 +817,7 @@ class ImageData:
         self,
         add_mask: bool = True,
         img_format: str = "PNG",
-        colormap: Optional[ColorMapType] = None,
+        colormap: ColorMapType | None = None,
         **kwargs,
     ) -> bytes:
         """Render data to image blob.
@@ -899,11 +913,11 @@ class ImageData:
     def statistics(
         self,
         categorical: bool = False,
-        categories: Optional[List[float]] = None,
-        percentiles: Optional[List[int]] = None,
-        hist_options: Optional[Dict] = None,
-        coverage: Optional[numpy.ndarray] = None,
-    ) -> Dict[str, BandStatistics]:
+        categories: list[float] | None = None,
+        percentiles: list[int] | None = None,
+        hist_options: dict | None = None,
+        coverage: numpy.ndarray | None = None,
+    ) -> dict[str, BandStatistics]:
         """Return statistics from ImageData."""
         hist_options = hist_options or {}
 
@@ -917,13 +931,16 @@ class ImageData:
         )
 
         return {
-            f"{self.band_names[ix]}": BandStatistics(**stats[ix])
+            f"{self.band_names[ix]}": BandStatistics(
+                **stats[ix],
+                description=self.band_descriptions[ix],
+            )
             for ix in range(len(stats))
         }
 
     def get_coverage_array(
         self,
-        shape: Dict,
+        shape: dict,
         shape_crs: CRS = WGS84_CRS,
         cover_scale: int = 10,
     ) -> NDArray[numpy.floating]:
@@ -972,7 +989,7 @@ class ImageData:
     def reproject(
         self,
         dst_crs: CRS,
-        resolution: Optional[Tuple[float, float]] = None,
+        resolution: tuple[float, float] | None = None,
         reproject_method: WarpResampling = "nearest",
     ) -> "ImageData":
         """Reproject data and mask."""

rio_tiler/mosaic/backend.py

@@ -2,7 +2,7 @@
 
 import abc
 import logging
-from typing import Any, Type
+from typing import Any
 
 import attr
 from morecantile import TileMatrixSet
@@ -51,7 +51,7 @@ class BaseBackend(BaseReader):
     input: str = attr.ib()
     tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
 
-    reader: Type[BaseReader] | Type[MultiBaseReader] | Type[MultiBandReader] = attr.ib(
+    reader: type[BaseReader] | type[MultiBaseReader] | type[MultiBandReader] = attr.ib(
         default=Reader
     )
     reader_options: dict = attr.ib(factory=dict)

rio_tiler/mosaic/methods/base.py

@@ -2,7 +2,6 @@
 
 import abc
 from dataclasses import dataclass, field
-from typing import Optional
 
 import numpy
 
@@ -11,9 +10,9 @@ import numpy
 class MosaicMethodBase(abc.ABC):
     """Abstract base class for rio-tiler-mosaic methods objects."""
 
-    mosaic: Optional[numpy.ma.MaskedArray] = field(default=None, init=False)
+    mosaic: numpy.ma.MaskedArray | None = field(default=None, init=False)
     exit_when_filled: bool = field(default=False, init=False)
-    cutline_mask: Optional[numpy.ndarray] = field(default=None, init=False)
+    cutline_mask: numpy.ndarray | None = field(default=None, init=False)
     width: int = field(init=False)
     height: int = field(init=False)
     count: int = field(init=False)
@@ -42,7 +41,7 @@ class MosaicMethodBase(abc.ABC):
         return False
 
     @property
-    def data(self) -> Optional[numpy.ma.MaskedArray]:
+    def data(self) -> numpy.ma.MaskedArray | None:
         """Return data."""
         return self.mosaic
 

rio_tiler/mosaic/methods/defaults.py

@@ -1,7 +1,6 @@
 """rio_tiler.mosaic.methods.defaults: default mosaic filling methods."""
 
 from dataclasses import dataclass, field
-from typing import List, Optional
 
 import numpy
 
@@ -18,7 +17,7 @@ class FirstMethod(MosaicMethodBase):
         """Mosaic Method repr."""
         return "<Mosaic: FirstMethod>"
 
-    def feed(self, array: Optional[numpy.ma.MaskedArray]):
+    def feed(self, array: numpy.ma.MaskedArray | None):
         """Add data to the mosaic array."""
         if self.mosaic is None:
             self.mosaic = array
@@ -39,7 +38,7 @@ class HighestMethod(MosaicMethodBase):
         """Mosaic Method repr."""
         return "<Mosaic: HighestMethod>"
 
-    def feed(self, array: Optional[numpy.ma.MaskedArray]):
+    def feed(self, array: numpy.ma.MaskedArray | None):
         """Add data to the mosaic array."""
         if self.mosaic is None:
             self.mosaic = array
@@ -63,7 +62,7 @@ class LowestMethod(MosaicMethodBase):
         """Mosaic Method repr."""
         return "<Mosaic: LowestMethod>"
 
-    def feed(self, array: Optional[numpy.ma.MaskedArray]):
+    def feed(self, array: numpy.ma.MaskedArray | None):
         """Add data to the mosaic array."""
         if self.mosaic is None:
             self.mosaic = array
@@ -84,14 +83,14 @@ class MeanMethod(MosaicMethodBase):
     """Stack the arrays and return the Mean pixel value."""
 
     enforce_data_type: bool = True
-    stack: List[numpy.ma.MaskedArray] = field(default_factory=list, init=False)
+    stack: list[numpy.ma.MaskedArray] = field(default_factory=list, init=False)
 
     def __repr__(self):
         """Mosaic Method repr."""
         return "<Mosaic: MeanMethod>"
 
     @property
-    def data(self) -> Optional[numpy.ma.MaskedArray]:
+    def data(self) -> numpy.ma.MaskedArray | None:
         """Return Mean of the data stack."""
         if self.stack:
             array = numpy.ma.mean(numpy.ma.stack(self.stack, axis=0), axis=0)
@@ -112,14 +111,14 @@ class MedianMethod(MosaicMethodBase):
     """Stack the arrays and return the Median pixel value."""
 
     enforce_data_type: bool = True
-    stack: List[numpy.ma.MaskedArray] = field(default_factory=list, init=False)
+    stack: list[numpy.ma.MaskedArray] = field(default_factory=list, init=False)
 
     def __repr__(self):
         """Mosaic Method repr."""
         return "<Mosaic: MedianMethod>"
 
     @property
-    def data(self) -> Optional[numpy.ma.MaskedArray]:
+    def data(self) -> numpy.ma.MaskedArray | None:
         """Return Median of the data stack."""
         if self.stack:
             array = numpy.ma.median(numpy.ma.stack(self.stack, axis=0), axis=0)
@@ -130,7 +129,7 @@ class MedianMethod(MosaicMethodBase):
 
         return None
 
-    def feed(self, array: Optional[numpy.ma.MaskedArray]):
+    def feed(self, array: numpy.ma.MaskedArray | None):
         """Add array to the stack."""
         self.stack.append(array)
 
@@ -139,21 +138,21 @@ class MedianMethod(MosaicMethodBase):
 class StdevMethod(MosaicMethodBase):
     """Stack the arrays and return the Standard Deviation value."""
 
-    stack: List[numpy.ma.MaskedArray] = field(default_factory=list, init=False)
+    stack: list[numpy.ma.MaskedArray] = field(default_factory=list, init=False)
 
     def __repr__(self):
         """Mosaic Method repr."""
         return "<Mosaic: StdevMethod>"
 
     @property
-    def data(self) -> Optional[numpy.ma.MaskedArray]:
+    def data(self) -> numpy.ma.MaskedArray | None:
         """Return STDDEV of the data stack."""
         if self.stack:
             return numpy.ma.std(numpy.ma.stack(self.stack, axis=0), axis=0)
 
         return None
 
-    def feed(self, array: Optional[numpy.ma.MaskedArray]):
+    def feed(self, array: numpy.ma.MaskedArray | None):
         """Add array to the stack."""
         self.stack.append(array)
 
@@ -167,14 +166,14 @@ class LastBandHighMethod(MosaicMethodBase):
         return "<Mosaic: LastBandHighMethod>"
 
     @property
-    def data(self) -> Optional[numpy.ma.MaskedArray]:
+    def data(self) -> numpy.ma.MaskedArray | None:
         """Return data."""
         if self.mosaic is not None:
             return self.mosaic[:-1].copy()
 
         return None
 
-    def feed(self, array: Optional[numpy.ma.MaskedArray]):
+    def feed(self, array: numpy.ma.MaskedArray | None):
         """Add data to the mosaic array."""
         if self.mosaic is None:
             self.mosaic = array
@@ -199,14 +198,14 @@ class LastBandLowMethod(MosaicMethodBase):
         return "<Mosaic: LastBandLowMethod>"
 
     @property
-    def data(self) -> Optional[numpy.ma.MaskedArray]:
+    def data(self) -> numpy.ma.MaskedArray | None:
         """Return data."""
         if self.mosaic is not None:
             return self.mosaic[:-1].copy()
 
         return None
 
-    def feed(self, array: Optional[numpy.ma.MaskedArray]):
+    def feed(self, array: numpy.ma.MaskedArray | None):
         """Add data to the mosaic array."""
         if self.mosaic is None:
             self.mosaic = array
@@ -226,14 +225,14 @@ class LastBandLowMethod(MosaicMethodBase):
 class CountMethod(MosaicMethodBase):
     """Stack the arrays and return the valid pixel count."""
 
-    stack: List[numpy.ma.MaskedArray] = field(default_factory=list, init=False)
+    stack: list[numpy.ma.MaskedArray] = field(default_factory=list, init=False)
 
     def __repr__(self):
         """Mosaic Method repr."""
         return "<Mosaic: CountMethod>"
 
     @property
-    def data(self) -> Optional[numpy.ma.MaskedArray]:
+    def data(self) -> numpy.ma.MaskedArray | None:
         """Return valid data count of the data stack."""
         if self.stack:
             data = numpy.ma.count(numpy.ma.stack(self.stack, axis=0), axis=0)
@@ -254,6 +253,6 @@ class CountMethod(MosaicMethodBase):
 
         return None
 
-    def feed(self, array: Optional[numpy.ma.MaskedArray]):
+    def feed(self, array: numpy.ma.MaskedArray | None):
         """Add array to the stack."""
         self.stack.append(array)