pastastore 1.10.2__py3-none-any.whl → 1.12.0__py3-none-any.whl

pastastore/base.py

@@ -2,25 +2,236 @@
 """Base classes for PastaStore Connectors."""
 
 import functools
+import logging
 import warnings
 
 # import weakref
 from abc import ABC, abstractmethod
+from collections.abc import Iterable
 from itertools import chain
-from typing import Callable, Dict, List, Optional, Tuple, Union
+from random import choice
+
+# import weakref
+from typing import Callable, Dict, List, Optional, Union
 
 import pandas as pd
 import pastas as ps
+from packaging.version import parse as parse_version
 from tqdm.auto import tqdm
 
-from pastastore.util import ItemInLibraryException, _custom_warning, validate_names
-from pastastore.version import PASTAS_GEQ_150, PASTAS_LEQ_022
+from pastastore.typing import AllLibs, FrameOrSeriesUnion, TimeSeriesLibs
+from pastastore.util import (
+    ItemInLibraryException,
+    SeriesUsedByModel,
+    _custom_warning,
+    validate_names,
+)
+from pastastore.validator import Validator
+from pastastore.version import PASTAS_GEQ_150
 
-FrameorSeriesUnion = Union[pd.DataFrame, pd.Series]
 warnings.showwarning = _custom_warning
 
+logger = logging.getLogger(__name__)
+
+
+class ConnectorUtil:
+    """Mix-in class for utility methods used by BaseConnector subclasses.
+
+    This class contains internal methods for parsing names, handling metadata,
+    and parsing model dictionaries. It is designed to be mixed into BaseConnector
+    subclasses and assumes the presence of certain attributes and methods from
+    BaseConnector (e.g., oseries_names, stresses_names, get_oseries, get_stresses).
+
+    Note
+    ----
+    This class should not be instantiated directly. It is intended to be used
+    as a mixin with BaseConnector subclasses only.
+    """
+
+    def _parse_names(
+        self,
+        names: list[str] | str | None = None,
+        libname: AllLibs = "oseries",
+    ) -> list:
+        """Parse names kwarg, returns iterable with name(s) (internal method).
+
+        Parameters
+        ----------
+        names : Union[list, str], optional
+            str or list of str or None or 'all' (last two options
+            retrieves all names)
+        libname : str, optional
+            name of library, default is 'oseries'
+
+        Returns
+        -------
+        list
+            list of names
+        """
+        if not isinstance(names, str) and isinstance(names, Iterable):
+            return names
+        elif isinstance(names, str) and names != "all":
+            return [names]
+        elif names is None or names == "all":
+            if libname == "oseries":
+                return self.oseries_names
+            elif libname == "stresses":
+                return self.stresses_names
+            elif libname == "models":
+                return self.model_names
+            elif libname == "oseries_models":
+                return self.oseries_with_models
+            elif libname == "stresses_models":
+                return self.stresses_with_models
+            else:
+                raise ValueError(f"No library '{libname}'!")
+        else:
+            raise NotImplementedError(f"Cannot parse 'names': {names}")
+
+    @staticmethod
+    def _meta_list_to_frame(metalist: list, names: list):
+        """Convert list of metadata dictionaries to DataFrame.
 
-class BaseConnector(ABC):
+        Parameters
+        ----------
+        metalist : list
+            list of metadata dictionaries
+        names : list
+            list of names corresponding to data in metalist
+
+        Returns
+        -------
+        pandas.DataFrame
+            DataFrame containing overview of metadata
+        """
+        # convert to dataframe
+        if len(metalist) > 1:
+            meta = pd.DataFrame(metalist)
+            if len({"x", "y"}.difference(meta.columns)) == 0:
+                meta["x"] = meta["x"].astype(float)
+                meta["y"] = meta["y"].astype(float)
+        elif len(metalist) == 1:
+            meta = pd.DataFrame(metalist)
+        elif len(metalist) == 0:
+            meta = pd.DataFrame()
+
+        meta.index = names
+        meta.index.name = "name"
+        return meta
+
+    def _parse_model_dict(self, mdict: dict, update_ts_settings: bool = False):
+        """Parse dictionary describing pastas models (internal method).
+
+        Parameters
+        ----------
+        mdict : dict
+            dictionary describing pastas.Model
+        update_ts_settings : bool, optional
+            update stored tmin and tmax in time series settings
+            based on time series loaded from store.
+
+        Returns
+        -------
+        ml : pastas.Model
+            time series analysis model
+        """
+        PASFILE_LEQ_022 = parse_version(
+            mdict["file_info"]["pastas_version"]
+        ) <= parse_version("0.22.0")
+
+        # oseries
+        if "series" not in mdict["oseries"]:
+            name = str(mdict["oseries"]["name"])
+            if name not in self.oseries.index:
+                msg = f"oseries '{name}' not present in library"
+                raise LookupError(msg)
+            mdict["oseries"]["series"] = self.get_oseries(name).squeeze()
+            # update tmin/tmax from time series
+            if update_ts_settings:
+                mdict["oseries"]["settings"]["tmin"] = mdict["oseries"]["series"].index[
+                    0
+                ]
+                mdict["oseries"]["settings"]["tmax"] = mdict["oseries"]["series"].index[
+                    -1
+                ]
+
+        # StressModel, WellModel
+        for ts in mdict["stressmodels"].values():
+            if "stress" in ts.keys():
+                # WellModel
+                classkey = "stressmodel" if PASFILE_LEQ_022 else "class"
+                if ts[classkey] == "WellModel":
+                    for stress in ts["stress"]:
+                        if "series" not in stress:
+                            name = str(stress["name"])
+                            if self._item_exists("stresses", name):
+                                stress["series"] = self.get_stresses(name).squeeze()
+                                # update tmin/tmax from time series
+                                if update_ts_settings:
+                                    stress["settings"]["tmin"] = stress["series"].index[
+                                        0
+                                    ]
+                                    stress["settings"]["tmax"] = stress["series"].index[
+                                        -1
+                                    ]
+                # StressModel
+                else:
+                    for stress in ts["stress"] if PASFILE_LEQ_022 else [ts["stress"]]:
+                        if "series" not in stress:
+                            name = str(stress["name"])
+                            if self._item_exists("stresses", name):
+                                stress["series"] = self.get_stresses(name).squeeze()
+                                # update tmin/tmax from time series
+                                if update_ts_settings:
+                                    stress["settings"]["tmin"] = stress["series"].index[
+                                        0
+                                    ]
+                                    stress["settings"]["tmax"] = stress["series"].index[
+                                        -1
+                                    ]
+
+            # RechargeModel, TarsoModel
+            if ("prec" in ts.keys()) and ("evap" in ts.keys()):
+                for stress in [ts["prec"], ts["evap"]]:
+                    if "series" not in stress:
+                        name = str(stress["name"])
+                        if self._item_exists("stresses", name):
+                            stress["series"] = self.get_stresses(name).squeeze()
+                            # update tmin/tmax from time series
+                            if update_ts_settings:
+                                stress["settings"]["tmin"] = stress["series"].index[0]
+                                stress["settings"]["tmax"] = stress["series"].index[-1]
+                        else:
+                            msg = "stress '{name}' not present in library"
+                            raise KeyError(msg)
+
+        # hack for pcov w dtype object (when filled with NaNs on store?)
+        if "fit" in mdict:
+            if "pcov" in mdict["fit"]:
+                pcov = mdict["fit"]["pcov"]
+                if pcov.dtypes.apply(lambda dtyp: isinstance(dtyp, object)).any():
+                    mdict["fit"]["pcov"] = pcov.astype(float)
+
+        # check pastas version vs pas-file version
+        file_version = mdict["file_info"]["pastas_version"]
+
+        # check file version and pastas version
+        # if file<0.23  and pastas>=1.0 --> error
+        PASTAS_GT_023 = parse_version(ps.__version__) > parse_version("0.23.1")
+        if PASFILE_LEQ_022 and PASTAS_GT_023:
+            raise UserWarning(
+                f"This file was created with Pastas v{file_version} "
+                f"and cannot be loaded with Pastas v{ps.__version__} Please load and "
+                "save the file with Pastas 0.23 first to update the file "
+                "format."
+            )
+
+        # Use pastas' internal _load_model - required for model reconstruction
+        ml = ps.io.base._load_model(mdict)  # noqa: SLF001
+        return ml
+
+
+class BaseConnector(ABC, ConnectorUtil):
     """Base Connector class.
 
     Class holds base logic for dealing with time series and Pastas Models. Create your
@@ -33,18 +244,35 @@ class BaseConnector(ABC):
         "stresses",
         "models",
         "oseries_models",
+        "stresses_models",
     ]
 
-    # whether to check model time series contents against stored copies
-    CHECK_MODEL_SERIES_VALUES = True
+    _conn_type: Optional[str] = None
+    _validator: Optional[Validator] = None
+    name = None
+    _added_models = []  # internal list of added models used for updating links
 
-    # whether to validate time series according to pastas rules
-    # True for pastas>=0.23.0 and False for pastas<=0.22.0
-    USE_PASTAS_VALIDATE_SERIES = False if PASTAS_LEQ_022 else True
+    def __getstate__(self):
+        """Replace Manager proxies with simple values for pickling.
 
