ssb-sgis 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

sgis/maps/thematicmap.py

@@ -11,12 +11,14 @@ import pandas as pd
 from geopandas import GeoDataFrame
 
 from ..geopandas_tools.conversion import to_bbox
+from ..geopandas_tools.conversion import to_gdf
 from ..helpers import is_property
 from .legend import LEGEND_KWARGS
 from .legend import ContinousLegend
 from .legend import Legend
 from .legend import prettify_bins
 from .map import Map
+from .map import _determine_best_name
 
 # the geopandas._explore raises a deprication warning. Ignoring for now.
 warnings.filterwarnings(
@@ -70,6 +72,7 @@ class ThematicMap(Map):
         bins: For numeric columns. List of numbers that define the
             maximum value for the color groups.
         nan_label: Label for missing data.
+        nan_hatch: Hatch for missing data. See https://matplotlib.org/stable/gallery/shapes_and_collections/hatch_style_reference.html.
         legend_kwargs: dictionary with attributes for the legend. E.g.:
             title: Legend title. Defaults to the column name.
             rounding: If positive number, it will round floats to n decimals.
@@ -170,23 +173,50 @@ class ThematicMap(Map):
         k: int = 5,
         bins: tuple[float] | None = None,
         nan_label: str = "Missing",
+        nan_color: str | None = None,
+        nan_hatch: str | None = None,
+        hatch: str | None = None,
         legend_kwargs: dict | None = None,
         title_kwargs: dict | None = None,
         legend: bool = True,
         **kwargs,
     ) -> None:
-        """Initialiser."""
+        """Initializer."""
+        new_gdfs = {}
+        for i, gdf in enumerate(gdfs):
+            if isinstance(gdf, str):
+                raise ValueError("gdfs cannot be a string in ThematicMap.")
+            name = _determine_best_name(gdf, column, i)
+            if name in new_gdfs:
+                name += str(i)
+            try:
+                new_gdfs[name] = to_gdf(gdf)
+            except Exception:
+                continue
+
+        new_kwargs = {}
+        self.kwargs = {}
+        for key, value in kwargs.items():
+            try:
+                new_gdfs[key] = to_gdf(value)
+            except Exception:
+                new_kwargs[key] = value
+
         super().__init__(
-            *gdfs,
             column=column,
             scheme=scheme,
             k=k,
             bins=bins,
             nan_label=nan_label,
+            nan_color=nan_color,
+            **new_gdfs,
         )
 
+        self.kwargs = self.kwargs | new_kwargs
+
         self.title = title
         self._size = size
+        self.hatch = hatch
         self._dark = dark
         self.title_kwargs = title_kwargs or {}
         if title_position and "position" in self.title_kwargs:
@@ -219,7 +249,7 @@ class ThematicMap(Map):
 
         self._title_fontsize = self._size * 1.9
 
-        black = kwargs.pop("black", None)
+        black = self.kwargs.pop("black", None)
         self._dark = self._dark or black
 
         if not self.cmap and not self._is_categorical:
@@ -235,13 +265,15 @@ class ThematicMap(Map):
         if cmap:
             self._cmap = cmap
 
-        for key, value in kwargs.items():
+        new_kwargs = {}
+        for key, value in self.kwargs.items():
             if key not in MAP_KWARGS:
-                self.kwargs[key] = value
+                new_kwargs[key] = value
             elif is_property(self, key):
                 setattr(self, f"_{key}", value)
             else:
                 setattr(self, key, value)
+        self.kwargs = new_kwargs
 
         for key, value in legend_kwargs.items():
             if key not in LEGEND_KWARGS:
@@ -261,6 +293,20 @@ class ThematicMap(Map):
         self.diffx = self.maxx - self.minx
         self.diffy = self.maxy - self.miny
 
+        if self._gdf[self._column].isna().any():
+            isnas = []
+            for label, gdf in self._gdfs.items():
+
+                isnas.append(gdf[gdf[self._column].isna()])
+                self._gdfs[label] = gdf[gdf[self._column].notna()]
+            color = self.facecolor if nan_hatch else self.nan_color
+            self._more_data[nan_label] = {
+                "gdf": pd.concat(isnas, ignore_index=True),
+                "color": color,
+                "hatch": nan_hatch,
+            } | new_kwargs
+            self._gdf = pd.concat(self.gdfs.values(), ignore_index=True)
+
     @property
     def valid_keywords(self) -> set[str]:
         """List all valid keywords for the class initialiser."""
@@ -279,6 +325,52 @@ class ThematicMap(Map):
         super().change_cmap(cmap, start, stop)
         return self
 
+    def add_data(
+        self,
+        *,
+        color: str | None = None,
+        hatch: str | None = None,
+        **kwargs,
+    ) -> "ThematicMap":
+        """Add Geometric Data of a given color or hatch.
+
+        The geodata must be passed as keyword argument.
+        The keyword will be used as label in the legend.
+
+        Args:
+            color: Color of the data.
+            hatch: Hatch of the data. See https://matplotlib.org/stable/gallery/shapes_and_collections/hatch_style_reference.html.
+            **kwargs: Must include exactly one GeoDataFrame or object that can be converted to GeoDataFrame.
+                Additional kwargs are passed to geopandas.GeoDataFrame.plot and matplotlib.patches.Patch.
+        """
+        new_kwargs = {}
+        n = 0
+        for key, value in kwargs.items():
+            try:
+                gdf = to_gdf(value)
+                label = key
+                n += 1
+            except Exception:
+                new_kwargs[key] = value
+
+        if n != 1:
+            raise ValueError(
+                "Must specify a single geometry object as keyword argument."
+            )
+        if not color and not hatch:
+            raise TypeError("Must pass either 'color' or 'hatch'.")
+        if hatch is not None:
+            color = self.facecolor
+        gdf["label"] = label
+        self._more_data[label] = {
+            "gdf": gdf,
+            "color": color,
+            "hatch": hatch,
+        } | new_kwargs
+        if self.bounds is None:
+            self.bounds = to_bbox(self._gdf.total_bounds)
+        return self
+
     def add_background(
         self,
         gdf: GeoDataFrame,
@@ -327,11 +419,13 @@ class ThematicMap(Map):
             include_legend = False
 
         elif self._is_categorical:
-            kwargs = self._prepare_categorical_plot(kwargs)
+            self._prepare_categorical_plot()
+            if self._gdf is not None:
+                kwargs["color"] = self._gdf["color"]
             if self.legend:
                 self.legend._prepare_categorical_legend(
                     categories_colors=self._categories_colors_dict,
-                    nan_label=self.nan_label,
+                    hatch=self.hatch,
                 )
 
         else:
@@ -339,19 +433,23 @@ class ThematicMap(Map):
             if self.legend:
                 if not self.legend.rounding:
                     self.legend._rounding = self.legend._get_rounding(
-                        array=self._gdf.loc[~self._nan_idx, self._column]
+                        array=self._gdf[self._column].dropna()
                     )
 
                 self.legend._prepare_continous_legend(
                     bins=self.bins,
                     colors=self._unique_colors,
-                    nan_label=self.nan_label,
                     bin_values=self._bins_unique_values,
+                    nan_label=self.nan_label,
+                    hatch=self.hatch,
                 )
 
+        if self.legend and self._more_data:
+            self.legend._add_more_data_to_legend(self._more_data)
+
         if self.legend and not self.legend._position_has_been_set:
             self.legend._position = self.legend._get_best_legend_position(
-                self._gdf, k=self._k + bool(len(self._nan_idx))
+                self._gdf, k=self._k + self._gdf[self._column].isna().any()
             )
 
         self._prepare_plot(**kwargs)
@@ -359,7 +457,9 @@ class ThematicMap(Map):
         if self.legend:
             self.ax = self.legend._actually_add_legend(ax=self.ax)
 
-        self.ax = self._gdf.plot(legend=include_legend, ax=self.ax, **kwargs)
+        self.ax = self._gdf.plot(
+            legend=include_legend, ax=self.ax, hatch=self.hatch, **kwargs
+        )
 
         if __test:
             return self
@@ -394,16 +494,17 @@ class ThematicMap(Map):
         )
         self.fig.patch.set_facecolor(self.facecolor)
         self.ax.set_axis_off()
+        self.ax.set_xlim([self.minx - self.diffx * 0.03, self.maxx + self.diffx * 0.03])
+        self.ax.set_ylim([self.miny - self.diffy * 0.03, self.maxy + self.diffy * 0.03])
 
         if hasattr(self, "_background_gdfs"):
             self._actually_add_background()
-        elif self.bounds is not None:
-            self.ax.set_xlim(
-                [self.minx - self.diffx * 0.03, self.maxx + self.diffx * 0.03]
-            )
-            self.ax.set_ylim(
-                [self.miny - self.diffy * 0.03, self.maxy + self.diffy * 0.03]
-            )
+        # if self.bounds is not None:
+
+        for datadict in self._more_data.values():
+            gdf = datadict["gdf"]
+            datadict = {key: value for key, value in datadict.items() if key != "gdf"}
+            gdf.plot(ax=self.ax, **datadict)
 
         if self.title:
             self.ax.set_title(
@@ -437,7 +538,10 @@ class ThematicMap(Map):
 
             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()
+            )
             self._unique_colors = self._get_continous_colors(n=n_colors)
             self._bins_unique_values = self._make_bin_value_dict(
                 self._gdf, classified_sequential
@@ -453,27 +557,16 @@ class ThematicMap(Map):
                 bins=self.bins, rounding=self.legend._rounding
             )
 
-            if any(self._nan_idx):
+            if self._gdf[self._column].isna().any():
                 self.bins = self.bins + [self.nan_label]
 
         return kwargs
 
-    def _prepare_categorical_plot(self, kwargs: dict) -> dict:
-        """Map values to colors."""
-        self._make_categories_colors_dict()
-        if self._gdf is not None and len(self._gdf):
-            self._fix_nans()
-
-        if self._gdf is not None:
-            colorarray = self._gdf["color"]
-            kwargs["color"] = colorarray
-        return kwargs
-
     def _actually_add_legend(self) -> None:
         """Add legend to the axis and fill it with colors and labels."""
         if not self.legend._position_has_been_set:
             self.legend._position = self.legend._get_best_legend_position(
-                self._gdf, k=self._k + bool(len(self._nan_idx))
+                self._gdf, k=self._k + self._gdf[self._column].isna().any()
             )
 
         if self._is_categorical:
@@ -518,15 +611,15 @@ class ThematicMap(Map):
         return bins_unique_values
 
     def _actually_add_background(self) -> None:
-        self.ax.set_xlim([self.minx - self.diffx * 0.03, self.maxx + self.diffx * 0.03])
-        self.ax.set_ylim([self.miny - self.diffy * 0.03, self.maxy + self.diffy * 0.03])
+        # self.ax.set_xlim([self.minx - self.diffx * 0.03, self.maxx + self.diffx * 0.03])
+        # self.ax.set_ylim([self.miny - self.diffy * 0.03, self.maxy + self.diffy * 0.03])
         self._background_gdfs.plot(
             ax=self.ax, color=self.bg_gdf_color, **self.bg_gdf_kwargs
         )
 
     @staticmethod
     def _get_matplotlib_figure_and_axix(
-        figsize: tuple[int, int]
+        figsize: tuple[int, int],
     ) -> tuple[matplotlib.figure.Figure, matplotlib.axes.Axes]:
         fig = plt.figure(figsize=figsize)
         ax = fig.add_subplot(1, 1, 1)
@@ -539,7 +632,7 @@ class ThematicMap(Map):
                 "#fefefe",
                 "#383836",
             )
-            self.nan_color = "#666666"
+            self.nan_color = "#666666" if self._nan_color_was_none else self.nan_color
             if not self._is_categorical:
                 self.change_cmap("viridis")
 
@@ -557,7 +650,7 @@ class ThematicMap(Map):
                 "#0f0f0f",
                 "#e8e6e6",
             )
-            self.nan_color = "#c2c2c2"
+            self.nan_color = "#c2c2c2" if self._nan_color_was_none else self.nan_color
             if not self._is_categorical:
                 self.change_cmap("RdPu", start=23)
 
@@ -569,16 +662,6 @@ class ThematicMap(Map):
                 }.items():
                     setattr(self.legend, key, color)
 
-    @property
-    def dark(self) -> bool:
-        """Whether to use dark background and light text colors."""
-        return self._dark
-
-    @dark.setter
-    def dark(self, new_value: bool):
-        self._dark = new_value
-        self._dark_or_light()
-
     @property
     def title_fontsize(self) -> int:
         """Title fontsize, not to be confused with legend.title_fontsize."""

