yirgacheffe 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

yirgacheffe/backends/enumeration.py

@@ -1,5 +1,7 @@
 from enum import Enum
 
+from osgeo import gdal
+
 class operators(Enum):
     ADD = 1
     SUB = 2
@@ -32,3 +34,25 @@ class operators(Enum):
     FLOORDIV = 29
     CONV2D = 30
     ABS = 31
+    ASTYPE = 32
+
+
+class dtype(Enum):
+    Float32 = gdal.GDT_Float32
+    Float64 = gdal.GDT_Float64
+    Byte = gdal.GDT_Byte
+    Int8 = gdal.GDT_Int8
+    Int16 = gdal.GDT_Int16
+    Int32 = gdal.GDT_Int32
+    Int64 = gdal.GDT_Int64
+    UInt8 = gdal.GDT_Byte
+    UInt16 = gdal.GDT_UInt16
+    UInt32 = gdal.GDT_UInt32
+    UInt64 = gdal.GDT_UInt64
+
+    def to_gdal(self):
+        return self.value
+
+    @classmethod
+    def of_gdal(cls, val):
+        return cls(val)

yirgacheffe/backends/mlx.py

@@ -4,6 +4,7 @@ import mlx.core as mx # pylint: disable=E0001,E0611,E0401
 import mlx.nn
 
 from .enumeration import operators as op
+from .enumeration import dtype
 
 array_t = mx.array
 float_t = mx.float32
@@ -121,9 +122,63 @@ def conv2d_op(data, weights):
     preped_data = mx.array(np.reshape(unshifted_data_shape, conv_data_shape))
 
     shifted_res = conv(preped_data)[0]
-    res = np.reshape(shifted_res, [1] + list(shifted_res.shape)[:-1])
+    res = mx.reshape(shifted_res, [1] + list(shifted_res.shape)[:-1])
     return res[0]
 
