yirgacheffe 1.7.9__py3-none-any.whl → 1.8.1__py3-none-any.whl

yirgacheffe/layers/group.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import copy
 from pathlib import Path
-from typing import Any, List, Optional, Sequence, Union
+from typing import Any, Sequence
 
 import numpy as np
 from numpy import ma
@@ -22,8 +22,8 @@ class GroupLayer(YirgacheffeLayer):
     @classmethod
     def layer_from_directory(
         cls,
-        directory_path: Union[Path,str],
-        name: Optional[str] = None,
+        directory_path: Path | str,
+        name: str | None = None,
         matching: str = "*.tif"
     ) -> GroupLayer:
         if directory_path is None:
@@ -38,20 +38,20 @@ class GroupLayer(YirgacheffeLayer):
     @classmethod
     def layer_from_files(
         cls,
-        filenames: Sequence[Union[Path,str]],
-        name: Optional[str] = None
+        filenames: Sequence[Path | str],
+        name: str | None = None
     ) -> GroupLayer:
         if filenames is None:
             raise ValueError("filenames argument is None")
-        rasters: List[YirgacheffeLayer] = [RasterLayer.layer_from_file(x) for x in filenames]
+        rasters: list[YirgacheffeLayer] = [RasterLayer.layer_from_file(x) for x in filenames]
         if len(rasters) < 1:
             raise GroupLayerEmpty("No files found")
         return cls(rasters, name)
 
     def __init__(
         self,
-        layers: List[YirgacheffeLayer],
-        name: Optional[str] = None
+        layers: list[YirgacheffeLayer],
+        name: str | None = None
     ) -> None:
         if not layers:
             raise GroupLayerEmpty("Expected one or more layers")
@@ -255,7 +255,7 @@ class TiledGroupLayer(GroupLayer):
             ysize
         )
 
-        partials: List[TileData] = []
+        partials: list[TileData] = []
         for layer in self.layers:
             # Normally this is hidden with set_window_for_...
             adjusted_layer_window = Window(
@@ -287,7 +287,7 @@ class TiledGroupLayer(GroupLayer):
         # the "obvious" tile. In which case, we should reject the smaller section. If we have
         # two tiles at the same offset and one is not a perfect subset of the other then the
         # tile set we were given is not regularly shaped, and so we should give up.
-        combed_partials: List[TileData] = []
+        combed_partials: list[TileData] = []
         previous_tile = None
         for tile in sorted_partials:
             if previous_tile is None:
@@ -312,7 +312,7 @@ class TiledGroupLayer(GroupLayer):
         expected_next_x = 0
         expected_next_y = 0
         data = None
-        row_chunk: Optional[np.ndarray] = None
+        row_chunk: np.ndarray | None = None
 
         # Allow for reading off top
         if combed_partials:

yirgacheffe/layers/h3layer.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from math import ceil, floor
-from typing import Any, Tuple
+from typing import Any
 
 import h3
 import numpy as np
@@ -75,7 +77,7 @@ class H3CellLayer(YirgacheffeLayer):
         )
 
     @property
-    def _raster_dimensions(self) -> Tuple[int,int]:
+    def _raster_dimensions(self) -> tuple[int, int]:
         return (self._raster_xsize, self._raster_ysize)
 
     @property

yirgacheffe/layers/rasters.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import math
 from pathlib import Path
-from typing import Any, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 from osgeo import gdal
@@ -26,14 +26,14 @@ class RasterLayer(YirgacheffeLayer):
     def empty_raster_layer(
         area: Area,
         scale: PixelScale,
-        datatype: Union[int, DataType],
-        filename: Optional[Union[Path,str]]=None,
+        datatype: int | DataType,
+        filename: Path | str | None = None,
         projection: str=WGS_84_PROJECTION,
-        name: Optional[str]=None,
+        name: str | None = None,
         compress: bool=True,
-        nodata: Optional[Union[float,int]]=None,
-        nbits: Optional[int]=None,
-        threads: Optional[int]=None,
+        nodata: float | int | None = None,
+        nbits: int | None = None,
+        threads: int | None = None,
         bands: int=1
     ) -> RasterLayer:
         abs_xstep, abs_ystep = abs(scale.xstep), abs(scale.ystep)
