yirgacheffe 1.7.9__tar.gz → 1.8.1__tar.gz

{yirgacheffe-1.7.9/yirgacheffe.egg-info → yirgacheffe-1.8.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.7.9
+Version: 1.8.1
 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
@@ -36,9 +36,13 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; 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.9 → yirgacheffe-1.8.1}/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.9 → yirgacheffe-1.8.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yirgacheffe"
-version = "1.7.9"
+version = "1.8.1"
 description = "Abstraction of gdal datasets for doing basic math operations"
 readme = "README.md"
 authors = [{ name = "Michael Dales", email = "mwd24@cam.ac.uk" }]
@@ -44,13 +44,17 @@ dev = [
     "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"
@@ -69,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.9 → yirgacheffe-1.8.1}/tests/test_area.py

@@ -29,3 +29,6 @@ def test_global_area() -> None:
     other_area = Area(-10.0, 10.0, 10.0, -10.0)
     assert area.overlaps(other_area)
     assert other_area.overlaps(area)
+
+def test_wrong_types_on_eq() -> None:
+    assert Area(-10, 10, 10, -10) != 42

{yirgacheffe-1.7.9 → yirgacheffe-1.8.1}/tests/test_auto_windowing.py

@@ -4,7 +4,7 @@ import tempfile
 import numpy as np
 import pytest
 
-import yirgacheffe
+import yirgacheffe as yg
 from tests.helpers import gdal_dataset_with_data, make_vectors_with_mutlile_ids
 from yirgacheffe.layers import ConstantLayer, RasterLayer, VectorLayer
 from yirgacheffe.window import Area
@@ -315,7 +315,7 @@ def test_vector_layers_multiply() -> None:
         expected = np.array([[2, 0], [0, 8]])
         assert (expected == actual).all()
 
-@pytest.mark.skipif(yirgacheffe._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
+@pytest.mark.skipif(yg._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
 def test_parallel_save_windows() -> None:
     data1 = np.array([[1, 2], [3, 4]])
     data2 = np.array([[10, 20, 30, 40], [50, 60, 70, 80], [90, 100, 110, 120], [130, 140, 150, 160]])

{yirgacheffe-1.7.9 → yirgacheffe-1.8.1}/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.9 → yirgacheffe-1.8.1}/tests/test_intersection.py

@@ -59,6 +59,9 @@ def test_find_intersection_with_constant() -> None:
     intersection = RasterLayer.find_intersection(layers)
     assert intersection == layers[0].area
 
+    for layer in layers:
+        layer.set_window_for_intersection(intersection)
+
 def test_find_intersection_with_vector_unbound() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = Path(tempdir) / "test.gpkg"
@@ -74,6 +77,10 @@ def test_find_intersection_with_vector_unbound() -> None:
         intersection = RasterLayer.find_intersection(layers)
         assert intersection == vector.area
 
+        raster.set_window_for_intersection(intersection)
+        with pytest.raises(ValueError):
+            vector.set_window_for_intersection(intersection)
+
 def test_find_intersection_with_vector_bound() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = Path(tempdir) / "test.gpkg"
@@ -89,6 +96,29 @@ def test_find_intersection_with_vector_bound() -> None:
         intersection = RasterLayer.find_intersection(layers)
         assert intersection == vector.area
 
+        for layer in layers:
+            layer.set_window_for_intersection(intersection)
+
+def test_find_intersection_with_vector_awkward_rounding() -> None:
+    with tempfile.TemporaryDirectory() as tempdir:
+        path = Path(tempdir) / "test.gpkg"
+        area = Area(left=-90, top=45, right=90, bottom=-45)
+        make_vectors_with_id(42, {area}, path)
+        assert path.exists
+
+        raster = RasterLayer(gdal_dataset_of_region(Area(left=-180, top=90, right=180, bottom=-90), 18.0))
+        vector = VectorLayer.layer_from_file(path, None, raster.map_projection.scale, raster.map_projection.name)
+
+        rounded_area = Area(left=-90, top=54, right=90, bottom=-54)
+        assert vector.area == rounded_area
+
+        layers = [raster, vector]
+        intersection = RasterLayer.find_intersection(layers)
+        assert intersection == vector.area
+
+        for layer in layers:
+            layer.set_window_for_intersection(intersection)
+
 def test_find_intersection_different_pixel_pitch() -> None:
     layers = [
         RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), 0.02)),