-    # set series equality comparison settings (using assert_series_equal)
-    SERIES_EQUALITY_ABSOLUTE_TOLERANCE = 1e-10
-    SERIES_EQUALITY_RELATIVE_TOLERANCE = 0.0
+        Manager proxies cannot be pickled, so we convert them to simple booleans.
+        This allows connectors to be pickled for multiprocessing.
+        """
+        state = self.__dict__.copy()
+        # Replace unpicklable Manager proxies with their values
+        state["_oseries_links_need_update"] = self._oseries_links_need_update.value
+        state["_stresses_links_need_update"] = self._stresses_links_need_update.value
+        return state
+
+    def __setstate__(self, state):
+        """Replace Manager proxies with simple booleans after unpickling.
+
+        After unpickling, use simple booleans instead of recreating Manager.
+        This works because worker processes don't need shared memory - they
+        work on independent copies of the connector.
+        """
+        self.__dict__.update(state)
+        # Flags are already simple booleans from __getstate__
 
     def __repr__(self):
         """Representation string of the object."""
@@ -55,13 +283,34 @@ class BaseConnector(ABC):
             f"{self.n_models} models"
         )
 
+    @property
+    def validation_settings(self):
+        """Return current connector settings as dictionary."""
+        return self.validator.settings
+
     @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])
 
+    @property
+    def validator(self) -> Validator:
+        """Get the Validator instance for this connector."""
+        if self._validator is None:
+            raise AttributeError("Validator not set for this connector.")
+        return self._validator
+
+    @property
+    def conn_type(self) -> str:
+        """Get the connector type."""
+        if self._conn_type is None:
+            raise AttributeError(
+                "Connector class must set a connector type in `conn_type` attribute."
+            )
+        return self._conn_type
+
     @abstractmethod
-    def _get_library(self, libname: str):
+    def _get_library(self, libname: AllLibs):
         """Get library handle.
 
         Must be overridden by subclass.
@@ -80,11 +329,10 @@ class BaseConnector(ABC):
     @abstractmethod
     def _add_item(
         self,
-        libname: str,
-        item: Union[FrameorSeriesUnion, Dict],
+        libname: AllLibs,
+        item: Union[FrameOrSeriesUnion, Dict],
         name: str,
         metadata: Optional[Dict] = None,
-        overwrite: bool = False,
     ) -> None:
         """Add item for both time series and pastas.Models (internal method).
 
@@ -100,10 +348,17 @@ class BaseConnector(ABC):
             name of the item
         metadata : dict, optional
             dictionary containing metadata, by default None
+
+        Note
+        ----
+        Metadata storage can vary by connector:
+        - ArcticDB: Native metadata support via write()
+        - DictConnector: Stored as tuple (metadata, item)
+        - PasConnector: Separate {name}_meta.pas JSON file
         """
 
     @abstractmethod
-    def _get_item(self, libname: str, name: str) -> Union[FrameorSeriesUnion, Dict]:
+    def _get_item(self, libname: AllLibs, name: str) -> Union[FrameOrSeriesUnion, Dict]:
         """Get item (series or pastas.Models) (internal method).
 
         Must be overridden by subclass.
@@ -122,7 +377,7 @@ class BaseConnector(ABC):
         """
 
     @abstractmethod
-    def _del_item(self, libname: str, name: str) -> None:
+    def _del_item(self, libname: AllLibs, name: str, force: bool = False) -> None:
         """Delete items (series or models) (internal method).
 
         Must be overridden by subclass.
@@ -136,7 +391,7 @@ class BaseConnector(ABC):
         """
 
     @abstractmethod
-    def _get_metadata(self, libname: str, name: str) -> Dict:
+    def _get_metadata(self, libname: TimeSeriesLibs, name: str) -> Dict:
         """Get metadata (internal method).
 
         Must be overridden by subclass.
@@ -154,35 +409,62 @@ class BaseConnector(ABC):
             dictionary containing metadata
         """
 
-    @property
     @abstractmethod
+    def _list_symbols(self, libname: AllLibs) -> List[str]:
+        """Return list of symbol names in library."""
+
+    @abstractmethod
+    def _item_exists(self, libname: AllLibs, name: str) -> bool:
+        """Return True if item present in library, else False."""
+
+    @property
     def oseries_names(self):
         """List of oseries names.
 
         Property must be overridden by subclass.
         """
+        return self._list_symbols("oseries")
 
     @property
-    @abstractmethod
     def stresses_names(self):
         """List of stresses names.
 
         Property must be overridden by subclass.
         """
+        return self._list_symbols("stresses")
 
     @property