+
+def dtype_to_backed(dt):
+    match dt:
+        case dtype.Float32:
+            return mx.float32
+        case dtype.Float64:
+            return mx.float32
+        case dtype.Byte:
+            return mx.uint8
+        case dtype.Int8:
+            return mx.int8
+        case dtype.Int16:
+            return mx.int16
+        case dtype.Int32:
+            return mx.int32
+        case dtype.Int64:
+            return mx.int64
+        case dtype.UInt8:
+            return mx.uint8
+        case dtype.UInt16:
+            return mx.uint16
+        case dtype.UInt32:
+            return mx.uint32
+        case dtype.UInt64:
+            return mx.uint64
+        case _:
+            raise ValueError
+
+def backend_to_dtype(val):
+    match val:
+        case mx.float32:
+            return dtype.Float32
+        case mx.int8:
+            return dtype.Int8
+        case mx.int16:
+            return dtype.Int16
+        case mx.int32:
+            return dtype.Int32
+        case mx.int64:
+            return dtype.Int64
+        case mx.uint8:
+            return dtype.Byte
+        case mx.uint16:
+            return dtype.UInt16
+        case mx.uint32:
+            return dtype.UInt32
+        case mx.uint64:
+            return dtype.UInt64
+        case _:
+            raise ValueError
+
+def astype_op(data, datatype):
+    return data.astype(dtype_to_backed(datatype))
+
 operator_map = {
     op.ADD: mx.array.__add__,
     op.SUB: mx.array.__sub__,
@@ -155,4 +210,5 @@ operator_map = {
     op.FLOORDIV: mx.array.__floordiv__,
     op.CONV2D: conv2d_op,
     op.ABS: mx.abs,
+    op.ASTYPE: astype_op,
 }

yirgacheffe/backends/numpy.py

@@ -3,6 +3,7 @@ import numpy as np
 import torch
 
 from .enumeration import operators as op
+from .enumeration import dtype
 
 array_t = np.ndarray
 float_t = np.float64
@@ -61,52 +62,91 @@ def conv2d_op(data, weights):
     res = conv(preped_data)
     return res.detach().numpy()[0][0]
 
-operator_map = {
-	op.ADD: np.ndarray.__add__,
-	op.SUB: np.ndarray.__sub__,
-	op.MUL: np.ndarray.__mul__,
-	op.TRUEDIV: np.ndarray.__truediv__,
-	op.POW: np.ndarray.__pow__,
-	op.EQ: np.ndarray.__eq__,
-	op.NE: np.ndarray.__ne__,
-	op.LT: np.ndarray.__lt__,
-	op.LE: np.ndarray.__le__,
-	op.GT: np.ndarray.__gt__,
-	op.GE: np.ndarray.__ge__,
-	op.AND: np.ndarray.__and__,
-	op.OR: np.ndarray.__or__,
-	op.LOG: np.log,
-	op.LOG2: np.log2,
-	op.LOG10: np.log10,
-	op.EXP: np.exp,
-	op.EXP2: np.exp2,
-	op.CLIP: np.clip,
-	op.WHERE: np.where,
-	op.MIN: np.min,
-	op.MAX: np.max,
-	op.MINIMUM: np.minimum,
-	op.MAXIMUM: np.maximum,
-	op.NAN_TO_NUM: np.nan_to_num,
-	op.ISIN: np.isin,
-	op.REMAINDER: np.ndarray.__mod__,
-	op.FLOORDIV: np.ndarray.__floordiv__,
-	op.CONV2D: conv2d_op,
-	op.ABS: np.abs,
-}
+def dtype_to_backed(dt):
+    match dt:
+        case dtype.Float32:
+            return np.float32
+        case dtype.Float64:
+            return np.float64
+        case dtype.Byte:
+            return np.uint8
+        case dtype.Int8:
+            return np.int8
+        case dtype.Int16:
+            return np.int16
+        case dtype.Int32:
+            return np.int32
+        case dtype.Int64:
+            return np.int64
+        case dtype.UInt8:
+            return np.uint8
+        case dtype.UInt16:
+            return np.uint16
+        case dtype.UInt32:
+            return np.uint32
+        case dtype.UInt64:
+            return np.uint64
+        case _:
+            raise ValueError
+
+def backend_to_dtype(val):
+    match val:
+        case np.float32:
+            return dtype.Float32
+        case np.float64:
+            return dtype.Float64
+        case np.int8:
+            return dtype.Int8
+        case np.int16:
+            return dtype.Int16
+        case np.int32:
+            return dtype.Int32
+        case np.int64:
+            return dtype.Int64
+        case np.uint8:
+            return dtype.Byte
+        case np.uint16:
+            return dtype.UInt16
+        case np.uint32:
+            return dtype.UInt32
+        case np.uint64:
+            return dtype.UInt64
+        case _:
+            raise ValueError
 
-operator_str_map = {
-	op.POW: "np.ndarray.__pow__(%s, %s)",
-	op.LOG: "np.log(%s)",
-	op.LOG2: "np.log2(%s)",
-	op.LOG10: "np.log10(%s)",
-	op.EXP: "np.exp(%s)",
-	op.EXP2: "np.exp2(%s)",
-	op.CLIP: "np.clip",
-	op.WHERE: "np.where(%s, %s, %s)",
-	op.MIN: "np.min(%s)",
-	op.MAX: "np.max(%s)",
-	op.MINIMUM: "np.minimum(%s)",
-	op.MAXIMUM: "np.maximum(%s)",
-	op.NAN_TO_NUM: "np.nan_to_num(%s)",
-	op.ISIN: "np.isin(%s, %s)",
+def astype_op(data, datatype):
+    return data.astype(dtype_to_backed(datatype))
+
+operator_map = {
+    op.ADD: np.ndarray.__add__,
+    op.SUB: np.ndarray.__sub__,
+    op.MUL: np.ndarray.__mul__,
+    op.TRUEDIV: np.ndarray.__truediv__,
+    op.POW: np.ndarray.__pow__,
+    op.EQ: np.ndarray.__eq__,
+    op.NE: np.ndarray.__ne__,
+    op.LT: np.ndarray.__lt__,
+    op.LE: np.ndarray.__le__,
+    op.GT: np.ndarray.__gt__,
+    op.GE: np.ndarray.__ge__,
+    op.AND: np.ndarray.__and__,
+    op.OR: np.ndarray.__or__,
+    op.LOG: np.log,
+    op.LOG2: np.log2,
+    op.LOG10: np.log10,
+    op.EXP: np.exp,
+    op.EXP2: np.exp2,
+    op.CLIP: np.clip,
+    op.WHERE: np.where,
+    op.MIN: np.min,
+    op.MAX: np.max,
+    op.MINIMUM: np.minimum,
+    op.MAXIMUM: np.maximum,
+    op.NAN_TO_NUM: np.nan_to_num,
+    op.ISIN: np.isin,
+    op.REMAINDER: np.ndarray.__mod__,
+    op.FLOORDIV: np.ndarray.__floordiv__,
+    op.CONV2D: conv2d_op,
+    op.ABS: np.abs,
+    op.ASTYPE: astype_op,
 }

yirgacheffe/layers/__init__.py

@@ -13,7 +13,6 @@ try:
 except ModuleNotFoundError:
     pass
 
-
 class Layer(RasterLayer):
     """A place holder for now, at some point I want to replace Layer with RasterLayer."""
 

yirgacheffe/layers/base.py

@@ -1,7 +1,7 @@
 
 from typing import Any, List, Optional, Tuple
 
-from ..operators import LayerMathMixin
+from ..operators import DataType, LayerMathMixin
 from ..rounding import almost_equal, are_pixel_scales_equal_enough, round_up_pixels, round_down_pixels
 from ..window import Area, PixelScale, Window
 
@@ -35,7 +35,7 @@ class YirgacheffeLayer(LayerMathMixin):
         self.close()
 
     @property
-    def datatype(self) -> int:
+    def datatype(self) -> DataType:
         raise NotImplementedError("Must be overridden by subclass")
 
     @property

yirgacheffe/layers/constant.py

@@ -1,7 +1,6 @@
 from typing import Any, Union
 
-from osgeo import gdal
-
+from ..operators import DataType
 from ..window import Area, PixelScale, Window
 from .base import YirgacheffeLayer
 from ..backends import backend
@@ -22,8 +21,8 @@ class ConstantLayer(YirgacheffeLayer):
         self.value = float(value)
 
     @property
-    def datatype(self) -> int:
-        return gdal.GDT_Float64
+    def datatype(self) -> DataType:
+        return DataType.Float64
 
     def check_pixel_scale(self, _scale: PixelScale) -> bool:
         return True

yirgacheffe/layers/group.py

@@ -4,6 +4,7 @@ import os
 from typing import Any, List, Optional, TypeVar
 
 import numpy as np
+from yirgacheffe.operators import DataType
 
 from ..rounding import are_pixel_scales_equal_enough, round_down_pixels
 from ..window import Area, Window
@@ -72,8 +73,8 @@ class GroupLayer(YirgacheffeLayer):
                 pass
 
     @property
-    def datatype(self):
-        return self.layers[0].datatype
+    def datatype(self) -> DataType:
+        return DataType.of_gdal(self.layers[0].datatype)
 
     def set_window_for_intersection(self, new_area: Area) -> None:
         super().set_window_for_intersection(new_area)

yirgacheffe/layers/h3layer.py

@@ -3,7 +3,7 @@ from typing import Any
 
 import h3
 import numpy as np
-from osgeo import gdal
+from yirgacheffe.operators import DataType
 
 from ..rounding import round_up_pixels
 from ..window import Area, PixelScale, Window
@@ -76,8 +76,8 @@ class H3CellLayer(YirgacheffeLayer):
 
 
     @property
-    def datatype(self) -> int:
-        return gdal.GDT_Float64
+    def datatype(self) -> DataType:
+        return DataType.Float64
 
     def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
         if (xsize <= 0) or (ysize <= 0):

yirgacheffe/layers/rasters.py

@@ -9,6 +9,7 @@ from .. import WGS_84_PROJECTION
 from ..window import Area, PixelScale, Window
 from ..rounding import round_up_pixels
 from .base import YirgacheffeLayer
+from ..operators import DataType
 from ..backends import backend
 
 # Still to early to require Python 3.11 :/
@@ -27,7 +28,7 @@ class RasterLayer(YirgacheffeLayer):
     def empty_raster_layer(
         area: Area,
         scale: PixelScale,
-        datatype: int,
+        datatype: Union[int, DataType],
         filename: Optional[str]=None,
         projection: str=WGS_84_PROJECTION,
         name: Optional[str]=None,
@@ -47,6 +48,10 @@ class RasterLayer(YirgacheffeLayer):
             bottom=math.floor(area.bottom / abs_ystep) * abs_ystep,
         )
 
+        # This used to the the GDAL type, so we support that for legacy reasons
+        if isinstance(datatype, int):
+            datatype = DataType.of_gdal(datatype)
+
         options = []
         if threads is not None:
             options.append(f"NUM_THREADS={threads}")
@@ -69,7 +74,7 @@ class RasterLayer(YirgacheffeLayer):
             round_up_pixels((pixel_friendly_area.right - pixel_friendly_area.left) / abs_xstep, abs_xstep),
             round_up_pixels((pixel_friendly_area.top - pixel_friendly_area.bottom) / abs_ystep, abs_ystep),
             bands,
-            datatype,
+            datatype.to_gdal(),
             options
         )
         dataset.SetGeoTransform([
@@ -85,7 +90,7 @@ class RasterLayer(YirgacheffeLayer):
         layer: Any,
         filename: Optional[str]=None,
         area: Optional[Area]=None,
-        datatype: Optional[int]=None,
+        datatype: Optional[Union[int, DataType]]=None,
         compress: bool=True,
         nodata: Optional[Union[float,int]]=None,
         nbits: Optional[int]=None,
@@ -98,6 +103,10 @@ class RasterLayer(YirgacheffeLayer):
             area = layer.area
         assert area is not None
 
+        if datatype is not None:
+            if isinstance(datatype, int):
+                datatype = DataType.of_gdal(datatype)
+
         scale = layer.pixel_scale
         if scale is None:
             raise ValueError("Can not work out area without explicit pixel scale")
@@ -130,7 +139,7 @@ class RasterLayer(YirgacheffeLayer):
             width,
             height,
             bands,
-            datatype if datatype is not None else layer.datatype,
+            (datatype if datatype is not None else layer.datatype).to_gdal(),
             options,
         )
         dataset.SetGeoTransform(geo_transform)
@@ -181,7 +190,7 @@ class RasterLayer(YirgacheffeLayer):
             new_width,
             new_height,
             1,
-            source.datatype,
+            source.datatype.to_gdal(),
             options
         )
         dataset.SetGeoTransform((
@@ -279,11 +288,11 @@ class RasterLayer(YirgacheffeLayer):
                 raise FileNotFoundError(f"Failed to open pickled raster {self._dataset_path}") from exc
 
     @property
-    def datatype(self) -> int:
+    def datatype(self) -> DataType:
         if self._dataset is None:
             self._unpark()
         assert self._dataset
-        return self._dataset.GetRasterBand(1).DataType
+        return DataType.of_gdal(self._dataset.GetRasterBand(1).DataType)
 
     def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
         if self._dataset is None:

yirgacheffe/layers/rescaled.py

@@ -2,6 +2,7 @@ from math import floor, ceil
 from typing import Any, Optional
 
 from skimage import transform
+from yirgacheffe.operators import DataType
 
 from ..window import PixelScale, Window
 from .rasters import RasterLayer, YirgacheffeLayer
@@ -56,7 +57,7 @@ class RescaledRasterLayer(YirgacheffeLayer):
         self._src._unpark()
 
     @property
-    def datatype(self) -> int:
+    def datatype(self) -> DataType:
         return self._src.datatype
 
     def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:

yirgacheffe/layers/vectors.py

@@ -5,6 +5,7 @@ from typing_extensions import NotRequired
 
 from osgeo import gdal, ogr
 
+from ..operators import DataType
 from ..window import Area, PixelScale
 from .base import YirgacheffeLayer
 from .rasters import RasterLayer
@@ -64,7 +65,7 @@ class RasteredVectorLayer(RasterLayer):
         where_filter: Optional[str],
         scale: PixelScale,
         projection: str,
-        datatype: Optional[int] = None,
+        datatype: Optional[Union[int, DataType]] = None,
         burn_value: Union[int,float,str] = 1,
     ): # pylint: disable=W0221
         vectors = ogr.Open(filename)
@@ -78,6 +79,9 @@ class RasteredVectorLayer(RasterLayer):
         if datatype is None:
             datatype = estimated_datatype
 
+        if isinstance(datatype, int):
+            datatype = DataType.of_gdal(datatype)
+
         vector_layer = RasteredVectorLayer(
             layer,
             scale,
@@ -97,7 +101,7 @@ class RasteredVectorLayer(RasterLayer):
         layer: ogr.Layer,
         scale: PixelScale,
         projection: str,
-        datatype: int = gdal.GDT_Byte,
+        datatype: Union[int, DataType] = DataType.Byte,
         burn_value: Union[int,float,str] = 1,
     ):
         if layer is None:
@@ -106,6 +110,9 @@ class RasteredVectorLayer(RasterLayer):
 
         self._original = None
 
+        if isinstance(datatype, int):
+            datatype = DataType.of_gdal(datatype)
+
         # work out region for mask
         envelopes = []
         layer.ResetReading()
@@ -135,7 +142,7 @@ class RasteredVectorLayer(RasterLayer):
             round((area.right - area.left) / abs_xstep),
             round((area.top - area.bottom) / abs_ystep),
             1,
-            datatype,
+            datatype.to_gdal(),
             []
         )
         if not dataset:
@@ -164,7 +171,7 @@ class VectorLayer(YirgacheffeLayer):
         filename: str,
         other_layer: YirgacheffeLayer,
         where_filter: Optional[str]=None,
-        datatype: Optional[int] = None,
+        datatype: Optional[Union[int, DataType]] = None,
         burn_value: Union[int,float,str] = 1,
     ):
         if other_layer is None:
@@ -179,6 +186,10 @@ class VectorLayer(YirgacheffeLayer):
         if where_filter is not None:
             layer.SetAttributeFilter(where_filter)
 
+        if datatype is not None:
+            if isinstance(datatype, int):
+                datatype = DataType.of_gdal(datatype)
+
         vector_layer = VectorLayer(
             layer,
             other_layer.pixel_scale,
@@ -205,7 +216,7 @@ class VectorLayer(YirgacheffeLayer):
         where_filter: Optional[str],
         scale: PixelScale,
         projection: str,
-        datatype: Optional[int] = None,
+        datatype: Optional[Union[int, DataType]] = None,
         burn_value: Union[int,float,str] = 1,
         anchor: Tuple[float,float] = (0.0, 0.0)
     ):
@@ -220,6 +231,9 @@ class VectorLayer(YirgacheffeLayer):
         if datatype is None:
             datatype = estimated_datatype
 
+        if isinstance(datatype, int):
+            datatype = DataType.of_gdal(datatype)
+
         vector_layer = VectorLayer(
             layer,
             scale,
@@ -244,7 +258,7 @@ class VectorLayer(YirgacheffeLayer):
         scale: PixelScale,
         projection: str,
         name: Optional[str] = None,
-        datatype: int = gdal.GDT_Byte,
+        datatype: Union[int,DataType] = DataType.Byte,
         burn_value: Union[int,float,str] = 1,
         anchor: Tuple[float,float] = (0.0, 0.0)
     ):