{yirgacheffe-1.7.9 → yirgacheffe-1.8.1}/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.9 → yirgacheffe-1.8.1}/tests/test_union.py

@@ -49,6 +49,9 @@ def test_find_union_distinct() -> None:
     union = RasterLayer.find_union(layers)
     assert union == Area(-110, 10, 110, -10)
 
+    for layer in layers:
+        layer.set_window_for_union(union)
+
 def test_find_union_with_null() -> None:
     layers = [
         RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), 0.02)),
@@ -80,6 +83,11 @@ def test_find_union_with_vector_unbound() -> None:
         union = RasterLayer.find_union(layers)
         assert union == vector.area
 
+        raster.set_window_for_union(union)
+        with pytest.raises(ValueError):
+            vector.set_window_for_union(union)
+
+
 def test_find_union_with_vector_bound() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = Path(tempdir) / "test.gpkg"
@@ -95,6 +103,9 @@ def test_find_union_with_vector_bound() -> None:
         union = RasterLayer.find_union(layers)
         assert union == vector.area
 
+        for layer in layers:
+            layer.set_window_for_union(union)
+
 @pytest.mark.parametrize("scale", [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09])
 def test_set_union_self(scale) -> None:
     layer = RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), scale))

{yirgacheffe-1.7.9 → yirgacheffe-1.8.1}/yirgacheffe/__init__.py

@@ -14,5 +14,7 @@ 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
+from ._backends.enumeration import dtype as DataType
 
 gdal.UseExceptions()

{yirgacheffe-1.7.9 → yirgacheffe-1.8.1}/yirgacheffe/_backends/enumeration.py

@@ -41,6 +41,26 @@ class operators(Enum):
     ISNAN = 36
 
 class dtype(Enum):
+    """Represents the type of data returned by a layer.
+
+    This enumeration defines the valid data types supported by Yirgacheffe, and is
+    what is returned by  calling `datatype` on a layer or expression, and can be
+    passed to `astype` to convert values between types.
+
+    Attributes:
+        Float32: 32 bit floating point value
+        Float64: 64 bit floating point value
+        Byte: Unsigned 8 bit integer value
+        Int8: Signed 8 bit integer value
+        Int16: Signed 16 bit integer value
+        Int32: Signed 32 bit integer value
+        Int64: Signed 64 bit integer value
+        UInt8: Unsigned 8 bit integer value
+        UInt16: Unsigned 16 bit integer value
+        UInt32: Unsigned 32 bit integer value
+        UInt64: Unsigned 64 bit integer value
+    """
+
     Float32 = gdal.GDT_Float32
     Float64 = gdal.GDT_Float64
     Byte = gdal.GDT_Byte

{yirgacheffe-1.7.9 → yirgacheffe-1.8.1}/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
@@ -184,7 +186,7 @@ def backend_to_dtype(val):
 def astype_op(data, 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.9 → yirgacheffe-1.8.1}/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
@@ -122,7 +124,7 @@ def backend_to_dtype(val):
 def astype_op(data, 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.1/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.9 → yirgacheffe-1.8.1}/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, List, Optional, Union
+from typing import Callable
 
 import deprecation
 import numpy as np
@@ -265,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):
@@ -398,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)
@@ -482,7 +484,7 @@ class LayerOperation(LayerMathMixin):
 
     @property
     def datatype(self) -> DataType:
-        internal_types: List[DataType] = [
+        internal_types: list[DataType] = [
             self.lhs.datatype
         ]
         if self.rhs is not None:
@@ -511,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:
@@ -530,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:
@@ -607,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.
@@ -723,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
@@ -763,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'),
@@ -882,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)
@@ -892,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.9 → yirgacheffe-1.8.1}/yirgacheffe/layers/area.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from math import ceil, floor
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 import numpy
 from osgeo import gdal
@@ -19,7 +21,7 @@ class UniformAreaLayer(RasterLayer):
     """
 
     @staticmethod
-    def generate_narrow_area_projection(source_filename: Union[Path,str], target_filename: Union[Path,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)
@@ -57,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)