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

sgis/geopandas_tools/general.py

@@ -1,30 +1,39 @@
 import numbers
 import warnings
-from collections.abc import Hashable, Iterable
+from collections.abc import Hashable
+from collections.abc import Iterable
 from typing import Any
 
 import joblib
 import numpy as np
 import pandas as pd
 import pyproj
-from geopandas import GeoDataFrame, GeoSeries
-from geopandas.array import GeometryArray, GeometryDtype
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
+from geopandas.array import GeometryArray
+from geopandas.array import GeometryDtype
 from numpy.typing import NDArray
-from shapely import (
-    Geometry,
-    get_coordinates,
-    get_exterior_ring,
-    get_interior_ring,
-    get_num_interior_rings,
-    get_parts,
-    linestrings,
-    make_valid,
-)
+from shapely import Geometry
+from shapely import get_coordinates
+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 linestrings
+from shapely import make_valid
 from shapely import points as shapely_points
 from shapely import unary_union
-from shapely.geometry import LineString, Point
+from shapely.geometry import LineString
+from shapely.geometry import Point
 
-from .geometry_types import get_geom_type, make_all_singlepart, to_single_geom_type
+try:
+    import dask_geopandas
+except ImportError:
+    pass
+
+from .geometry_types import get_geom_type
+from .geometry_types import make_all_singlepart
+from .geometry_types import to_single_geom_type
 
 
 def split_geom_types(gdf: GeoDataFrame | GeoSeries) -> tuple[GeoDataFrame | GeoSeries]:
@@ -79,13 +88,13 @@ def get_common_crs(
             actually_different.add(x)
 
         if len(actually_different) == 1:
-            return list(actually_different)[0]
+            return next(iter(actually_different))
         raise ValueError("'crs' mismatch.", truthy_crs)
 
     return pyproj.CRS(truthy_crs[0])
 
 
-def is_bbox_like(obj) -> bool:
+def is_bbox_like(obj: Any) -> bool:
     if (
         hasattr(obj, "__iter__")
         and len(obj) == 4
@@ -114,6 +123,7 @@ def _push_geom_col(gdf: GeoDataFrame) -> GeoDataFrame:
 
 
 def drop_inactive_geometry_columns(gdf: GeoDataFrame) -> GeoDataFrame:
+    """Removes geometry columns in a GeoDataFrame if they are not active."""
     for col in gdf.columns:
         if (
             isinstance(gdf[col].dtype, GeometryDtype)
@@ -123,7 +133,7 @@ def drop_inactive_geometry_columns(gdf: GeoDataFrame) -> GeoDataFrame:
     return gdf
 
 
-def rename_geometry_if(gdf: GeoDataFrame) -> GeoDataFrame:
+def _rename_geometry_if(gdf: GeoDataFrame) -> GeoDataFrame:
     geom_col = gdf._geometry_column_name
     if geom_col == "geometry" and geom_col in gdf.columns:
         return gdf
@@ -157,8 +167,8 @@ def clean_geoms(
         GeoDataFrame or GeoSeries with fixed geometries and only the rows with valid,
         non-empty and not-NaN/-None geometries.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> import sgis as sg
     >>> import pandas as pd
     >>> from shapely import wkt
@@ -231,8 +241,20 @@ def clean_geoms(
 
 
 def get_grouped_centroids(
-    gdf: GeoDataFrame, groupby: str, as_string: bool = True
+    gdf: GeoDataFrame, groupby: str | list[str], as_string: bool = True
 ) -> pd.Series:
+    """Get the centerpoint of the geometries within a group.
+
+    Args:
+        gdf: GeoDataFrame.
+        groupby: column to group by.
+        as_string: If True (default), coordinates are returned in
+            the format "{x}_{y}". If False, coordinates are returned
+            as Points.
+
+    Returns:
+        A pandas.Series of grouped centroids with the index of 'gdf'.
+    """
     centerpoints = gdf.assign(geometry=lambda x: x.centroid)
 
     grouped_centerpoints = centerpoints.dissolve(by=groupby).assign(
@@ -242,9 +264,13 @@ def get_grouped_centroids(
     ys = grouped_centerpoints.geometry.y
 
     if as_string:
-        grouped_centerpoints["wkt"] = [f"{int(x)}_{int(y)}" for x, y in zip(xs, ys)]
+        grouped_centerpoints["wkt"] = [
+            f"{int(x)}_{int(y)}" for x, y in zip(xs, ys, strict=False)
+        ]
     else:
-        grouped_centerpoints["wkt"] = [Point(x, y) for x, y in zip(xs, ys)]
+        grouped_centerpoints["wkt"] = [
+            Point(x, y) for x, y in zip(xs, ys, strict=False)
+        ]
 
     return gdf[groupby].map(grouped_centerpoints["wkt"])
 
@@ -258,12 +284,20 @@ def sort_large_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
     Returns:
         A GeoDataFrame or GeoSeries sorted from large to small in area.
 
-    Examples
-    --------
+    Examples:
+    ---------
     Create GeoDataFrame with NaN values.
 
     >>> import sgis as sg
-    >>> df = sg.random_points(5)
+    >>> df = sg.to_gdf(
+    ...     [
+    ...         (0, 1),
+    ...         (1, 0),
+    ...         (1, 1),
+    ...         (0, 0),
+    ...         (0.5, 0.5),
+    ...     ]
+    ... )
     >>> df.geometry = df.buffer([4, 1, 2, 3, 5])
     >>> df["col"] = [None, 1, 2, None, 1]
     >>> df["col2"] = [None, 1, 2, 3, None]
@@ -299,16 +333,6 @@ def sort_large_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
     return gdf.iloc[list(sorted_areas)]
 
 
-def sort_df(
-    df: pd.DataFrame | GeoDataFrame, sort_col: pd.Series
-) -> pd.DataFrame | GeoDataFrame:
-    value_mapper: dict[int, Any] = dict(enumerate(sort_col.values))
-    sorted_indices = dict(
-        reversed(sorted(value_mapper.items(), key=lambda item: item[1]))
-    )
-    return df.iloc[list(sorted_indices)]
-
-
 def sort_long_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
     """Sort GeoDataFrame by length in decending order.
 
@@ -402,8 +426,8 @@ def random_points(n: int, loc: float | int = 0.5) -> GeoDataFrame:
     Returns:
         A GeoDataFrame of points with n rows.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> import sgis as sg
     >>> points = sg.random_points(10_000)
     >>> points
@@ -451,6 +475,16 @@ def random_points(n: int, loc: float | int = 0.5) -> GeoDataFrame:
 
 
 def random_points_in_polygons(gdf: GeoDataFrame, n: int, seed=None) -> GeoDataFrame:
+    """Creates a GeoDataFrame with n random points within the geometries of 'gdf'.
+
+    Args:
+        gdf: A GeoDataFrame.
+        n: Number of points/rows to create.
+        seed: Optional random seet.
+
+    Returns:
+        A GeoDataFrame of points with n rows.
+    """
     all_points = []
 
     rng = np.random.default_rng(seed)
@@ -492,8 +526,8 @@ def to_lines(*gdfs: GeoDataFrame, copy: bool = True) -> GeoDataFrame:
         ignored. This is because the union overlay used if multiple GeoDataFrames
         always ignores the index.
 
-    Examples
-    --------
+    Examples:
+    ---------
     Convert single polygon to linestring.
 
     >>> import sgis as sg
@@ -525,7 +559,6 @@ def to_lines(*gdfs: GeoDataFrame, copy: bool = True) -> GeoDataFrame:
     >>> lines["l"] = lines.length
     >>> sg.qtm(lines, "l")
     """
-
     if not all(isinstance(gdf, (GeoSeries, GeoDataFrame)) for gdf in gdfs):
         raise TypeError("gdf must be GeoDataFrame or GeoSeries")
 
@@ -534,7 +567,6 @@ def to_lines(*gdfs: GeoDataFrame, copy: bool = True) -> GeoDataFrame:
 
     def _shapely_geometry_to_lines(geom):
         """Get all lines from the exterior and interiors of a Polygon."""
-
         # if lines (points are not allowed in this function)
         if geom.area == 0:
             return geom
@@ -664,11 +696,11 @@ def _determine_geom_type_args(
     return gdf, geom_type, keep_geom_type
 
 
-def merge_geometries(geoms: GeoSeries, grid_size=None) -> Geometry:
+def _merge_geometries(geoms: GeoSeries, grid_size=None) -> Geometry:
     return make_valid(unary_union(geoms, grid_size=grid_size))
 
 
-def parallel_unary_union(
+def _parallel_unary_union(
     gdf: GeoDataFrame, n_jobs: int = 1, by=None, grid_size=None, **kwargs
 ) -> list[Geometry]:
     try:
@@ -702,7 +734,7 @@ def parallel_unary_union(
     return dissolved.geometry
 
 
-def parallel_unary_union_geoseries(
+def _parallel_unary_union_geoseries(
     ser: GeoSeries, n_jobs: int = 1, grid_size=None, **kwargs
 ) -> list[Geometry]:
     if ser.crs is None:
@@ -725,7 +757,7 @@ def parallel_unary_union_geoseries(
     return dissolved.geometry
 
 
-def parallel_unary_union(
+def _parallel_unary_union(
     gdf: GeoDataFrame, n_jobs: int = 1, by=None, grid_size=None, **kwargs
 ) -> list[Geometry]:
     try:
@@ -737,13 +769,13 @@ def parallel_unary_union(
         delayed_operations = []
         for _, geoms in gdf.groupby(by, **kwargs)[geom_col]:
             delayed_operations.append(
-                joblib.delayed(merge_geometries)(geoms, grid_size=grid_size)
+                joblib.delayed(_merge_geometries)(geoms, grid_size=grid_size)
             )
 
         return parallel(delayed_operations)
 
 
-def parallel_unary_union_geoseries(
+def _parallel_unary_union_geoseries(
     ser: GeoSeries, n_jobs: int = 1, grid_size=None, **kwargs
 ) -> list[Geometry]:
 
@@ -756,18 +788,18 @@ def parallel_unary_union_geoseries(
         delayed_operations = []
         for _, geoms in many_hits.groupby(**kwargs):
             delayed_operations.append(
-                joblib.delayed(merge_geometries)(geoms, grid_size=grid_size)
+                joblib.delayed(_merge_geometries)(geoms, grid_size=grid_size)
             )
 
         dissolved = pd.Series(
             parallel(delayed_operations),
-            index=is_one_hit[lambda x: x == False].index.unique(),
+            index=is_one_hit[lambda x: x is False].index.unique(),
         )
 
     return pd.concat([dissolved, one_hit]).sort_index().values
 
 
-def parallel_unary_union_geoseries(
+def _parallel_unary_union_geoseries(
     ser: GeoSeries, n_jobs: int = 1, grid_size=None, **kwargs
 ) -> list[Geometry]:
 
@@ -775,7 +807,7 @@ def parallel_unary_union_geoseries(
         delayed_operations = []
         for _, geoms in ser.groupby(**kwargs):
             delayed_operations.append(
-                joblib.delayed(merge_geometries)(geoms, grid_size=grid_size)
+                joblib.delayed(_merge_geometries)(geoms, grid_size=grid_size)
             )
 
         return parallel(delayed_operations)

sgis/geopandas_tools/geometry_types.py

@@ -1,8 +1,10 @@
 """Check and set geometry type."""
+
 import numpy as np
 import pandas as pd
 import shapely
-from geopandas import GeoDataFrame, GeoSeries
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
 from geopandas.array import GeometryArray
 from shapely import Geometry
 
@@ -10,6 +12,18 @@ from shapely import Geometry
 def make_all_singlepart(
     gdf: GeoDataFrame | GeoSeries, index_parts: bool = False, ignore_index: bool = False
 ) -> GeoDataFrame | GeoSeries:
+    """Make all geometries single part.
+
+    This means doing either 0, 1 or 2 calls to the explode method.
+
+    Args:
+        gdf: GeoDataFrame
+        index_parts: Defaults to False.
+        ignore_index: Defaults to False.
+
+    Returns:
+        A GeoDataFrame of singlepart geometries.
+    """
     # only explode if nessecary
     if (
         index_parts or ignore_index
@@ -25,7 +39,7 @@ def make_all_singlepart(
 
 
 def to_single_geom_type(
-    gdf: GeoDataFrame | GeoSeries,
+    gdf: GeoDataFrame | GeoSeries | Geometry | GeometryArray | np.ndarray,
     geom_type: str,
     ignore_index: bool = False,
 ) -> GeoDataFrame | GeoSeries:
@@ -49,8 +63,8 @@ def to_single_geom_type(
         TypeError: If incorrect gdf type.
         ValueError: If 'geom_type' is neither 'polygon', 'line' or 'point'.
 
-    Examples
-    --------
+    Examples:
+    ---------
     First create a GeoDataFrame of mixed geometries.
 
     >>> from sgis import to_gdf, to_single_geom_type
@@ -96,7 +110,7 @@ def to_single_geom_type(
         arr = np.vectorize(_shapely_to_single_geom_type)(gdf, geom_type)
         return arr[~shapely.is_empty(arr)]
 
-    if not isinstance(gdf, (GeoDataFrame, GeoSeries)):
+    if not isinstance(gdf, (GeoDataFrame, GeoSeries)):  # type: ignore [unreachable]
         raise TypeError(f"'gdf' should be GeoDataFrame or GeoSeries, got {type(gdf)}")
 
     # explode collections to single-typed geometries
@@ -122,7 +136,7 @@ def to_single_geom_type(
     return gdf.reset_index(drop=True) if ignore_index else gdf
 
 
-def _shapely_to_single_geom_type(geom, geom_type):
+def _shapely_to_single_geom_type(geom: Geometry, geom_type: str) -> Geometry:
     parts = shapely.get_parts(geom)
     return shapely.unary_union(
         [part for part in parts if geom_type.lower() in part.geom_type.lower()]
@@ -141,8 +155,8 @@ def get_geom_type(gdf: GeoDataFrame | GeoSeries) -> str:
     Raises:
         TypeError: If 'gdf' is not of type GeoDataFrame or GeoSeries.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import to_gdf, get_geom_type
     >>> gdf = to_gdf([0, 0])
     >>> gdf
@@ -189,8 +203,8 @@ def is_single_geom_type(gdf: GeoDataFrame | GeoSeries) -> bool:
     Raises:
         TypeError: If 'gdf' is not of type GeoDataFrame or GeoSeries.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import to_gdf, get_geom_type
     >>> gdf = to_gdf([0, 0])
     >>> gdf

sgis/geopandas_tools/neighbors.py

@@ -10,9 +10,10 @@ types.
 
 import numpy as np
 import shapely
-from geopandas import GeoDataFrame, GeoSeries
-from pandas import DataFrame, Series, concat
-from shapely import STRtree
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
+from pandas import DataFrame
+from pandas import Series
 from sklearn.neighbors import NearestNeighbors
 
 from .conversion import coordinate_array
@@ -48,8 +49,8 @@ def get_neighbor_indices(
         ValueError: If gdf and neighbors do not have the same coordinate reference
             system.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import get_neighbor_indices, to_gdf
     >>> points = to_gdf([(0, 0), (0.5, 0.5)])
     >>> points
@@ -96,7 +97,6 @@ def get_neighbor_indices(
     ['a' 'a' 'b' 'b']
 
     """
-
     if gdf.crs != neighbors.crs:
         raise ValueError(f"'crs' mismatch. Got {gdf.crs} and {neighbors.crs}")
 
@@ -152,8 +152,8 @@ def get_all_distances(
         ValueError: If the coordinate reference system of 'gdf' and 'neighbors' are
             not the same.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import get_all_distances, random_points
     >>> points = random_points(100)
     >>> neighbors = random_points(100)
@@ -248,7 +248,6 @@ def sjoin_within_distance(
     **kwargs,
 ) -> GeoDataFrame:
     """Sjoin with a buffer on the right GeoDataFrame and adds a distance column."""
-
     new_neighbor_cols = {"__left_range_idx": range(len(neighbors))}
     if distance:
         new_neighbor_cols[neighbors._geometry_column_name] = lambda x: x.buffer(
@@ -297,8 +296,8 @@ def get_k_nearest_neighbors(
         ValueError: If the coordinate reference system of 'gdf' and 'neighbors' are
             not the same.
 
-    Examples
-    --------
+    Examples:
+    ---------
     Make some random points.
 
     >>> from sgis import get_k_nearest_neighbors, random_points
@@ -430,6 +429,19 @@ def k_nearest_neighbors(
     k: int | None = None,
     strict: bool = False,
 ) -> tuple[np.ndarray[float], np.ndarray[int]]:
+    """Finds nearest neighbors for an array of coordinates to another array of coordinates.
+
+    Args:
+        from_array: Numpy array of coordinates.
+        to_array: Numpy array of coordinates.
+        k: Number of neighbors to find.
+        strict: If True (not default), an exception is raised
+            if k is larger than the length of 'to_array'.
+
+    Returns a tuple of arrays, one with distances and one with indices
+        of the neighbors.
+
+    """
     if not len(to_array) or not len(from_array):
         return np.array([]), np.array([])