yirgacheffe 1.7.8__tar.gz → 1.8.0__tar.gz

{yirgacheffe-1.7.8/yirgacheffe.egg-info → yirgacheffe-1.8.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.7.8
+Version: 1.8.0
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC
-Project-URL: Homepage, https://github.com/quantifyearth/yirgacheffe
+Project-URL: Homepage, https://yirgacheffe.org/
 Project-URL: Repository, https://github.com/quantifyearth/yirgacheffe.git
 Project-URL: Issues, https://github.com/quantifyearth/yirgacheffe/issues
-Project-URL: Changelog, https://github.com/quantifyearth/yirgacheffe/blob/main/CHANGES.md
+Project-URL: Changelog, https://yirgacheffe.org/latest/changelog/
 Keywords: gdal,gis,geospatial,declarative
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
@@ -26,16 +26,23 @@ Requires-Dist: torch
 Requires-Dist: dill
 Requires-Dist: deprecation
 Requires-Dist: tomli
+Requires-Dist: h3
+Provides-Extra: mlx
+Requires-Dist: mlx; extra == "mlx"
 Provides-Extra: dev
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pylint; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: h3; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: mlx; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: mkdocstrings-python; extra == "dev"
+Requires-Dist: mike; extra == "dev"
+Requires-Dist: mkdocs-gen-files; extra == "dev"
 Dynamic: license-file
 
-# Yirgacheffe: a gdal wrapper that does the tricky bits
+# Yirgacheffe: a declarative geospatial library for Python to make data-science with maps easier
 
 ## Overview
 

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/README.md

@@ -1,4 +1,4 @@
-# Yirgacheffe: a gdal wrapper that does the tricky bits
+# Yirgacheffe: a declarative geospatial library for Python to make data-science with maps easier
 
 ## Overview
 

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yirgacheffe"
-version = "1.7.8"
+version = "1.8.0"
 description = "Abstraction of gdal datasets for doing basic math operations"
 readme = "README.md"
 authors = [{ name = "Michael Dales", email = "mwd24@cam.ac.uk" }]
@@ -28,18 +28,33 @@ dependencies = [
     "torch",
     "dill",
     "deprecation",
-    "tomli"
+    "tomli",
+    "h3",
 ]
 requires-python = ">=3.10"
 
 [project.optional-dependencies]
-dev = ["mypy", "pylint", "pytest", "h3", "pytest-cov", "mlx"]
+mlx = [
+    "mlx",
+]
+dev = [
+    "mypy",
+    "pylint",
+    "pytest",
+    "pytest-cov",
+    "build",
+    "twine",
+    "mkdocs-material",
+    "mkdocstrings-python",
+    "mike",
+    "mkdocs-gen-files",
+]
 
 [project.urls]
-Homepage = "https://github.com/quantifyearth/yirgacheffe"
+Homepage = "https://yirgacheffe.org/"
 Repository = "https://github.com/quantifyearth/yirgacheffe.git"
 Issues = "https://github.com/quantifyearth/yirgacheffe/issues"
-Changelog = "https://github.com/quantifyearth/yirgacheffe/blob/main/CHANGES.md"
+Changelog = "https://yirgacheffe.org/latest/changelog/"
 
 [project.scripts]
 realpython = "reader.__main__:main"
@@ -58,3 +73,6 @@ ignore_missing_imports = true
 [[tool.mypy.overrides]]
 module = "deprecation.*"
 ignore_missing_imports = true
+
+[tool.setuptools.packages.find]
+exclude = ["site*", "docs*", "tests*"]

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/tests/test_base.py

@@ -1,5 +1,4 @@
 import math
-from typing import Tuple
 
 import pytest
 
@@ -58,7 +57,7 @@ def test_pixel_from_latlng_unsupported_projection() -> None:
         ),
     ]
 )
