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

sgis/geopandas_tools/polygons_as_rings.py

@@ -1,6 +1,4 @@
-import functools
-import itertools
-from typing import Callable, Iterable
+from typing import Any, Callable, Iterable
 
 import geopandas as gpd
 import igraph
@@ -56,7 +54,7 @@ from shapely.geometry import (
     Polygon,
 )
 
-from .conversion import to_gdf
+from .conversion import to_gdf, to_geoseries
 
 
 class PolygonsAsRings:
@@ -71,6 +69,7 @@ class PolygonsAsRings:
         if not isinstance(polys, pd.DataFrame):
             polys = to_gdf(polys, crs)
 
+        self._index_mapper = dict(enumerate(polys.index))
         self.gdf = polys.reset_index(drop=True)
 
         if crs is not None:
@@ -161,7 +160,11 @@ class PolygonsAsRings:
 
         self.rings.loc[:] = np.array(
             func(
-                GeoSeries(self.rings, crs=self.crs, index=self.rings.index),
+                GeoSeries(
+                    self.rings.values,
+                    crs=self.crs,
+                    index=self.rings.index.get_level_values(1).map(self._index_mapper),
+                ),
                 *args,
                 **kwargs,
             )
@@ -179,7 +182,7 @@ class PolygonsAsRings:
         gdf = GeoDataFrame(
             {"geometry": self.rings.values},
             crs=self.crs,
-            index=self.rings.index.get_level_values(1),
+            index=self.rings.index.get_level_values(1).map(self._index_mapper),
         ).join(self.gdf.drop(columns="geometry"))
 
         assert len(gdf) == len(self.rings)
@@ -246,18 +249,26 @@ class PolygonsAsRings:
         self.gdf.geometry = self.to_numpy()
         return self.gdf
 
+    def to_geoseries(self) -> GeoDataFrame:
+        """Return the GeoDataFrame with polygons."""
+        self.gdf.geometry = self.to_numpy()
+        return self.gdf.geometry
+
     def to_numpy(self) -> NDArray[Polygon]:
         """Return a numpy array of polygons."""
         if not len(self.rings):
             return np.array([])
 
-        exterior = self.rings.loc[self.is_exterior].sort_index().values
+        exterior = self.rings.loc[self.is_exterior].sort_index()
         assert exterior.shape == (len(self.gdf),)
 
         nonempty_interiors = self.rings.loc[self.is_interior]
 
         if not len(nonempty_interiors):
-            return make_valid(polygons(exterior))
+            try:
+                return make_valid(polygons(exterior.values))
+            except Exception:
+                return _geoms_to_linearrings_fallback(exterior)
 
         empty_interiors = pd.Series(
             [None for _ in range(len(self.gdf) * self.max_rings)],
@@ -270,8 +281,59 @@ class PolygonsAsRings:
             # make each ring level a column with same length and order as gdf
             .unstack(level=2)
             .sort_index()
-            .values
         )
         assert interiors.shape == (len(self.gdf), self.max_rings), interiors.shape
 
-        return make_valid(polygons(exterior, interiors))
+        try:
+            return make_valid(polygons(exterior.values, interiors.values))
+        except Exception:
+            return _geoms_to_linearrings_fallback(exterior, interiors)
+
+
+def get_linearring_series(geoms: Any) -> pd.Series:
+    geoms = to_geoseries(geoms).explode(index_parts=False)
+    coords, indices = get_coordinates(geoms, return_index=True)
+    return pd.Series(linearrings(coords, indices=indices), index=geoms.index)
+
+
+def _geoms_to_linearrings_fallback(
+    exterior: pd.Series, interiors: pd.Series | None = None
+) -> pd.Series:
+    exterior.index = exterior.index.get_level_values(1)
+
+    exterior = get_linearring_series(exterior)
+
+    if interiors is None:
+        return (
+            pd.Series(
+                make_valid(polygons(exterior.values)),
+                index=exterior.index,
+            )
+            .groupby(level=0)
+            .agg(unary_union)
+        )
+
+    interiors.index = interiors.index.get_level_values(1)
+    new_interiors = []
+    for col in interiors:
+        new_interiors.append(get_linearring_series(interiors[col]))
+
+    all_none = [[None] * len(new_interiors)] * len(exterior)
+    cols = list(interiors.columns)
+    out_interiors = pd.DataFrame(
+        all_none,
+        columns=cols,
+        index=exterior.index,
+    )
+    out_interiors[cols] = pd.concat(new_interiors, axis=1)
+    for col in out_interiors:
+        out_interiors.loc[out_interiors[col].isna(), col] = None
+
+    return (
+        pd.Series(
+            make_valid(polygons(exterior.values, out_interiors.values)),
+            index=exterior.index,
+        )
+        .groupby(level=0)
+        .agg(unary_union)
+    )

sgis/geopandas_tools/sfilter.py

@@ -65,11 +65,11 @@ def _get_sfilter_indices(
 
 
 def sfilter(
-    gdf: GeoDataFrame,
+    gdf: GeoDataFrame | GeoSeries,
     other: GeoDataFrame | GeoSeries | Geometry,
     predicate: str = "intersects",
 ) -> GeoDataFrame:
-    """Filter a GeoDataFrame by spatial predicate.
+    """Filter a GeoDataFrame or GeoSeries by spatial predicate.
 
     Does an sjoin and returns the rows of 'gdf' that were returned
     without getting duplicates or columns from 'other'.
@@ -135,11 +135,11 @@ def sfilter(
 
 
 def sfilter_split(
-    gdf: GeoDataFrame,
+    gdf: GeoDataFrame | GeoSeries,
     other: GeoDataFrame | GeoSeries | Geometry,
     predicate: str = "intersects",
 ) -> tuple[GeoDataFrame, GeoDataFrame]:
-    """Split a GeoDataFrame by spatial predicate.
+    """Split a GeoDataFrame or GeoSeries by spatial predicate.
 
     Like sfilter, but returns both the rows that do and do not match
     the spatial predicate as separate GeoDataFrames.
@@ -207,16 +207,16 @@ def sfilter_split(
 
 
 def sfilter_inverse(
-    gdf: GeoDataFrame,
+    gdf: GeoDataFrame | GeoSeries,
     other: GeoDataFrame | GeoSeries | Geometry,
     predicate: str = "intersects",
-) -> tuple[GeoDataFrame, GeoDataFrame]:
-    """Filter a GeoDataFrame by inverse spatial predicate.
+) -> GeoDataFrame | GeoSeries:
+    """Filter a GeoDataFrame or GeoSeries by inverse spatial predicate.
 
     Returns the rows that do not match the spatial predicate.
 
     Args:
-        gdf: The GeoDataFrame.
+        gdf: The GeoDataFrame or GeoSeries.
         other: The geometry object to filter 'gdf' by.
         predicate: Spatial predicate to use. Defaults to 'intersects'.
 

sgis/helpers.py

@@ -153,23 +153,38 @@ def unit_is_degrees(gdf: GeoDataFrame) -> bool:
     return False
 
 
-def get_object_name(var: object, n: int = 5) -> str | None:
+def get_object_name(
+    var: object, start: int = 2, stop: int = 7, ignore_self: bool = True
+) -> str | None:
     """Searches through the local variables down one level at a time."""
-    frame = inspect.currentframe().f_back.f_back
+    frame = inspect.currentframe()
 
-    for _ in range(n):
+    for _ in range(start):
+        frame = frame.f_back
+
+    for _ in np.arange(start, stop):
         names = [
             var_name for var_name, var_val in frame.f_locals.items() if var_val is var
         ]
         if names and len(names) == 1:
+            if ignore_self and names[0] == "self":
+                frame = frame.f_back
+                continue
             return names[0]
 
         names = [name for name in names if not name.startswith("_")]
 
         if names and len(names) == 1:
+            if ignore_self and names[0] == "self":
+                frame = frame.f_back
+                continue
+
             return names[0]
 
         if names and len(names) > 1:
+            if ignore_self and names[0] == "self":
+                frame = frame.f_back
+                continue
             warnings.warn(
                 "More than one local variable matches the object. Name might be wrong."
             )
@@ -193,6 +208,8 @@ def make_namedict(gdfs: tuple[GeoDataFrame]) -> dict[int, str]:
 
 
 def sort_nans_last(df, ignore_index: bool = False):
+    if not len(df):
+        return df
     df["n_nan"] = df.isna().sum(axis=1).values
 
     df["_idx"] = range(len(df))

sgis/io/{dapla.py → dapla_functions.py}

@@ -1,7 +1,7 @@
 """Functions for reading and writing GeoDataFrames in Statistics Norway's GCS Dapla.
 """
-import os
 from pathlib import Path
+from typing import Optional
 
 import dapla as dp
 import geopandas as gpd
@@ -12,21 +12,31 @@ from pandas import DataFrame
 from pyarrow import parquet
 
 
-def read_geopandas(gcs_path: str | Path, **kwargs) -> GeoDataFrame | DataFrame:
+def read_geopandas(
+    gcs_path: str | Path,
+    pandas_fallback: bool = False,
+    fs: Optional[dp.gcs.GCSFileSystem] = None,
+    **kwargs,
+) -> GeoDataFrame | DataFrame:
     """Reads geoparquet or other geodata from a file on GCS.
 
+    If the file has 0 rows, the contents will be returned as a pandas.DataFrame,
+    since geopandas does not read and write empty tables.
+
     Note:
         Does not currently read shapefiles or filegeodatabases.
 
     Args:
         gcs_path: path to a file on Google Cloud Storage.
+        pandas_fallback: If False (default), an exception is raised if the file can
+            not be read with geopandas and the number of rows is more than 0. If True,
+            the file will be read as
         **kwargs: Additional keyword arguments passed to geopandas' read_parquet
             or read_file, depending on the file type.
 
      Returns:
          A GeoDataFrame if it has rows. If zero rows, a pandas DataFrame is returned.
     """
-    fs = dp.FileClient.get_gcs_file_system()
 
     if not isinstance(gcs_path, str):
         try:
@@ -34,13 +44,17 @@ def read_geopandas(gcs_path: str | Path, **kwargs) -> GeoDataFrame | DataFrame:
         except TypeError:
             raise TypeError(f"Unexpected type {type(gcs_path)}.")
 
+    if fs is None:
+        fs = dp.FileClient.get_gcs_file_system()
+
     if "parquet" in gcs_path or "prqt" in gcs_path:
         with fs.open(gcs_path, mode="rb") as file:
             try:
                 return gpd.read_parquet(file, **kwargs)
             except ValueError as e:
                 df = dp.read_pandas(gcs_path, **kwargs)
-                if not len(df):
+
+                if pandas_fallback or not len(df):
                     return df
                 else:
                     raise e
@@ -50,14 +64,19 @@ def read_geopandas(gcs_path: str | Path, **kwargs) -> GeoDataFrame | DataFrame:
                 return gpd.read_file(file, **kwargs)
             except ValueError as e:
                 df = dp.read_pandas(gcs_path, **kwargs)
-                if not len(df):
+
+                if pandas_fallback or not len(df):
                     return df
                 else:
                     raise e
 
 
 def write_geopandas(
-    df: gpd.GeoDataFrame, gcs_path: str | Path, overwrite: bool = True, **kwargs
+    df: gpd.GeoDataFrame,
+    gcs_path: str | Path,
+    overwrite: bool = True,
+    fs: Optional[dp.gcs.GCSFileSystem] = None,
+    **kwargs,
 ) -> None:
     """Writes a GeoDataFrame to the speficied format.
 
@@ -81,6 +100,9 @@ def write_geopandas(
     if not overwrite and exists(gcs_path):
         raise ValueError("File already exists.")
 
+    if fs is None:
+        fs = dp.FileClient.get_gcs_file_system()
+
     pd.io.parquet.BaseImpl.validate_dataframe(df)
 
     if not len(df):

sgis/io/write_municipality_data.py

@@ -1,14 +1,14 @@
-from pathlib import Path
 from collections.abc import Callable
+from pathlib import Path
 
 import pandas as pd
-from dapla import write_pandas
+from dapla import read_pandas, write_pandas
 from geopandas import GeoDataFrame
 from pandas import DataFrame
 
 from ..geopandas_tools.general import clean_clip, clean_geoms
 from ..geopandas_tools.neighbors import get_neighbor_indices
-from .dapla import read_geopandas, write_geopandas
+from .dapla_functions import read_geopandas, write_geopandas
 
 
 def write_municipality_data(
@@ -66,8 +66,14 @@ def _write_municipality_data(
     data = _validate_data(data)
 
     if isinstance(data, (str, Path)):
-        gdf = read_geopandas(str(data))
-    elif isinstance(data, GeoDataFrame):
+        try:
+            gdf = read_geopandas(str(data))
+        except ValueError as e:
+            try:
+                gdf = read_pandas(str(data))
+            except ValueError:
+                raise e.__class__(e, data)
+    elif isinstance(data, DataFrame):
         gdf = data
     else:
         raise TypeError(type(data))
@@ -84,14 +90,14 @@ def _write_municipality_data(
 
         if not len(gdf_muni):
             if write_empty:
-                gdf_muni = gdf_muni.drop(columns="geometry")
+                gdf_muni = gdf_muni.drop(columns="geometry", errors="ignore")
                 gdf_muni["geometry"] = None
                 write_pandas(gdf_muni, out)
             continue
 
         if not len(gdf_muni):
             if write_empty:
-                gdf_muni = gdf_muni.drop(columns="geometry")
+                gdf_muni = gdf_muni.drop(columns="geometry", errors="ignore")
                 gdf_muni["geometry"] = None
                 write_pandas(gdf_muni, out)
             continue

sgis/maps/examine.py

@@ -78,7 +78,7 @@ class Examine:
         only_show_mask: bool = False,
         **kwargs,
     ):
-        if not all(isinstance(gdf, gpd.GeoDataFrame) for gdf in gdfs):
+        if not all(isinstance(gdf, gpd.GeoDataFrame) or not len(gdf) for gdf in gdfs):
             raise ValueError("gdfs must be of type GeoDataFrame.")
 
         self._gdfs = gdfs
@@ -87,6 +87,15 @@ class Examine:
         else:
             self.mask_gdf = mask_gdf
 
+        self.indices = list(range(len(self.mask_gdf)))
+        self.i = 0
+        self.column = column
+        self.size = size
+        self.kwargs = kwargs
+
+        if not len(self.mask_gdf):
+            return
+
         if unit_is_degrees(self.mask_gdf) and size > 360:
             raise ValueError(
                 "CRS unit is degrees. Use geopandas' "
@@ -103,12 +112,6 @@ class Examine:
                 self.mask_gdf["area"] = self.mask_gdf.area
             self.mask_gdf = self.mask_gdf.sort_values(sort_values)
 
-        self.indices = list(range(len(gdfs[0])))
-        self.i = 0
-        self.column = column
-        self.size = size
-        self.kwargs = kwargs
-
         if only_show_mask:
             self.kwargs["show"] = [True] + [False] * len(self._gdfs[1:])
         elif not kwargs.get("show"):

sgis/maps/explore.py

@@ -14,19 +14,21 @@ import folium
 import matplotlib
 import numpy as np
 import pandas as pd
+import xyzservices
 from folium import plugins
 from geopandas import GeoDataFrame
 from IPython.display import display
 from jinja2 import Template
+from pandas.api.types import is_datetime64_any_dtype
 from shapely import Geometry
 from shapely.geometry import LineString
 
 from ..geopandas_tools.conversion import to_gdf
 from ..geopandas_tools.general import clean_geoms, make_all_singlepart
 from ..geopandas_tools.geometry_types import get_geom_type, to_single_geom_type
-from ..helpers import unit_is_degrees
 from .httpserver import run_html_server
 from .map import Map
+from .tilesources import kartverket, xyz
 
 
 # the geopandas._explore raises a deprication warning. Ignoring for now.
@@ -91,7 +93,52 @@ class MeasureControlFix(plugins.MeasureControl):
         )
 
 
+def to_tile(tile: str | xyzservices.TileProvider, max_zoom: int) -> folium.TileLayer:
+    common_bgmaps = {
+        "openstreetmap": folium.TileLayer(
+            "OpenStreetMap", min_zoom=0, max_zoom=max_zoom
+        ),
+        "grunnkart": kartverket.norges_grunnkart,
+        "gråtone": kartverket.norges_grunnkart_gråtone,
+        "norge_i_bilder": kartverket.norge_i_bilder,
+        "dark": xyz.CartoDB.DarkMatter,
+        "voyager": xyz.CartoDB.Voyager,
+    }
+    try:
+        name = tile["name"]
+    except TypeError:
+        name = tile
+
+    if not isinstance(tile, str):
+        try:
+            return folium.TileLayer(tile, name=name, max_zoom=max_zoom)
+        except TypeError:
+            return folium.TileLayer(tile, max_zoom=max_zoom)
+
+    try:
+        provider = common_bgmaps[tile.lower()]
+    except KeyError:
+        provider = xyzservices.providers.query_name(tile)
+
+    if isinstance(provider, folium.TileLayer):
+        return provider
+
+    if isinstance(provider, xyzservices.TileProvider):
+        attr = provider.html_attribution
+        provider = provider.build_url(scale_factor="{r}")
+    else:
+        try:
+            attr = provider["attr"]
+        except (AttributeError, TypeError):
+            attr = None
+
+    return folium.TileLayer(provider, name=name, attr=attr, max_zoom=max_zoom)
+
+
 class Explore(Map):
+    # class attribute that can be overridden locally
+    tiles = ("OpenStreetMap", "dark", "norge_i_bilder", "grunnkart")
+
     def __init__(
         self,
         *gdfs,
@@ -104,7 +151,7 @@ class Explore(Map):
         measure_control: bool = True,
         geocoder: bool = True,
         save=None,
-        show: bool | Iterable[bool] = True,
+        show: bool | Iterable[bool] | None = None,
         **kwargs,
     ):
         self.popup = popup
@@ -121,6 +168,12 @@ class Explore(Map):
         if not self.browser and "in_browser" in kwargs:
             self.browser = kwargs.pop("in_browser")
 
+        if show is None:
+            show_was_none = True
+            show = True
+        else:
+            show_was_none = False
+
         super().__init__(*gdfs, column=column, show=show, **kwargs)
 
         if self.gdfs is None:
@@ -129,7 +182,18 @@ class Explore(Map):
         # stringify or remove columns not renerable by leaflet (list, geometry etc.)
         new_gdfs, show_new = [], []
         for gdf, show in zip(self.gdfs, self.show, strict=True):
+            try:
+                gdf = gdf.reset_index()
+            except Exception:
+                pass
             for col in gdf.columns:
+                if is_datetime64_any_dtype(gdf[col]):
+                    try:
+                        gdf[col] = [str(x) for x in gdf[col].dt.round("d")]
+                    except Exception:
+                        gdf = gdf.drop(col, axis=1)
+                    continue
+
                 if not len(gdf.loc[gdf[col].notna()]):
                     continue
                 if not isinstance(
@@ -139,7 +203,7 @@ class Explore(Map):
                     and isinstance(gdf.loc[gdf[col].notna(), col].iloc[0], (Geometry))
                 ):
                     try:
-                        gdf[col] = gdf[col].astype(str)
+                        gdf[col] = gdf[col].astype(str).fillna(pd.NA)
                     except Exception:
                         gdf = gdf.drop(col, axis=1)
 
@@ -150,8 +214,12 @@ class Explore(Map):
             new_gdfs.append(gdf)
             show_new.append(show)
         self._gdfs = new_gdfs
+        self._gdf = pd.concat(new_gdfs, ignore_index=True)
         self.show = show_new
 
+        if show_was_none and len(self._gdfs) > 6:
+            self.show = [False] * len(self._gdfs)
+
         if self._is_categorical:
             if len(self.gdfs) == 1:
                 self._split_categories()
@@ -167,6 +235,9 @@ class Explore(Map):
     def explore(
         self, column: str | None = None, center=None, size=None, **kwargs
     ) -> None:
+        if not any(len(gdf) for gdf in self._gdfs):
+            warnings.warn("None of the GeoDataFrames have rows.")
+            return
         if column:
             self._column = column
             self._update_column()
@@ -342,6 +413,7 @@ class Explore(Map):
 
             gdf = self._to_single_geom_type(gdf)
             gdf = self._prepare_gdf_for_map(gdf)
+
             gjs = self._make_geojson(
                 gdf,
                 show=show,
@@ -351,10 +423,9 @@ class Explore(Map):
                 **{
                     key: value
                     for key, value in self.kwargs.items()
-                    if key not in ["title"]
+                    if key not in ["title", "tiles"]
                 },
             )
-
             gjs.layer_name = label
 
             gjs.add_to(f)
@@ -366,10 +437,15 @@ class Explore(Map):
             self._categories_colors_dict.keys(),
             self._categories_colors_dict.values(),
         )
-        folium.TileLayer("stamentoner", max_zoom=self.max_zoom).add_to(self.map)
-        folium.TileLayer("cartodbdark_matter", max_zoom=self.max_zoom).add_to(self.map)
+
         self.map.add_child(folium.LayerControl())
 
+    def _add_tiles(
+        self, mapobj: folium.Map, tiles: list[str, xyzservices.TileProvider]
+    ):
+        for tile in tiles:
+            to_tile(tile, max_zoom=self.max_zoom).add_to(mapobj)
+
     def _create_continous_map(self):
         self._prepare_continous_map()
         if self.scheme:
@@ -428,8 +504,6 @@ class Explore(Map):
             self.map.add_child(f)
 
         self.map.add_child(colorbar)
-        folium.TileLayer("stamentoner").add_to(self.map)
-        folium.TileLayer("cartodbdark_matter").add_to(self.map)
         self.map.add_child(folium.LayerControl())
 
     def _tooltip_cols(self, gdf: GeoDataFrame) -> list:
@@ -456,18 +530,19 @@ class Explore(Map):
         self,
         bounds,
         attr=None,
-        tiles="OpenStreetMap",
+        tiles=None,
         width="100%",
         height="100%",
         control_scale=True,
         map_kwds=None,
         **kwargs,
     ):
-        import xyzservices
-
         if not map_kwds:
             map_kwds = {}
 
+        if tiles is None:
+            tiles = self.tiles
+
         # create folium.Map object
         # Get bounds to specify location and map extent
         location = kwargs.pop("location", None)
@@ -493,30 +568,32 @@ class Explore(Map):
             **map_kwds,
             **{i: kwargs[i] for i in kwargs.keys() if i in _MAP_KWARGS},
         }
+        map_kwds["min_zoom"] = 0
+        map_kwds["max_zoom"] = kwargs.get("max_zoom", self.max_zoom)
 
-        # match provider name string to xyzservices.TileProvider
-        if isinstance(tiles, str):
-            try:
-                tiles = xyzservices.providers.query_name(tiles)
-            except ValueError:
-                pass
+        if isinstance(tiles, (list, tuple)):
+            default_tile, *more_tiles = tiles
+        else:
+            default_tile, more_tiles = tiles, []
 
-        if isinstance(tiles, xyzservices.TileProvider):
-            attr = attr if attr else tiles.html_attribution
-            map_kwds["min_zoom"] = tiles.get("min_zoom", 0)
-            map_kwds["max_zoom"] = tiles.get("max_zoom", 30)
-            tiles = tiles.build_url(scale_factor="{r}")
+        default_tile = to_tile(default_tile, max_zoom=self.max_zoom)
+
+        if isinstance(default_tile, xyzservices.TileProvider):
+            attr = attr if attr else default_tile.html_attribution
+            default_tile = default_tile.build_url(scale_factor="{r}")
 
         m = folium.Map(
             location=location,
             control_scale=control_scale,
-            tiles=tiles,
+            tiles=default_tile,
             attr=attr,
             width=width,
             height=height,
             **map_kwds,
         )
 
+        self._add_tiles(m, more_tiles)
+
         if self.measure_control:
             MeasureControlFix(
                 primary_length_unit="meters",
@@ -539,7 +616,7 @@ class Explore(Map):
             separator=", ",
             empty_string="NaN",
             lng_first=True,
-            num_digits=5,
+            num_digits=8,
         ).add_to(m)
 
         if self.geocoder: