yirgacheffe 1.6.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

yirgacheffe/operators.py

@@ -12,14 +12,15 @@ from multiprocessing.managers import SharedMemoryManager
 from pathlib import Path
 from typing import Callable, Dict, Optional, Union
 
+import deprecation
 import numpy as np
 import numpy.typing as npt
 from osgeo import gdal
 from dill import dumps, loads # type: ignore
 
-from . import constants
-from .rounding import are_pixel_scales_equal_enough, round_up_pixels, round_down_pixels
-from .window import Area, PixelScale, Window
+from . import constants, __version__
+from .rounding import round_up_pixels, round_down_pixels
+from .window import Area, PixelScale, MapProjection, Window
 from ._backends import backend
 from ._backends.enumeration import operators as op
 from ._backends.enumeration import dtype as DataType
@@ -38,14 +39,17 @@ class LayerConstant:
     def __init__(self, val):
         self.val = val
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.val)
 
-    def _eval(self, _area, _index, _step, _target_window):
+    def _eval(self, _area, _projection, _index, _step, _target_window):
         return self.val
 
     @property
-    def area(self):
+    def area(self) -> Area:
+        return Area.world()
+
+    def _get_operation_area(self, _projection) -> Area:
         return Area.world()
 
 class LayerMathMixin:
@@ -95,12 +99,26 @@ class LayerMathMixin:
     def __or__(self, other):
         return LayerOperation(self, op.OR, other, window_op=WindowOperation.UNION)
 
-    def _eval(self, area, index, step, target_window=None):
+    def _eval(
+        self,
+        area,
+        projection,
+        index,
+        step,
+        target_window=None
+    ):
         try:
             window = self.window if target_window is None else target_window
-            return self._read_array_for_area(area, 0, index, window.xsize, step)
+            return self._read_array_for_area(area, projection, 0, index, window.xsize, step)
         except AttributeError:
-            return self._read_array_for_area(area, 0, index, target_window.xsize if target_window else 1, step)
+            return self._read_array_for_area(
+                area,
+                projection,
+                0,
+                index,
+                target_window.xsize if target_window else 1,
+                step
+            )
 
     def nan_to_num(self, nan=0, posinf=None, neginf=None):
         return LayerOperation(
@@ -314,7 +332,7 @@ class LayerOperation(LayerMathMixin):
                 else:
                     raise ValueError("Numpy arrays are no allowed")
             else:
-                if not are_pixel_scales_equal_enough([lhs.pixel_scale, rhs.pixel_scale]):
+                if not lhs.map_projection == rhs.map_projection:
                     raise ValueError("Not all layers are at the same pixel scale")
                 self.rhs = rhs
         else:
@@ -329,7 +347,7 @@ class LayerOperation(LayerMathMixin):
                 else:
                     raise ValueError("Numpy arrays are no allowed")
             else:
-                if not are_pixel_scales_equal_enough([lhs.pixel_scale, other.pixel_scale]):
+                if not lhs.map_projection == other.map_projection:
                     raise ValueError("Not all layers are at the same pixel scale")
                 self.other = other
         else:
@@ -403,7 +421,56 @@ class LayerOperation(LayerMathMixin):
             case _:
                 assert False, "Should not be reached"
 
+    def _get_operation_area(self, projection: Optional[MapProjection]) -> Area:
+
+        # The type().__name__ here is to avoid a circular import dependancy
+        lhs_area = self.lhs._get_operation_area(projection)
+        try:
+            rhs_area = self.rhs._get_operation_area(projection)
+        except AttributeError:
+            rhs_area = None
+        try:
+            other_area = self.other._get_operation_area(projection)
+        except AttributeError:
+            other_area = None
+
+        all_areas = [x for x in [lhs_area, rhs_area, other_area] if (x is not None) and (not x.is_world)]
+
+        match self.window_op:
+            case WindowOperation.NONE:
+                return all_areas[0]
+            case WindowOperation.LEFT:
+                return lhs_area
+            case WindowOperation.RIGHT:
+                assert rhs_area is not None
+                return rhs_area
+            case WindowOperation.INTERSECTION:
+                intersection = Area(
+                    left=max(x.left for x in all_areas),
+                    top=min(x.top for x in all_areas),
+                    right=min(x.right for x in all_areas),
+                    bottom=max(x.bottom for x in all_areas)
+                )
+                if (intersection.left >= intersection.right) or (intersection.bottom >= intersection.top):
+                    raise ValueError('No intersection possible')
+                return intersection
+            case WindowOperation.UNION:
+                return Area(
+                    left=min(x.left for x in all_areas),
+                    top=max(x.top for x in all_areas),
+                    right=max(x.right for x in all_areas),
+                    bottom=min(x.bottom for x in all_areas)
+                )
+            case _:
+                assert False, "Should not be reached"
+
     @property
+    @deprecation.deprecated(
+        deprecated_in="1.7",
+        removed_in="2.0",
+        current_version=__version__,
+        details="Use `map_projection` instead."
+    )
     def pixel_scale(self) -> PixelScale:
         # Because we test at construction that pixel scales for RHS/other are roughly equal,
         # I believe this should be sufficient...
@@ -418,19 +485,22 @@ class LayerOperation(LayerMathMixin):
 
     @property
     def window(self) -> Window:
-        pixel_scale = self.pixel_scale
-        area = self.area
+        projection = self.map_projection
+        if projection is None:
+            # This can happen if your source layers are say just constants
+            raise AttributeError("No window without projection")
+        area = self._get_operation_area(projection)
         assert area is not None
 
         return Window(
-            xoff=round_down_pixels(area.left / pixel_scale.xstep, pixel_scale.xstep),
-            yoff=round_down_pixels(area.top / (pixel_scale.ystep * -1.0), pixel_scale.ystep * -1.0),
+            xoff=round_down_pixels(area.left / projection.xstep, projection.xstep),
+            yoff=round_down_pixels(area.top / (projection.ystep * -1.0), projection.ystep * -1.0),
             xsize=round_up_pixels(
-                (area.right - area.left) / pixel_scale.xstep, pixel_scale.xstep
+                (area.right - area.left) / projection.xstep, projection.xstep
             ),
             ysize=round_up_pixels(
-                (area.top - area.bottom) / (pixel_scale.ystep * -1.0),
-                (pixel_scale.ystep * -1.0)
+                (area.top - area.bottom) / (projection.ystep * -1.0),
+                (projection.ystep * -1.0)
             ),
         )
 
@@ -440,23 +510,53 @@ class LayerOperation(LayerMathMixin):
         return self.lhs.datatype
 
     @property
+    @deprecation.deprecated(
+        deprecated_in="1.7",
+        removed_in="2.0",
+        current_version=__version__,
+        details="Use `map_projection` instead."
+    )
     def projection(self):
         try:
-            return self.lhs.projection
+            projection = self.lhs.projection
         except AttributeError:
-            return self.rhs.projection
+            projection = None
 
-    def _eval(self, area: Area, index: int, step: int, target_window:Optional[Window]=None):
+        if projection is None:
+            projection = self.rhs.projection
+        return projection
+
+    @property
+    def map_projection(self) -> Optional[MapProjection]:
+        try:
+            projection = self.lhs.map_projection
+        except AttributeError:
+            projection = None
+
+        if projection is None:
+            try:
+                projection = self.rhs.map_projection
+            except AttributeError:
+                pass
+        return projection
+
+    def _eval(
+        self,
+        area: Area,
+        projection: MapProjection,
+        index: int,
+        step: int,
+        target_window:Optional[Window]=None
+    ):
 
         if self.buffer_padding:
             if target_window:
                 target_window = target_window.grow(self.buffer_padding)
-            pixel_scale = self.pixel_scale
-            area = area.grow(self.buffer_padding * pixel_scale.xstep)
+            area = area.grow(self.buffer_padding * projection.xstep)
             # The index doesn't need updating because we updated area/window
             step += (2 * self.buffer_padding)
 
-        lhs_data = self.lhs._eval(area, index, step, target_window)
+        lhs_data = self.lhs._eval(area, projection, index, step, target_window)
 
         if self.operator is None:
             return lhs_data
@@ -469,12 +569,12 @@ class LayerOperation(LayerMathMixin):
 
         if self.other is not None:
             assert self.rhs is not None
-            rhs_data = self.rhs._eval(area, index, step, target_window)
-            other_data = self.other._eval(area, index, step, target_window)
+            rhs_data = self.rhs._eval(area, projection, index, step, target_window)
+            other_data = self.other._eval(area, projection, index, step, target_window)
             return operator(lhs_data, rhs_data, other_data, **self.kwargs)
 
         if self.rhs is not None:
-            rhs_data = self.rhs._eval(area, index, step, target_window)
+            rhs_data = self.rhs._eval(area, projection, index, step, target_window)
             return operator(lhs_data, rhs_data, **self.kwargs)
 
         return operator(lhs_data, **self.kwargs)
@@ -486,22 +586,24 @@ class LayerOperation(LayerMathMixin):
         # of the sum are done in different types.
         res = 0.0
         computation_window = self.window
+        projection = self.map_projection
         for yoffset in range(0, computation_window.ysize, self.ystep):
             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(self._get_operation_area(projection), projection, yoffset, step, computation_window)
             res += backend.sum_op(chunk)
         return res
 
     def min(self):
         res = None
         computation_window = self.window
+        projection = self.map_projection
         for yoffset in range(0, computation_window.ysize, self.ystep):
             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(self._get_operation_area(projection), projection, yoffset, step, computation_window)
             chunk_min = backend.min_op(chunk)
             if (res is None) or (res > chunk_min):
                 res = chunk_min
@@ -510,11 +612,12 @@ class LayerOperation(LayerMathMixin):
     def max(self):
         res = None
         computation_window = self.window
+        projection = self.map_projection
         for yoffset in range(0, computation_window.ysize, self.ystep):
             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(self._get_operation_area(projection), projection, yoffset, step, computation_window)
             chunk_max = backend.max_op(chunk)
             if (res is None) or (chunk_max > res):
                 res = chunk_max
@@ -533,14 +636,24 @@ class LayerOperation(LayerMathMixin):
         except AttributeError as exc:
             raise ValueError("Layer must be a raster backed layer") from exc
 
+        projection = self.map_projection
+
         destination_window = destination_layer.window
+        destination_projection = destination_layer.map_projection
+        assert destination_projection is not None
+
+        if projection is None:
+            projection = destination_projection
+        else:
+            if projection != destination_projection:
+                raise ValueError("Destination layer and input layers have different projection/scale")
 
         # 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_area = self._get_operation_area(projection)
+        except (AttributeError, IndexError):
             computation_window = destination_window
             computation_area = destination_layer.area
 
@@ -556,7 +669,7 @@ class LayerOperation(LayerMathMixin):
             step=self.ystep
             if yoffset+step > computation_window.ysize:
                 step = computation_window.ysize - yoffset
-            chunk = self._eval(computation_area, yoffset, step, computation_window)
+            chunk = self._eval(computation_area, projection, yoffset, step, computation_window)
             if isinstance(chunk, (float, int)):
                 chunk = backend.full((step, destination_window.xsize), chunk)
             band.WriteArray(
@@ -573,7 +686,7 @@ class LayerOperation(LayerMathMixin):
 
     def _parallel_worker(self, index, shared_mem, sem, np_dtype, width, input_queue, output_queue, computation_window):
         arr = np.ndarray((self.ystep, width), dtype=np_dtype, buffer=shared_mem.buf)
-
+        projection = self.map_projection
         try:
             while True:
                 # We acquire the lock so we know we have somewhere to put the
@@ -591,7 +704,7 @@ class LayerOperation(LayerMathMixin):
                     break
                 yoffset, step = task
 
-                result = self._eval(self.area, yoffset, step, computation_window)
+                result = self._eval(self._get_operation_area(projection), projection, yoffset, step, computation_window)
                 backend.eval_op(result)
 
                 arr[:step] = backend.demote_array(result)
@@ -628,7 +741,7 @@ class LayerOperation(LayerMathMixin):
         assert (destination_layer is not None) or and_sum
         try:
             computation_window = self.window
-        except AttributeError:
+        except (AttributeError, IndexError):
             # 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
@@ -828,12 +941,12 @@ class LayerOperation(LayerMathMixin):
 
 class ShaderStyleOperation(LayerOperation):
 
-    def _eval(self, area, index, step, target_window=None):
+    def _eval(self, area, projection, index, step, target_window=None):
         if target_window is None:
             target_window = self.window
-        lhs_data = self.lhs._eval(area, index, step, target_window)
+        lhs_data = self.lhs._eval(area, projection, index, step, target_window)
         if self.rhs is not None:
-            rhs_data = self.rhs._eval(area, index, step, target_window)
+            rhs_data = self.rhs._eval(area, projection, index, step, target_window)
         else:
             rhs_data = None
 

yirgacheffe/window.py

@@ -7,6 +7,47 @@ from typing import List, Optional, Tuple
 
 PixelScale = namedtuple('PixelScale', ['xstep', 'ystep'])
 
+@dataclass
+class MapProjection:
+    """Records the map projection and the size of the pixels in a layer.
+
+    This superceeeds the old PixelScale class, which will be removed in version 2.0.
+
+    Parameters
+    ----------
+    name : str
+        The map projection used.
+    xstep : float
+        The number of units horizontal distance a step of one pixel makes in the map projection.
+    ystep : float
+        The number of units verticle distance a step of one pixel makes in the map projection.
+
+    Attributes
+    ----------
+    name : str
+        The map projection used.
+    xstep : float
+        The number of units horizontal distance a step of one pixel makes in the map projection.
+    ystep : float
+        The number of units verticle distance a step of one pixel makes in the map projection.
+    """
+
+    name : str
+    xstep : float
+    ystep : float
+
+    def __eq__(self, other) -> bool:
+        if other is None:
+            return True
+        # to avoid circular dependancies
+        from .rounding import are_pixel_scales_equal_enough  # pylint: disable=C0415
+        return (self.name == other.name) and \
+            are_pixel_scales_equal_enough([self.scale, other.scale])
+
+    @property
+    def scale(self) -> PixelScale:
+        return PixelScale(self.xstep, self.ystep)
+
 @dataclass
 class Area:
     """Class to hold a geospatial area of data in the given projection.

{yirgacheffe-1.6.1.dist-info → yirgacheffe-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.6.1
+Version: 1.7.0
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC
@@ -14,6 +14,8 @@ Requires-Dist: gdal[numpy]
 Requires-Dist: scikit-image
 Requires-Dist: torch
 Requires-Dist: dill
+Requires-Dist: deprecation
+Requires-Dist: tomli
 Provides-Extra: dev
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pylint; extra == "dev"
@@ -57,7 +59,7 @@ import yirgaceffe as yg
 
 habitat_map = yg.read_raster("habitats.tif")
 elevation_map = yg.read_raster('elevation.tif')
-range_polygon = yg.read_shape_like('species123.geojson', like=habitat_map)
+range_polygon = yg.read_shape('species123.geojson')
 area_per_pixel_map = yg.read_raster('area_per_pixel.tif')
 
 refined_habitat = habitat_map.isin([...species habitat codes...])
@@ -177,22 +179,22 @@ with VectorLayer.layer_from_file('range.gpkg', PixelScale(0.001, -0.001), WGS_84
     ...
 ```
 
-The new 2.0 way of doing this is:
+The new 2.0 way of doing this is, if you plan to use the vector layer in calculation with other raster layers that will have projection information:
 
 ```python
 import yirgacheffe as yg
 
-with yg.read_shape('range.gpkg', (0.001, -0.001), WGS_84_PROJECTION) as layer:
+with yg.read_shape('range.gpkg') as layer:
     ...
 ```
 
-It is more common that when a shape file is loaded that its pixel size and projection will want to be made to match that of an existing raster (as per the opening area of habitat example). For that there is the following convenience method:
-
+Of if you plan to use the layer on its own and want to specify a rasterisation projection you can do:
 
 ```python
-with yg.read_raster("test.tif") as raster_layer:
-    with yg.read_shape_like('range.gpkg', raster_layer) as shape_layer:
-        ...
+import yirgacheffe as yg
+
+with yg.read_shape('range.gpkg', (yg.WGS_84_PROJECTION, (0.001, -0.001))) as layer:
+    ...
 ```
 
 ### GroupLayer

yirgacheffe-1.7.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+yirgacheffe/__init__.py,sha256=flTXNQQs6k8nboEv9O4eJnlv8kZ11z5zrfWcmUovCLg,537
+yirgacheffe/_core.py,sha256=SjdIqNlIpePo2Ea5A88aqg1WSmqcmrqORRExBPuR-S0,4191
+yirgacheffe/constants.py,sha256=uCWJwec3-ND-zVxYbsk1sdHKANl3ToNCTPg7MZb0j2g,434
+yirgacheffe/operators.py,sha256=fqk61NW_BjNuuBVPx_nvxPbgBs839cx6WztGOxrtiuE,35653
+yirgacheffe/rounding.py,sha256=ggBG4lMyLMtHLW3dBxr3gBCcF2qhRrY5etZiFGlIoqA,2258
+yirgacheffe/window.py,sha256=0Wy3BT4SZLyviDwzLcX8LYOo2MeZ2zXCWAiJNpMbQpc,9505
+yirgacheffe/_backends/__init__.py,sha256=jN-2iRrHStnPI6cNL7XhwhsROtI0EaGfIrbF5c-ECV0,334
+yirgacheffe/_backends/enumeration.py,sha256=pADawllxpW_hW-IVVvZpHWIKzvEMs9aaqfkZRD1zjnY,1003
+yirgacheffe/_backends/mlx.py,sha256=2vOTMqHbQbeqt81Eq_8hxWDXZHaPsDpbXkALRVGEnnw,6130
+yirgacheffe/_backends/numpy.py,sha256=cYO628s4-5K_-Bp3CrnHegzYSZfkt2QC8iE9oOOMtvA,4069
+yirgacheffe/layers/__init__.py,sha256=mYKjw5YTcMNv_hMy7a6K4yRzIuNUbR8WuBTw4WIAmSk,435
+yirgacheffe/layers/area.py,sha256=OFOM1_dMblzXLW29TwEqfdgSecl6aNs04bKJwUydLH0,3914
+yirgacheffe/layers/base.py,sha256=VCqN6oykGeS68IvKZ7my7otZo1lJpymAasIyw_zXY6E,14143
+yirgacheffe/layers/constant.py,sha256=XQ1ibeSckAcUOow-dMUlZiW5S2MKeFquOz_m8Y027GI,1437
+yirgacheffe/layers/group.py,sha256=tSkyJK6sp8VFxB8ieA3hzEeKLkP6cjW6iIOSLmdbL6c,16088
+yirgacheffe/layers/h3layer.py,sha256=Ys6F-e4Jre7lbFBYErF_4oidQx22WkWMKpHpQ7pPDTs,9875
+yirgacheffe/layers/rasters.py,sha256=-yECyz3Odhy1er0ilJ9bfLUseI2cTHfwqhP-H3ImUKo,13365
+yirgacheffe/layers/rescaled.py,sha256=hkvsd7paDCyUViABxrAXdXPOZegdwiphibkdrBuRclk,3366
+yirgacheffe/layers/vectors.py,sha256=40XAgOAmkxY1liGizwgAaeVtYJYdkFCysh9HvzvmNOU,19731
+yirgacheffe-1.7.0.dist-info/licenses/LICENSE,sha256=dNSHwUCJr6axStTKDEdnJtfmDdFqlE3h1NPCveqPfnY,757
+yirgacheffe-1.7.0.dist-info/METADATA,sha256=DORzQDxIzC2lFGZki3xHzOdiCwzTOxJaWIBVjhso6_g,22351
+yirgacheffe-1.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+yirgacheffe-1.7.0.dist-info/entry_points.txt,sha256=j4KgHXbVGbGyfTySc1ypBdERpfihO4WNjppvCdE9HjE,52
+yirgacheffe-1.7.0.dist-info/top_level.txt,sha256=9DBFlKO2Ld3hG6TuE3qOTd3Tt8ugTiXil4AN4Wr9_y0,12
+yirgacheffe-1.7.0.dist-info/RECORD,,

yirgacheffe-1.6.1.dist-info/RECORD

@@ -1,25 +0,0 @@
-yirgacheffe/__init__.py,sha256=n0v998xPOMMS6hdAQ16UNzmJUdnN5612HRtdudwjYa4,302
-yirgacheffe/_core.py,sha256=0E56yP63vUiwi0g6ntUzmKhOuWQWoh3sSD6Ui8SWWRI,4082
-yirgacheffe/constants.py,sha256=uCWJwec3-ND-zVxYbsk1sdHKANl3ToNCTPg7MZb0j2g,434
-yirgacheffe/operators.py,sha256=4REikGD_hDZjY3jfUfo4NmrrCXXu5hn1tYKedbwUlvg,31609
-yirgacheffe/rounding.py,sha256=ggBG4lMyLMtHLW3dBxr3gBCcF2qhRrY5etZiFGlIoqA,2258
-yirgacheffe/window.py,sha256=kR8sHQ6lcixpndOWC18wLRgbgS8y00tq4Fkh8PLESvM,8209
-yirgacheffe/_backends/__init__.py,sha256=jN-2iRrHStnPI6cNL7XhwhsROtI0EaGfIrbF5c-ECV0,334
-yirgacheffe/_backends/enumeration.py,sha256=pADawllxpW_hW-IVVvZpHWIKzvEMs9aaqfkZRD1zjnY,1003
-yirgacheffe/_backends/mlx.py,sha256=2vOTMqHbQbeqt81Eq_8hxWDXZHaPsDpbXkALRVGEnnw,6130
-yirgacheffe/_backends/numpy.py,sha256=cYO628s4-5K_-Bp3CrnHegzYSZfkt2QC8iE9oOOMtvA,4069
-yirgacheffe/layers/__init__.py,sha256=mYKjw5YTcMNv_hMy7a6K4yRzIuNUbR8WuBTw4WIAmSk,435
-yirgacheffe/layers/area.py,sha256=Qs5N5XMrQwk7StE_Rky94X7BhavRxgRmpC6mXLeu2HQ,3905
-yirgacheffe/layers/base.py,sha256=AgFe1HoWNuJWm2z_CgEE5o-3j-5hdC8HuNpYIM_h8HE,12672
-yirgacheffe/layers/constant.py,sha256=PiRiAgcvOE1Li-fFItt6P_cj8IOlwTf_xi5G_iaqHok,1440
-yirgacheffe/layers/group.py,sha256=e3pyQb35Ma-CPqY0dB4xDjMk3m2DQzzKiMGLSbBMY7c,16292
-yirgacheffe/layers/h3layer.py,sha256=Hy8kJF9-EQnLaRbZlj4TLSRfpq2-dJga8x4jiiPUHYo,9919
-yirgacheffe/layers/rasters.py,sha256=stZOi0sojJqMybvtKpvzfXlFJwRUvW7mA77Q3B4nhzA,13296
-yirgacheffe/layers/rescaled.py,sha256=uam0dsidKpP97gQBig34zXefyNruUbwAnQaeuN68KE4,3104
-yirgacheffe/layers/vectors.py,sha256=4BCGRSzbkFfsGZwLsQS9WelMXV5hDCcLmGGW6mf6MjU,15839
-yirgacheffe-1.6.1.dist-info/licenses/LICENSE,sha256=dNSHwUCJr6axStTKDEdnJtfmDdFqlE3h1NPCveqPfnY,757
-yirgacheffe-1.6.1.dist-info/METADATA,sha256=fn6CGfn17HeAcGhGO1YEbBdc_9WUjTsTnTZPZfQFNU8,22402
-yirgacheffe-1.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-yirgacheffe-1.6.1.dist-info/entry_points.txt,sha256=j4KgHXbVGbGyfTySc1ypBdERpfihO4WNjppvCdE9HjE,52
-yirgacheffe-1.6.1.dist-info/top_level.txt,sha256=9DBFlKO2Ld3hG6TuE3qOTd3Tt8ugTiXil4AN4Wr9_y0,12
-yirgacheffe-1.6.1.dist-info/RECORD,,