@@ -88,13 +88,13 @@ class RasterLayer(YirgacheffeLayer):
     @staticmethod
     def empty_raster_layer_like(
         layer: Any,
-        filename: Optional[Union[Path,str]]=None,
-        area: Optional[Area]=None,
-        datatype: Optional[Union[int, DataType]]=None,
+        filename: Path | str | None = None,
+        area: Area | None = None,
+        datatype: int | DataType | None = None,
         compress: bool=True,
-        nodata: Optional[Union[float,int]]=None,
-        nbits: Optional[int]=None,
-        threads: Optional[int]=None,
+        nodata: float | int | None = None,
+        nbits: int | None = None,
+        threads: int | None = None,
         bands: int=1
     ) -> RasterLayer:
         if area is None:
@@ -165,7 +165,7 @@ class RasterLayer(YirgacheffeLayer):
         cls,
         source: RasterLayer,
         new_pixel_scale: PixelScale,
-        filename: Optional[Union[Path,str]]=None,
+        filename: Path | str | None = None,
         compress: bool=True,
         algorithm: int=gdal.GRA_NearestNeighbour,
     ) -> RasterLayer:
@@ -220,7 +220,7 @@ class RasterLayer(YirgacheffeLayer):
     @classmethod
     def layer_from_file(
         cls,
-        filename: Union[Path,str],
+        filename: Path | str,
         band: int = 1,
         ignore_nodata: bool = False,
     ) -> RasterLayer:
@@ -238,7 +238,7 @@ class RasterLayer(YirgacheffeLayer):
     def __init__(
         self,
         dataset: gdal.Dataset,
-        name: Optional[str] = None,
+        name: str | None = None,
         band: int = 1,
         ignore_nodata: bool = False,
     ) -> None:
@@ -273,7 +273,7 @@ class RasterLayer(YirgacheffeLayer):
         self._ignore_nodata = ignore_nodata
 
     @property
-    def _raster_dimensions(self) -> Tuple[int,int]:
+    def _raster_dimensions(self) -> tuple[int, int]:
         return (self._raster_xsize, self._raster_ysize)
 
     def close(self):
@@ -321,7 +321,7 @@ class RasterLayer(YirgacheffeLayer):
         return DataType.of_gdal(self._dataset.GetRasterBand(1).DataType)
 
     @property
-    def nodata(self) -> Optional[Any]:
+    def nodata(self) -> Any | None:
         if self._dataset is None:
             self._unpark()
         assert self._dataset

yirgacheffe/layers/rescaled.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from math import floor, ceil
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 from skimage import transform
 
@@ -18,7 +18,7 @@ class RescaledRasterLayer(YirgacheffeLayer):
     @classmethod
     def layer_from_file(
         cls,
-        filename: Union[Path,str],
+        filename: Path | str,
         pixel_scale: PixelScale,
         band: int = 1,
         nearest_neighbour: bool = True,
@@ -35,7 +35,7 @@ class RescaledRasterLayer(YirgacheffeLayer):
         src: RasterLayer,
         target_projection: MapProjection,
         nearest_neighbour: bool = True,
-        name: Optional[str] = None,
+        name: str | None = None,
     ):
         super().__init__(
             src.area,

yirgacheffe/layers/vectors.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 from math import ceil, floor
 from pathlib import Path
-from typing import Any, Optional, Tuple, Union
-from typing_extensions import NotRequired
+from typing import Any
 
 import deprecation
 from osgeo import gdal, ogr
@@ -70,12 +69,12 @@ class RasteredVectorLayer(RasterLayer):
     )
     def layer_from_file( # type: ignore[override] # pylint: disable=W0221
         cls,
-        filename: Union[Path,str],
-        where_filter: Optional[str],
+        filename: Path | str,
+        where_filter: str | None,
         scale: PixelScale,
         projection: str,
-        datatype: Optional[Union[int, DataType]] = None,
-        burn_value: Union[int,float,str] = 1,
+        datatype: int | DataType | None = None,
+        burn_value: int | float | str = 1,
     ) -> RasteredVectorLayer:
         vectors = ogr.Open(filename)
         if vectors is None:
@@ -111,14 +110,14 @@ class RasteredVectorLayer(RasterLayer):
         self,
         layer: ogr.Layer,
         projection: MapProjection,
-        datatype: Union[int, DataType] = DataType.Byte,
-        burn_value: Union[int,float,str] = 1,
+        datatype: int | DataType = DataType.Byte,
+        burn_value: int | float | str = 1,
     ):
         if layer is None:
             raise ValueError('No layer provided')
         self.layer = layer
 
-        self._original: Optional[Any] = None
+        self._original: Any | None = None
 
         if isinstance(datatype, int):
             datatype_arg = DataType.of_gdal(datatype)