-    @abstractmethod
     def model_names(self):
         """List of model names.
 
         Property must be overridden by subclass.
         """
+        return self._modelnames_cache
+
+    @property
+    def oseries_with_models(self):
+        """List of oseries used in models.
+
+        Property must be overridden by subclass.
+        """
+        self._trigger_links_update_if_needed()
+        return self._list_symbols("oseries_models")
+
+    @property
+    def stresses_with_models(self):
+        """List of stresses used in models.
+
+        Property must be overridden by subclass.
+        """
+        self._trigger_links_update_if_needed()
+        return self._list_symbols("stresses_models")
 
     @abstractmethod
     def _parallel(
         self,
         func: Callable,
         names: List[str],
+        kwargs: Optional[Dict] = None,
         progressbar: Optional[bool] = True,
         max_workers: Optional[int] = None,
         chunksize: Optional[int] = None,
@@ -198,6 +480,8 @@ class BaseConnector(ABC):
             function to apply in parallel
         names : list
             list of names to apply function to
+        kwargs : dict
+            additional keyword arguments to pass to function
         progressbar : bool, optional
             show progressbar, by default True
         max_workers : int, optional
@@ -208,72 +492,122 @@ class BaseConnector(ABC):
             description for progressbar, by default ""
         """
 
-    def set_check_model_series_values(self, b: bool):
-        """Turn CHECK_MODEL_SERIES_VALUES option on (True) or off (False).
+    def parse_names(
+        self,
+        names: list[str] | str | None = None,
+        libname: AllLibs = "oseries",
+    ) -> list:
+        """Parse names argument and return list of names.
 
-        The default option is on (it is highly recommended to keep it that
-        way). When turned on, the model time series
-        (ml.oseries._series_original, and stressmodel.stress._series_original)
-        values are checked against the stored copies in the database. If these
-        do not match, an error is raised, and the model is not added to the
-        database. This guarantees the stored model will be identical after
-        loading from the database. This check is somewhat computationally
-        expensive, which is why it can be turned on or off.
+        Public method that exposes name parsing functionality.
 
         Parameters
         ----------
-        b : bool
-            boolean indicating whether option should be turned on (True) or
-            off (False). Option is on by default.
+        names : Union[list, str], optional
+            str or list of str or None or 'all' (last two options
+            retrieves all names)
+        libname : str, optional
+            name of library, default is 'oseries'
+
+        Returns
+        -------
+        list
+            list of names
         """
-        self.CHECK_MODEL_SERIES_VALUES = b
-        print(f"Model time series checking set to: {b}.")
+        return self._parse_names(names, libname)
 
-    def set_use_pastas_validate_series(self, b: bool):
-        """Turn USE_PASTAS_VALIDATE_SERIES option on (True) or off (False).
+    @property  # type: ignore
+    @functools.lru_cache()
+    def oseries(self):
+        """Dataframe with overview of oseries."""
+        return self.get_metadata("oseries", self.oseries_names)
 
-        This will use pastas.validate_oseries() or pastas.validate_stresses()
-        to test the time series. If they do not meet the criteria, an error is
-        raised. Turning this option off will allow the user to store any time
-        series but this will mean that time series models cannot be made from
-        stored time series directly and will have to be modified before
-        building the models. This in turn will mean that storing the models
-        will not work as the stored time series copy is checked against the
-        time series in the model to check if they are equal.
+    @property  # type: ignore
+    @functools.lru_cache()
+    def stresses(self):
+        """Dataframe with overview of stresses."""
+        return self.get_metadata("stresses", self.stresses_names)
 
-        Note: this option requires pastas>=0.23.0, otherwise it is turned off.
+    @property  # type: ignore
+    @functools.lru_cache()
+    def _modelnames_cache(self):
+        """List of model names."""
+        return self._list_symbols("models")
 
-        Parameters
-        ----------
-        b : bool
-            boolean indicating whether option should be turned on (True) or
-            off (False). Option is on by default.
+    @property
+    def n_oseries(self):
         """
-        self.USE_PASTAS_VALIDATE_SERIES = b
-        print(f"Model time series checking set to: {b}.")
+        Returns the number of oseries.
 
-    def _pastas_validate(self, validate):
-        """Whether to validate time series.
+        Returns
+        -------
+        int
+            The number of oseries names.
+        """
+        return len(self.oseries_names)
 
-        Parameters
-        ----------
-        validate : bool, NoneType
-            value of validate keyword argument
+    @property
+    def n_stresses(self):
+        """
+        Returns the number of stresses.
 
         Returns
         -------
-        b : bool
-            return global or local setting (True or False)
+        int
+            The number of stresses.
         """
-        if validate is None:
-            return self.USE_PASTAS_VALIDATE_SERIES
-        else:
-            return validate
+        return len(self.stresses_names)
+
+    @property
+    def n_models(self):
+        """
+        Returns the number of models in the store.
+
+        Returns
+        -------
+            int
+                The number of models in the store.
+        """
+        return len(self.model_names)
+
+    @property  # type: ignore
+    @functools.lru_cache()
+    def oseries_models(self):
+        """List of model names per oseries.
+
+        Returns
+        -------
+        d : dict
+            dictionary with oseries names as keys and list of model names as
+            values
+        """
+        self._trigger_links_update_if_needed()
+        d = {}
+        for onam in self.oseries_with_models:
+            d[onam] = self._get_item("oseries_models", onam)
+        return d
+
+    @property  # type: ignore
+    @functools.lru_cache()
+    def stresses_models(self):
+        """List of model names per stress.
+
+        Returns
+        -------
+        d : dict
+            dictionary with stress names as keys and list of model names as
+            values
+        """
+        self._trigger_links_update_if_needed()
+        d = {}
+        for stress_name in self.stresses_with_models:
+            d[stress_name] = self._get_item("stresses_models", stress_name)
+        return d
 
     def _add_series(
         self,
-        libname: str,
-        series: FrameorSeriesUnion,
+        libname: TimeSeriesLibs,
+        series: FrameOrSeriesUnion,
         name: str,
         metadata: Optional[dict] = None,
         validate: Optional[bool] = None,
@@ -305,9 +639,11 @@ class BaseConnector(ABC):
         """
         if not isinstance(name, str):
             name = str(name)
-        self._validate_input_series(series)
-        series = self._set_series_name(series, name)
-        if self._pastas_validate(validate):
+        if metadata:
+            self.validator.validate_metadata(metadata)
+        self.validator.validate_input_series(series)
+        series = self.validator.set_series_name(series, name)
+        if self.validator.pastas_validation_status(validate):
             if libname == "oseries":
                 if PASTAS_GEQ_150 and not ps.validate_oseries(series):
                     raise ValueError(
@@ -326,10 +662,16 @@ class BaseConnector(ABC):
                     ps.validate_stress(series)
         in_store = getattr(self, f"{libname}_names")
         if name not in in_store or overwrite:
-            self._add_item(
-                libname, series, name, metadata=metadata, overwrite=overwrite
-            )
+            self._add_item(libname, series, name, metadata=metadata)
             self._clear_cache(libname)
+        elif (libname == "oseries" and self._item_exists("oseries_models", name)) or (
+            libname == "stresses" and self._item_exists("stresses_model", name)
+        ):
+            raise SeriesUsedByModel(
+                f"Time series with name '{name}' is used by a model! "
+                "Use overwrite=True to replace existing time series. "
+                "Note that this may modify the model!"
+            )
         else:
             raise ItemInLibraryException(
                 f"Time series with name '{name}' already in '{libname}' library! "
@@ -338,11 +680,12 @@ class BaseConnector(ABC):
 
     def _update_series(
         self,
-        libname: str,
-        series: FrameorSeriesUnion,
+        libname: TimeSeriesLibs,
+        series: FrameOrSeriesUnion,
         name: str,
         metadata: Optional[dict] = None,
         validate: Optional[bool] = None,
+        force: bool = False,
     ) -> None:
         """Update time series (internal method).
 
@@ -360,11 +703,16 @@ class BaseConnector(ABC):
         validate: bool, optional
             use pastas to validate series, default is None, which will use the
             USE_PASTAS_VALIDATE_SERIES value (default is True).
+        force : bool, optional
+            force update even if time series is used in a model, by default False
+
         """
         if libname not in ["oseries", "stresses"]:
             raise ValueError("Library must be 'oseries' or 'stresses'!")
-        self._validate_input_series(series)
-        series = self._set_series_name(series, name)
+        if not force:
+            self.validator.check_series_in_models(libname, name)
+        self.validator.validate_input_series(series)
+        series = self.validator.set_series_name(series, name)
         stored = self._get_series(libname, name, progressbar=False)
         if self.conn_type == "pas" and not isinstance(series, type(stored)):
             if isinstance(series, pd.DataFrame):
@@ -389,11 +737,12 @@ class BaseConnector(ABC):
 
     def _upsert_series(
         self,
-        libname: str,
-        series: FrameorSeriesUnion,
+        libname: TimeSeriesLibs,
+        series: FrameOrSeriesUnion,
         name: str,
         metadata: Optional[dict] = None,
         validate: Optional[bool] = None,
+        force: bool = False,
     ) -> None:
         """Update or insert series depending on whether it exists in store.
 
@@ -410,19 +759,23 @@ class BaseConnector(ABC):
         validate : bool, optional
             use pastas to validate series, default is None, which will use the
             USE_PASTAS_VALIDATE_SERIES value (default is True).
+        force : bool, optional
+            force update even if time series is used in a model, by default False
         """
         if libname not in ["oseries", "stresses"]:
             raise ValueError("Library must be 'oseries' or 'stresses'!")
         if name in getattr(self, f"{libname}_names"):
             self._update_series(
-                libname, series, name, metadata=metadata, validate=validate
+                libname, series, name, metadata=metadata, validate=validate, force=force
             )
         else:
             self._add_series(
                 libname, series, name, metadata=metadata, validate=validate
             )
 
-    def update_metadata(self, libname: str, name: str, metadata: dict) -> None:
+    def update_metadata(
+        self, libname: TimeSeriesLibs, name: str, metadata: dict
+    ) -> None:
         """Update metadata.
 
         Note: also retrieves and stores time series as updating only metadata
@@ -449,7 +802,7 @@ class BaseConnector(ABC):
 
     def add_oseries(
         self,
-        series: FrameorSeriesUnion,
+        series: FrameOrSeriesUnion,
         name: str,
         metadata: Optional[dict] = None,
         validate: Optional[bool] = None,
@@ -472,7 +825,6 @@ class BaseConnector(ABC):
             overwrite existing dataset with the same name,
             by default False
         """
-        series, metadata = self._parse_series_input(series, metadata)
         self._add_series(
             "oseries",
             series,
@@ -484,7 +836,7 @@ class BaseConnector(ABC):
 
     def add_stress(
         self,
-        series: FrameorSeriesUnion,
+        series: FrameOrSeriesUnion,
         name: str,
         kind: str,
         metadata: Optional[dict] = None,
@@ -511,7 +863,6 @@ class BaseConnector(ABC):
             overwrite existing dataset with the same name,
             by default False
         """
-        series, metadata = self._parse_series_input(series, metadata)
         if metadata is None:
             metadata = {}
         metadata["kind"] = kind
@@ -563,58 +914,98 @@ class BaseConnector(ABC):
             raise TypeError("Expected pastas.Model or dict!")
         if not isinstance(name, str):
             name = str(name)
-        if name not in self.model_names or overwrite:
+        if not self._item_exists("models", name) or overwrite:
             # check if stressmodels supported
-            self._check_stressmodels_supported(ml)
-            # check if oseries and stresses exist in store
-            self._check_model_series_names_for_store(ml)
-            self._check_oseries_in_store(ml)
-            self._check_stresses_in_store(ml)
+            self.validator.check_stressmodels_supported(ml)
+            # check oseries and stresses names and if they exist in store
+            self.validator.check_model_series_names_duplicates(ml)
+            self.validator.check_oseries_in_store(ml)
+            self.validator.check_stresses_in_store(ml)
             # write model to store
-            self._add_item(
-                "models", mldict, name, metadata=metadata, overwrite=overwrite
-            )
+            self._add_item("models", mldict, name, metadata=metadata)
+            self._clear_cache("_modelnames_cache")
+            # avoid updating links so parallel operations do not simultaneously
+            # access the same object. Indicate that these links need updating and
+            # clear existing caches. Handle both Manager proxies and booleans
+            if hasattr(self._oseries_links_need_update, "value"):
+                self._oseries_links_need_update.value = True
+                self._stresses_links_need_update.value = True
+                # this won't update main instance in parallel
+                self._added_models.append(name)
+            else:
+                self._oseries_links_need_update = True
+                self._stresses_links_need_update = True
+                self._added_models.append(name)
+            self._clear_cache("oseries_models")
+            self._clear_cache("stresses_models")
         else:
             raise ItemInLibraryException(
                 f"Model with name '{name}' already in 'models' library! "
                 "Use overwrite=True to replace existing model."
             )
-        self._clear_cache("_modelnames_cache")
-        self._add_oseries_model_links(str(mldict["oseries"]["name"]), name)
 
-    @staticmethod
-    def _parse_series_input(
-        series: FrameorSeriesUnion,
-        metadata: Optional[Dict] = None,
-    ) -> Tuple[FrameorSeriesUnion, Optional[Dict]]:
-        """Parse series input (internal method).
+    def _update_series(
+        self,
+        libname: str,
+        series: FrameOrSeriesUnion,
+        name: str,
+        metadata: Optional[dict] = None,
+        validate: Optional[bool] = None,
+        force: bool = False,
+    ) -> None:
+        """Update time series (internal method).
 
         Parameters
         ----------
-        series : FrameorSeriesUnion,
-            series object to parse
-        metadata : dict, optional
-            metadata dictionary or None, by default None
-
-        Returns
-        -------
-        series, metadata : FrameorSeriesUnion, Optional[Dict]
-            time series as pandas.Series or DataFrame and optionally
-            metadata dictionary
+        libname : str
+            name of library
+        series : FrameorSeriesUnion
+            time series containing update values
+        name : str
+            name of the time series to update
+        metadata : Optional[dict], optional
+            optionally provide metadata dictionary which will also update
+            the current stored metadata dictionary, by default None
+        validate: bool, optional
+            use pastas to validate series, default is None, which will use the
+            USE_PASTAS_VALIDATE_SERIES value (default is True).
+        force : bool, optional
+           force update even if time series is used in a model, by default False
         """
-        if isinstance(series, ps.timeseries.TimeSeries):
-            raise DeprecationWarning(
-                "Pastas TimeSeries objects are no longer supported!"
-            )
-        s = series
-        m = metadata
-        return s, m
+        if libname not in ["oseries", "stresses"]:
+            raise ValueError("Library must be 'oseries' or 'stresses'!")
+        if not force:
+            self.validator.check_series_in_models(libname, name)
+        self.validator.validate_input_series(series)
+        series = self.validator.set_series_name(series, name)
+        stored = self._get_series(libname, name, progressbar=False)
+        if self.conn_type == "pas" and not isinstance(series, type(stored)):
+            if isinstance(series, pd.DataFrame):
+                stored = stored.to_frame()
+        # get union of index
+        idx_union = stored.index.union(series.index)
+        # update series with new values
+        update = stored.reindex(idx_union)
+        update.update(series)
+        # metadata
+        update_meta = self._get_metadata(libname, name)
+        if metadata is not None:
+            update_meta.update(metadata)
+        self._add_series(
+            libname,
+            update,
+            name,
+            metadata=update_meta,
+            validate=validate,
+            overwrite=True,
+        )
 
     def update_oseries(
         self,
-        series: FrameorSeriesUnion,
+        series: FrameOrSeriesUnion,
         name: str,
         metadata: Optional[dict] = None,
+        force: bool = False,
     ) -> None:
         """Update oseries values.
 
@@ -627,61 +1018,67 @@ class BaseConnector(ABC):
         metadata : Optional[dict], optional
             optionally provide metadata, which will update
             the stored metadata dictionary, by default None
+        force : bool, optional
+            force update even if time series is used in a model, by default False
         """
-        series, metadata = self._parse_series_input(series, metadata)
-        self._update_series("oseries", series, name, metadata=metadata)
+        self._update_series("oseries", series, name, metadata=metadata, force=force)
 
-    def upsert_oseries(
+    def update_stress(
         self,
-        series: FrameorSeriesUnion,
+        series: FrameOrSeriesUnion,
         name: str,
         metadata: Optional[dict] = None,
+        force: bool = False,
     ) -> None:
-        """Update or insert oseries values depending on whether it exists.
+        """Update stresses values.
+
+        Note: the 'kind' attribute of a stress cannot be updated! To update
+        the 'kind' delete and add the stress again.
 
         Parameters
         ----------
         series : FrameorSeriesUnion
-            time series to update/insert
+            time series to update stored stress with
         name : str
-            name of the oseries
+            name of the stress to update
         metadata : Optional[dict], optional
             optionally provide metadata, which will update
-            the stored metadata dictionary if it exists, by default None
+            the stored metadata dictionary, by default None
+        force : bool, optional
+            force update even if time series is used in a model, by default False
         """
-        series, metadata = self._parse_series_input(series, metadata)
-        self._upsert_series("oseries", series, name, metadata=metadata)
+        self._update_series("stresses", series, name, metadata=metadata, force=force)
 
-    def update_stress(
+    def upsert_oseries(
         self,
-        series: FrameorSeriesUnion,
+        series: FrameOrSeriesUnion,
         name: str,
         metadata: Optional[dict] = None,
+        force: bool = False,
     ) -> None:
-        """Update stresses values.
-
-        Note: the 'kind' attribute of a stress cannot be updated! To update
-        the 'kind' delete and add the stress again.
+        """Update or insert oseries values depending on whether it exists.
 
         Parameters
         ----------
         series : FrameorSeriesUnion
-            time series to update stored stress with
+            time series to update/insert
         name : str
-            name of the stress to update
+            name of the oseries
         metadata : Optional[dict], optional
             optionally provide metadata, which will update
-            the stored metadata dictionary, by default None
+            the stored metadata dictionary if it exists, by default None
+        force : bool, optional
+            force update even if time series is used in a model, by default False
         """
-        series, metadata = self._parse_series_input(series, metadata)
-        self._update_series("stresses", series, name, metadata=metadata)
+        self._upsert_series("oseries", series, name, metadata=metadata, force=force)
 
     def upsert_stress(
         self,
-        series: FrameorSeriesUnion,
+        series: FrameOrSeriesUnion,
         name: str,
         kind: str,
         metadata: Optional[dict] = None,
+        force: bool = False,
     ) -> None:
         """Update or insert stress values depending on whether it exists.
 
@@ -694,12 +1091,16 @@ class BaseConnector(ABC):
         metadata : Optional[dict], optional
             optionally provide metadata, which will update
             the stored metadata dictionary if it exists, by default None
+        kind : str
+            category to identify type of stress, this label is added to the
+            metadata dictionary.
+        force : bool, optional
+            force update even if time series is used in a model, by default False
         """
-        series, metadata = self._parse_series_input(series, metadata)
         if metadata is None:
             metadata = {}
         metadata["kind"] = kind
-        self._upsert_series("stresses", series, name, metadata=metadata)
+        self._upsert_series("stresses", series, name, metadata=metadata, force=force)
 
     def del_models(self, names: Union[list, str], verbose: bool = True) -> None:
         """Delete model(s) from the database.
@@ -716,10 +1117,15 @@ class BaseConnector(ABC):
             mldict = self.get_models(n, return_dict=True)
             oname = mldict["oseries"]["name"]
             self._del_item("models", n)
-            self._del_oseries_model_link(oname, n)
+            # delete reference to added model if present
+            if n in self._added_models:
+                self._added_models.remove(n)
+            else:
+                self._del_oseries_model_link(oname, n)
+                self._del_stress_model_link(self._get_model_stress_names(mldict), n)
         self._clear_cache("_modelnames_cache")
         if verbose:
-            print(f"Deleted {len(names)} model(s) from database.")
+            logger.info("Deleted %d model(s) from database.", len(names))
 
     def del_model(self, names: Union[list, str], verbose: bool = True) -> None:
         """Delete model(s) from the database.
@@ -736,7 +1142,11 @@ class BaseConnector(ABC):
         self.del_models(names=names, verbose=verbose)
 
     def del_oseries(
-        self, names: Union[list, str], remove_models: bool = False, verbose: bool = True
+        self,
+        names: Union[list, str],
+        remove_models: bool = False,
+        force: bool = False,
+        verbose: bool = True,
     ):
         """Delete oseries from the database.
 
@@ -746,38 +1156,60 @@ class BaseConnector(ABC):
             name(s) of the oseries to delete
         remove_models : bool, optional
             also delete models for deleted oseries, default is False
+        force : bool, optional
+            force deletion of oseries that are used in models, by default False
         verbose : bool, optional
             print information about deleted oseries, by default True
         """
         names = self._parse_names(names, libname="oseries")
         for n in names:
-            self._del_item("oseries", n)
+            self._del_item("oseries", n, force=force)
         self._clear_cache("oseries")
         if verbose:
-            print(f"Deleted {len(names)} oseries from database.")
+            logger.info("Deleted %d oseries from database.", len(names))
         # remove associated models from database
         if remove_models:
             modelnames = list(
                 chain.from_iterable([self.oseries_models.get(n, []) for n in names])
             )
             self.del_models(modelnames, verbose=verbose)
+            if verbose:
+                logger.info("Deleted %d model(s) from database.", len(modelnames))
 
-    def del_stress(self, names: Union[list, str], verbose: bool = True):
+    def del_stress(
+        self,
+        names: Union[list, str],
+        remove_models: bool = False,
+        force: bool = False,
+        verbose: bool = True,
+    ):
         """Delete stress from the database.
 
         Parameters
         ----------
         names : str or list of str
             name(s) of the stress to delete
+        remove_models : bool, optional
+            also delete models for deleted stresses, default is False
+        force : bool, optional
+            force deletion of stresses that are used in models, by default False
         verbose : bool, optional
             print information about deleted stresses, by default True
         """
         names = self._parse_names(names, libname="stresses")
         for n in names:
-            self._del_item("stresses", n)
+            self._del_item("stresses", n, force=force)
         self._clear_cache("stresses")
         if verbose:
-            print(f"Deleted {len(names)} stress(es) from database.")
+            logger.info("Deleted %d stress(es) from database.", len(names))
+        # remove associated models from database
+        if remove_models:
+            modelnames = list(
+                chain.from_iterable([self.stresses_models.get(n, []) for n in names])
+            )
+            self.del_models(modelnames, verbose=verbose)
+            if verbose:
+                logger.info("Deleted %d model(s) from database.", len(modelnames))
 
     def _get_series(
         self,
@@ -785,7 +1217,7 @@ class BaseConnector(ABC):
         names: Union[list, str],
         progressbar: bool = True,
         squeeze: bool = True,
-    ) -> FrameorSeriesUnion:
+    ) -> FrameOrSeriesUnion:
         """Get time series (internal method).
 
         Parameters
@@ -809,6 +1241,7 @@ class BaseConnector(ABC):
         ts = {}
         names = self._parse_names(names, libname=libname)
         desc = f"Get {libname}"
+        n = None
         for n in tqdm(names, desc=desc) if progressbar else names:
             ts[n] = self._get_item(libname, n)
         # return frame if len == 1
@@ -865,7 +1298,7 @@ class BaseConnector(ABC):
         return_metadata: bool = False,
         progressbar: bool = False,
         squeeze: bool = True,
-    ) -> Union[Union[FrameorSeriesUnion, Dict], Optional[Union[Dict, List]]]:
+    ) -> Union[Union[FrameOrSeriesUnion, Dict], Optional[Union[Dict, List]]]:
         """Get oseries from database.
 
         Parameters
@@ -910,7 +1343,7 @@ class BaseConnector(ABC):
         return_metadata: bool = False,
         progressbar: bool = False,
         squeeze: bool = True,
-    ) -> Union[Union[FrameorSeriesUnion, Dict], Optional[Union[Dict, List]]]:
+    ) -> Union[Union[FrameOrSeriesUnion, Dict], Optional[Union[Dict, List]]]:
         """Get stresses from database.
 
         Parameters
@@ -955,7 +1388,7 @@ class BaseConnector(ABC):
         return_metadata: bool = False,
         progressbar: bool = False,
         squeeze: bool = True,
-    ) -> Union[Union[FrameorSeriesUnion, Dict], Optional[Union[Dict, List]]]:
+    ) -> Union[Union[FrameOrSeriesUnion, Dict], Optional[Union[Dict, List]]]:
         """Get stresses from database.
 
         Alias for `get_stresses()`
@@ -1078,7 +1511,7 @@ class BaseConnector(ABC):
         )
 
     def empty_library(
-        self, libname: str, prompt: bool = True, progressbar: bool = True
+        self, libname: AllLibs, prompt: bool = True, progressbar: bool = True
     ):
         """Empty library of all its contents.
 
@@ -1101,8 +1534,8 @@ class BaseConnector(ABC):
                 return
 
         if libname == "models":
-            # also delete linked modelnames linked to oseries
-            libs = ["models", "oseries_models"]
+            # also delete linked modelnames linked to oseries and stresses
+            libs = ["models", "oseries_models", "stresses_models"]
         else:
             libs = [libname]
 
@@ -1114,11 +1547,13 @@ class BaseConnector(ABC):
                 if progressbar
                 else names
             ):
-                self._del_item(libname, name)
+                self._del_item(libname, name, force=True)
             self._clear_cache(libname)
-            print(f"Emptied library {libname} in {self.name}: {self.__class__}")
+            logger.info(
+                "Emptied library %s in %s: %s", libname, self.name, self.__class__
+            )
 
-    def _iter_series(self, libname: str, names: Optional[List[str]] = None):
+    def _iter_series(self, libname: TimeSeriesLibs, names: Optional[List[str]] = None):
         """Iterate over time series in library (internal method).
 
         Parameters
@@ -1196,33 +1631,76 @@ class BaseConnector(ABC):
         for mlnam in modelnames:
             yield self.get_models(mlnam, return_dict=return_dict, progressbar=False)
 
-    def _add_oseries_model_links(self, onam: str, mlnames: Union[str, List[str]]):
+    def _add_oseries_model_links(
+        self,
+        oseries_name: str,
+        model_names: Union[str, List[str]],
+        _clear_cache: bool = True,
+    ):
         """Add model name to stored list of models per oseries.
 
         Parameters
         ----------
