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

rio_tiler/mosaic/reader.py

@@ -1,8 +1,9 @@
 """rio_tiler.mosaic: create tile from multiple assets."""
 
 import warnings
+from collections.abc import Callable, Sequence
 from inspect import isclass
-from typing import Any, Callable, List, Optional, Sequence, Tuple, Type, Union, cast
+from typing import Any, cast
 
 import numpy
 from rasterio.crs import CRS
@@ -26,12 +27,12 @@ def mosaic_reader(  # noqa: C901
     mosaic_assets: Sequence,
     reader: Callable[..., ImageData],
     *args: Any,
-    pixel_selection: Union[Type[MosaicMethodBase], MosaicMethodBase] = FirstMethod,
-    chunk_size: Optional[int] = None,
+    pixel_selection: type[MosaicMethodBase] | MosaicMethodBase = FirstMethod,
+    chunk_size: int | None = None,
     threads: int = MAX_THREADS,
-    allowed_exceptions: Tuple = (TileOutsideBounds,),
+    allowed_exceptions: tuple = (TileOutsideBounds,),
     **kwargs,
-) -> Tuple[ImageData, List]:
+) -> tuple[ImageData, list]:
     """Merge multiple assets.
 
     Args:
@@ -65,7 +66,7 @@ def mosaic_reader(  # noqa: C901
 
     """
     if isclass(pixel_selection):
-        pixel_selection = cast(Type[MosaicMethodBase], pixel_selection)
+        pixel_selection = cast(type[MosaicMethodBase], pixel_selection)
 
         if issubclass(pixel_selection, MosaicMethodBase):
             pixel_selection = pixel_selection()
@@ -79,10 +80,10 @@ def mosaic_reader(  # noqa: C901
     if not chunk_size:
         chunk_size = threads if threads > 1 else len(mosaic_assets)
 
-    assets_used: List = []
-    crs: Optional[CRS]
-    bounds: Optional[BBox]
-    band_names: List[str]
+    assets_used: list = []
+    crs: CRS | None
+    bounds: BBox | None
+    band_names: list[str]
 
     for chunks in _chunks(mosaic_assets, chunk_size):
         tasks = create_tasks(reader, chunks, threads, *args, **kwargs)
@@ -171,12 +172,12 @@ def mosaic_point_reader(
     mosaic_assets: Sequence,
     reader: Callable[..., PointData],
     *args: Any,
-    pixel_selection: Union[Type[MosaicMethodBase], MosaicMethodBase] = FirstMethod,
-    chunk_size: Optional[int] = None,
+    pixel_selection: type[MosaicMethodBase] | MosaicMethodBase = FirstMethod,
+    chunk_size: int | None = None,
     threads: int = MAX_THREADS,
-    allowed_exceptions: Tuple = (PointOutsideBounds,),
+    allowed_exceptions: tuple = (PointOutsideBounds,),
     **kwargs,
-) -> Tuple[PointData, List]:
+) -> tuple[PointData, list]:
     """Merge multiple assets.
 
     Args:
@@ -202,7 +203,7 @@ def mosaic_point_reader(
 
     """
     if isclass(pixel_selection):
-        pixel_selection = cast(Type[MosaicMethodBase], pixel_selection)
+        pixel_selection = cast(type[MosaicMethodBase], pixel_selection)
 
         if issubclass(pixel_selection, MosaicMethodBase):
             pixel_selection = pixel_selection()