@@ -180,11 +179,11 @@ class VectorLayer(YirgacheffeLayer):
     @classmethod
     def layer_from_file_like(
         cls,
-        filename: Union[Path,str],
+        filename: Path | str,
         other_layer: YirgacheffeLayer,
-        where_filter: Optional[str]=None,
-        datatype: Optional[Union[int, DataType]] = None,
-        burn_value: Union[int,float,str] = 1,
+        where_filter: str | None = None,
+        datatype: int | DataType | None = None,
+        burn_value: int | float | str = 1,
     ) -> VectorLayer:
         if other_layer is None:
             raise ValueError("like layer can not be None")
@@ -223,13 +222,13 @@ class VectorLayer(YirgacheffeLayer):
     @classmethod
     def layer_from_file(
         cls,
-        filename: Union[Path,str],
-        where_filter: Optional[str],
-        scale: Optional[PixelScale],
-        projection: Optional[str],
-        datatype: Optional[Union[int, DataType]] = None,
-        burn_value: Union[int,float,str] = 1,
-        anchor: Tuple[float,float] = (0.0, 0.0)
+        filename: Path | str,
+        where_filter: str | None,
+        scale: PixelScale | None,
+        projection: str | None,
+        datatype: int | DataType | None = None,
+        burn_value: int | float | str = 1,
+        anchor: tuple[float, float] = (0.0, 0.0)
     ) -> VectorLayer:
         # In 2.0 we need to remove this and migrate to the MapProjection version
         if (projection is None) ^ (scale is None):
@@ -250,12 +249,12 @@ class VectorLayer(YirgacheffeLayer):
     @classmethod
     def _future_layer_from_file(
         cls,
-        filename: Union[Path,str],
-        where_filter: Optional[str],
-        projection: Optional[MapProjection],
-        datatype: Optional[Union[int, DataType]] = None,
-        burn_value: Union[int,float,str] = 1,
-        anchor: Tuple[float,float] = (0.0, 0.0)
+        filename: Path | str,
+        where_filter: str | None,
+        projection: MapProjection | None,
+        datatype: int | DataType | None = None,
+        burn_value: int | float | str = 1,
+        anchor: tuple[float, float] = (0.0, 0.0)
     ) -> VectorLayer:
         try:
             vectors = ogr.Open(filename)
@@ -295,11 +294,11 @@ class VectorLayer(YirgacheffeLayer):
     def __init__(
         self,
         layer: ogr.Layer,
-        projection: Optional[MapProjection],
-        name: Optional[str] = None,
-        datatype: Union[int,DataType] = DataType.Byte,
-        burn_value: Union[int,float,str] = 1,
-        anchor: Tuple[float,float] = (0.0, 0.0)
+        projection: MapProjection | None,
+        name: str | None = None,
+        datatype: int | DataType = DataType.Byte,
+        burn_value: int | float | str = 1,
+        anchor: tuple[float, float] = (0.0, 0.0)
     ):
         if layer is None:
             raise ValueError('No layer provided')
@@ -316,9 +315,9 @@ class VectorLayer(YirgacheffeLayer):
         self.burn_value = burn_value
 
         self._original = None
-        self._dataset_path: Optional[Path] = None
-        self._filter: Optional[str] = None
-        self._anchor: Tuple[float,float] = (0.0, 0.0)
+        self._dataset_path: Path | None = None
+        self._filter: str | None = None
+        self._anchor: tuple[float, float] = (0.0, 0.0)
 
         # work out region for mask
         envelopes = []
@@ -334,41 +333,41 @@ class VectorLayer(YirgacheffeLayer):
         self._anchor = anchor
         self._envelopes = envelopes
 