-        onam : str
+        oseries_name : str
             name of oseries
-        mlnames : Union[str, List[str]]
+        model_names : Union[str, List[str]]
             model name or list of model names for an oseries with name
-            onam.
+            oseries_name.
+        _clear_cache : bool, optional
+            whether to clear the cache after adding, by default True.
+            Set to False during bulk operations to improve performance.
         """
         # get stored list of model names
-        if str(onam) in self.oseries_with_models:
-            modellist = self._get_item("oseries_models", onam)
+        if self._item_exists("oseries_models", oseries_name):
+            modellist = self._get_item("oseries_models", oseries_name)
         else:
             # else empty list
             modellist = []
         # if one model name, make list for loop
-        if isinstance(mlnames, str):
-            mlnames = [mlnames]
+        if isinstance(model_names, str):
+            model_names = [model_names]
         # loop over model names
-        for iml in mlnames:
+        for iml in model_names:
             # if not present, add to list
             if iml not in modellist:
                 modellist.append(iml)
-        self._add_item("oseries_models", modellist, onam, overwrite=True)
-        self._clear_cache("oseries_models")
+        self._add_item("oseries_models", modellist, oseries_name)
+        if _clear_cache:
+            self._clear_cache("oseries_models")
+
+    def _add_stresses_model_links(
+        self, stress_names, model_names, _clear_cache: bool = True
+    ):
+        """Add model name to stored list of models per stress.
+
+        Parameters
+        ----------
+        stress_names : list of str
+            names of stresses
+        model_names : Union[str, List[str]]
+            model name or list of model names for a stress with name
+        _clear_cache : bool, optional
+            whether to clear the cache after adding, by default True.
+            Set to False during bulk operations to improve performance.
+        """
+        # if one model name, make list for loop
+        if isinstance(model_names, str):
+            model_names = [model_names]
+        for snam in stress_names:
+            # get stored list of model names
+            if self._item_exists("stresses_models", str(snam)):
+                modellist = self._get_item("stresses_models", snam)
+            else:
+                # else empty list
+                modellist = []
+            # loop over model names
+            for iml in model_names:
+                # if not present, add to list
+                if iml not in modellist:
+                    modellist.append(iml)
+            self._add_item("stresses_models", modellist, snam)
+        if _clear_cache:
+            self._clear_cache("stresses_models")
 
     def _del_oseries_model_link(self, onam, mlnam):
         """Delete model name from stored list of models per oseries.
