ssb-sgis 1.2.2__tar.gz → 1.2.3__tar.gz

{ssb_sgis-1.2.2 → ssb_sgis-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ssb-sgis
-Version: 1.2.2
+Version: 1.2.3
 Summary: GIS functions used at Statistics Norway.
 Home-page: https://github.com/statisticsnorway/ssb-sgis
 License: MIT

{ssb_sgis-1.2.2 → ssb_sgis-1.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-sgis"
-version = "1.2.2"
+version = "1.2.3"
 description = "GIS functions used at Statistics Norway."
 authors = ["Morten Letnes <morten.letnes@ssb.no>"]
 license = "MIT"

{ssb_sgis-1.2.2 → ssb_sgis-1.2.3}/src/sgis/geopandas_tools/general.py

@@ -643,7 +643,7 @@ def to_lines(
             f"Point geometries not allowed in 'to_lines'. {geoms.geom_type.value_counts()}"
         )
 
-    gdf.geometry.loc[:] = geoms
+    gdf.loc[:, gdf.geometry.name] = geoms
 
     if not split:
         return gdf

{ssb_sgis-1.2.2 → ssb_sgis-1.2.3}/src/sgis/geopandas_tools/overlay.py

@@ -172,9 +172,11 @@ def clean_overlay(
     if df2.geometry.name != "geometry":
         df2 = df2.rename_geometry("geometry")
 
-    # to pandas because GeoDataFrame constructor is expensive
+    # to pandas because GeoDataFrame constructor is slow
     df1 = DataFrame(df1).reset_index(drop=True)
     df2 = DataFrame(df2).reset_index(drop=True)
+    df1.geometry.values.crs = None
+    df2.geometry.values.crs = None
 
     overlayed = (
         gpd.GeoDataFrame(

{ssb_sgis-1.2.2 → ssb_sgis-1.2.3}/src/sgis/maps/explore.py

@@ -44,6 +44,7 @@ from ..geopandas_tools.general import make_all_singlepart
 from ..geopandas_tools.geometry_types import get_geom_type
 from ..geopandas_tools.geometry_types import to_single_geom_type
 from ..helpers import _get_file_system
+from ..helpers import dict_zip
 from .wms import WmsLoader
 
 try:
@@ -385,12 +386,12 @@ class Explore(Map):
 
         super().__init__(column=column, show=show, **(new_kwargs | new_gdfs))
 
-        if self.gdfs is None:
+        if self._gdfs is None:
             return
 
         # 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):
+        new_gdfs, show_new = {}, {}
+        for label, gdf, show in dict_zip(self._gdfs, self.show):
             try:
                 gdf = gdf.reset_index()
             except Exception:
@@ -420,18 +421,15 @@ class Explore(Map):
                 gdf.index = gdf.index.astype(str)
             except Exception:
                 pass
-            new_gdfs.append(to_gdf(gdf))
-            show_new.append(show)
+            new_gdfs[label] = to_gdf(gdf)
+            show_new[label] = show
         self._gdfs = new_gdfs
         if self._gdfs:
             self._gdf = pd.concat(new_gdfs, ignore_index=True)
         else:
-            self._gdf = GeoDataFrame({"geometry": [], self._column: []})
+            self._gdf = self._get_gdf_template()
         self.show = show_new
 
-        # if self._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()
@@ -455,7 +453,7 @@ class Explore(Map):
             rasters = self.raster_data
         except AttributeError:
             rasters = self.rasters
-        return len([gdf for gdf in self._gdfs if len(gdf)]) + len(rasters)
+        return len([gdf for gdf in self._gdfs.values() if len(gdf)]) + len(rasters)
 
     def __bool__(self) -> bool:
         """True if any gdfs have rows or there are any raster images."""
@@ -473,7 +471,7 @@ class Explore(Map):
         self.mask = mask if mask is not None else self.mask
         if (
             self._gdfs
-            and not any(len(gdf) for gdf in self._gdfs)
+            and not any(len(gdf) for gdf in self._gdfs.values())
             and not len(self.rasters)
         ):
             warnings.warn("None of the GeoDataFrames have rows.", stacklevel=1)
@@ -498,13 +496,11 @@ class Explore(Map):
             else center
         )
 
-        gdfs: tuple[GeoDataFrame] = ()
-        for gdf in self._gdfs:
+        for label, gdf in self._gdfs.items():
             keep_geom_type = False if get_geom_type(gdf) == "mixed" else True
             gdf = gdf.clip(centerpoint.buffer(size), keep_geom_type=keep_geom_type)
-            gdfs = gdfs + (gdf,)
-        self._gdfs = gdfs
-        self._gdf = pd.concat(gdfs, ignore_index=True)
+            self._gdfs[label] = gdf
+        self._gdf = pd.concat(self._gdfs.values(), ignore_index=True)
 
         self._get_unique_values()
 
@@ -558,19 +554,17 @@ class Explore(Map):
             self._update_column()
             kwargs.pop("column", None)
 
-        gdfs: tuple[GeoDataFrame] = ()
-        for gdf in self._gdfs:
+        for label, gdf in self._gdfs.items():
             gdf = gdf.clip(self.mask)
             collections = gdf.loc[gdf.geom_type == "GeometryCollection"]
             if len(collections):
                 collections = make_all_singlepart(collections)
                 gdf = pd.concat([gdf, collections], ignore_index=False)
-            gdfs = gdfs + (gdf,)
-        self._gdfs = gdfs
+            self._gdfs[label] = gdf
         if self._gdfs:
-            self._gdf = pd.concat(self._gdfs, ignore_index=True)
+            self._gdf = pd.concat(self._gdfs.values(), ignore_index=True)
         else:
-            self._gdf = GeoDataFrame({"geometry": [], self._column: []})
+            self._gdf = self._get_gdf_template()
 
         self._explore(**kwargs)
 
@@ -638,8 +632,11 @@ class Explore(Map):
     def _explore(self, **kwargs) -> None:
         self.kwargs = self.kwargs | kwargs
 
-        if self._show_was_none and len([gdf for gdf in self._gdfs if len(gdf)]) > 6:
-            self.show = [False] * len(self._gdfs)
+        if (
+            self._show_was_none
+            and len([gdf for gdf in self._gdfs.values() if len(gdf)]) > 6
+        ):
+            self.show = {label: False for label in self._gdfs}
 
         if self._is_categorical:
             self._create_categorical_map()
@@ -662,15 +659,13 @@ class Explore(Map):
             display(self.map)
 
     def _split_categories(self) -> None:
-        new_gdfs, new_labels, new_shows = [], [], []
+        new_gdfs, new_shows = {}, {}
         for cat in self._unique_values:
             gdf = self.gdf.loc[self.gdf[self.column] == cat]
-            new_gdfs.append(gdf)
-            new_labels.append(cat)
-            new_shows.append(self.show[0])
+            new_gdfs[cat] = gdf
+            new_shows[cat] = next(iter(self.show.values()))
         self._gdfs = new_gdfs
         self._gdf = pd.concat(new_gdfs, ignore_index=True)
-        self.labels = new_labels
         self.show = new_shows
 
     def _to_single_geom_type(self, gdf: GeoDataFrame) -> GeoDataFrame:
@@ -720,12 +715,11 @@ class Explore(Map):
         return gdf.total_bounds
 
     def _create_categorical_map(self) -> None:
-        self._make_categories_colors_dict()
+        self._prepare_categorical_plot()
         if self._gdf is not None and len(self._gdf):
-            self._fix_nans()
             gdf = self._prepare_gdf_for_map(self._gdf)
         else:
-            gdf = GeoDataFrame({"geometry": [], self._column: []})
+            gdf = self._get_gdf_template()
 
         self._load_rasters_as_images()
 
@@ -742,7 +736,7 @@ class Explore(Map):
             **self.kwargs,
         )
 
-        for gdf, label, show in zip(self._gdfs, self.labels, self.show, strict=True):
+        for label, gdf, show in dict_zip(self._gdfs, self.show):
             if not len(gdf):
                 continue
 
@@ -798,7 +792,10 @@ class Explore(Map):
         if self.scheme:
             classified = self._classify_from_bins(self._gdf, bins=self.bins)
             classified_sequential = self._push_classification(classified)
-            n_colors = len(np.unique(classified_sequential)) - any(self._nan_idx)
+            n_colors = (
+                len(np.unique(classified_sequential))
+                - self._gdf[self._column].isna().any()
+            )
             unique_colors = self._get_continous_colors(n=n_colors)
 
         self._load_rasters_as_images()
@@ -824,7 +821,7 @@ class Explore(Map):
             index=self.bins,
         )
 
-        for gdf, label, show in zip(self._gdfs, self.labels, self.show, strict=True):
+        for (label, gdf), show in zip(self._gdfs.items(), self.show, strict=True):
             if not len(gdf):
                 continue
 

{ssb_sgis-1.2.2 → ssb_sgis-1.2.3}/src/sgis/maps/legend.py

@@ -14,7 +14,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
-from matplotlib.lines import Line2D
+from matplotlib.patches import Patch
 from pandas import Series
 
 from ..geopandas_tools.bounds import bounds_to_points
@@ -50,6 +50,7 @@ LEGEND_KWARGS = {
     "rounding",
     "facecolor",
     "labelcolor",
+    "hatch",
 }
 
 LOWERCASE_WORDS = {
@@ -265,8 +266,17 @@ class Legend:
         else:
             self._markersize = size
 
+    def _get_patch(self, color, edgecolor="black", **kwargs) -> Patch:
+        return Patch(
+            facecolor=color,
+            edgecolor=edgecolor,
+            **kwargs,
+        )
+
     def _prepare_categorical_legend(
-        self, categories_colors: dict, nan_label: str
+        self,
+        categories_colors: dict,
+        hatch: str,
     ) -> None:
         for attr in self.__dict__.keys():
             if attr in self.kwargs:
@@ -279,31 +289,30 @@ class Legend:
             }
         # swap column values with label list and hope it's in the correct order
         elif self.labels:
-            categories_colors = {
-                label: color
-                for label, color in zip(
-                    self.labels, categories_colors.values(), strict=True
+            if len(self.labels) != len(categories_colors):
+                raise ValueError(
+                    f"Unequal length of labels {self.labels} and categories/colors  {categories_colors}"
                 )
-            }
+            categories_colors = dict(
+                zip(self.labels, categories_colors.values(), strict=True)
+            )
 
         self._patches, self._categories = [], []
         for category, color in categories_colors.items():
             if self.pretty_labels:
                 category = prettify_label(category)
-            if category == nan_label:
-                self._categories.append(nan_label)
-            else:
-                self._categories.append(category)
+            self._categories.append(category)
+            self._patches.append(self._get_patch(color=color, hatch=hatch))
+
+    def _add_more_data_to_legend(self, more_data: dict[str, dict]) -> None:
+        for label, datadict in more_data.items():
+            if self.pretty_labels:
+                label = prettify_label(label)
+            self._categories.append(label)
+            datadict = {key: value for key, value in datadict.items() if key != "gdf"}
             self._patches.append(
-                Line2D(
-                    [0],
-                    [0],
-                    linestyle="none",
-                    marker="o",
-                    alpha=self.kwargs.get("alpha", 1),
-                    markersize=self._markersize,
-                    markerfacecolor=color,
-                    markeredgewidth=0,
+                self._get_patch(
+                    **datadict,
                 )
             )
 
@@ -595,40 +604,34 @@ class ContinousLegend(Legend):
         self,
         bins: list[float],
         colors: list[str],
-        nan_label: str,
         bin_values: dict,
+        nan_label: str,
+        hatch: str,
     ) -> None:
         # TODO: clean up this messy method
 
-        for attr in self.kwargs:
+        if (
+            colors is not None
+            and self.labels is not None
+            and len(self.labels) != len(colors)
+        ):
+            raise ValueError(
+                "Label list must be same length as the number of groups. "
+                f"Got k={len(colors)} and labels={len(self.labels)}."
+                f"labels: {', '.join(self.labels)}"
+                f"colors: {', '.join(colors)}"
+                f"bins: {bins}"
+            )
+
+        for attr in dict(self.kwargs):
             if attr in self.__dict__:
                 self[attr] = self.kwargs.pop(attr)
 
         self._patches, self._categories = [], []
-
         for color in colors:
-            self._patches.append(
-                Line2D(
-                    [0],
-                    [0],
-                    linestyle="none",
-                    marker="o",
-                    alpha=self.kwargs.get("alpha", 1),
-                    markersize=self._markersize,
-                    markerfacecolor=color,
-                    markeredgewidth=0,
-                )
-            )
+            self._patches.append(self._get_patch(color=color, hatch=hatch))
 
         if self.labels:
-            if len(self.labels) != len(colors):
-                raise ValueError(
-                    "Label list must be same length as the number of groups. "
-                    f"Got k={len(colors)} and labels={len(self.labels)}."
-                    f"labels: {', '.join(self.labels)}"
-                    f"colors: {', '.join(colors)}"
-                    f"bins: {bins}"
-                )
             self._categories = self.labels
 
         elif len(bins) == len(colors):
@@ -703,6 +706,9 @@ class ContinousLegend(Legend):
                     label = self._get_two_value_label(min_rounded, max_rounded)
                     self._categories.append(label)
 
+        # if nan_label:
+        #     self._categories.append(nan_label)
+
     def _get_two_value_label(self, value1: int | float, value2: int | float) -> str:
         return (
             f"{value1} {self.label_suffix} {self.label_sep} "