pastastore 1.6.1__tar.gz → 1.7.0__tar.gz

{pastastore-1.6.1 → pastastore-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pastastore
-Version: 1.6.1
+Version: 1.7.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>

{pastastore-1.6.1 → pastastore-1.7.0}/pastastore/base.py

@@ -56,6 +56,11 @@ class BaseConnector(ABC):
             f"{self.n_models} models"
         )
 
+    @property
+    def empty(self):
+        """Check if the database is empty."""
+        return not any([self.n_oseries > 0, self.n_stresses > 0, self.n_models > 0])
+
     @abstractmethod
     def _get_library(self, libname: str):
         """Get library handle.

{pastastore-1.6.1 → pastastore-1.7.0}/pastastore/store.py

@@ -4,6 +4,8 @@ import json
 import logging
 import os
 import warnings
+from concurrent.futures import ProcessPoolExecutor
+from functools import partial
 from typing import Dict, List, Literal, Optional, Tuple, Union
 
 import numpy as np
@@ -12,6 +14,7 @@ import pastas as ps
 from packaging.version import parse as parse_version
 from pastas.io.pas import pastas_hook
 from tqdm.auto import tqdm
+from tqdm.contrib.concurrent import process_map
 
 from pastastore.base import BaseConnector
 from pastastore.connectors import DictConnector
@@ -78,6 +81,11 @@ class PastaStore:
         self.plots = Plots(self)
         self.yaml = PastastoreYAML(self)
 
+    @property
+    def empty(self) -> bool:
+        """Check if the PastaStore is empty."""
+        return self.conn.empty
+
     def _register_connector_methods(self):
         """Register connector methods (internal method)."""
         methods = [
@@ -1175,18 +1183,19 @@ class PastaStore:
 
     def solve_models(
         self,
-        mls: Optional[Union[ps.Model, list, str]] = None,
+        modelnames: Union[List[str], str, None] = None,
         report: bool = False,
         ignore_solve_errors: bool = False,
-        store_result: bool = True,
         progressbar: bool = True,
+        parallel: bool = False,
+        max_workers: Optional[int] = None,
         **kwargs,
     ) -> None:
         """Solves the models in the store.
 
         Parameters
         ----------
-        mls : list of str, optional
+        modelnames : list of str, optional
             list of model names, if None all models in the pastastore
             are solved.
         report : boolean, optional
@@ -1196,43 +1205,103 @@ class PastaStore:
             if True, errors emerging from the solve method are ignored,
             default is False which will raise an exception when a model
             cannot be optimized
-        store_result : bool, optional
-            if True save optimized models, default is True
         progressbar : bool, optional
-            show progressbar, default is True
-        **kwargs :
+            show progressbar, default is True.
+        parallel: bool, optional
+            if True, solve models in parallel using ProcessPoolExecutor
+        max_workers: int, optional
+            maximum number of workers to use in parallel solving, default is
+            None which will use the number of cores available on the machine
+        **kwargs : dictionary
             arguments are passed to the solve method.
+
+        Notes
+        -----
+        Users should be aware that parallel solving is platform dependent
+        and may not always work. The current implementation works well for Linux users.
+        For Windows users, parallel solving does not work when called directly from
+        Jupyter Notebooks or IPython. To use parallel solving on Windows, the following
+        code should be used in a Python file::
+
+            from multiprocessing import freeze_support
+
+            if __name__ == "__main__":
+                freeze_support()
+                pstore.solve_models(parallel=True)
         """
-        if mls is None:
-            mls = self.conn.model_names
-        elif isinstance(mls, ps.Model):
-            mls = [mls.name]
+        if "mls" in kwargs:
+            modelnames = kwargs.pop("mls")
+            logger.warning("Argument `mls` is deprecated, use `modelnames` instead.")
 
-        desc = "Solving models"
-        for ml_name in tqdm(mls, desc=desc) if progressbar else mls:
-            ml = self.conn.get_models(ml_name)
+        modelnames = self.conn._parse_names(modelnames, libname="models")
 
-            m_kwargs = {}
-            for key, value in kwargs.items():
-                if isinstance(value, pd.Series):
-                    m_kwargs[key] = value.loc[ml_name]
-                else:
-                    m_kwargs[key] = value
-            # Convert timestamps
-            for tstamp in ["tmin", "tmax"]:
-                if tstamp in m_kwargs:
-                    m_kwargs[tstamp] = pd.Timestamp(m_kwargs[tstamp])
+        solve_model = partial(
+            self._solve_model,
+            report=report,
+            ignore_solve_errors=ignore_solve_errors,
+            **kwargs,
+        )
+        if self.conn.conn_type != "pas":
+            parallel = False
+            logger.error(
+                "Parallel solving only supported for PasConnector databases."
+                "Setting parallel to `False`"
+            )
 
-            try:
-                ml.solve(report=report, **m_kwargs)
-                if store_result:
-                    self.conn.add_model(ml, overwrite=True)
-            except Exception as e:
-                if ignore_solve_errors:
-                    warning = "solve error ignored for -> {}".format(ml.name)
-                    ps.logger.warning(warning)
-                else:
-                    raise e
+        if parallel and progressbar:
+            process_map(solve_model, modelnames, max_workers=max_workers)
+        elif parallel and not progressbar:
+            with ProcessPoolExecutor(max_workers=max_workers) as executor:
+                executor.map(solve_model, modelnames)
+        else:
+            for ml_name in (
+                tqdm(modelnames, desc="Solving models") if progressbar else modelnames
+            ):
+                solve_model(ml_name=ml_name)
+
+    def _solve_model(
+        self,
+        ml_name: str,
+        report: bool = False,
+        ignore_solve_errors: bool = False,
+        **kwargs,
+    ) -> None:
+        """Solve a model in the store (internal method).
+
+        ml_name : list of str, optional
+            name of a model in the pastastore
+        report : boolean, optional
+            determines if a report is printed when the model is solved,
+            default is False
+        ignore_solve_errors : boolean, optional
+            if True, errors emerging from the solve method are ignored,
+            default is False which will raise an exception when a model
+            cannot be optimized
+        **kwargs : dictionary
+            arguments are passed to the solve method.
+        """
+        ml = self.conn.get_models(ml_name)
+        m_kwargs = {}
+        for key, value in kwargs.items():
+            if isinstance(value, pd.Series):
+                m_kwargs[key] = value.loc[ml.name]
+            else:
+                m_kwargs[key] = value
+        # Convert timestamps
+        for tstamp in ["tmin", "tmax"]:
+            if tstamp in m_kwargs:
+                m_kwargs[tstamp] = pd.Timestamp(m_kwargs[tstamp])
+
+        try:
+            ml.solve(report=report, **m_kwargs)
+        except Exception as e:
+            if ignore_solve_errors:
+                warning = "Solve error ignored for '%s': %s " % (ml.name, e)
+                logger.warning(warning)
+            else:
+                raise e
+
+        self.conn.add_model(ml, overwrite=True)
 
     def model_results(
         self,

{pastastore-1.6.1 → pastastore-1.7.0}/pastastore/styling.py

@@ -1,8 +1,8 @@
 """Module containing dataframe styling functions."""
 
-import matplotlib as mpl
 import matplotlib.pyplot as plt
 import numpy as np
+from matplotlib.colors import rgb2hex
 
 
 def float_styler(val, norm, cmap=None):
@@ -26,12 +26,12 @@ def float_styler(val, norm, cmap=None):
     -----
     Given some dataframe
 
-    >>> df.map(float_styler, subset=["some column"], norm=norm, cmap=cmap)
+    >>> df.style.map(float_styler, subset=["some column"], norm=norm, cmap=cmap)
     """
     if cmap is None:
         cmap = plt.get_cmap("RdYlBu")
     bg = cmap(norm(val))
-    color = mpl.colors.rgb2hex(bg)
+    color = rgb2hex(bg)
     c = "White" if np.mean(bg[:3]) < 0.4 else "Black"
     return f"background-color: {color}; color: {c}"
 
@@ -53,15 +53,48 @@ def boolean_styler(b):
     -----
     Given some dataframe
 
-    >>> df.map(boolean_styler, subset=["some column"])
+    >>> df.style.map(boolean_styler, subset=["some column"])
     """
     if b:
         return (
-            f"background-color: {mpl.colors.rgb2hex((231/255, 255/255, 239/255))}; "
+            f"background-color: {rgb2hex((231/255, 255/255, 239/255))}; "
             "color: darkgreen"
         )
     else:
         return (
-            f"background-color: {mpl.colors.rgb2hex((255/255, 238/255, 238/255))}; "
+            f"background-color: {rgb2hex((255/255, 238/255, 238/255))}; "
             "color: darkred"
         )
+
+
+def boolean_row_styler(row, column):
+    """Styler function to color rows based on the value in column.
+
+    Parameters
+    ----------
+    row : pd.Series
+        row in dataframe
+    column : str
+        column name to get boolean value for styling
+
+    Returns
+    -------
+    str
+        css for styling dataframe row
+
+    Usage
+    -----
+    Given some dataframe
+
+    >>> df.style.apply(boolean_row_styler, column="boolean_column", axis=1)
+    """
+    if row[column]:
+        return (
+            f"background-color: {rgb2hex((231/255, 255/255, 239/255))}; "
+            "color: darkgreen",
+        ) * row.size
+    else:
+        return (
+            f"background-color: {rgb2hex((255/255, 238/255, 238/255))}; "
+            "color: darkred",
+        ) * row.size

{pastastore-1.6.1 → pastastore-1.7.0}/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.6.1"
+__version__ = "1.7.0"
 
 
 def show_versions(optional=False) -> None:

{pastastore-1.6.1 → pastastore-1.7.0}/pastastore.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pastastore
-Version: 1.6.1
+Version: 1.7.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>

{pastastore-1.6.1 → pastastore-1.7.0}/pyproject.toml

@@ -61,7 +61,7 @@ test = [
     "codacy-coverage",
 ]
 test_py312 = [
-    "pastastore[lint,optional]",
+    "pastastore[lint,optional]",  # no arcticdb
     "hydropandas[full]",
     "coverage",
     "codecov",

{pastastore-1.6.1 → pastastore-1.7.0}/tests/test_003_pastastore.py

@@ -195,13 +195,18 @@ def test_iter_models(request, pstore):
 def test_solve_models_and_get_stats(request, pstore):
     depends(request, [f"test_create_models[{pstore.type}]"])
     _ = pstore.solve_models(
-        ignore_solve_errors=False, progressbar=False, store_result=True
+        ignore_solve_errors=False, progressbar=False, parallel=False
     )
     stats = pstore.get_statistics(["evp", "aic"], progressbar=False)
     assert stats.index.size == 2
 
 
 @pytest.mark.dependency
+def test_solve_models_parallel(request, pstore):
+    depends(request, [f"test_create_models[{pstore.type}]"])
+    _ = pstore.solve_models(ignore_solve_errors=False, progressbar=False, parallel=True)
+
+
 def test_apply(request, pstore):
     depends(request, [f"test_solve_models_and_get_stats[{pstore.type}]"])