ssb-sgis 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

sgis/geopandas_tools/conversion.py

@@ -61,7 +61,7 @@ def to_shapely(obj) -> Geometry:
         raise TypeError(obj) from e
 
 
-def get_utm33(lon: float, lat: float, crs=25833):
+def from_4326(lon: float, lat: float, crs=25833):
     """Get utm 33 N coordinates from lonlat (4326)."""
     transformer = pyproj.Transformer.from_crs(
         "EPSG:4326", f"EPSG:{crs}", always_xy=True
@@ -69,7 +69,7 @@ def get_utm33(lon: float, lat: float, crs=25833):
     return transformer.transform(lon, lat)
 
 
-def get_lonlat(lon: float, lat: float, crs=25833):
+def to_4326(lon: float, lat: float, crs=25833):
     """Get degree coordinates  33 N coordinates from lonlat (4326)."""
     transformer = pyproj.Transformer.from_crs(
         f"EPSG:{crs}", "EPSG:4326", always_xy=True

sgis/geopandas_tools/duplicates.py

@@ -3,11 +3,9 @@ from collections.abc import Iterable
 import networkx as nx
 import pandas as pd
 from geopandas import GeoDataFrame, GeoSeries
-from shapely import STRtree, difference, intersection, make_valid, unary_union, union
-from shapely.errors import GEOSException
-from shapely.geometry import Polygon
+from shapely import STRtree, difference, make_valid, unary_union
 
-from .general import _push_geom_col, clean_geoms
+from .general import _determine_geom_type_args, _push_geom_col, clean_geoms
 from .geometry_types import get_geom_type, make_all_singlepart, to_single_geom_type
 from .overlay import clean_overlay
 
@@ -15,7 +13,7 @@ from .overlay import clean_overlay
 def update_geometries(
     gdf: GeoDataFrame,
     geom_type: str | None = None,
-    keep_geom_type: bool = True,
+    keep_geom_type: bool | None = None,
     grid_size: int | None = None,
 ) -> GeoDataFrame:
     """Puts geometries on top of each other rowwise.
@@ -80,13 +78,11 @@ def update_geometries(
     if len(gdf) <= 1:
         return gdf
 
-    if geom_type:
-        gdf = to_single_geom_type(gdf, geom_type)
-        keep_geom_type = True
-    elif keep_geom_type:
-        geom_type = get_geom_type(gdf)
-        if geom_type == "mixed":
-            raise ValueError("Cannot have mixed geometries when keep_geom_type is True")
+    gdf = make_all_singlepart(clean_geoms(gdf))
+
+    gdf, geom_type, keep_geom_type = _determine_geom_type_args(
+        gdf, geom_type, keep_geom_type
+    )
 
     geom_col = gdf._geometry_column_name
     index_mapper = {i: idx for i, idx in enumerate(gdf.index)}
@@ -100,14 +96,16 @@ def update_geometries(
     erasers = (
         pd.Series(gdf.geometry.loc[indices.values].values, index=indices.index)
         .groupby(level=0)
-        .agg(unary_union)
+        .agg(lambda x: make_valid(unary_union(x, grid_size=grid_size)))
     )
 
     # match up the aggregated erasers by index
-    erased = difference(
-        gdf.geometry.loc[erasers.index],
-        erasers,
-        grid_size=grid_size,
+    erased = make_valid(
+        difference(
+            gdf.geometry.loc[erasers.index],
+            erasers,
+            grid_size=grid_size,
+        )
     )
 
     gdf.loc[erased.index, geom_col] = erased
@@ -123,7 +121,7 @@ def update_geometries(
 
 
 def get_intersections(
-    gdf: GeoDataFrame, geom_type: str | None = None, keep_geom_type: bool = True
+    gdf: GeoDataFrame, geom_type: str | None = None, keep_geom_type: bool | None = None
 ) -> GeoDataFrame:
     """Find geometries that intersect in a GeoDataFrame.
 
@@ -203,6 +201,10 @@ def get_intersections(
     else:
         was_geoseries = False
 
+    gdf, geom_type, keep_geom_type = _determine_geom_type_args(
+        gdf, geom_type, keep_geom_type
+    )
+
     idx_name = gdf.index.name
     gdf = gdf.assign(orig_idx=gdf.index).reset_index(drop=True)
 
@@ -212,8 +214,10 @@ def get_intersections(
 
     duplicated_geoms.index = duplicated_geoms["orig_idx"].values
     duplicated_geoms.index.name = idx_name
+
     if was_geoseries:
         return duplicated_geoms.geometry
+
     return duplicated_geoms.drop(columns="orig_idx")
 
 

sgis/geopandas_tools/general.py

@@ -19,6 +19,7 @@ from shapely import (
     linestrings,
     make_valid,
 )
+from shapely import points as shapely_points
 from shapely.geometry import LineString, Point
 from shapely.ops import unary_union
 
@@ -304,7 +305,7 @@ def sort_long_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
         gdf: A GeoDataFrame or GeoSeries.
 
     Returns:
-        A GeoDataFrame or GeoSeries sorted from large to small in length.
+        A GeoDataFrame or GeoSeries sorted from long to short in length.
     """
     # using enumerate, then iloc on the sorted dict keys.
     # to avoid creating a temporary area column (which doesn't work for GeoSeries).
@@ -315,6 +316,39 @@ def sort_long_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
     return gdf.iloc[list(sorted_lengths)]
 
 
+def sort_short_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
+    """Sort GeoDataFrame by length in ascending order.
+
+    Args:
+        gdf: A GeoDataFrame or GeoSeries.
+
+    Returns:
+        A GeoDataFrame or GeoSeries sorted from short to long in length.
+    """
+    # using enumerate, then iloc on the sorted dict keys.
+    # to avoid creating a temporary area column (which doesn't work for GeoSeries).
+    length_mapper = dict(enumerate(gdf.length.values))
+    sorted_lengths = dict(sorted(length_mapper.items(), key=lambda item: item[1]))
+    return gdf.iloc[list(sorted_lengths)]
+
+
+def sort_small_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
+    """Sort GeoDataFrame by area in ascending order.
+
+    Args:
+        gdf: A GeoDataFrame or GeoSeries.
+
+    Returns:
+        A GeoDataFrame or GeoSeries sorted from small to large in area.
+
+    """
+    # using enumerate, then iloc on the sorted dict keys.
+    # to avoid creating a temporary area column (which doesn't work for GeoSeries).
+    area_mapper = dict(enumerate(gdf.area.values))
+    sorted_areas = dict(sorted(area_mapper.items(), key=lambda item: item[1]))
+    return gdf.iloc[list(sorted_areas)]
+
+
 def make_lines_between_points(
     arr1: NDArray[Point] | GeometryArray | GeoSeries,
     arr2: NDArray[Point] | GeometryArray | GeoSeries,
@@ -405,6 +439,28 @@ def random_points(n: int, loc: float | int = 0.5) -> GeoDataFrame:
     )
 
 
+def random_points_in_polygons(gdf: GeoDataFrame, n: int, seed=None) -> GeoDataFrame:
+    all_points = []
+
+    rng = np.random.default_rng(seed)
+
+    for i, geom in enumerate(gdf.geometry):
+        minx, miny, maxx, maxy = geom.bounds
+
+        xs = rng.uniform(minx, maxx, size=n * 500)
+        ys = rng.uniform(miny, maxy, size=n * 500)
+
+        points = GeoSeries(shapely_points(xs, y=ys), index=[i] * len(xs))
+        all_points.append(points)
+
+    return (
+        pd.concat(all_points)
+        .loc[lambda x: x.intersects(gdf.geometry)]
+        .groupby(level=0)
+        .head(n)
+    )
+
+
 def to_lines(*gdfs: GeoDataFrame, copy: bool = True) -> GeoDataFrame:
     """Makes lines out of one or more GeoDataFrames and splits them at intersections.
 
@@ -527,7 +583,7 @@ def to_lines(*gdfs: GeoDataFrame, copy: bool = True) -> GeoDataFrame:
 def clean_clip(
     gdf: GeoDataFrame | GeoSeries,
     mask: GeoDataFrame | GeoSeries | Geometry,
-    keep_geom_type: bool = True,
+    keep_geom_type: bool | None = None,
     geom_type: str | None = None,
     **kwargs,
 ) -> GeoDataFrame | GeoSeries:
@@ -540,6 +596,12 @@ def clean_clip(
     Args:
         gdf: GeoDataFrame or GeoSeries to be clipped
         mask: the geometry to clip gdf
+        geom_type: Optionally specify what geometry type to keep.,
+            if there are mixed geometry types. Must be either "polygon",
+            "line" or "point".
+        keep_geom_type: Defaults to None, meaning True if 'geom_type' is given
+            and True if the geometries are single-typed and False if the geometries
+            are mixed.
         **kwargs: Keyword arguments passed to geopandas.GeoDataFrame.clip
 
     Returns:
@@ -551,12 +613,9 @@ def clean_clip(
     if not isinstance(gdf, (GeoDataFrame, GeoSeries)):
         raise TypeError(f"'gdf' should be GeoDataFrame or GeoSeries, got {type(gdf)}")
 
-    if geom_type is None and keep_geom_type:
-        geom_type = get_geom_type(gdf)
-        if geom_type == "mixed":
-            raise ValueError(
-                "Mixed geometry types is not allowed when keep_geom_type is True."
-            )
+    gdf, geom_type, keep_geom_type = _determine_geom_type_args(
+        gdf, geom_type, keep_geom_type
+    )
 
     try:
         gdf = gdf.clip(mask, **kwargs).pipe(clean_geoms)
@@ -569,7 +628,26 @@ def clean_clip(
 
         return gdf.clip(mask, **kwargs).pipe(clean_geoms)
 
-    if geom_type is not None or keep_geom_type:
+    if keep_geom_type:
         gdf = to_single_geom_type(gdf, geom_type)
 
     return gdf
+
+
+def _determine_geom_type_args(
+    gdf: GeoDataFrame, geom_type: str | None, keep_geom_type: bool | None
+) -> tuple[GeoDataFrame, str, bool]:
+    if geom_type:
+        gdf = to_single_geom_type(gdf, geom_type)
+        keep_geom_type = True
+    elif keep_geom_type is None:
+        geom_type = get_geom_type(gdf)
+        if geom_type == "mixed":
+            keep_geom_type = False
+        else:
+            keep_geom_type = True
+    elif keep_geom_type:
+        geom_type = get_geom_type(gdf)
+        if geom_type == "mixed":
+            raise ValueError("Cannot set keep_geom_type=True with mixed geometries")
+    return gdf, geom_type, keep_geom_type

sgis/geopandas_tools/overlay.py

@@ -7,6 +7,8 @@ version of the solution from GH 2792.
 'clean_overlay' also includes the overlay type "update", which can be specified in the
 "how" parameter, in addition to the five native geopandas how-s.
 """
+import functools
+
 import geopandas as gpd
 import numpy as np
 import pandas as pd
@@ -409,9 +411,11 @@ def _shapely_diffclip_left(pairs, df1, grid_size):
     """Aggregate areas in right by unique values of left, then use those to clip
     areas out of left"""
 
+    agg_geoms_partial = functools.partial(agg_geoms, grid_size=grid_size)
+
     clip_left = pairs.groupby(level=0).agg(
         {
-            "geom_right": agg_geoms,
+            "geom_right": agg_geoms_partial,
             **{
                 c: "first"
                 for c in df1.columns
@@ -433,12 +437,14 @@ def _shapely_diffclip_left(pairs, df1, grid_size):
 
 
 def _shapely_diffclip_right(pairs, df1, df2, grid_size, rsuffix):
+    agg_geoms_partial = functools.partial(agg_geoms, grid_size=grid_size)
+
     clip_right = (
         pairs.rename(columns={"geometry": "geom_left", "geom_right": "geometry"})
         .groupby(by="_overlay_index_right")
         .agg(
             {
-                "geom_left": agg_geoms,
+                "geom_left": agg_geoms_partial,
                 "geometry": "first",
             }
         )
@@ -479,5 +485,7 @@ def _try_difference(left, right, grid_size):
         )
 
 
-def agg_geoms(g):
-    return make_valid(unary_union(g)) if len(g) > 1 else make_valid(g)
+def agg_geoms(g, grid_size=None):
+    return (
+        make_valid(unary_union(g, grid_size=grid_size)) if len(g) > 1 else make_valid(g)
+    )

sgis/geopandas_tools/polygon_operations.py

@@ -203,6 +203,7 @@ def eliminate_by_longest(
     fix_double: bool = True,
     ignore_index: bool = False,
     aggfunc: str | dict | list | None = None,
+    grid_size=None,
     **kwargs,
 ) -> GeoDataFrame | tuple[GeoDataFrame]:
     """Dissolves selected polygons with the longest bordering neighbor polygon.
@@ -236,6 +237,33 @@ def eliminate_by_longest(
     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
+    --------
+
+    Create two polygons with a sliver in between:
+
+    >>> sliver = sg.to_gdf(Polygon([(0, 0), (0.1, 1), (0, 2), (-0.1, 1)]))
+    >>> small_poly = sg.to_gdf(
+    ...     Polygon([(0, 0), (-0.1, 1), (0, 2), (-1, 2), (-2, 2), (-1, 1)])
+    ... )
+    >>> large_poly = sg.to_gdf(
+    ...     Polygon([(0, 0), (0.1, 1), (1, 2), (2, 2), (3, 2), (3, 0)])
+    ... )
+
+    Using multiple GeoDataFrame as input, the sliver is eliminated into the small
+    polygon (because it has the longest border with sliver).
+
+    >>> small_poly_eliminated, large_poly_eliminated = sg.eliminate_by_longest(
+    ...     [small_poly, large_poly], sliver
+    ... )
+
+    With only one input GeoDataFrame:
+
+    >>> polys = pd.concat([small_poly, large_poly])
+    >>> eliminated = sg.eliminate_by_longest(polys, sliver)
+
+
     """
     if isinstance(gdf, (list, tuple)):
         # concat, then break up the dataframes in the end
@@ -297,6 +325,7 @@ def eliminate_by_longest(
         aggfunc,
         crs,
         fix_double,
+        grid_size=grid_size,
         **kwargs,
     )
 
@@ -341,6 +370,7 @@ def eliminate_by_largest(
     ignore_index: bool = False,
     aggfunc: str | dict | list | None = None,
     predicate: str = "intersects",
+    grid_size=None,
     **kwargs,
 ) -> GeoDataFrame | tuple[GeoDataFrame]:
     """Dissolves selected polygons with the largest neighbor polygon.
@@ -374,6 +404,31 @@ def eliminate_by_largest(
         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
+    --------
+
+    Create two polygons with a sliver in between:
+
+    >>> sliver = sg.to_gdf(Polygon([(0, 0), (0.1, 1), (0, 2), (-0.1, 1)]))
+    >>> small_poly = sg.to_gdf(
+    ...     Polygon([(0, 0), (-0.1, 1), (0, 2), (-1, 2), (-2, 2), (-1, 1)])
+    ... )
+    >>> large_poly = sg.to_gdf(
+    ...     Polygon([(0, 0), (0.1, 1), (1, 2), (2, 2), (3, 2), (3, 0)])
+    ... )
+
+    Using multiple GeoDataFrame as input, the sliver is eliminated into
+    the large polygon.
+
+    >>> small_poly_eliminated, large_poly_eliminated = sg.eliminate_by_largest(
+    ...     [small_poly, large_poly], sliver
+    ... )
+
+    With only one input GeoDataFrame:
+
+    >>> polys = pd.concat([small_poly, large_poly])
+    >>> eliminated = sg.eliminate_by_largest(polys, sliver)
+
     """
     return _eliminate_by_area(
         gdf,
@@ -385,6 +440,7 @@ def eliminate_by_largest(
         aggfunc=aggfunc,
         predicate=predicate,
         fix_double=fix_double,
+        grid_size=grid_size,
         **kwargs,
     )
 
@@ -399,6 +455,7 @@ def eliminate_by_smallest(
     aggfunc: str | dict | list | None = None,
     predicate: str = "intersects",
     fix_double: bool = False,
+    grid_size=None,
     **kwargs,
 ) -> GeoDataFrame | tuple[GeoDataFrame]:
     return _eliminate_by_area(
@@ -411,6 +468,7 @@ def eliminate_by_smallest(
         aggfunc=aggfunc,
         predicate=predicate,
         fix_double=fix_double,
+        grid_size=grid_size,
         **kwargs,
     )
 
@@ -425,6 +483,7 @@ def _eliminate_by_area(
     aggfunc: str | dict | list | None = None,
     predicate="intersects",
     fix_double: bool = False,
+    grid_size=None,
     **kwargs,
 ) -> GeoDataFrame:
     if isinstance(gdf, (list, tuple)):
@@ -468,7 +527,9 @@ def _eliminate_by_area(
 
     notna = joined.loc[lambda x: x["_dissolve_idx"].notna()]
 
-    eliminated = _eliminate(gdf, notna, aggfunc, crs, fix_double=fix_double, **kwargs)
+    eliminated = _eliminate(
+        gdf, notna, aggfunc, crs, fix_double=fix_double, grid_size=grid_size, **kwargs
+    )
 
     if not ignore_index:
         eliminated.index = eliminated.index.map(idx_mapper)
@@ -503,7 +564,7 @@ def _eliminate_by_area(
     return gdfs
 
 
-def _eliminate(gdf, to_eliminate, aggfunc, crs, fix_double, **kwargs):
+def _eliminate(gdf, to_eliminate, aggfunc, crs, fix_double, grid_size, **kwargs):
     if not len(to_eliminate):
         return gdf
 
@@ -660,8 +721,12 @@ def _eliminate(gdf, to_eliminate, aggfunc, crs, fix_double, **kwargs):
 
         # allign and aggregate by dissolve index to not get duplicates in difference
         intersecting.index = soon_erased.index
-        soon_erased = soon_erased.geometry.groupby(level=0).agg(unary_union)
-        intersecting = intersecting.groupby(level=0).agg(unary_union)
+        soon_erased = soon_erased.geometry.groupby(level=0).agg(
+            lambda x: unary_union(x, grid_size=grid_size)
+        )
+        intersecting = intersecting.groupby(level=0).agg(
+            lambda x: unary_union(x, grid_size=grid_size)
+        )
 
         # from ..maps.maps import explore_locals
         # explore_locals()
@@ -674,12 +739,16 @@ def _eliminate(gdf, to_eliminate, aggfunc, crs, fix_double, **kwargs):
         eliminated["geometry"] = (
             pd.concat([eliminators, soon_erased, missing])
             .groupby(level=0)
-            .agg(lambda x: make_valid(unary_union(x.dropna().values)))
+            .agg(
+                lambda x: make_valid(
+                    unary_union(x.dropna().values, grid_size=grid_size)
+                )
+            )
         )
 
     else:
         eliminated["geometry"] = many_hits.groupby("_dissolve_idx")["geometry"].agg(
-            lambda x: make_valid(unary_union(x.values))
+            lambda x: make_valid(unary_union(x.values, grid_size=grid_size))
         )
 
     # setting crs on the GeometryArrays to avoid warning in concat
@@ -973,7 +1042,11 @@ def _close_all_holes_no_islands(poly, all_geoms):
     return make_valid(unary_union(holes_closed))
 
 
-def get_gaps(gdf: GeoDataFrame, include_interiors: bool = False) -> GeoDataFrame:
+def get_gaps(
+    gdf: GeoDataFrame,
+    include_interiors: bool = False,
+    grid_size: float | int | None = None,
+) -> GeoDataFrame:
     """Get the gaps between polygons.
 
     Args:
@@ -998,7 +1071,9 @@ def get_gaps(gdf: GeoDataFrame, include_interiors: bool = False) -> GeoDataFrame
     )
 
     bbox_diff = make_all_singlepart(
-        clean_overlay(bbox, gdf, how="difference", geom_type="polygon")
+        clean_overlay(
+            bbox, gdf, how="difference", geom_type="polygon", grid_size=grid_size
+        )
     )
 
     # remove the outer "gap", i.e. the surrounding area

sgis/geopandas_tools/sfilter.py

@@ -11,59 +11,6 @@ from .conversion import to_gdf
 gdf_type_error_message = "'gdf' should be of type GeoDataFrame or GeoSeries."
 
 
-def _get_sfilter_indices(
-    left: GeoDataFrame | GeoSeries,
-    right: GeoDataFrame | GeoSeries | Geometry,
-    predicate: str,
-) -> np.ndarray:
-    """Compute geometric comparisons and get matching indices.
-
-    Taken from:
-    geopandas.tools.sjoin._geom_predicate_query
-
-    Parameters
-    ----------
-    left : GeoDataFrame
-    right : GeoDataFrame
-    predicate : string
-        Binary predicate to query.
-
-    Returns
-    -------
-    DataFrame
-        DataFrame with matching indices in
-        columns named `_key_left` and `_key_right`.
-    """
-    original_predicate = predicate
-
-    with warnings.catch_warnings():
-        # We don't need to show our own warning here
-        # TODO remove this once the deprecation has been enforced
-        warnings.filterwarnings(
-            "ignore", "Generated spatial index is empty", FutureWarning
-        )
-
-        if predicate == "within":
-            # within is implemented as the inverse of contains
-            # contains is a faster predicate
-            # see discussion at https://github.com/geopandas/geopandas/pull/1421
-            predicate = "contains"
-            sindex = left.sindex
-            input_geoms = right.geometry if isinstance(right, GeoDataFrame) else right
-        else:
-            # all other predicates are symmetric
-            # keep them the same
-            sindex = right.sindex
-            input_geoms = left.geometry if isinstance(left, GeoDataFrame) else left
-
-    l_idx, r_idx = sindex.query(input_geoms, predicate=predicate, sort=False)
-
-    if original_predicate == "within":
-        return np.unique(r_idx)
-
-    return np.unique(l_idx)
-
-
 def sfilter(
     gdf: GeoDataFrame | GeoSeries,
     other: GeoDataFrame | GeoSeries | Geometry,
@@ -290,3 +237,56 @@ def _sfilter_checks(other, crs):
             raise ValueError("crs mismatch", crs, other.crs) from e
 
     return other
+
+
+def _get_sfilter_indices(
+    left: GeoDataFrame | GeoSeries,
+    right: GeoDataFrame | GeoSeries | Geometry,
+    predicate: str,
+) -> np.ndarray:
+    """Compute geometric comparisons and get matching indices.
+
+    Taken from:
+    geopandas.tools.sjoin._geom_predicate_query
+
+    Parameters
+    ----------
+    left : GeoDataFrame
+    right : GeoDataFrame
+    predicate : string
+        Binary predicate to query.
+
+    Returns
+    -------
+    DataFrame
+        DataFrame with matching indices in
+        columns named `_key_left` and `_key_right`.
+    """
+    original_predicate = predicate
+
+    with warnings.catch_warnings():
+        # We don't need to show our own warning here
+        # TODO remove this once the deprecation has been enforced
+        warnings.filterwarnings(
+            "ignore", "Generated spatial index is empty", FutureWarning
+        )
+
+        if predicate == "within":
+            # within is implemented as the inverse of contains
+            # contains is a faster predicate
+            # see discussion at https://github.com/geopandas/geopandas/pull/1421
+            predicate = "contains"
+            sindex = left.sindex
+            input_geoms = right.geometry if isinstance(right, GeoDataFrame) else right
+        else:
+            # all other predicates are symmetric
+            # keep them the same
+            sindex = right.sindex
+            input_geoms = left.geometry if isinstance(left, GeoDataFrame) else left
+
+    l_idx, r_idx = sindex.query(input_geoms, predicate=predicate, sort=False)
+
+    if original_predicate == "within":
+        return np.unique(r_idx)
+
+    return np.unique(l_idx)

sgis/helpers.py

@@ -219,6 +219,14 @@ def sort_nans_last(df, ignore_index: bool = False):
     return df.reset_index(drop=True) if ignore_index else df
 
 
+def is_number(text) -> bool:
+    try:
+        float(text)
+        return True
+    except ValueError:
+        return False
+
+
 class LocalFunctionError(ValueError):
     def __init__(self, func: str):
         self.func = func.__name__

sgis/io/dapla_functions.py

@@ -52,6 +52,8 @@ def read_geopandas(
             try:
                 return gpd.read_parquet(file, **kwargs)
             except ValueError as e:
+                if "Missing geo metadata" not in str(e) and "geometry" not in str(e):
+                    raise e
                 df = dp.read_pandas(gcs_path, **kwargs)
 
                 if pandas_fallback or not len(df):
@@ -63,6 +65,8 @@ def read_geopandas(
             try:
                 return gpd.read_file(file, **kwargs)
             except ValueError as e:
+                if "Missing geo metadata" not in str(e) and "geometry" not in str(e):
+                    raise e
                 df = dp.read_pandas(gcs_path, **kwargs)
 
                 if pandas_fallback or not len(df):
@@ -75,6 +79,7 @@ def write_geopandas(
     df: gpd.GeoDataFrame,
     gcs_path: str | Path,
     overwrite: bool = True,
+    pandas_fallback: bool = False,
     fs: Optional[dp.gcs.GCSFileSystem] = None,
     **kwargs,
 ) -> None:
@@ -106,12 +111,10 @@ def write_geopandas(
     pd.io.parquet.BaseImpl.validate_dataframe(df)
 
     if not len(df):
-        try:
-            dp.write_pandas(df, gcs_path, **kwargs)
-        except Exception:
-            dp.write_pandas(
-                df.drop(df._geometry_column_name, axis=1), gcs_path, **kwargs
-            )
+        if pandas_fallback:
+            df.geometry = df.geometry.astype(str)
+            df = pd.DataFrame(df)
+        dp.write_pandas(df, gcs_path, **kwargs)
         return
 
     fs = dp.FileClient.get_gcs_file_system()