sgis/maps/wms.py

@@ -55,6 +55,7 @@ class NorgeIBilderWms(WmsLoader):
     contains: str | Iterable[str] | None = None
     not_contains: str | Iterable[str] | None = None
     show: bool | Iterable[int] | int = False
+    _use_json: bool = True
 
     def load_tiles(self) -> None:
         """Load all Norge i bilder tiles into self.tiles."""
@@ -184,7 +185,7 @@ class NorgeIBilderWms(WmsLoader):
 
         self.years = [str(int(year)) for year in self.years]
 
-        if all(year in JSON_YEARS for year in self.years):
+        if self._use_json and all(year in JSON_YEARS for year in self.years):
             try:
                 with open(JSON_PATH, encoding="utf-8") as file:
                     self.tiles = json.load(file)

sgis/raster/image_collection.py

@@ -94,6 +94,8 @@ except ImportError:
         """Placeholder."""
 
 
+from ..conf import _get_instance
+from ..conf import config
 from ..geopandas_tools.bounds import get_total_bounds
 from ..geopandas_tools.conversion import to_bbox
 from ..geopandas_tools.conversion import to_gdf
@@ -106,7 +108,7 @@ from ..helpers import is_method
 from ..helpers import is_property
 from ..io._is_dapla import is_dapla
 from ..io.opener import opener
-from . import sentinel_config as config
+from . import sentinel_config
 from .base import _array_to_geojson
 from .base import _gdf_to_arr
 from .base import _get_res_from_bounds
@@ -443,11 +445,15 @@ class _ImageBase:
     metadata_attributes: ClassVar[dict | None] = None
     masking: ClassVar[BandMasking | None] = None
 
-    def __init__(self, *, metadata=None, bbox=None, **kwargs) -> None:
+    def __init__(self, *, metadata=None, bbox=None, file_system=None, **kwargs) -> None:
 
         self._bounds = None
         self._path = None
         self._bbox = to_bbox(bbox) if bbox is not None else None
+        if file_system is None:
+            self.file_system = _get_instance(config, "file_system")
+        else:
+            self.file_system = file_system
 
         self.metadata_attributes = self.metadata_attributes or {}
 
@@ -3135,8 +3141,8 @@ class ImageCollection(_ImageBase):
 class Sentinel2Config:
     """Holder of Sentinel 2 regexes, band_ids etc."""
 