@@ -216,10 +217,10 @@ def mosaic_point_reader(
     if not chunk_size:
         chunk_size = threads if threads > 1 else len(mosaic_assets)
 
-    assets_used: List = []
-    crs: Optional[CRS]
-    coordinates: Optional[Tuple[float, float]]
-    band_names: List[str]
+    assets_used: list = []
+    crs: CRS | None
+    coordinates: tuple[float, float] | None
+    band_names: list[str]
 
     for chunks in _chunks(mosaic_assets, chunk_size):
         tasks = create_tasks(reader, chunks, threads, *args, **kwargs)

rio_tiler/reader.py

@@ -3,7 +3,8 @@
 import contextlib
 import math
 import warnings
-from typing import Callable, Dict, Optional, Tuple, TypedDict, Union, cast
+from collections.abc import Callable
+from typing import TypedDict, cast
 
 import numpy
 from affine import Affine
@@ -34,12 +35,12 @@ from rio_tiler.utils import (
 class Options(TypedDict, total=False):
     """Reader Options."""
 
-    nodata: Optional[NoData]
-    vrt_options: Optional[Dict]
-    resampling_method: Optional[RIOResampling]
-    reproject_method: Optional[WarpResampling]
-    unscale: Optional[bool]
-    post_process: Optional[Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]]
+    nodata: NoData | None
+    vrt_options: dict | None
+    resampling_method: RIOResampling | None
+    reproject_method: WarpResampling | None
+    unscale: bool | None
+    post_process: Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray] | None
 
 
 def _apply_buffer(
@@ -47,7 +48,7 @@ def _apply_buffer(
     bounds: BBox,
     height: int,
     width: int,
-) -> Tuple[BBox, int, int]:
+) -> tuple[BBox, int, int]:
     """Apply buffer on bounds."""
     x_res = (bounds[2] - bounds[0]) / width
     y_res = (bounds[3] - bounds[1]) / height
@@ -68,20 +69,20 @@ def _apply_buffer(
 
 
 def read(
-    src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
-    dst_crs: Optional[CRS] = None,
-    height: Optional[int] = None,
-    width: Optional[int] = None,
-    max_size: Optional[int] = None,
-    indexes: Optional[Indexes] = None,
-    window: Optional[windows.Window] = None,
-    nodata: Optional[NoData] = None,
-    vrt_options: Optional[Dict] = None,
-    out_dtype: Optional[Union[str, numpy.dtype]] = None,
+    src_dst: DatasetReader | DatasetWriter | WarpedVRT,
+    dst_crs: CRS | None = None,
+    height: int | None = None,
+    width: int | None = None,
+    max_size: int | None = None,
+    indexes: Indexes | None = None,
+    window: windows.Window | None = None,
+    nodata: NoData | None = None,
+    vrt_options: dict | None = None,
+    out_dtype: str | numpy.dtype | None = None,
     resampling_method: RIOResampling = "nearest",
     reproject_method: WarpResampling = "nearest",
     unscale: bool = False,
-    post_process: Optional[Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]] = None,
+    post_process: Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray] | None = None,
 ) -> ImageData:
     """Low level read function.
 
@@ -297,8 +298,9 @@ def read(
             data,
             bounds=out_bounds,
             crs=dataset.crs,
-            band_names=[f"b{idx}" for idx in indexes],
-            band_descriptions=[dataset.descriptions[ix - 1] or "" for idx in indexes],
+            band_descriptions=[
+                dataset.descriptions[ix - 1] or f"b{idx}" for idx in indexes
+            ],
             dataset_statistics=dataset_statistics,
             metadata=dataset.tags(),
             nodata=nodata,
@@ -309,25 +311,25 @@ def read(
 
 # flake8: noqa: C901
 def part(
-    src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
+    src_dst: DatasetReader | DatasetWriter | WarpedVRT,
     bounds: BBox,
-    height: Optional[int] = None,
-    width: Optional[int] = None,
-    max_size: Optional[int] = None,
-    dst_crs: Optional[CRS] = None,
-    bounds_crs: Optional[CRS] = None,
-    indexes: Optional[Indexes] = None,
-    minimum_overlap: Optional[float] = None,
-    padding: Optional[int] = None,
-    buffer: Optional[float] = None,
-    nodata: Optional[NoData] = None,
-    vrt_options: Optional[Dict] = None,
-    out_dtype: Optional[Union[str, numpy.dtype]] = None,
+    height: int | None = None,
+    width: int | None = None,
+    max_size: int | None = None,
+    dst_crs: CRS | None = None,
+    bounds_crs: CRS | None = None,
+    indexes: Indexes | None = None,
+    minimum_overlap: float | None = None,
+    padding: int | None = None,
+    buffer: float | None = None,
+    nodata: NoData | None = None,
+    vrt_options: dict | None = None,
+    out_dtype: str | numpy.dtype | None = None,
     align_bounds_with_dataset: bool = False,
     resampling_method: RIOResampling = "nearest",
     reproject_method: WarpResampling = "nearest",
     unscale: bool = False,
-    post_process: Optional[Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]] = None,
+    post_process: Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray] | None = None,
 ) -> ImageData:
     """Read part of a dataset.
 
