ssb-sgis 0.2.6__py3-none-any.whl → 0.2.7__py3-none-any.whl

sgis/__init__.py

@@ -46,6 +46,7 @@ from .geopandas_tools.polygon_operations import (
 )
 from .geopandas_tools.to_geodataframe import to_gdf
 from .helpers import get_name
+from .maps.examine import Examine
 from .maps.explore import Explore
 from .maps.httpserver import run_html_server
 from .maps.legend import Legend

sgis/geopandas_tools/polygon_operations.py

@@ -1,4 +1,5 @@
 """Functions for polygon geometries."""
+import functools
 import warnings
 
 import geopandas as gpd
@@ -8,6 +9,7 @@ import pandas as pd
 from geopandas import GeoDataFrame, GeoSeries
 from shapely import (
     area,
+    difference,
     get_exterior_ring,
     get_interior_ring,
     get_num_interior_rings,
@@ -457,21 +459,19 @@ def get_overlapping_polygon_product(gdf: GeoDataFrame | GeoSeries) -> pd.Index:
     return series
 
 
-def close_small_holes(
+def close_all_holes(
     gdf: GeoDataFrame | GeoSeries,
-    max_area: int | float,
     *,
+    without_islands: bool = True,
     copy: bool = True,
 ) -> GeoDataFrame | GeoSeries:
-    """Closes holes in polygons if the area is less than the given maximum.
+    """Closes all holes in polygons.
 
     It takes a GeoDataFrame or GeoSeries of polygons and
-    fills the holes that are smaller than the specified area given in units of
-    either square meters ('max_m2') or square kilometers ('max_km2').
+    returns the outer circle.
 
     Args:
         gdf: GeoDataFrame or GeoSeries of polygons.
-        max_area: The maximum area in the unit of the GeoDataFrame's crs.
         copy: if True (default), the input GeoDataFrame or GeoSeries is copied.
             Defaults to True.
 
@@ -479,17 +479,11 @@ def close_small_holes(
         A GeoDataFrame or GeoSeries of polygons with closed holes in the geometry
         column.
 
-    Raises:
-        ValueError: If the coordinate reference system of the GeoDataFrame is not in
-            meter units.
-        ValueError: If both 'max_m2' and 'max_km2' is given.
-
     Examples
     --------
-
     Let's create a circle with a hole in it.
 
-    >>> from sgis import close_small_holes, buff, to_gdf
+    >>> from sgis import close_all_holes, buff, to_gdf
     >>> point = to_gdf([260000, 6650000], crs=25833)
     >>> point
                             geometry
@@ -501,50 +495,54 @@ def close_small_holes(
     0    2.355807e+06
     dtype: float64
 
-    Close holes smaller than 1 square kilometer (1 million square meters).
+    Close the hole.
 
-    >>> holes_closed = close_small_holes(circle_with_hole, max_area=1_000_000)
+    >>> holes_closed = close_all_holes(circle_with_hole)
     >>> holes_closed.area
     0    3.141076e+06
     dtype: float64
-
-    The hole will not be closed if it is larger.
-
-    >>> holes_closed = close_small_holes(circle_with_hole, max_area=1_000)
-    >>> holes_closed.area
-    0    2.355807e+06
-    dtype: float64
     """
-    if copy:
-        gdf = gdf.copy()
-
-    if isinstance(gdf, GeoDataFrame):
-        gdf["geometry"] = gdf.geometry.map(
-            lambda x: _close_small_holes_poly(x, max_area)
+    if not isinstance(gdf, (GeoDataFrame, GeoSeries)):
+        raise ValueError(
+            f"'gdf' should be of type GeoDataFrame or GeoSeries. Got {type(gdf)}"
         )
-        return gdf
 
-    elif isinstance(gdf, gpd.GeoSeries):
-        return gdf.map(lambda x: _close_small_holes_poly(x, max_area))
+    if copy:
+        gdf = gdf.copy()
 
+    if without_islands:
+        all_geoms = gdf.unary_union
+        if isinstance(gdf, GeoDataFrame):
+            gdf["geometry"] = gdf.geometry.map(
+                lambda x: _close_all_holes_no_islands(x, all_geoms)
+            )
+            return gdf
+        else:
+            return gdf.map(lambda x: _close_all_holes_no_islands(x, all_geoms))
     else:
-        raise ValueError(
-            f"'gdf' should be of type GeoDataFrame or GeoSeries. Got {type(gdf)}"
-        )
+        if isinstance(gdf, GeoDataFrame):
+            gdf["geometry"] = gdf.geometry.map(_close_all_holes)
+            return gdf
+        else:
+            return gdf.map(_close_all_holes)
 
 
-def close_all_holes(
+def close_small_holes(
     gdf: GeoDataFrame | GeoSeries,
+    max_area: int | float,
     *,
+    without_islands: bool = True,
     copy: bool = True,
 ) -> GeoDataFrame | GeoSeries:
-    """Closes all holes in polygons.
+    """Closes holes in polygons if the area is less than the given maximum.
 
     It takes a GeoDataFrame or GeoSeries of polygons and
-    returns the outer circle.
+    fills the holes that are smaller than the specified area given in units of
+    either square meters ('max_m2') or square kilometers ('max_km2').
 
     Args:
         gdf: GeoDataFrame or GeoSeries of polygons.
+        max_area: The maximum area in the unit of the GeoDataFrame's crs.
         copy: if True (default), the input GeoDataFrame or GeoSeries is copied.
             Defaults to True.
 
@@ -552,11 +550,17 @@ def close_all_holes(
         A GeoDataFrame or GeoSeries of polygons with closed holes in the geometry
         column.
 
+    Raises:
+        ValueError: If the coordinate reference system of the GeoDataFrame is not in
+            meter units.
+        ValueError: If both 'max_m2' and 'max_km2' is given.
+
     Examples
     --------
+
     Let's create a circle with a hole in it.
 
-    >>> from sgis import close_all_holes, buff, to_gdf
+    >>> from sgis import close_small_holes, buff, to_gdf
     >>> point = to_gdf([260000, 6650000], crs=25833)
     >>> point
                             geometry
@@ -568,35 +572,51 @@ def close_all_holes(
     0    2.355807e+06
     dtype: float64
 
-    Close the hole.
+    Close holes smaller than 1 square kilometer (1 million square meters).
 
-    >>> holes_closed = close_all_holes(circle_with_hole)
+    >>> holes_closed = close_small_holes(circle_with_hole, max_area=1_000_000)
     >>> holes_closed.area
     0    3.141076e+06
     dtype: float64
-    """
-    if copy:
-        gdf = gdf.copy()
 
-    def close_all_holes_func(poly):
-        return unary_union(polygons(get_exterior_ring(get_parts(poly))))
+    The hole will not be closed if it is larger.
 
-    close_all_holes_func = np.vectorize(close_all_holes_func)
+    >>> holes_closed = close_small_holes(circle_with_hole, max_area=1_000)
+    >>> holes_closed.area
+    0    2.355807e+06
+    dtype: float64
+    """
+    if not isinstance(gdf, (GeoSeries, GeoDataFrame)):
+        raise ValueError(
+            f"'gdf' should be of type GeoDataFrame or GeoSeries. Got {type(gdf)}"
+        )
 
-    if isinstance(gdf, GeoDataFrame):
-        gdf["geometry"] = close_all_holes_func(gdf.geometry)
-        return gdf
+    if copy:
+        gdf = gdf.copy()
 
-    elif isinstance(gdf, gpd.GeoSeries):
-        return close_all_holes_func(gdf)
+    if without_islands:
+        all_geoms = gdf.unary_union
 
+        if isinstance(gdf, GeoDataFrame):
+            gdf["geometry"] = gdf.geometry.map(
+                lambda x: _close_small_holes_no_islands(x, max_area, all_geoms)
+            )
+            return gdf
+        else:
+            return gdf.map(
+                lambda x: _close_small_holes_no_islands(x, max_area, all_geoms)
+            )
     else:
-        raise ValueError(
-            f"'gdf' should be of type GeoDataFrame or GeoSeries. Got {type(gdf)}"
-        )
+        if isinstance(gdf, GeoDataFrame):
+            gdf["geometry"] = gdf.geometry.map(
+                lambda x: _close_small_holes(x, max_area)
+            )
+            return gdf
+        else:
+            return gdf.map(lambda x: _close_small_holes(x, max_area))
 
 
-def _close_small_holes_poly(poly, max_area):
+def _close_small_holes(poly, max_area):
     """Closes cmall holes within one shapely geometry of polygons."""
 
     # start with a list containing the polygon,
@@ -612,7 +632,56 @@ def _close_small_holes_poly(poly, max_area):
         for n in range(n_interior_rings):
             hole = polygons(get_interior_ring(part, n))
 
+            print(area(hole))
+
             if area(hole) < max_area:
                 holes_closed.append(hole)
 
     return unary_union(holes_closed)
+
+
+def _close_small_holes_no_islands(poly, max_area, all_geoms):
+    """Closes small holes within one shapely geometry of polygons."""
+
+    # start with a list containing the polygon,
+    # then append all holes smaller than 'max_km2' to the list.
+    holes_closed = [poly]
+    singlepart = get_parts(poly)
+    for part in singlepart:
+        n_interior_rings = get_num_interior_rings(part)
+
+        if not (n_interior_rings):
+            continue
+
+        for n in range(n_interior_rings):
+            hole = polygons(get_interior_ring(part, n))
+            no_islands = unary_union(hole.difference(all_geoms))
+            if area(no_islands) < max_area:
+                holes_closed.append(no_islands)
+
+    return unary_union(holes_closed)
+
+
+def _close_all_holes(poly):
+    return unary_union(polygons(get_exterior_ring(get_parts(poly))))
+
+
+def _close_all_holes_no_islands(poly, all_geoms):
+    """Closes all holes within one shapely geometry of polygons."""
+
+    # start with a list containing the polygon,
+    # then append all holes smaller than 'max_km2' to the list.
+    holes_closed = [poly]
+    singlepart = get_parts(poly)
+    for part in singlepart:
+        n_interior_rings = get_num_interior_rings(part)
+
+        if not (n_interior_rings):
+            continue
+
+        for n in range(n_interior_rings):
+            hole = polygons(get_interior_ring(part, n))
+            no_islands = unary_union(hole.difference(all_geoms))
+            holes_closed.append(no_islands)
+
+    return unary_union(holes_closed)

sgis/geopandas_tools/to_geodataframe.py

@@ -5,7 +5,7 @@ import geopandas as gpd
 import pandas as pd
 from geopandas import GeoDataFrame, GeoSeries
 from pandas.api.types import is_array_like, is_dict_like, is_list_like
-from shapely import Geometry, wkb, wkt
+from shapely import Geometry, box, wkb, wkt
 from shapely.geometry import Point
 from shapely.ops import unary_union
 
@@ -168,6 +168,8 @@ def to_gdf(
             geoseries = GeoSeries(
                 _make_shapely_geoms(list(geom.values())[0]), index=index
             )
+        elif isinstance(geom, pd.Series):
+            geoseries = GeoSeries(_make_shapely_geoms(geom), index=index)
         else:
             geoseries = GeoSeries(_make_shapely_geoms(geom.iloc[:, 0]), index=index)
         return GeoDataFrame({key: geoseries}, geometry=key, crs=crs, **kwargs)
@@ -292,9 +294,11 @@ def _make_one_shapely_geom(geom):
     elif len(geom) == 2 or len(geom) == 3:
         return Point(geom)
 
+    elif len(geom) == 4:
+        return box(*geom)
     else:
         raise ValueError(
             "If 'geom' is an iterable, each item should consist of "
-            "wkt, wkb or 2/3 coordinates (x, y, z). Got ",
+            "wkt, wkb or (x, y (z) or bbox). Got ",
             geom,
         )

sgis/maps/examine.py

@@ -0,0 +1,192 @@
+import geopandas as gpd
+
+from ..helpers import unit_is_degrees
+from .maps import clipmap
+
+
+class Examine:
+    """Explore geometries one row at a time.
+
+    It takes one or more GeoDataFrames and shows an interactive map
+    of one area at the time with the 'next', 'prev' and 'current' methods.
+
+    After creating the examiner object, the 'next' method will create a map
+    showing all geometries within a given radius (the size parameter) of the
+    first geometry in 'mask_gdf' (or the first speficied gdf). The 'next' method
+    can then be repeated.
+
+    Args:
+        *gdfs: One or more GeoDataFrames. The rows of the first GeoDataFrame
+            will be used as masks, unless 'mask_gdf' is specified.
+        column: Column to use as colors.
+        mask_gdf: Optional GeoDataFrame to use as mask iterator. The geometries
+            of mask_gdf will not be shown.
+        size: Number of meters (or other crs unit) to buffer the mask geometry
+            before clipping.
+        sort_values: Optional sorting column(s) of the mask GeoDataFrame. Rows
+            will be iterated through from the top.
+        **kwargs: Additional keyword arguments passed to sgis.clipmap.
+
+    Examples
+    --------
+    Create the examiner.
+
+    >>> import sgis as sg
+    >>> roads = sg.read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
+    >>> points = sg.read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/points_oslo.parquet")
+    >>> e = sg.Examine(points, roads)
+    >>> e
+
+    Then the line below can be repeated for all rows if 'points'. This has to be
+    in a separate notebook cell to the previous.
+
+    >>> e.next()
+
+    Previous geometry:
+
+    >>> e.prev()
+
+    Repeating the current area with another layer and new column:
+
+    >>> some_points = points.sample(100)
+    >>> e.current(some_points, column="idx")
+
+    The row number can also be specified manually.
+    Can be done in 'next', 'prev' and 'current'.
+
+    >>> e.next(i=101)
+
+    This will create an examiner where 'points' is not shown, only used as mask.
+
+    >>>  e = sg.Examine(roads, mask_gdf=points, column="oneway")
+    """
+
+    def __init__(
+        self,
+        *gdfs: gpd.GeoDataFrame,
+        column: str | None = None,
+        mask_gdf: gpd.GeoDataFrame | None = None,
+        sort_values: str | None = None,
+        size: int | float = 1000,
+        **kwargs,
+    ):
+        if not all(isinstance(gdf, gpd.GeoDataFrame) for gdf in gdfs):
+            raise ValueError("gdfs must be of type GeoDataFrame.")
+
+        self.gdfs = gdfs
+        if mask_gdf is None:
+            self.mask_gdf = gdfs[0]
+        else:
+            self.mask_gdf = mask_gdf
+
+        if unit_is_degrees(self.mask_gdf) and size > 360:
+            raise ValueError(
+                "CRS unit is degrees. Use geopandas' "
+                "to_crs method to change crs to e.g. UTM. "
+                "Or set 'size' to a smaller number."
+            )
+
+        if sort_values is not None:
+            self.mask_gdf = self.mask_gdf.sort_values(sort_values)
+
+        self.indices = list(range(len(gdfs[0])))
+        self.i = 0
+        self.column = column
+        self.size = size
+        self.kwargs = kwargs
+
+    def next(self, *gdfs, i: int | None = None, **kwargs):
+        """Displays a map of geometries within the next row of the mask gdf.
+
+        Args:
+            *gdfs: Optional GeoDataFrames to be added on top of the current.
+            i: Optionally set the integer index of which row to use as mask.
+            **kwargs: Additional keyword arguments passed to sgis.clipmap.
+        """
+        gdfs = () if not gdfs else gdfs
+        self.gdfs = self.gdfs + gdfs
+        if kwargs:
+            kwargs = self._fix_kwargs(kwargs)
+            self.kwargs = self.kwargs | kwargs
+
+        if i:
+            self.i = i
+
+        if self.i >= len(self.mask_gdf):
+            print("All rows are shown.")
+            return
+
+        print(f"{self.i + 1} of {len(self.mask_gdf)}")
+        clipmap(
+            *self.gdfs,
+            self.column,
+            mask=self.mask_gdf.iloc[[self.i]].buffer(self.size),
+            **self.kwargs,
+        )
+        self.i += 1
+
+    def prev(self, *gdfs, i: int | None = None, **kwargs):
+        """Displays a map of geometries within the previus row of the mask gdf.
+
+        Args:
+            *gdfs: Optional GeoDataFrames to be added on top of the current.
+            i: Optionally set the integer index of which row to use as mask.
+            **kwargs: Additional keyword arguments passed to sgis.clipmap.
+        """
+        gdfs = () if not gdfs else gdfs
+        self.gdfs = self.gdfs + gdfs
+        if kwargs:
+            kwargs = self._fix_kwargs(kwargs)
+            self.kwargs = self.kwargs | kwargs
+
+        self.i -= 2
+
+        if i:
+            self.i = i
+
+        print(f"{self.i + 1} of {len(self.mask_gdf)}")
+        clipmap(
+            *self.gdfs,
+            self.column,
+            mask=self.mask_gdf.iloc[[self.i]].buffer(self.size),
+            **self.kwargs,
+        )
+
+    def current(self, *gdfs, i: int | None = None, **kwargs):
+        """Repeat the last shown map."""
+        gdfs = () if not gdfs else gdfs
+        self.gdfs = self.gdfs + gdfs
+        if kwargs:
+            kwargs = self._fix_kwargs(kwargs)
+            self.kwargs = self.kwargs | kwargs
+
+        if i:
+            self.i = i
+
+        print(f"{self.i + 1} of {len(self.mask_gdf)}")
+        clipmap(
+            *self.gdfs,
+            self.column,
+            mask=self.mask_gdf.iloc[[self.i]].buffer(self.size),
+            **self.kwargs,
+        )
+
+    def get_current_mask(self) -> gpd.GeoDataFrame:
+        """Returns a GeoDataFrame of the last shown mask geometry."""
+        return self.mask_gdf.iloc[[self.i]]
+
+    def get_current_geoms(self) -> tuple[gpd.GeoDataFrame]:
+        """Returns all GeoDataFrames in the area of the last shown mask geometry."""
+        mask = self.mask_gdf.iloc[[self.i]]
+        gdfs = ()
+        for gdf in self.gdfs:
+            gdfs = gdfs + (gdf.clip(mask.buffer(self.size)),)
+        return gdfs
+
+    def _fix_kwargs(self, kwargs) -> dict:
+        self.size = kwargs.pop("size", self.size)
+        self.column = kwargs.pop("column", self.column)
+        return kwargs
+
+    def __repr__(self) -> str:
+        return f"{self.__class__}(indices={len(self.indices)}, current={self.i}, n_gdfs={len(self.gdfs)})"

sgis/maps/map.py

@@ -467,6 +467,8 @@ class Map:
             if gdf[self._column].isna().all():
                 return np.repeat(len(bins), len(gdf))
 
+            # need numpy.nan instead of pd.NA as of now
+            gdf[self._column] = gdf[self._column].fillna(np.nan)
             classified = np.searchsorted(bins, gdf[self._column])
 
         return classified

{ssb_sgis-0.2.6.dist-info → ssb_sgis-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ssb-sgis
-Version: 0.2.6
+Version: 0.2.7
 Summary: GIS functions used at Statistics Norway.
 Home-page: https://github.com/statisticsnorway/ssb-sgis
 License: MIT

{ssb_sgis-0.2.6.dist-info → ssb_sgis-0.2.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sgis/__init__.py,sha256=7XYr7wiJ4lw4lQDSj7B2JhLzREA_sgw3_CuqWaJf9b8,2334
+sgis/__init__.py,sha256=BWIQpUVt_X9jFJ6VkJO1XVcGQiOKv60PskNG5XO26G0,2368
 sgis/dapla.py,sha256=BlJ62kLwpTTQtmbj0Yutbh-bwokVPXHVb3QsRlMugF8,3542
 sgis/exceptions.py,sha256=ztMp4sB9xxPvwj2IEsO5kOaB4FmHuU_7-M2pZ7qaxTs,576
 sgis/geopandas_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -8,14 +8,15 @@ sgis/geopandas_tools/geometry_types.py,sha256=o3MbBP-aI7hVWWKVr_5p91TDhjiqZ_2IGx
 sgis/geopandas_tools/neighbors.py,sha256=tv8bmYgq4VNFbXmT2wcmJsFH8946NwbIBMQXAi3n8L4,14520
 sgis/geopandas_tools/overlay.py,sha256=RSxrDF0sXs6ZMxbeBJC9HFBVM4yaz10-cdbq3SCosFQ,11862
 sgis/geopandas_tools/point_operations.py,sha256=3JynroucouAbpON4DWG32S3MQQGmfIJuY7D6gkqtk70,6888
-sgis/geopandas_tools/polygon_operations.py,sha256=PfdrYLMmPtmlvOc9TkwYabsXxGe8B25F_Vzc7Sp1WUM,20336
-sgis/geopandas_tools/to_geodataframe.py,sha256=4jOy0YvXBIiOEqQx7_ept5xfd39R1XKPN_OVK8kxhp8,9722
+sgis/geopandas_tools/polygon_operations.py,sha256=ZzRx57w4LodN8_P_Tqc-zBAxGCvgvObIi9kJQKa-LLc,22646
+sgis/geopandas_tools/to_geodataframe.py,sha256=g1NqPVVH6hAdMupWxHVd10EvipLY9wPiahh2u_vLOnk,9887
 sgis/helpers.py,sha256=OqTojkSl-JVKlJzqqB-d_0CH6mk7_LS1DkiIjp1gD8E,2674
 sgis/maps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sgis/maps/examine.py,sha256=Wf48WwyNyPC1vYdw-n7GpvJYhwd-YMd_VZLOUI5vWZ4,6479
 sgis/maps/explore.py,sha256=mab8LE8c_dsGwS1gVCCA2A3r5_Vh7hnzEfEs5MBadvE,23631
 sgis/maps/httpserver.py,sha256=7ksCSs-WlchcREgjdCZd6II-riJpox34HpVXsCzN_AU,1923
 sgis/maps/legend.py,sha256=GXAqGOb_zAWcDavd5aHzRyRB7nTRhPCQfSupYA693lk,20499
-sgis/maps/map.py,sha256=9sqidnL_ERS0gkmXoEnOS-mAkqsT1kId_X2J2KG5tDU,18490
+sgis/maps/map.py,sha256=niK6N0eFJjAalxjHTNA7kh-2KuazLVsnWlu8i9Ava7o,18611
 sgis/maps/maps.py,sha256=NaK_wu4RGf6kKRUnnY7gLtxAY9x0d6gKxgQLubDbgHY,15961
 sgis/maps/thematicmap.py,sha256=6aVPciftW1YjxjRVQDipxayl3aI3tHpYiZ3HfpnSavc,14132
 sgis/networkanalysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -33,7 +34,7 @@ sgis/networkanalysis/networkanalysisrules.py,sha256=BhhaSXIyBRNzxSOUP2kVBIR--TRq
 sgis/networkanalysis/nodes.py,sha256=Ys3FjB39Pir3U0jOoLKIPxCC4psC9mdlqdC7G6dSJg0,6767
 sgis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sgis/read_parquet.py,sha256=GSW2NDy4-XosbamPEzB1xhWxFAPHuGEJZglfQ-V6DzY,3774
-ssb_sgis-0.2.6.dist-info/LICENSE,sha256=lL2h0dNKGTKAE0CjTy62SDbRennVD1xPgM5LzGqhKeo,1074
-ssb_sgis-0.2.6.dist-info/METADATA,sha256=elNsqzxjoSHPYPuH4fBF1Ims1Qb_qm0a4nxACdH_q7g,8831
-ssb_sgis-0.2.6.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-ssb_sgis-0.2.6.dist-info/RECORD,,
+ssb_sgis-0.2.7.dist-info/LICENSE,sha256=lL2h0dNKGTKAE0CjTy62SDbRennVD1xPgM5LzGqhKeo,1074
+ssb_sgis-0.2.7.dist-info/METADATA,sha256=hpcq2ydyXosFFnw-35qJtrdL3a7bhdblNERuDUiQea8,8831
+ssb_sgis-0.2.7.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+ssb_sgis-0.2.7.dist-info/RECORD,,