yirgacheffe 1.8.0__tar.gz → 1.8.1__tar.gz

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

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

{yirgacheffe-1.8.0 → yirgacheffe-1.8.1}/pyproject.toml

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

{yirgacheffe-1.8.0 → yirgacheffe-1.8.1}/tests/test_area.py

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

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

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

{yirgacheffe-1.8.0 → yirgacheffe-1.8.1}/tests/test_intersection.py

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

{yirgacheffe-1.8.0 → yirgacheffe-1.8.1}/tests/test_union.py

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

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

@@ -15,5 +15,6 @@ except ModuleNotFoundError:
 from ._core import read_raster, read_rasters, read_shape, read_shape_like, constant, read_narrow_raster
 from .constants import WGS_84_PROJECTION
 from .window import Area, MapProjection, Window
+from ._backends.enumeration import dtype as DataType
 
 gdal.UseExceptions()

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

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

{yirgacheffe-1.8.0 → yirgacheffe-1.8.1}/yirgacheffe/layers/vectors.py

@@ -333,36 +333,36 @@ 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)
 

{yirgacheffe-1.8.0 → yirgacheffe-1.8.1}/yirgacheffe/window.py

@@ -72,7 +72,9 @@ class Area:
     def __hash__(self):
         return (self.left, self.top, self.right, self.bottom).__hash__()
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Area):
+            return False
         return math.isclose(self.left, other.left, abs_tol=1e-09) and \
             math.isclose(self.right, other.right, abs_tol=1e-09) and \
             math.isclose(self.top, other.top, abs_tol=1e-09) and \

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

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