yirgacheffe 1.8.1__tar.gz → 1.10.3__tar.gz

yirgacheffe-1.10.3/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: yirgacheffe
+Version: 1.10.3
+Summary: Abstraction of gdal datasets for doing basic math operations
+Author-email: Michael Dales <mwd24@cam.ac.uk>
+License-Expression: ISC
+Project-URL: Homepage, https://yirgacheffe.org/
+Project-URL: Repository, https://github.com/quantifyearth/yirgacheffe.git
+Project-URL: Issues, https://github.com/quantifyearth/yirgacheffe/issues
+Project-URL: Changelog, https://yirgacheffe.org/latest/changelog/
+Keywords: gdal,gis,geospatial,declarative
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3.0,>=1.24
+Requires-Dist: gdal[numpy]<4.0,>=3.8
+Requires-Dist: scikit-image<1.0,>=0.20
+Requires-Dist: torch
+Requires-Dist: dill
+Requires-Dist: deprecation
+Requires-Dist: tomli
+Requires-Dist: h3
+Requires-Dist: pyproj
+Provides-Extra: mlx
+Requires-Dist: mlx; extra == "mlx"
+Provides-Extra: matplotlib
+Requires-Dist: matplotlib; extra == "matplotlib"
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: mkdocstrings-python; extra == "dev"
+Requires-Dist: mike; extra == "dev"
+Requires-Dist: mkdocs-gen-files; extra == "dev"
+Dynamic: license-file
+
+# Yirgacheffe: a declarative geospatial library for Python to make data-science with maps easier
+
+[![CI](https://github.com/quantifyearth/yirgacheffe/actions/workflows/pull-request.yml/badge.svg?branch=main)](https://github.com/quantifyearth/yirgacheffe/actions)
+[![Documentation](https://img.shields.io/badge/docs-yirgacheffe.org-blue)](https://yirgacheffe.org)
+[![PyPI version](https://img.shields.io/pypi/v/yirgacheffe)](https://pypi.org/project/yirgacheffe/)
+
+
+## Overview
+
+Yirgacheffe is a declarative geospatial library, allowing you to operate on both raster and polygon geospatial datasets without having to do all the tedious book keeping around layer alignment or dealing with hardware concerns around memory or parallelism. you can load into memory safely.
+
+Example common use-cases:
+
+* Do the datasets overlap? Yirgacheffe will let you define either the intersection or the union of a set of different datasets, scaling up or down the area as required.
+* Rasterisation of vector layers: if you have a vector dataset then you can add that to your computation and yirgaceffe will rasterize it on demand, so you never need to store more data in memory than necessary.
+* Do the raster layers get big and take up large amounts of memory? Yirgacheffe will let you do simple numerical operations with layers directly and then worry about the memory management behind the scenes for you.
+* Parallelisation of operations over many CPU cores.
+* Built in support for optionally using GPUs via [MLX](https://ml-explore.github.io/mlx/build/html/index.html) support.
+
+## Installation
+
+Yirgacheffe is available via pypi, so can be installed with pip for example:
+
+```SystemShell
+$ pip install yirgacheffe
+```
+
+## Documentation
+
+The documentation can be found on [yirgacheffe.org](https://yirgacheffe.org/)
+
+## Simple examples:
+
+Here is how to do cloud removal from [Sentinel-2 data](https://browser.dataspace.copernicus.eu/?zoom=14&lat=6.15468&lng=38.20581&themeId=DEFAULT-THEME&visualizationUrl=U2FsdGVkX1944lrmeTJcaSsnoxNMp4oucN1AjklGUANHd2cRZWyXnepHvzpaOWzMhH8SrWQo%2BqrOvOnu6f9FeCMrS%2FDZmvjzID%2FoE1tbOCEHK8ohPXjFqYojeR9%2B82ri&datasetId=S2_L2A_CDAS&fromTime=2025-09-09T00%3A00%3A00.000Z&toTime=2025-09-09T23%3A59%3A59.999Z&layerId=1_TRUE_COLOR&demSource3D=%22MAPZEN%22&cloudCoverage=30&dateMode=SINGLE), using the [Scene Classification Layer](https://custom-scripts.sentinel-hub.com/custom-scripts/sentinel-2/scene-classification/) data:
+
+```python
+import yirgaceffe as yg
+
+with (
+  yg.read_raster("T37NCG_20250909T073609_B06_20m.jp2") as vre2,
+  yg.read_raster("T37NCG_20250909T073609_SCL_20m.jp2") as scl,
+):
+  is_cloud = (scl == 8) | (scl == 9) | (scl == 10)  # various cloud types
+  is_shadow = (scl == 3)
+  is_bad = is_cloud | is_shadow
+
+  masked_vre2 = yg.where(is_bad, float("nan"), vre2)
+  masked_vre2.to_geotiff("vre2_cleaned.tif")
+```
+
+or a species' [Area of Habitat](https://www.sciencedirect.com/science/article/pii/S0169534719301892) calculation:
+
+```python
+import yirgaceffe as yg
+
+with (
+    yg.read_raster("habitats.tif") as habitat_map,
+    yg.read_raster('elevation.tif') as elevation_map,
+    yg.read_shape('species123.geojson') as range_map,
+):
+    refined_habitat = habitat_map.isin([...species habitat codes...])
+    refined_elevation = (elevation_map >= species_min) & (elevation_map <= species_max)
+    aoh = refined_habitat * refined_elevation * range_polygon * area_per_pixel_map
+    print(f'Area of habitat: {aoh.sum()}')
+```
+
+## Citation
+
+If you use Yirgacheffe in your research, please cite our paper:
+
+> Michael Winston Dales, Alison Eyres, Patrick Ferris, Francesca A. Ridley, Simon Tarr, and Anil Madhavapeddy. 2025. Yirgacheffe: A Declarative Approach to Geospatial Data. In *Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming for the Planet* (PROPL '25). Association for Computing Machinery, New York, NY, USA, 47–54. https://doi.org/10.1145/3759536.3763806
+
+<details>
+<summary>BibTeX</summary>
+
+```bibtex
+@inproceedings{10.1145/3759536.3763806,
+  author = {Dales, Michael Winston and Eyres, Alison and Ferris, Patrick and Ridley, Francesca A. and Tarr, Simon and Madhavapeddy, Anil},
+  title = {Yirgacheffe: A Declarative Approach to Geospatial Data},
+  year = {2025},
+  isbn = {9798400721618},
+  publisher = {Association for Computing Machinery},
+  address = {New York, NY, USA},
+  url = {https://doi.org/10.1145/3759536.3763806},
+  doi = {10.1145/3759536.3763806},
+  abstract = {We present Yirgacheffe, a declarative geospatial library that allows spatial algorithms to be implemented concisely, supports parallel execution, and avoids common errors by automatically handling data (large geospatial rasters) and resources (cores, memory, GPUs). Our primary user domain comprises ecologists, where a typical problem involves cleaning messy occurrence data, overlaying it over tiled rasters, combining layers, and deriving actionable insights from the results. We describe the successes of this approach towards driving key pipelines related to global biodiversity and describe the capability gaps that remain, hoping to motivate more research into geospatial domain-specific languages.},
+  booktitle = {Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming for the Planet},
+  pages = {47–54},
+  numpages = {8},
+  keywords = {Biodiversity, Declarative, Geospatial, Python},
+  location = {Singapore, Singapore},
+  series = {PROPL '25}
+}
+```
+
+</details>
+
+## Thanks
+
+Thanks to discussion and feedback from my colleagues, particularly Alison Eyres, Patrick Ferris, Amelia Holcomb, and Anil Madhavapeddy.
+
+Inspired by the work of Daniele Baisero in his AoH library.

yirgacheffe-1.10.3/README.md

@@ -0,0 +1,102 @@
+# Yirgacheffe: a declarative geospatial library for Python to make data-science with maps easier
+
+[![CI](https://github.com/quantifyearth/yirgacheffe/actions/workflows/pull-request.yml/badge.svg?branch=main)](https://github.com/quantifyearth/yirgacheffe/actions)
+[![Documentation](https://img.shields.io/badge/docs-yirgacheffe.org-blue)](https://yirgacheffe.org)
+[![PyPI version](https://img.shields.io/pypi/v/yirgacheffe)](https://pypi.org/project/yirgacheffe/)
+
+
+## Overview
+
+Yirgacheffe is a declarative geospatial library, allowing you to operate on both raster and polygon geospatial datasets without having to do all the tedious book keeping around layer alignment or dealing with hardware concerns around memory or parallelism. you can load into memory safely.
+
+Example common use-cases:
+
+* Do the datasets overlap? Yirgacheffe will let you define either the intersection or the union of a set of different datasets, scaling up or down the area as required.
+* Rasterisation of vector layers: if you have a vector dataset then you can add that to your computation and yirgaceffe will rasterize it on demand, so you never need to store more data in memory than necessary.
+* Do the raster layers get big and take up large amounts of memory? Yirgacheffe will let you do simple numerical operations with layers directly and then worry about the memory management behind the scenes for you.
+* Parallelisation of operations over many CPU cores.
+* Built in support for optionally using GPUs via [MLX](https://ml-explore.github.io/mlx/build/html/index.html) support.
+
+## Installation
+
+Yirgacheffe is available via pypi, so can be installed with pip for example:
+
+```SystemShell
+$ pip install yirgacheffe
+```
+
+## Documentation
+
+The documentation can be found on [yirgacheffe.org](https://yirgacheffe.org/)
+
+## Simple examples:
+
+Here is how to do cloud removal from [Sentinel-2 data](https://browser.dataspace.copernicus.eu/?zoom=14&lat=6.15468&lng=38.20581&themeId=DEFAULT-THEME&visualizationUrl=U2FsdGVkX1944lrmeTJcaSsnoxNMp4oucN1AjklGUANHd2cRZWyXnepHvzpaOWzMhH8SrWQo%2BqrOvOnu6f9FeCMrS%2FDZmvjzID%2FoE1tbOCEHK8ohPXjFqYojeR9%2B82ri&datasetId=S2_L2A_CDAS&fromTime=2025-09-09T00%3A00%3A00.000Z&toTime=2025-09-09T23%3A59%3A59.999Z&layerId=1_TRUE_COLOR&demSource3D=%22MAPZEN%22&cloudCoverage=30&dateMode=SINGLE), using the [Scene Classification Layer](https://custom-scripts.sentinel-hub.com/custom-scripts/sentinel-2/scene-classification/) data:
+
+```python
+import yirgaceffe as yg
+
+with (
+  yg.read_raster("T37NCG_20250909T073609_B06_20m.jp2") as vre2,
+  yg.read_raster("T37NCG_20250909T073609_SCL_20m.jp2") as scl,
+):
+  is_cloud = (scl == 8) | (scl == 9) | (scl == 10)  # various cloud types
+  is_shadow = (scl == 3)
+  is_bad = is_cloud | is_shadow
+
+  masked_vre2 = yg.where(is_bad, float("nan"), vre2)
+  masked_vre2.to_geotiff("vre2_cleaned.tif")
+```
+
+or a species' [Area of Habitat](https://www.sciencedirect.com/science/article/pii/S0169534719301892) calculation:
+
+```python
+import yirgaceffe as yg
+
+with (
+    yg.read_raster("habitats.tif") as habitat_map,
+    yg.read_raster('elevation.tif') as elevation_map,
+    yg.read_shape('species123.geojson') as range_map,
+):
+    refined_habitat = habitat_map.isin([...species habitat codes...])
+    refined_elevation = (elevation_map >= species_min) & (elevation_map <= species_max)
+    aoh = refined_habitat * refined_elevation * range_polygon * area_per_pixel_map
+    print(f'Area of habitat: {aoh.sum()}')
+```
+
+## Citation
+
+If you use Yirgacheffe in your research, please cite our paper:
+
+> Michael Winston Dales, Alison Eyres, Patrick Ferris, Francesca A. Ridley, Simon Tarr, and Anil Madhavapeddy. 2025. Yirgacheffe: A Declarative Approach to Geospatial Data. In *Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming for the Planet* (PROPL '25). Association for Computing Machinery, New York, NY, USA, 47–54. https://doi.org/10.1145/3759536.3763806
+
+<details>
+<summary>BibTeX</summary>
+
+```bibtex
+@inproceedings{10.1145/3759536.3763806,
+  author = {Dales, Michael Winston and Eyres, Alison and Ferris, Patrick and Ridley, Francesca A. and Tarr, Simon and Madhavapeddy, Anil},
+  title = {Yirgacheffe: A Declarative Approach to Geospatial Data},
+  year = {2025},
+  isbn = {9798400721618},
+  publisher = {Association for Computing Machinery},
+  address = {New York, NY, USA},
+  url = {https://doi.org/10.1145/3759536.3763806},
+  doi = {10.1145/3759536.3763806},
+  abstract = {We present Yirgacheffe, a declarative geospatial library that allows spatial algorithms to be implemented concisely, supports parallel execution, and avoids common errors by automatically handling data (large geospatial rasters) and resources (cores, memory, GPUs). Our primary user domain comprises ecologists, where a typical problem involves cleaning messy occurrence data, overlaying it over tiled rasters, combining layers, and deriving actionable insights from the results. We describe the successes of this approach towards driving key pipelines related to global biodiversity and describe the capability gaps that remain, hoping to motivate more research into geospatial domain-specific languages.},
+  booktitle = {Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming for the Planet},
+  pages = {47–54},
+  numpages = {8},
+  keywords = {Biodiversity, Declarative, Geospatial, Python},
+  location = {Singapore, Singapore},
+  series = {PROPL '25}
+}
+```
+
+</details>
+
+## Thanks
+
+Thanks to discussion and feedback from my colleagues, particularly Alison Eyres, Patrick Ferris, Amelia Holcomb, and Anil Madhavapeddy.
+
+Inspired by the work of Daniele Baisero in his AoH library.

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yirgacheffe"
-version = "1.8.1"
+version = "1.10.3"
 description = "Abstraction of gdal datasets for doing basic math operations"
 readme = "README.md"
 authors = [{ name = "Michael Dales", email = "mwd24@cam.ac.uk" }]
@@ -30,6 +30,7 @@ dependencies = [
     "deprecation",
     "tomli",
     "h3",
+    "pyproj",
 ]
 requires-python = ">=3.10"
 
@@ -37,11 +38,15 @@ requires-python = ">=3.10"
 mlx = [
     "mlx",
 ]
+matplotlib = [
+    "matplotlib",
+]
 dev = [
     "mypy",
     "pylint",
     "pytest",
     "pytest-cov",
+    "pytest-mock",
     "build",
     "twine",
     "mkdocs-material",

yirgacheffe-1.10.3/tests/test_aggregations.py

@@ -0,0 +1,68 @@
+import json
+
+import numpy as np
+import pytest
+
+import yirgacheffe as yg
+from yirgacheffe._backends import backend, BACKEND
+
+def test_sum_result_is_scalar() -> None:
+    rng = np.random.default_rng(seed=42)
+    data = rng.integers(0, 128, size=(1000, 1000))
+    with yg.from_array(data, (0, 0), ("epsg:4326", (0.01, -0.01))) as layer:
+        total = layer.sum()
+        json.dumps(total)
+
+@pytest.mark.parametrize("c,dtype,maxval", [
+    (int(2), np.int8, 120),
+    (int(2), np.uint8, 250),
+    (int(2), np.int16, 32000),
+    (int(2), np.uint16, 64000),
+    (int(2), np.int32, 66000),
+    (int(2), np.uint32, 66000),
+])
+@pytest.mark.parametrize("step", [1, 2, 4, 8])
+def test_sums_of_calc_int(monkeypatch, step, c, dtype: type, maxval: int) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yg.constants, "YSTEP", step)
+
+        rng = np.random.default_rng(seed=42)
+
+        data = rng.integers(0, maxval, size=(1000, 1000), dtype=dtype)
+        typed_data = backend.promote(data)
+
+        assert np.sum(data) == backend.sum_op(typed_data)
+
+        with yg.from_array(data, (0, 0), ("epsg:4326", (0.01, -0.01))) as layer:
+            assert layer.sum() == backend.sum_op(typed_data)
+            calc = layer * c
+            actual = calc.sum()
+            expected = backend.sum_op(typed_data * c)
+            assert actual == expected
+
+@pytest.mark.parametrize("c,dtype,maxval", [
+    (float(2.5), np.int8, 120),
+    (float(2.5), np.uint8, 250),
+    (float(2.5), np.int16, 32000),
+    (float(2.5), np.uint16, 640),
+    (float(2.5), np.int32, 660),
+    (float(2.5), np.uint32, 660),
+])
+@pytest.mark.parametrize("step", [1, 2, 4, 8])
+def test_sums_of_calc_float_mlx(monkeypatch, step, c, dtype: type, maxval: int) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yg.constants, "YSTEP", step)
+
+        rng = np.random.default_rng(seed=42)
+
+        data = rng.integers(0, maxval, size=(100, 100), dtype=dtype)
+        typed_data = backend.promote(data)
+
+        with yg.from_array(data, (0, 0), ("epsg:4326", (0.01, -0.01))) as layer:
+            assert layer.sum() == backend.sum_op(typed_data)
+            calc = layer * c
+            actual = calc.sum()
+            expected = backend.sum_op(typed_data * c)
+            # MLX has a maximum float size of 32 bit for GPU and NUMPY has 64 bit on CPU
+            rel = 1e-6 if BACKEND == "MLX" else 1e-10
+            assert float(actual) == pytest.approx(float(expected), rel=rel)

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

@@ -5,7 +5,7 @@ import numpy as np
 import pytest
 
 import yirgacheffe as yg
-from tests.helpers import gdal_dataset_with_data, make_vectors_with_mutlile_ids
+from tests.helpers import gdal_dataset_with_data, make_vectors_with_multiple_ids
 from yirgacheffe.layers import ConstantLayer, RasterLayer, VectorLayer
 from yirgacheffe.window import Area
 
@@ -208,7 +208,7 @@ def test_vector_layers_add() -> None:
                 (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)
+            make_vectors_with_multiple_ids(areas, path)
 
             burn_value = 2
             with VectorLayer.layer_from_file(
@@ -242,7 +242,7 @@ def test_vector_layers_add_unbound_rhs() -> None:
                 (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)
+            make_vectors_with_multiple_ids(areas, path)
 
             burn_value = 2
             with VectorLayer.layer_from_file(path, None, None, None, burn_value=burn_value) as vector_layer:
@@ -269,7 +269,7 @@ def test_vector_layers_add_unbound_lhs() -> None:
                 (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)
+            make_vectors_with_multiple_ids(areas, path)
 
             burn_value = 2
             with VectorLayer.layer_from_file(path, None, None, None, burn_value=burn_value) as vector_layer:
@@ -297,7 +297,7 @@ def test_vector_layers_multiply() -> None:
             (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)
+        make_vectors_with_multiple_ids(areas, path)
 
         burn_value = 2
         layer2 = VectorLayer.layer_from_file(path, None, layer1.pixel_scale, layer1.projection, burn_value=burn_value)

{yirgacheffe-1.8.1 → yirgacheffe-1.10.3}/tests/test_constants.py

@@ -1,6 +1,8 @@
 
 import numpy as np
-import yirgacheffe
+import pytest
+
+import yirgacheffe as yg
 from yirgacheffe.layers import RasterLayer, ConstantLayer
 from yirgacheffe.operators import DataType
 from yirgacheffe.window import Area, PixelScale
@@ -21,12 +23,29 @@ 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)
+        with monkeypatch.context() as m:
+            m.setattr(yg.constants, "YSTEP", 1)
+            with ConstantLayer(42.0) as c:
                 c.parallel_save(result)
 
         expected = np.full((20, 20), 42.0)
         actual = result.read_array(0, 0, 20, 20)
 
         assert (expected == actual).all()
+
+@pytest.mark.parametrize("lhs,rhs,expected_equal", [
+    (1, 2, False),
+    (1, 1, True),
+    (1.0, 2.0, False),
+    (1.0, 1.0, True),
+    (1, 1.0, True), # This is Python standard behaviour
+])
+def test_cse_hash(lhs,rhs,expected_equal) -> None:
+    a = yg.constant(lhs)
+    b = yg.constant(rhs)
+
+    assert a is not b
+    assert a.name != b.name
+
+    are_hashed_same = a._cse_hash == b._cse_hash
+    assert expected_equal == are_hashed_same

{yirgacheffe-1.8.1 → yirgacheffe-1.10.3}/tests/test_datatypes.py

@@ -41,6 +41,23 @@ def test_round_trip_from_gdal(ytype) -> None:
     gtype = ytype.to_gdal()
     assert DataType.of_gdal(gtype) == ytype
 
+@pytest.mark.parametrize("ytype,expected", [
+    (DataType.Byte, 1),
+    (DataType.Int8, 1),
+    (DataType.Int16, 2),
+    (DataType.Int32, 4),
+    (DataType.Int64, 8),
+    (DataType.UInt8, 1),
+    (DataType.UInt16, 2),
+    (DataType.UInt32, 4),
+    (DataType.UInt64, 8),
+    (DataType.Float32, 4),
+    (DataType.Float64, 8),
+])
+def test_datatype_size(ytype,expected) -> None:
+    actual = ytype.sizeof()
+    assert expected == actual
+
 def test_round_trip_float64() -> None:
     backend_type = backend.dtype_to_backend(DataType.Float64)
     ytype = backend.backend_to_dtype(backend_type)
@@ -62,5 +79,51 @@ def test_float_to_int() -> None:
     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))
+    actual = result.read_array(0, 0, 4, 2)
     assert (expected == actual).all()
+
+@pytest.mark.parametrize("array,expected_type", [
+    (
+        np.ones((2, 2)).astype(np.int8),
+        DataType.Int8,
+    ),
+    (
+        np.ones((2, 2)).astype(np.int16),
+        DataType.Int16,
+    ),
+    (
+        np.ones((2, 2)).astype(np.int32),
+        DataType.Int32,
+    ),
+    (
+        np.ones((2, 2)).astype(np.int64),
+        DataType.Int64,
+    ),
+    (
+        np.ones((2, 2)).astype(np.uint8),
+        DataType.UInt8,
+    ),
+    (
+        np.ones((2, 2)).astype(np.uint16),
+        DataType.UInt16,
+    ),
+    (
+        np.ones((2, 2)).astype(np.uint32),
+        DataType.UInt32,
+    ),
+    (
+        np.ones((2, 2)).astype(np.uint64),
+        DataType.UInt64,
+    ),
+    (
+        np.ones((2, 2)).astype(np.float32),
+        DataType.Float32,
+    ),
+    (
+        np.ones((2, 2)).astype(np.float64),
+        DataType.Float64,
+    ),
+])
+def test_of_Array(array: np.ndarray, expected_type: DataType) -> None:
+    ytype = DataType.of_array(array)
+    assert ytype == expected_type

{yirgacheffe-1.8.1 → yirgacheffe-1.10.3}/tests/test_h3layer.py

@@ -23,7 +23,7 @@ def test_h3_layer(cell_id: str, is_valid: bool, expected_zoom: int) -> None:
     if is_valid:
         with H3CellLayer(cell_id, MapProjection(WGS_84_PROJECTION, 0.001, -0.001)) as layer:
             assert layer.zoom == expected_zoom
-            assert layer.projection == WGS_84_PROJECTION
+            assert layer.map_projection.epsg == 4326
 
             # without getting too deep, we'd expect a mix of zeros and ones in the data
             window = layer.window

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

@@ -67,7 +67,7 @@ def test_find_intersection_with_vector_unbound() -> None:
         path = Path(tempdir) / "test.gpkg"
         area = Area(left=58, top=74, right=180, bottom=42)
         make_vectors_with_id(42, {area}, path)
-        assert path.exists
+        assert path.exists()
 
         raster = RasterLayer(gdal_dataset_of_region(Area(left=-180.05, top=90.09, right=180.05, bottom=-90.09), 0.13))
         vector = VectorLayer.layer_from_file(path, None, None, None)
@@ -86,10 +86,10 @@ def test_find_intersection_with_vector_bound() -> None:
         path = Path(tempdir) / "test.gpkg"
         area = Area(left=58, top=74, right=180, bottom=42)
         make_vectors_with_id(42, {area}, path)
-        assert path.exists
+        assert path.exists()
 
         raster = RasterLayer(gdal_dataset_of_region(Area(left=-180.05, top=90.09, right=180.05, bottom=-90.09), 0.13))
-        vector = VectorLayer.layer_from_file(path, None, raster.map_projection.scale, raster.map_projection.name)
+        vector = VectorLayer.layer_from_file_like(path, raster)
         assert vector.area != area
 
         layers = [raster, vector]
@@ -104,10 +104,10 @@ def test_find_intersection_with_vector_awkward_rounding() -> None:
         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
+        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)
+        vector = VectorLayer.layer_from_file_like(path, raster)
 
         rounded_area = Area(left=-90, top=54, right=90, bottom=-54)
         assert vector.area == rounded_area

{yirgacheffe-1.8.1 → yirgacheffe-1.10.3}/tests/test_multiband.py

@@ -4,7 +4,7 @@ import tempfile
 import numpy as np
 from osgeo import gdal
 
-from tests.helpers import gdal_dataset_with_data
+import yirgacheffe as yg
 from yirgacheffe.layers import RasterLayer
 from yirgacheffe.window import Area, PixelScale
 
@@ -23,9 +23,10 @@ def test_simple_two_band_image() -> None:
         )
 
         # Create a set of rasters in turn to fill each band
+        projection = yg.MapProjection("epsg:4326", 1.0, -1.0)
         for i in range(bands):
             data1 = np.full((2, 2), i+1)
-            layer1 = RasterLayer(gdal_dataset_with_data((-1.0, 1.0), 1.0, data1))
+            layer1 = yg.from_array(data1, (-1.0, 1.0), projection)
             layer1.save(target, band=i+1)
 
         # force things to disk
@@ -33,7 +34,7 @@ def test_simple_two_band_image() -> None:
 
         #check they do what we expect
         for i in range(bands):
-            o = RasterLayer.layer_from_file(target_path, band=i+1)
+            o = yg.read_raster(target_path, band=i+1)
             assert o.sum() == (4 * (i + 1))
 
 def test_stack_tifs_with_area_match() -> None:
@@ -43,9 +44,10 @@ def test_stack_tifs_with_area_match() -> None:
         # slight alignment offset when we create them)
         bands = 4
         source_layers = []
+        projection = yg.MapProjection("epsg:4326", 1.0, -1.0)
         for i in range(bands):
             data1 = np.full((100, 100), i+1)
-            layer1 = RasterLayer(gdal_dataset_with_data((-100+i, 100+i), 1, data1))
+            layer1 = yg.from_array(data1, (-100+i, 100+i), projection)
             source_layers.append(layer1)
 
         intersection = RasterLayer.find_intersection(source_layers)
@@ -66,5 +68,5 @@ def test_stack_tifs_with_area_match() -> None:
 
         #check they do what we expect
         for i in range(bands):
-            o = RasterLayer.layer_from_file(target_path, band=i+1)
+            o = yg.read_raster(target_path, band=i+1)
             assert o.sum() == ((100 - (bands - 1)) * (100 - (bands - 1)) * (i + 1))