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

sgis/maps/map.py

@@ -4,32 +4,37 @@ This module holds the Map class, which is the basis for the Explore class.
 """
 
 import warnings
+from collections.abc import Sequence
+from statistics import mean
+from typing import Any
 
 import matplotlib
 import matplotlib.colors as colors
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame, GeoSeries
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
 from jenkspy import jenks_breaks
 from mapclassify import classify
 from shapely import Geometry
 
 from ..geopandas_tools.conversion import to_gdf
-from ..geopandas_tools.general import (
-    clean_geoms,
-    drop_inactive_geometry_columns,
-    get_common_crs,
-    rename_geometry_if,
-)
+from ..geopandas_tools.general import _rename_geometry_if
+from ..geopandas_tools.general import clean_geoms
+from ..geopandas_tools.general import drop_inactive_geometry_columns
+from ..geopandas_tools.general import get_common_crs
 from ..helpers import get_object_name
-
+from ..helpers import unit_is_meters
+from ..raster.image_collection import Band
+from ..raster.image_collection import Image
+from ..raster.image_collection import ImageCollection
 
 try:
     from torchgeo.datasets.geo import RasterDataset
 except ImportError:
 
     class RasterDataset:
-        """Placeholder"""
+        """Placeholder."""
 
 
 # the geopandas._explore raises a deprication warning. Ignoring for now.
@@ -60,8 +65,16 @@ _CATEGORICAL_CMAP = {
 DEFAULT_SCHEME = "quantiles"
 
 
-def proper_fillna(val, fill_val):
-    """fillna doesn't always work. So doing it manually."""
+def proper_fillna(val: Any, fill_val: Any) -> Any:
+    """Manually handle missing values when fillna doesn't work as expected.
+
+    Args:
+        val: The value to check and fill.
+        fill_val: The value to fill in.
+
+    Returns:
+        The original value or the filled value if conditions are met.
+    """
     try:
         if "NAType" in val.__class__.__name__:
             return fill_val
@@ -84,15 +97,28 @@ class Map:
         self,
         *gdfs: GeoDataFrame,
         column: str | None = None,
-        labels: tuple[str] | None = None,
         k: int = 5,
         bins: tuple[float] | None = None,
         nan_label: str = "Missing",
         nan_color="#c2c2c2",
         scheme: str = DEFAULT_SCHEME,
+        cmap: str | None = None,
         **kwargs,
-    ):
+    ) -> None:
+        """Initialiser.
 
+        Args:
+            *gdfs: Variable length GeoDataFrame list.
+            column: The column name to work with.
+            k: Number of bins or classes for classification (default: 5).
+            bins: Predefined bins for data classification.
+            nan_label: Label for missing data.
+            nan_color: Color for missing data.
+            scheme: Classification scheme to be used.
+            cmap (str): Colormap of the plot. See:
+                https://matplotlib.org/stable/tutorials/colors/colormaps.html
+            **kwargs: Arbitrary keyword arguments.
+        """
         gdfs, column, kwargs = self._separate_args(gdfs, column, kwargs)
 
         self._column = column
@@ -100,27 +126,14 @@ class Map:
         self._k = k
         self.nan_label = nan_label
         self.nan_color = nan_color
-        self._cmap = kwargs.pop("cmap", None)
+        self._cmap = cmap
         self.scheme = scheme
 
-        if not all(isinstance(gdf, GeoDataFrame) for gdf in gdfs):
-            gdfs = [
-                to_gdf(gdf) if not isinstance(gdf, GeoDataFrame) else gdf
-                for gdf in gdfs
-            ]
-            if not all(isinstance(gdf, GeoDataFrame) for gdf in gdfs):
-                raise ValueError("gdfs must be GeoDataFrames.")
-
-        if "namedict" in kwargs:
-            for i, gdf in enumerate(gdfs):
-                gdf.name = kwargs["namedict"][i]
-            kwargs.pop("namedict")
-
         # need to get the object names of the gdfs before copying. Only getting,
         # not setting, labels. So the original gdfs don't get the label column.
-        self.labels = labels
-        if not self.labels:
-            self._get_labels(gdfs)
+        self.labels: list[str] = [
+            _determine_best_name(gdf, column, i) for i, gdf in enumerate(gdfs)
+        ]
 
         show = kwargs.pop("show", True)
         if isinstance(show, (int, bool)):
@@ -138,7 +151,7 @@ class Map:
         self._gdfs = []
         new_labels = []
         self.show = []
-        for label, gdf, show in zip(self.labels, gdfs, show_args):
+        for label, gdf, show in zip(self.labels, gdfs, show_args, strict=False):
             if not len(gdf):
                 continue
 
@@ -146,31 +159,18 @@ class Map:
             if not len(gdf):
                 continue
 
-            self._gdfs.append(gdf)
+            self._gdfs.append(to_gdf(gdf))
             new_labels.append(label)
             self.show.append(show)
         self.labels = new_labels
 
-        # if len(self._gdfs):
-        #     last_show = self.show[-1]
-        # else:
-        #     last_show = show
-
         # pop all geometry-like items from kwargs into self._gdfs
         self.kwargs = {}
         i = 0
         for key, value in kwargs.items():
-            # if isinstance(value, GeoDataFrame):
-            #     self._gdfs.append(value)
-            #     self.labels.append(key)
-            #     try:
-            #         show = show_kwargs[i]
-            #     except IndexError:
-            #         pass
-            #     self.show.append(show)
-            #     i += 1
-            #     continue
             try:
+                if not len(value):
+                    continue
                 self._gdfs.append(to_gdf(value))
                 self.labels.append(key)
                 try:
@@ -189,10 +189,10 @@ class Map:
             )
 
         if not any(len(gdf) for gdf in self._gdfs):
-            warnings.warn("None of the GeoDataFrames have rows.")
-            self._gdfs = None
+            self._gdfs = []
             self._is_categorical = True
             self._unique_values = []
+            self._nan_idx = []
             return
 
         if not self.labels:
@@ -222,7 +222,7 @@ class Map:
         self._nan_idx = self._gdf[self._column].isna()
         self._get_unique_values()
 
-    def _get_unique_values(self):
+    def _get_unique_values(self) -> None:
         if not self._is_categorical:
             self._unique_values = self._get_unique_floats()
         else:
@@ -243,7 +243,7 @@ class Map:
         Because floats don't always equal each other. This will make very
         similar values count as the same value in the color classification.
         """
-        array = self._gdf.loc[~self._nan_idx, self._column]
+        array = self._gdf.loc[list(~self._nan_idx), self._column]
         self._min = np.min(array)
         self._max = np.max(array)
         self._get_multiplier(array)
@@ -254,7 +254,7 @@ class Map:
 
         return np.sort(np.array(unique.loc[no_duplicates.index]))
 
-    def _array_to_large_int(self, array):
+    def _array_to_large_int(self, array: np.ndarray | pd.Series) -> pd.Series:
         """Multiply values in float array, then convert to integer."""
         if not isinstance(array, pd.Series):
             array = pd.Series(array)
@@ -266,9 +266,8 @@ class Map:
 
         return pd.concat([unique_multiplied, isna]).sort_index()
 
-    def _get_multiplier(self, array: np.ndarray):
-        """Find the number of zeros needed to push the max value of the array above
-        +-1_000_000.
+    def _get_multiplier(self, array: np.ndarray) -> None:
+        """Find the number of zeros needed to push the max value of the array above +-1_000_000.
 
         Adding this as an attribute to use later in _classify_from_bins.
         """
@@ -293,31 +292,72 @@ class Map:
     def _add_minmax_to_bins(self, bins: list[float | int]) -> list[float | int]:
         """If values are outside the bin range, add max and/or min values of array."""
         # make sure they are lists
