yirgacheffe 1.3.3__tar.gz → 1.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.3.3
+Version: 1.4.0
 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.4.0}/pyproject.toml

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

yirgacheffe-1.4.0/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.4.0/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.4.0/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.4.0/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.4.0}/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.4.0}/tests/test_h3layer.py

@@ -6,8 +6,10 @@ 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
+from yirgacheffe._backends import backend
+
+# work around of pylint
+demote_array = backend.demote_array
 
 
 @pytest.mark.parametrize(
@@ -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.4.0}/tests/test_intersection.py

@@ -1,10 +1,9 @@
 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
+from yirgacheffe.layers import RasterLayer, ConstantLayer, H3CellLayer
 from yirgacheffe import WGS_84_PROJECTION
 
 

{yirgacheffe-1.3.3 → yirgacheffe-1.4.0}/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.4.0}/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 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)
@@ -585,7 +584,7 @@ def test_direct_layer_save_and_sum() -> None:
     assert (data1 == actual_data).all()
     assert expected_sum == actual_sum
 
-@pytest.mark.skipif(yirgacheffe.backends.BACKEND != "NUMPY", reason="Only applies for numpy")
+@pytest.mark.skipif(yirgacheffe._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
 def test_add_to_float_layer_by_np_array() -> 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))
@@ -620,7 +619,7 @@ def test_write_mulitband_raster() -> None:
 
             assert (expected == actual).all()
 
-@pytest.mark.skipif(yirgacheffe.backends.BACKEND != "NUMPY", reason="Only applies for numpy")
+@pytest.mark.skipif(yirgacheffe._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
 def test_save_and_sum_float32(monkeypatch) -> None:
     random.seed(42)
     data = []
@@ -644,7 +643,7 @@ def test_save_and_sum_float32(monkeypatch) -> None:
                 actual = layer1.save(store, and_sum=True)
             assert expected == actual
 
-@pytest.mark.skipif(yirgacheffe.backends.BACKEND != "NUMPY", reason="Only applies for numpy")
+@pytest.mark.skipif(yirgacheffe._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
 def test_parallel_save_and_sum_float32(monkeypatch) -> None:
     random.seed(42)
     data = []
@@ -672,7 +671,7 @@ def test_parallel_save_and_sum_float32(monkeypatch) -> None:
                     actual = layer1.parallel_save(store, and_sum=True)
                 assert expected == actual
 
-@pytest.mark.skipif(yirgacheffe.backends.BACKEND != "NUMPY", reason="Only applies for numpy")
+@pytest.mark.skipif(yirgacheffe._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
 def test_sum_float32(monkeypatch) -> None:
     random.seed(42)
     data = []

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

@@ -4,8 +4,7 @@ import numpy as np
 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, H3CellLayer
 from yirgacheffe.window import Area
 import yirgacheffe.operators as yo
 
@@ -14,7 +13,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)