-        # if projection is not None:
-        #     # Get the area, but scale it to the pixel resolution that we're using. Note that
-        #     # the pixel scale GDAL uses can have -ve values, but those will mess up the
-        #     # ceil/floor math, so we use absolute versions when trying to round.
-        #     abs_xstep, abs_ystep = abs(projection.xstep), abs(projection.ystep)
-#
-        #     # Lacking any other reference, we will make the raster align with
-        #     # (0.0, 0.0), if sometimes we want to align with an existing raster, so if
-        #     # an anchor is specified, ensure we use that as our pixel space alignment
-        #     x_anchor = anchor[0]
-        #     y_anchor = anchor[1]
-        #     left_shift = x_anchor - abs_xstep
-        #     right_shift = x_anchor
-        #     top_shift = y_anchor
-        #     bottom_shift = y_anchor - abs_ystep
-#
-        #     area = Area(
-        #         left=(floor((min(x[0] for x in envelopes) - left_shift) / abs_xstep) * abs_xstep) + left_shift,
-        #         top=(ceil((max(x[3] for x in envelopes) - top_shift) / abs_ystep) * abs_ystep) + top_shift,
-        #         right=(ceil((max(x[1] for x in envelopes) - right_shift) / abs_xstep) * abs_xstep) + right_shift,
-        #         bottom=(floor((min(x[2] for x in envelopes) - bottom_shift) / abs_ystep) * abs_ystep) + bottom_shift,
-        #     )
-        # else:
+        if projection is not None:
+            # Get the area, but scale it to the pixel resolution that we're using. Note that
+            # the pixel scale GDAL uses can have -ve values, but those will mess up the
+            # ceil/floor math, so we use absolute versions when trying to round.
+            abs_xstep, abs_ystep = abs(projection.xstep), abs(projection.ystep)
+
+            # Lacking any other reference, we will make the raster align with
+            # (0.0, 0.0), if sometimes we want to align with an existing raster, so if
+            # an anchor is specified, ensure we use that as our pixel space alignment
+            x_anchor = anchor[0]
+            y_anchor = anchor[1]
+            left_shift = x_anchor - abs_xstep
+            right_shift = x_anchor
+            top_shift = y_anchor
+            bottom_shift = y_anchor - abs_ystep
+
+            area = Area(
+                left=(floor((min(x[0] for x in envelopes) - left_shift) / abs_xstep) * abs_xstep) + left_shift,
+                top=(ceil((max(x[3] for x in envelopes) - top_shift) / abs_ystep) * abs_ystep) + top_shift,
+                right=(ceil((max(x[1] for x in envelopes) - right_shift) / abs_xstep) * abs_xstep) + right_shift,
+                bottom=(floor((min(x[2] for x in envelopes) - bottom_shift) / abs_ystep) * abs_ystep) + bottom_shift,
+            )
+        else:
             # If we don't have  a projection just go with the idealised area
-        area = Area(
-            left=floor(min(x[0] for x in envelopes)),
-            top=ceil(max(x[3] for x in envelopes)),
-            right=ceil(max(x[1] for x in envelopes)),
-            bottom=floor(min(x[2] for x in envelopes)),
-        )
+            area = Area(
+                left=floor(min(x[0] for x in envelopes)),
+                top=ceil(max(x[3] for x in envelopes)),
+                right=ceil(max(x[1] for x in envelopes)),
+                bottom=floor(min(x[2] for x in envelopes)),
+            )
 
         super().__init__(area, projection)
 
 
-    def _get_operation_area(self, projection: Optional[MapProjection]=None) -> Area:
+    def _get_operation_area(self, projection: MapProjection | None = None) -> Area:
         if self._projection is not None and projection is not None and self._projection != projection:
             raise ValueError("Calculation projection does not match layer projection")
 
@@ -449,7 +448,7 @@ class VectorLayer(YirgacheffeLayer):
     def _read_array_for_area(
         self,
         target_area: Area,
-        target_projection: Optional[MapProjection],
+        target_projection: MapProjection | None,
         x: int,
         y: int,
         width: int,
@@ -496,7 +495,7 @@ class VectorLayer(YirgacheffeLayer):
         return res
 
     def _read_array_with_window(self, _x, _y, _width, _height, _window) -> Any:
-        assert NotRequired
+        raise NotImplementedError("VectorLayer does not support windowed reading")
 
     def _read_array(self, x: int, y: int, width: int, height: int) -> Any:
         return self._read_array_for_area(self.area, None, x, y, width, height)

yirgacheffe/rounding.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
+
 import math
 import sys
-from typing import List, Optional
 
 from .window import PixelScale
 
@@ -39,10 +40,10 @@ def round_down_pixels(value: float, pixelscale: float) -> int:
     else:
         return math.floor(value)
 
-def are_pixel_scales_equal_enough(pixel_scales: List[Optional[PixelScale]]) -> bool:
+def are_pixel_scales_equal_enough(pixel_scales: list[PixelScale | None]) -> bool:
     # some layers (e.g., constant layers) have no scale, and always work, so filter
     # them out first
-    cleaned_pixel_scales: List[PixelScale] = [x for x in pixel_scales if x is not None]
+    cleaned_pixel_scales: list[PixelScale] = [x for x in pixel_scales if x is not None]
 
     try:
         first = cleaned_pixel_scales[0]