pastastore 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

pastastore/base.py

@@ -1471,6 +1471,7 @@ class ConnectorUtil:
                         else:
                             msg = "stress '{}' not present in library".format(name)
                             raise KeyError(msg)
+
         # hack for pcov w dtype object (when filled with NaNs on store?)
         if "fit" in mdict:
             if "pcov" in mdict["fit"]:
@@ -1534,7 +1535,7 @@ class ConnectorUtil:
         if isinstance(series, pd.Series):
             series.name = name
             # empty string on index name causes trouble when reading
-            # data from Arctic VersionStores
+            # data from ArcticDB: TODO: check if still an issue?
             if series.index.name == "":
                 series.index.name = None
 

pastastore/connectors.py

@@ -4,7 +4,6 @@ import json
 import os
 import warnings
 from copy import deepcopy
-from importlib import import_module
 from typing import Dict, Optional, Union
 
 import pandas as pd
@@ -17,195 +16,6 @@ FrameorSeriesUnion = Union[pd.DataFrame, pd.Series]
 warnings.showwarning = _custom_warning
 
 
-class ArcticConnector(BaseConnector, ConnectorUtil):  # pragma: no cover
-    """ArcticConnector object that connects to a running MongoDB database via Arctic."""
-
-    conn_type = "arctic"
-
-    def __init__(self, name: str, connstr: str):
-        """Create an ArcticConnector object that connects to a MongoDB database.
-
-        Parameters
-        ----------
-        name : str
-            name of the database
-        connstr : str
-            connection string (e.g. 'mongodb://localhost:27017/')
-        """
-        warnings.warn(
-            "ArcticConnector is deprecated. Please use a different "
-            "connector, e.g. `pst.ArcticDBConnector`.",
-            DeprecationWarning,
-            stacklevel=1,
-        )
-        try:
-            import arctic
-        except ModuleNotFoundError as e:
-            print(
-                "Please install arctic (also requires "
-                "a MongoDB instance running somewhere, e.g. "
-                "MongoDB Community: \n"
-                "https://docs.mongodb.com/manual/administration"
-                "/install-community/)!"
-            )
-            raise e
-        self.connstr = connstr
-        self.name = name
-
-        self.libs: dict = {}
-        self.arc = arctic.Arctic(connstr)
-        self._initialize()
-        self.models = ModelAccessor(self)
-        # for older versions of PastaStore, if oseries_models library is empty
-        # populate oseries - models database
-        self._update_all_oseries_model_links()
-
-    def _initialize(self) -> None:
-        """Initialize the libraries (internal method)."""
-        for libname in self._default_library_names:
-            if self._library_name(libname) not in self.arc.list_libraries():
-                self.arc.initialize_library(self._library_name(libname))
-            else:
-                print(
-                    f"ArcticConnector: library "
-                    f"'{self._library_name(libname)}'"
-                    " already exists. Linking to existing library."
-                )
-            self.libs[libname] = self._get_library(libname)
-
-    def _library_name(self, libname: str) -> str:
-        """Get full library name according to Arctic (internal method)."""
-        return ".".join([self.name, libname])
-
-    def _get_library(self, libname: str):
-        """Get Arctic library handle.
-
-        Parameters
-        ----------
-        libname : str
-            name of the library
-
-        Returns
-        -------
-        lib : arctic.Library handle
-            handle to the library
-        """
-        # get library handle
-        lib = self.arc.get_library(self._library_name(libname))
-        return lib
-
-    def _add_item(
-        self,
-        libname: str,
-        item: Union[FrameorSeriesUnion, Dict],
-        name: str,
-        metadata: Optional[Dict] = None,
-        **_,
-    ) -> None:
-        """Add item to library (time series or model) (internal method).
-
-        Parameters
-        ----------
-        libname : str
-            name of the library
-        item : Union[FrameorSeriesUnion, Dict]
-            item to add, either time series or pastas.Model as dictionary
-        name : str
-            name of the item
-        metadata : Optional[Dict], optional
-            dictionary containing metadata, by default None
-        """
-        lib = self._get_library(libname)
-        lib.write(name, item, metadata=metadata)
-
-    def _get_item(self, libname: str, name: str) -> Union[FrameorSeriesUnion, Dict]:
-        """Retrieve item from library (internal method).
-
-        Parameters
-        ----------
-        libname : str
-            name of the library
-        name : str
-            name of the item
-
-        Returns
-        -------
-        item : Union[FrameorSeriesUnion, Dict]
-            time series or model dictionary
-        """
-        lib = self._get_library(libname)
-        return lib.read(name).data
-
-    def _del_item(self, libname: str, name: str) -> None:
-        """Delete items (series or models) (internal method).
-
-        Parameters
-        ----------
-        libname : str
-            name of library to delete item from
-        name : str
-            name of item to delete
-        """
-        lib = self._get_library(libname)
-        lib.delete(name)
-
-    def _get_metadata(self, libname: str, name: str) -> dict:
-        """Retrieve metadata for an item (internal method).
-
-        Parameters
-        ----------
-        libname : str
-            name of the library
-        name : str
-            name of the item
-
-        Returns
-        -------
-        dict
-            dictionary containing metadata
-        """
-        lib = self._get_library(libname)
-        return lib.read_metadata(name).metadata
-
-    @property
-    def oseries_names(self):
-        """List of oseries names.
-
-        Returns
-        -------
-        list
-            list of oseries in library
-        """
-        return self._get_library("oseries").list_symbols()
-
-    @property
-    def stresses_names(self):
-        """List of stresses names.
-
-        Returns
-        -------
-        list
-            list of stresses in library
-        """
-        return self._get_library("stresses").list_symbols()
-
-    @property
-    def model_names(self):
-        """List of model names.
-
-        Returns
-        -------
-        list
-            list of models in library
-        """
-        return self._get_library("models").list_symbols()
-
-    @property
-    def oseries_with_models(self):
-        """List of oseries with models."""
-        return self._get_library("oseries_models").list_symbols()
-
-
 class ArcticDBConnector(BaseConnector, ConnectorUtil):
     """ArcticDBConnector object using ArcticDB to store data."""
 
