yirgacheffe 1.3.3__tar.gz → 1.3.4__tar.gz

{yirgacheffe-1.3.3/yirgacheffe.egg-info → yirgacheffe-1.3.4}/PKG-INFO

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

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/pyproject.toml

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

yirgacheffe-1.3.4/tests/test_area.py

@@ -0,0 +1,21 @@
+import pytest
+
+# I've no idea why pylint dislikes this particular import but accepts
+# other entries in the module.
+from yirgacheffe.window import Area # pylint: disable=E0401, E0611
+
+@pytest.mark.parametrize(
+    "lhs,rhs,is_equal,overlaps",
+    [
+        # Obvious equality
+        (Area(-10.0, 10.0, 10.0, -10.0), Area(-10.0, 10.0, 10.0, -10.0), True,  True),
+        (Area(-9.0, 9.0, 9.0, -9.0),     Area(-10.0, 10.0, 10.0, -10.0), False, True), # subset
+        (Area(-9.0, 9.0, -1.0, 1.0),     Area(1.0, -1.0, 9.0, -9.0),     False, False),
+        (Area(-10.0, 10.0, 1.0, -10.0),  Area(-1.0, 10.0, 10.0, -10.0),  False, True),
+    ]
+)
+def test_area_operators(lhs: Area, rhs: Area, is_equal: bool, overlaps: bool) -> None:
+    assert (lhs == rhs) == is_equal
+    assert (lhs != rhs) == (not is_equal)
+    assert (lhs.overlaps(rhs)) == overlaps
+    assert (rhs.overlaps(lhs)) == overlaps

yirgacheffe-1.3.4/tests/test_auto_windowing.py