@@ -253,7 +267,10 @@ class VectorLayer(YirgacheffeLayer):
         self.layer = layer
         self.name = name
 
-        self._datatype = datatype
+        if isinstance(datatype, int):
+            self._datatype = DataType.of_gdal(datatype)
+        else:
+            self._datatype = datatype
 
         # If the burn value is a number, use it directly, if it's a string
         # then assume it is a column name in the dataset
@@ -332,7 +349,7 @@ class VectorLayer(YirgacheffeLayer):
                 self.layer.SetAttributeFilter(self._filter)
 
     @property
-    def datatype(self) -> int:
+    def datatype(self) -> DataType:
         return self._datatype
 
     def read_array_for_area(self, target_area: Area, x: int, y: int, width: int, height: int) -> Any:
@@ -348,7 +365,7 @@ class VectorLayer(YirgacheffeLayer):
             width,
             height,
             1,
-            self.datatype,
+            self.datatype.to_gdal(),
             []
         )
         if not dataset:

yirgacheffe/operators.py

@@ -17,6 +17,7 @@ from .rounding import are_pixel_scales_equal_enough, round_up_pixels, round_down
 from .window import Area, PixelScale, Window
 from .backends import backend
 from .backends.enumeration import operators as op
+from .backends.enumeration import dtype as DataType
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.WARNING)
@@ -208,6 +209,14 @@ class LayerMathMixin:
     def max(self):
         return LayerOperation(self).max()
 
