ssb-sgis 1.3.5__py3-none-any.whl → 1.3.8__py3-none-any.whl

sgis/geopandas_tools/conversion.py

@@ -67,7 +67,7 @@ def to_geoseries(obj: Any, crs: Any | None = None) -> GeoSeries:
             # pandas objects
             index = obj.index
         else:
-            # list
+            # list (has method 'index')
             index = None
     except AttributeError:
         index = None

sgis/geopandas_tools/duplicates.py

@@ -38,8 +38,9 @@ def update_geometries(
 ) -> GeoDataFrame:
     """Puts geometries on top of each other rowwise.
 
-    Since this operation is done rowwise, it's important to
-    first sort the GeoDataFrame approriately. See example below.
+    IMPORTANT: Since this operation is done rowwise, meaning the top rows
+    are put on top of bottommore rows, it is important to first sort the
+    GeoDataFrame approriately. See examples below.
 
     Args:
         gdf: The GeoDataFrame to be updated.
@@ -63,6 +64,22 @@ def update_geometries(
 
     Example:
     --------
+    Create some overlapping circles and update the geometries based on area.
+    Sorting the data small to large might be the appropriate choice if you want to keep all details
+    in the coverage and the data has no attributes that should be given priority over another.
+
+    >>> coords = [(0, 0), (0, 1), (1, 1), (1, 0)]
+    >>> buffers = [0.9, 1.3, 0.7, 1.1]
+    >>> circles = sg.to_gdf(coords)
+    >>> circles["geometry"] = circles["geometry"].buffer(buffers)
+    >>> updated_smallest_first = sg.update_geometries(sg.sort_small_first(circles))
+    >>> updated_largest_first = sg.update_geometries(sg.sort_large_first(circles))
+    >>> sg.explore(circles, updated_smallest_first, updated_largest_first, tiles=["dark"])
+
+    If you want to prioritize geometries based on attributes,
+
+    >>> circles["hva"] = ["skog", "elv", "bro", "tunnel"]
+
     Create two circles and get the overlap.
 
     >>> import sgis as sg
@@ -123,7 +140,7 @@ def update_geometries(
     )
 
     geom_col = copied._geometry_column_name
-    index_mapper = {i: idx for i, idx in enumerate(copied.index)}
+    index_mapper = dict(enumerate(copied.index))
     copied = copied.reset_index(drop=True)
 
     left, right = rtree_runner.run(

sgis/geopandas_tools/general.py

@@ -688,8 +688,7 @@ def _split_lines_by_points_along_line(lines, points, splitted_col: str | None =
     relevant_lines.geometry = shapely.force_2d(relevant_lines.geometry)
     points.geometry = shapely.force_2d(points.geometry)
 
-    # split the lines with buffer + difference, since shaply.split usually doesn't work
-    # relevant_lines["_idx"] = range(len(relevant_lines))
+    # split the lines with tiny buffer + difference, since shaply.split usually doesn't work
     splitted = relevant_lines.overlay(points_buff, how="difference").explode(
         ignore_index=True
     )
@@ -703,8 +702,9 @@ def _split_lines_by_points_along_line(lines, points, splitted_col: str | None =
     if not len(splitted):
         return pd.concat([the_other_lines, circles], ignore_index=True)
 
-    # the endpoints of the new lines are now sligtly off. Using get_k_nearest_neighbors
-    # to get the exact snapped point coordinates, . This will map the sligtly
+    # the endpoints of the new lines are now sligtly off because of the buffer.
+    # Using get_k_nearest_neighbors
+    # to get the exact snapped point coordinates. This will map the sligtly
     # wrong line endpoints with the point the line was split by.
 
     points["point_coords"] = [(geom.x, geom.y) for geom in points.geometry]
@@ -721,7 +721,6 @@ def _split_lines_by_points_along_line(lines, points, splitted_col: str | None =
             lambda x: x["distance"] <= precision * 2
         ]
 
-    # points = points.set_index("point_coords")
     points.index = points.geometry
     dists_source = get_nearest(splitted_source, points)
     dists_target = get_nearest(splitted_target, points)
@@ -828,16 +827,21 @@ def make_edge_coords_cols(gdf: GeoDataFrame) -> GeoDataFrame:
     Returns:
         A GeoDataFrame with new columns 'source_coords' and 'target_coords'
     """
+    if not gdf.index.is_unique:
+        index_mapper = dict(enumerate(gdf.index))
+        gdf = gdf.reset_index(drop=True)
+    else:
+        index_mapper = None
     try:
         gdf, endpoints = _prepare_make_edge_cols_simple(gdf)
     except ValueError:
         gdf, endpoints = _prepare_make_edge_cols(gdf)
 
-    coords = [(geom.x, geom.y) for geom in endpoints.geometry]
-    gdf["source_coords"], gdf["target_coords"] = (
-        coords[0::2],
-        coords[1::2],
-    )
+    gdf["source_coords"] = endpoints.groupby(level=0).first()
+    gdf["target_coords"] = endpoints.groupby(level=0).last()
+
+    if index_mapper is not None:
+        gdf.index = gdf.index.map(index_mapper)
 
     return gdf
 
@@ -855,19 +859,22 @@ def make_edge_wkt_cols(gdf: GeoDataFrame) -> GeoDataFrame:
     Returns:
         A GeoDataFrame with new columns 'source_wkt' and 'target_wkt'
     """
+    if not gdf.index.is_unique:
+        index_mapper = dict(enumerate(gdf.index))
+        gdf = gdf.reset_index(drop=True)
+    else:
+        index_mapper = None
     try:
         gdf, endpoints = _prepare_make_edge_cols_simple(gdf)
     except ValueError:
         gdf, endpoints = _prepare_make_edge_cols(gdf)
 
-    wkt_geom = [
-        f"POINT ({x} {y})" for x, y in zip(endpoints.x, endpoints.y, strict=True)
-    ]
-    gdf["source_wkt"], gdf["target_wkt"] = (
-        wkt_geom[0::2],
-        wkt_geom[1::2],
-    )
+    endpoints = endpoints.force_2d().to_wkt()
+    gdf["source_wkt"] = endpoints.groupby(level=0).first()
+    gdf["target_wkt"] = endpoints.groupby(level=0).last()
 
+    if index_mapper is not None:
+        gdf.index = gdf.index.map(index_mapper)
     return gdf
 
 
@@ -889,18 +896,16 @@ def _prepare_make_edge_cols(lines: GeoDataFrame) -> tuple[GeoDataFrame, GeoDataF
                 "Try using: to_single_geom_type(gdf, 'lines')."
             )
 
-    geom_col = lines._geometry_column_name
-
     # some LineStrings are in fact rings and must be removed manually
     lines, _ = split_out_circles(lines)
 
-    endpoints = lines[geom_col].boundary.explode(ignore_index=True)
+    endpoints = lines.geometry.boundary.explode(ignore_index=False)
 
     if len(lines) and len(endpoints) / len(lines) != 2:
         raise ValueError(
             "The lines should have only two endpoints each. "
             "Try splitting multilinestrings with explode.",
-            lines[geom_col],
+            lines.geometry,
         )
 
     return lines, endpoints
@@ -910,7 +915,7 @@ def _prepare_make_edge_cols_simple(
     lines: GeoDataFrame,
 ) -> tuple[GeoDataFrame, GeoDataFrame]:
     """Faster version of _prepare_make_edge_cols."""
-    endpoints = lines[lines._geometry_column_name].boundary.explode(ignore_index=True)
+    endpoints = lines.geometry.boundary.explode(ignore_index=False)
 
     if len(lines) and len(endpoints) / len(lines) != 2:
         raise ValueError(

sgis/geopandas_tools/point_operations.py

@@ -5,12 +5,15 @@ import pandas as pd
 from geopandas import GeoDataFrame
 from geopandas import GeoSeries
 from shapely import distance
-from shapely import union_all
 from shapely.ops import nearest_points
 
+from ..conf import _get_instance
+from ..conf import config
+from ..geopandas_tools.conversion import to_geoseries
 from ..geopandas_tools.geometry_types import get_geom_type
 from ..geopandas_tools.geometry_types import to_single_geom_type
 from ..geopandas_tools.polygon_operations import PolygonsAsRings
+from ..geopandas_tools.runners import RTreeQueryRunner
 
 
 def snap_within_distance(
@@ -19,6 +22,8 @@ def snap_within_distance(
     max_distance: int | float,
     *,
     distance_col: str | None = None,
+    n_jobs: int = 1,
+    rtree_runner: RTreeQueryRunner | None = None,
 ) -> GeoDataFrame | GeoSeries:
     """Snaps points to nearest geometry if within given distance.
 
@@ -33,6 +38,9 @@ def snap_within_distance(
         distance_col: Name of column with the snap distance. Defaults to
             'snap_distance'. Set to None to not get any distance column. This will make
             the function a bit faster.
+        n_jobs: Number of workers.
+        rtree_runner: Optionally debug/manipulate the spatial indexing operations.
+            See the 'runners' module for example implementations.
 
     Returns:
         A GeoDataFrame or GeoSeries with the points snapped to the nearest point in the
@@ -80,22 +88,31 @@ def snap_within_distance(
     """
     to = _polygons_to_rings(to)
 
+    if not isinstance(to, GeoSeries):
+        to = to_geoseries(to)
+
     if not distance_col and not isinstance(points, GeoDataFrame):
         return _shapely_snap(
             points=points,
-            to=to,
+            to=to.values,
             max_distance=max_distance,
+            rtree_runner=rtree_runner,
+            n_jobs=n_jobs,
         )
-    elif not isinstance(points, GeoDataFrame):
-        points = points.to_frame()
 
     copied = points.copy()
 
-    copied.geometry = _shapely_snap(
-        points=copied.geometry.values,
-        to=to,
+    snapped = _shapely_snap(
+        points=copied.geometry,
+        to=to.values,
         max_distance=max_distance,
+        rtree_runner=rtree_runner,
+        n_jobs=n_jobs,
     )
+    if isinstance(copied, GeoSeries):
+        copied = snapped.to_frame("geometry")
+    else:
+        copied.geometry = snapped
 
     if distance_col:
         copied[distance_col] = copied.distance(points)
@@ -111,6 +128,8 @@ def snap_all(
     to: GeoDataFrame | GeoSeries,
     *,
     distance_col: str | None = None,
+    n_jobs: int = 1,
+    rtree_runner: RTreeQueryRunner | None = None,
 ) -> GeoDataFrame | GeoSeries:
     """Snaps points to the nearest geometry.
 
@@ -121,6 +140,9 @@ def snap_all(
         points: The GeoDataFrame of points to snap.
         to: The GeoDataFrame to snap to.
         distance_col: Name of column with the snap distance. Defaults to None.
+        n_jobs: Number of workers.
+        rtree_runner: Optionally debug/manipulate the spatial indexing operations.
+            See the 'runners' module for example implementations.
 
     Returns:
         A GeoDataFrame or GeoSeries with the points snapped to the nearest point in the
@@ -159,30 +181,15 @@ def snap_all(
     0  POINT (2.00000 2.00000)       2.828427
     1  POINT (2.00000 2.00000)       1.414214
     """
-    to = _polygons_to_rings(to)
-
-    if not isinstance(points, GeoDataFrame):
-        return _shapely_snap(
-            points=points,
-            to=to,
-            max_distance=None,
-        )
-
-    copied = points.copy()
-
-    copied.geometry = _shapely_snap(
-        points=copied.geometry.values,
-        to=to,
+    return snap_within_distance(
+        points,
+        to,
         max_distance=None,
+        distance_col=distance_col,
+        rtree_runner=rtree_runner,
+        n_jobs=n_jobs,
     )
 
-    if distance_col:
-        copied[distance_col] = copied.distance(points)
-        copied[distance_col] = np.where(
-            copied[distance_col] == 0, pd.NA, copied[distance_col]
-        )
-    return copied
-
 
 def _polygons_to_rings(gdf: GeoDataFrame) -> GeoDataFrame:
     if get_geom_type(gdf) == "polygon":
@@ -197,17 +204,19 @@ def _polygons_to_rings(gdf: GeoDataFrame) -> GeoDataFrame:
 
 def _shapely_snap(
     points: np.ndarray | GeoSeries,
-    to: GeoSeries | GeoDataFrame,
+    to: np.ndarray | GeoSeries,
+    *,
+    rtree_runner: RTreeQueryRunner | None,
+    n_jobs: int,
     max_distance: int | float | None = None,
 ) -> GeoSeries:
-    try:
-        unioned = union_all(to.geometry.values)
-    except AttributeError:
-        unioned = union_all(to)
+    if rtree_runner is None:
+        rtree_runner = _get_instance(config, "rtree_runner", n_jobs=n_jobs)
 
-    nearest = nearest_points(points, unioned)[1]
+    nearest_indices = rtree_runner.run(points, to, method="nearest")
+    nearest = nearest_points(points, to[nearest_indices])[1]
 
-    if not max_distance:
+    if max_distance is None:
         return nearest
 
     distances = distance(points, nearest)
@@ -219,6 +228,6 @@ def _shapely_snap(
     )
 
     if isinstance(points, GeoSeries):
-        return GeoSeries(points, crs=points.crs, index=points.index, name=points.name)
+        return GeoSeries(snapped, crs=points.crs, index=points.index, name=points.name)
 
     return points.__class__(snapped)

sgis/geopandas_tools/runners.py

@@ -177,10 +177,16 @@ def _strtree_query(
 ):
     tree = STRtree(arr2)
     func = getattr(tree, method)
-    left, right = func(arr1, **kwargs)
+    results = func(arr1, **kwargs)
+    if results.ndim == 2:
+        left, right = results
+    else:
+        left = results
     if indices1 is not None:
         index_mapper1 = {i: x for i, x in enumerate(indices1)}
         left = np.array([index_mapper1[i] for i in left])
+    if results.ndim == 1:
+        return left
     if indices2 is not None:
         index_mapper2 = {i: x for i, x in enumerate(indices2)}
         right = np.array([index_mapper2[i] for i in right])
@@ -228,9 +234,11 @@ class RTreeQueryRunner(AbstractRunner):
                     )
                     for chunk in chunks
                 )
-            left = np.concatenate([x[0] for x in results])
-            right = np.concatenate([x[1] for x in results])
-            return left, right
+            results = np.concatenate(results)
+            if results.ndim == 2:
+                left, right = results
+                return left, right
+            return results
         elif (
             (self.n_jobs or 1) > 1
             and len(arr2) / self.n_jobs > 10_000
@@ -248,9 +256,11 @@ class RTreeQueryRunner(AbstractRunner):
                     )
                     for chunk in chunks
                 )
-            left = np.concatenate([x[0] for x in results])
-            right = np.concatenate([x[1] for x in results])
-            return left, right
+            results = np.concatenate(results)
+            if results.ndim == 2:
+                left, right = results
+                return left, right
+            return results
 
         return _strtree_query(arr1, arr2, method=method, **kwargs)
 

sgis/io/dapla_functions.py

@@ -121,7 +121,7 @@ def read_geopandas(
             ).replace("==", "=")
             glob_func = _get_glob_func(file_system)
             suffix: str = Path(gcs_path).suffix
-            paths = glob_func(str(Path(gcs_path) / expression / f"*{suffix}"))
+            paths = glob_func(_standardize_path(gcs_path) + f"/{expression}/*{suffix}")
             if paths:
                 return _read_geopandas_from_iterable(
                     paths,
@@ -256,7 +256,7 @@ def _read_pyarrow(path: str, file_system, mask=None, **kwargs) -> pyarrow.Table
         if not len(
             {
                 x
-                for x in glob_func(str(Path(path) / "**"))
+                for x in glob_func(str(_standardize_path(path) + "/**"))
                 if not paths_are_equal(path, x)
             }
         ):
@@ -618,7 +618,7 @@ def _write_partitioned_geoparquet(
             as_partition_part(col, value)
             for col, value in zip(partition_cols, group, strict=True)
         )
-        paths.append(Path(path) / partition_parts)
+        paths.append(_standardize_path(path) + f"/{partition_parts}")
         dfs.append(rows)
 
     def threaded_write(rows: DataFrame, path: str) -> None:
@@ -626,7 +626,9 @@ def _write_partitioned_geoparquet(
             this_basename = (uuid.uuid4().hex + "-{i}.parquet").replace("-{i}", "0")
         else:
             this_basename = basename_template.replace("-{i}", "0")
-        for i, sibling_path in enumerate(sorted(glob_func(str(Path(path) / "**")))):
+        for i, sibling_path in enumerate(
+            sorted(glob_func(str(_standardize_path(path) + "/**")))
+        ):
             if paths_are_equal(sibling_path, path):
                 continue
             if existing_data_behavior == "delete_matching":
@@ -638,7 +640,7 @@ def _write_partitioned_geoparquet(
             else:
                 this_basename = basename_template.replace("-{i}", str(i + 1))
 
-        out_path = str(Path(path) / this_basename)
+        out_path = str(_standardize_path(path) + "/" + this_basename)
         try:
             with file_system.open(out_path, mode="wb") as file:
                 write_func(rows, file, schema=schema, **kwargs)
@@ -780,7 +782,7 @@ def _read_partitioned_parquet(
     glob_func = _get_glob_func(file_system)
 
     if child_paths is None:
-        child_paths = list(glob_func(str(Path(path) / "**/*.parquet")))
+        child_paths = list(glob_func(str(_standardize_path(path) + "/**/*.parquet")))
 
     filters = _filters_to_expression(filters)
 
@@ -830,7 +832,7 @@ def get_child_paths(path, file_system) -> list[str]:
     glob_func = _get_glob_func(file_system)
     return [
         x
-        for x in glob_func(str(Path(path) / "**/*.parquet"))
+        for x in glob_func(str(_standardize_path(path) + "/**/*.parquet"))
         if not paths_are_equal(x, path)
     ]
 
@@ -938,3 +940,8 @@ def _maybe_strip_prefix(path, file_system):
     if isinstance(file_system, GCSFileSystem) and path.startswith("gs://"):
         return path.replace("gs://", "")
     return path
+
+
+def _standardize_path(path: str | Path) -> str:
+    """Make sure delimiter is '/' and path ends without '/'."""
+    return str(path).replace("\\", "/").replace(r"\"", "/")

sgis/networkanalysis/_od_cost_matrix.py

@@ -1,10 +1,12 @@
+from collections.abc import Iterable
+
 import geopandas as gpd
 import numpy as np
 import pandas as pd
+import shapely
 from geopandas import GeoDataFrame
 from igraph import Graph
 from pandas import DataFrame
-from shapely import shortest_line
 
 
 def _od_cost_matrix(
@@ -24,90 +26,49 @@ def _od_cost_matrix(
     # calculating all-to-all distances is much faster than looping rowwise,
     # so filtering to rowwise afterwards instead
     if rowwise:
-        rowwise_df = DataFrame(
-            {
-                "origin": origins.index,
-                "destination": destinations.index,
-            }
+        keys = pd.MultiIndex.from_arrays(
+            [origins.index, destinations.index],
+            names=["origin", "destination"],
         )
-        results = rowwise_df.merge(results, on=["origin", "destination"], how="left")
-
-    results["wkt_ori"] = results["origin"].map(origins.geometry)
-    results["wkt_des"] = results["destination"].map(destinations.geometry)
+        results = results.set_index(["origin", "destination"]).loc[keys].reset_index()
 
-    results.loc[results.wkt_ori == results.wkt_des, weight] = 0
+    results["geom_ori"] = results["origin"].map(origins.geometry)
+    results["geom_des"] = results["destination"].map(destinations.geometry)
 
     # straight lines between origin and destination
     if lines:
-        results["geometry"] = shortest_line(results["wkt_ori"], results["wkt_des"])
+        results["geometry"] = shapely.shortest_line(
+            results["geom_ori"], results["geom_des"]
+        )
         results = gpd.GeoDataFrame(results, geometry="geometry", crs=25833)
 
-    results = results.drop(["wkt_ori", "wkt_des"], axis=1, errors="ignore")
+    results.loc[
+        shapely.to_wkb(results["geom_ori"]) == shapely.to_wkb(results["geom_des"]),
+        weight,
+    ] = 0
 
-    return results.reset_index(drop=True)
+    return results.drop(["geom_ori", "geom_des"], axis=1, errors="ignore").reset_index(
+        drop=True
+    )
 
 
 def _get_od_df(
-    graph: Graph, origins: GeoDataFrame, destinations: GeoDataFrame, weight_col: str
+    graph: Graph, origins: Iterable[str], destinations: Iterable[str], weight_col: str
 ) -> pd.DataFrame:
     distances: list[list[float]] = graph.distances(
         weights="weight",
         source=origins,
         target=destinations,
+        algorithm="dijkstra",
     )
 
-    ori_idx, des_idx, costs = [], [], []
-    for i, f_idx in enumerate(origins):
-        for j, t_idx in enumerate(destinations):
-            ori_idx.append(f_idx)
-            des_idx.append(t_idx)
-            costs.append(distances[i][j])
-
-    return (
-        pd.DataFrame(
-            data={"origin": ori_idx, "destination": des_idx, weight_col: costs}
-        )
-        .replace([np.inf, -np.inf], np.nan)
-        .reset_index(drop=True)
+    costs = np.array(
+        [distances[i][j] for j in range(len(destinations)) for i in range(len(origins))]
     )
+    costs[(costs == np.inf) | (costs == -np.inf)] = np.nan
+    ori_idx = np.array([x for _ in range(len(destinations)) for x in origins])
+    des_idx = np.array([x for x in destinations for _ in range(len(origins))])
 
-
-def _get_one_od_df(
-    graph: Graph, origins: GeoDataFrame, destinations: GeoDataFrame, weight_col: str
-) -> pd.DataFrame:
-    distances: list[list[float]] = graph.distances(
-        weights="weight",
-        source=origins,
-        target=destinations,
+    return pd.DataFrame(
+        data={"origin": ori_idx, "destination": des_idx, weight_col: costs}
     )
-
-    ori_idx, des_idx, costs = [], [], []
-    for i, f_idx in enumerate(origins):
-        for j, t_idx in enumerate(destinations):
-            ori_idx.append(f_idx)
-            des_idx.append(t_idx)
-            costs.append(distances[i][j])
-
-    return (
-        pd.DataFrame(
-            data={"origin": ori_idx, "destination": des_idx, weight_col: costs}
-        )
-        .replace([np.inf, -np.inf], np.nan)
-        .reset_index(drop=True)
-    )
-
-
-# def _get_od_df(
-#     graph: Graph,
-#     origins: GeoDataFrame,
-#     destinations: GeoDataFrame,
-#     weight_col: str,
-# ) -> pd.DataFrame:
-#     from ..parallel.parallel import Parallel
-
-#     results: list[pd.DataFrame] = Parallel(40, backend="loky").map(
-#         _get_one_od_df,
-#         [origins[origins.index == i] for i in origins.index.unique()],
-#         kwargs=dict(graph=graph, destinations=destinations, weight_col=weight_col),
-#     )
-#     return pd.concat(results, ignore_index=True)

sgis/networkanalysis/_points.py

@@ -16,10 +16,7 @@ opposite directions.
 
 
 class Points:
-    def __init__(
-        self,
-        points: GeoDataFrame,
-    ) -> None:
+    def __init__(self, points: GeoDataFrame) -> None:
         self.gdf = points.copy()
 
     def _make_temp_idx(self, start: int) -> None:

sgis/networkanalysis/closing_network_holes.py

@@ -79,6 +79,7 @@ def close_network_holes(
     gdf: GeoDataFrame,
     max_distance: int | float,
     max_angle: int,
+    *,
     hole_col: str | None = "hole",
 ) -> GeoDataFrame:
     """Fills network gaps with straigt lines.
@@ -282,11 +283,13 @@ def _close_holes_all_lines(
 ) -> GeoSeries:
     k = min(len(nodes), 50)
 
+    n_dict = nodes.set_index("wkt")["n"]
+
     # make points for the deadends and the other endpoint of the deadend lines
-    deadends_target = lines.loc[lines["n_target"] == 1].rename(
+    deadends_target = lines.loc[lines["target_wkt"].map(n_dict) == 1].rename(
         columns={"target_wkt": "wkt", "source_wkt": "wkt_other_end"}
     )
-    deadends_source = lines.loc[lines["n_source"] == 1].rename(
+    deadends_source = lines.loc[lines["source_wkt"].map(n_dict) == 1].rename(
         columns={"source_wkt": "wkt", "target_wkt": "wkt_other_end"}
     )
     deadends = pd.concat([deadends_source, deadends_target], ignore_index=True)
@@ -349,12 +352,6 @@ def _close_holes_all_lines(
         to_idx = indices[condition]
         to_wkt = nodes.iloc[to_idx]["wkt"]
 
-        # all_angles = all_angles + [
-        #     diff
-        #     for f, diff in zip(from_wkt, angles_difference[condition], strict=True)
-        #     if f not in new_sources
-        # ]
-
         # now add the wkts to the lists of new sources and targets. If the source
         # is already added, the new wks will not be added again
         new_targets = new_targets + [

sgis/networkanalysis/finding_isolated_networks.py

@@ -57,9 +57,7 @@ def get_connected_components(gdf: GeoDataFrame) -> GeoDataFrame:
 
     gdf["connected"] = gdf.source.map(largest_component_dict).fillna(0)
 
-    gdf = gdf.drop(
-        ["source_wkt", "target_wkt", "source", "target", "n_source", "n_target"], axis=1
-    )
+    gdf = gdf.drop(["source_wkt", "target_wkt", "source", "target"], axis=1)
 
     return gdf
 
@@ -120,8 +118,6 @@ def get_component_size(gdf: GeoDataFrame) -> GeoDataFrame:
     gdf["component_index"] = gdf["source"].map(mapper["component_index"])
     gdf["component_size"] = gdf["source"].map(mapper["component_size"])
 
-    gdf = gdf.drop(
-        ["source_wkt", "target_wkt", "source", "target", "n_source", "n_target"], axis=1
-    )
+    gdf = gdf.drop(["source_wkt", "target_wkt", "source", "target"], axis=1)
 
     return gdf

sgis/networkanalysis/network.py

@@ -36,14 +36,12 @@ class Network:
             raise TypeError(f"'lines' should be GeoDataFrame, got {type(gdf)}")
 
         if not len(gdf):
-            raise ZeroLinesError
+            raise ZeroLinesError()
 
         self.gdf = self._prepare_network(gdf)
 
         self._make_node_ids()
 
-        self._percent_bidirectional = self._check_percent_bidirectional()
-
     def _make_node_ids(self) -> None:
         """Gives the lines node ids and return lines (edges) and nodes.
 
@@ -55,6 +53,7 @@ class Network:
             The lines must be singlepart linestrings.
         """
         self.gdf, self._nodes = make_node_ids(self.gdf)
+        self._percent_bidirectional = self._check_percent_bidirectional()
 
     @staticmethod
     def _prepare_network(gdf: GeoDataFrame) -> GeoDataFrame:
@@ -138,6 +137,8 @@ class Network:
         or any superfluous node-ids (meaning rows have been removed from the lines
         gdf).
         """
+        if not hasattr(self, "_nodes"):
+            return False
         new_or_missing = (~self.gdf.source.isin(self._nodes.node_id)) | (
             ~self.gdf.target.isin(self._nodes.node_id)
         )

sgis/networkanalysis/networkanalysis.py

@@ -20,6 +20,7 @@ from pandas import MultiIndex
 from shapely import force_2d
 
 from ..geopandas_tools.general import _push_geom_col
+from ..geopandas_tools.sfilter import sfilter_inverse
 from ._get_route import _get_k_routes
 from ._get_route import _get_route
 from ._get_route import _get_route_frequencies
@@ -30,6 +31,8 @@ from ._service_area import _service_area
 from .cutting_lines import split_lines_by_nearest_point
 from .network import Network
 from .networkanalysisrules import NetworkAnalysisRules
+from .nodes import _map_node_ids_from_wkt
+from .nodes import make_node_ids
 
 
 class NetworkAnalysis:
@@ -1372,15 +1375,14 @@ class NetworkAnalysis:
 
         self.origins = Origins(origins)
         self.origins._make_temp_idx(
-            start=max(self.network.nodes.node_id.astype(int)) + 1
+            start=max(self.network.nodes["node_id"].astype(int)) + 1
         )
 
         if destinations is not None:
             self.destinations = Destinations(destinations)
             self.destinations._make_temp_idx(
-                start=max(self.origins.gdf.temp_idx.astype(int)) + 1
+                start=max(self.origins.gdf["temp_idx"].astype(int)) + 1
             )
-
         else:
             self.destinations = None
 
@@ -1396,8 +1398,6 @@ class NetworkAnalysis:
                 directed=self.rules.directed,
             )
 
-            self._add_missing_vertices()
-
             self._graph_updated_count += 1
 
         self._update_wkts()
@@ -1413,7 +1413,6 @@ class NetworkAnalysis:
         """
         if self.rules.split_lines:
             self._split_lines()
-            self.network._make_node_ids()
             self.origins._make_temp_idx(
                 start=max(self.network.nodes.node_id.astype(int)) + 1
             )
@@ -1428,6 +1427,7 @@ class NetworkAnalysis:
 
         self.network.gdf["src_tgt_wt"] = self.network._create_edge_ids(edges, weights)
 
+        # add edges between origins+destinations to the network nodes
         edges_start, weights_start = self.origins._get_edges_and_weights(
             nodes=self.network.nodes,
             rules=self.rules,
@@ -1438,6 +1438,7 @@ class NetworkAnalysis:
         weights = weights + weights_start
 
         if self.destinations is None:
+            edges, weights = self._add_fake_edges(edges, weights)
             edge_ids = self.network._create_edge_ids(edges, weights)
             return edges, weights, edge_ids
 
@@ -1450,10 +1451,29 @@ class NetworkAnalysis:
         edges = edges + edges_end
         weights = weights + weights_end
 
+        edges, weights = self._add_fake_edges(edges, weights)
         edge_ids = self.network._create_edge_ids(edges, weights)
 
         return edges, weights, edge_ids
 
+    def _add_fake_edges(self, edges, weights):
+        """Add edges for origins and destinations to not get error in igraph because of non-existing nodes."""
+        nodes = {x[0] for x in edges} | {x[1] for x in edges}
+
+        fake_edges = [
+            (idx, idx)
+            for idx in list(self.origins.gdf["temp_idx"])
+            + list(
+                self.destinations.gdf["temp_idx"]
+                if self.destinations is not None
+                else []
+            )
+            if idx not in nodes
+        ]
+        edges = edges + fake_edges
+        weights = weights + [0 for _ in fake_edges]
+        return edges, weights
+
     def _split_lines(self) -> None:
         if self.destinations is not None:
             points = pd.concat(
@@ -1464,7 +1484,7 @@ class NetworkAnalysis:
 
         points = points.drop_duplicates(points.geometry.name)
 
-        self.network.gdf["meters_"] = self.network.gdf.length
+        self.network.gdf["_meters2"] = self.network.gdf.length
 
         # create an id from before the split, used to revert the split later
         self.network.gdf["temp_idx__"] = range(len(self.network.gdf))
@@ -1477,50 +1497,53 @@ class NetworkAnalysis:
         )
 
         # save the unsplit lines for later
-        splitted = lines.loc[lines["splitted"] == 1, "temp_idx__"]
+        splitted = lines.loc[lines["splitted"] == 1]
         self.network._not_splitted = self.network.gdf.loc[
-            self.network.gdf["temp_idx__"].isin(splitted)
+            lambda x: x["temp_idx__"].isin(splitted["temp_idx__"])
         ]
 
+        new_lines, new_nodes = make_node_ids(splitted)
+        new_nodes = sfilter_inverse(new_nodes, self.network.nodes.buffer(1e-5))
+        new_nodes["node_id"] = (
+            new_nodes["node_id"].astype(int) + len(self.network.nodes) + 1
+        ).astype(str)
+        self.network._new_node_ids = list(new_nodes["node_id"])
+
         # adjust weight to new length
-        lines[self.rules.weight] = lines[self.rules.weight] * (
-            lines.length / lines["meters_"]
+        new_lines[self.rules.weight] = new_lines[self.rules.weight] * (
+            new_lines.length / new_lines["_meters2"]
+        )
+        self.network._nodes = pd.concat(
+            [self.network._nodes, new_nodes],
+            ignore_index=True,
         )
 
+        lines = pd.concat(
+            [
+                self.network.gdf.loc[
+                    lambda x: ~x["temp_idx__"].isin(splitted["temp_idx__"])
+                ],
+                new_lines,
+            ],
+            ignore_index=True,
+        )
+
+        lines = _map_node_ids_from_wkt(lines, self.network._nodes)
+
         self.network.gdf = lines
 
     def _unsplit_network(self):
         """Remove the splitted lines and add the unsplitted ones."""
+        if not hasattr(self.network, "_not_splitted"):
+            return
         lines = self.network.gdf.loc[self.network.gdf["splitted"] != 1]
         self.network.gdf = pd.concat(
             [lines, self.network._not_splitted], ignore_index=True
         ).drop("temp_idx__", axis=1)
-        del self.network._not_splitted
-
-    def _add_missing_vertices(self):
-        """Adds the missing points.
-
-        Nodes that had no nodes within the search_tolerance are added to the graph.
-        To not get an error when running the distance calculation.
-        """
-        # TODO: either check if any() beforehand, or add fictional edges before
-        # making the graph, to make things faster
-        # (this method took 64.660 out of 500 seconds)
-        self.graph.add_vertices(
-            [
-                idx
-                for idx in self.origins.gdf["temp_idx"]
-                if idx not in self.graph.vs["name"]
-            ]
-        )
-        if self.destinations is not None:
-            self.graph.add_vertices(
-                [
-                    idx
-                    for idx in self.destinations.gdf["temp_idx"]
-                    if idx not in self.graph.vs["name"]
-                ]
-            )
+        self.network._nodes = self.network._nodes[
+            lambda x: ~x["node_id"].isin(self.network._new_node_ids)
+        ]
+        del self.network._not_splitted, self.network._new_node_ids
 
     @staticmethod
     def _make_graph(
@@ -1530,10 +1553,8 @@ class NetworkAnalysis:
         directed: bool,
     ) -> Graph:
         """Creates an igraph Graph from a list of edges and weights."""
-        assert len(edges) == len(weights)
-
+        assert len(edges) == len(weights) == len(edge_ids)
         graph = igraph.Graph.TupleList(edges, directed=directed)
-
         graph.es["weight"] = weights
         graph.es["src_tgt_wt"] = edge_ids
         graph.es["edge_tuples"] = edges
@@ -1566,7 +1587,7 @@ class NetworkAnalysis:
         for points in ["origins", "destinations"]:
             if self[points] is None:
                 continue
-            if points not in self.wkts:
+            if not hasattr(self, points) or self[points] is None:
                 return False
             if self._points_have_changed(self[points].gdf, what=points):
                 return False
@@ -1596,8 +1617,6 @@ class NetworkAnalysis:
         """
         self.wkts = {}
 
-        self.wkts["network"] = self.network.gdf.geometry.to_wkt().values
-
         if not hasattr(self, "origins"):
             return
 

sgis/networkanalysis/networkanalysisrules.py

@@ -261,10 +261,10 @@ class NetworkAnalysisRules:
     @staticmethod
     def _check_for_nans(df: GeoDataFrame, col: str) -> None:
         """Remove NaNs and give warning if there are any."""
-        if all(df[col].isna()):
+        if df[col].isna().all():
             raise ValueError(f"All values in the {col!r} column are NaN.")
 
-        nans = sum(df[col].isna())
+        nans = df[col].isna().sum()
         if nans:
             raise ValueError(
                 f"{nans} rows have missing values in the {col!r} column. "
@@ -274,7 +274,7 @@ class NetworkAnalysisRules:
     @staticmethod
     def _check_for_negative_values(df: GeoDataFrame, col: str) -> None:
         """Remove negative values and give warning if there are any."""
-        negative = sum(df[col] < 0)
+        negative = (df[col] < 0).sum()
         if negative:
             raise ValueError(
                 f"{negative} negative values found in the {col!r} column. Fill these "

sgis/networkanalysis/nodes.py

@@ -47,16 +47,14 @@ def make_node_ids(
         gdf = make_edge_coords_cols(gdf)
         geomcol1, geomcol2, geomcol_final = "source_coords", "target_coords", "coords"
 
-    # remove identical lines in opposite directions
+    # remove identical lines in opposite directions in order to get n==1 for deadends
     gdf["meters_"] = gdf.length.astype(str)
-
     sources = gdf[[geomcol1, geomcol2, "meters_"]].rename(
         columns={geomcol1: geomcol_final, geomcol2: "temp"}
     )
     targets = gdf[[geomcol1, geomcol2, "meters_"]].rename(
         columns={geomcol2: geomcol_final, geomcol1: "temp"}
     )
-
     nodes = (
         pd.concat([sources, targets], axis=0, ignore_index=True)
         .drop_duplicates([geomcol_final, "temp", "meters_"])
@@ -66,22 +64,11 @@ def make_node_ids(
     gdf = gdf.drop("meters_", axis=1)
 
     nodes["n"] = nodes.assign(n=1).groupby(geomcol_final)["n"].transform("sum")
-
     nodes = nodes.drop_duplicates(subset=[geomcol_final]).reset_index(drop=True)
-
     nodes["node_id"] = nodes.index
     nodes["node_id"] = nodes["node_id"].astype(str)
 
-    id_dict = {
-        geom: node_id
-        for geom, node_id in zip(nodes[geomcol_final], nodes["node_id"], strict=True)
-    }
-    gdf["source"] = gdf[geomcol1].map(id_dict)
-    gdf["target"] = gdf[geomcol2].map(id_dict)
-
-    n_dict = {geom: n for geom, n in zip(nodes[geomcol_final], nodes["n"], strict=True)}
-    gdf["n_source"] = gdf[geomcol1].map(n_dict)
-    gdf["n_target"] = gdf[geomcol2].map(n_dict)
+    gdf = _map_node_ids_from_wkt(gdf, nodes, wkt=wkt)
 
     if wkt:
         nodes["geometry"] = gpd.GeoSeries.from_wkt(nodes[geomcol_final], crs=gdf.crs)
@@ -95,3 +82,17 @@ def make_node_ids(
     gdf = _push_geom_col(gdf)
 
     return gdf, nodes
+
+
+def _map_node_ids_from_wkt(lines, nodes, wkt: bool = True) -> GeoDataFrame:
+    if wkt:
+        geomcol1, geomcol2, geomcol_final = "source_wkt", "target_wkt", "wkt"
+    else:
+        geomcol1, geomcol2, geomcol_final = "source_coords", "target_coords", "coords"
+    id_dict = {
+        geom: node_id
+        for geom, node_id in zip(nodes[geomcol_final], nodes["node_id"], strict=True)
+    }
+    lines["source"] = lines[geomcol1].map(id_dict)
+    lines["target"] = lines[geomcol2].map(id_dict)
+    return lines

{ssb_sgis-1.3.5.dist-info → ssb_sgis-1.3.8.dist-info}/METADATA

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

{ssb_sgis-1.3.5.dist-info → ssb_sgis-1.3.8.dist-info}/RECORD

@@ -7,23 +7,23 @@ sgis/geopandas_tools/bounds.py,sha256=Os9o4EZ1ax38reW-9cdJzgKHoX2il9lUEIZ7wc5CpB
 sgis/geopandas_tools/buffer_dissolve_explode.py,sha256=z9HvakazR_prXH862e8-gEe7UFbeI4rRTbUaBgPeMBk,19552
 sgis/geopandas_tools/centerlines.py,sha256=Q65Sx01SeAlulBEd9oaZkB2maBBNdLcJwAbTILg4SPU,11848
 sgis/geopandas_tools/cleaning.py,sha256=fST0xFztmyn-QUOAfvjZmu7aO_zPiolWK7gd7TR6ffI,24393
-sgis/geopandas_tools/conversion.py,sha256=iX954YEpobmn_R1Ecx_zDU1RlWq_67pfbzMXtwTH04I,24162
-sgis/geopandas_tools/duplicates.py,sha256=TDDM4u1n7SIkyJrOfl1Lno92AmUPqtXBHsj1IUKC0hI,14992
-sgis/geopandas_tools/general.py,sha256=DTQM8p-krgR3gA3miP931eCrxDCpF1ya7dRiMy3K_bs,44099
+sgis/geopandas_tools/conversion.py,sha256=viZz9t1Gi-8nJ9GwZlCVvObXO52VTODkTZ_F3b0gLek,24183
+sgis/geopandas_tools/duplicates.py,sha256=AU8J2X3sUuohRDsQOc9TA5K0k2KHDlGLbvb6eMSQvvc,15893
+sgis/geopandas_tools/general.py,sha256=W8R0_EXGZXDnTl36iGVtF3YTe_BvdrR2Jzy1TZo5o9A,44363
 sgis/geopandas_tools/geocoding.py,sha256=sZjUW52ULhQWDLmU51C9_itBePkDuWkp8swvYaiYmJk,679
 sgis/geopandas_tools/geometry_types.py,sha256=ijQDbQaZPqPGjBl707H4yooNXpk21RXyatI7itnvqLk,7603
 sgis/geopandas_tools/neighbors.py,sha256=VZGOwwC3-C6KpwLQ3j0K5cOVInmckxIXoGMqPGkemk4,17606
 sgis/geopandas_tools/overlay.py,sha256=uR9troLM9amo-z5Bs6jhPtFbr0RrDFsW-WJpeuQ4WSQ,23522
-sgis/geopandas_tools/point_operations.py,sha256=JM4hvfIVxZaZdGNlGzcCurrKzkgC_b9hzbFYN42f9WY,6972
+sgis/geopandas_tools/point_operations.py,sha256=R_39MoMIMsTB0mxmWibZxfUoUZUriuOoxjMNC8mFCds,7624
 sgis/geopandas_tools/polygon_operations.py,sha256=v-B9IgbFfm4dVHKPyzvmnNiqVCdtl9ddpCsQpZZ-9sU,49284
 sgis/geopandas_tools/polygons_as_rings.py,sha256=BX_GZS6F9I4NbEpiOlNBd7zywJjdfdJVi_MkeONBuiM,14941
-sgis/geopandas_tools/runners.py,sha256=J4lH0RXYDYTLVeQFgNv8gEY0E97QGIQ4zPW5vfoxgDU,12979
+sgis/geopandas_tools/runners.py,sha256=m2AgT1GTSACPzGeP0cuaItnpN-77bpTPcXHwmaOqNNQ,13170
 sgis/geopandas_tools/sfilter.py,sha256=CZ_-c4t1CQCwJ7RHCKo1Na9u-aAg18xXnJAMiUqoaj8,10411
 sgis/geopandas_tools/utils.py,sha256=X0pRvB1tWgV_0BCrRS1HU9LtLGnZCpvVPxyqM9JGb0Y,1415
 sgis/helpers.py,sha256=4N6vFWQ3TYVzRHNcWY_fNa_GkFuaZB3vtCkkFND-qs0,9628
 sgis/io/__init__.py,sha256=uyBr20YDqB2bQttrd5q1JuGOvX32A-MSvS7Wmw5f5qg,177
 sgis/io/_is_dapla.py,sha256=wmfkSe98IrLhUg3dtXZusV6OVC8VlY1kbc5EQDf3P-Q,358
-sgis/io/dapla_functions.py,sha256=EmliBKnGm8XELY450BMTYfRtYw2WRMR2SBUxhYP5huw,31896
+sgis/io/dapla_functions.py,sha256=_arLbkfdC18hUi5chNdKyE6JIEPCEBeVjjblBjLnLx8,32195
 sgis/io/opener.py,sha256=3D65XF0dHLigZfzB5uAG-3T_VXVu4wJXZUMzAkqHypc,844
 sgis/io/read_parquet.py,sha256=FvZYv1rLkUlrSaUY6QW6E1yntmntTeQuZ9ZRgCDO4IM,3776
 sgis/maps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -39,17 +39,17 @@ sgis/maps/tilesources.py,sha256=F4mFHxPwkiPJdVKzNkScTX6xbJAMIUtlTq4mQ83oguw,1746
 sgis/maps/wms.py,sha256=sCVpKxH1Rsd14GECW7BFh8yaWngpVWYvw9Yhuez1yW8,12482
 sgis/networkanalysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sgis/networkanalysis/_get_route.py,sha256=3m5xQdQqGtt51vcI5fcmYQAOQCeBtL6sorDoPxBNf84,7818
-sgis/networkanalysis/_od_cost_matrix.py,sha256=zkyPX7ObT996ahaFJ2oI0D0SqQWbWyfy_qLtXwValPg,3434
-sgis/networkanalysis/_points.py,sha256=128QEepBGAyI5XakMUVvNyOnJE0Ts7hvGiVUt1YTXiU,4439
+sgis/networkanalysis/_od_cost_matrix.py,sha256=DZDQGZN_OGkYC35fpS_WoXoZuQ3zoZnmtArXl5eGc70,2333
+sgis/networkanalysis/_points.py,sha256=iG5whhXAo5NcjLNaVgjvNfl6oSm9SOoVmUeMPB3uNWQ,4416
 sgis/networkanalysis/_service_area.py,sha256=-xSdiZrZ3uqAhd4ZaBY8a8fMJjN09MPoYxlVMXm3UZk,5642
-sgis/networkanalysis/closing_network_holes.py,sha256=FYZ677nRwLmDkP6bQ1ssQ_h29RzAG463U4xmbu5ksfg,14572
+sgis/networkanalysis/closing_network_holes.py,sha256=7mQmqvcx4kpu0WGlGS8PH4j4dDFsm19FOm-z0rYD2nk,14455
 sgis/networkanalysis/cutting_lines.py,sha256=ZQAt0cufaPeNAEqUzp-imu26AIL9S5-lw6Xifa8RoWk,9818
 sgis/networkanalysis/directednetwork.py,sha256=Mrc2zHip4P5RNxnyffKm-xU832AVQeSHz-YZueAc0pM,11413
-sgis/networkanalysis/finding_isolated_networks.py,sha256=Wg4ILhm7uS9RLOGcL0WN8uZBMJYjdljJc8L5DU5nIPY,3754
-sgis/networkanalysis/network.py,sha256=zV9bAbVdTgTohg2o2RFGy2uhOJrd3Ma57hwIAStxMAQ,7847
-sgis/networkanalysis/networkanalysis.py,sha256=P2kqE1kBxabBnv4h6ort1IiO4W0XlsJn5DrT7IbeG5w,68651
-sgis/networkanalysis/networkanalysisrules.py,sha256=na26iZTpnlwwIEEGswoqMH4W1ZOLN2GIvACZbxn8GPw,12958
-sgis/networkanalysis/nodes.py,sha256=atFSpqz-_uJHMrf6MC0zhrrcWIydRMFZrsaHC2xr1GU,3374
+sgis/networkanalysis/finding_isolated_networks.py,sha256=FDel7zF03eBpicwZnfK2-e9IXYaZ4KVleaTnUvgW-4k,3678
+sgis/networkanalysis/network.py,sha256=13yoArGOX1J_nCLTxh7tQjDTxj545RDYFYc_11m3FuM,7913
+sgis/networkanalysis/networkanalysis.py,sha256=gy69ym4mBkQJAq6U27mB9Vkvq71ZuOI1Fr0deggG0oY,69641
+sgis/networkanalysis/networkanalysisrules.py,sha256=k1f-DNEmJtiP_TkCCDclsnRjGTkBqAkj-MYQMUAt_Yc,12963
+sgis/networkanalysis/nodes.py,sha256=h7j3vCFdTsuiVEkmB26ebe44HiFLKOlQhghJ5NV0cU4,3562
 sgis/networkanalysis/traveling_salesman.py,sha256=Jjo6bHY4KJ-eK0LycyTy0sWxZjgITs5MBllZ_G9FhTE,5655
 sgis/parallel/__init__.py,sha256=fw_Fl3IJk1bKzrRBhZIoOpznJqwd09NVHJJFj2ZLeIU,32
 sgis/parallel/parallel.py,sha256=3Nq7cgvkVmg-2TEyNCEiqBshYOHt6Qf6xg6rrcnzf78,39394
@@ -61,7 +61,7 @@ sgis/raster/indices.py,sha256=efJmgfPg_VuSzXFosXV661IendF8CwPFWtMhyP4TMUg,222
 sgis/raster/regex.py,sha256=4idTJ9vFtsGtbxcjJrx2VrpJJuDMP3bLdqF93Vc_cmY,3752
 sgis/raster/sentinel_config.py,sha256=nySDqn2R8M6W8jguoBeSAK_zzbAsqmaI59i32446FwY,1268
 sgis/raster/zonal.py,sha256=D4Gyptw-yOLTCO41peIuYbY-DANsJCG19xXDlf1QAz4,2299
-ssb_sgis-1.3.5.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
-ssb_sgis-1.3.5.dist-info/METADATA,sha256=TbqucBYChWXB_Xw2eFf9PZwQoguEWeKGav18lFbhUfI,11495
-ssb_sgis-1.3.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ssb_sgis-1.3.5.dist-info/RECORD,,
+ssb_sgis-1.3.8.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
+ssb_sgis-1.3.8.dist-info/METADATA,sha256=qWEIyFwB_LmGabBeT9zQUq34Ne7FWXzsYoRQL_RgOLE,11495
+ssb_sgis-1.3.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ssb_sgis-1.3.8.dist-info/RECORD,,