ssb-sgis 1.0.15__py3-none-any.whl → 1.1.1__py3-none-any.whl

sgis/__init__.py

@@ -1,10 +1,6 @@
-config = {
-    "n_jobs": 1,
-}
-
-
 import sgis.raster.indices as indices
 
+from .conf import config
 from .geopandas_tools.bounds import Gridlooper
 from .geopandas_tools.bounds import bounds_to_points
 from .geopandas_tools.bounds import bounds_to_polygon

sgis/conf.py

@@ -0,0 +1,16 @@
+try:
+    from gcsfs import GCSFileSystem
+except ImportError:
+
+    class GCSFileSystem:
+        """Placeholder."""
+
+        def __init__(self, *args, **kwargs) -> None:
+            """Placeholder."""
+            raise ImportError("gcsfs")
+
+
+config = {
+    "n_jobs": 1,
+    "file_system": GCSFileSystem,
+}

sgis/geopandas_tools/bounds.py

@@ -669,6 +669,7 @@ def bounds_to_points(
     0  MULTIPOINT (1.00000 0.00000, 1.00000 1.00000, ...
     1                       MULTIPOINT (0.00000 0.00000)
     """
+    gdf = gdf.copy() if copy else gdf
     as_bounds = bounds_to_polygon(gdf, copy=copy)
     if isinstance(gdf, GeoSeries):
         return GeoSeries(extract_unique_points(as_bounds), index=gdf.index)

sgis/geopandas_tools/buffer_dissolve_explode.py

@@ -5,7 +5,7 @@ for the following:
 
 - Geometries are made valid after buffer and dissolve.
 
-- The buffer resolution defaults to 50 (geopandas' default is 16).
+- The buffer resolution defaults to 30 (geopandas' default is 16).
 
 - If 'by' is not specified, the index will be labeled 0, 1, …, n - 1 after exploded, instead of 0, 0, …, 0 as it will with the geopandas defaults.
 
@@ -49,7 +49,7 @@ def buffdissexp(
     gdf: GeoDataFrame,
     distance: int | float,
     *,
-    resolution: int = 50,
+    resolution: int = 30,
     index_parts: bool = False,
     copy: bool = True,
     grid_size: float | int | None = None,
@@ -68,7 +68,7 @@ def buffdissexp(
         distance: the distance (meters, degrees, depending on the crs) to buffer
             the geometry by
         resolution: The number of segments used to approximate a quarter circle.
-            Here defaults to 50, as opposed to the default 16 in geopandas.
+            Here defaults to 30, as opposed to the default 16 in geopandas.
         index_parts: If False (default), the index after dissolve is respected. If
             True, an integer index level is added during explode.
         copy: Whether to copy the GeoDataFrame before buffering. Defaults to True.
@@ -101,7 +101,7 @@ def buffdissexp(
 def buffdiss(
     gdf: GeoDataFrame,
     distance: int | float,
-    resolution: int = 50,
+    resolution: int = 30,
     copy: bool = True,
     n_jobs: int = 1,
     join_style: int | str = "round",
@@ -119,7 +119,7 @@ def buffdiss(
         distance: the distance (meters, degrees, depending on the crs) to buffer
             the geometry by
         resolution: The number of segments used to approximate a quarter circle.
-            Here defaults to 50, as opposed to the default 16 in geopandas.
+            Here defaults to 30, as opposed to the default 16 in geopandas.
         join_style: Buffer join style.
         copy: Whether to copy the GeoDataFrame before buffering. Defaults to True.
         n_jobs: Number of threads to use. Defaults to 1.
@@ -511,7 +511,7 @@ def buffdissexp_by_cluster(
     gdf: GeoDataFrame,
     distance: int | float,
     *,
-    resolution: int = 50,
+    resolution: int = 30,
     copy: bool = True,
     n_jobs: int = 1,
     join_style: int | str = "round",
@@ -532,7 +532,7 @@ def buffdissexp_by_cluster(
         distance: the distance (meters, degrees, depending on the crs) to buffer
             the geometry by
         resolution: The number of segments used to approximate a quarter circle.
-            Here defaults to 50, as opposed to the default 16 in geopandas.
+            Here defaults to 30, as opposed to the default 16 in geopandas.
         join_style: Buffer join style.
         copy: Whether to copy the GeoDataFrame before buffering. Defaults to True.
         n_jobs: int = 1,
@@ -554,7 +554,7 @@ def buffdissexp_by_cluster(
 def buff(
     gdf: GeoDataFrame | GeoSeries,
     distance: int | float,
-    resolution: int = 50,
+    resolution: int = 30,
     copy: bool = True,
     join_style: int | str = "round",
     **buffer_kwargs,
@@ -566,7 +566,7 @@ def buff(
         distance: the distance (meters, degrees, depending on the crs) to buffer
             the geometry by
         resolution: The number of segments used to approximate a quarter circle.
-            Here defaults to 50, as opposed to the default 16 in geopandas.
+            Here defaults to 30, as opposed to the default 16 in geopandas.
         join_style: Buffer join style.
         copy: Whether to copy the GeoDataFrame before buffering. Defaults to True.
         **buffer_kwargs: additional keyword arguments passed to geopandas' buffer.

sgis/io/dapla_functions.py

@@ -2,35 +2,42 @@
 
 from __future__ import annotations
 
+import functools
+import glob
 import json
 import multiprocessing
 import os
+import shutil
+import uuid
 from collections.abc import Iterable
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
-import dapla as dp
 import geopandas as gpd
 import joblib
 import pandas as pd
 import pyarrow
 import pyarrow.parquet as pq
 import shapely
+from gcsfs import GCSFileSystem
 from geopandas import GeoDataFrame
 from geopandas import GeoSeries
 from geopandas.io.arrow import _geopandas_to_arrow
 from pandas import DataFrame
 from pyarrow import ArrowInvalid
 
+from ..geopandas_tools.conversion import to_shapely
 from ..geopandas_tools.general import get_common_crs
 from ..geopandas_tools.sfilter import sfilter
 
 PANDAS_FALLBACK_INFO = " Set pandas_fallback=True to ignore this error."
+from ..conf import config
 
 
 def read_geopandas(
     gcs_path: str | Path | list[str | Path] | tuple[str | Path] | GeoSeries,
     pandas_fallback: bool = False,
-    file_system: dp.gcs.GCSFileSystem | None = None,
+    file_system: GCSFileSystem | None = None,
     mask: GeoSeries | GeoDataFrame | shapely.Geometry | tuple | None = None,
     threads: int | None = None,
     **kwargs,
@@ -62,7 +69,7 @@ def read_geopandas(
          A GeoDataFrame if it has rows. If zero rows, a pandas DataFrame is returned.
     """
     if file_system is None:
-        file_system = dp.FileClient.get_gcs_file_system()
+        file_system = config["file_system"]()
 
     if not isinstance(gcs_path, (str | Path | os.PathLike)):
         kwargs |= {"file_system": file_system, "pandas_fallback": pandas_fallback}
@@ -129,6 +136,18 @@ def read_geopandas(
         except TypeError as e:
             raise TypeError(f"Unexpected type {type(gcs_path)}.") from e
 
+    if has_partitions(gcs_path, file_system):
+        filters = kwargs.pop("filters", None)
+        return _read_partitioned_parquet(
+            gcs_path,
+            file_system=file_system,
+            mask=mask,
+            pandas_fallback=pandas_fallback,
+            threads=threads,
+            filters=filters,
+            **kwargs,
+        )
+
     if "parquet" in gcs_path or "prqt" in gcs_path:
         with file_system.open(gcs_path, mode="rb") as file:
             try:
@@ -138,8 +157,7 @@ def read_geopandas(
                     raise e.__class__(
                         f"{e.__class__.__name__}: {e} for {gcs_path}."
                     ) from e
-                df = dp.read_pandas(gcs_path, **kwargs)
-
+                df = pd.read_parquet(file, **kwargs)
                 if pandas_fallback or not len(df):
                     return df
                 else:
@@ -157,7 +175,7 @@ def read_geopandas(
             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)
+                df = pd.read_parquet(file, **kwargs)
 
                 if pandas_fallback or not len(df):
                     return df
@@ -168,7 +186,7 @@ def read_geopandas(
                     ) from e
             except Exception as e:
                 raise e.__class__(
-                    f"{e.__class__.__name__}: {e} for {df}." + more_txt
+                    f"{e.__class__.__name__}: {e} for {gcs_path}." + more_txt
                 ) from e
 
     if mask is not None:
@@ -177,33 +195,44 @@ def read_geopandas(
 
 
 def _get_bounds_parquet(
-    path: str | Path, file_system: dp.gcs.GCSFileSystem, pandas_fallback: bool = False
+    path: str | Path, file_system: GCSFileSystem, pandas_fallback: bool = False
+) -> tuple[list[float], dict] | tuple[None, None]:
+    with file_system.open(path, "rb") as file:
+        return _get_bounds_parquet_from_open_file(file, file_system)
+
+
+def _get_bounds_parquet_from_open_file(
+    file, file_system
 ) -> tuple[list[float], dict] | tuple[None, None]:
-    with file_system.open(path) as f:
+    geo_metadata = _get_geo_metadata(file, file_system)
+    if not geo_metadata:
+        return None, None
+    return geo_metadata["bbox"], geo_metadata["crs"]
+
+
+def _get_geo_metadata(file, file_system) -> dict:
+    meta = pq.read_schema(file).metadata
+    geo_metadata = json.loads(meta[b"geo"])
+    try:
+        primary_column = geo_metadata["primary_column"]
+    except KeyError as e:
+        raise KeyError(e, geo_metadata) from e
+    try:
+        return geo_metadata["columns"][primary_column]
+    except KeyError as e:
         try:
-            num_rows = pq.read_metadata(f).num_rows
+            num_rows = pq.read_metadata(file).num_rows
         except ArrowInvalid as e:
-            if not file_system.isfile(f):
-                return None, None
-            raise ArrowInvalid(e, path) from e
+            if not file_system.isfile(file):
+                return {}
+            raise ArrowInvalid(e, file) from e
         if not num_rows:
-            return None, None
-        meta = pq.read_schema(f).metadata
-    try:
-        meta = json.loads(meta[b"geo"])["columns"]["geometry"]
-    except KeyError as e:
-        if pandas_fallback:
-            return None, None
-        raise KeyError(
-            f"{e.__class__.__name__}: {e} for {path}." + PANDAS_FALLBACK_INFO,
-            # f"{num_rows=}",
-            # meta,
-        ) from e
-    return meta["bbox"], meta["crs"]
+            return {}
+    return {}
 
 
-def _get_columns(path: str | Path, file_system: dp.gcs.GCSFileSystem) -> pd.Index:
-    with file_system.open(path) as f:
+def _get_columns(path: str | Path, file_system: GCSFileSystem) -> pd.Index:
+    with file_system.open(path, "rb") as f:
         schema = pq.read_schema(f)
         index_cols = _get_index_cols(schema)
         return pd.Index(schema.names).difference(index_cols)
@@ -216,7 +245,7 @@ def _get_index_cols(schema: pyarrow.Schema) -> list[str]:
 
 def get_bounds_series(
     paths: list[str | Path] | tuple[str | Path],
-    file_system: dp.gcs.GCSFileSystem | None = None,
+    file_system: GCSFileSystem | None = None,
     threads: int | None = None,
     pandas_fallback: bool = False,
 ) -> GeoSeries:
@@ -227,7 +256,7 @@ def get_bounds_series(
 
     Args:
         paths: Iterable of file paths in gcs.
-        file_system: Optional instance of dp.gcs.GCSFileSystem.
+        file_system: Optional instance of GCSFileSystem.
             If None, an instance is created within the function.
             Note that this is slower in long loops.
         threads: Number of threads to use if reading multiple files. Defaults to
@@ -242,8 +271,7 @@ def get_bounds_series(
     ---------
     >>> import sgis as sg
     >>> import dapla as dp
-    >>> file_system = dp.FileClient.get_gcs_file_system()
-    >>> all_paths = file_system.ls("...")
+    >>> all_paths =  GCSFileSystem().ls("...")
 
     Get the bounds of all your file paths, indexed by path.
 
@@ -275,7 +303,7 @@ def get_bounds_series(
 
     """
     if file_system is None:
-        file_system = dp.FileClient.get_gcs_file_system()
+        file_system = config["file_system"]()
 
     if threads is None:
         threads = min(len(paths), int(multiprocessing.cpu_count())) or 1
@@ -307,8 +335,8 @@ def write_geopandas(
     gcs_path: str | Path,
     overwrite: bool = True,
     pandas_fallback: bool = False,
-    file_system: dp.gcs.GCSFileSystem | None = None,
-    write_covering_bbox: bool = False,
+    file_system: GCSFileSystem | None = None,
+    partition_cols=None,
     **kwargs,
 ) -> None:
     """Writes a GeoDataFrame to the speficied format.
@@ -324,13 +352,7 @@ def write_geopandas(
             not be written with geopandas and the number of rows is more than 0. If True,
             the file will be written without geo-metadata if >0 rows.
         file_system: Optional file sustem.
-        write_covering_bbox: Writes the bounding box column for each row entry with column name "bbox".
-            Writing a bbox column can be computationally expensive, but allows you to specify
-            a bbox in : func:read_parquet for filtered reading.
-            Note: this bbox column is part of the newer GeoParquet 1.1 specification and should be
-            considered as experimental. While writing the column is backwards compatible, using it
-            for filtering may not be supported by all readers.
-
+        partition_cols: Column(s) to partition by. Only for parquet files.
         **kwargs: Additional keyword arguments passed to parquet.write_table
             (for parquet) or geopandas' to_file method (if not parquet).
     """
@@ -340,22 +362,25 @@ def write_geopandas(
         except TypeError as e:
             raise TypeError(f"Unexpected type {type(gcs_path)}.") from e
 
-    if not overwrite and exists(gcs_path):
+    if file_system is None:
+        file_system = config["file_system"]()
+
+    if not overwrite and file_system.exists(gcs_path):
         raise ValueError("File already exists.")
 
     if not isinstance(df, GeoDataFrame):
         raise ValueError("DataFrame must be GeoDataFrame.")
 
-    if file_system is None:
-        file_system = dp.FileClient.get_gcs_file_system()
-
-    if not len(df):
+    if not len(df) and has_partitions(gcs_path, file_system):
+        return
+    elif not len(df):
         if pandas_fallback:
             df = pd.DataFrame(df)
             df.geometry = df.geometry.astype(str)
             df.geometry = None
         try:
-            dp.write_pandas(df, gcs_path, **kwargs)
+            with file_system.open(gcs_path, "wb") as file:
+                df.to_parquet(gcs_path, **kwargs)
         except Exception as e:
             more_txt = PANDAS_FALLBACK_INFO if not pandas_fallback else ""
             raise e.__class__(
@@ -363,17 +388,22 @@ def write_geopandas(
             ) from e
         return
 
-    file_system = dp.FileClient.get_gcs_file_system()
-
     if ".parquet" in gcs_path or "prqt" in gcs_path:
-        with file_system.open(gcs_path, mode="wb") as buffer:
+        if partition_cols is not None:
+            return _write_partitioned_geoparquet(
+                df,
+                gcs_path,
+                partition_cols,
+                file_system,
+                **kwargs,
+            )
+        with file_system.open(gcs_path, mode="wb") as file:
             table = _geopandas_to_arrow(
                 df,
                 index=df.index,
                 schema_version=None,
-                write_covering_bbox=write_covering_bbox,
             )
-            pq.write_table(table, buffer, compression="snappy", **kwargs)
+            pq.write_table(table, file, compression="snappy", **kwargs)
         return
 
     layer = kwargs.pop("layer", None)
@@ -393,17 +423,156 @@ def write_geopandas(
         df.to_file(file, driver=driver, layer=layer)
 
 
-def exists(path: str | Path) -> bool:
-    """Returns True if the path exists, and False if it doesn't.
+def _remove_file(path, file_system) -> None:
+    try:
+        file_system.rm_file(path)
+    except (AttributeError, TypeError, PermissionError):
+        try:
+            shutil.rmtree(path)
+        except NotADirectoryError:
+            try:
+                os.remove(path)
+            except PermissionError:
+                pass
+
 
-    Args:
-        path (str): The path to the file or directory.
+def _write_partitioned_geoparquet(df, path, partition_cols, file_system, **kwargs):
+    path = Path(path)
+    unique_id = uuid.uuid4()
 
-    Returns:
-        True if the path exists, False if not.
-    """
-    file_system = dp.FileClient.get_gcs_file_system()
-    return file_system.exists(path)
+    try:
+        glob_func = functools.partial(file_system.glob, detail=False)
+    except AttributeError:
+        glob_func = functools.partial(glob.glob, recursive=True)
+
+    args: list[tuple[Path, DataFrame]] = []
+    dirs: list[Path] = set()
+    for group, rows in df.groupby(partition_cols):
+        name = (
+            "/".join(
+                f"{col}={value}"
+                for col, value in zip(partition_cols, group, strict=True)
+            )
+            + f"/{unique_id}.parquet"
+        )
+
+        dirs.add((path / name).parent)
+        args.append((path / name, rows))
+
+    if file_system.exists(path) and not has_partitions(path, file_system):
+        _remove_file(path, file_system)
+
+    for dir_ in dirs:
+        try:
+            os.makedirs(dir_, exist_ok=True)
+        except (OSError, FileNotFoundError, FileExistsError) as e:
+            print(e)
+            pass
+
+    def threaded_write(path_rows):
+        new_path, rows = path_rows
+        for sibling_path in glob_func(str(Path(new_path).with_name("**"))):
+            if not paths_are_equal(sibling_path, Path(new_path).parent):
+                _remove_file(sibling_path, file_system)
+        with file_system.open(new_path, mode="wb") as file:
+            table = _geopandas_to_arrow(
+                rows,
+                index=df.index,
+                schema_version=None,
+            )
+            pq.write_table(table, file, compression="snappy", **kwargs)
+
+    with ThreadPoolExecutor() as executor:
+        list(executor.map(threaded_write, args))
+
+
+def _read_partitioned_parquet(
+    path, filters, file_system, mask, pandas_fallback, threads, **kwargs
+):
+    try:
+        glob_func = functools.partial(file_system.glob, detail=False)
+    except AttributeError:
+        glob_func = functools.partial(glob.glob, recursive=True)
+
+    filters = filters or []
+    new_filters = []
+    for filt in filters:
+        if "in" in filt:
+            values = [
+                x.strip("(")
+                .strip(")")
+                .strip("[")
+                .strip("]")
+                .strip("{")
+                .strip("}")
+                .strip(" ")
+                for x in filt[-1].split(",")
+            ]
+            filt = [filt[0] + "=" + x for x in values]
+        else:
+            filt = ["".join(filt)]
+        new_filters.append(filt)
+
+    def intersects(file, mask) -> bool:
+        bbox, _ = _get_bounds_parquet_from_open_file(file, file_system)
+        return shapely.box(*bbox).intersects(to_shapely(mask))
+
+    def read(path) -> GeoDataFrame | None:
+        with file_system.open(path, "rb") as file:
+            if mask is not None and not intersects(file, mask):
+                return
+
+            schema = kwargs.pop("schema", pq.read_schema(file))
+
+            return gpd.read_parquet(file, schema=schema, **kwargs)
+
+    with ThreadPoolExecutor() as executor:
+        results = [
+            x
+            for x in (
+                executor.map(
+                    read,
+                    (
+                        path
+                        for path in glob_func(str(Path(path) / "**/*.parquet"))
+                        if all(
+                            any(subfilt in Path(path).parts for subfilt in filt)
+                            for filt in new_filters
+                        )
+                    ),
+                )
+            )
+            if x is not None
+        ]
+    if results:
+        if mask is not None:
+            return sfilter(pd.concat(results), mask)
+        return pd.concat(results)
+
+    # add columns to empty DataFrame
+    first_path = next(iter(glob_func(str(Path(path) / "**/*.parquet"))))
+    return gpd.GeoDataFrame(
+        columns=list(dict.fromkeys(_get_columns(first_path, file_system)))
+    )
+
+
+def paths_are_equal(path1: Path | str, path2: Path | str) -> bool:
+    return Path(path1).parts == Path(path2).parts
+
+
+def has_partitions(path, file_system) -> bool:
+    try:
+        glob_func = functools.partial(file_system.glob, detail=False)
+    except AttributeError:
+        glob_func = functools.partial(glob.glob, recursive=True)
+
+    return bool(
+        [
+            x
+            for x in glob_func(str(Path(path) / "**/*.parquet"))
+            if not paths_are_equal(x, path)
+        ]
+    )
 
 
 def check_files(
@@ -419,7 +588,7 @@ def check_files(
         within_minutes: Optionally include only files that were updated in the
             last n minutes.
     """
-    file_system = dp.FileClient.get_gcs_file_system()
+    file_system = config["file_system"]()
 
     # (recursive doesn't work, so doing recursive search below)
     info = file_system.ls(folder, detail=True, recursive=True)
@@ -474,7 +643,7 @@ def check_files(
 
 
 def _get_files_in_subfolders(folderinfo: list[dict]) -> list[tuple]:
-    file_system = dp.FileClient.get_gcs_file_system()
+    file_system = config["file_system"]()
 
     fileinfo = []
 

sgis/maps/thematicmap.py

@@ -280,7 +280,10 @@ class ThematicMap(Map):
         return self
 
     def add_background(
-        self, gdf: GeoDataFrame, color: str | None = None
+        self,
+        gdf: GeoDataFrame,
+        color: str | None = None,
+        **kwargs,
     ) -> "ThematicMap":
         """Add a GeoDataFrame as a background layer.
 
@@ -288,6 +291,7 @@ class ThematicMap(Map):
             gdf: a GeoDataFrame.
             color: Single color. Defaults to gray (shade depends on whether the map
                 facecolor is black or white).
+            **kwargs: Keyword arguments sent to GeoDataFrame.plot.
         """
         if color:
             self.bg_gdf_color = color
@@ -299,6 +303,7 @@ class ThematicMap(Map):
             )
         if self.bounds is None:
             self.bounds = to_bbox(self._gdf.total_bounds)
+        self.bg_gdf_kwargs = kwargs
         return self
 
     def plot(self, **kwargs) -> None:
@@ -515,7 +520,9 @@ class ThematicMap(Map):
     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._background_gdfs.plot(ax=self.ax, color=self.bg_gdf_color)
+        self._background_gdfs.plot(
+            ax=self.ax, color=self.bg_gdf_color, **self.bg_gdf_kwargs
+        )
 
     @staticmethod
     def _get_matplotlib_figure_and_axix(

sgis/parallel/parallel.py

@@ -590,7 +590,7 @@ class Parallel:
         with_neighbors: bool = False,
         funcdict: dict[str, Callable] | None = None,
         file_type: str = "parquet",
-        muni_number_col: str = "KOMMUNENR",
+        muni_number_col: str = "komm_nr",
         strict: bool = False,
         write_empty: bool = False,
         id_assign_func: Callable | functools.partial = clean_overlay,
@@ -622,7 +622,7 @@ class Parallel:
                 the data is read.
             file_type: Defaults to parquet.
             muni_number_col: String column name with municipality
-                number/identifier. Defaults to KOMMUNENR. If the column is not present
+                number/identifier. Defaults to komm_nr. If the column is not present
                 in the data to be split, the data will be intersected with the
                 municipalities.
             strict: If False (default), the dictionaries 'out_data' and 'funcdict' does
@@ -761,7 +761,7 @@ def write_municipality_data(
     out_folder: str,
     municipalities: GeoDataFrame | list[str] | None = None,
     with_neighbors: bool = False,
-    muni_number_col: str = "KOMMUNENR",
+    muni_number_col: str = "komm_nr",
     file_type: str = "parquet",
     func: Callable | None = None,
     write_empty: bool = False,
@@ -840,7 +840,7 @@ def _write_municipality_data(
     data: str | GeoDataFrame | DataFrame,
     out_folder: str,
     municipalities: GeoDataFrame | list[str] | None = None,
-    muni_number_col: str = "KOMMUNENR",
+    muni_number_col: str = "komm_nr",
     file_type: str = "parquet",
     func: Callable | None = None,
     write_empty: bool = False,
@@ -896,7 +896,7 @@ def _write_neighbor_municipality_data(
     data: str | GeoDataFrame | DataFrame,
     out_folder: str,
     municipalities: GeoDataFrame,
-    muni_number_col: str = "KOMMUNENR",
+    muni_number_col: str = "komm_nr",
     file_type: str = "parquet",
     func: Callable | None = None,
     write_empty: bool = False,

{ssb_sgis-1.0.15.dist-info → ssb_sgis-1.1.1.dist-info}/METADATA

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

{ssb_sgis-1.0.15.dist-info → ssb_sgis-1.1.1.dist-info}/RECORD

@@ -1,9 +1,10 @@
-sgis/__init__.py,sha256=Bh-W4cB6-1uc-xRzUxqxECwwoennpdlikZI3gwXtZ7E,7389
+sgis/__init__.py,sha256=h6B-UD121eAYNpesXIPfEYISrSTN6mfZd7aXPfcMiqs,7382
+sgis/conf.py,sha256=-PraZWfHZerrMVKutPv7u-MezwAG7RlhGgmf5z-iPxA,304
 sgis/debug_config.py,sha256=Tfr19kU46hSkkspsIJcrUWvlhaL4U3-f8xEPkujSCAQ,593
 sgis/exceptions.py,sha256=WNaEBPNNx0rmz-YDzlFX4vIE7ocJQruUTqS2RNAu2zU,660
 sgis/geopandas_tools/__init__.py,sha256=bo8lFMcltOz7TtWAi52_ekR2gd3mjfBfKeMDV5zuqFY,28
-sgis/geopandas_tools/bounds.py,sha256=BpQFoON-sFXt4zmkUi07Epc2Cj-8OXZAPBfKqT99T4I,23760
-sgis/geopandas_tools/buffer_dissolve_explode.py,sha256=5Dy-HfLm-n4IjlLm98Wtufl4IuCw0Zglyy5VlEH0mak,19955
+sgis/geopandas_tools/bounds.py,sha256=MUtm3w6P_t7RfZ8WJz5iKqG2PyVzFMiAALf6AMLAewk,23798
+sgis/geopandas_tools/buffer_dissolve_explode.py,sha256=t9GJqRMDsHEU74RIlqeMr4QBgbTK0hYlXL4af1RKIks,19955
 sgis/geopandas_tools/centerlines.py,sha256=Q65Sx01SeAlulBEd9oaZkB2maBBNdLcJwAbTILg4SPU,11848
 sgis/geopandas_tools/cleaning.py,sha256=tkHH5wm0BF_1EXMsh3rM9DqWOwtr7JKkqCCi6uymSP4,60214
 sgis/geopandas_tools/conversion.py,sha256=o3QJZLfaqqpJNdWWNKfQn_dS77uJxxRxWZxhf18vPXs,25505
@@ -19,7 +20,7 @@ sgis/geopandas_tools/polygons_as_rings.py,sha256=BX_GZS6F9I4NbEpiOlNBd7zywJjdfdJ
 sgis/geopandas_tools/sfilter.py,sha256=SLcMYprQwnY5DNo0R7TGXk4m6u26H8o4PRn-RPhmeZY,9345
 sgis/helpers.py,sha256=3NqPfVBKlZcZTiMJrsTAlDv5tNKDHrJr_8NimutVzQg,8797
 sgis/io/_is_dapla.py,sha256=wmfkSe98IrLhUg3dtXZusV6OVC8VlY1kbc5EQDf3P-Q,358
-sgis/io/dapla_functions.py,sha256=e4EYjZK2Sxt5OwxI6a8y-ye7EpjLJFbG80qAZWcfsiE,18216
+sgis/io/dapla_functions.py,sha256=rTdTrxUQLM0NtnuYKiVFXInagh6wCWWr4lUTbzk_V0Q,23130
 sgis/io/opener.py,sha256=HWO3G1NB6bpXKM94JadCD513vjat1o1TFjWGWzyVasg,898
 sgis/io/read_parquet.py,sha256=FvZYv1rLkUlrSaUY6QW6E1yntmntTeQuZ9ZRgCDO4IM,3776
 sgis/maps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,7 +31,7 @@ sgis/maps/legend.py,sha256=lVRVCkhPmJRjGK23obFJZAO3qp6du1LYnobkkN7DPkc,26279
 sgis/maps/map.py,sha256=smaf9i53EoRZWmZjn9UuqlhzUvVs1XKo2ItIpHxyuik,29592
 sgis/maps/maps.py,sha256=gxu0rgcVygjudRtM1dVRmsUMilMUIg3vG-UgvASM91E,23072
 sgis/maps/norge_i_bilder.json,sha256=W_mFfte3DxugWbEudZ5fadZ2JeFYb0hyab2Quf4oJME,481311
-sgis/maps/thematicmap.py,sha256=yAE1xEfubJcDmBlOJf-Q3SVae1ZHIEMP-YB95Wy8cRw,21691
+sgis/maps/thematicmap.py,sha256=w6q4_gIr8BubQgsPJkc6WXk-tmplDLGcKyjphhFp7ng,21873
 sgis/maps/tilesources.py,sha256=F4mFHxPwkiPJdVKzNkScTX6xbJAMIUtlTq4mQ83oguw,1746
 sgis/maps/wms.py,sha256=XHlCszR0raPbmUc2wYpQ_XRHnSJ6c1ic3w2dNnfMRm4,6252
 sgis/networkanalysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,7 +48,7 @@ sgis/networkanalysis/networkanalysis.py,sha256=-g7slZLFNxUZSUMvVmf7zax-9IOXz1NGC
 sgis/networkanalysis/networkanalysisrules.py,sha256=9sXigaCzvKhXFwpeVNMtOiIK3_Hzp9yDpFklmEEAPak,12956
 sgis/networkanalysis/nodes.py,sha256=atFSpqz-_uJHMrf6MC0zhrrcWIydRMFZrsaHC2xr1GU,3374
 sgis/networkanalysis/traveling_salesman.py,sha256=Jjo6bHY4KJ-eK0LycyTy0sWxZjgITs5MBllZ_G9FhTE,5655
-sgis/parallel/parallel.py,sha256=SlC_mOwvSSyWTKUcxLMGkuWHUkEC6dXTlN0Jn5cAtxA,39687
+sgis/parallel/parallel.py,sha256=eyIXPp6nhUhLh1rwkfPLayG5hAi3i8PxmwFHxGCo-k4,39677
 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
@@ -56,7 +57,7 @@ sgis/raster/indices.py,sha256=-J1HYmnT240iozvgagvyis6K0_GHZHRuUrPOgyoeIrY,223
 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.0.15.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
-ssb_sgis-1.0.15.dist-info/METADATA,sha256=bRaj-9WssZ9IsI2IPEtI_uyLGhpEWd52xfMst-vI3g4,11741
-ssb_sgis-1.0.15.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ssb_sgis-1.0.15.dist-info/RECORD,,
+ssb_sgis-1.1.1.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
+ssb_sgis-1.1.1.dist-info/METADATA,sha256=dwdCCyDOy441bczyc2JwdB9eZo_BtmTqL0Dqq05IZeQ,11740
+ssb_sgis-1.1.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ssb_sgis-1.1.1.dist-info/RECORD,,