@@ -388,234 +198,6 @@ class ArcticDBConnector(BaseConnector, ConnectorUtil):
         return self._get_library("oseries_models").list_symbols()
 
 
-class PystoreConnector(BaseConnector, ConnectorUtil):  # pragma: no cover
-    """PystoreConnector object using pystore as database backend."""
-
-    conn_type = "pystore"
-
-    def __init__(self, name: str, path: str):
-        """Create a PystoreConnector object that points to a Pystore.
-
-        Parameters
-        ----------
-        name : str
-            name of the store
-        path : str
-            path to the pystore directory
-        """
-        warnings.warn(
-            "PystoreConnector is deprecated. Please use a different "
-            "connector, e.g. `pst.PasConnector`.",
-            DeprecationWarning,
-            stacklevel=1,
-        )
-        try:
-            import pystore
-        except ModuleNotFoundError as e:
-            print(
-                "Install pystore, follow instructions at "
-                "https://github.com/ranaroussi/pystore#dependencies"
-            )
-            raise e
-        self.name = name
-        self.path = path
-        pystore.set_path(self.path)
-        self.store = pystore.store(self.name)
-        self.libs: dict = {}
-        self._initialize()
-        self.models = ModelAccessor(self)
-        # for older versions of PastaStore, if oseries_models library is empty
-        # populate oseries - models database
-        self._update_all_oseries_model_links()
-
-    def _initialize(self) -> None:
-        """Initialize the libraries (stores) (internal method)."""
-        for libname in self._default_library_names:
-            if libname in self.store.list_collections():
-                print(
-                    f"PystoreConnector: library '{self.path}/{libname}' "
-                    "already exists. Linking to existing library."
-                )
-            lib = self.store.collection(libname)
-            self.libs[libname] = lib
-
-    def _get_library(self, libname: str):
-        """Get Pystore library handle.
-
-        Parameters
-        ----------
-        libname : str
-            name of the library
-
-        Returns
-        -------
-        Pystore.Collection handle
-            handle to the library
-        """
-        # get library handle
-        lib = self.store.collection(libname)
-        return lib
-
-    def _add_item(
-        self,
-        libname: str,
-        item: Union[FrameorSeriesUnion, Dict],
-        name: str,
-        metadata: Optional[Dict] = None,
-        overwrite: bool = False,
-    ) -> None:
-        """Add item to library (time series or model) (internal method).
-
-        Parameters
-        ----------
-        libname : str
-            name of the library
-        item : Union[FrameorSeriesUnion, Dict]
-            item to add, either time series or pastas.Model as dictionary
-        name : str
-            name of the item
-        metadata : Optional[Dict], optional
-            dictionary containing metadata, by default None
-        overwrite : bool, optional
-            overwrite item if it already exists, by default False.
-        """
-        # convert to DataFrame because pystore doesn't accept pandas.Series
-        # (maybe has an easy fix, but converting w to_frame for now)
-        if isinstance(item, pd.Series):
-            s = item.to_frame(name=name)
-            is_type = "series"
-        elif isinstance(item, dict):
-            s = pd.DataFrame()  # empty DataFrame as placeholder
-            jsondict = json.loads(json.dumps(item, cls=PastasEncoder, indent=4))
-            metadata = jsondict  # model dict is stored in metadata
-            is_type = "series"
-        elif isinstance(item, list):
-            s = pd.Series(item).to_frame(name="modelnames")
-            is_type = "list"
-        elif isinstance(item, pd.DataFrame):
-            s = item
-            is_type = "dataframe"
-
-        # store info about input type to ensure same type is returned
-        if metadata is None:
-            metadata = {"_is_type": is_type}
-        else:
-            metadata["_is_type"] = is_type
-
-        lib = self._get_library(libname)
-        lib.write(name, s, metadata=metadata, overwrite=overwrite)
-
-    def _get_item(self, libname: str, name: str) -> Union[FrameorSeriesUnion, Dict]:
-        """Retrieve item from pystore library (internal method).
-
-        Parameters
-        ----------
-        libname : str
-            name of the library
-        name : str
-            name of the item
-
-        Returns
-        -------
-        item : Union[FrameorSeriesUnion, Dict]
-            time series or model dictionary
-        """
-        load_mod = import_module("pastas.io.pas")  # type: ignore
-        lib = self._get_library(libname)
-        # hack for storing models, stored as metadata
-        if libname == "models":
-            jsonpath = lib._item_path(name).joinpath("metadata.json")
-            s = load_mod.load(jsonpath)  # type: ignore
-        else:
-            # read series and convert to pandas
-            item = lib.item(name)
-            s = item.to_pandas()
-            # remove _is_type key and return correct type
-            is_type = item.metadata.pop("_is_type")
-            if is_type == "series":
-                s = s.squeeze()
-            elif is_type == "list":
-                s = s["modelnames"].tolist()
-        return s
-
-    def _del_item(self, libname: str, name: str) -> None:
-        """Delete data from the store (internal method).
-
-        Parameters
-        ----------
-        libname : str
-            name of the library
-        name : str
-            name of the item to delete
-        """
-        lib = self._get_library(libname)
-        lib.delete_item(name)
-        self._clear_cache(libname)
-
-    def _get_metadata(self, libname: str, name: str) -> dict:
-        """Read metadata from pystore (internal method).
-
-        Parameters
-        ----------
-        libname : str
-            name of the library the series are in ("oseries" or "stresses")
-        name : str
-            name of item to load metadata for
-
-        Returns
-        -------
-        imeta : dict
-            dictionary containing metadata
-        """
-        from pystore.utils import read_metadata
-
-        lib = self._get_library(libname)
-        imeta = read_metadata(lib._item_path(name))
-        if "name" not in imeta.keys():
-            imeta["name"] = name
-        if "_is_type" in imeta.keys():
-            imeta.pop("_is_type")
-        return imeta
-
-    @property
-    def oseries_names(self):
-        """List of oseries names.
-
-        Returns
-        -------
-        list
-            list of oseries in library
-        """
-        return list(self._get_library("oseries").list_items())
-
-    @property
-    def stresses_names(self):
-        """List of stresses names.
-
-        Returns
-        -------
-        list
-            list of stresses in library
-        """
-        return list(self._get_library("stresses").list_items())
-
-    @property
-    def model_names(self):
-        """List of model names.
-
-        Returns
-        -------
-        list
-            list of models in library
-        """
-        return list(self._get_library("models").list_items())
-
-    @property
-    def oseries_with_models(self):
-        """List of oseries with models."""
-        return list(self._get_library("oseries_models").list_items())
-
-
 class DictConnector(BaseConnector, ConnectorUtil):
     """DictConnector object that stores timeseries and models in dictionaries."""
 

pastastore/datasets.py

@@ -176,8 +176,7 @@ def _default_connector(conntype: str):
     Parameters
     ----------
     conntype : str
-        name of connector (DictConnector, PasConnector,
-        ArcticConnector, ArcticDBConnector or PystoreConnector)
+        name of connector (DictConnector, PasConnector, ArcticDBConnector)
 
     Returns
     -------
@@ -185,14 +184,9 @@ def _default_connector(conntype: str):
         default Connector based on type.
     """
     Conn = getattr(pst, conntype)
-    if Conn.conn_type == "arctic":
-        connstr = "mongodb://localhost:27017/"
-        conn = Conn("my_db", connstr)
-    elif Conn.conn_type == "arcticdb":
+    if Conn.conn_type == "arcticdb":
         uri = "lmdb://./arctic_db"
         conn = Conn("my_db", uri)
-    elif Conn.conn_type == "pystore":
-        conn = Conn("my_db", "./pystore_db")
     elif Conn.conn_type == "dict":
         conn = Conn("my_db")
     elif Conn.conn_type == "pas":

pastastore/store.py

@@ -1,9 +1,10 @@
 """Module containing the PastaStore object for managing time series and models."""
 
 import json
+import logging
 import os
 import warnings
-from typing import List, Literal, Optional, Tuple, Union
+from typing import Dict, List, Literal, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
@@ -16,12 +17,14 @@ from pastastore.base import BaseConnector
 from pastastore.connectors import DictConnector
 from pastastore.plotting import Maps, Plots
 from pastastore.util import _custom_warning
-from pastastore.version import PASTAS_GEQ_150
+from pastastore.version import PASTAS_GEQ_150, PASTAS_LEQ_022
 from pastastore.yaml_interface import PastastoreYAML
 
 FrameorSeriesUnion = Union[pd.DataFrame, pd.Series]
 warnings.showwarning = _custom_warning
 
+logger = logging.getLogger(__name__)
+
 
 class PastaStore:
     """PastaStore object for managing pastas time series and models.
@@ -30,9 +33,8 @@ class PastaStore:
     the database. Different Connectors are available, e.g.:
 
     - PasConnector for storing all data as .pas (JSON) files on disk (recommended)
-    - DictConenctor for storing all data in dictionaries (in-memory)
-    - ArcticConnector for saving data to MongoDB using the Arctic module
-    - PystoreConnector for saving data to disk using the Pystore module
+    - ArcticDBConnector for saving data on disk using arcticdb package
+    - DictConnector for storing all data in dictionaries (in-memory)
 
     Parameters
     ----------
@@ -43,6 +45,8 @@ class PastaStore:
         name of the PastaStore, by default takes the name of the Connector object
     """
 
+    _accessors = set()
+
     def __init__(
         self,
         connector: Optional[BaseConnector] = None,
@@ -668,7 +672,7 @@ class PastaStore:
     def create_model(
         self,
         name: str,
-        modelname: str = None,
+        modelname: Optional[str] = None,
         add_recharge: bool = True,
         add_ar_noisemodel: bool = False,
         recharge_name: str = "recharge",
@@ -685,7 +689,7 @@ class PastaStore:
             add recharge to the model by looking for the closest
             precipitation and evaporation time series in the stresses
             library, by default True
-        add_ar1_noisemodel : bool, optional
+        add_ar_noisemodel : bool, optional
             add AR(1) noise model to the model, by default False
         recharge_name : str
             name of the RechargeModel
@@ -706,7 +710,7 @@ class PastaStore:
         meta = self.conn.get_metadata("oseries", name, as_frame=False)
         ts = self.conn.get_oseries(name)
 
-        # convert to Timeseries and create model
+        # convert to time series and create model
         if not ts.dropna().empty:
             if modelname is None:
                 modelname = name
@@ -811,50 +815,363 @@ class PastaStore:
         recharge_name : str
             name of the RechargeModel
         """