-        bins = [bin for bin in bins]
-
-        if min(bins) > 0 and min(self._gdf.loc[~self._nan_idx, self._column]) < min(
-            bins
-        ):
-            bins = [min(self._gdf.loc[~self._nan_idx, self._column])] + bins
-
-        if min(bins) < 0 and min(self._gdf.loc[~self._nan_idx, self._column]) < min(
-            bins
-        ):
-            bins = [min(self._gdf.loc[~self._nan_idx, self._column])] + bins
+        bins = [bin_ for bin_ in bins]
+
+        if min(bins) > 0 and min(
+            self._gdf.loc[list(~self._nan_idx), self._column]
+        ) < min(bins):
+            num = min(self._gdf.loc[list(~self._nan_idx), self._column])
+            # if isinstance(num, float):
+            #     num -= (
+            #         float(f"1e-{abs(self.legend.rounding)}")
+            #         if self.legend and self.legend.rounding
+            #         else 0
+            #     )
+            bins = [num] + bins
+
+        if min(bins) < 0 and min(
+            self._gdf.loc[list(~self._nan_idx), self._column]
+        ) < min(bins):
+            num = min(self._gdf.loc[list(~self._nan_idx), self._column])
+            # if isinstance(num, float):
+            #     num -= (
+            #         float(f"1e-{abs(self.legend.rounding)}")
+            #         if self.legend and self.legend.rounding
+            #         else 0
+            #     )
+            bins = [num] + bins
 
         if max(bins) > 0 and max(
             self._gdf.loc[self._gdf[self._column].notna(), self._column]
         ) > max(bins):
-            bins = bins + [
-                max(self._gdf.loc[self._gdf[self._column].notna(), self._column])
-            ]
+            num = max(self._gdf.loc[self._gdf[self._column].notna(), self._column])
+            # if isinstance(num, float):
+            #     num += (
+            #         float(f"1e-{abs(self.legend.rounding)}")
+            #         if self.legend and self.legend.rounding
+            #         else 0
+            #     )
+            bins = bins + [num]
 
         if max(bins) < 0 and max(
             self._gdf.loc[self._gdf[self._column].notna(), self._column]
         ) < max(bins):
-            bins = bins + [
-                max(self._gdf.loc[self._gdf[self._column].notna(), self._column])
-            ]
+            num = max(self._gdf.loc[self._gdf[self._column].notna(), self._column])
+            # if isinstance(num, float):
+            #     num += (
+            #         float(f"1e-{abs(self.legend.rounding)}")
+            #         if self.legend and self.legend.rounding
+            #         else 0
+            #     )
+
+            bins = bins + [num]
+
+        def adjust_bin(num: int | float, i: int) -> int | float:
+            if isinstance(num, int):
+                return num
+            adjuster = (
+                float(f"1e-{abs(self.legend.rounding)}")
+                if self.legend and self.legend.rounding
+                else 0
+            )
+            if i == 0:
+                return num - adjuster
+            elif i == len(bins) - 1:
+                return num + adjuster
+            return num
+
+        bins = [adjust_bin(x, i) for i, x in enumerate(bins)]
 
         return bins
 
@@ -329,16 +369,26 @@ class Map:
     ) -> tuple[tuple[GeoDataFrame], str]:
         """Separate GeoDataFrames from string (column argument)."""
 
-        def as_dict(obj):
+        def as_dict(obj) -> dict:
             if hasattr(obj, "__dict__"):
                 return obj.__dict__
             elif isinstance(obj, dict):
                 return obj
-            raise TypeError
-
-        allowed_types = (GeoDataFrame, GeoSeries, Geometry, RasterDataset)
+            raise TypeError(type(obj))
+
+        allowed_types = (
+            GeoDataFrame,
+            GeoSeries,
+            Geometry,
+            RasterDataset,
+            ImageCollection,
+            Image,
+            Band,
+        )
 
-        gdfs: tuple[GeoDataFrame | GeoSeries | Geometry | RasterDataset] = ()
+        gdfs = ()
+        more_gdfs = {}
+        i = 0
         for arg in args:
             if isinstance(arg, str):
                 if column is None:
@@ -349,12 +399,31 @@ class Map:
                     )
             elif isinstance(arg, allowed_types):
                 gdfs = gdfs + (arg,)
+            # elif isinstance(arg, Sequence) and not isinstance(arg, str):
             elif isinstance(arg, dict) or hasattr(arg, "__dict__"):
                 # add dicts or classes with GeoDataFrames to kwargs