@@ -0,0 +1,284 @@
+import os
+import tempfile
+
+import numpy as np
+import pytest
+
+import yirgacheffe
+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
+
+def test_add_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]])
+
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    layer2 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2))
+
+    assert layer1.area != layer2.area
+    assert layer1.window != layer2.window
+
+    calc = layer1 + layer2
+
+    assert calc.area == layer2.area
+    assert calc.window == layer2.window
+
+    result = RasterLayer.empty_raster_layer_like(calc)
+    calc.save(result)
+
+    expected = np.array([[11, 22, 30, 40], [53, 64, 70, 80], [90, 100, 110, 120], [130, 140, 150, 160]])
+    actual = result.read_array(0, 0, 4, 4)
+    assert (expected == actual).all()
+
+def test_multiply_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]])
+
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    layer2 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2))
+
+    assert layer1.area != layer2.area
+    assert layer1.window != layer2.window
+
+    calc = layer1 * layer2
+
+    assert calc.area == layer1.area
+    assert calc.window == layer1.window
+
+    result = RasterLayer.empty_raster_layer_like(calc)
+    calc.save(result)
+
+    expected = np.array([[10, 40], [150, 240]])
+    actual = result.read_array(0, 0, 2, 2)
+    assert (expected == actual).all()
+
+def test_add_windows_offset() -> 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]])
+
+    layer1 = RasterLayer(gdal_dataset_with_data((-0.02, 0.02), 0.02, data1))
+    layer2 = RasterLayer(gdal_dataset_with_data((-0.04, 0.04), 0.02, data2))
+
+    assert layer1.area != layer2.area
+    assert layer1.window != layer2.window
+
+    calc = layer1 + layer2
+
+    assert calc.area == layer2.area
+
+    result = RasterLayer.empty_raster_layer_like(calc)
+    calc.save(result)
+
+    expected = np.array([[10, 20, 30, 40], [50, 61, 72, 80], [90, 103, 114, 120], [130, 140, 150, 160]])
+    actual = result.read_array(0, 0, 4, 4)
+    assert (expected == actual).all()
+
+def test_multiply_windows_offset() -> 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]])
+
+    layer1 = RasterLayer(gdal_dataset_with_data((-0.02, 0.02), 0.02, data1))
+    layer2 = RasterLayer(gdal_dataset_with_data((-0.04, 0.04), 0.02, data2))
+
+    assert layer1.area != layer2.area
+    assert layer1.window != layer2.window
+
+    calc = layer1 * layer2
+
+    assert calc.area == layer1.area
+
+    result = RasterLayer.empty_raster_layer_like(calc)
+    calc.save(result)
+
+    expected = np.array([[60, 140], [300, 440]])
+    actual = result.read_array(0, 0, 2, 2)
+    assert (expected == actual).all()
+
+def test_add_windows_sum() -> 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]])
+
+    layer1 = RasterLayer(gdal_dataset_with_data((-0.02, 0.02), 0.02, data1))
+    layer2 = RasterLayer(gdal_dataset_with_data((-0.04, 0.04), 0.02, data2))
+
+    calc = layer1 + layer2
+    total = calc.sum()
+
+    expected = np.array([[10, 20, 30, 40], [50, 61, 72, 80], [90, 103, 114, 120], [130, 140, 150, 160]])
+    assert total == np.sum(expected)
+
+def test_multiply_windows_sum() -> 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]])
+
+    layer1 = RasterLayer(gdal_dataset_with_data((-0.02, 0.02), 0.02, data1))
+    layer2 = RasterLayer(gdal_dataset_with_data((-0.04, 0.04), 0.02, data2))
+
+    calc = layer1 * layer2
+    total = calc.sum()
+
+    expected = np.array([[60, 140], [300, 440]])
+    assert total == np.sum(expected)
+
+def test_constant_layer_result_rhs_add() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    const_layer = ConstantLayer(1.0)
+
+    calc = layer1 + const_layer
+
+    assert calc.area == layer1.area
+
+    result = RasterLayer.empty_raster_layer_like(calc)
+    calc.save(result)
+    actual = result.read_array(0, 0, 4, 2)
+
+    expected = 1.0 + data1
+
+    assert (expected == actual).all()
+
+def test_constant_layer_result_lhs_add() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    const_layer = ConstantLayer(1.0)
+    result = RasterLayer.empty_raster_layer_like(layer1)
+
+    intersection = RasterLayer.find_intersection([layer1, const_layer])
+    const_layer.set_window_for_intersection(intersection)
+    layer1.set_window_for_intersection(intersection)
+
+    calc = const_layer + layer1
+
+    assert calc.area == layer1.area
+
+    result = RasterLayer.empty_raster_layer_like(calc)
+    calc.save(result)
+    actual = result.read_array(0, 0, 4, 2)
+
+    expected = 1.0 + data1
+
+    assert (expected == actual).all()
+
+def test_constant_layer_result_rhs_multiply() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    const_layer = ConstantLayer(2.0)
+
+    calc = layer1 * const_layer
+
+    assert calc.area == layer1.area
+
+    result = RasterLayer.empty_raster_layer_like(calc)
+    calc.save(result)
+    actual = result.read_array(0, 0, 4, 2)
+
+    expected = data1 * 2.0
+
+    assert (expected == actual).all()
+
+def test_constant_layer_result_lhs_multiply() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    const_layer = ConstantLayer(2.0)
+    result = RasterLayer.empty_raster_layer_like(layer1)
+
+    intersection = RasterLayer.find_intersection([layer1, const_layer])
+    const_layer.set_window_for_intersection(intersection)
+    layer1.set_window_for_intersection(intersection)
+
+    calc = const_layer * layer1
+
+    assert calc.area == layer1.area
+
+    result = RasterLayer.empty_raster_layer_like(calc)
+    calc.save(result)
+    actual = result.read_array(0, 0, 4, 2)
+
+    expected = 2.0 * data1
+
+    assert (expected == actual).all()
+
+def test_vector_layers_add() -> None:
+    data1 = np.array([[1, 2], [3, 4]])
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 1.0, data1))
+
+    with tempfile.TemporaryDirectory() as tempdir:
+        path = os.path.join(tempdir, "test.gpkg")
+        areas = {
+            (Area(-10.0, 10.0, 0.0, 0.0), 42),
+            (Area(0.0, 0.0, 10, -10), 43)
+        }
+        make_vectors_with_mutlile_ids(areas, path)
+
+        burn_value = 2
+        layer2 = VectorLayer.layer_from_file(path, None, layer1.pixel_scale, layer1.projection, burn_value=burn_value)
+        layer2_total = layer2.sum()
+        assert layer2_total == ((layer2.window.xsize * layer2.window.ysize) / 2) * burn_value
+
+        calc = layer1 + layer2
+
+        assert calc.area == layer2.area
+
+        total = calc.sum()
+        assert total == layer2_total + np.sum(data1)
+
+def test_vector_layers_multiply() -> None:
+    data1 = np.array([[1, 2], [3, 4]])
+    layer1 = RasterLayer(gdal_dataset_with_data((-1.0, 1.0), 1.0, data1))
+
+    with tempfile.TemporaryDirectory() as tempdir:
+        path = os.path.join(tempdir, "test.gpkg")
+        areas = {
+            (Area(-10.0, 10.0, 0.0, 0.0), 42),
+            (Area(0.0, 0.0, 10, -10), 43)
+        }
+        make_vectors_with_mutlile_ids(areas, path)
+
+        burn_value = 2
+        layer2 = VectorLayer.layer_from_file(path, None, layer1.pixel_scale, layer1.projection, burn_value=burn_value)
+        layer2_total = layer2.sum()
+        assert layer2_total == ((layer2.window.xsize * layer2.window.ysize) / 2) * burn_value
+
+        calc = layer1 * layer2
+
+        assert calc.area == layer1.area
+
+        result = RasterLayer.empty_raster_layer_like(calc)
+        calc.save(result)
+        actual = result.read_array(0, 0, 2, 2)
+
+        expected = np.array([[2, 0], [0, 8]])
+        assert (expected == actual).all()
+
+@pytest.mark.skipif(yirgacheffe.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]])
+
+    with tempfile.TemporaryDirectory() as tempdir:
+        layer1_filename = os.path.join(tempdir, "layer1.tif")
+        layer1_dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data1, filename=layer1_filename)
+        layer1_dataset.Close()
+
+        layer2_filename = os.path.join(tempdir, "layer2.tif")
+        layer2_dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data2, filename=layer2_filename)
+        layer2_dataset.Close()
+
+        layer1 = RasterLayer.layer_from_file(layer1_filename)
+        layer2 = RasterLayer.layer_from_file(layer2_filename)
+
+        assert layer1.area != layer2.area
+        assert layer1.window != layer2.window
+
+        calc = layer1 + layer2
+
+        assert calc.area == layer2.area
+        assert calc.window == layer2.window
+
+        result = RasterLayer.empty_raster_layer_like(calc)
+        calc.parallel_save(result)
+
+        expected = np.array([[11, 22, 30, 40], [53, 64, 70, 80], [90, 100, 110, 120], [130, 140, 150, 160]])
+        actual = result.read_array(0, 0, 4, 4)
+        assert (expected == actual).all()

yirgacheffe-1.3.4/tests/test_constants.py

@@ -0,0 +1,32 @@
+
+import numpy as np
+import yirgacheffe
+from yirgacheffe.layers import RasterLayer, ConstantLayer
+from yirgacheffe.operators import DataType
+from yirgacheffe.window import Area, PixelScale
+
+def test_constant_save() -> None:
+    area = Area(left=-1.0, right=1.0, top=1.0, bottom=-1.0)
+    scale = PixelScale(0.1, -0.1)
+    with RasterLayer.empty_raster_layer(area, scale, DataType.Float32) as result:
+        with ConstantLayer(42.0) as c:
+            c.save(result)
+
+        expected = np.full((20, 20), 42.0)
+        actual = result.read_array(0, 0, 20, 20)
+
+        assert (expected == actual).all()
+
+def test_constant_parallel_save(monkeypatch) -> None:
+    area = Area(left=-1.0, right=1.0, top=1.0, bottom=-1.0)
+    scale = PixelScale(0.1, -0.1)
+    with RasterLayer.empty_raster_layer(area, scale, DataType.Float32) as result:
+        with ConstantLayer(42.0) as c:
+            with monkeypatch.context() as m:
+                m.setattr(yirgacheffe.constants, "YSTEP", 1)
+                c.parallel_save(result)
+
+        expected = np.full((20, 20), 42.0)
+        actual = result.read_array(0, 0, 20, 20)
+
+        assert (expected == actual).all()

yirgacheffe-1.3.4/tests/test_datatypes.py

@@ -0,0 +1,67 @@
+
+import numpy as np
+import pytest
+from osgeo import gdal
+
+from yirgacheffe.operators import DataType
+from yirgacheffe.backends import backend, BACKEND
+from yirgacheffe.layers import RasterLayer
+
+from tests.helpers import gdal_dataset_with_data
+
+@pytest.mark.parametrize("gtype", [
+    gdal.GDT_Int8,
+    gdal.GDT_Int16,
+    gdal.GDT_Int32,
+    gdal.GDT_Int64,
+    gdal.GDT_Byte,
+    gdal.GDT_UInt16,
+    gdal.GDT_UInt32,
+    gdal.GDT_UInt64,
+    gdal.GDT_Float32,
+])
+def test_round_trip(gtype) -> None:
+    ytype = DataType.of_gdal(gtype)
+    backend_type = backend.dtype_to_backed(ytype)
+    assert backend.backend_to_dtype(backend_type) == ytype
+
+@pytest.mark.parametrize("ytype", [
+    DataType.Int8,
+    DataType.Int16,
+    DataType.Int32,
+    DataType.Int64,
+    DataType.UInt8,
+    DataType.UInt16,
+    DataType.UInt32,
+    DataType.UInt64,
+    DataType.Float32,
+    DataType.Float64,
+])
+def test_round_trip_from_gdal(ytype) -> None:
+    gtype = ytype.to_gdal()
+    assert DataType.of_gdal(gtype) == ytype
+
+def test_round_trip_float64() -> None:
+    backend_type = backend.dtype_to_backed(DataType.Float64)
+    ytype = backend.backend_to_dtype(backend_type)
+    print(BACKEND, "sad")
+    match BACKEND:
+        case "NUMPY":
+            assert ytype == DataType.Float64
+        case "MLX":
+            assert ytype == DataType.Float32
+
+def test_float_to_int() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.5, 6.5, 7.5, 8.5]])
+
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+    # Note the float 32 here is to rule out that writing the result to the
+    # new dataset was what caused the truncation
+    result = RasterLayer.empty_raster_layer_like(layer1, datatype=DataType.Float32)
+
+    comp = layer1.astype(DataType.UInt8)
+    comp.save(result)
+
+    expected = backend.promote(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]))
+    actual = backend.demote_array(result.read_array(0, 0, 4, 2))
+    assert (expected == actual).all()

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_group.py

@@ -5,7 +5,7 @@ import tempfile
 import numpy as np
 import pytest
 
-from helpers import gdal_dataset_of_region, gdal_dataset_with_data, make_vectors_with_id, generate_child_tile
+from tests.helpers import gdal_dataset_of_region, gdal_dataset_with_data, make_vectors_with_id, generate_child_tile
 from yirgacheffe import WGS_84_PROJECTION
 from yirgacheffe.layers import GroupLayer, RasterLayer, TiledGroupLayer, VectorLayer
 from yirgacheffe.window import Area, PixelScale, Window
@@ -35,7 +35,7 @@ def test_valid_file_list():
             assert group.area == area
             assert group.window == Window(0, 0, 100, 100)
 
-def test_valid_file_list():
+def test_valid_file_list_from_dir():
     with tempfile.TemporaryDirectory() as tempdir:
         path = os.path.join(tempdir, "test.tif")
         area = Area(-10, 10, 10, -10)
@@ -221,8 +221,8 @@ def test_with_window_adjust(klass):
 
         # Test before we apply a window
         row = group.read_array(0, 0, 100, 1)[0]
-        for idx in range(len(row)):
-            assert row[idx] == math.ceil((idx + 1) / 10.0)
+        for idx, val in enumerate(row):
+            assert val == math.ceil((idx + 1) / 10.0)
 
         # Test also for manual offsets that we get expected result
         for idx in range(0, 10):

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_h3layer.py

@@ -6,9 +6,11 @@ from osgeo import gdal
 from yirgacheffe import WGS_84_PROJECTION
 from yirgacheffe.layers import RasterLayer, H3CellLayer
 from yirgacheffe.window import Area, PixelScale
-from yirgacheffe.operators import ShaderStyleOperation
 from yirgacheffe.backends import backend
 
