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

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)
@@ -870,9 +869,9 @@ def make_edge_wkt_cols(gdf: GeoDataFrame) -> GeoDataFrame:
     except ValueError:
         gdf, endpoints = _prepare_make_edge_cols(gdf)
 
-    endpoints = endpoints.force_2d()
-    gdf["source_wkt"] = endpoints.groupby(level=0).first().to_wkt()
-    gdf["target_wkt"] = endpoints.groupby(level=0).last().to_wkt()
+    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)

sgis/geopandas_tools/runners.py

@@ -239,9 +239,6 @@ class RTreeQueryRunner(AbstractRunner):
                 left, right = results
                 return left, right
             return results
-            left = np.concatenate([x[0] for x in results])
-            right = np.concatenate([x[1] for x in results])
-            return left, right
         elif (
             (self.n_jobs or 1) > 1
             and len(arr2) / self.n_jobs > 10_000
@@ -264,9 +261,6 @@ class RTreeQueryRunner(AbstractRunner):
                 left, right = results
                 return left, right
             return results
-            left = np.concatenate([x[0] for x in results])
-            right = np.concatenate([x[1] for x in results])
-            return left, right
 
         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

@@ -26,13 +26,11 @@ 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 = results.set_index(["origin", "destination"]).loc[keys].reset_index()
 
     results["geom_ori"] = results["origin"].map(origins.geometry)
     results["geom_des"] = results["destination"].map(destinations.geometry)

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
 
@@ -1411,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
             )
@@ -1426,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,
@@ -1482,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))
@@ -1495,25 +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
+        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(
@@ -1557,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
@@ -1587,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.6.dist-info → ssb_sgis-1.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ssb-sgis
-Version: 1.3.6
+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.6.dist-info → ssb_sgis-1.3.8.dist-info}/RECORD

@@ -9,7 +9,7 @@ sgis/geopandas_tools/centerlines.py,sha256=Q65Sx01SeAlulBEd9oaZkB2maBBNdLcJwAbTI
 sgis/geopandas_tools/cleaning.py,sha256=fST0xFztmyn-QUOAfvjZmu7aO_zPiolWK7gd7TR6ffI,24393
 sgis/geopandas_tools/conversion.py,sha256=viZz9t1Gi-8nJ9GwZlCVvObXO52VTODkTZ_F3b0gLek,24183
 sgis/geopandas_tools/duplicates.py,sha256=AU8J2X3sUuohRDsQOc9TA5K0k2KHDlGLbvb6eMSQvvc,15893
-sgis/geopandas_tools/general.py,sha256=B4houRK2zDrlarhihQs4w6ITfh6UZHhUciB120bbniI,44447
+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
@@ -17,13 +17,13 @@ sgis/geopandas_tools/overlay.py,sha256=uR9troLM9amo-z5Bs6jhPtFbr0RrDFsW-WJpeuQ4W
 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=ZVJnUoJAgc0K_UNIIBOwUWaQDCKCzebygGMu2Fdw6LA,13470
+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=u2UtgZ0GvvCE1PNvKpB3lM35RCcFKXqtC3NLYWX_jmA,2348
-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=5LFCapexrkO97ZyAV2-0lwEPHfVQrdQ4Q1A2eRQBOVo,68498
-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.6.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
-ssb_sgis-1.3.6.dist-info/METADATA,sha256=M-4XAxb5WFhaHhbzq4IIb2oE0Ww8gNhbJSqFKjoPnSs,11495
-ssb_sgis-1.3.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ssb_sgis-1.3.6.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,,