-                more_gdfs = {}
                 for key, value in as_dict(arg).items():
                     if isinstance(value, allowed_types):
                         more_gdfs[key] = value
+                    elif isinstance(value, dict) or hasattr(value, "__dict__"):
+                        # elif isinstance(value, Sequence) and not isinstance(value, str):
+                        try:
+                            # same as above, one level down
+                            more_gdfs |= {
+                                k: v
+                                for k, v in as_dict(value).items()
+                                if isinstance(v, allowed_types)
+                            }
+                        except Exception:
+                            # ignore all exceptions
+                            pass
+
+            elif isinstance(arg, Sequence) and not isinstance(arg, str):
+                # add dicts or classes with GeoDataFrames to kwargs
+                for value in arg:
+                    if isinstance(value, allowed_types):
+                        name = _determine_best_name(value, column, i)
+                        more_gdfs[name] = value
                     elif isinstance(value, dict) or hasattr(value, "__dict__"):
                         try:
                             # same as above, one level down
@@ -366,18 +435,24 @@ class Map:
                         except Exception:
                             # no need to raise here
                             pass
+                    elif isinstance(value, Sequence) and not isinstance(value, str):
+                        for x in value:
+                            if not isinstance(x, allowed_types):
+                                continue
+                            name = _determine_best_name(value, column, i)
+                            more_gdfs[name] = x
+                    i += 1
 
-                kwargs |= more_gdfs
+        kwargs |= more_gdfs
 
         return gdfs, column, kwargs
 
-    def _prepare_continous_map(self):
+    def _prepare_continous_map(self) -> None:
         """Create bins if not already done and adjust k if needed."""
-
         if self.scheme is None:
             return
 
-        if not self.bins:
+        if self.bins is None:
             self.bins = self._create_bins(self._gdf, self._column)
             if len(self.bins) <= self._k and len(self.bins) != len(self._unique_values):
                 self._k = len(self.bins)
@@ -389,17 +464,6 @@ class Map:
             self._unique_values = self.nan_label
             self._k = 1
 
-    def _get_labels(self, gdfs: tuple[GeoDataFrame]) -> None:
-        """Putting the labels/names in a list before copying the gdfs."""
-        self.labels: list[str] = []
-        for i, gdf in enumerate(gdfs):
-            if hasattr(gdf, "name") and isinstance(gdf.name, str):
-                name = gdf.name
-            else:
-                name = get_object_name(gdf)
-                name = name or str(i)
-            self.labels.append(name)
-
     def _set_labels(self) -> None:
         """Setting the labels after copying the gdfs."""
         gdfs = []
@@ -408,7 +472,9 @@ class Map:
             gdfs.append(gdf)
         self._gdfs = gdfs
 
-    def _to_common_crs_and_one_geom_col(self, gdfs: list[GeoDataFrame]):
+    def _to_common_crs_and_one_geom_col(
+        self, gdfs: list[GeoDataFrame]
+    ) -> list[GeoDataFrame]:
         """Need common crs and max one geometry column."""
         crs_list = list({gdf.crs for gdf in gdfs if gdf.crs is not None})
         if crs_list:
@@ -416,7 +482,7 @@ class Map:
         new_gdfs = []
         for gdf in gdfs:
             gdf = gdf.reset_index(drop=True)
-            gdf = drop_inactive_geometry_columns(gdf).pipe(rename_geometry_if)
+            gdf = drop_inactive_geometry_columns(gdf).pipe(_rename_geometry_if)
             if crs_list:
                 try:
                     gdf = gdf.to_crs(self.crs)
@@ -451,7 +517,18 @@ class Map:
         if not self._column:
             return True
 
+        def is_maybe_km2():
+            if "area" in self._column and (
+                "km2" in self._column
+                or "kilomet" in self._column
+                and ("sq" in self._column or "2" in self._column)
+            ):
+                return True
+            else:
+                return False
+
         maybe_area = 1 if "area" in self._column else 0