-    image_regexes: ClassVar[str] = (config.SENTINEL2_IMAGE_REGEX,)
-    filename_regexes: ClassVar[str] = (config.SENTINEL2_FILENAME_REGEX,)
+    image_regexes: ClassVar[str] = (sentinel_config.SENTINEL2_IMAGE_REGEX,)
+    filename_regexes: ClassVar[str] = (sentinel_config.SENTINEL2_FILENAME_REGEX,)
     metadata_attributes: ClassVar[
         dict[str, Callable | functools.partial | tuple[str]]
     ] = {
@@ -3222,8 +3228,8 @@ class Sentinel2Config:
 class Sentinel2CloudlessConfig(Sentinel2Config):
     """Holder of regexes, band_ids etc. for Sentinel 2 cloudless mosaic."""
 
-    image_regexes: ClassVar[str] = (config.SENTINEL2_MOSAIC_IMAGE_REGEX,)
-    filename_regexes: ClassVar[str] = (config.SENTINEL2_MOSAIC_FILENAME_REGEX,)
+    image_regexes: ClassVar[str] = (sentinel_config.SENTINEL2_MOSAIC_IMAGE_REGEX,)
+    filename_regexes: ClassVar[str] = (sentinel_config.SENTINEL2_MOSAIC_FILENAME_REGEX,)
     masking: ClassVar[None] = None
     all_bands: ClassVar[list[str]] = [
         x.replace("B0", "B") for x in Sentinel2Config.all_bands

{ssb_sgis-1.2.1.dist-info → ssb_sgis-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ssb-sgis
-Version: 1.2.1
+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.1.dist-info → ssb_sgis-1.2.3.dist-info}/RECORD

@@ -9,11 +9,11 @@ sgis/geopandas_tools/centerlines.py,sha256=Q65Sx01SeAlulBEd9oaZkB2maBBNdLcJwAbTI
 sgis/geopandas_tools/cleaning.py,sha256=PkAVVZ84ahek8_uVlTRtCO8nCWO6DdGltWLTmPOsvxM,24426
 sgis/geopandas_tools/conversion.py,sha256=w3W0Utaw7SESRR659percNLwOY9_yfg6DL5hcuM1CUA,25017
 sgis/geopandas_tools/duplicates.py,sha256=TDDM4u1n7SIkyJrOfl1Lno92AmUPqtXBHsj1IUKC0hI,14992
-sgis/geopandas_tools/general.py,sha256=PHcQipR579mhABPALQICw2HnnByGe65XMHthTzVH_Ps,43927
+sgis/geopandas_tools/general.py,sha256=YRpNEdwTHyFdQOdAfbCmYXS7PxoDjXxoagwpteXkYdI,43937
 sgis/geopandas_tools/geocoding.py,sha256=n47aFQMm4yX1MsPnTM4dFjwegCA1ZmGUDj1uyu7OJV4,691
 sgis/geopandas_tools/geometry_types.py,sha256=ijQDbQaZPqPGjBl707H4yooNXpk21RXyatI7itnvqLk,7603
 sgis/geopandas_tools/neighbors.py,sha256=tMs8jUU0np5QvIysUdF0lLEdXwiXTBotTSdgUXclEfY,17480
-sgis/geopandas_tools/overlay.py,sha256=WsJFt9QjkYCUQY_2ckySZ0yG66EeEBHpkyipHs0do4o,23399
+sgis/geopandas_tools/overlay.py,sha256=5i9u8GgFuU0fCqzELsbIaoUPhw-E7eZHl_yKB0wEcGM,23464
 sgis/geopandas_tools/point_operations.py,sha256=JM4hvfIVxZaZdGNlGzcCurrKzkgC_b9hzbFYN42f9WY,6972
 sgis/geopandas_tools/polygon_operations.py,sha256=v-B9IgbFfm4dVHKPyzvmnNiqVCdtl9ddpCsQpZZ-9sU,49284
 sgis/geopandas_tools/polygons_as_rings.py,sha256=BX_GZS6F9I4NbEpiOlNBd7zywJjdfdJVi_MkeONBuiM,14941
@@ -23,20 +23,20 @@ sgis/geopandas_tools/utils.py,sha256=X0pRvB1tWgV_0BCrRS1HU9LtLGnZCpvVPxyqM9JGb0Y
 sgis/helpers.py,sha256=4N6vFWQ3TYVzRHNcWY_fNa_GkFuaZB3vtCkkFND-qs0,9628
 sgis/io/__init__.py,sha256=uyBr20YDqB2bQttrd5q1JuGOvX32A-MSvS7Wmw5f5qg,177
 sgis/io/_is_dapla.py,sha256=wmfkSe98IrLhUg3dtXZusV6OVC8VlY1kbc5EQDf3P-Q,358
-sgis/io/dapla_functions.py,sha256=3jt5444gXNDV5Md8E2_Sjvb4p0QjHptjqDjw7aHWlns,30476
+sgis/io/dapla_functions.py,sha256=cwCmwgOoWOaYMJ35hgAJtCJ7m8bQBM4RsL7y3afjnLc,30539
 sgis/io/opener.py,sha256=HWO3G1NB6bpXKM94JadCD513vjat1o1TFjWGWzyVasg,898
 sgis/io/read_parquet.py,sha256=FvZYv1rLkUlrSaUY6QW6E1yntmntTeQuZ9ZRgCDO4IM,3776
 sgis/maps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sgis/maps/examine.py,sha256=Pb0dH8JazU5E2svfQrzHO1Bi-sjy5SeyY6zoeMO34jE,9369
-sgis/maps/explore.py,sha256=0QDPaj5YU2Jps5iujuHu-vk_R9mFh_aOhbN1eU-fxcI,47898
+sgis/maps/explore.py,sha256=4ly_zeMiHUZThBzoVt62Z4smEZH97qsnzodaaRiBJco,47697
 sgis/maps/httpserver.py,sha256=eCDoB9x74kSLiGEj2X3O91t3oscY_ia17UNuaaJ6tCc,2472
-sgis/maps/legend.py,sha256=lVRVCkhPmJRjGK23obFJZAO3qp6du1LYnobkkN7DPkc,26279
-sgis/maps/map.py,sha256=veTx5blncH54jDx3WCLwstryn9CjlaNqWggooJY49Pg,30480
-sgis/maps/maps.py,sha256=csPXJa9R7zwlDJ0lz8qW91l0uRxjo1m2smoU8IPtgLA,23091
-sgis/maps/norge_i_bilder.json,sha256=W_mFfte3DxugWbEudZ5fadZ2JeFYb0hyab2Quf4oJME,481311
-sgis/maps/thematicmap.py,sha256=w6q4_gIr8BubQgsPJkc6WXk-tmplDLGcKyjphhFp7ng,21873
+sgis/maps/legend.py,sha256=qq2RkebuaNAdFztlXrDOWbN0voeK5w5VycmRKyx0NdM,26512
+sgis/maps/map.py,sha256=q0gqOg_DD1ea7B_8__nuFN1dYA7o3uIxS6KuJwmVNhQ,30269
+sgis/maps/maps.py,sha256=Ti4nfm6bz_8ZWVHoEHF61moI3LQH9Ee6Jd8NHzInWkw,23135
+sgis/maps/norge_i_bilder.json,sha256=VKmb7rg4jvgc8_Ve1fFnHyZ_Dkv4T5GTA0UCpqpFAi4,492751
+sgis/maps/thematicmap.py,sha256=xTX_Y6ZXLcjNCgfUOr87pAMD4cjKxhFudZZXn_ewpII,25171
 sgis/maps/tilesources.py,sha256=F4mFHxPwkiPJdVKzNkScTX6xbJAMIUtlTq4mQ83oguw,1746
-sgis/maps/wms.py,sha256=y8xJSWCqE1SZPInWKiTGdGLI015hOFrdwUyPVouU1LU,6885
+sgis/maps/wms.py,sha256=UjsKAvrZkcYRgjVGGeg6XA4Lkx6WU9w6WTyeSkwN78w,6931
 sgis/networkanalysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sgis/networkanalysis/_get_route.py,sha256=9I3t9pnccUPr4mozy3TJCOpGCCf3UOIojmsbifubZbA,6368
 sgis/networkanalysis/_od_cost_matrix.py,sha256=zkyPX7ObT996ahaFJ2oI0D0SqQWbWyfy_qLtXwValPg,3434
@@ -56,12 +56,12 @@ sgis/parallel/parallel.py,sha256=qPhCiL81SZNKnJqFrW-rHrJeZvC7jO9_FjxO0RMdEUo,400
 sgis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sgis/raster/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sgis/raster/base.py,sha256=tiZEuMcVK6hOm_aIjWhQ1WGshcjsxT1fFkuBSLFiMC0,7785
-sgis/raster/image_collection.py,sha256=wyrxb9HNzp916HKnsF7BuW6HzrGFU2zOyxRwLmytXog,126273
+sgis/raster/image_collection.py,sha256=W5x4PsaOnXALAXTDj3q-X6TMVgVD9kyFXmFdJewe9lY,126533
 sgis/raster/indices.py,sha256=efJmgfPg_VuSzXFosXV661IendF8CwPFWtMhyP4TMUg,222
 sgis/raster/regex.py,sha256=kYhVpRYzoXutx1dSYmqMoselWXww7MMEsTPmLZwHjbM,3759
 sgis/raster/sentinel_config.py,sha256=nySDqn2R8M6W8jguoBeSAK_zzbAsqmaI59i32446FwY,1268
 sgis/raster/zonal.py,sha256=D4Gyptw-yOLTCO41peIuYbY-DANsJCG19xXDlf1QAz4,2299
-ssb_sgis-1.2.1.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
-ssb_sgis-1.2.1.dist-info/METADATA,sha256=yStXt7J5YdWyJVMZd8bnzCkYX2NbYb6kEerzS55BLAc,11740
-ssb_sgis-1.2.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ssb_sgis-1.2.1.dist-info/RECORD,,
+ssb_sgis-1.2.3.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
+ssb_sgis-1.2.3.dist-info/METADATA,sha256=14UzO4efbS_k7OMKyV7rCQjZknag0TTuwQ6sgaQvaww,11740
+ssb_sgis-1.2.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ssb_sgis-1.2.3.dist-info/RECORD,,