+# work around of pylint
+demote_array = backend.demote_array
+
 
 @pytest.mark.parametrize(
     "cell_id,is_valid,expected_zoom",
@@ -135,10 +137,10 @@ def test_h3_layer_clipped(lat: float, lng: float) -> None:
 
         # whilst we're here, check that we do have an filled border (i.e., does window for
         # intersection do the right thing)
-        assert np.sum(backend.demote_array(h3_layer.read_array(0, 0, h3_layer.window.xsize, 5))) > 0.0
-        assert np.sum(backend.demote_array(h3_layer.read_array(0, h3_layer.window.ysize - 5, h3_layer.window.xsize, 5))) > 0.0
-        assert np.sum(backend.demote_array(h3_layer.read_array(0, 0, 5, h3_layer.window.ysize))) > 0.0
-        assert np.sum(backend.demote_array(h3_layer.read_array(h3_layer.window.xsize - 5, 0, 5, h3_layer.window.ysize))) > 0.0
+        assert np.sum(demote_array(h3_layer.read_array(0, 0, h3_layer.window.xsize, 5))) > 0.0
+        assert np.sum(demote_array(h3_layer.read_array(0, h3_layer.window.ysize - 5, h3_layer.window.xsize, 5))) > 0.0
+        assert np.sum(demote_array(h3_layer.read_array(0, 0, 5, h3_layer.window.ysize))) > 0.0
+        assert np.sum(demote_array(h3_layer.read_array(h3_layer.window.xsize - 5, 0, 5, h3_layer.window.ysize))) > 0.0
 
 @pytest.mark.parametrize(
     "lat,lng",
@@ -189,8 +191,8 @@ def test_h3_layer_wrapped_on_projection(lat: float, lng: float) -> None:
     assert expanded_area == area
 
     # whilst we're here, check that we do have an empty border (i.e., does window for union do the right thing)
-    assert np.sum(backend.demote_array(h3_layer.read_array(0, 0, h3_layer.window.xsize, 2))) == 0.0
-    assert np.sum(backend.demote_array(h3_layer.read_array(0, h3_layer.window.ysize - 2, h3_layer.window.xsize, 2))) == 0.0
+    assert np.sum(demote_array(h3_layer.read_array(0, 0, h3_layer.window.xsize, 2))) == 0.0
+    assert np.sum(demote_array(h3_layer.read_array(0, h3_layer.window.ysize - 2, h3_layer.window.xsize, 2))) == 0.0
 
 def test_h3_layer_overlapped():
     # This is based on a regression, where somehow I made tiles not tesselate properly

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_intersection.py

@@ -1,7 +1,7 @@
 import pytest
 from osgeo import gdal
 
-from helpers import gdal_dataset_of_region, gdal_empty_dataset_of_region
+from tests.helpers import gdal_dataset_of_region, gdal_empty_dataset_of_region
 from yirgacheffe.window import Area, PixelScale, Window
 from yirgacheffe.layers import RasterLayer, ConstantLayer
 from yirgacheffe.h3layer import H3CellLayer

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_multiband.py

@@ -4,7 +4,7 @@ import tempfile
 import numpy as np
 from osgeo import gdal
 
-from helpers import gdal_dataset_with_data
+from tests.helpers import gdal_dataset_with_data
 from yirgacheffe.layers import RasterLayer
 from yirgacheffe.window import Area, PixelScale
 
@@ -52,7 +52,7 @@ def test_stack_tifs_with_area_match() -> None:
         for layer in source_layers:
             layer.set_window_for_intersection(intersection)
 
-        # Note we're abusing that layer is the last of the source_layers here from the above loop
+        layer = source_layers[-1]
         assert layer.window.xsize == 100 - (bands - 1)
         assert layer.window.ysize == 100 - (bands - 1)
 

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_operators.py

@@ -5,13 +5,12 @@ import tempfile
 import numpy as np
 import pytest
 import torch
-from osgeo import gdal
 
-from helpers import gdal_dataset_with_data
 import yirgacheffe
 from yirgacheffe.layers import RasterLayer, ConstantLayer
 from yirgacheffe.operators import LayerOperation, DataType
 from yirgacheffe.backends import backend
+from tests.helpers import gdal_dataset_with_data
 
 def test_add_byte_layers() -> None:
     data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]).astype(np.uint8)
@@ -71,7 +70,7 @@ def test_add_byte_layers_with_callback(skip, expected_steps) -> None:
 
     comp = layer1 + layer2
     comp.ystep = skip
-    comp.save(result, callback=lambda x: callback_possitions.append(x))
+    comp.save(result, callback=callback_possitions.append)
 
     expected = data1 + data2
     actual = result.read_array(0, 0, 4, 2)

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_optimisation.py

@@ -5,7 +5,7 @@ import pytest
 
 from yirgacheffe import WGS_84_PROJECTION
 from yirgacheffe.h3layer import H3CellLayer
-from yirgacheffe.layers import PixelScale, ConstantLayer, RasterLayer
+from yirgacheffe.layers import PixelScale, RasterLayer
 from yirgacheffe.window import Area
 import yirgacheffe.operators as yo
 