-        # get nearest prec and evap stns
-        if "prec" not in self.stresses.kind.values:
-            raise ValueError(
-                "No stresses with kind='prec' found in store. "
-                "add_recharge() requires stresses with kind='prec'!"
-            )
-        if "evap" not in self.stresses.kind.values:
-            raise ValueError(
-                "No stresses with kind='evap' found in store. "
-                "add_recharge() requires stresses with kind='evap'!"
-            )
-        names = []
-        for var in ("prec", "evap"):
-            try:
-                name = self.get_nearest_stresses(ml.oseries.name, kind=var).iloc[0, 0]
-            except AttributeError as e:
-                msg = "No precipitation or evaporation time series found!"
-                raise Exception(msg) from e
-            if isinstance(name, float):
-                if np.isnan(name):
+        if recharge is None:
+            recharge = ps.rch.Linear()
+        if rfunc is None:
+            rfunc = ps.Exponential
+
+        self.add_stressmodel(
+            ml,
+            stresses={"prec": "nearest", "evap": "nearest"},
+            rfunc=rfunc,
+            stressmodel=ps.RechargeModel,
+            stressmodel_name=recharge_name,
+            recharge=recharge,
+        )
+
+    def _parse_stresses(
+        self,
+        stresses: Union[str, List[str], Dict[str, str]],
+        kind: Optional[str],
+        stressmodel,
+        oseries: Optional[str] = None,
+    ):
+        # parse stresses for RechargeModel, allow list of len 2 or 3 and
+        # set correct kwarg names
+        if stressmodel._name == "RechargeModel":
+            if isinstance(stresses, list):
+                if len(stresses) == 2:
+                    stresses = {
+                        "prec": stresses[0],
+                        "evap": stresses[1],
+                    }
+                elif len(stresses) == 3:
+                    stresses = {
+                        "prec": stresses[0],
+                        "evap": stresses[1],
+                        "temp": stresses[2],
+                    }
+                else:
                     raise ValueError(
-                        f"Unable to find nearest '{var}' stress! "
-                        "Check x and y coordinates."
+                        "RechargeModel requires 2 or 3 stress names, "
+                        f"got: {len(stresses)}!"
                     )
