yirgacheffe 1.7.0__tar.gz → 1.7.2__tar.gz

{yirgacheffe-1.7.0/yirgacheffe.egg-info → yirgacheffe-1.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.7.0
+Version: 1.7.2
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yirgacheffe"
-version = "1.7.0"
+version = "1.7.2"
 description = "Abstraction of gdal datasets for doing basic math operations"
 readme = "README.md"
 authors = [{ name = "Michael Dales", email = "mwd24@cam.ac.uk" }]

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/tests/test_openers.py

@@ -191,3 +191,25 @@ def test_open_two_raster_areas_side_by_side(tiled):
             with yg.read_raster(path1) as raster1:
                 with yg.read_raster(path2) as raster2:
                     assert group.sum() == raster1.sum() + raster2.sum()
+
+@pytest.mark.parametrize("tiled", [False, True])
+def test_open_two_raster_by_glob(tiled):
+    with tempfile.TemporaryDirectory() as tempdir:
+        temppath = Path(tempdir)
+        path1 = temppath / "test1.tif"
+        area1 = Area(-10, 10, 10, -10)
+        dataset1 = gdal_dataset_of_region(area1, 0.2, filename=path1)
+        dataset1.Close()
+
+        path2 = temppath / "test2.tif"
+        area2 = Area(10, 10, 30, -10)
+        dataset2 = gdal_dataset_of_region(area2, 0.2, filename=path2)
+        dataset2.Close()
+
+        with yg.read_rasters(temppath.glob("*.tif"), tiled=tiled) as group:
+            assert group.area == Area(-10, 10, 30, -10)
+            assert group.window == Window(0, 0, 200, 100)
+
+            with yg.read_raster(path1) as raster1:
+                with yg.read_raster(path2) as raster2:
+                    assert group.sum() == raster1.sum() + raster2.sum()

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/tests/test_operators.py

@@ -1472,42 +1472,54 @@ def test_to_geotiff_single_thread_and_sum() -> None:
             assert (expected == actual).all()
 
 @pytest.mark.skipif(yirgacheffe._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
-def test_to_geotiff_parallel_thread(monkeypatch) -> 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))
-
-    calc = layer1 * 2
-
-    with tempfile.TemporaryDirectory() as tempdir:
-        filename = os.path.join(tempdir, "test.tif")
-        with monkeypatch.context() as m:
-            m.setattr(yirgacheffe.constants, "YSTEP", 1)
-            calc.to_geotiff(filename, parallelism=2)
-
-        with RasterLayer.layer_from_file(filename) as result:
-            expected = data1 * 2
-            actual = result.read_array(0, 0, 4, 2)
-            assert (expected == actual).all()
+@pytest.mark.parametrize("parallelism", [
+    2,
+    True,
+])
+def test_to_geotiff_parallel_thread(monkeypatch, parallelism) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yirgacheffe.constants, "YSTEP", 1)
+        m.setattr(LayerOperation, "save", None)
+        with tempfile.TemporaryDirectory() as tempdir:
+            data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
+            src_filename = os.path.join("src.tif")
+            dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data1, filename=src_filename)
+            dataset.Close()
+            with yirgacheffe.read_raster(src_filename) as layer1:
+                calc = layer1 * 2
+                filename = os.path.join(tempdir, "test.tif")
+                calc.to_geotiff(filename, parallelism=parallelism)
+
+                with RasterLayer.layer_from_file(filename) as result:
+                    expected = data1 * 2
+                    actual = result.read_array(0, 0, 4, 2)
+                    assert (expected == actual).all()
 
 @pytest.mark.skipif(yirgacheffe._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
-def test_to_geotiff_parallel_thread_and_sum(monkeypatch) -> 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))
-
-    calc = layer1 * 2
-
-    with tempfile.TemporaryDirectory() as tempdir:
-        filename = os.path.join(tempdir, "test.tif")
-        with monkeypatch.context() as m:
-            m.setattr(yirgacheffe.constants, "YSTEP", 1)
-            actual_sum = calc.to_geotiff(filename, and_sum=True)
-
-        assert (data1.sum() * 2) == actual_sum
-
-        with RasterLayer.layer_from_file(filename) as result:
-            expected = data1 * 2
-            actual = result.read_array(0, 0, 4, 2)
-            assert (expected == actual).all()
+@pytest.mark.parametrize("parallelism", [
+    2,
+    True,
+])
+def test_to_geotiff_parallel_thread_and_sum(monkeypatch, parallelism) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yirgacheffe.constants, "YSTEP", 1)
+        m.setattr(LayerOperation, "save", None)
+        with tempfile.TemporaryDirectory() as tempdir:
+            data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
+            src_filename = os.path.join("src.tif")
+            dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data1, filename=src_filename)
+            dataset.Close()
+            with yirgacheffe.read_raster(src_filename) as layer1:
+                filename = os.path.join(tempdir, "test.tif")
+                calc = layer1 * 2
+                actual_sum = calc.to_geotiff(filename, and_sum=True, parallelism=parallelism)
+
+                assert (data1.sum() * 2) == actual_sum
+
+                with RasterLayer.layer_from_file(filename) as result:
+                    expected = data1 * 2
+                    actual = result.read_array(0, 0, 4, 2)
+                    assert (expected == actual).all()
 
 def test_raster_and_vector() -> None:
     with tempfile.TemporaryDirectory() as tempdir:

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/tests/test_pickle.py

