ssb-sgis 1.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

sgis/networkanalysis/closing_network_holes.py

@@ -3,61 +3,15 @@
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame, GeoSeries
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
 from pandas import DataFrame
 from shapely import shortest_line
 
-from ..geopandas_tools.conversion import coordinate_array, to_geoseries
-from ..geopandas_tools.geometry_types import get_geom_type
+from ..geopandas_tools.conversion import coordinate_array
 from ..geopandas_tools.neighbors import k_nearest_neighbors
-from .nodes import make_edge_wkt_cols, make_node_ids
-
-
-def close_network_holes_to(
-    lines: GeoDataFrame | GeoSeries,
-    extend_to: GeoDataFrame | GeoSeries,
-    max_distance: int | float,
-    max_angle: int | float,
-) -> GeoDataFrame | GeoSeries:
-    if isinstance(lines, GeoSeries):
-        lines = lines.to_frame("geometry")
-        was_geoseries = True
-    else:
-        was_geoseries = False
-
-    lines, _ = make_node_ids(lines)
-
-    if isinstance(extend_to, GeoSeries):
-        extend_to = extend_to.to_frame("geometry")
-
-    if not (extend_to.geom_type == "Point").all():
-        raise ValueError("'extend_to' must be singlepart point geometries")
-
-    extend_to["wkt"] = extend_to.geometry.to_wkt()
-    extend_to = extend_to.drop_duplicates("wkt")
-    extend_to["node_id"] = range(len(extend_to))
-
-    new_lines: GeoSeries = _close_holes_all_lines(
-        lines, extend_to, max_distance=max_distance, max_angle=max_angle, idx_start=0
-    )
-
-    if was_geoseries:
-        return pd.concat([lines.geometry, new_lines])
-
-    new_lines = gpd.GeoDataFrame(
-        {"geometry": new_lines}, geometry="geometry", crs=lines.crs
-    )
-
-    return pd.concat([lines, new_lines], ignore_index=True).drop(
-        columns=[
-            "source_wkt",
-            "target_wkt",
-            "source",
-            "target",
-            "n_source",
-            "n_target",
-        ]
-    )
+from .nodes import make_edge_wkt_cols
+from .nodes import make_node_ids
 
 
 def close_network_holes(
@@ -65,7 +19,7 @@ def close_network_holes(
     max_distance: int | float,
     max_angle: int,
     hole_col: str | None = "hole",
-):
+) -> GeoDataFrame:
     """Fills network gaps with straigt lines.
 
     Fills holes in the network by connecting deadends with the nodes that are
@@ -89,7 +43,7 @@ def close_network_holes(
         The holes will have missing values in the weight column used in
         NetworkAnalysis. These values must be filled before analysis.
 
-    Examples
+    Examples:
     --------
     Read road data with small gaps.
 
@@ -105,10 +59,10 @@ def close_network_holes(
 
     >>> filled = sg.close_network_holes(roads, max_distance=1.1, max_angle=180)
     >>> filled.hole.value_counts()
-    Name: connected, dtype: int64
+    hole
     0    93395
     1     7102
-    Name: hole, dtype: int64
+    Name: count, dtype: int64
 
     Compare the number of isolated lines before and after.
 
@@ -128,15 +82,15 @@ def close_network_holes(
 
     >>> filled = sg.close_network_holes(roads, max_distance=1.1, max_angle=30)
     >>> filled.hole.value_counts()
+    hole
     0    93395
     1     7092
-    Name: hole, dtype: int64
+    Name: count, dtype: int64
 
     It's not always wise to fill gaps. In the case of this data, these small gaps are
     intentional. They are road blocks where most cars aren't allowed to pass. Fill the
     holes only if it makes the travel times/routes more realistic.
     """
-
     lines, nodes = make_node_ids(gdf)
 
     # remove duplicates of lines going both directions
@@ -174,7 +128,7 @@ def close_network_holes(
     return pd.concat([lines, new_lines], ignore_index=True)
 
 
-def get_angle(array_a, array_b):
+def get_angle(array_a: np.ndarray, array_b: np.ndarray) -> np.ndarray:
     dx = array_b[:, 0] - array_a[:, 0]
     dy = array_b[:, 1] - array_a[:, 1]
 
@@ -187,7 +141,7 @@ def close_network_holes_to_deadends(
     gdf: GeoDataFrame,
     max_distance: int | float,
     hole_col: str | None = "hole",
-):
+) -> GeoDataFrame:
     """Fills gaps between two deadends if the distance is less than 'max_distance'.
 
     Fills holes between deadends in the network with straight lines if the distance is
@@ -202,7 +156,7 @@ def close_network_holes_to_deadends(
     Returns:
         The input GeoDataFrame with new lines added.
 
-    Examples
+    Examples:
     --------
     Read road data with small gaps.
 
@@ -246,7 +200,7 @@ def close_network_holes_to_deadends(
     new_lines = make_edge_wkt_cols(new_lines)
 
     wkt_id_dict = {
-        wkt: id for wkt, id in zip(nodes["wkt"], nodes["node_id"], strict=True)
+        wkt: id_ for wkt, id_ in zip(nodes["wkt"], nodes["node_id"], strict=True)
     }
     new_lines["source"] = new_lines["source_wkt"].map(wkt_id_dict)
     new_lines["target"] = new_lines["target_wkt"].map(wkt_id_dict)
@@ -259,7 +213,11 @@ def close_network_holes_to_deadends(
 
 
 def _close_holes_all_lines(
-    lines, nodes, max_distance, max_angle, idx_start: int
+    lines: GeoDataFrame,
+    nodes: GeoDataFrame,
+    max_distance: int | None,
+    max_angle: int | None,
+    idx_start: int,
 ) -> GeoSeries:
     k = min(len(nodes), 50)
 

sgis/networkanalysis/cutting_lines.py

@@ -1,31 +1,23 @@
 """Cutting and splitting line geometries."""
+
 import warnings
 
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame, GeoSeries
-from pandas import DataFrame, Series
-from shapely import (
-    buffer,
-    extract_unique_points,
-    force_2d,
-    get_coordinates,
-    get_parts,
-    linestrings,
-    touches,
-    unary_union,
-)
-from shapely.geometry import LineString, Point
+from geopandas import GeoDataFrame
+from pandas import DataFrame
+from pandas import Series
+from shapely import extract_unique_points
+from shapely import force_2d
+from shapely.geometry import LineString
+from shapely.geometry import Point
 
 from ..geopandas_tools.buffer_dissolve_explode import buff
 from ..geopandas_tools.conversion import to_gdf
 from ..geopandas_tools.geometry_types import get_geom_type
 from ..geopandas_tools.neighbors import get_k_nearest_neighbors
-from ..geopandas_tools.point_operations import (
-    _shapely_snap,
-    snap_all,
-    snap_within_distance,
-)
+from ..geopandas_tools.point_operations import snap_all
+from ..geopandas_tools.point_operations import snap_within_distance
 from ..geopandas_tools.sfilter import sfilter_split
 from .nodes import make_edge_coords_cols
 
@@ -59,7 +51,7 @@ def split_lines_by_nearest_point(
     Raises:
         ValueError: If the crs of the input data differs.
 
-    Examples
+    Examples:
     --------
     >>> from sgis import read_parquet_url, split_lines_by_nearest_point
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
@@ -148,8 +140,8 @@ def split_lines_by_nearest_point(
     splitted_source = to_gdf(splitted["source_coords"], crs=gdf.crs)
     splitted_target = to_gdf(splitted["target_coords"], crs=gdf.crs)
 
-    def get_nearest(splitted, snapped) -> pd.DataFrame:
-        """find the nearest snapped point for each source and target of the lines"""
+    def get_nearest(splitted: GeoDataFrame, snapped: GeoDataFrame) -> pd.DataFrame:
+        """Find the nearest snapped point for each source and target of the lines."""
         return get_k_nearest_neighbors(splitted, snapped, k=1).loc[
             lambda x: x["distance"] <= PRECISION * 2
         ]
@@ -166,7 +158,7 @@ def split_lines_by_nearest_point(
     # now, we can replace the source/target coordinate with the coordinates of
     # the snapped points.
 
-    splitted = change_line_endpoint(
+    splitted = _change_line_endpoint(
         splitted,
         indices=dists_source.index,
         pointmapper=pointmapper_source,
@@ -174,7 +166,7 @@ def split_lines_by_nearest_point(
     )  # i=0)
 
     # same for the lines where the target was split, but change the last coordinate
-    splitted = change_line_endpoint(
+    splitted = _change_line_endpoint(
         splitted,
         indices=dists_target.index,
         pointmapper=pointmapper_target,
@@ -189,22 +181,38 @@ def split_lines_by_nearest_point(
     )
 
 
-def change_line_endpoint(
+def _change_line_endpoint(
     gdf: GeoDataFrame,
     indices: pd.Index,
     pointmapper: pd.Series,
     change_what: str | int,
 ) -> GeoDataFrame:
-    """
-    Loop for each line where the source is the endpoint that was split
-    change the first point of the line to the point it was split by
+    """Modify the endpoints of selected lines in a GeoDataFrame based on an index mapping.
+
+    This function updates the geometry of specified line features within a GeoDataFrame,
+    changing either the first or last point of each line to new coordinates provided by a mapping.
+    It is typically used in scenarios where line endpoints need to be adjusted to new locations,
+    such as in network adjustments or data corrections.
+
+    Args:
+        gdf: A GeoDataFrame containing line geometries.
+        indices: An Index object identifying the rows in the GeoDataFrame whose endpoints will be changed.
+        pointmapper: A Series mapping from the index of lines to new point geometries.
+        change_what: Specifies which endpoint of the line to change. Accepts 'first' or 0 for the
+            starting point, and 'last' or -1 for the ending point.
+
+    Returns:
+        A GeoDataFrame with the specified line endpoints updated according to the pointmapper.
+
+    Raises:
+        ValueError: If `change_what` is not one of the accepted values ('first', 'last', 0, -1).
     """
     assert gdf.index.is_unique
 
     if change_what == "first" or change_what == 0:
-        to_be_changed = lambda x: ~x.index.duplicated(keep="first")
+        keep = "first"
     elif change_what == "last" or change_what == -1:
-        to_be_changed = lambda x: ~x.index.duplicated(keep="last")
+        keep = "last"
     else:
         raise ValueError(
             f"change_what should be 'first' or 'last' or 0 or -1. Got {change_what}"
@@ -216,8 +224,10 @@ def change_line_endpoint(
     relevant_lines.geometry = extract_unique_points(relevant_lines.geometry)
     relevant_lines = relevant_lines.explode(index_parts=False)
 
-    relevant_lines.loc[to_be_changed, "geometry"] = (
-        relevant_lines.loc[to_be_changed].index.map(pointmapper).values
+    relevant_lines.loc[lambda x: ~x.index.duplicated(keep=keep), "geometry"] = (
+        relevant_lines.loc[lambda x: ~x.index.duplicated(keep=keep)]
+        .index.map(pointmapper)
+        .values
     )
 
     relevant_lines_mapped = relevant_lines.groupby(level=0)["geometry"].agg(LineString)
@@ -227,7 +237,9 @@ def change_line_endpoint(
     return gdf
 
 
-def cut_lines(gdf: GeoDataFrame, max_length: int, ignore_index=False) -> GeoDataFrame:
+def cut_lines(
+    gdf: GeoDataFrame, max_length: int, ignore_index: bool = False
+) -> GeoDataFrame:
     """Cuts lines of a GeoDataFrame into pieces of a given length.
 
     Args:
@@ -242,7 +254,7 @@ def cut_lines(gdf: GeoDataFrame, max_length: int, ignore_index=False) -> GeoData
     Note:
         This method is time consuming for large networks and low 'max_length'.
 
-    Examples
+    Examples:
     --------
     >>> from sgis import read_parquet_url, cut_lines
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
@@ -314,7 +326,7 @@ def cut_lines_once(
         ignore_index: If True, the resulting axis will be labeled 0, 1, …, n - 1.
             Defaults to False.
 
-    Examples
+    Examples:
     --------
     >>> from sgis import cut_lines_once, to_gdf
     >>> import pandas as pd
@@ -344,24 +356,24 @@ def cut_lines_once(
     >>> cut_lines_once(gdf, "dist")
                                                 geometry  dist
     0      LINESTRING (0.00000 0.00000, 0.70711 0.70711)     1
-    1  LINESTRING (0.70711 0.70711, 1.00000 1.00000, ...     1
-    2  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     2
-    3      LINESTRING (1.41421 1.41421, 2.00000 2.00000)     2
-    4  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     3
+    0  LINESTRING (0.70711 0.70711, 1.00000 1.00000, ...     1
+    0  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     2
+    0      LINESTRING (1.41421 1.41421, 2.00000 2.00000)     2
+    0  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     3
 
     Cut distance as list (same result as above).
 
     >>> cut_lines_once(gdf, [1, 2, 3])
                                                 geometry  dist
     0      LINESTRING (0.00000 0.00000, 0.70711 0.70711)     1
-    1  LINESTRING (0.70711 0.70711, 1.00000 1.00000, ...     1
-    2  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     2
-    3      LINESTRING (1.41421 1.41421, 2.00000 2.00000)     2
-    4  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     3
+    0  LINESTRING (0.70711 0.70711, 1.00000 1.00000, ...     1
+    0  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     2
+    0      LINESTRING (1.41421 1.41421, 2.00000 2.00000)     2
+    0  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     3
     """
 
     def _cut(line: LineString, distance: int | float) -> list[LineString]:
-        """From the shapely docs"""
+        """From the shapely docs."""
         if distance <= 0.0 or distance >= line.length:
             return line
         coords = list(line.coords)

sgis/networkanalysis/directednetwork.py

@@ -1,12 +1,14 @@
 """Prepare a GeoDataFrame of line geometries for directed network analysis."""
 
 import warnings
+from collections.abc import Sequence
 
 import pandas as pd
 from geopandas import GeoDataFrame
 from shapely.constructive import reverse
 
-from ..helpers import return_two_vals, unit_is_meters
+from ..helpers import return_two_vals
+from ..helpers import unit_is_meters
 
 
 def make_directed_network_norway(gdf: GeoDataFrame, dropnegative: bool) -> GeoDataFrame:
@@ -26,7 +28,7 @@ def make_directed_network_norway(gdf: GeoDataFrame, dropnegative: bool) -> GeoDa
             network graph. Recode these rows to a non-negative values if you want
             to keep them.
 
-    Examples
+    Examples:
     --------
     2022 data for the municipalities of Oslo and Eidskog can be read directly like this:
 
@@ -47,11 +49,12 @@ def make_directed_network_norway(gdf: GeoDataFrame, dropnegative: bool) -> GeoDa
     1944398      B      0.068239      0.068239  MULTILINESTRING Z ((258292.600 6648313.440 18....
     1944409      B      0.023629      0.023629  MULTILINESTRING Z ((258291.452 6648289.258 19....
     1944415      B      0.175876      0.175876  MULTILINESTRING Z ((260762.830 6650240.620 43....
-    [93395 rows x 46 columns]
+    <BLANKLINE>
+    [93395 rows x 4 columns]
 
     And converted to a directed network like this:
 
-    >>> roads_directed = sg.make_directed_network_norway(roads)
+    >>> roads_directed = sg.make_directed_network_norway(roads, dropnegative=True)
     >>> roads_directed[["minutes", "geometry"]]
              minutes                                           geometry
     0       0.216611  MULTILINESTRING Z ((258028.440 6674249.890 413...
@@ -65,7 +68,8 @@ def make_directed_network_norway(gdf: GeoDataFrame, dropnegative: bool) -> GeoDa
     175622  0.036810  MULTILINESTRING Z ((268681.757 6651886.457 110...
     175623  0.003019  MULTILINESTRING Z ((268682.748 6651886.162 110...
     175624  0.036975  MULTILINESTRING Z ((268694.594 6651881.688 111...
-    [175541 rows x 45 columns]
+    <BLANKLINE>
+    [175541 rows x 2 columns]
     """
     if gdf["drivetime_fw"].isna().any():
         raise ValueError("Missing values in the columns 'drivetime_fw'")
@@ -202,7 +206,9 @@ def make_directed_network(
     return gdf
 
 
-def _validate_minute_args(minute_cols, speed_col_kmh, flat_speed_kmh):
+def _validate_minute_args(
+    minute_cols: Sequence[str], speed_col_kmh: str, flat_speed_kmh: str
+) -> None:
     if not minute_cols and not speed_col_kmh and not flat_speed_kmh:
         warnings.warn(
             "Minute column will not be calculated when both 'minute_cols', "
@@ -217,7 +223,9 @@ def _validate_minute_args(minute_cols, speed_col_kmh, flat_speed_kmh):
         )
 
 
-def _validate_direction_args(gdf, direction_col, direction_vals_bft):
+def _validate_direction_args(
+    gdf: GeoDataFrame, direction_col: str, direction_vals_bft: Sequence[str]
+) -> None:
     if len(direction_vals_bft) != 3:
         raise ValueError(
             "'direction_vals_bft' should be tuple/list with values of directions "

sgis/networkanalysis/finding_isolated_networks.py

@@ -22,7 +22,7 @@ def get_connected_components(gdf: GeoDataFrame) -> GeoDataFrame:
     Returns:
         The GeoDataFrame with a new column "connected".
 
-    Examples
+    Examples:
     --------
     >>> from sgis import read_parquet_url, get_connected_components
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
@@ -75,19 +75,20 @@ def get_component_size(gdf: GeoDataFrame) -> GeoDataFrame:
     Returns:
         A GeoDataFrame with a new column "component_size".
 
-    Examples
+    Examples:
     --------
     >>> from sgis import read_parquet_url, get_component_size
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
 
     >>> roads = get_component_size(roads)
     >>> roads.component_size.value_counts().head()
+    component_size
     79180    85638
     2         1601
     4          688
     6          406
     3          346
-    Name: component_size, dtype: int64
+    Name: count, dtype: int64
     """
     gdf, _ = make_node_ids(gdf)
 

sgis/networkanalysis/network.py

@@ -5,7 +5,8 @@ network, finding and removing isolated network islands and creating unique node
 """
 
 import warnings
-from copy import copy, deepcopy
+from copy import copy
+from copy import deepcopy
 
 import numpy as np
 from geopandas import GeoDataFrame
@@ -21,9 +22,12 @@ from .nodes import make_node_ids
 class Network:
     """Class used in NetworkAnalysis."""
 
-    def __init__(self, gdf: GeoDataFrame):
+    def __init__(self, gdf: GeoDataFrame) -> None:
         """The lines are fixed, welded together rowwise and exploded. Creates node-ids.
 
+        Args:
+            gdf: GeoDataFrame of line geometries to make up the network.
+
         Raises:
             TypeError: If 'gdf' is not of type GeoDataFrame.
             ZeroLinesError: If 'gdf' has zero rows.
@@ -152,6 +156,7 @@ class Network:
         return True
 
     def get_edges(self) -> list[tuple[str, str]]:
+        """Get a list of edges in the network."""
         return [
             (str(source), str(target))
             for source, target in zip(
@@ -166,12 +171,12 @@ class Network:
         """Edge identifiers represented with source and target ids and the weight."""
         return [f"{s}_{t}_{w}" for (s, t), w in zip(edges, weights, strict=True)]
 
-    def _update_nodes_if(self):
+    def _update_nodes_if(self) -> None:
         if not self._nodes_are_up_to_date():
             self._make_node_ids()
 
     @property
-    def nodes(self):
+    def nodes(self) -> GeoDataFrame:
         """GeoDataFrame with the network nodes (line endpoints).
 
         Upon instantiation of the class, a GeoDataFrame of points is created from the
@@ -182,7 +187,7 @@ class Network:
         """
         return self._nodes
 
-    def _warn_if_undirected(self):
+    def _warn_if_undirected(self) -> None:
         """Road data often have to be duplicated and flipped to make it directed."""
         if self.percent_bidirectional > 5:
             return
@@ -202,15 +207,15 @@ class Network:
         warnings.warn(mess, stacklevel=2)
 
     @property
-    def percent_bidirectional(self):
+    def percent_bidirectional(self) -> float:
         """The percentage of lines that appear in both directions."""
         return self._percent_bidirectional
 
-    def copy(self):
+    def copy(self) -> "Network":
         """Returns a shallow copy of the class instance."""
         return copy(self)
 
-    def deepcopy(self):
+    def deepcopy(self) -> "Network":
         """Returns a deep copy of the class instance."""
         return deepcopy(self)
 
@@ -220,9 +225,6 @@ class Network:
         km = int(sum(self.gdf.length) / 1000)
         return f"{cl}({km} km, percent_bidirectional={self._percent_bidirectional})"
 
-    def __iter__(self):
-        """So the attributes can be iterated through."""
-        return iter(self.__dict__.items())
-
-    def __len__(self):
+    def __len__(self) -> int:
+        """Number og rows in the GeoDataFrame."""
         return len(self.gdf)