+        maybe_area_km2 = 1 if is_maybe_km2() else 0
         maybe_length = (
             1 if any(x in self._column for x in ["meter", "metre", "leng"]) else 0
         )
@@ -460,7 +537,10 @@ class Map:
         col_not_present = 0
         for gdf in self._gdfs:
             if self._column not in gdf:
-                if maybe_area:
+                if maybe_area_km2 and unit_is_meters(gdf):
+                    gdf["area_km2"] = gdf.area / 1_000_000
+                    maybe_area_km2 += 1
+                elif maybe_area:
                     gdf["area"] = gdf.area
                     maybe_area += 1
                 elif maybe_length:
@@ -473,6 +553,9 @@ class Map:
                     all_nan += 1
                 return True
 
+        if maybe_area_km2 > 1:
+            self._column = "area_km2"
+            return False
         if maybe_area > 1:
             self._column = "area"
             return False
@@ -488,7 +571,7 @@ class Map:
 
         return False
 
-    def _get_categorical_colors(self) -> None:
+    def _make_categories_colors_dict(self) -> None:
         # custom categorical cmap
         if not self._cmap and len(self._unique_values) <= len(_CATEGORICAL_CMAP):
             self._categories_colors_dict = {
@@ -510,6 +593,7 @@ class Map:
                 for i, category in enumerate(self._unique_values)
             }
 
+    def _fix_nans(self) -> None:
         if any(self._nan_idx):
             self._gdf[self._column] = self._gdf[self._column].fillna(self.nan_label)
             self._categories_colors_dict[self.nan_label] = self.nan_color
@@ -530,8 +614,7 @@ class Map:
         If 'scheme' is not specified, the jenks_breaks function is used, which is
         much faster than the one from Mapclassifier.
         """
-
-        if not len(gdf.loc[~self._nan_idx, column]):
+        if not len(gdf.loc[list(~self._nan_idx), column]):
             return np.array([0])
 
         n_classes = (
@@ -547,29 +630,26 @@ class Map:
             n_classes = len(self._unique_values)
 
         if self.scheme == "jenks":
-            try:
-                bins = jenks_breaks(
-                    gdf.loc[~self._nan_idx, column], n_classes=n_classes
-                )
-                bins = self._add_minmax_to_bins(bins)
-            except Exception:
-                pass
+            bins = jenks_breaks(
+                gdf.loc[list(~self._nan_idx), column], n_classes=n_classes
+            )
         else:
             binning = classify(
-                np.asarray(gdf.loc[~self._nan_idx, column]),
+                np.asarray(gdf.loc[list(~self._nan_idx), column]),
                 scheme=self.scheme,
-                k=self._k,
+                # k=self._k,
+                k=n_classes,
             )
             bins = binning.bins
-            bins = self._add_minmax_to_bins(bins)
 
-        unique_bins = list({round(bin, 5) for bin in bins})
-        unique_bins.sort()
+        bins = self._add_minmax_to_bins(bins)
 
-        if self._k == len(self._unique_values) - 1:
-            return np.array(unique_bins)
+        unique_bins = list({round(bin_, 5) for bin_ in bins})
+        unique_bins.sort()
 
-        if len(unique_bins) == len(self._unique_values):
+        if self._k == len(self._unique_values) - 1 or len(unique_bins) == len(
+            self._unique_values
+        ):
             return np.array(unique_bins)
 
         if len(unique_bins) == len(bins) - 1:
@@ -577,7 +657,7 @@ class Map:
 
         return np.array(bins)
 
-    def change_cmap(self, cmap: str, start: int = 0, stop: int = 256):
+    def change_cmap(self, cmap: str, start: int = 0, stop: int = 256) -> "Map":
         """Change the color palette of the plot.
 
         Args:
@@ -606,6 +686,7 @@ class Map:
 
     def _classify_from_bins(self, gdf: GeoDataFrame, bins: np.ndarray) -> np.ndarray:
         """Place the column values into groups."""
+        bins = bins.copy()
 
         # if equal lenght, convert to integer and check for equality
         if len(bins) == len(self._unique_values):