+    def astype(self, datatype):
+        return LayerOperation(
+            self,
+            op.ASTYPE,
+            window_op=WindowOperation.NONE,
+            datatype=datatype
+        )
+
 
 class LayerOperation(LayerMathMixin):
 
@@ -392,7 +401,7 @@ class LayerOperation(LayerMathMixin):
         )
 
     @property
-    def datatype(self):
+    def datatype(self) -> DataType:
         # TODO: Work out how to indicate type promotion via numpy
         return self.lhs.datatype
 

{yirgacheffe-1.2.1.dist-info → yirgacheffe-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.2.1
+Version: 1.3.0
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC
@@ -35,6 +35,14 @@ Example common use-cases:
 * 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.
 
 
+## Installation
+
+Yirgacheffe is available via pypi, so can be installed with pip for example:
+
+```SystemShell
+$ pip install yirgacheffe
+```
+
 ## Basic usage
 
 They main unit of data in Yirgacheffe is a "layer", which wraps either a raster dataset or polygon data, and then you can do work on layers without having to worry (unless you choose to) about how they align - Yirgacheffe will work out all the details around overlapping
@@ -339,6 +347,18 @@ with RasterLayer.layer_from_file('original.tif') as layer1:
         calc.save(result)
 ```
 
+### Type conversion
+
+Similar to numpy and other Python numerical libraries, Yirgacheffe will automatically deal with simple type conversion where possible, however sometimes explicit conversion is either necessary or desired. Similar to numpy, there is an `astype` operator that lets you set the conversion:
+
+```python
+from yirgacheffe.operations import DataType
+
+
+with RasterLayer.layer_from_file('float_data.tif') as float_layer:
+    int_layer = float_layer.astype(DataType.Int32)
+```
+
 ### Apply
 
 You can specify a function that takes either data from one layer or from two layers, and returns the processed data. There's two version of this: one that lets you specify a numpy function that'll be applied to the layer data as an array, or one that is more shader like that lets you do pixel wise processing.

yirgacheffe-1.3.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+yirgacheffe/__init__.py,sha256=U5AoPk_iWreSCexG2ID-tmSXiJz4_9Lvzbf42DMvT7k,658
+yirgacheffe/constants.py,sha256=9ZcFLcir4GhPBBDG2rzLhDtJ0pMzpZYuzE9f-CFeA44,12
+yirgacheffe/h3layer.py,sha256=MT2hm6n64hzHSeRPvjn-CwErru937ntKXbEU7CIlPSU,91
+yirgacheffe/operators.py,sha256=dOzScup0rYKU2GbY3j5zFJJ0JMQomq6hN0c1nH1_igs,27198
+yirgacheffe/rounding.py,sha256=ggBG4lMyLMtHLW3dBxr3gBCcF2qhRrY5etZiFGlIoqA,2258
+yirgacheffe/window.py,sha256=0XZdwD4mz0bRU9eBhFY1Xk1hQt6FqCKp3BnUgxZup3c,5224
+yirgacheffe/backends/__init__.py,sha256=149-fg1PVXC36cgyuSZsU8SYOm65fzUmYN_MHZtEyrY,313
+yirgacheffe/backends/enumeration.py,sha256=v1CsWSq97LNS4QXgUc59OyaBQWF5dAG5cDrMY2NWx1o,960
+yirgacheffe/backends/mlx.py,sha256=Bt0Jlt96ECHZmBwI7kqJ6kSVsLDU-6rq0E7oUt7EzOg,5969
+yirgacheffe/backends/numpy.py,sha256=t8rPDqkghE5UfkJi8r6ZUg14f1nL2lsPp61FGqUJwCg,3887
+yirgacheffe/layers/__init__.py,sha256=GR_TJlhPKDK1212CG2T99X2FdBlNo_G8q2zQ6nJbiO4,1534
+yirgacheffe/layers/area.py,sha256=yIRXzeeLi3MMyuh4LG_VgZrKNWe5xwZgDGdgaoYRpP0,3805
+yirgacheffe/layers/base.py,sha256=vVxumZgFLTYXFtVxJEiBVV1QqtQWa5kwL10ckUF-ykE,11617
+yirgacheffe/layers/constant.py,sha256=5YWSdr48Cw3DhryLBx45PNnPi4NzcVuQVin_YmOSWTg,1426
+yirgacheffe/layers/group.py,sha256=2hRta24Mn5JwfDOB4-gJfroa_lVJSUFgSZ8FMeWy_FM,15127
+yirgacheffe/layers/h3layer.py,sha256=Cyrw_6nXc1a_Twsb0FfexKhHAbegKXStL3J5LLk2AX8,9687
+yirgacheffe/layers/rasters.py,sha256=8mAbH49RtKIoA3h9mxWNbPzo8NJWDSfoRPT7fpkTJ4I,12328
+yirgacheffe/layers/rescaled.py,sha256=kWJlu7DuUB3nRDt3VtbJKiqBDQb2Ba8xzIIXTvOGdK8,2945
+yirgacheffe/layers/vectors.py,sha256=JOqM7Ym53ZdxWKpBJac-opPp2N_ynMfet1Xtsi85dpM,15087
+yirgacheffe-1.3.0.dist-info/licenses/LICENSE,sha256=dNSHwUCJr6axStTKDEdnJtfmDdFqlE3h1NPCveqPfnY,757
+yirgacheffe-1.3.0.dist-info/METADATA,sha256=jt79WCW-SqvTFkzqnHQC6VQoK0rJwo6R3uMePZD4CMc,20473
+yirgacheffe-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+yirgacheffe-1.3.0.dist-info/entry_points.txt,sha256=j4KgHXbVGbGyfTySc1ypBdERpfihO4WNjppvCdE9HjE,52
+yirgacheffe-1.3.0.dist-info/top_level.txt,sha256=9DBFlKO2Ld3hG6TuE3qOTd3Tt8ugTiXil4AN4Wr9_y0,12
+yirgacheffe-1.3.0.dist-info/RECORD,,

yirgacheffe-1.2.1.dist-info/RECORD

@@ -1,25 +0,0 @@
-yirgacheffe/__init__.py,sha256=U5AoPk_iWreSCexG2ID-tmSXiJz4_9Lvzbf42DMvT7k,658
-yirgacheffe/constants.py,sha256=9ZcFLcir4GhPBBDG2rzLhDtJ0pMzpZYuzE9f-CFeA44,12
-yirgacheffe/h3layer.py,sha256=MT2hm6n64hzHSeRPvjn-CwErru937ntKXbEU7CIlPSU,91
-yirgacheffe/operators.py,sha256=eGa_y5fXXaEb4DkQ7b899bbhzl639yyIVLfVRbkD7vE,26945
-yirgacheffe/rounding.py,sha256=ggBG4lMyLMtHLW3dBxr3gBCcF2qhRrY5etZiFGlIoqA,2258
-yirgacheffe/window.py,sha256=0XZdwD4mz0bRU9eBhFY1Xk1hQt6FqCKp3BnUgxZup3c,5224
-yirgacheffe/backends/__init__.py,sha256=149-fg1PVXC36cgyuSZsU8SYOm65fzUmYN_MHZtEyrY,313
-yirgacheffe/backends/enumeration.py,sha256=lddqmD7Z2z2g2SIPkmgNOiNSSZer3rIuBG3qHwy7t_g,474
-yirgacheffe/backends/mlx.py,sha256=wJ5kUNWdhpE-DLrgsvxpLeiXm7fUlKvrqik976jM9kc,4558
-yirgacheffe/backends/numpy.py,sha256=-y3oLi3BOUuS5l9IJJ3orl08YrPbo9mideW9M1Re6lA,2745
-yirgacheffe/layers/__init__.py,sha256=TrKSHpd-TF7wgC371hka6paFXBnqvDtjJYblproNKZs,1535
-yirgacheffe/layers/area.py,sha256=yIRXzeeLi3MMyuh4LG_VgZrKNWe5xwZgDGdgaoYRpP0,3805
-yirgacheffe/layers/base.py,sha256=pWnmmohGqI4rtH_CruDWfEfOiNcyns-sU2FcNw55ng4,11602
-yirgacheffe/layers/constant.py,sha256=Fm76YLZobSlNJjbpJOX8VDDkifYPVtg55zdUc8kt7xc,1412
-yirgacheffe/layers/group.py,sha256=RXl6sGa4OagudIb8seveLfnvCMC9_wm-5hrGq6LYgnw,15054
-yirgacheffe/layers/h3layer.py,sha256=O4u-tGO32SQaEsgNLlgGCOFd4bjm1mt2coZDL23F_HI,9662
-yirgacheffe/layers/rasters.py,sha256=8kT2ETplWTJNb7F9HsmqRMz7APolByvIkZuBB0mRduk,11907
-yirgacheffe/layers/rescaled.py,sha256=hEj6BnrJm8o7dMVND5KMpVfg-HVVExovcKRnUl64dRI,2897
-yirgacheffe/layers/vectors.py,sha256=OxXxnV5pss9vSmeiqvmx68ZGmC7iX6Iet0y4b4ZEMcc,14436
-yirgacheffe-1.2.1.dist-info/licenses/LICENSE,sha256=dNSHwUCJr6axStTKDEdnJtfmDdFqlE3h1NPCveqPfnY,757
-yirgacheffe-1.2.1.dist-info/METADATA,sha256=bmztQnEJWScy1ig9svcz_vyy6-I8XIvRESPuf5WgEHc,19844
-yirgacheffe-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-yirgacheffe-1.2.1.dist-info/entry_points.txt,sha256=j4KgHXbVGbGyfTySc1ypBdERpfihO4WNjppvCdE9HjE,52
-yirgacheffe-1.2.1.dist-info/top_level.txt,sha256=9DBFlKO2Ld3hG6TuE3qOTd3Tt8ugTiXil4AN4Wr9_y0,12
-yirgacheffe-1.2.1.dist-info/RECORD,,