@@ -1239,128 +1717,255 @@ class BaseConnector(ABC):
         if len(modellist) == 0:
             self._del_item("oseries_models", onam)
         else:
-            self._add_item("oseries_models", modellist, onam, overwrite=True)
+            self._add_item("oseries_models", modellist, onam)
         self._clear_cache("oseries_models")
 
-    def _update_all_oseries_model_links(self):
-        """Add all model names to oseries metadata dictionaries.
+    def _del_stress_model_link(self, stress_names, model_name):
+        """Delete model name from stored list of models per stress.
+
+        Parameters
+        ----------
+        stress_names : list of str
+            List of stress names for which to remove the model link.
+        model_name : str
+            Name of the model to remove from the stress links.
+        """
+        for stress_name in stress_names:
+            modellist = self._get_item("stresses_models", stress_name)
+            modellist.remove(model_name)
+            if len(modellist) == 0:
+                self._del_item("stresses_models", stress_name)
+            else:
+                self._add_item("stresses_models", modellist, stress_name)
+        self._clear_cache("stresses_models")
 
-        Used for old PastaStore versions, where relationship between oseries and models
-        was not stored. If there are any models in the database and if the
-        oseries_models library is empty, loops through all models to determine which
-        oseries each model belongs to.
+    def _update_time_series_model_links(
+        self,
+        libraries: list[str] = None,
+        modelnames: Optional[List[str]] = None,
+        recompute: bool = True,
+        progressbar: bool = False,
+    ):
+        """Add all model names to reverse lookup time series dictionaries.
+
+        Used for old PastaStore versions, where relationship between time series and
+        models was not stored. If there are any models in the database and if the
+        oseries_models or stresses_models libraries are empty, loop through all models
+        to determine which time series are used in each model.
+
+        Parameters
+        ----------
+        libraries : list of str, optional
+            list of time series libraries to update model links for,
+            by default None which will update both 'oseries' and 'stresses'
+        modelnames : Optional[List[str]], optional
+            list of model names to update links for, by default None
+        recompute : bool, optional
+            Indicate operation is an update/recompute of existing links,
+            by default False
+        progressbar : bool, optional
+            show progressbar, by default True
         """
-        # get oseries_models library if there are any contents, if empty
-        # add all model links.
+        # get oseries_models and stresses_models libraries,
+        # if empty add all time series -> model links.
+        if libraries is None:
+            libraries = ["oseries", "stresses"]
         if self.n_models > 0:
-            if len(self.oseries_models) == 0:
-                links = self._get_all_oseries_model_links()
-                for onam, mllinks in tqdm(
-                    links.items(),
-                    desc="Store models per oseries",
-                    total=len(links),
+            logger.debug("Updating time series -> models links in store.")
+            links = self._get_time_series_model_links(
+                modelnames=modelnames, recompute=recompute, progressbar=progressbar
+            )
+            for k in libraries:
+                if recompute:
+                    desc = f"Updating {k}-models links"
+                else:
+                    desc = f"Storing {k}-models links"
+                for name, model_links in tqdm(
+                    links[k].items(),
+                    desc=desc,
+                    total=len(links[k]),
+                    disable=not progressbar,
                 ):
-                    self._add_oseries_model_links(onam, mllinks)
+                    if k == "oseries":
+                        self._add_oseries_model_links(
+                            name, model_links, _clear_cache=False
+                        )
+                    elif k == "stresses":
+                        self._add_stresses_model_links(
+                            [name], model_links, _clear_cache=False
+                        )
+        # Clear caches after all updates are complete
+        if "oseries" in libraries:
+            self._clear_cache("oseries_models")
+        if "stresses" in libraries:
+            self._clear_cache("stresses_models")
+
+    def _trigger_links_update_if_needed(
+        self, modelnames: Optional[list[str]] = None, progressbar: bool = False
+    ):
+        # Check if time series-> model links need updating
+        # Handle both Manager proxies (main) and booleans (worker after pickle)
+        needs_update = (
+            self._oseries_links_need_update.value
+            if hasattr(self._oseries_links_need_update, "value")
+            else self._oseries_links_need_update
+        )
+        if needs_update:
+            self._clear_cache("_modelnames_cache")
+            # Set BOTH flags to False BEFORE updating to prevent recursion
+            # (update always recomputes both oseries and stresses links)
+            if hasattr(self._oseries_links_need_update, "value"):
+                self._oseries_links_need_update.value = False
+                self._stresses_links_need_update.value = False
+            else:
+                self._oseries_links_need_update = False
+                self._stresses_links_need_update = False
+                modelnames = self._added_models
+            if modelnames is None or len(modelnames) > 0:
+                self._update_time_series_model_links(
+                    modelnames=modelnames, recompute=True, progressbar=progressbar
+                )
+            self._added_models = []  # reset list of added models
+        else:
+            self._added_models = []  # reset list of added models
 
-    def _get_all_oseries_model_links(self):
-        """Get all model names per oseries in dictionary.
+    def _get_time_series_model_links(
+        self,
+        modelnames: Optional[list[str]] = None,
+        recompute: bool = False,
+        progressbar: bool = True,
+    ) -> dict:
+        """Get model names per oseries and stresses time series in a dictionary.
 
         Returns
         -------
         links : dict
-            dictionary with oseries names as keys and lists of model names as
-            values
+            dictionary with 'oseries' and 'stresses' as keys containing
+            dictionaries with time series names as keys and lists of model
+            names as values.
         """