@@ -14,7 +14,7 @@ class NaiveH3CellLayer(H3CellLayer):
     so the H3CellLayer has a bunch of tricks to try reduce the work done. This is a naive
     version that checks for every cell."""
 
-    def read_array(self, xoffset, yoffset, xsize, ysize):
+    def read_array(self, xoffset, yoffset, xsize, ysize): # pylint: disable=W0237
         res = np.zeros((ysize, xsize), dtype=float)
         start_x = self._active_area.left + (xoffset * self._pixel_scale.xstep)
         start_y = self._active_area.top + (yoffset * self._pixel_scale.ystep)

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_parallel_operators.py

@@ -6,8 +6,8 @@ import pytest
 import torch
 
 import yirgacheffe
-from helpers import gdal_dataset_with_data
-from yirgacheffe.layers import RasterLayer, ConstantLayer
+from tests.helpers import gdal_dataset_with_data
+from yirgacheffe.layers import RasterLayer
 from yirgacheffe.operators import LayerOperation
 
 # These tests are marked skip for MLX, because there seems to be a problem with
@@ -153,7 +153,7 @@ def test_parallel_with_different_skip(monkeypatch, skip, expected_steps) -> None
 
             comp = layer1 + layer2
             comp.ystep = skip
-            comp.parallel_save(result, callback=lambda x: callback_possitions.append(x))
+            comp.parallel_save(result, callback=callback_possitions.append)
 
             expected = data1 + data2
             actual = result.read_array(0, 0, 4, 4)

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_pickle.py

@@ -7,9 +7,10 @@ import tempfile
 import numpy as np
 import pytest
 
-from helpers import gdal_dataset_of_region, make_vectors_with_id
+from tests.helpers import gdal_dataset_of_region, make_vectors_with_id
 from yirgacheffe.window import Area, PixelScale, Window
-from yirgacheffe.layers import ConstantLayer, GroupLayer, RasterLayer, RescaledRasterLayer, UniformAreaLayer, VectorLayer
+from yirgacheffe.layers import ConstantLayer, GroupLayer, RasterLayer, RescaledRasterLayer, \
+    UniformAreaLayer, VectorLayer
 from yirgacheffe import WGS_84_PROJECTION
 from yirgacheffe.backends import backend
 

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_raster.py

@@ -5,7 +5,7 @@ import numpy as np
 import pytest
 from osgeo import gdal
 
-from helpers import gdal_dataset_of_region, gdal_multiband_dataset_with_data
+from tests.helpers import gdal_dataset_of_region, gdal_multiband_dataset_with_data
 from yirgacheffe.window import Area, PixelScale, Window
 from yirgacheffe.layers import RasterLayer, InvalidRasterBand
 from yirgacheffe.rounding import round_up_pixels
@@ -39,7 +39,7 @@ def test_make_basic_layer() -> None:
     assert close_called
 
 def test_make_basic_layer_old_name() -> None:
-    from yirgacheffe.layers import Layer
+    from yirgacheffe.layers import Layer # pylint: disable=C0415
 
     area = Area(-10, 10, 10, -10)
     with Layer(gdal_dataset_of_region(area, 0.02)) as layer:
@@ -104,7 +104,7 @@ def test_empty_layer_from_raster():
     assert empty.window == source.window
     assert empty.datatype == source.datatype
     assert empty.geo_transform == source.geo_transform
-    assert empty._dataset.GetRasterBand(1).GetNoDataValue() == None
+    assert empty._dataset.GetRasterBand(1).GetNoDataValue() is None
 
 @pytest.mark.parametrize("nodata", [0, 0.0, 2, 2.0])
 def test_empty_layer_from_raster_with_no_data_value(nodata):

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_rescaling.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from helpers import gdal_dataset_of_region, gdal_dataset_with_data
+from tests.helpers import gdal_dataset_of_region, gdal_dataset_with_data
 from yirgacheffe.layers import RasterLayer, RescaledRasterLayer
 from yirgacheffe.window import Area, PixelScale, Window
 

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_save_with_window.py

@@ -1,6 +1,6 @@
 import numpy
 
-from helpers import gdal_dataset_with_data
+from tests.helpers import gdal_dataset_with_data
 from yirgacheffe.layers import RasterLayer
 
 def test_add_byte_layers_with_union() -> None:

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_sum_with_window.py

@@ -1,6 +1,6 @@
 import numpy
 
-from helpers import gdal_dataset_with_data
+from tests.helpers import gdal_dataset_with_data
 from yirgacheffe.layers import RasterLayer
 
 

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_uniform_area_layer.py

@@ -4,7 +4,7 @@ from math import ceil, floor
 
 import pytest
 
-from helpers import gdal_dataset_of_region
+from tests.helpers import gdal_dataset_of_region
 from yirgacheffe.layers import UniformAreaLayer
 from yirgacheffe.window import Area, Window
 

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_union.py

@@ -1,6 +1,6 @@
 import pytest
 
-from helpers import gdal_dataset_of_region
+from tests.helpers import gdal_dataset_of_region
 from yirgacheffe.window import Area, Window
 from yirgacheffe.layers import ConstantLayer, RasterLayer
 

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/tests/test_vectors.py

@@ -2,9 +2,8 @@ import os
 import tempfile
 
 import pytest
-from osgeo import gdal
 
-from helpers import make_vectors_with_mutlile_ids, make_vectors_with_id, make_vectors_with_empty_feature
+from tests.helpers import make_vectors_with_mutlile_ids, make_vectors_with_id, make_vectors_with_empty_feature
 from yirgacheffe import WGS_84_PROJECTION
 from yirgacheffe.layers import RasterLayer, RasteredVectorLayer, VectorLayer, VectorRangeLayer, DynamicVectorRangeLayer
 from yirgacheffe.window import Area, PixelScale, Window
@@ -111,7 +110,12 @@ def test_empty_layer_from_vector():
         area = Area(left=44.00253688814017, top=-12.440948032828079, right=50.483612168477286, bottom=-25.1535466075739)
         make_vectors_with_id(42, {area}, path)
 
-        source = VectorLayer.layer_from_file(path, "id_no = 42", PixelScale(xstep=0.00026949458523585647, ystep=-0.00026949458523585647), WGS_84_PROJECTION)
+        source = VectorLayer.layer_from_file(
+            path,
+            "id_no = 42",
+            PixelScale(xstep=0.00026949458523585647, ystep=-0.00026949458523585647),
+            WGS_84_PROJECTION
+        )
 
         empty = RasterLayer.empty_raster_layer_like(source)
         assert empty.pixel_scale == source.pixel_scale
@@ -422,7 +426,13 @@ def test_anchor_offsets(anchor, area, expected):
         path = os.path.join(tempdir, "test.gpkg")
         make_vectors_with_id(42, {area}, path)
 
-        source = VectorLayer.layer_from_file(path, "id_no = 42", PixelScale(1.0, -1.0), WGS_84_PROJECTION, anchor=anchor)
+        source = VectorLayer.layer_from_file(
+            path,
+            "id_no = 42",
+            PixelScale(1.0, -1.0),
+            WGS_84_PROJECTION,
+            anchor=anchor
+        )
 
         final_area = source.area
         assert final_area == expected

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/yirgacheffe/operators.py

@@ -521,9 +521,17 @@ class LayerOperation(LayerMathMixin):
         except AttributeError as exc:
             raise ValueError("Layer must be a raster backed layer") from exc
 
-        computation_window = self.window
         destination_window = destination_layer.window
 
+        # If we're calculating purely from a constant layer, then we don't have a window or area
+        # so we should use the destination raster details.
+        try:
+            computation_window = self.window
+            computation_area = self.area
+        except AttributeError:
+            computation_window = destination_window
+            computation_area = destination_layer.area
+
         if (computation_window.xsize != destination_window.xsize) \
                 or (computation_window.ysize != destination_window.ysize):
             raise ValueError("Destination raster window size does not match input raster window size.")
@@ -536,7 +544,7 @@ class LayerOperation(LayerMathMixin):
             step=self.ystep
             if yoffset+step > computation_window.ysize:
                 step = computation_window.ysize - yoffset
-            chunk = self._eval(self.area, yoffset, step, computation_window)
+            chunk = self._eval(computation_area, yoffset, step, computation_window)
             if isinstance(chunk, (float, int)):
                 chunk = backend.full((step, destination_window.xsize), chunk)
             band.WriteArray(
@@ -599,7 +607,18 @@ class LayerOperation(LayerMathMixin):
 
     def _parallel_save(self, destination_layer, and_sum=False, callback=None, parallelism=None, band=1):
         assert (destination_layer is not None) or and_sum
-        computation_window = self.window
+        try:
+            computation_window = self.window
+        except AttributeError:
+            # This is most likely because the calculation is on a constant layer (or combination of only constant
+            # layers) and there's no real benefit to parallel saving then, so to keep this code from getting yet
+            # more complicated just fall back to the single threaded path
+            if destination_layer:
+                return self.save(destination_layer, and_sum, callback, band)
+            elif and_sum:
+                return self.sum()
+            else:
+                assert False
 
         worker_count = parallelism or multiprocessing.cpu_count()
         work_blocks = len(range(0, computation_window.ysize, self.ystep))

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4/yirgacheffe.egg-info}/PKG-INFO

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

{yirgacheffe-1.3.3 → yirgacheffe-1.3.4}/yirgacheffe.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ pyproject.toml
 tests/test_area.py
 tests/test_auto_windowing.py
 tests/test_base.py
+tests/test_constants.py
 tests/test_datatypes.py
 tests/test_group.py
 tests/test_h3layer.py

yirgacheffe-1.3.3/tests/test_area.py

@@ -1,21 +0,0 @@
-import pytest
-
-# I've no idea why pylint dislikes this particular import but accepts
-# other entries in the module.
-from yirgacheffe.window import Area # pylint: disable=E0401, E0611
-
-@pytest.mark.parametrize(
-	"lhs,rhs,is_equal,overlaps",
-	[
-		# Obvious equality
-		(Area(-10.0, 10.0, 10.0, -10.0), Area(-10.0, 10.0, 10.0, -10.0), True,  True),
-		(Area(-9.0, 9.0, 9.0, -9.0),     Area(-10.0, 10.0, 10.0, -10.0), False, True), # subset
-		(Area(-9.0, 9.0, -1.0, 1.0),     Area(1.0, -1.0, 9.0, -9.0),     False, False),
-		(Area(-10.0, 10.0, 1.0, -10.0),  Area(-1.0, 10.0, 10.0, -10.0),  False, True),
-	]
-)
-def test_area_operators(lhs: Area, rhs: Area, is_equal: bool, overlaps: bool) -> None:
-	assert (lhs == rhs) == is_equal
-	assert (lhs != rhs) == (not is_equal)
-	assert (lhs.overlaps(rhs)) == overlaps
-	assert (rhs.overlaps(lhs)) == overlaps

yirgacheffe-1.3.3/tests/test_auto_windowing.py

@@ -1,284 +0,0 @@
-import os
-import tempfile
-
-import numpy as np
-import pytest
-
-import yirgacheffe
-from helpers import gdal_dataset_with_data, make_vectors_with_mutlile_ids
-from yirgacheffe.layers import ConstantLayer, RasterLayer, VectorLayer, area
-from yirgacheffe.window import Area
-
-def test_add_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]])
-
-	layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
-	layer2 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2))
-
-	assert layer1.area != layer2.area
-	assert layer1.window != layer2.window
-
-	calc = layer1 + layer2
-
-	assert calc.area == layer2.area
-	assert calc.window == layer2.window
-
-	result = RasterLayer.empty_raster_layer_like(calc)
-	calc.save(result)
-
-	expected = np.array([[11, 22, 30, 40], [53, 64, 70, 80], [90, 100, 110, 120], [130, 140, 150, 160]])
-	actual = result.read_array(0, 0, 4, 4)
-	assert (expected == actual).all()
-
-def test_multiply_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]])
-
-	layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
-	layer2 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2))
-
-	assert layer1.area != layer2.area
-	assert layer1.window != layer2.window
-
-	calc = layer1 * layer2
-
-	assert calc.area == layer1.area
-	assert calc.window == layer1.window
-
-	result = RasterLayer.empty_raster_layer_like(calc)
-	calc.save(result)
-
-	expected = np.array([[10, 40], [150, 240]])
-	actual = result.read_array(0, 0, 2, 2)
-	assert (expected == actual).all()
-
-def test_add_windows_offset() -> 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]])
-
-	layer1 = RasterLayer(gdal_dataset_with_data((-0.02, 0.02), 0.02, data1))
-	layer2 = RasterLayer(gdal_dataset_with_data((-0.04, 0.04), 0.02, data2))
-
-	assert layer1.area != layer2.area
-	assert layer1.window != layer2.window
-
-	calc = layer1 + layer2
-
-	assert calc.area == layer2.area
-
-	result = RasterLayer.empty_raster_layer_like(calc)
-	calc.save(result)
-
-	expected = np.array([[10, 20, 30, 40], [50, 61, 72, 80], [90, 103, 114, 120], [130, 140, 150, 160]])
-	actual = result.read_array(0, 0, 4, 4)
-	assert (expected == actual).all()
-
-def test_multiply_windows_offset() -> 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]])
-
-	layer1 = RasterLayer(gdal_dataset_with_data((-0.02, 0.02), 0.02, data1))
-	layer2 = RasterLayer(gdal_dataset_with_data((-0.04, 0.04), 0.02, data2))
-
-	assert layer1.area != layer2.area
-	assert layer1.window != layer2.window
-
-	calc = layer1 * layer2
-
-	assert calc.area == layer1.area
-
-	result = RasterLayer.empty_raster_layer_like(calc)
-	calc.save(result)
-
-	expected = np.array([[60, 140], [300, 440]])
-	actual = result.read_array(0, 0, 2, 2)
-	assert (expected == actual).all()
-
-def test_add_windows_sum() -> 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]])
-
-	layer1 = RasterLayer(gdal_dataset_with_data((-0.02, 0.02), 0.02, data1))
-	layer2 = RasterLayer(gdal_dataset_with_data((-0.04, 0.04), 0.02, data2))
-
-	calc = layer1 + layer2
-	total = calc.sum()
-
-	expected = np.array([[10, 20, 30, 40], [50, 61, 72, 80], [90, 103, 114, 120], [130, 140, 150, 160]])
-	assert total == np.sum(expected)
-
-def test_multiply_windows_sum() -> 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]])
-
-	layer1 = RasterLayer(gdal_dataset_with_data((-0.02, 0.02), 0.02, data1))
-	layer2 = RasterLayer(gdal_dataset_with_data((-0.04, 0.04), 0.02, data2))
-
-	calc = layer1 * layer2
-	total = calc.sum()
-
-	expected = np.array([[60, 140], [300, 440]])
-	assert total == np.sum(expected)
-
-def test_constant_layer_result_rhs_add() -> None:
-	data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
-	layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
-	const_layer = ConstantLayer(1.0)
-
-	calc = layer1 + const_layer
-
-	assert calc.area == layer1.area
-
-	result = RasterLayer.empty_raster_layer_like(calc)
-	calc.save(result)
-	actual = result.read_array(0, 0, 4, 2)
-
-	expected = 1.0 + data1
-
-	assert (expected == actual).all()
-
-def test_constant_layer_result_lhs_add() -> None:
-	data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
-	layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
-	const_layer = ConstantLayer(1.0)
-	result = RasterLayer.empty_raster_layer_like(layer1)
-
-	intersection = RasterLayer.find_intersection([layer1, const_layer])
-	const_layer.set_window_for_intersection(intersection)
-	layer1.set_window_for_intersection(intersection)
-
-	calc = const_layer + layer1
-
-	assert calc.area == layer1.area
-
-	result = RasterLayer.empty_raster_layer_like(calc)
-	calc.save(result)
-	actual = result.read_array(0, 0, 4, 2)
-
-	expected = 1.0 + data1
-
-	assert (expected == actual).all()
-
-def test_constant_layer_result_rhs_multiply() -> None:
-	data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
-	layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
-	const_layer = ConstantLayer(2.0)
-
-	calc = layer1 * const_layer
-
-	assert calc.area == layer1.area
-
-	result = RasterLayer.empty_raster_layer_like(calc)
-	calc.save(result)
-	actual = result.read_array(0, 0, 4, 2)
-
-	expected = data1 * 2.0
-
-	assert (expected == actual).all()
-
-def test_constant_layer_result_lhs_multiply() -> None:
-	data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
-	layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
-	const_layer = ConstantLayer(2.0)
-	result = RasterLayer.empty_raster_layer_like(layer1)
-
-	intersection = RasterLayer.find_intersection([layer1, const_layer])
-	const_layer.set_window_for_intersection(intersection)
-	layer1.set_window_for_intersection(intersection)
-
-	calc = const_layer * layer1
-
-	assert calc.area == layer1.area
-
-	result = RasterLayer.empty_raster_layer_like(calc)
-	calc.save(result)
-	actual = result.read_array(0, 0, 4, 2)
-
-	expected = 2.0 * data1
-
-	assert (expected == actual).all()
-
-def test_vector_layers_add() -> None:
-	data1 = np.array([[1, 2], [3, 4]])
-	layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 1.0, data1))
-
-	with tempfile.TemporaryDirectory() as tempdir:
-		path = os.path.join(tempdir, "test.gpkg")
-		areas = {
-			(Area(-10.0, 10.0, 0.0, 0.0), 42),
-			(Area(0.0, 0.0, 10, -10), 43)
-		}
-		make_vectors_with_mutlile_ids(areas, path)
-
-		burn_value = 2
-		layer2 = VectorLayer.layer_from_file(path, None, layer1.pixel_scale, layer1.projection, burn_value=burn_value)
-		layer2_total = layer2.sum()
-		assert layer2_total == ((layer2.window.xsize * layer2.window.ysize) / 2) * burn_value
-
-		calc = layer1 + layer2
-
-		assert calc.area == layer2.area
-
-		total = calc.sum()
-		assert total == layer2_total + np.sum(data1)
-
-def test_vector_layers_multiply() -> None:
-	data1 = np.array([[1, 2], [3, 4]])
-	layer1 = RasterLayer(gdal_dataset_with_data((-1.0, 1.0), 1.0, data1))
-
-	with tempfile.TemporaryDirectory() as tempdir:
-		path = os.path.join(tempdir, "test.gpkg")
-		areas = {
-			(Area(-10.0, 10.0, 0.0, 0.0), 42),
-			(Area(0.0, 0.0, 10, -10), 43)
-		}
-		make_vectors_with_mutlile_ids(areas, path)
-
-		burn_value = 2
-		layer2 = VectorLayer.layer_from_file(path, None, layer1.pixel_scale, layer1.projection, burn_value=burn_value)
-		layer2_total = layer2.sum()
-		assert layer2_total == ((layer2.window.xsize * layer2.window.ysize) / 2) * burn_value
-
-		calc = layer1 * layer2
-
-		assert calc.area == layer1.area
-
-		result = RasterLayer.empty_raster_layer_like(calc)
-		calc.save(result)
-		actual = result.read_array(0, 0, 2, 2)
-
-		expected = np.array([[2, 0], [0, 8]])
-		assert (expected == actual).all()
-
-@pytest.mark.skipif(yirgacheffe.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]])
-
-	with tempfile.TemporaryDirectory() as tempdir:
-		layer1_filename = os.path.join(tempdir, "layer1.tif")
-		layer1_dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data1, filename=layer1_filename)
-		layer1_dataset.Close()
-
-		layer2_filename = os.path.join(tempdir, "layer2.tif")
-		layer2_dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data2, filename=layer2_filename)
-		layer2_dataset.Close()
-
-		layer1 = RasterLayer.layer_from_file(layer1_filename)
-		layer2 = RasterLayer.layer_from_file(layer2_filename)
-
-		assert layer1.area != layer2.area
-		assert layer1.window != layer2.window
-
-		calc = layer1 + layer2
-
-		assert calc.area == layer2.area
-		assert calc.window == layer2.window
-
-		result = RasterLayer.empty_raster_layer_like(calc)
-		calc.parallel_save(result)
-
-		expected = np.array([[11, 22, 30, 40], [53, 64, 70, 80], [90, 100, 110, 120], [130, 140, 150, 160]])
-		actual = result.read_array(0, 0, 4, 4)
-		assert (expected == actual).all()

yirgacheffe-1.3.3/tests/test_datatypes.py

@@ -1,67 +0,0 @@
-
-import numpy as np
-import pytest
-from osgeo import gdal
-
-from yirgacheffe.operators import DataType
-from yirgacheffe.backends import backend, BACKEND
-from yirgacheffe.layers import RasterLayer
-
-from helpers import gdal_dataset_with_data
-
-@pytest.mark.parametrize("gtype", [
-	gdal.GDT_Int8,
-	gdal.GDT_Int16,
-	gdal.GDT_Int32,
-	gdal.GDT_Int64,
-	gdal.GDT_Byte,
-	gdal.GDT_UInt16,
-	gdal.GDT_UInt32,
-	gdal.GDT_UInt64,
-	gdal.GDT_Float32,
-])
-def test_round_trip(gtype) -> None:
-	ytype = DataType.of_gdal(gtype)
-	backend_type = backend.dtype_to_backed(ytype)
-	assert backend.backend_to_dtype(backend_type) == ytype
-
-@pytest.mark.parametrize("ytype", [
-	DataType.Int8,
-	DataType.Int16,
-	DataType.Int32,
-	DataType.Int64,
-	DataType.UInt8,
-	DataType.UInt16,
-	DataType.UInt32,
-	DataType.UInt64,
-	DataType.Float32,
-	DataType.Float64,
-])
-def test_round_trip_from_gdal(ytype) -> None:
-	gtype = ytype.to_gdal()
-	assert DataType.of_gdal(gtype) == ytype
-
-def test_round_trip_float64() -> None:
-	backend_type = backend.dtype_to_backed(DataType.Float64)
-	ytype = backend.backend_to_dtype(backend_type)
-	print(BACKEND, "sad")
-	match BACKEND:
-		case "NUMPY":
-			assert ytype == DataType.Float64
-		case "MLX":
-			assert ytype == DataType.Float32
-
-def test_float_to_int() -> None:
-	data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.5, 6.5, 7.5, 8.5]])
-
-	layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
-	# Note the float 32 here is to rule out that writing the result to the
-	# new dataset was what caused the truncation
-	result = RasterLayer.empty_raster_layer_like(layer1, datatype=DataType.Float32)
-
-	comp = layer1.astype(DataType.UInt8)
-	comp.save(result)
-
-	expected = backend.promote(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]))
-	actual = backend.demote_array(result.read_array(0, 0, 4, 2))
-	assert (expected == actual).all()