ssb-sgis 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

sgis/maps/maps.py

@@ -11,25 +11,30 @@ import inspect
 from numbers import Number
 from typing import Any
 
-from geopandas import GeoDataFrame, GeoSeries
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
 from pyproj import CRS
 from shapely import Geometry
+from shapely import box
+from shapely.geometry import Polygon
 
+from ..geopandas_tools.bounds import get_total_bounds
 from ..geopandas_tools.conversion import to_gdf as to_gdf_func
-from ..geopandas_tools.general import clean_geoms, get_common_crs, is_wkt
+from ..geopandas_tools.general import clean_geoms
+from ..geopandas_tools.general import get_common_crs
+from ..geopandas_tools.general import is_wkt
 from ..geopandas_tools.geocoding import address_to_gdf
 from ..geopandas_tools.geometry_types import get_geom_type
 from .explore import Explore
 from .map import Map
 from .thematicmap import ThematicMap
 
-
 try:
     from torchgeo.datasets.geo import RasterDataset
 except ImportError:
 
     class RasterDataset:
-        """Placeholder"""
+        """Placeholder."""
 
 
 def _get_location_mask(kwargs: dict, gdfs) -> tuple[GeoDataFrame | None, dict]:
@@ -72,7 +77,6 @@ def explore(
     *gdfs: GeoDataFrame | dict[str, GeoDataFrame],
     column: str | None = None,
     center: Any | None = None,
-    center_4326: Any | None = None,
     labels: tuple[str] | None = None,
     max_zoom: int = 40,
     browser: bool = False,
@@ -94,10 +98,9 @@ def explore(
         *gdfs: one or more GeoDataFrames.
         column: The column to color the geometries by. Defaults to None, which means
             each GeoDataFrame will get a unique color.
-        center: Either an address string to be geocoded or a geometry like object
-            (coordinate pair (x, y), GeoDataFrame, bbox, etc.). If the geometry is a
-            point (or line), it will be buffered by 1000 (can be changed with the)
-            size parameter. If a polygon is given, it will not be buffered.
+        center: Geometry-like object to center the map on. If a three-length tuple
+            is given, the first two should be x and y coordinates and the third
+            should be a number of meters to buffer the centerpoint by.
         labels: By default, the GeoDataFrames will be labeled by their object names.
             Alternatively, labels can be specified as a tuple of strings with the same
             length as the number of gdfs.
@@ -113,12 +116,12 @@ def explore(
             instance 'cmap' to change the colors, 'scheme' to change how the data
             is grouped. This defaults to 'fisherjenkssampled' for numeric data.
 
-    See also
+    See Also:
     --------
     samplemap: same functionality, but shows only a random area of a given size.
     clipmap: same functionality, but shows only the areas clipped by a given mask.
 
-    Examples
+    Examples:
     --------
     >>> import sgis as sg
     >>> roads = sg.read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
@@ -138,7 +141,6 @@ def explore(
     >>> points["meters"] = points.length
     >>> sg.explore(roads, points, column="meters", cmap="plasma", max_zoom=60, center_4326=(10.7463, 59.92, 500))
     """
-
     gdfs, column, kwargs = Map._separate_args(gdfs, column, kwargs)
 
     loc_mask, kwargs = _get_location_mask(kwargs | {"size": size}, gdfs)
@@ -162,14 +164,11 @@ def explore(
         to_crs = gdfs[0].crs
     except IndexError:
         try:
-            to_crs = [x for x in kwargs.values() if hasattr(x, "crs")][0].crs
+            to_crs = next(x for x in kwargs.values() if hasattr(x, "crs")).crs
         except IndexError:
             to_crs = None
 
-    if center_4326 is not None:
-        from_crs = 4326
-        center = center_4326
-    elif "crs" in kwargs:
+    if "crs" in kwargs:
         from_crs = kwargs.pop("crs")
     else:
         from_crs = to_crs
@@ -185,6 +184,10 @@ def explore(
                 *center, size = center
             mask = to_gdf_func(center, crs=from_crs)
 
+        bounds: Polygon = box(*get_total_bounds(*gdfs, *list(kwargs.values())))
+        if not mask.intersects(bounds).any():
+            mask = mask.set_crs(4326, allow_override=True)
+
         try:
             mask = mask.to_crs(to_crs)
         except ValueError:
@@ -270,12 +273,12 @@ def samplemap(
             instance 'cmap' to change the colors, 'scheme' to change how the data
             is grouped. This defaults to 'fisherjenkssampled' for numeric data.
 
-    See also
+    See Also:
     --------
     explore: Same functionality, but shows the entire area of the geometries.
     clipmap: Same functionality, but shows only the areas clipped by a given mask.
 
-    Examples
+    Examples:
     --------
     >>> from sgis import read_parquet_url, samplemap
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_eidskog_2022.parquet")
@@ -290,7 +293,6 @@ def samplemap(
     >>> samplemap(roads, points, size=5_000, column="meters")
 
     """
-
     if gdfs and isinstance(gdfs[-1], (float, int)):
         *gdfs, size = gdfs
 
@@ -393,12 +395,11 @@ def clipmap(
             instance 'cmap' to change the colors, 'scheme' to change how the data
             is grouped. This defaults to 'fisherjenkssampled' for numeric data.
 
-    See also
+    See Also:
     --------
     explore: same functionality, but shows the entire area of the geometries.
     samplemap: same functionality, but shows only a random area of a given size.
     """
-
     gdfs, column, kwargs = Map._separate_args(gdfs, column, kwargs)
 
     if mask is None and len(gdfs) > 1:
@@ -444,7 +445,7 @@ def clipmap(
         qtm(m._gdf, column=m.column, cmap=m._cmap, k=m.k)
 
 
-def explore_locals(*gdfs, convert: bool = True, **kwargs):
+def explore_locals(*gdfs: GeoDataFrame, convert: bool = True, **kwargs) -> None:
     """Displays all local variables with geometries (GeoDataFrame etc.).
 
     Local means inside a function or file/notebook.
@@ -478,15 +479,15 @@ def explore_locals(*gdfs, convert: bool = True, **kwargs):
 
             if isinstance(value, dict) or hasattr(value, "__dict__"):
                 # add dicts or classes with GeoDataFrames to kwargs
-                for key, value in as_dict(value).items():
-                    if isinstance(value, allowed_types):
-                        gdf = clean_geoms(to_gdf_func(value))
+                for key, val in as_dict(value).items():
+                    if isinstance(val, allowed_types):
+                        gdf = clean_geoms(to_gdf_func(val))
                         if len(gdf):
                             local_gdfs[key] = gdf
 
-                    elif isinstance(value, dict) or hasattr(value, "__dict__"):
+                    elif isinstance(val, dict) or hasattr(val, "__dict__"):
                         try:
-                            for k, v in value.items():
+                            for k, v in val.items():
                                 if isinstance(v, allowed_types):
                                     gdf = clean_geoms(to_gdf_func(v))
                                     if len(gdf):
@@ -543,12 +544,13 @@ def qtm(
             'viridis' when black, and 'RdPu' when white.
         size: Size of the plot. Defaults to 10.
         title_fontsize: Size of the title.
+        legend: Whether to add legend. Defaults to True.
         cmap: Color palette of the map. See:
             https://matplotlib.org/stable/tutorials/colors/colormaps.html
         k: Number of color groups.
         **kwargs: Additional keyword arguments taken by the geopandas plot method.
 
-    See also:
+    See Also:
         ThematicMap: Class with more options for customising the plot.
     """
     gdfs, column, kwargs = Map._separate_args(gdfs, column, kwargs)

sgis/maps/thematicmap.py

@@ -1,16 +1,19 @@
 """Make static maps with geopandas and matplotlib."""
+
 import warnings
+from typing import Any
 
 import matplotlib
+import matplotlib.figure
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 
-from .legend import ContinousLegend, Legend
+from .legend import ContinousLegend
+from .legend import Legend
 from .map import Map
 
-
 # the geopandas._explore raises a deprication warning. Ignoring for now.
 warnings.filterwarnings(
     action="ignore", category=matplotlib.MatplotlibDeprecationWarning
@@ -24,16 +27,6 @@ class ThematicMap(Map):
     The class takes one or more GeoDataFrames and a column name. The class attributes
     can then be set to customise the map before plotting.
 
-    Args:
-        *gdfs: One or more GeoDataFrames.
-        column: The name of the column to plot.
-        size: Width and height of the plot in inches. Fontsize of title and legend is
-            adjusted accordingly. Defaults to 25.
-        black: If False (default), the background will be white and the text black. If
-            True, the background will be black and the text white. When True, the
-            default cmap is "viridis", and when False, the default is red to purple
-            (RdPu).
-
     Attributes:
         size (int): Width and height of the plot in inches.
         k (int): Number of color groups.
@@ -50,7 +43,7 @@ class ThematicMap(Map):
         cmap_stop (int): End position for the color palette.
         facecolor (str): Background color.
 
-    Examples
+    Examples:
     --------
     >>> import sgis as sg
     >>> points = sg.random_points(100).pipe(sg.buff, np.random.rand(100))
@@ -90,7 +83,20 @@ class ThematicMap(Map):
         column: str | None = None,
         size: int = 25,
         black: bool = False,
-    ):
+    ) -> None:
+        """Initialiser.
+
+        Args:
+            *gdfs: One or more GeoDataFrames.
+            column: The name of the column to plot.
+            size: Width and height of the plot in inches. Fontsize of title and legend is
+                adjusted accordingly. Defaults to 25.
+            black: If False (default), the background will be white and the text black. If
+                True, the background will be black and the text white. When True, the
+                default cmap is "viridis", and when False, the default is red to purple
+                (RdPu).
+
+        """
         super().__init__(*gdfs, column=column)
 
         self._size = size
@@ -106,7 +112,7 @@ class ThematicMap(Map):
 
         self._create_legend()
 
-    def change_cmap(self, cmap: str, start: int = 0, stop: int = 256):
+    def change_cmap(self, cmap: str, start: int = 0, stop: int = 256) -> "ThematicMap":
         """Change the color palette of the plot.
 
         Args:
@@ -119,7 +125,9 @@ class ThematicMap(Map):
         super().change_cmap(cmap, start, stop)
         return self
 
-    def add_background(self, gdf, color: str | None = None):
+    def add_background(
+        self, gdf: GeoDataFrame, color: str | None = None
+    ) -> "ThematicMap":
         """Add a GeoDataFrame as a background layer.
 
         Args:
@@ -145,7 +153,6 @@ class ThematicMap(Map):
 
         This method should be run after customising the map, but before saving.
         """
-
         __test = kwargs.pop("__test", False)
         include_legend = bool(kwargs.pop("legend", self.legend))
 
@@ -214,7 +221,7 @@ class ThematicMap(Map):
             with fs.open(path, "wb") as file:
                 plt.savefig(file)
 
-    def _prepare_plot(self, **kwargs):
+    def _prepare_plot(self, **kwargs) -> None:
         """Add figure and axis, title and background gdf."""
         for attr in self.__dict__.keys():
             if attr in self.kwargs:
@@ -236,7 +243,7 @@ class ThematicMap(Map):
                 self.title, fontsize=self.title_fontsize, color=self.title_color
             )
 
-    def _prepare_continous_plot(self, kwargs) -> dict:
+    def _prepare_continous_plot(self, kwargs: dict) -> dict:
         """Create bins and colors."""
         self._prepare_continous_map()
 
@@ -270,7 +277,7 @@ class ThematicMap(Map):
 
         return kwargs
 
-    def _prepare_categorical_plot(self, kwargs) -> dict:
+    def _prepare_categorical_plot(self, kwargs: dict) -> dict:
         """Map values to colors."""
         self._get_categorical_colors()
         colorarray = self._gdf["color"]
@@ -300,7 +307,7 @@ class ThematicMap(Map):
                 bin_values=self._bins_unique_values,
             )
 
-    def _create_legend(self):
+    def _create_legend(self) -> None:
         """Instantiate the Legend class."""
         kwargs = {}
         if self._black:
@@ -313,8 +320,8 @@ class ThematicMap(Map):
         else:
             self.legend = ContinousLegend(title=self._column, size=self._size, **kwargs)
 
-    def _choose_cmap(self):
-        """kwargs is to catch start and stop points for the cmap in __init__."""
+    def _choose_cmap(self) -> None:
+        """Kwargs is to catch start and stop points for the cmap in __init__."""
         if self._black:
             self._cmap = "viridis"
             self.cmap_start = 0
@@ -324,7 +331,7 @@ class ThematicMap(Map):
             self.cmap_start = 23
             self.cmap_stop = 256
 
-    def _make_bin_value_dict(self, gdf, classified) -> dict:
+    def _make_bin_value_dict(self, gdf: GeoDataFrame, classified: np.ndarray) -> dict:
         """Dict with unique values of all bins. Used in labels in ContinousLegend."""
         bins_unique_values = {
             i: list(set(gdf.loc[classified == i, self._column]))
@@ -332,18 +339,20 @@ class ThematicMap(Map):
         }
         return bins_unique_values
 
-    def _actually_add_background(self):
+    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)
 
     @staticmethod
-    def _get_matplotlib_figure_and_axix(figsize: tuple[int, int]):
+    def _get_matplotlib_figure_and_axix(
+        figsize: tuple[int, int]
+    ) -> tuple[matplotlib.figure.Figure, matplotlib.axes.Axes]:
         fig = plt.figure(figsize=figsize)
         ax = fig.add_subplot(1, 1, 1)
         return fig, ax
 
-    def _black_or_white(self):
+    def _black_or_white(self) -> None:
         if self._black:
             self.facecolor, self.title_color, self.bg_gdf_color = (
                 "#0f0f0f",
@@ -367,7 +376,8 @@ class ThematicMap(Map):
         self._create_legend()
 
     @property
-    def black(self):
+    def black(self) -> bool:
+        """Whether to use dark background and light text colors."""
         return self._black
 
     @black.setter
@@ -376,20 +386,22 @@ class ThematicMap(Map):
         self._black_or_white()
 
     @property
-    def title_fontsize(self):
+    def title_fontsize(self) -> int:
+        """Title fontsize, not to be confused with legend.title_fontsize."""
         return self._title_fontsize
 
     @title_fontsize.setter
-    def title_fontsize(self, new_value: bool):
+    def title_fontsize(self, new_value: int) -> None:
         self._title_fontsize = new_value
         self._title_fontsize_has_been_set = True
 
     @property
-    def size(self):
+    def size(self) -> int:
+        """Size of the image."""
         return self._size
 
     @size.setter
-    def size(self, new_value: bool):
+    def size(self, new_value: bool) -> None:
         """Adjust font and marker size if not actively set."""
         self._size = new_value
         if not hasattr(self, "_title_fontsize_has_been_set"):
@@ -403,7 +415,8 @@ class ThematicMap(Map):
         if not hasattr(self.legend, "_markersize_has_been_set"):
             self.legend._markersize = self._size
 
-    def __setattr__(self, __name: str, __value) -> None:
+    def __setattr__(self, __name: str, __value: Any) -> None:
+        """Set an attribute with square brackets."""
         if "legend_" in __name:
             last_part = __name.split("legend_")[-1]
             raise AttributeError(

sgis/maps/tilesources.py

@@ -1,4 +1,6 @@
-from xyzservices import TileProvider, Bunch, providers
+from xyzservices import Bunch
+from xyzservices import TileProvider
+from xyzservices import providers
 
 kartverket = Bunch(
     norgeskart=TileProvider(
@@ -7,49 +9,42 @@ kartverket = Bunch(
         attribution="© Kartverket",
         html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
     ),
-
     bakgrunnskart_forenklet=TileProvider(
         name="Norgeskart forenklet",
         url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=bakgrunnskart_forenklet&zoom={z}&x={x}&y={y}",
         attribution="© Kartverket",
         html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
     ),
-
     norges_grunnkart=TileProvider(
         name="Norges grunnkart",
         url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=norges_grunnkart&zoom={z}&x={x}&y={y}",
         attribution="© Kartverket",
         html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
     ),
-
     norges_grunnkart_gråtone=TileProvider(
         name="Norges grunnkart gråtone",
         url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=norges_grunnkart_graatone&zoom={z}&x={x}&y={y}",
         attribution="© Kartverket",
         html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
     ),
-
     n50=TileProvider(
         name="N5 til N50 kartdata",
         url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=kartdata3&zoom={z}&x={x}&y={y}",
         attribution="© Kartverket",
         html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
     ),
-
     topogråtone=TileProvider(
         name="Topografisk norgeskart gråtone",
         url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=topo4graatone&zoom={z}&x={x}&y={y}",
         attribution="© Kartverket",
         html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
     ),
-
     toporaster=TileProvider(
         name="Topografisk raster",
         url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=toporaster4&zoom={z}&x={x}&y={y}",
         attribution="© Kartverket",
         html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
     ),
-
     norge_i_bilder=TileProvider(
         name="Norge i bilder",
         url="https://opencache.statkart.no/gatekeeper/gk/gk.open_nib_web_mercator_wmts_v2?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=Nibcache_web_mercator_v2&STYLE=default&FORMAT=image/jpgpng&tileMatrixSet=default028mm&tileMatrix={z}&tileRow={y}&tileCol={x}",

sgis/networkanalysis/_get_route.py

@@ -7,7 +7,7 @@ from pandas import DataFrame
 
 
 def _get_route_frequencies(
-    graph,
+    graph: Graph,
     roads: GeoDataFrame,
     weight_df: DataFrame,
 ) -> GeoDataFrame:
@@ -60,7 +60,6 @@ def _get_route(
     od_pairs: pd.MultiIndex,
 ) -> GeoDataFrame:
     """Function used in the get_route method of NetworkAnalysis."""
-
     warnings.filterwarnings("ignore", category=RuntimeWarning)
 
     resultlist: list[DataFrame] = []
@@ -86,7 +85,8 @@ def _get_route(
     if not resultlist:
         warnings.warn(
             "No paths were found. Try larger search_tolerance or search_factor. "
-            "Or close_network_holes() or remove_isolated()."
+            "Or close_network_holes() or remove_isolated().",
+            stacklevel=1,
         )
         return pd.DataFrame(columns=["origin", "destination", weight, "geometry"])
 
@@ -121,7 +121,8 @@ def _get_k_routes(
     if not resultlist:
         warnings.warn(
             "No paths were found. Try larger search_tolerance or search_factor. "
-            "Or close_network_holes() or remove_isolated()."
+            "Or close_network_holes() or remove_isolated().",
+            stacklevel=1,
         )
         return pd.DataFrame(columns=["origin", "destination", weight, "geometry"])
 

sgis/networkanalysis/_od_cost_matrix.py

@@ -47,7 +47,9 @@ def _od_cost_matrix(
     return results.reset_index(drop=True)
 
 
-def _get_od_df(graph, origins, destinations, weight_col):
+def _get_od_df(
+    graph: Graph, origins: GeoDataFrame, destinations: GeoDataFrame, weight_col: str
+) -> pd.DataFrame:
     distances: list[list[float]] = graph.distances(
         weights="weight",
         source=origins,
@@ -68,3 +70,44 @@ def _get_od_df(graph, origins, destinations, weight_col):
         .replace([np.inf, -np.inf], np.nan)
         .reset_index(drop=True)
     )
+
+
+def _get_one_od_df(
+    graph: Graph, origins: GeoDataFrame, destinations: GeoDataFrame, weight_col: str
+) -> pd.DataFrame:
+    distances: list[list[float]] = graph.distances(
+        weights="weight",
+        source=origins,
+        target=destinations,
+    )
+
+    ori_idx, des_idx, costs = [], [], []
+    for i, f_idx in enumerate(origins):
+        for j, t_idx in enumerate(destinations):
+            ori_idx.append(f_idx)
+            des_idx.append(t_idx)
+            costs.append(distances[i][j])
+
+    return (
+        pd.DataFrame(
+            data={"origin": ori_idx, "destination": des_idx, weight_col: costs}
+        )
+        .replace([np.inf, -np.inf], np.nan)
+        .reset_index(drop=True)
+    )
+
+
+# def _get_od_df(
+#     graph: Graph,
+#     origins: GeoDataFrame,
+#     destinations: GeoDataFrame,
+#     weight_col: str,
+# ) -> pd.DataFrame:
+#     from ..parallel.parallel import Parallel
+
+#     results: list[pd.DataFrame] = Parallel(40, backend="loky").map(
+#         _get_one_od_df,
+#         [origins[origins.index == i] for i in origins.index.unique()],
+#         kwargs=dict(graph=graph, destinations=destinations, weight_col=weight_col),
+#     )
+#     return pd.concat(results, ignore_index=True)

sgis/networkanalysis/_points.py

@@ -1,10 +1,12 @@
+from collections.abc import Sequence
+
 import numpy as np
+import pandas as pd
 from geopandas import GeoDataFrame
 
 from ..geopandas_tools.neighbors import get_k_nearest_neighbors
 from .networkanalysisrules import NetworkAnalysisRules
 
-
 """
 These are internal classes used in the NetworkAnalysis class. The classes used in
 NetworkAnalysis are Origins and Destinations, which are subclasses of Points. The
@@ -26,7 +28,6 @@ class Points:
         The original indices are stored in a dict and mapped back to the results in the
         end.
         """
-
         self.gdf["temp_idx"] = np.arange(start=start, stop=start + len(self.gdf))
         self.gdf["temp_idx"] = self.gdf["temp_idx"].astype(str)
 
@@ -36,7 +37,9 @@ class Points:
         }
 
     @staticmethod
-    def _convert_distance_to_weight(distances, rules):
+    def _convert_distance_to_weight(
+        distances: Sequence, rules: NetworkAnalysisRules
+    ) -> list[float]:
         """Meters to minutes based on 'weight_to_nodes_' attribute of the rules."""
         if not rules.nodedist_multiplier and not rules.nodedist_kmh:
             return [0 for _ in distances]
@@ -60,7 +63,9 @@ class Points:
 
         return [x / (16.666667 * rules.nodedist_kmh) for x in distances]
 
-    def _make_edges(self, df, from_col, to_col):
+    def _make_edges(
+        self, df: GeoDataFrame | pd.DataFrame, from_col: str, to_col: str
+    ) -> list[tuple[int, int]]:
         return [(f, t) for f, t in zip(df[from_col], df[to_col], strict=True)]
 
     def _get_edges_and_weights(
@@ -71,6 +76,7 @@ class Points:
         from_col: str,
         to_col: str,
     ):
+        """Make edges and weights between points and the nodes of a network."""
         distances = get_k_nearest_neighbors(
             gdf=self.gdf.set_index("temp_idx"),
             neighbors=nodes.set_index("node_id"),

sgis/networkanalysis/_service_area.py

@@ -2,8 +2,11 @@ import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 from igraph import Graph
-from shapely import force_2d, reverse, unary_union
-from shapely.geometry import MultiLineString, MultiPoint, Point
+from shapely import force_2d
+from shapely import reverse
+from shapely import unary_union
+from shapely.geometry import MultiPoint
+from shapely.geometry import Point
 from shapely.ops import nearest_points
 from shapely.wkt import loads