-def test_latlng_for_pixel(area: Area, pixel: Tuple[int,int], expected: Tuple[float,float]) -> None:
+def test_latlng_for_pixel(area: Area, pixel: tuple[int, int], expected: tuple[float, float]) -> None:
     layer = YirgacheffeLayer(
         area,
         MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
@@ -87,7 +86,7 @@ def test_latlng_for_pixel(area: Area, pixel: Tuple[int,int], expected: Tuple[flo
         ),
     ]
 )
-def test_pixel_for_latlng(area: Area, coord: Tuple[float,float], expected: Tuple[int,int]) -> None:
+def test_pixel_for_latlng(area: Area, coord: tuple[float, float], expected: tuple[int, int]) -> None:
     layer = YirgacheffeLayer(
         area,
         MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
@@ -140,8 +139,8 @@ def test_pixel_for_latlng(area: Area, coord: Tuple[float,float], expected: Tuple
 def test_latlng_for_pixel_with_intersection(
     area: Area,
     window: Area,
-    pixel: Tuple[int,int],
-    expected: Tuple[float,float]
+    pixel: tuple[int, int],
+    expected: tuple[float, float]
 ) -> None:
     layer = YirgacheffeLayer(
         area,
@@ -178,8 +177,8 @@ def test_latlng_for_pixel_with_intersection(
 def test_pixel_for_latlng_with_intersection(
     area: Area,
     window: Area,
-    coord: Tuple[float,float],
-    expected: Tuple[int,int]
+    coord: tuple[float, float],
+    expected: tuple[int, int]
 ) -> None:
     layer = YirgacheffeLayer(
         area,

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/tests/test_datatypes.py

@@ -22,7 +22,7 @@ from tests.helpers import gdal_dataset_with_data
 ])
 def test_round_trip(gtype) -> None:
     ytype = DataType.of_gdal(gtype)
-    backend_type = backend.dtype_to_backed(ytype)
+    backend_type = backend.dtype_to_backend(ytype)
     assert backend.backend_to_dtype(backend_type) == ytype
 
 @pytest.mark.parametrize("ytype", [
@@ -42,7 +42,7 @@ def test_round_trip_from_gdal(ytype) -> None:
     assert DataType.of_gdal(gtype) == ytype
 
 def test_round_trip_float64() -> None:
-    backend_type = backend.dtype_to_backed(DataType.Float64)
+    backend_type = backend.dtype_to_backend(DataType.Float64)
     ytype = backend.backend_to_dtype(backend_type)
     match BACKEND:
         case "NUMPY":

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/tests/test_operators.py

@@ -1428,18 +1428,34 @@ def test_ceil_module() -> None:
     actual = result.read_array(0, 0, 4, 2)
     assert (expected == actual).all()
 
-def test_to_geotiff_on_layer() -> None:
+def test_to_geotiff_on_int_layer() -> None:
     data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
     layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    assert layer1.datatype == DataType.Int64
 
     with tempfile.TemporaryDirectory() as tempdir:
         filename = os.path.join(tempdir, "test.tif")
         layer1.to_geotiff(filename)
 
         with RasterLayer.layer_from_file(filename) as result:
+            assert result.datatype == DataType.Int64
             actual = result.read_array(0, 0, 4, 2)
             assert (data1 == actual).all()
 
+def test_to_geotiff_on_float_layer() -> None:
+    data1 = np.array([[1.1, 2.1, 3.1, 4.1], [5.1, 6.1, 7.1, 8.1]])
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    assert layer1.datatype == DataType.Float64
+
+    with tempfile.TemporaryDirectory() as tempdir:
+        filename = os.path.join(tempdir, "test.tif")
+        layer1.to_geotiff(filename)
+
+        with RasterLayer.layer_from_file(filename) as result:
+            assert result.datatype == DataType.Float64
+            actual = result.read_array(0, 0, 4, 2)
+            assert np.isclose(data1, actual).all()
+
 def test_to_geotiff_single_thread() -> None:
     data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
     layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/tests/test_rounding.py

@@ -1,5 +1,4 @@
 import sys
-from typing import List
 
 import pytest
 
@@ -84,5 +83,5 @@ def test_pixel_rounding_down(pixels: float, scale: float, expected: int) -> None
         ),
     ]
 )
-def test_pixel_scale_comparison(pixel_scales: List[PixelScale], expected: bool) -> None:
+def test_pixel_scale_comparison(pixel_scales: list[PixelScale], expected: bool) -> None:
     assert are_pixel_scales_equal_enough(pixel_scales) == expected

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/yirgacheffe/__init__.py

@@ -14,5 +14,6 @@ except ModuleNotFoundError:
 
 from ._core import read_raster, read_rasters, read_shape, read_shape_like, constant, read_narrow_raster
 from .constants import WGS_84_PROJECTION
+from .window import Area, MapProjection, Window
 
 gdal.UseExceptions()

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/yirgacheffe/_backends/mlx.py

@@ -1,4 +1,6 @@
-from typing import Callable, Dict
+from __future__ import annotations
+
+from typing import Callable
 
 import numpy as np
 import mlx.core as mx # type: ignore
@@ -131,7 +133,7 @@ def conv2d_op(data, weights):
     return res[0]
 
 
-def dtype_to_backed(dt):
+def dtype_to_backend(dt):
     match dt:
         case dtype.Float32:
             return mx.float32
@@ -182,9 +184,9 @@ def backend_to_dtype(val):
             raise ValueError
 
 def astype_op(data, datatype):
-    return data.astype(dtype_to_backed(datatype))
+    return data.astype(dtype_to_backend(datatype))
 
-operator_map : Dict[op,Callable] = {
+operator_map: dict[op, Callable] = {
     op.ADD: mx.array.__add__,
     op.SUB: mx.array.__sub__,
     op.MUL: mul_op,

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/yirgacheffe/_backends/numpy.py

@@ -1,4 +1,6 @@
-from typing import Callable, Dict
+from __future__ import annotations
+
+from typing import Callable
 
 import numpy as np
 import torch
@@ -67,7 +69,7 @@ def conv2d_op(data, weights):
     res = conv(preped_data)
     return res.detach().numpy()[0][0]
 
-def dtype_to_backed(dt):
+def dtype_to_backend(dt):
     match dt:
         case dtype.Float32:
             return np.float32
@@ -120,9 +122,9 @@ def backend_to_dtype(val):
             raise ValueError
 
 def astype_op(data, datatype):
-    return data.astype(dtype_to_backed(datatype))
+    return data.astype(dtype_to_backend(datatype))
 
-operator_map : Dict[op,Callable] = {
+operator_map: dict[op, Callable] = {
     op.ADD: np.ndarray.__add__,
     op.SUB: np.ndarray.__sub__,
     op.MUL: np.ndarray.__mul__,

yirgacheffe-1.8.0/yirgacheffe/_core.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Sequence
+
+from .layers.area import UniformAreaLayer
+from .layers.base import YirgacheffeLayer
+from .layers.constant import ConstantLayer
+from .layers.group import GroupLayer, TiledGroupLayer
+from .layers.rasters import RasterLayer
+from .layers.vectors import VectorLayer
+from .window import MapProjection
+from ._backends.enumeration import dtype as DataType
+
+def read_raster(
+    filename: Path | str,
+    band: int = 1,
+    ignore_nodata: bool = False,
+) -> RasterLayer:
+    """Open a raster file (e.g., GeoTIFF).
+
+    Args:
+        filename: Path of raster file to open.
+        band: For multi-band rasters, which band to use (defaults to first if not specified).
+        ignore_nodata: If the GeoTIFF has a NODATA value, don't substitute that value for NaN.
+
+    Returns:
+        An layer representing the raster data.
+
+    Examples:
+        >>> import yirgacheffe as yg
+        >>> with yg.read_raster('test.tif') as layer:
+        ...     total = layer.sum()
+    """
+    return RasterLayer.layer_from_file(filename, band, ignore_nodata)
+
+def read_narrow_raster(
+    filename: Path | str,
+    band: int = 1,
+    ignore_nodata: bool = False,
+) -> RasterLayer:
+    """Open a 1 pixel wide raster file as a global raster.
+
+    This exists for the special use case where an area per pixel raster would have the same value per horizontal row
+    (e.g., a WGS84 map projection). For that case you can use this to load a raster that is 1 pixel wide and have
+    it automatically expanded to act like a global raster in calculations.
+
+    Args:
+        filename: Path of raster file to open.
+        band: For multi-band rasters, which band to use (defaults to first if not specified).
+        ignore_nodata: If the GeoTIFF has a NODATA value, don't substitute that value for NaN.
+
+    Returns:
+        An layer representing the raster data.
+    """
+    return UniformAreaLayer.layer_from_file(filename, band, ignore_nodata)
+
+def read_rasters(
+    filenames : Sequence[Path | str],
+    tiled: bool=False
+) -> GroupLayer:
+    """Open a set of raster files (e.g., GeoTIFFs) as a single layer.
+
+    Args:
+        filenames: List of paths of raster files to open.
+        tiled: If you know that the rasters for a regular tileset, then setting this flag allows
+            Yirgacheffe to perform certain optimisations that significantly improve performance for
+            this use case.
+
+    Returns:
+        An layer representing the raster data.
+
+    Examples:
+        >>> import yirgacheffe as yg
+        >>> with yg.read_rasters(['tile_N10_E10.tif', 'tile_N20_E10.tif']) as all_tiles:
+        ...    ...
+    """
+    if not tiled:
+        return GroupLayer.layer_from_files(filenames)
+    else:
+        return TiledGroupLayer.layer_from_files(filenames)
+
+def read_shape(
+    filename: Path | str,
+    projection: MapProjection | tuple[str, tuple[float, float]] | None = None,
+    where_filter: str | None = None,
+    datatype: DataType | None = None,
+    burn_value: int | float | str = 1,
+) -> VectorLayer:
+    """Open a polygon file (e.g., GeoJSON, GPKG, or ESRI Shape File).
+
+    Args:
+        filename: Path of vector file to open.
+        projection: The map projection to use.
+        where_filter: For use with files with many entries (e.g., GPKG), applies this filter to the data.
+        datatype: Specify the data type of the raster data generated.
+        burn_value: The value of each pixel in the polygon.
+
+    Returns:
+        An layer representing the vector data.
+
+    Examples:
+        >>> import yirgacheffe as yg
+        >>> with yg.read_shape('range.gpkg') as layer:
+        ...    ...
+    """
+
+    if projection is not None:
+        if not isinstance(projection, MapProjection):
+            projection_name, scale_tuple = projection
+            projection = MapProjection(projection_name, scale_tuple[0], scale_tuple[1])
+
+    return VectorLayer._future_layer_from_file(
+        filename,
+        where_filter,
+        projection,
+        datatype,
+        burn_value,
+    )
+
+def read_shape_like(
+    filename: Path | str,
+    like: YirgacheffeLayer,
+    where_filter: str | None = None,
+    datatype: DataType | None = None,
+    burn_value: int | float | str = 1,
+) -> VectorLayer:
+    """Open a polygon file (e.g., GeoJSON, GPKG, or ESRI Shape File).
+
+    Args:
+        filename: Path of vector file to open.
+        like: Another layer that has a projection and pixel scale set. This layer will
+            use the same projection and pixel scale as that one.
+        where_filter: For use with files with many entries (e.g., GPKG), applies this filter to the data.
+        datatype: Specify the data type of the raster data generated.
+        burn_value: The value of each pixel in the polygon.
+
+    Returns:
+        An layer representing the vector data.
+    """
+    return VectorLayer.layer_from_file_like(
+        filename,
+        like,
+        where_filter,
+        datatype,
+        burn_value,
+    )
+
+def constant(value: int | float) -> ConstantLayer:
+    """Generate a layer that has the same value in all pixels regardless of scale, projection, and area.
+
+    Generally this should not be necessary unless you must have the constant as the first term in an
+    expression, as Yirgacheffe will automatically convert numbers into constant layers. However if the
+    constant is the first term in the expression it must be wrapped by this call otherwise Python will
+    not know that it should be part of the Yirgacheffe expression.
+
+    Args:
+        value: The value to be in each pixel of the expression term.
+
+    Returns:
+        A constant layer of the provided value.
+    """
+    return ConstantLayer(value)

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/yirgacheffe/_operators.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import math
 import multiprocessing
@@ -12,7 +14,7 @@ from enum import Enum
 from multiprocessing import Semaphore, Process
 from multiprocessing.managers import SharedMemoryManager
 from pathlib import Path
-from typing import Callable, Dict, Optional, Union
+from typing import Callable
 
 import deprecation
 import numpy as np
@@ -26,6 +28,8 @@ from .window import Area, PixelScale, MapProjection, Window
 from ._backends import backend
 from ._backends.enumeration import operators as op
 from ._backends.enumeration import dtype as DataType
+from ._backends.numpy import dtype_to_backend as dtype_to_numpy
+from ._backends.numpy import backend_to_dtype as numpy_to_dtype
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.WARNING)
@@ -47,6 +51,11 @@ class LayerConstant:
     def _eval(self, _area, _projection, _index, _step, _target_window):
         return self.val
 
+    @property
+    def datatype(self) -> DataType:
+        numpy_type = np.result_type(self.val)
+        return numpy_to_dtype(numpy_type)
+
     @property
     def area(self) -> Area:
         return Area.world()
@@ -258,10 +267,10 @@ class LayerMathMixin:
 
     def to_geotiff(
         self,
-        filename: Union[Path,str],
+        filename: Path | str,
         and_sum: bool = False,
-        parallelism:Optional[Union[int,bool]]=None
-    ) -> Optional[float]:
+        parallelism: int | bool | None = None
+    ) -> float | None:
         return LayerOperation(self).to_geotiff(filename, and_sum, parallelism)
 
     def sum(self):
@@ -391,7 +400,7 @@ class LayerOperation(LayerMathMixin):
     def area(self) -> Area:
         return self._get_operation_area(self.map_projection)
 
-    def _get_operation_area(self, projection: Optional[MapProjection]) -> Area:
+    def _get_operation_area(self, projection: MapProjection | None) -> Area:
         lhs_area = self.lhs._get_operation_area(projection)
         try:
             rhs_area = self.rhs._get_operation_area(projection)
@@ -475,8 +484,16 @@ class LayerOperation(LayerMathMixin):
 
     @property
     def datatype(self) -> DataType:
-        # TODO: Work out how to indicate type promotion via numpy
-        return self.lhs.datatype
+        internal_types: list[DataType] = [
+            self.lhs.datatype
+        ]
+        if self.rhs is not None:
+            internal_types.append(self.rhs.datatype)
+        if self.other is not None:
+            internal_types.append(self.other.datatype)
+        internal_types_as_numpy_types = [dtype_to_numpy(x) for x in internal_types]
+        coerced_type = np.result_type(*internal_types_as_numpy_types)
+        return numpy_to_dtype(coerced_type)
 
     @property
     @deprecation.deprecated(
@@ -496,7 +513,7 @@ class LayerOperation(LayerMathMixin):
         return projection
 
     @property
-    def map_projection(self) -> Optional[MapProjection]:
+    def map_projection(self) -> MapProjection | None:
         try:
             projection = self.lhs.map_projection
         except AttributeError:
@@ -515,7 +532,7 @@ class LayerOperation(LayerMathMixin):
         projection: MapProjection,
         index: int,
         step: int,
-        target_window:Optional[Window]=None
+        target_window: Window | None = None
     ):
 
         if self.buffer_padding:
@@ -592,7 +609,7 @@ class LayerOperation(LayerMathMixin):
                 res = chunk_max
         return res
 
-    def save(self, destination_layer, and_sum=False, callback=None, band=1) -> Optional[float]:
+    def save(self, destination_layer, and_sum=False, callback=None, band=1) -> float | None:
         """
         Calling save will write the output of the operation to the provied layer.
         If you provide sum as true it will additionall compute the sum and return that.
@@ -708,7 +725,7 @@ class LayerOperation(LayerMathMixin):
         callback=None,
         parallelism=None,
         band=1
-    ) -> Optional[float]:
+    ) -> float | None:
         assert (destination_layer is not None) or and_sum
         try:
             computation_window = self.window
@@ -748,7 +765,7 @@ class LayerOperation(LayerMathMixin):
                     or (computation_window.ysize != destination_window.ysize):
                 raise ValueError("Destination raster window size does not match input raster window size.")
 
-            np_type_map : Dict[int, np.dtype] = {
+            np_type_map: dict[int, np.dtype] = {
                 gdal.GDT_Byte:    np.dtype('byte'),
                 gdal.GDT_Float32: np.dtype('float32'),
                 gdal.GDT_Float64: np.dtype('float64'),
@@ -867,7 +884,7 @@ class LayerOperation(LayerMathMixin):
         callback=None,
         parallelism=None,
         band=1
-    ) -> Optional[float]:
+    ) -> float | None:
         if destination_layer is None:
             raise ValueError("Layer is required")
         return self._parallel_save(destination_layer, and_sum, callback, parallelism, band)
@@ -877,25 +894,20 @@ class LayerOperation(LayerMathMixin):
 
     def to_geotiff(
         self,
-        filename: Union[Path,str],
+        filename: Path | str,
         and_sum: bool = False,
-        parallelism:Optional[Union[int,bool]] = None
-    ) -> Optional[float]:
+        parallelism: int | bool | None = None
+    ) -> float | None:
         """Saves a calculation to a raster file, optionally also returning the sum of pixels.
 
-        Parameters
-        ----------
-        filename : Path
-            Path of the raster to save the result to.
-        and_sum : bool, default=False
-            If true then the function will also calculate the sum of the raster as it goes and return that value.
-        parallelism : int or bool, optional, default=None
-            If passed, attempt to use multiple CPU cores up to the number provided, or if set to True, yirgacheffe
-            will pick a sensible value.
-
-        Returns
-        -------
-        float, optional
+        Args:
+            filename: Path of the raster to save the result to.
+            and_sum: If true then the function will also calculate the sum of the raster as it goes and return
+                that value.
+            parallelism: If passed, attempt to use multiple CPU cores up to the number provided, or if set to True,
+                yirgacheffe will pick a sensible value.
+
+        Returns:
             Either returns None, or the sum of the pixels in the resulting raster if `and_sum` was specified.
         """
 

{yirgacheffe-1.7.8 → yirgacheffe-1.8.0}/yirgacheffe/layers/area.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 from math import ceil, floor
-from typing import Any, Optional
+from pathlib import Path
+from typing import Any
 
 import numpy
 from osgeo import gdal
@@ -18,7 +21,7 @@ class UniformAreaLayer(RasterLayer):
     """
 
     @staticmethod
-    def generate_narrow_area_projection(source_filename: str, target_filename: str) -> None:
+    def generate_narrow_area_projection(source_filename: Path | str, target_filename: Path | str) -> None:
         source = gdal.Open(source_filename, gdal.GA_ReadOnly)
         if source is None:
             raise FileNotFoundError(source_filename)
@@ -56,7 +59,7 @@ class UniformAreaLayer(RasterLayer):
                 return False
         return True
 
-    def __init__(self, dataset, name: Optional[str] = None, band: int = 1, ignore_nodata: bool = False):
+    def __init__(self, dataset, name: str | None = None, band: int = 1, ignore_nodata: bool = False):
         if dataset.RasterXSize > 1:
             raise ValueError("Expected a shrunk dataset")
         self.databand = dataset.GetRasterBand(1).ReadAsArray(0, 0, 1, dataset.RasterYSize)