@@ -12,7 +12,6 @@ from yirgacheffe.window import Area, MapProjection, PixelScale, Window
 from yirgacheffe.layers import ConstantLayer, GroupLayer, RasterLayer, RescaledRasterLayer, \
     UniformAreaLayer, VectorLayer
 from yirgacheffe import WGS_84_PROJECTION
-from yirgacheffe._backends import backend
 
 
 def test_pickle_raster_layer() -> None:
@@ -97,7 +96,7 @@ def test_pickle_group_layer() -> None:
 
         group = GroupLayer.layer_from_directory(tempdir)
         expected = group.read_array(0, 0, 100, 100)
-        assert backend.sum_op(expected) != 0 # just check there is meaningful data
+        assert expected.sum() != 0 # just check there is meaningful data
 
         p = pickle.dumps(group)
         restore = pickle.loads(p)
@@ -192,4 +191,4 @@ def test_pickle_rescaled_raster_layer() -> None:
         assert restore.window == Window(0, 0, 2000, 2000)
 
         expected = restore.read_array(0, 0, 100, 100)
-        assert backend.sum_op(expected) != 0 # just check there is meaningful data
+        assert expected.sum() != 0 # just check there is meaningful data

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/tests/test_raster.py

@@ -5,7 +5,7 @@ import numpy as np
 import pytest
 from osgeo import gdal
 
-from tests.helpers import gdal_dataset_of_region, gdal_multiband_dataset_with_data
+from tests.helpers import gdal_dataset_of_region, gdal_multiband_dataset_with_data, gdal_dataset_with_data
 from yirgacheffe.window import Area, PixelScale, Window
 from yirgacheffe.layers import RasterLayer, InvalidRasterBand
 from yirgacheffe.rounding import round_up_pixels
@@ -260,3 +260,12 @@ def test_multiband_raster() -> None:
         layer = layers[i]
         actual = layer.read_array(0, 0, 4, 2)
         assert (data == actual).all()
+
+def test_read_array_is_numpy():
+    # This test will fail if we use say the MLX backend without casting it back to numpy
+    data = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+    dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data)
+    with RasterLayer(dataset) as layer1:
+        actual = layer1.read_array(0, 0, 4, 2).astype(int)
+        expected = data.astype(int)
+        assert (actual == expected).all

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/tests/test_vectors.py

@@ -19,7 +19,7 @@ def test_basic_vector_layer_no_filter_match() -> None:
             with RasteredVectorLayer.layer_from_file(path, "id_no = 123", PixelScale(1.0, -1.0), "WGS 84") as _layer:
                 pass
 
-def test_basic_dyanamic_vector_layer() -> None:
+def test_basic_dynamic_vector_layer() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = os.path.join(tempdir, "test.gpkg")
         area = Area(-10.0, 10.0, 10.0, 0.0)
@@ -31,6 +31,10 @@ def test_basic_dyanamic_vector_layer() -> None:
             assert layer.window == Window(0, 0, 20, 10)
             assert layer.projection == WGS_84_PROJECTION
 
+            # The astype here is to catch escaping MLX types...
+            res = layer.read_array(0, 0, 20, 20).astype(int)
+            assert res.sum() > 0
+
 def test_rastered_vector_layer() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = os.path.join(tempdir, "test.gpkg")

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/yirgacheffe/_core.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Sequence, Tuple, Union
 
 from .layers.base import YirgacheffeLayer
 from .layers.group import GroupLayer, TiledGroupLayer
@@ -32,7 +32,7 @@ def read_raster(
     return RasterLayer.layer_from_file(filename, band, ignore_nodata)
 
 def read_rasters(
-    filenames : Union[List[Path],List[str]],
+    filenames : Sequence[Union[Path,str]],
     tiled: bool=False
 ) -> GroupLayer:
     """Open a set of raster files (e.g., GeoTIFFs) as a single layer.

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/yirgacheffe/layers/base.py

@@ -7,6 +7,7 @@ from .. import __version__
 from ..operators import DataType, LayerMathMixin
 from ..rounding import almost_equal, round_up_pixels, round_down_pixels
 from ..window import Area, MapProjection, PixelScale, Window
+from .._backends import backend
 
 class YirgacheffeLayer(LayerMathMixin):
     """The common base class for the different layer types. Most still inherit from RasterLayer as deep down
@@ -310,6 +311,9 @@ class YirgacheffeLayer(LayerMathMixin):
         )
         return self._read_array_with_window(x, y, width, height, target_window)
 