+        # if stresses is list, create dictionary normally
+        elif isinstance(stresses, list):
+            stresses = {"stress": stresses}
+        # if stresses is str, make it a list of len 1
+        elif isinstance(stresses, str):
+            stresses = {"stress": [stresses]}
+
+        # check if stresses is a dictionary, else raise TypeError
+        if not isinstance(stresses, dict):
+            raise TypeError("stresses must be a list, string or dictionary!")
+
+        # if no kind specified, set to well for WellModel
+        if stressmodel._name == "WellModel":
+            if kind is None:
+                kind = "well"
+
+        # store a copy of the user input for kind
+        if isinstance(kind, list):
+            _kind = kind.copy()
+        else:
+            _kind = kind
+
+        # create empty list for gathering metadata
+        metadata = []
+        # loop over stresses keys/values
+        for i, (k, v) in enumerate(stresses.items()):
+            # if entry in dictionary is str, make it list of len 1
+            if isinstance(v, str):
+                v = [v]
+            # parse value
+            if isinstance(v, list):
+                for item in v:
+                    names = []  # empty list for names
+                    # parse nearest
+                    if item.startswith("nearest"):
+                        # check oseries defined if nearest option is used
+                        if not oseries:
+                            raise ValueError(
+                                "Getting nearest stress(es) requires oseries name!"
+                            )
+                        try:
+                            if len(item.split()) == 3:  # nearest <n> <kind>
+                                n = int(item.split()[1])
+                                kind = item.split()[2]
+                            elif len(item.split()) == 2:  # nearest <n> | <kind>
+                                try:
+                                    n = int(item.split()[1])  # try converting to <n>
+                                except ValueError:
+                                    n = 1
+                                    kind = item.split()[1]  # interpret as <kind>
+                            else:  # nearest
+                                n = 1
+                                # if RechargeModel, we can infer kind
+                                if (
+                                    _kind is None
+                                    and stressmodel._name == "RechargeModel"
+                                ):
+                                    kind = k
+                                elif _kind is None:  # catch no kind with bare nearest
+                                    raise ValueError(
+                                        "Bare 'nearest' found but no kind specified."
+                                    )
+                                elif isinstance(_kind, list):
+                                    kind = _kind[i]  # if multiple kind, select i-th
+                        except Exception as e:
+                            # raise if nearest parsing failed
+                            raise ValueError(
+                                f"Could not parse stresses: '{item}'! "
+                                "When using option 'nearest', use 'nearest' and specify"
+                                " kind, or 'nearest <kind>' or 'nearest <n> <kind>'!"
+                            ) from e
+                        # check if kind exists at all
+                        if kind not in self.stresses.kind.values:
+                            raise ValueError(
+                                f"Could not find stresses with kind='{kind}'!"
+                            )
+                        # get stress names of <n> nearest <kind> stresses
+                        inames = self.get_nearest_stresses(
+                            oseries, kind=kind, n=n
+                        ).iloc[0]
+                        # check if any NaNs in result
+                        if inames.isna().any():
+                            nkind = (self.stresses.kind == kind).sum()
+                            raise ValueError(
+                                f"Could not find {n} nearest stress(es) for '{kind}'! "
+                                f"There are only {nkind} '{kind}' stresses."
+                            )
+                        # append names
+                        names += inames.tolist()
+                    else:
+                        # assume name is name of stress
+                        names.append(item)
+                # get stresses and metadata
+                stress_series, imeta = self.get_stresses(
+                    names, return_metadata=True, squeeze=True
+                )
+                # replace stress name(s) with time series
+                if len(names) > 1:
+                    stresses[k] = list(stress_series.values())
+                else:
+                    stresses[k] = stress_series
+                # gather metadata
+                if isinstance(imeta, list):
+                    metadata += imeta
+                else:
+                    metadata.append(imeta)
+
+        return stresses, metadata
+
+    def get_stressmodel(
+        self,
+        stresses: Union[str, List[str], Dict[str, str]],
+        stressmodel=ps.StressModel,
+        stressmodel_name: Optional[str] = None,
+        rfunc=ps.Exponential,
+        rfunc_kwargs: Optional[dict] = None,
+        kind: Optional[Union[List[str], str]] = None,
+        oseries: Optional[str] = None,
+        **kwargs,
+    ):
+        """Get a Pastas stressmodel from stresses time series in Pastastore.
+
+        Supports "nearest" selection. Any stress name can be replaced by
+        "nearest [<n>] <kind>" where <n> is optional and represents the number of
+        nearest stresses and <kind> and represents the kind of stress to
+        consider. <kind> can also be specified directly with the `kind` kwarg.
+
+        Note: the 'nearest' option requires the oseries name to be provided.
+        Additionally, 'x' and 'y' metadata must be stored for oseries and stresses.
+
+        Parameters
+        ----------
+        stresses : str, list of str, or dict
+            name(s) of the time series to use for the stressmodel, or dictionary
+            with key(s) and value(s) as time series name(s). Options include:
+               - name of stress: `"prec_stn"`
+               - list of stress names: `["prec_stn", "evap_stn"]`
+               - dict for RechargeModel: `{"prec": "prec_stn", "evap": "evap_stn"}`
+               - dict for StressModel: `{"stress": "well1"}`
+               - nearest, specifying kind: `"nearest well"`
+               - nearest specifying number and kind: `"nearest 2 well"`
+        stressmodel : str or class
+            stressmodel class to use, by default ps.StressModel
+        stressmodel_name : str, optional
+            name of the stressmodel, by default None, which uses the stress name,
+            if there is 1 stress otherwise the name of the stressmodel type. For
+            RechargeModels, the name defaults to 'recharge'.
+        rfunc : str or class
+            response function class to use, by default ps.Exponential
+        rfunc_kwargs : dict, optional
+            keyword arguments to pass to the response function, by default None
+        kind : str or list of str, optional
+            specify kind of stress(es) to use, by default None, useful in combination
+            with 'nearest' option for defining stresses
+        oseries : str, optional
+            name of the oseries to use for the stressmodel, by default None, used when
+            'nearest' option is used for defining stresses.
+        **kwargs
+            additional keyword arguments to pass to the stressmodel
+
+        Returns
+        -------
+        stressmodel : pastas.StressModel
+            pastas StressModel that can be added to pastas Model.
+        """
+        # get stressmodel class, if str was provided
+        if isinstance(stressmodel, str):
+            stressmodel = getattr(ps, stressmodel)
+
+        # parse stresses names to get time series and metadata
+        stresses, metadata = self._parse_stresses(
+            stresses=stresses, stressmodel=stressmodel, kind=kind, oseries=oseries
+        )
+
+        # get stressmodel name if not provided
+        if stressmodel_name is None:
+            if stressmodel._name == "RechargeModel":
+                stressmodel_name = "recharge"
+            elif len(metadata) == 1:
+                stressmodel_name = stresses["stress"].squeeze().name
             else:
-                names.append(name)
-        if len(names) == 0:
-            msg = "No precipitation or evaporation time series found!"
-            raise Exception(msg)
-
-        # get data
-        tsdict = self.conn.get_stresses(names)
-        metadata = self.conn.get_metadata("stresses", names, as_frame=False)
-        # add recharge to model
-        rch = ps.RechargeModel(
-            tsdict[names[0]],
-            tsdict[names[1]],
+                stressmodel_name = stressmodel._name
+
+        # check if metadata is list of len 1 and unpack
+        if isinstance(metadata, list) and len(metadata) == 1:
+            metadata = metadata[0]
+
+        # get stressmodel time series settings
+        if kind and "settings" not in kwargs:
+            # try using kind to get predefined settings options
+            if isinstance(kind, str):
+                kwargs["settings"] = ps.rcParams["timeseries"].get(kind, None)
+            else:
+                kwargs["settings"] = [
+                    ps.rcParams["timeseries"].get(ikind, None) for ikind in kind
+                ]
+        elif kind is None and "settings" not in kwargs:
+            # try using kind stored in metadata to get predefined settings options
+            if isinstance(metadata, list):
+                kwargs["settings"] = [
+                    ps.rcParams["timeseries"].get(imeta.get("kind", None), None)
+                    for imeta in metadata
+                ]
+            elif isinstance(metadata, dict):
+                kwargs["settings"] = ps.rcParams["timeseries"].get(
+                    metadata.get("kind", None), None
+                )
+
+        # get rfunc class if str was provided
+        if isinstance(rfunc, str):
+            rfunc = getattr(ps, rfunc)
+
+        # create empty rfunc_kwargs if not provided
+        if rfunc_kwargs is None:
+            rfunc_kwargs = {}
+
+        # special for WellModels
+        if stressmodel._name == "WellModel":
+            names = [s.squeeze().name for s in stresses["stress"]]
+            # check oseries is provided
+            if oseries is None:
+                raise ValueError("WellModel requires 'oseries' to compute distances!")
+            # compute distances and add to kwargs
+            distances = (
+                self.get_distances(oseries=oseries, stresses=names).T.squeeze().values
+            )
+            kwargs["distances"] = distances
+            # set settings to well
+            if "settings" not in kwargs:
+                kwargs["settings"] = "well"
+            # override rfunc and set to HantushWellModel
+            rfunc = ps.HantushWellModel
+
+        # do not add metadata for pastas 0.22 and WellModel
+        if not PASTAS_LEQ_022 and (stressmodel._name != "WellModel"):
+            kwargs["metadata"] = metadata
+
+        return stressmodel(
+            **stresses,
+            rfunc=rfunc(**rfunc_kwargs),
+            name=stressmodel_name,
+            **kwargs,
+        )
+
+    def add_stressmodel(
+        self,
+        ml: Union[ps.Model, str],
+        stresses: Union[str, List[str], Dict[str, str]],
+        stressmodel=ps.StressModel,
+        stressmodel_name: Optional[str] = None,
+        rfunc=ps.Exponential,
+        rfunc_kwargs: Optional[dict] = None,
+        kind: Optional[Union[List[str], str]] = None,
+        **kwargs,
+    ):
+        """Add a pastas StressModel from stresses time series in Pastastore.
+
+        Supports "nearest" selection. Any stress name can be replaced by
+        "nearest [<n>] <kind>" where <n> is optional and represents the number of
+        nearest stresses and <kind> and represents the kind of stress to
+        consider. <kind> can also be specified directly with the `kind` kwarg.
+
+        Note: the 'nearest' option requires the oseries name to be provided.
+        Additionally, 'x' and 'y' metadata must be stored for oseries and stresses.
+
+        Parameters
+        ----------
+        ml : pastas.Model or str
+            pastas.Model object to add StressModel to, if passed as string,
+            model is loaded from store, the stressmodel is added and then written
+            back to the store.
+        stresses : str, list of str, or dict
+            name(s) of the time series to use for the stressmodel, or dictionary
+            with key(s) and value(s) as time series name(s). Options include:
+               - name of stress: `"prec_stn"`
+               - list of stress names: `["prec_stn", "evap_stn"]`
+               - dict for RechargeModel: `{"prec": "prec_stn", "evap": "evap_stn"}`
+               - dict for StressModel: `{"stress": "well1"}`
+               - nearest, specifying kind: `"nearest well"`
+               - nearest specifying number and kind: `"nearest 2 well"`
+        stressmodel : str or class
+            stressmodel class to use, by default ps.StressModel
+        stressmodel_name : str, optional
+            name of the stressmodel, by default None, which uses the stress name,
+            if there is 1 stress otherwise the name of the stressmodel type. For
+            RechargeModels, the name defaults to 'recharge'.
+        rfunc : str or class
+            response function class to use, by default ps.Exponential
+        rfunc_kwargs : dict, optional
+            keyword arguments to pass to the response function, by default None
+        kind : str or list of str, optional
+            specify kind of stress(es) to use, by default None, useful in combination
+            with 'nearest' option for defining stresses
+        **kwargs
+            additional keyword arguments to pass to the stressmodel
+        """
+        sm = self.get_stressmodel(
+            stresses=stresses,
+            stressmodel=stressmodel,
+            stressmodel_name=stressmodel_name,
             rfunc=rfunc,
-            name=recharge_name,
-            recharge=recharge,
-            settings=("prec", "evap"),
-            metadata=metadata,
+            rfunc_kwargs=rfunc_kwargs,
+            kind=kind,
+            oseries=ml if isinstance(ml, str) else ml.oseries.name,
+            **kwargs,
         )
-        ml.add_stressmodel(rch)
+        if isinstance(ml, str):
+            ml = self.get_model(ml)
+            ml.add_stressmodel(sm)
+            self.conn.add_model(ml, overwrite=True)
+            logger.info(
+                f"Stressmodel '{sm.name}' added to model '{ml.name}' "
+                "and stored in database."
+            )
+        else:
+            ml.add_stressmodel(sm)
 
     def solve_models(
         self,

pastastore/util.py

@@ -1,7 +1,6 @@
 """Useful utilities for pastastore."""
 
 import os
-import warnings
 from typing import Dict, List, Optional, Union
 
 import numpy as np
@@ -24,111 +23,6 @@ class ItemInLibraryException(Exception):
     pass
 
 
-# TODO: remove in future version
-def delete_pystore_connector(
-    conn=None,
-    path: Optional[str] = None,
-    name: Optional[str] = None,
-    libraries: Optional[List[str]] = None,
-) -> None:  # pragma: no cover
-    """Delete libraries from pystore.
-
-    Parameters
-    ----------
-    conn : PystoreConnector, optional
-        PystoreConnector object
-    path : str, optional
-        path to pystore
-    name : str, optional
-        name of the pystore
-    libraries : Optional[List[str]], optional
-        list of library names to delete, by default None which deletes
-        all libraries
-    """
-    warnings.warn(
-        "This function is deprecated. We recommend to migrate to a different "
-        "Connector, e.g. `pst.PasConnector`.",
-        DeprecationWarning,
-        stacklevel=1,
-    )
-    import pystore
-
-    if conn is not None:
-        name = conn.name
-        path = conn.path
-    elif name is None or path is None:
-        raise ValueError("Please provide 'name' and 'path' OR 'conn'!")
-
-    print(f"Deleting PystoreConnector database: '{name}' ...", end="")
-    pystore.set_path(path)
-    if libraries is None:
-        pystore.delete_store(name)
-        print(" Done!")
-    else:
-        store = pystore.store(name)
-        for lib in libraries:
-            print()
-            store.delete_collection(lib)
-            print(f" - deleted: {lib}")
-
-
-# TODO: remove in future version
-def delete_arctic_connector(
-    conn=None,
-    connstr: Optional[str] = None,
-    name: Optional[str] = None,
-    libraries: Optional[List[str]] = None,
-) -> None:  # pragma: no cover
-    """Delete libraries from arctic database.
-
-    Parameters
-    ----------
-    conn : pastastore.ArcticConnector
-        ArcticConnector object
-    connstr : str, optional
-        connection string to the database
-    name : str, optional
-        name of the database
-    libraries : Optional[List[str]], optional
-        list of library names to delete, by default None which deletes
-        all libraries
-    """
-    warnings.warn(
-        "This function is deprecated. We recommend to migrate to a different "
-        "Connector, e.g. `pst.ArcticDBConnector`.",
-        DeprecationWarning,
-        stacklevel=1,
-    )
-    import arctic
-
-    if conn is not None:
-        name = conn.name
-        connstr = conn.connstr
-    elif name is None or connstr is None:
-        raise ValueError("Provide 'name' and 'connstr' OR 'conn'!")
-
-    arc = arctic.Arctic(connstr)
-
-    print(f"Deleting ArcticConnector database: '{name}' ... ", end="")
-    # get library names
-    if libraries is None:
-        libs = []
-        for ilib in arc.list_libraries():
-            if ilib.split(".")[0] == name:
-                libs.append(ilib)
-    elif name is not None:
-        libs = [name + "." + ilib for ilib in libraries]
-    else:
-        raise ValueError("Provide 'name' and 'connstr' OR 'conn'!")
-
-    for lib in libs:
-        arc.delete_library(lib)
-        if libraries is not None:
-            print()
-            print(f" - deleted: {lib}")
-    print("Done!")
-
-
 def delete_arcticdb_connector(
     conn=None,
     uri: Optional[str] = None,
@@ -167,17 +61,15 @@ def delete_arcticdb_connector(
         libs = []
         for ilib in arc.list_libraries():
             if ilib.split(".")[0] == name:
-                # TODO: remove replace when arcticdb is able to delete
-                libs.append(ilib.replace(".", "/"))
+                libs.append(ilib)
     elif name is not None:
-        # TODO: replace / with . when arcticdb is able to delete
-        libs = [name + "/" + ilib for ilib in libraries]
+        libs = [name + "." + ilib for ilib in libraries]
     else:
         raise ValueError("Provide 'name' and 'uri' OR 'conn'!")
 
     for lib in libs:
-        # arc.delete_library(lib)  # TODO: not working at the moment.
-        shutil.rmtree(os.path.join(conn.uri.split("//")[-1], lib))
+        arc.delete_library(lib)
+        # shutil.rmtree(os.path.join(conn.uri.split("//")[-1], lib))
 
         if libraries is not None:
             print()
@@ -243,14 +135,8 @@ def delete_pastastore(pstore, libraries: Optional[List[str]] = None) -> None:
     TypeError
         when Connector type is not recognized
     """
-    # TODO: remove in future version
-    if pstore.conn.conn_type == "pystore":
-        delete_pystore_connector(conn=pstore.conn, libraries=libraries)
-    elif pstore.conn.conn_type == "dict":
+    if pstore.conn.conn_type == "dict":
         delete_dict_connector(pstore)
-    # TODO: remove in future version
-    elif pstore.conn.conn_type == "arctic":
-        delete_arctic_connector(conn=pstore.conn, libraries=libraries)
     elif pstore.conn.conn_type == "arcticdb":
         delete_arcticdb_connector(conn=pstore.conn, libraries=libraries)
     elif pstore.conn.conn_type == "pas":

pastastore/version.py

@@ -9,7 +9,7 @@ PASTAS_VERSION = parse_version(ps.__version__)
 PASTAS_LEQ_022 = PASTAS_VERSION <= parse_version("0.22.0")
 PASTAS_GEQ_150 = PASTAS_VERSION >= parse_version("1.5.0")
 
-__version__ = "1.5.0"
+__version__ = "1.6.0"
 
 
 def show_versions(optional=False) -> None:
@@ -21,6 +21,7 @@ def show_versions(optional=False) -> None:
         Print the version of optional dependencies, by default False
     """
     msg = (
+        f"Pastastore version : {__version__}\n\n"
         f"Python version     : {python_version()}\n"
         f"Pandas version     : {metadata.version('pandas')}\n"
         f"Matplotlib version : {metadata.version('matplotlib')}\n"

{pastastore-1.5.0.dist-info → pastastore-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pastastore
-Version: 1.5.0
+Version: 1.6.0
 Summary: Tools for managing Pastas time series models.
 Author: D.A. Brakenhoff
 Maintainer-email: "D.A. Brakenhoff" <d.brakenhoff@artesia-water.nl>, "R. Calje" <r.calje@artesia-water.nl>, "M.A. Vonk" <m.vonk@artesia-water.nl>
@@ -61,12 +61,12 @@ Requires-Dist: Ipython ; extra == 'docs'
 Requires-Dist: ipykernel ; extra == 'docs'
 Requires-Dist: nbsphinx ; extra == 'docs'
 Requires-Dist: nbsphinx-link ; extra == 'docs'
+Provides-Extra: extensions
+Requires-Dist: hydropandas ; extra == 'extensions'
 Provides-Extra: full
 Requires-Dist: pastastore[arcticdb,optional] ; extra == 'full'
 Provides-Extra: lint
-Requires-Dist: black ; extra == 'lint'
-Requires-Dist: flake8 ; extra == 'lint'
-Requires-Dist: isort ; extra == 'lint'
+Requires-Dist: ruff ; extra == 'lint'
 Provides-Extra: optional
 Requires-Dist: contextily ; extra == 'optional'
 Requires-Dist: pyproj ; extra == 'optional'

pastastore-1.6.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pastastore/__init__.py,sha256=l6zRpDO0j6MIrfdljCTbkF70bt-GFlPseBd4IlmaC-o,269
+pastastore/base.py,sha256=n7hPrkaLjR6_8S0XRHxvviqBWvULx3W_faQcoA9HZ9I,67166
+pastastore/connectors.py,sha256=YK3I_Jb2uNwzBQvN2VwZvmTRfPeUETW-4ddcFSWkHVw,16820
+pastastore/datasets.py,sha256=FHVfmKqb8beEs9NONsWrCoJY37BmlvFLSEQ1VAFmE8A,6415
+pastastore/plotting.py,sha256=t6gEeHVGzrwvM6q1l8V3OkklpU75O2Y4h6nKEHRWdjo,46416
+pastastore/store.py,sha256=istLgbTVXvNWqTkZQtEcxWEweouh-M6HWUAXybKrESw,58286
+pastastore/styling.py,sha256=ioaH10ELV8CFvJA-xAKFbnBklTd6FB1TZV8sqvZrEcw,1518
+pastastore/util.py,sha256=iXHoGHfK6VDbUpufNsnzdV71oBVp-koZUD4VJj6MOwo,28250
+pastastore/version.py,sha256=p4YdipfRBvajfHzz2s7TjR_IpDOit_K_Lr2e7pnKhLU,1205
+pastastore/yaml_interface.py,sha256=MddELxWe8_aqJRMUydOCbjoU1-ZodzxFKYnAaqJ5SqA,29947
+pastastore-1.6.0.dist-info/LICENSE,sha256=DtHftfUEm99KzgwLr3rQUTg8H3kAS0Z-p5WWJgLf_OY,1082
+pastastore-1.6.0.dist-info/METADATA,sha256=cFimKbNDGJdY-iOFcDfpo4ger907HniL0kWFeSUvTqg,8021
+pastastore-1.6.0.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+pastastore-1.6.0.dist-info/top_level.txt,sha256=QKfonr1KJZN46MFsj8eGRBw9Mg-jO-HFvgE2orVX7Sk,11
+pastastore-1.6.0.dist-info/RECORD,,

{pastastore-1.5.0.dist-info → pastastore-1.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (72.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pastastore-1.5.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-pastastore/__init__.py,sha256=l6zRpDO0j6MIrfdljCTbkF70bt-GFlPseBd4IlmaC-o,269
-pastastore/base.py,sha256=tUWIenFjiIeQHkA2CYBxmwMy7KXXq5JZ5jZCphRjuj8,67145
-pastastore/connectors.py,sha256=-Rsw8Uf7wcos9XsQMDPgysU2acT-kqt25WFeNnpf5K0,29588
-pastastore/datasets.py,sha256=VTjlekM3UryGpslSdMLAaT-QIAVJfaZql0dka2AbMyc,6665
-pastastore/plotting.py,sha256=t6gEeHVGzrwvM6q1l8V3OkklpU75O2Y4h6nKEHRWdjo,46416
-pastastore/store.py,sha256=1HEkr84vmCiB07Yj8iOMybFRY_l93C4J1e2suGd92SU,44171
-pastastore/styling.py,sha256=ioaH10ELV8CFvJA-xAKFbnBklTd6FB1TZV8sqvZrEcw,1518
-pastastore/util.py,sha256=4P1cQ_euEo3-YopKGReQ18EznTxBVfDpXFiEczpn_Bw,31811
-pastastore/version.py,sha256=xF0vR3dPK9WQScTFt_osbszvZt9GKJQTBvrT8nRgswc,1155
-pastastore/yaml_interface.py,sha256=MddELxWe8_aqJRMUydOCbjoU1-ZodzxFKYnAaqJ5SqA,29947
-pastastore-1.5.0.dist-info/LICENSE,sha256=DtHftfUEm99KzgwLr3rQUTg8H3kAS0Z-p5WWJgLf_OY,1082
-pastastore-1.5.0.dist-info/METADATA,sha256=_JrozH-4rPhQdxsVuzzHhmW3rWd_T_9oC8H-b68B_7s,8023
-pastastore-1.5.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-pastastore-1.5.0.dist-info/top_level.txt,sha256=QKfonr1KJZN46MFsj8eGRBw9Mg-jO-HFvgE2orVX7Sk,11
-pastastore-1.5.0.dist-info/RECORD,,