@@ -508,7 +510,6 @@ def part(
             img.array[:, padding:-padding, padding:-padding],
             bounds=bounds,
             crs=img.crs,
-            band_names=img.band_names,
             band_descriptions=img.band_descriptions,
             nodata=img.nodata,
             scales=img.scales,
@@ -533,18 +534,18 @@ def part(
 
 
 def point(
-    src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
-    coordinates: Tuple[float, float],
-    indexes: Optional[Indexes] = None,
+    src_dst: DatasetReader | DatasetWriter | WarpedVRT,
+    coordinates: tuple[float, float],
+    indexes: Indexes | None = None,
     coord_crs: CRS = WGS84_CRS,
-    nodata: Optional[NoData] = None,
-    vrt_options: Optional[Dict] = None,
-    out_dtype: Optional[Union[str, numpy.dtype]] = None,
+    nodata: NoData | None = None,
+    vrt_options: dict | None = None,
+    out_dtype: str | numpy.dtype | None = None,
     resampling_method: RIOResampling = "nearest",
     reproject_method: WarpResampling = "nearest",
     interpolate: bool = False,
     unscale: bool = False,
-    post_process: Optional[Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]] = None,
+    post_process: Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray] | None = None,
 ) -> PointData:
     """Read a pixel value for a point.
 
@@ -648,7 +649,6 @@ def point(
 
         return PointData(
             img.array[:, 0, 0],
-            band_names=img.band_names,
             band_descriptions=img.band_descriptions,
             coordinates=coordinates,
             crs=coord_crs,

rio_tiler/tasks.py

@@ -1,19 +1,20 @@
 """rio_tiler.tasks: tools for handling rio-tiler's future tasks."""
 
+from collections.abc import Callable, Generator, Sequence
 from concurrent import futures
 from functools import partial
-from typing import Any, Callable, Dict, Generator, Optional, Sequence, Tuple, Union
+from typing import Any
 
 from rio_tiler.constants import MAX_THREADS
 from rio_tiler.logger import logger
 from rio_tiler.models import ImageData, PointData
 