+    def _read_array(self, x: int, y: int, width: int, height: int) -> Any:
+        return self._read_array_with_window(x, y, width, height, self.window)
+
     def read_array(self, x: int, y: int, width: int, height: int) -> Any:
         """Reads data from the layer based on the current reference window.
 
@@ -329,7 +333,8 @@ class YirgacheffeLayer(LayerMathMixin):
         Any
             An array of values from the layer.
         """
-        return self._read_array_with_window(x, y, width, height, self.window)
+        res = self._read_array(x, y, width, height)
+        return backend.demote_array(res)
 
     def latlng_for_pixel(self, x_coord: int, y_coord: int) -> Tuple[float,float]:
         """Get geo coords for pixel. This is relative to the set view window."""

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/yirgacheffe/layers/group.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import copy
 from pathlib import Path
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional, Sequence, Union
 
 import numpy as np
 from numpy import ma
@@ -39,14 +39,14 @@ class GroupLayer(YirgacheffeLayer):
     @classmethod
     def layer_from_files(
         cls,
-        filenames: Union[List[Path],List[str]],
+        filenames: Sequence[Union[Path,str]],
         name: Optional[str] = None
     ) -> GroupLayer:
         if filenames is None:
             raise ValueError("filenames argument is None")
-        if len(filenames) < 1:
-            raise GroupLayerEmpty("No files found")
         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__(
@@ -144,7 +144,7 @@ class GroupLayer(YirgacheffeLayer):
         if len(contributing_layers) == 1:
             layer, adjusted_layer_window, intersection = contributing_layers[0]
             if target_window == intersection:
-                data = layer.read_array(
+                data = layer._read_array(
                     intersection.xoff - adjusted_layer_window.xoff,
                     intersection.yoff - adjusted_layer_window.yoff,
                     intersection.xsize,
@@ -156,11 +156,11 @@ class GroupLayer(YirgacheffeLayer):
 
         result = np.zeros((ysize, xsize), dtype=float)
         for layer, adjusted_layer_window, intersection in contributing_layers:
-            data = layer.read_array(
+            data = layer._read_array(
                 intersection.xoff - adjusted_layer_window.xoff,
                 intersection.yoff - adjusted_layer_window.yoff,
                 intersection.xsize,
-                intersection.ysize,
+                intersection.ysize
             )
             result_x_offset = (intersection.xoff - xoffset) - window.xoff
             result_y_offset = (intersection.yoff - yoffset) - window.yoff
@@ -269,7 +269,7 @@ class TiledGroupLayer(GroupLayer):
             intersection = Window.find_intersection_no_throw([target_window, adjusted_layer_window])
             if intersection is None:
                 continue
-            data = layer.read_array(
+            data = layer._read_array(
                 intersection.xoff - adjusted_layer_window.xoff,
                 intersection.yoff - adjusted_layer_window.yoff,
                 intersection.xsize,

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/yirgacheffe/layers/vectors.py

@@ -490,5 +490,9 @@ class VectorLayer(YirgacheffeLayer):
     def _read_array_with_window(self, _x, _y, _width, _height, _window) -> Any:
         assert NotRequired
 
-    def read_array(self, x: int, y: int, width: int, height: int) -> Any:
+    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)
+
+    def read_array(self, x: int, y: int, width: int, height: int) -> Any:
+        res = self._read_array(x, y, width, height)
+        return backend.demote_array(res)

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2}/yirgacheffe/operators.py

@@ -251,7 +251,7 @@ class LayerMathMixin:
         self,
         filename: Union[Path,str],
         and_sum: bool = False,
-        parallelism:Optional[int]=None
+        parallelism:Optional[Union[int,bool]]=None
     ) -> Optional[float]:
         return LayerOperation(self).to_geotiff(filename, and_sum, parallelism)
 
@@ -899,7 +899,7 @@ class LayerOperation(LayerMathMixin):
         self,
         filename: Union[Path,str],
         and_sum: bool = False,
-        parallelism:Optional[int]=None
+        parallelism:Optional[Union[int,bool]] = None
     ) -> Optional[float]:
         """Saves a calculation to a raster file, optionally also returning the sum of pixels.
 
@@ -909,8 +909,9 @@ class LayerOperation(LayerMathMixin):
             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, optional, default=None
-            If passed, attempt to use multiple CPU cores up to the number provided.
+        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
         -------
@@ -932,6 +933,9 @@ class LayerOperation(LayerMathMixin):
                 if parallelism is None:
                     result = self.save(layer, and_sum=and_sum)
                 else:
+                    if isinstance(parallelism, bool):
+                        # Parallel save treats None as "work it out"
+                        parallelism = None
                     result = self.parallel_save(layer, and_sum=and_sum, parallelism=parallelism)
 
             os.makedirs(target_dir, exist_ok=True)

{yirgacheffe-1.7.0 → yirgacheffe-1.7.2/yirgacheffe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.7.0
+Version: 1.7.2
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC