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

sgis/geopandas_tools/overlay.py

@@ -9,35 +9,30 @@ version of the solution from GH 2792.
 """
 
 import functools
+from collections.abc import Callable
 
-import dask
 import dask.array as da
 import geopandas as gpd
 import joblib
 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 (
-    Geometry,
-    STRtree,
-    box,
-    difference,
-    get_parts,
-    intersection,
-    make_valid,
-    unary_union,
-)
+from shapely import Geometry
+from shapely import STRtree
+from shapely import box
+from shapely import difference
+from shapely import intersection
+from shapely import make_valid
+from shapely import unary_union
 from shapely.errors import GEOSException
 
-from .general import (
-    _determine_geom_type_args,
-    clean_geoms,
-    merge_geometries,
-    parallel_unary_union,
-)
-from .geometry_types import get_geom_type, make_all_singlepart, to_single_geom_type
-
+from .general import _determine_geom_type_args
+from .general import clean_geoms
+from .geometry_types import get_geom_type
+from .geometry_types import make_all_singlepart
+from .geometry_types import to_single_geom_type
 
 DEFAULT_GRID_SIZE = None
 DEFAULT_LSUFFIX = "_1"
@@ -75,6 +70,10 @@ def clean_overlay(
             "point".
         grid_size: Precision grid size to round the geometries. Will use the highest
             precision of the inputs by default.
+        n_jobs: number of threads.
+        predicate: Spatial predicate in the spatial tree.
+        lsuffix: Suffix of columns in df1 that are also in df2.
+        rsuffix: Suffix of columns in df2 that are also in df1.
 
     Returns:
         GeoDataFrame with overlayed and fixed geometries and columns from both
@@ -190,9 +189,10 @@ def _join_and_get_no_rows(df1, df2, lsuffix, rsuffix):
     )
 
 
-def _no_intersections_return(df1, df2, how, lsuffix, rsuffix):
-    """Return with no overlay if no intersecting bounding box"""
-
+def _no_intersections_return(
+    df1: GeoDataFrame, df2: GeoDataFrame, how: str, lsuffix, rsuffix: str
+) -> GeoDataFrame:
+    """Return with no overlay if no intersecting bounding box."""
     if how == "intersection":
         return _join_and_get_no_rows(df1, df2, lsuffix, rsuffix)
 
@@ -226,9 +226,9 @@ def _shapely_pd_overlay(
     how: str,
     grid_size: float = DEFAULT_GRID_SIZE,
     predicate: str = "intersects",
-    lsuffix=DEFAULT_LSUFFIX,
-    rsuffix=DEFAULT_RSUFFIX,
-    geom_type=None,
+    lsuffix: str = DEFAULT_LSUFFIX,
+    rsuffix: str = DEFAULT_RSUFFIX,
+    geom_type: str | None = None,
     n_jobs: int = 1,
 ) -> DataFrame:
     if not grid_size and not len(df1) or not len(df2):
@@ -316,7 +316,15 @@ def _shapely_pd_overlay(
     return overlayed
 
 
-def _update(pairs, df1, df2, left, grid_size, geom_type, n_jobs) -> GeoDataFrame:
+def _update(
+    pairs: pd.DataFrame,
+    df1: pd.DataFrame,
+    df2: pd.DataFrame,
+    left: np.ndarray,
+    grid_size: float | None | int,
+    geom_type: str | None,
+    n_jobs: int,
+) -> GeoDataFrame:
     overlayed = _difference(
         pairs, df1, left, grid_size=grid_size, geom_type=geom_type, n_jobs=n_jobs
     )
@@ -324,24 +332,36 @@ def _update(pairs, df1, df2, left, grid_size, geom_type, n_jobs) -> GeoDataFrame
     return overlayed + [df2]
 
 
-def _run_overlay_dask(arr1, arr2, func, n_jobs, grid_size):
+def _run_overlay_dask(
+    arr1: np.ndarray,
+    arr2: np.ndarray,
+    func: Callable,
+    n_jobs: int,
+    grid_size: float | int | None,
+) -> np.ndarray:
     if len(arr1) // n_jobs <= 1:
         try:
             return func(arr1, arr2, grid_size=grid_size)
         except TypeError as e:
-            raise TypeError(e, {type(x) for x in arr1}, {type(x) for x in arr2})
+            raise TypeError(e, {type(x) for x in arr1}, {type(x) for x in arr2}) from e
     arr1 = da.from_array(arr1, chunks=len(arr1) // n_jobs)
     arr2 = da.from_array(arr2, chunks=len(arr2) // n_jobs)
     res = arr1.map_blocks(func, arr2, grid_size=grid_size, dtype=float)
     return res.compute(scheduler="threads", optimize_graph=False, num_workers=n_jobs)
 
 
-def _run_overlay_joblib_threading(arr1, arr2, func, n_jobs, grid_size):
+def _run_overlay_joblib_threading(
+    arr1: np.ndarray,
+    arr2: np.ndarray,
+    func: Callable,
+    n_jobs: int,
+    grid_size: int | float | None,
+) -> list[Geometry]:
     if len(arr1) // n_jobs <= 1:
         try:
             return func(arr1, arr2, grid_size=grid_size)
         except TypeError as e:
-            raise TypeError(e, {type(x) for x in arr1}, {type(x) for x in arr2})
+            raise TypeError(e, {type(x) for x in arr1}, {type(x) for x in arr2}) from e
     with joblib.Parallel(n_jobs=n_jobs, backend="threading") as parallel:
         return parallel(
             joblib.delayed(func)(g1, g2, grid_size=grid_size)
@@ -349,7 +369,12 @@ def _run_overlay_joblib_threading(arr1, arr2, func, n_jobs, grid_size):
         )
 
 
-def _intersection(pairs, grid_size, geom_type, n_jobs=1) -> GeoDataFrame:
+def _intersection(
+    pairs: pd.DataFrame,
+    grid_size: None | float | int,
+    geom_type: str | None,
+    n_jobs: int = 1,
+) -> GeoDataFrame:
     if not len(pairs):
         return pairs.drop(columns="geom_right")
 
@@ -410,7 +435,17 @@ def _intersection(pairs, grid_size, geom_type, n_jobs=1) -> GeoDataFrame:
     return intersections.drop(columns="geom_right")
 
 
-def _union(pairs, df1, df2, left, right, grid_size, rsuffix, geom_type, n_jobs=1):
+def _union(
+    pairs: pd.DataFrame,
+    df1: pd.DataFrame,
+    df2: pd.DataFrame,
+    left: np.ndarray,
+    right: np.ndarray,
+    grid_size: int | float | None,
+    rsuffix: str,
+    geom_type: str | None,
+    n_jobs: int = 1,
+) -> list[GeoDataFrame]:
     merged = []
     if len(left):
         intersections = _intersection(
@@ -432,7 +467,14 @@ def _union(pairs, df1, df2, left, right, grid_size, rsuffix, geom_type, n_jobs=1
     return merged
 
 
-def _identity(pairs, df1, left, grid_size, geom_type, n_jobs=1):
+def _identity(
+    pairs: pd.DataFrame,
+    df1: pd.DataFrame,
+    left: np.ndarray,
+    grid_size: int | float | None,
+    geom_type: str | None,
+    n_jobs: int = 1,
+) -> list[GeoDataFrame]:
     merged = []
     if len(left):
         intersections = _intersection(
@@ -445,8 +487,16 @@ def _identity(pairs, df1, left, grid_size, geom_type, n_jobs=1):
 
 
 def _symmetric_difference(
-    pairs, df1, df2, left, right, grid_size, rsuffix, geom_type, n_jobs=1
-) -> list:
+    pairs: pd.DataFrame,
+    df1: pd.DataFrame,
+    df2: pd.DataFrame,
+    left: np.ndarray,
+    right: np.ndarray,
+    grid_size: int | float | None,
+    rsuffix: str,
+    geom_type: str | None,
+    n_jobs: int = 1,
+) -> list[GeoDataFrame]:
     merged = []
 
     difference_left = _difference(
@@ -472,7 +522,14 @@ def _symmetric_difference(
     return merged
 
 
-def _difference(pairs, df1, left, grid_size=None, geom_type=None, n_jobs=1) -> list:
+def _difference(
+    pairs: pd.DataFrame,
+    df1: pd.DataFrame,
+    left: np.ndarray,
+    grid_size: int | float | None = None,
+    geom_type: str | None = None,
+    n_jobs: int = 1,
+) -> list[GeoDataFrame]:
     merged = []
     if len(left):
         clip_left = _shapely_diffclip_left(
@@ -493,7 +550,7 @@ def _get_intersects_pairs(
     df2: GeoDataFrame,
     left: np.ndarray,
     right: np.ndarray,
-    rsuffix,
+    rsuffix: str,
 ) -> DataFrame:
     return pd.concat(
         [
@@ -512,7 +569,9 @@ def _get_intersects_pairs(
     )
 
 
-def _add_suffix_left(overlayed, df1, df2, lsuffix):
+def _add_suffix_left(
+    overlayed: pd.DataFrame, df1: pd.DataFrame, df2: pd.DataFrame, lsuffix: str
+):
     """Separating this from _add_indices_from_left, since this suffix is not needed in difference."""
     return overlayed.rename(
         columns={
@@ -526,12 +585,12 @@ def _add_suffix_left(overlayed, df1, df2, lsuffix):
     )
 
 
-def _add_indices_from_left(df1, left):
+def _add_indices_from_left(df1: pd.DataFrame, left: np.ndarray) -> pd.DataFrame:
     return df1.take(np.setdiff1d(np.arange(len(df1)), left))
 
 
 def _add_from_right(
-    df1: GeoDataFrame, df2: GeoDataFrame, right: np.ndarray, rsuffix
+    df1: GeoDataFrame, df2: GeoDataFrame, right: np.ndarray, rsuffix: str
 ) -> GeoDataFrame:
     return df2.take(np.setdiff1d(np.arange(len(df2)), right)).rename(
         columns={
@@ -541,13 +600,17 @@ def _add_from_right(
     )
 
 
-def _shapely_diffclip_left(pairs, df1, grid_size, geom_type, n_jobs):
-    """Aggregate areas in right by unique values of left, then use those to clip
-    areas out of left"""
-
+def _shapely_diffclip_left(
+    pairs: pd.DataFrame,
+    df1: pd.DataFrame,
+    grid_size: int | float | None,
+    geom_type: str | None,
+    n_jobs: int,
+) -> pd.DataFrame:
+    """Aggregate areas in right by unique values from left, then erases those from left."""
     keep_cols = list(df1.columns.difference({"_overlay_index_right"})) + ["geom_right"]
 
-    agg_geoms_partial = functools.partial(agg_geoms, grid_size=grid_size)
+    agg_geoms_partial = functools.partial(_agg_geoms, grid_size=grid_size)
 
     try:
         only_one = pairs.groupby(level=0).transform("size") == 1
@@ -592,7 +655,9 @@ def _shapely_diffclip_left(pairs, df1, grid_size, geom_type, n_jobs):
             {
                 i: g
                 for i, g in zip(
-                    many_hits["_overlay_index_right"], many_hits["geom_right"]
+                    many_hits["_overlay_index_right"],
+                    many_hits["geom_right"],
+                    strict=False,
                 )
             }
         )
@@ -624,8 +689,16 @@ def _shapely_diffclip_left(pairs, df1, grid_size, geom_type, n_jobs):
     return clip_left.drop(columns="geom_right")
 
 
-def _shapely_diffclip_right(pairs, df1, df2, grid_size, rsuffix, geom_type, n_jobs):
-    agg_geoms_partial = functools.partial(agg_geoms, grid_size=grid_size)
+def _shapely_diffclip_right(
+    pairs: pd.DataFrame,
+    df1: pd.DataFrame,
+    df2: pd.DataFrame,
+    grid_size: int | float | None,
+    rsuffix: str,
+    geom_type: str | None,
+    n_jobs: int,
+) -> pd.DataFrame:
+    agg_geoms_partial = functools.partial(_agg_geoms, grid_size=grid_size)
 
     pairs = pairs.rename(columns={"geometry": "geom_left", "geom_right": "geometry"})
 
@@ -675,7 +748,13 @@ def _shapely_diffclip_right(pairs, df1, df2, grid_size, rsuffix, geom_type, n_jo
     return clip_right.drop(columns="geom_left")
 
 
-def _try_difference(left, right, grid_size, geom_type, n_jobs=1):
+def _try_difference(
+    left: np.ndarray,
+    right: np.ndarray,
+    grid_size: int | float | None,
+    geom_type: str | None,
+    n_jobs: int = 1,
+) -> np.ndarray:
     """Try difference overlay, then make_valid and retry."""
     if n_jobs > 1 and len(left) / n_jobs > 10:
         try:
@@ -722,17 +801,21 @@ def _try_difference(left, right, grid_size, geom_type, n_jobs=1):
                 grid_size=grid_size,
             )
         except GEOSException as e:
-            raise e.__class__(e, f"{grid_size=}", f"{left=}", f"{right=}")
+            raise e.__class__(e, f"{grid_size=}", f"{left=}", f"{right=}") from e
 
 
 def make_valid_and_keep_geom_type(
-    geoms: np.ndarray, geom_type: str, n_jobs
+    geoms: np.ndarray, geom_type: str, n_jobs: int
 ) -> GeoSeries:
     """Make GeometryCollections into (Multi)Polygons, (Multi)LineStrings or (Multi)Points.
 
     Because GeometryCollections might appear after dissolving (unary_union).
     And this makes shapely difference/intersection fail.
 
+    Args:
+        geoms: Array of geometries.
+        geom_type: geometry type to be kept.
+        n_jobs: Number of treads.
     """
     geoms = GeoSeries(geoms)
     geoms.index = range(len(geoms))
@@ -744,5 +827,5 @@ def make_valid_and_keep_geom_type(
     return pd.concat([one_hit, many_hits]).sort_index()
 
 
-def agg_geoms(g, grid_size=None):
+def _agg_geoms(g: np.ndarray, grid_size: int | float | None = None) -> Geometry:
     return make_valid(unary_union(g, grid_size=grid_size))

sgis/geopandas_tools/point_operations.py

@@ -2,12 +2,14 @@
 
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame, GeoSeries
-from shapely import distance, snap, unary_union
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
+from shapely import distance
+from shapely import unary_union
 from shapely.ops import nearest_points
 
-from ..geopandas_tools.general import to_lines
-from ..geopandas_tools.geometry_types import get_geom_type, to_single_geom_type
+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
 
 
@@ -45,8 +47,8 @@ def snap_within_distance(
         'to' geometries to multipoint before snapping if the snap points should be
         vertices.
 
-    Examples
-    --------
+    Examples:
+    ---------
     Create som points.
 
     >>> from sgis import snap_within_distance, to_gdf
@@ -76,7 +78,6 @@ def snap_within_distance(
     0  POINT (2.00000 2.00000)      2.828427
     1  POINT (2.00000 2.00000)      1.414214
     """
-
     to = _polygons_to_rings(to)
 
     if not distance_col and not isinstance(points, GeoDataFrame):
@@ -134,8 +135,8 @@ def snap_all(
         'to' geometries to multipoint before snapping if the snap points should be
         vertices.
 
-    Examples
-    --------
+    Examples:
+    ---------
     Create som points.
 
     >>> from sgis import snap_all, to_gdf
@@ -183,7 +184,7 @@ def snap_all(
     return copied
 
 
-def _polygons_to_rings(gdf):
+def _polygons_to_rings(gdf: GeoDataFrame) -> GeoDataFrame:
     if get_geom_type(gdf) == "polygon":
         return PolygonsAsRings(gdf).get_rings()
     if get_geom_type(gdf) != "mixed":

sgis/geopandas_tools/polygon_operations.py

@@ -3,40 +3,38 @@
 import networkx as nx
 import numpy as np
 import pandas as pd
-import shapely
-from geopandas import GeoDataFrame, GeoSeries
-from geopandas.array import GeometryArray
-from shapely import (
-    STRtree,
-    area,
-    box,
-    buffer,
-    difference,
-    get_exterior_ring,
-    get_interior_ring,
-    get_num_interior_rings,
-    get_parts,
-    is_empty,
-    make_valid,
-    polygons,
-    unary_union,
-)
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
+from shapely import STRtree
+from shapely import area
+from shapely import box
+from shapely import buffer
+from shapely import difference
+from shapely import get_exterior_ring
+from shapely import get_interior_ring
+from shapely import get_num_interior_rings
+from shapely import get_parts
+from shapely import is_empty
+from shapely import make_valid
+from shapely import polygons
+from shapely import unary_union
 from shapely.errors import GEOSException
 
-from .duplicates import get_intersections
-from .general import (
-    _push_geom_col,
-    clean_geoms,
-    get_grouped_centroids,
-    parallel_unary_union,
-    parallel_unary_union_geoseries,
-    to_lines,
-)
-from .geometry_types import get_geom_type, make_all_singlepart, to_single_geom_type
+from .general import _parallel_unary_union
+from .general import _parallel_unary_union_geoseries
+from .general import _push_geom_col
+from .general import clean_geoms
+from .general import get_grouped_centroids
+from .general import to_lines
+from .geometry_types import get_geom_type
+from .geometry_types import make_all_singlepart
+from .geometry_types import to_single_geom_type
 from .neighbors import get_neighbor_indices
-from .overlay import _try_difference, clean_overlay
+from .overlay import _try_difference
+from .overlay import clean_overlay
 from .polygons_as_rings import PolygonsAsRings
-from .sfilter import sfilter, sfilter_inverse
+from .sfilter import sfilter
+from .sfilter import sfilter_inverse
 
 
 def get_polygon_clusters(
@@ -63,6 +61,7 @@ def get_polygon_clusters(
         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.
+        predicate: Spatial predicate. Defaults to "intersects".
         as_string: Whether to return the cluster column values as a string with x and y
             coordinates. Convinient to always get unique ids.
             Defaults to False because of speed.
@@ -70,9 +69,8 @@ def get_polygon_clusters(
     Returns:
         One or more GeoDataFrames (same amount as was given) with a new cluster column.
 
-    Examples
-    --------
-
+    Examples:
+    ---------
     Create geometries with three clusters of overlapping polygons.
 
     >>> import sgis as sg
@@ -186,7 +184,9 @@ def get_polygon_clusters(
     return unconcated
 
 
-def get_cluster_mapper(gdf, predicate="intersects"):
+def get_cluster_mapper(
+    gdf: GeoDataFrame | GeoSeries, predicate: str = "intersects"
+) -> dict[int, int]:
     if not gdf.index.is_unique:
         raise ValueError("Index must be unique")
     neighbors = get_neighbor_indices(gdf, gdf, predicate=predicate)
@@ -241,15 +241,16 @@ def eliminate_by_longest(
             'gdf' are sorted first, but if 'gdf' has missing values, the resulting
             polygons might get values from the polygons to be eliminated
             (if aggfunc="first").
-        kwargs: Keyword arguments passed to the dissolve method.
+        grid_size: Rounding of the coordinates. Defaults to None.
+        n_jobs: Number of threads to use. Defaults to 1.
+        **kwargs: Keyword arguments passed to the dissolve method.
 
     Returns:
         The GeoDataFrame (gdf) with the geometries of 'to_eliminate' dissolved in.
         If multiple GeoDataFrame are passed as 'gdf', they are returned as a tuple.
 
-    Examples
-    --------
-
+    Examples:
+    ---------
     Create two polygons with a sliver in between:
 
     >>> sliver = sg.to_gdf(Polygon([(0, 0), (0.1, 1), (0, 2), (-0.1, 1)]))
@@ -398,6 +399,8 @@ def eliminate_by_largest(
     Args:
         gdf: GeoDataFrame with polygon geometries, or a list of GeoDataFrames.
         to_eliminate: The geometries to be eliminated by 'gdf'.
+        max_distance: Max distance to search for neighbors. Defaults to None, meaning
+            0.
         remove_isolated: If False (default), polygons in 'to_eliminate' that share
             no border with any polygon in 'gdf' will be kept. If True, the isolated
             polygons will be removed.
@@ -414,15 +417,16 @@ def eliminate_by_largest(
             polygons might get values from the polygons to be eliminated
             (if aggfunc="first").
         predicate: Binary predicate passed to sjoin. Defaults to "intersects".
-        kwargs: Keyword arguments passed to the dissolve method.
+        grid_size: Rounding of the coordinates. Defaults to None.
+        n_jobs: Number of threads to use. Defaults to 1.
+        **kwargs: Keyword arguments passed to the dissolve method.
 
     Returns:
         The GeoDataFrame (gdf) with the geometries of 'to_eliminate' dissolved in.
         If multiple GeoDataFrame are passed as 'gdf', they are returned as a tuple.
 
-    Examples
-    --------
-
+    Examples:
+    ---------
     Create two polygons with a sliver in between:
 
     >>> sliver = sg.to_gdf(Polygon([(0, 0), (0.1, 1), (0, 2), (-0.1, 1)]))
@@ -700,7 +704,7 @@ def _eliminate(
 
         if n_jobs > 1:
             eliminated["geometry"] = GeoSeries(
-                parallel_unary_union_geoseries(
+                _parallel_unary_union_geoseries(
                     pd.concat([eliminators, soon_erased, missing]),
                     level=0,
                     grid_size=grid_size,
@@ -721,7 +725,7 @@ def _eliminate(
 
     else:
         if n_jobs > 1:
-            eliminated["geometry"] = parallel_unary_union(
+            eliminated["geometry"] = _parallel_unary_union(
                 many_hits, by="_dissolve_idx", grid_size=grid_size, n_jobs=n_jobs
             )
         else:
@@ -773,16 +777,6 @@ def close_thin_holes(gdf: GeoDataFrame, tolerance: int | float) -> GeoDataFrame:
     return PolygonsAsRings(gdf).apply_numpy_func_to_interiors(to_none_if_thin).to_gdf()
 
 
-def return_correct_geometry_object(in_obj, out_obj):
-    if isinstance(in_obj, GeoDataFrame):
-        in_obj.geometry = out_obj
-        return in_obj
-    elif isinstance(in_obj, GeoSeries):
-        return GeoSeries(out_obj, crs=in_obj.crs)
-    else:
-        return out_obj
-
-
 def close_all_holes(
     gdf: GeoDataFrame | GeoSeries,
     *,
@@ -808,8 +802,8 @@ def close_all_holes(
         A GeoDataFrame or GeoSeries of polygons with closed holes in the geometry
         column.
 
-    Examples
-    --------
+    Examples:
+    ---------
     Let's create a circle with a hole in it.
 
     >>> point = sg.to_gdf([260000, 6650000], crs=25833)
@@ -897,9 +891,8 @@ def close_small_holes(
             meter units.
         ValueError: If both 'max_m2' and 'max_km2' is given.
 
-    Examples
-    --------
-
+    Examples:
+    ---------
     Let's create a circle with a hole in it.
 
     >>> point = sg.to_gdf([260000, 6650000], crs=25833)
@@ -984,7 +977,6 @@ def close_small_holes(
 
 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]
@@ -1010,7 +1002,6 @@ def _close_small_holes_no_islands(poly, max_area, all_geoms):
 
 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]
@@ -1041,6 +1032,7 @@ def get_gaps(
         gdf: GeoDataFrame of polygons.
         include_interiors: If False (default), the holes inside individual polygons
             will not be included as gaps.
+        grid_size: Rounding of the coordinates.
 
     Note:
         See get_holes to find holes inside singlepart polygons.