-        links = {}
+        oseries_links = {}
+        stresses_links = {}
         for mldict in tqdm(
-            self.iter_models(return_dict=True),
+            self.iter_models(modelnames=modelnames, return_dict=True),
             total=self.n_models,
-            desc="Get models per oseries",
+            desc=f"{'Recompute' if recompute else 'Get'} models per time series",
+            disable=not progressbar,
         ):
-            onam = mldict["oseries"]["name"]
             mlnam = mldict["name"]
-            if onam in links:
-                links[onam].append(mlnam)
+            # oseries
+            onam = mldict["oseries"]["name"]
+            if onam in oseries_links:
+                oseries_links[onam].append(mlnam)
             else:
-                links[onam] = [mlnam]
-        return links
-
-    @staticmethod
-    def _clear_cache(libname: str) -> None:
-        """Clear cached property."""
-        if libname == "models":
-            libname = "_modelnames_cache"
-        getattr(BaseConnector, libname).fget.cache_clear()
-
-    @property  # type: ignore
-    @functools.lru_cache()
-    def oseries(self):
-        """Dataframe with overview of oseries."""
-        return self.get_metadata("oseries", self.oseries_names)
-
-    @property  # type: ignore
-    @functools.lru_cache()
-    def stresses(self):
-        """Dataframe with overview of stresses."""
-        return self.get_metadata("stresses", self.stresses_names)
-
-    @property  # type: ignore
-    @functools.lru_cache()
-    def _modelnames_cache(self):
-        """List of model names."""
-        return self.model_names
-
-    @property
-    def n_oseries(self):
-        """
-        Returns the number of oseries.
+                oseries_links[onam] = [mlnam]
+            # stresses
+            stress_names = self._get_model_stress_names(mldict)
+            for snam in stress_names:
+                if snam in stresses_links:
+                    stresses_links[snam].append(mlnam)
+                else:
+                    stresses_links[snam] = [mlnam]
+        return {"oseries": oseries_links, "stresses": stresses_links}
 
-        Returns
-        -------
-        int
-            The number of oseries names.
-        """
-        return len(self.oseries_names)
+    def _get_model_stress_names(self, ml: ps.Model | dict) -> List[str]:
+        """Get list of stress names used in model.
 
-    @property
-    def n_stresses(self):
-        """
-        Returns the number of stresses.
+        Parameters
+        ----------
+        ml : pastas.Model or dict
+            model to get stress names from
 
         Returns
         -------
-        int
-            The number of stresses.
+        list of str
+            list of stress names used in model
         """
-        return len(self.stresses_names)
+        stresses = []
+        if isinstance(ml, dict):
+            for sm in ml["stressmodels"].values():
+                class_key = "class"
+                if sm[class_key] == "RechargeModel":
+                    stresses.append(sm["prec"]["name"])
+                    stresses.append(sm["evap"]["name"])
+                    if sm["temp"] is not None:
+                        stresses.append(sm["temp"]["name"])
+                elif "stress" in sm:
+                    smstress = sm["stress"]
+                    if isinstance(smstress, dict):
+                        smstress = [smstress]
+                    for s in smstress:
+                        stresses.append(s["name"])
+        else:
+            for sm in ml.stressmodels.values():
+                # Check class name using type instead of protected _name attribute
+                if type(sm).__name__ == "RechargeModel":
+                    stresses.append(sm.prec.name)
+                    stresses.append(sm.evap.name)
+                    if sm.temp is not None:
+                        stresses.append(sm.temp.name)
+                elif hasattr(sm, "stress"):
+                    smstress = sm.stress
+                    if not isinstance(smstress, list):
+                        smstress = [smstress]
+                    for s in smstress:
+                        stresses.append(s.name)
+        return list(set(stresses))
+
+    def get_model_time_series_names(
+        self,
+        modelnames: Optional[Union[list, str]] = None,
+        dropna: bool = True,
+        progressbar: bool = True,
+    ) -> FrameOrSeriesUnion:
+        """Get time series names contained in model.
 
-    @property
-    def n_models(self):
-        """
-        Returns the number of models in the store.
+        Parameters
+        ----------
+        modelnames : Optional[Union[list, str]], optional
+            list or name of models to get time series names for,
+            by default None which will use all modelnames
+        dropna : bool, optional
+            drop stresses from table if stress is not included in any
+            model, by default True
+        progressbar : bool, optional
+            show progressbar, by default True
 
         Returns
         -------
-            int
-                The number of models in the store.
+        structure : pandas.DataFrame
+            returns DataFrame with oseries name per model, and a flag
+            indicating whether a stress is contained within a time series
+            model.
         """
-        return len(self.model_names)
+        model_names = self._parse_names(modelnames, libname="models")
+        structure = pd.DataFrame(
+            index=model_names, columns=["oseries"] + self.stresses_names
+        )
+        structure.index.name = "model"
 
-    @property  # type: ignore
-    @functools.lru_cache()
-    def oseries_models(self):
-        """List of model names per oseries.
+        for mlnam in (
+            tqdm(model_names, desc="Get model time series names")
+            if progressbar
+            else model_names
+        ):
+            mldict = self.get_models(mlnam, return_dict=True)
+            stresses_names = self._get_model_stress_names(mldict)
+            # oseries
+            structure.loc[mlnam, "oseries"] = mldict["oseries"]["name"]
+            # stresses
+            structure.loc[mlnam, stresses_names] = 1
+        if dropna:
+            return structure.dropna(how="all", axis=1)
+        else:
+            return structure
 
-        Returns
-        -------
-        d : dict
-            dictionary with oseries names as keys and list of model names as
-            values
-        """
-        d = {}
-        for onam in self.oseries_with_models:
-            d[onam] = self._get_item("oseries_models", onam)
-        return d
+    @staticmethod
+    def _clear_cache(libname: AllLibs) -> None:
+        """Clear cached property."""
+        if libname == "models":
+            libname = "_modelnames_cache"
+        getattr(BaseConnector, libname).fget.cache_clear()
 
 
 class ModelAccessor:
@@ -1412,7 +2017,7 @@ class ModelAccessor:
         """Representation contains the number of models and the list of model names."""
         return (
             f"<{self.__class__.__name__}> {len(self)} model(s): \n"
-            + self.conn._modelnames_cache.__repr__()
+            + self.conn.model_names.__repr__()
         )
 
     def __getitem__(self, name: str):
@@ -1463,9 +2068,7 @@ class ModelAccessor:
         pastas.Model
             A random model object from the connection.
         """
-        from random import choice
-
-        return self.conn.get_models(choice(self.conn._modelnames_cache))
+        return self.conn.get_models(choice(self.conn.model_names))
 
     @property
     def metadata(self):