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

sgis/__init__.py

@@ -3,7 +3,9 @@ from .geopandas_tools.buffer_dissolve_explode import (
     buff,
     buffdiss,
     buffdissexp,
+    buffdissexp_by_cluster,
     dissexp,
+    dissexp_by_cluster,
 )
 from .geopandas_tools.general import (
     bounds_to_points,
@@ -23,6 +25,7 @@ from .geopandas_tools.general import (
 from .geopandas_tools.geometry_types import (
     get_geom_type,
     is_single_geom_type,
+    make_all_singlepart,
     to_single_geom_type,
 )
 from .geopandas_tools.neighbors import (
@@ -46,6 +49,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/buffer_dissolve_explode.py

@@ -17,6 +17,7 @@ for the following:
 from geopandas import GeoDataFrame, GeoSeries
 
 from .geometry_types import make_all_singlepart
+from .polygon_operations import get_polygon_clusters
 
 
 def _decide_ignore_index(kwargs: dict) -> tuple[dict, bool]:
@@ -190,6 +191,31 @@ def dissexp(
     )
 
 
+def dissexp_by_cluster(gdf: GeoDataFrame) -> GeoDataFrame:
+    return (
+        gdf.explode(ignore_index=True)
+        .pipe(get_polygon_clusters, cluster_col="cluster")
+        .pipe(dissexp, by="cluster")
+        .reset_index(drop=True)
+    )
+
+
+def buffdissexp_by_cluster(
+    gdf: GeoDataFrame,
+    distance: int | float,
+    *,
+    resolution: int = 50,
+    copy: bool = True,
+) -> GeoDataFrame:
+    return (
+        buff(gdf, distance, resolution=resolution, copy=copy)
+        .explode(ignore_index=True)
+        .pipe(get_polygon_clusters, cluster_col="cluster")
+        .pipe(dissexp, by="cluster")
+        .reset_index(drop=True)
+    )
+
+
 def buff(
     gdf: GeoDataFrame | GeoSeries,
     distance: int | float,

sgis/geopandas_tools/general.py

@@ -2,6 +2,7 @@ import warnings
 
 import geopandas as gpd
 import numpy as np
+import pandas as pd
 from geopandas import GeoDataFrame, GeoSeries
 from geopandas.array import GeometryDtype
 from shapely import (
@@ -519,11 +520,17 @@ def to_lines(*gdfs: GeoDataFrame, copy: bool = True) -> GeoDataFrame:
     if len(lines) == 1:
         return lines[0]
 
-    unioned = lines[0].overlay(lines[1], how="union", keep_geom_type=True)
+    if len(lines[0]) and len(lines[1]):
+        unioned = lines[0].overlay(lines[1], how="union", keep_geom_type=True)
+    else:
+        unioned = pd.concat([lines[0], lines[1]], ignore_index=True)
 
     if len(lines) > 2:
         for line_gdf in lines[2:]:
-            unioned = unioned.overlay(line_gdf, how="union", keep_geom_type=True)
+            if len(line_gdf):
+                unioned = unioned.overlay(line_gdf, how="union", keep_geom_type=True)
+            else:
+                unioned = pd.concat([unioned, line_gdf], ignore_index=True)
 
     return make_all_singlepart(unioned, ignore_index=True)
 

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,
@@ -21,6 +23,147 @@ from .neighbors import get_neighbor_indices
 from .overlay import clean_overlay
 
 
+def get_polygon_clusters(
+    *gdfs: GeoDataFrame | GeoSeries,
+    cluster_col: str = "cluster",
+    allow_multipart: bool = False,
+) -> GeoDataFrame | tuple[GeoDataFrame]:
+    """Find which polygons overlap without dissolving.
+
+    Devides polygons into clusters in a fast and precice manner by using spatial join
+    and networkx to find the connected components, i.e. overlapping geometries.
+    If multiple GeoDataFrames are given, the clusters will be based on all
+    combined.
+
+    This can be used instead of dissolve+explode, or before dissolving by the cluster
+    column. This has been tested to be a lot faster if there are many
+    non-overlapping polygons, but somewhat slower than dissolve+explode if most
+    polygons overlap.
+
+    Args:
+        gdfs: One or more GeoDataFrames of polygons.
+        cluster_col: Name of the resulting cluster column.
+        allow_multipart: Whether to allow mutipart geometries in the gdfs.
+            Defaults to False to avoid confusing results.
+
+    Returns:
+        One or more GeoDataFrames (same amount as was given) with a new cluster column.
+
+    Examples
+    --------
+
+    Create geometries with three clusters of overlapping polygons.
+
+    >>> import sgis as sg
+    >>> gdf = sg.to_gdf([(0, 0), (1, 1), (0, 1), (4, 4), (4, 3), (7, 7)])
+    >>> buffered = sg.buff(gdf, 1)
+    >>> gdf
+                                                geometry
+    0  POLYGON ((1.00000 0.00000, 0.99951 -0.03141, 0...
+    1  POLYGON ((2.00000 1.00000, 1.99951 0.96859, 1....
+    2  POLYGON ((1.00000 1.00000, 0.99951 0.96859, 0....
+    3  POLYGON ((5.00000 4.00000, 4.99951 3.96859, 4....
+    4  POLYGON ((5.00000 3.00000, 4.99951 2.96859, 4....
+    5  POLYGON ((8.00000 7.00000, 7.99951 6.96859, 7....
+
+    Add a cluster column to the GeoDataFrame:
+
+    >>> gdf = sg.get_polygon_clusters(gdf, cluster_col="cluster")
+    >>> gdf
+       cluster                                           geometry
+    0        0  POLYGON ((1.00000 0.00000, 0.99951 -0.03141, 0...
+    1        0  POLYGON ((2.00000 1.00000, 1.99951 0.96859, 1....
+    2        0  POLYGON ((1.00000 1.00000, 0.99951 0.96859, 0....
+    3        1  POLYGON ((5.00000 4.00000, 4.99951 3.96859, 4....
+    4        1  POLYGON ((5.00000 3.00000, 4.99951 2.96859, 4....
+    5        2  POLYGON ((8.00000 7.00000, 7.99951 6.96859, 7....
+
+    If multiple GeoDataFrames are given, all are returned with common
+    cluster values.
+
+    >>> gdf2 = sg.to_gdf([(0, 0), (7, 7)])
+    >>> gdf, gdf2 = sg.get_polygon_clusters(gdf, gdf2, cluster_col="cluster")
+    >>> gdf2
+       cluster                 geometry
+    0        0  POINT (0.00000 0.00000)
+    1        2  POINT (7.00000 7.00000)
+    >>> gdf
+       cluster                                           geometry
+    0        0  POLYGON ((1.00000 0.00000, 0.99951 -0.03141, 0...
+    1        0  POLYGON ((2.00000 1.00000, 1.99951 0.96859, 1....
+    2        0  POLYGON ((1.00000 1.00000, 0.99951 0.96859, 0....
+    3        1  POLYGON ((5.00000 4.00000, 4.99951 3.96859, 4....
+    4        1  POLYGON ((5.00000 3.00000, 4.99951 2.96859, 4....
+    5        2  POLYGON ((8.00000 7.00000, 7.99951 6.96859, 7....
+
+    Dissolving 'by' the cluster column will make the dissolve much
+    faster if there are a lot of non-overlapping polygons.
+
+    >>> dissolved = gdf.dissolve(by="cluster", as_index=False)
+    >>> dissolved
+       cluster                                           geometry
+    0        0  POLYGON ((0.99951 -0.03141, 0.99803 -0.06279, ...
+    1        1  POLYGON ((4.99951 2.96859, 4.99803 2.93721, 4....
+    2        2  POLYGON ((8.00000 7.00000, 7.99951 6.96859, 7....
+    """
+    if isinstance(gdfs[-1], str):
+        *gdfs, cluster_col = gdfs
+
+    concated = pd.DataFrame()
+    orig_indices = ()
+    for i, gdf in enumerate(gdfs):
+        if isinstance(gdf, GeoSeries):
+            gdf = gdf.to_frame()
+
+        if not isinstance(gdf, GeoDataFrame):
+            raise TypeError("'gdfs' should be GeoDataFrames or GeoSeries.")
+
+        if not allow_multipart and len(gdf) != len(gdf.explode(index_parts=False)):
+            raise ValueError(
+                "All geometries should be exploded to singlepart "
+                "in order to get correct polygon clusters. "
+                "To allow multipart geometries, set allow_multipart=True"
+            )
+
+        orig_indices = orig_indices + (gdf.index,)
+
+        gdf["i__"] = i
+
+        concated = pd.concat([concated, gdf], ignore_index=True)
+
+    neighbors = get_neighbor_indices(concated, concated)
+
+    edges = [(source, target) for source, target in neighbors.items()]
+
+    graph = nx.Graph()
+    graph.add_edges_from(edges)
+
+    component_mapper = {
+        j: i
+        for i, component in enumerate(nx.connected_components(graph))
+        for j in component
+    }
+
+    concated[cluster_col] = component_mapper
+
+    concated = _push_geom_col(concated)
+
+    n_gdfs = concated["i__"].unique()
+
+    if len(n_gdfs) == 1:
+        concated.index = orig_indices[0]
+        return concated.drop(["i__"], axis=1)
+
+    unconcated = ()
+    for i in n_gdfs:
+        gdf = concated[concated["i__"] == i]
+        gdf.index = orig_indices[i]
+        gdf = gdf.drop(["i__"], axis=1)
+        unconcated = unconcated + (gdf,)
+
+    return unconcated
+
+
 def eliminate_by_longest(
     gdf: GeoDataFrame,
     to_eliminate: GeoDataFrame,
@@ -213,146 +356,6 @@ def _eliminate_by_area(
     return eliminated
 
 
-def get_polygon_clusters(
-    *gdfs: GeoDataFrame | GeoSeries,
-    cluster_col: str = "cluster",
-    allow_multipart: bool = False,
-) -> GeoDataFrame | tuple[GeoDataFrame]:
-    """Find which polygons overlap without dissolving.
-
-    Devides polygons into clusters in a fast and precice manner by using spatial join
-    and networkx to find the connected components, i.e. overlapping geometries.
-    If multiple GeoDataFrames are given, the clusters will be based on all
-    combined.
-
-    This can be used instead of dissolve+explode, or before dissolving by the cluster
-    column. This has been tested to be a lot faster if there are many
-    non-overlapping polygons, but somewhat slower than dissolve+explode if most
-    polygons overlap.
-
-    Args:
-        gdfs: One or more GeoDataFrames of polygons.
-        cluster_col: Name of the resulting cluster column.
-        allow_multipart: Whether to allow mutipart geometries in the gdfs.
-            Defaults to False to avoid confusing results.
-
-    Returns:
-        One or more GeoDataFrames (same amount as was given) with a new cluster column.
-
-    Examples
-    --------
-
-    Create geometries with three clusters of overlapping polygons.
-
-    >>> import sgis as sg
-    >>> gdf = sg.to_gdf([(0, 0), (1, 1), (0, 1), (4, 4), (4, 3), (7, 7)])
-    >>> buffered = sg.buff(gdf, 1)
-    >>> gdf
-                                                geometry
-    0  POLYGON ((1.00000 0.00000, 0.99951 -0.03141, 0...
-    1  POLYGON ((2.00000 1.00000, 1.99951 0.96859, 1....
-    2  POLYGON ((1.00000 1.00000, 0.99951 0.96859, 0....
-    3  POLYGON ((5.00000 4.00000, 4.99951 3.96859, 4....
-    4  POLYGON ((5.00000 3.00000, 4.99951 2.96859, 4....
-    5  POLYGON ((8.00000 7.00000, 7.99951 6.96859, 7....
-
-    Add a cluster column to the GeoDataFrame:
-
-    >>> gdf = sg.get_polygon_clusters(gdf, cluster_col="cluster")
-    >>> gdf
-       cluster                                           geometry
-    0        0  POLYGON ((1.00000 0.00000, 0.99951 -0.03141, 0...
-    1        0  POLYGON ((2.00000 1.00000, 1.99951 0.96859, 1....
-    2        0  POLYGON ((1.00000 1.00000, 0.99951 0.96859, 0....
-    3        1  POLYGON ((5.00000 4.00000, 4.99951 3.96859, 4....
-    4        1  POLYGON ((5.00000 3.00000, 4.99951 2.96859, 4....
-    5        2  POLYGON ((8.00000 7.00000, 7.99951 6.96859, 7....
-
-    If multiple GeoDataFrames are given, all are returned with common
-    cluster values.
-
-    >>> gdf2 = sg.to_gdf([(0, 0), (7, 7)])
-    >>> gdf, gdf2 = sg.get_polygon_clusters(gdf, gdf2, cluster_col="cluster")
-    >>> gdf2
-       cluster                 geometry
-    0        0  POINT (0.00000 0.00000)
-    1        2  POINT (7.00000 7.00000)
-    >>> gdf
-       cluster                                           geometry
-    0        0  POLYGON ((1.00000 0.00000, 0.99951 -0.03141, 0...
-    1        0  POLYGON ((2.00000 1.00000, 1.99951 0.96859, 1....
-    2        0  POLYGON ((1.00000 1.00000, 0.99951 0.96859, 0....
-    3        1  POLYGON ((5.00000 4.00000, 4.99951 3.96859, 4....
-    4        1  POLYGON ((5.00000 3.00000, 4.99951 2.96859, 4....
-    5        2  POLYGON ((8.00000 7.00000, 7.99951 6.96859, 7....
-
-    Dissolving 'by' the cluster column will make the dissolve much
-    faster if there are a lot of non-overlapping polygons.
-
-    >>> dissolved = gdf.dissolve(by="cluster", as_index=False)
-    >>> dissolved
-       cluster                                           geometry
-    0        0  POLYGON ((0.99951 -0.03141, 0.99803 -0.06279, ...
-    1        1  POLYGON ((4.99951 2.96859, 4.99803 2.93721, 4....
-    2        2  POLYGON ((8.00000 7.00000, 7.99951 6.96859, 7....
-    """
-    if isinstance(gdfs[-1], str):
-        *gdfs, cluster_col = gdfs
-
-    concated = pd.DataFrame()
-    orig_indices = ()
-    for i, gdf in enumerate(gdfs):
-        if isinstance(gdf, GeoSeries):
-            gdf = gdf.to_frame()
-
-        if not isinstance(gdf, GeoDataFrame):
-            raise TypeError("'gdfs' should be one or more GeoDataFrames or GeoSeries.")
-
-        if not allow_multipart and len(gdf) != len(gdf.explode(index_parts=False)):
-            raise ValueError(
-                "All geometries should be exploded to singlepart "
-                "in order to get correct polygon clusters. "
-                "To allow multipart geometries, set allow_multipart=True"
-            )
-
-        orig_indices = orig_indices + (gdf.index,)
-        gdf["i__"] = i
-
-        concated = pd.concat([concated, gdf], ignore_index=True)
-
-    neighbors = get_neighbor_indices(concated, concated)
-
-    edges = [(source, target) for source, target in neighbors.items()]
-
-    graph = nx.Graph()
-    graph.add_edges_from(edges)
-
-    component_mapper = {
-        j: i
-        for i, component in enumerate(nx.connected_components(graph))
-        for j in component
-    }
-
-    concated[cluster_col] = component_mapper
-
-    concated = _push_geom_col(concated)
-
-    n_gdfs = concated["i__"].unique()
-
-    if len(n_gdfs) == 1:
-        concated.index = orig_indices[0]
-        return concated.drop(["i__"], axis=1)
-
-    unconcated = ()
-    for i in n_gdfs:
-        gdf = concated[concated["i__"] == i]
-        gdf.index = orig_indices[i]
-        gdf = gdf.drop(["i__"], axis=1)
-        unconcated = unconcated + (gdf,)
-
-    return unconcated
-
-
 def get_overlapping_polygons(
     gdf: GeoDataFrame | GeoSeries, ignore_index: bool = False
 ) -> GeoDataFrame | GeoSeries:
@@ -457,21 +460,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 +480,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 +496,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 +551,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 +573,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 +633,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

@@ -3,9 +3,10 @@ from collections.abc import Iterator, Sized
 
 import geopandas as gpd
 import pandas as pd
+import shapely
 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
 
@@ -128,7 +129,7 @@ def to_gdf(
         raise TypeError("'to_gdf' doesn't accept GeoDataFrames as input type.")
 
     if isinstance(geom, GeoSeries):
-        geom_col = "geometry" if not geometry else geometry
+        geom_col = geometry if geometry else "geometry"
         return _geoseries_to_gdf(geom, geom_col, crs, **kwargs)
 
     geom_col = _find_geometry_column(geom, geometry)
@@ -144,8 +145,26 @@ def to_gdf(
         return GeoDataFrame({geom_col: geom}, geometry=geom_col, crs=crs, **kwargs)
 
     if not is_dict_like(geom):
-        geom = GeoSeries(_make_shapely_geoms(geom), index=index)
-        return GeoDataFrame({geom_col: geom}, geometry=geom_col, crs=crs, **kwargs)
+        if not hasattr(geom, "__iter__") and hasattr(geom, "__dict__"):
+            if all(attr in geom.__dict__ for attr in ["minx", "miny", "maxx", "maxy"]):
+                geom = GeoSeries(
+                    shapely.box(*(geom.minx, geom.miny, geom.maxx, geom.maxy)),
+                    index=index,
+                )
+                return GeoDataFrame(
+                    {geom_col: geom}, geometry=geom_col, crs=crs, **kwargs
+                )
+        if hasattr(geom, "__iter__") and all(isinstance(g, dict) for g in geom):
+            crs = crs if crs else _get_crs(geom)
+            geom = pd.concat(GeoSeries(_from_json(g)) for g in geom)
+            if index is not None:
+                geom.index = index
+            else:
+                geom = geom.reset_index(drop=True)
+            return GeoDataFrame({geom_col: geom}, geometry=geom_col, crs=crs, **kwargs)
+        else:
+            geom = GeoSeries(_make_shapely_geoms(geom), index=index)
+            return GeoDataFrame({geom_col: geom}, geometry=geom_col, crs=crs, **kwargs)
 
     # now we have dict, Series or DataFrame
 
@@ -168,6 +187,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)
@@ -175,10 +196,61 @@ def to_gdf(
     if geometry and geom_col not in geom or isinstance(geom, pd.DataFrame):
         raise ValueError("Cannot find geometry column(s)", geometry)
 
+    # geojson, __geo_interface__
+    if (
+        isinstance(geom, dict)
+        and sum(key in geom for key in ["type", "coordinates", "features"]) >= 2
+    ):
+        if "geometry" in geom:
+            geometry = "geometry"
+
+        crs = crs if crs else _get_crs(geom)
+        print(crs)
+        geom = GeoSeries(_from_json(geom), index=index)
+        return GeoDataFrame({geom_col: geom}, geometry=geom_col, crs=crs, **kwargs)
+
     geoseries = _series_like_to_geoseries(geom, index=index)
     return GeoDataFrame(geometry=geoseries, crs=crs, **kwargs)
 
 
+def _get_crs(geom):
+    if not is_dict_like(geom) and is_dict_like(geom[0]):
+        crss = list({_get_crs(g) for g in geom})
+        if len(crss) == 1:
+            return crss[0]
+        return None
+    if "properties" in geom:
+        return _get_crs(geom["properties"])
+    if "crs" in geom:
+        geom = geom["crs"]
+        while is_dict_like(geom):
+            if "properties" in geom:
+                geom = geom["properties"]
+            elif "name" in geom:
+                geom = geom["name"]
+            else:
+                return None
+        return geom
+    return None
+
+
+def _from_json(geom: dict):
+    if not isinstance(geom, dict) and isinstance(geom[0], dict):
+        return [_from_json(g) for g in geom]
+    if "geometry" in geom:
+        return _from_json(geom["geometry"])
+    if "features" in geom:
+        return _from_json(geom["features"])
+    coords = geom["coordinates"]
+    constructor = eval("shapely.geometry." + geom.get("type", Point))
+    try:
+        return constructor(coords)
+    except TypeError:
+        while len(coords) == 1:
+            coords = coords[0]
+        return constructor(coords)
+
+
 def _series_like_to_geoseries(geom, index):
     if index is None:
         index = geom.keys()
@@ -250,6 +322,8 @@ def _is_one_geometry(geom) -> bool:
 def _make_shapely_geoms(geom):
     if _is_one_geometry(geom):
         return _make_one_shapely_geom(geom)
+    if isinstance(geom, dict) and "coordinates" in geom:
+        return _from_json(geom)
     return (_make_one_shapely_geom(g) for g in geom)
 
 
@@ -292,9 +366,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/helpers.py

@@ -58,9 +58,9 @@ def get_name(var: object, n: int = 5) -> str | None:
     frame = inspect.currentframe().f_back.f_back
 
     for _ in range(n):
-        locals_ = frame.f_locals
-
-        names = [var_name for var_name, var_val in locals_.items() if var_val is var]
+        names = [
+            var_name for var_name, var_val in frame.f_locals.items() if var_val is var
+        ]
         if names and len(names) == 1:
             return names[0]
 

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/explore.py

@@ -4,6 +4,7 @@ This module holds the Explore class, which is the basis for the explore, samplem
 clipmap functions from the 'maps' module.
 """
 import warnings
+from numbers import Number
 from statistics import mean
 
 import branca as bc
@@ -15,10 +16,11 @@ from folium import plugins
 from geopandas import GeoDataFrame
 from IPython.display import display
 from jinja2 import Template
+from shapely import Geometry
 from shapely.geometry import LineString
 
 from ..geopandas_tools.general import clean_geoms, make_all_singlepart
-from ..geopandas_tools.geometry_types import get_geom_type
+from ..geopandas_tools.geometry_types import get_geom_type, to_single_geom_type
 from ..geopandas_tools.to_geodataframe import to_gdf
 from ..helpers import unit_is_degrees
 from .httpserver import run_html_server
@@ -110,6 +112,17 @@ class Explore(Map):
 
         super().__init__(*gdfs, column=column, **kwargs)
 
+        # remove columns not renerable by leaflet (list columns etc.)
+        new_gdfs = []
+        for gdf in self.gdfs:
+            cols_to_keep = [
+                col
+                for col in gdf.columns
+                if isinstance(gdf[col].iloc[0], (Number, str, Geometry))
+            ]
+            new_gdfs.append(gdf[cols_to_keep])
+        self._gdfs = new_gdfs
+
         self.popup = popup
         self.max_zoom = max_zoom
         self.smooth_factor = smooth_factor
@@ -266,6 +279,7 @@ class Explore(Map):
 
         new_gdfs = []
         for gdf in self._gdfs:
+            print(gdf)
             if get_geom_type(gdf) == "mixed" and not unit_is_degrees(gdf):
                 gdf[gdf._geometry_column_name] = gdf.buffer(0.01)
             gdf = make_all_singlepart(gdf)
@@ -615,7 +629,26 @@ class Explore(Map):
                     "supported as marker values"
                 )
 
-        gdf = clean_geoms(gdf)
+        gdf = clean_geoms(gdf).pipe(make_all_singlepart)
+        if get_geom_type(gdf) == "mixed":
+            if gdf.geom_type.str.lower().str.contains("polygon").any():
+                warnings.warn(
+                    "GeoJsonTooltip is not configured to render for GeoJson "
+                    "GeometryCollection geometries. Keeping only polygons."
+                )
+                gdf = to_single_geom_type(gdf, geom_type="polygon")
+            elif gdf.geom_type.str.lower().str.contains("line").any():
+                warnings.warn(
+                    "GeoJsonTooltip is not configured to render for GeoJson "
+                    "GeometryCollection geometries. Keeping only lines."
+                )
+                gdf = to_single_geom_type(gdf, geom_type="line")
+            else:
+                warnings.warn(
+                    "GeoJsonTooltip is not configured to render for GeoJson "
+                    "GeometryCollection geometries. Keeping only points."
+                )
+                gdf = to_single_geom_type(gdf, geom_type="point")
 
         # prepare tooltip and popup
         if isinstance(gdf, GeoDataFrame):

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.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ssb-sgis
-Version: 0.2.6
+Version: 0.2.8
 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.8.dist-info}/RECORD

@@ -1,21 +1,22 @@
-sgis/__init__.py,sha256=7XYr7wiJ4lw4lQDSj7B2JhLzREA_sgw3_CuqWaJf9b8,2334
+sgis/__init__.py,sha256=84lCHfBsH9nHwopwoPTMNHs1FvTWemuRPLALAhUEFIA,2445
 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
-sgis/geopandas_tools/buffer_dissolve_explode.py,sha256=46uBomQJMDFtGWVNZWyZLl-NLMwYyhr4wWkwj6BTxoo,8080
-sgis/geopandas_tools/general.py,sha256=BGBXobFRFl9fmFF-vRkkrcA2xHKGy4hylOEC4y4Ooto,17659
+sgis/geopandas_tools/buffer_dissolve_explode.py,sha256=JHFdhFVURHKAW9NraQZ7YEtvp_lBveGdL0PkBZn1fuE,8780
+sgis/geopandas_tools/general.py,sha256=Hbk1A_aFH_xgD_TkvaJQDW1U2lJYh-LHI9CmsPTkHaI,17930
 sgis/geopandas_tools/geometry_types.py,sha256=o3MbBP-aI7hVWWKVr_5p91TDhjiqZ_2IGxJq7SxlCT4,5870
 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/helpers.py,sha256=OqTojkSl-JVKlJzqqB-d_0CH6mk7_LS1DkiIjp1gD8E,2674
+sgis/geopandas_tools/polygon_operations.py,sha256=84AGRHKZR-3zKKVDNbKYCziC9YNUVm2qUEpfRvmIdn4,22635
+sgis/geopandas_tools/to_geodataframe.py,sha256=qtbeiQ9rPcM9afopNPzlN2fiMH5o6SoIYDotX6e_E0Q,12458
+sgis/helpers.py,sha256=6tElQx9Rr3nbQPp_vAgugw-pNHNuYQO-Ta2311_EcWs,2669
 sgis/maps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sgis/maps/explore.py,sha256=mab8LE8c_dsGwS1gVCCA2A3r5_Vh7hnzEfEs5MBadvE,23631
+sgis/maps/examine.py,sha256=Wf48WwyNyPC1vYdw-n7GpvJYhwd-YMd_VZLOUI5vWZ4,6479
+sgis/maps/explore.py,sha256=d16h8hHyUeSfsrAWdeFUPK6XT6S7-xr1w4_cHu2XA_I,25138
 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.8.dist-info/LICENSE,sha256=lL2h0dNKGTKAE0CjTy62SDbRennVD1xPgM5LzGqhKeo,1074
+ssb_sgis-0.2.8.dist-info/METADATA,sha256=hR3yvnhqhsaE8jEvutRwNHAFJq78Hhua5JodgYX99mE,8831
+ssb_sgis-0.2.8.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+ssb_sgis-0.2.8.dist-info/RECORD,,