@@ -621,6 +702,14 @@ class Map:
             if len(bins) == self._k + 1:
                 bins = bins[1:]
 
+            if (
+                self.legend
+                and self.legend.rounding
+                and (self.legend.rounding or 1) <= 0
+            ):
+                bins[0] = bins[0] - 1
+                bins[-1] = bins[-1] + 1
+
             if gdf[self._column].isna().all():
                 return np.repeat(len(bins), len(gdf))
 
@@ -647,11 +736,12 @@ class Map:
         return np.array([rank_dict[val] for val in classified])
 
     @property
-    def k(self):
+    def k(self) -> int:
+        """Number of bins."""
         return self._k
 
     @k.setter
-    def k(self, new_value: bool):
+    def k(self, new_value: int) -> None:
         if not self._is_categorical and new_value > len(self._unique_values):
             raise ValueError(
                 "'k' cannot be greater than the number of unique values in the column.'"
@@ -661,55 +751,84 @@ class Map:
         self._k = int(new_value)
 
     @property
-    def cmap(self):
+    def cmap(self) -> str:
+        """Colormap."""
         return self._cmap
 
     @cmap.setter
-    def cmap(self, new_value: bool):
+    def cmap(self, new_value: str) -> None:
         self._cmap = new_value
-        self.change_cmap(cmap=new_value, start=self.cmap_start, stop=self.cmap_stop)
+        if not self._is_categorical:
+            self.change_cmap(cmap=new_value, start=self.cmap_start, stop=self.cmap_stop)
 
     @property
-    def gdf(self):
+    def gdf(self) -> GeoDataFrame:
+        """All GeoDataFrames concated."""
         return self._gdf
 
     @gdf.setter
-    def gdf(self, _):
+    def gdf(self, _) -> None:
         raise ValueError(
             "Cannot change 'gdf' after init. Put the GeoDataFrames into "
             "the class initialiser."
         )
 
     @property
-    def gdfs(self):
+    def gdfs(self) -> list[GeoDataFrame]:
+        """All GeoDataFrames as a list."""
         return self._gdfs
 
     @gdfs.setter
-    def gdfs(self, _):
+    def gdfs(self, _) -> None:
         raise ValueError(
             "Cannot change 'gdfs' after init. Put the GeoDataFrames into "
             "the class initialiser."
         )
 
     @property
-    def column(self):
+    def column(self) -> str | None:
+        """Column to use as colormap."""
         return self._column
 
     @column.setter
-    def column(self, _):
+    def column(self, _) -> None:
         raise ValueError(
             "Cannot change 'column' after init. Specify 'column' in the "
             "class initialiser."
         )
 
-    def __setitem__(self, item, new_item):
+    def __setitem__(self, item: Any, new_item: Any) -> None:
+        """Set an attribute with square brackets."""
         return setattr(self, item, new_item)
 
-    def __getitem__(self, item):
+    def __getitem__(self, item: Any) -> Any:
+        """Get an attribute with square brackets."""
         return getattr(self, item)
 
-    def get(self, key, default=None):
+    def get(self, key: Any, default: Any | None = None) -> Any:
+        """Get an attribute with default value if not present."""
         try:
             return self[key]
         except (KeyError, ValueError, IndexError, AttributeError):
             return default
+
+
+def _determine_best_name(obj: Any, column: str | None, i: int) -> str:
+    try:
+        # Frame 3: actual object name Frame 2: maps.py:explore(). Frame 1: __init__. Frame 0: this function.
+        return str(get_object_name(obj, start=3))
+    except ValueError:
+        if isinstance(obj, GeoSeries) and obj.name:
+            return str(obj.name)
+        elif isinstance(obj, GeoDataFrame) and len(obj.columns) == 2 and not column:
+            series = obj.drop(columns=obj._geometry_column_name).iloc[:, 0]
+            if (
+                len(series.unique()) == 1
+                and mean(isinstance(x, str) for x in series) > 0.5
+            ):
+                return str(next(iter(series)))
+            elif series.name:
+                return str(series.name)
+        else:
+            # generic label e.g. Image(1)
+            return f"{obj.__class__.__name__}({i})"