-TaskType = Sequence[Tuple[Union[futures.Future, Callable], Any]]
+TaskType = Sequence[tuple[futures.Future | Callable, Any]]
 
 
 def filter_tasks(
     tasks: TaskType,
-    allowed_exceptions: Optional[Tuple] = None,
+    allowed_exceptions: tuple | None = None,
 ) -> Generator:
     """Filter Tasks to remove Exceptions.
 
@@ -60,7 +61,7 @@ def multi_arrays(
     reader: Callable[..., ImageData],
     *args: Any,
     threads: int = MAX_THREADS,
-    allowed_exceptions: Optional[Tuple] = None,
+    allowed_exceptions: tuple | None = None,
     **kwargs: Any,
 ) -> ImageData:
     """Merge arrays returned from tasks."""
@@ -75,7 +76,7 @@ def multi_points(
     reader: Callable[..., PointData],
     *args: Any,
     threads: int = MAX_THREADS,
-    allowed_exceptions: Optional[Tuple] = None,
+    allowed_exceptions: tuple | None = None,
     **kwargs: Any,
 ) -> PointData:
     """Merge points returned from tasks."""
@@ -90,9 +91,9 @@ def multi_values(
     reader: Callable,
     *args: Any,
     threads: int = MAX_THREADS,
-    allowed_exceptions: Optional[Tuple] = None,
+    allowed_exceptions: tuple | None = None,
     **kwargs: Any,
-) -> Dict:
+) -> dict:
     """Merge values returned from tasks."""
     tasks = create_tasks(reader, asset_list, threads, *args, **kwargs)
     return {
@@ -106,7 +107,7 @@ def multi_values_list(
     reader: Callable,
     *args: Any,
     threads: int = MAX_THREADS,
-    allowed_exceptions: Optional[Tuple] = None,
+    allowed_exceptions: tuple | None = None,
     **kwargs: Any,
 ) -> list[tuple[Any, Any]]:
     """Merge values returned from tasks."""

rio_tiler/types.py

@@ -1,34 +1,31 @@
 """rio-tiler types."""
 
-from typing import Any, Dict, Literal, Optional, Sequence, Tuple, TypedDict, Union
+from collections.abc import Sequence
+from typing import Any, Literal, NotRequired, TypedDict
 
 import numpy
 
-NumType = Union[float, int]
+NumType = float | int
 
-BBox = Tuple[float, float, float, float]
-NoData = Union[float, int, str]
-Indexes = Union[Sequence[int], int]
+BBox = tuple[float, float, float, float]
+NoData = float | int | str
+Indexes = Sequence[int] | int
 
-DataMaskType = Tuple[numpy.ndarray, numpy.ndarray]
+DataMaskType = tuple[numpy.ndarray, numpy.ndarray]
 
-ColorTuple = Tuple[int, int, int, int]  # (red, green, blue, alpha)
-IntervalTuple = Tuple[NumType, NumType]  # (0, 100)
+ColorTuple = tuple[int, int, int, int]  # (red, green, blue, alpha)
+IntervalTuple = tuple[NumType, NumType]  # (0, 100)
 
 # ColorMap Dict: {1: (0, 0, 0, 255), ...}
-GDALColorMapType = Dict[int, ColorTuple]
+GDALColorMapType = dict[int, ColorTuple]
 
 # Discrete Colormap, like GDALColorMapType but accept Float: {0.1: (0, 0, 0, 255), ...}
-DiscreteColorMapType = Dict[NumType, ColorTuple]
+DiscreteColorMapType = dict[NumType, ColorTuple]
 
 # Intervals ColorMap: [((0, 1), (0, 0, 0, 0)), ...]
-IntervalColorMapType = Sequence[Tuple[IntervalTuple, ColorTuple]]
+IntervalColorMapType = Sequence[tuple[IntervalTuple, ColorTuple]]
 
-ColorMapType = Union[
-    GDALColorMapType,
-    DiscreteColorMapType,
-    IntervalColorMapType,
-]
+ColorMapType = GDALColorMapType | DiscreteColorMapType | IntervalColorMapType
 
 # RasterIO() resampling method.
 # ref: https://gdal.org/api/raster_c_api.html#_CPPv418GDALRIOResampleAlg
@@ -64,11 +61,13 @@ WarpResampling = Literal[
 ]
 
 
-class AssetInfo(TypedDict, total=False):
+class AssetInfo(TypedDict):
     """Asset Reader Options."""
 
     url: Any
-    media_type: str
-    env: Optional[Dict]
-    metadata: Optional[Dict]
-    dataset_statistics: Optional[Sequence[Tuple[float, float]]]
+    name: str
+    media_type: str | None
+    method_options: dict
+    env: NotRequired[dict]
+    metadata: NotRequired[dict]
+    dataset_statistics: NotRequired[Sequence[tuple[float, float]]]

rio_tiler/utils.py

@@ -3,18 +3,9 @@
 import math
 import time
 import warnings
+from collections.abc import Callable, Generator
 from io import BytesIO
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
-)
+from typing import Any, Sequence
 
 import numpy
 import rasterio
@@ -44,7 +35,7 @@ def _chunks(my_list: Sequence, chuck_size: int) -> Generator[Sequence, None, Non
         yield my_list[i : i + chuck_size]
 
 
-def _get_width_height(max_size, dataset_height, dataset_width) -> Tuple[int, int]:
+def _get_width_height(max_size, dataset_height, dataset_width) -> tuple[int, int]:
     """Get Output Width/Height based on a max_size and dataset shape."""
     if max(dataset_height, dataset_width) < max_size:
         return dataset_height, dataset_width
@@ -60,7 +51,7 @@ def _get_width_height(max_size, dataset_height, dataset_width) -> Tuple[int, int
     return height, width
 
 
-def _missing_size(w: Optional[int] = None, h: Optional[int] = None):
+def _missing_size(w: int | None = None, h: int | None = None):
     """Check if one and only one size (width, height) is valid."""
     iterator = iter([w, h])
     return any(iterator) and not any(iterator)
@@ -90,11 +81,11 @@ def _weighted_stdev(
 def get_array_statistics(
     data: numpy.ma.MaskedArray,
     categorical: bool = False,
-    categories: Optional[List[float]] = None,
-    percentiles: Optional[List[int]] = None,
-    coverage: Optional[NDArray[numpy.floating]] = None,
+    categories: list[float] | None = None,
+    percentiles: list[int] | None = None,
+    coverage: NDArray[numpy.floating] | None = None,
     **kwargs: Any,
-) -> List[Dict[Any, Any]]:
+) -> list[dict[Any, Any]]:
     """Calculate per band array statistics.
 
     Args:
@@ -141,7 +132,7 @@ def get_array_statistics(
     if len(data.shape) < 3:
         data = numpy.ma.expand_dims(data, axis=0)  # type: ignore [assignment]
 
-    output: List[Dict[Any, Any]] = []
+    output: list[dict[Any, Any]] = []
     percentiles_names = [f"percentile_{int(p)}" for p in percentiles]
 
     if coverage is not None:
@@ -274,7 +265,7 @@ def _round_window(window: windows.Window) -> windows.Window:
 
 
 def get_overview_level(
-    src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
+    src_dst: DatasetReader | DatasetWriter | WarpedVRT,
     bounds: BBox,
     height: int,
     width: int,
@@ -327,14 +318,14 @@ def get_overview_level(
 
 
 def get_vrt_transform(
-    src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
+    src_dst: DatasetReader | DatasetWriter | WarpedVRT,
     bounds: BBox,
-    height: Optional[int] = None,
-    width: Optional[int] = None,
+    height: int | None = None,
+    width: int | None = None,
     dst_crs: CRS = WEB_MERCATOR_CRS,
     window_precision: int = 6,
     align_bounds_with_dataset: bool = False,
-) -> Tuple[Affine, int, int]:
+) -> tuple[Affine, int, int]:
     """Calculate VRT transform.
 
     Args:
@@ -468,7 +459,7 @@ def get_vrt_transform(
     return vrt_transform, vrt_width, vrt_height
 
 
-def has_alpha_band(src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT]) -> bool:
+def has_alpha_band(src_dst: DatasetReader | DatasetWriter | WarpedVRT) -> bool:
     """Check for alpha band or mask in source."""
     if (
         any(MaskFlags.alpha in flags for flags in src_dst.mask_flag_enums)
@@ -478,7 +469,7 @@ def has_alpha_band(src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT]) -> b
     return False
 
 
-def has_mask_band(src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT]) -> bool:
+def has_mask_band(src_dst: DatasetReader | DatasetWriter | WarpedVRT) -> bool:
     """Check for mask band in source."""
     if any(
         (MaskFlags.per_dataset in flags and MaskFlags.alpha not in flags)
@@ -488,7 +479,7 @@ def has_mask_band(src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT]) -> bo
     return False
 
 
-def non_alpha_indexes(src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT]) -> Tuple:
+def non_alpha_indexes(src_dst: DatasetReader | DatasetWriter | WarpedVRT) -> tuple:
     """Return indexes of non-alpha bands."""
     return tuple(
         b
@@ -524,7 +515,7 @@ def linear_rescale(
 
 
 def _requested_tile_aligned_with_internal_tile(
-    src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
+    src_dst: DatasetReader | DatasetWriter | WarpedVRT,
     bounds: BBox,
     bounds_crs: CRS = WEB_MERCATOR_CRS,
 ) -> bool:
@@ -553,9 +544,9 @@ def _requested_tile_aligned_with_internal_tile(
 
 def render(
     data: numpy.ndarray,
-    mask: Optional[numpy.ndarray] = None,
+    mask: numpy.ndarray | None = None,
     img_format: str = "PNG",
-    colormap: Optional[ColorMapType] = None,
+    colormap: ColorMapType | None = None,
     **creation_options: Any,
 ) -> bytes:
     """Translate numpy.ndarray to image bytes.
@@ -705,10 +696,10 @@ def pansharpening_brovey(
 
 
 def _convert_to_raster_space(
-    src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
-    poly_coordinates: List,
-    op: Optional[Callable[[float], Any]] = None,
-) -> List[str]:
+    src_dst: DatasetReader | DatasetWriter | WarpedVRT,
+    poly_coordinates: list,
+    op: Callable[[float], Any] | None = None,
+) -> list[str]:
     # NOTE: we could remove this once we have rasterio >= 1.4.2
     op = op or numpy.floor
     polygons = []
@@ -722,10 +713,10 @@ def _convert_to_raster_space(
 
 
 def create_cutline(
-    src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
-    geometry: Dict,
+    src_dst: DatasetReader | DatasetWriter | WarpedVRT,
+    geometry: dict,
     geometry_crs: CRS = None,
-    op: Optional[Callable[[float], Any]] = None,
+    op: Callable[[float], Any] | None = None,
 ) -> str:
     """
     Create WKT Polygon Cutline for GDALWarpOptions.
@@ -807,7 +798,7 @@ def resize_array(
     resampling_method: RIOResampling = "nearest",
 ) -> numpy.ndarray:
     """resize array to a given height and width."""
-    out_shape: Union[Tuple[int, int], Tuple[int, int, int]]
+    out_shape: int | tuple[int, int] | tuple[int, int, int]
     if len(data.shape) == 2:
         out_shape = (height, width)
     else:
@@ -841,7 +832,7 @@ def normalize_bounds(bounds: BBox) -> BBox:
     )
 
 
-def _validate_shape_input(shape: Dict) -> Dict:
+def _validate_shape_input(shape: dict) -> dict:
     """Ensure input shape is valid and reduce features to geometry"""
 
     if "geometry" in shape:
@@ -853,7 +844,7 @@ def _validate_shape_input(shape: Dict) -> Dict:
     return shape
 
 
-def cast_to_sequence(val: Optional[Any] = None) -> Sequence:
+def cast_to_sequence(val: Any | None = None) -> Sequence:
     """Cast input to sequence if not Tuple of List."""
     if val is not None and not isinstance(val, (list, tuple)):
         val = (val,)
@@ -861,7 +852,7 @@ def cast_to_sequence(val: Optional[Any] = None) -> Sequence:
     return val
 
 
-def _CRS_authority_info(crs: CRS) -> Optional[Tuple[str, str, str]]:
+def _CRS_authority_info(crs: CRS) -> tuple[str, str, str] | None:
     """Convert CRS to URI.
 
     Code adapted from https://github.com/developmentseed/morecantile/blob/1829fe12408e4a1feee7493308f3f02257ef4caf/morecantile/models.py#L148-L161
@@ -879,7 +870,7 @@ def _CRS_authority_info(crs: CRS) -> Optional[Tuple[str, str, str]]:
     return None
 
 
-def CRS_to_uri(crs: CRS) -> Optional[str]:
+def CRS_to_uri(crs: CRS) -> str | None:
     """Convert CRS to URI."""
     if info := _CRS_authority_info(crs):
         authority, version, code = info
@@ -889,7 +880,7 @@ def CRS_to_uri(crs: CRS) -> Optional[str]:
     return None
 
 
-def CRS_to_urn(crs: CRS) -> Optional[str]:
+def CRS_to_urn(crs: CRS) -> str | None:
     """Convert CRS to URN."""
     if info := _CRS_authority_info(crs):
         authority, version, code = info

{rio_tiler-8.0.4.dist-info → rio_tiler-9.0.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rio-tiler
-Version: 8.0.4
+Version: 9.0.0a1
 Summary: User friendly Rasterio plugin to read raster datasets.
 Project-URL: Homepage, https://cogeotiff.github.io/rio-tiler/
 Project-URL: Documentation, https://cogeotiff.github.io/rio-tiler/