From 57581908b58649dceb230d176603f95d01961c63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 30 Jul 2024 15:37:12 +0200 Subject: [PATCH 01/31] Add hydropandas extension - some thin wrappers around hydropandas for downloading BRO or KNMI data - convenient option to update time series currently in store from BRO or KNMI. --- pastastore/extensions/__init__.py | 13 ++ pastastore/extensions/accessor.py | 7 + pastastore/extensions/hpd.py | 359 ++++++++++++++++++++++++++++++ pastastore/store.py | 4 +- pyproject.toml | 2 +- tests/test_007_hpdextension.py | 33 +++ 6 files changed, 416 insertions(+), 2 deletions(-) create mode 100644 pastastore/extensions/__init__.py create mode 100644 pastastore/extensions/accessor.py create mode 100644 pastastore/extensions/hpd.py create mode 100644 tests/test_007_hpdextension.py diff --git a/pastastore/extensions/__init__.py b/pastastore/extensions/__init__.py new file mode 100644 index 0000000..04ac3a2 --- /dev/null +++ b/pastastore/extensions/__init__.py @@ -0,0 +1,13 @@ +from pastastore.extensions.accessor import ( + register_pastastore_accessor as register_pastastore_accessor, +) + + +def activate_hydropandas_extension(): + """Register Plotly extension for pastas.Model class for interactive plotting.""" + from pastastore.extensions.hpd import HydroPandasExtension as HpdExt + + print( + "Registered HydroPandas extension in PastaStore class, " + "e.g. `pstore.hpd.download_bro()`." + ) diff --git a/pastastore/extensions/accessor.py b/pastastore/extensions/accessor.py new file mode 100644 index 0000000..4697748 --- /dev/null +++ b/pastastore/extensions/accessor.py @@ -0,0 +1,7 @@ +from pastas.extensions.accessor import _register_accessor + + +def register_pastastore_accessor(name: str): + from pastastore.store import PastaStore + + return _register_accessor(name, PastaStore) \ No newline at end of file diff --git a/pastastore/extensions/hpd.py b/pastastore/extensions/hpd.py new file mode 100644 index 0000000..8b34267 --- /dev/null +++ b/pastastore/extensions/hpd.py @@ -0,0 +1,359 @@ +import logging +from typing import Optional, Union + +import hydropandas as hpd +import numpy as np +from pandas import DataFrame, Series, Timedelta, Timestamp +from tqdm.auto import tqdm + +from pastastore.extensions.accessor import register_pastastore_accessor + +logger = logging.getLogger("hydropandas") + + +TimeType = Optional[Union[str, Timestamp]] + + +@register_pastastore_accessor("hpd") +class HydroPandasExtension: + """HydroPandas extension for PastaStore. + + Parameters + ---------- + store: pastastore.store.PastaStore + PastaStore object to extend with HydroPandas functionality + """ + + def __init__(self, store): + """Initialize HydroPandasExtenstion. + + Parameters + ---------- + store : pasta.store.PastaStore + PastaStore object to extend with HydroPandas functionality + """ + self._store = store + + def add_obscollection( + self, + libname: str, + oc: hpd.ObsCollection, + kind: Optional[str] = None, + data_column: Optional[str] = None, + unit_multiplier: float = 1.0, + ): + """Add an ObsCollection to the PastaStore. + + Parameters + ---------- + libname : str + Name of the library to add the ObsCollection to ["oseries", "stresses"]. + oc : hpd.ObsCollection + ObsCollection to add to the store. + kind : str, optional + kind identifier for observations, by default None. Required for adding + stresses. + data_column : str, optional + name of column containing observation values, by default None. + unit_multiplier : float, optional + multiply unit by this value before saving it in the store + """ + for name, row in oc.iterrows(): + obs = row["obs"] + # metadata = row.drop("obs").to_dict() + self.add_observation( + libname, obs, name=name, kind=kind, data_column=data_column + ) + + def add_observation( + self, + libname: str, + obs: hpd.Obs, + name: Optional[str] = None, + kind: Optional[str] = None, + data_column: Optional[str] = None, + unit_multiplier: float = 1.0, + ): + """Add an hydropandas observation series to the PastaStore. + + Parameters + ---------- + libname : str + Name of the library to add the observation to ["oseries", "stresses"]. + obs : hpd.Obs + hydroPandas observation series to add to the store. + name : str, optional + Name of the observation, by default None. If None, the name of the + observation is used. + kind : str, optional + kind identifier for observations, by default None. Required for adding + stresses. + data_column : str, optional + name of column containing observation values, by default None. + unit_multiplier : float, optional + multiply unit by this value before saving it in the store + """ + # if data_column is not None, use data_column + if data_column is not None: + if not obs.empty: + o = obs[data_column] + else: + o = Series() + # if data_column is None, check no. of columns in obs + # if only one column, use that column + elif isinstance(obs, DataFrame) and obs.columns.size == 1: + o = obs.iloc[:, 0] + elif isinstance(obs, Series): + o = obs + # else raise error + else: + raise ValueError("No data_column specified and obs has multiple columns.") + + # break if obs is empty + if o.empty: + logger.info("Observation '%s' is empty, not adding to store.", name) + return + + # gather metadata from obs object + metadata = {key: getattr(obs, key) for key in obs._metadata} + + metadata.pop("name", None) + metadata.pop("meta", None) + unit = metadata.get("unit", None) + if unit == "m" and unit_multiplier == 1e3: + metadata["unit"] = "mm" + elif unit_multiplier != 1.0: + metadata["unit"] = f"{unit_multiplier:e}*{unit}" + + source = metadata.get("source", "") + if len(source) > 0: + source = f"{source} " + + if libname == "oseries": + self._store.add_oseries(o, name, metadata=metadata) + logger.info("%sobservation '%s' added to oseries library.", source, name) + elif libname == "stresses": + if kind is None: + raise ValueError("`kind` must be specified for stresses!") + self._store.add_stress(o * unit_multiplier, name, kind, metadata=metadata) + logger.info( + "%sstress '%s' (kind='%s') added to stresses library.", + source, + name, + kind, + ) + else: + raise ValueError("libname must be 'oseries' or 'stresses'.") + + def download_knmi_precipitation( + self, + stns: Optional[list[int]] = None, + meteo_var: str = "RH", + tmin: TimeType = None, + tmax: TimeType = None, + unit_multiplier: float = 1e3, + update: bool = False, + **kwargs, + ): + """Download precipitation data from KNMI and store in PastaStore. + + Parameters + ---------- + stns : list of int/str, optional + list of station numbers to download data for, by default None + meteo_var : str, optional + variable to download, by default "RH", valid options are ["RD", "RH"]. + tmin : TimeType, optional + start time, by default None + tmax : TimeType, optional + end time, by default None + unit_multiplier : float, optional + multiply unit by this value before saving it in the store, + by default 1e3 to convert m to mm + update : bool, optional + if True, update currently stored precipitation time series with new data + """ + self.download_knmi_meteo( + meteo_var=meteo_var, + kind="prec", + stns=stns, + tmin=tmin, + tmax=tmax, + unit_multiplier=unit_multiplier, + update=update, + **kwargs, + ) + + def download_knmi_evaporation( + self, + stns: Optional[list[int]] = None, + meteo_var: str = "EV24", + tmin: TimeType = None, + tmax: TimeType = None, + unit_multiplier: float = 1e3, + update: bool = False, + **kwargs, + ): + """Download evaporation data from KNMI and store in PastaStore. + + Parameters + ---------- + stns : list of int/str, optional + list of station numbers to download data for, by default None + meteo_var : str, optional + variable to download, by default "EV24" + tmin : TimeType, optional + start time, by default None + tmax : TimeType, optional + end time, by default None + unit_multiplier : float, optional + multiply unit by this value before saving it in the store, + by default 1e3 to convert m to mm + update : bool, optional + if True, update currently stored evaporation time series with new data + """ + self.download_knmi_meteo( + meteo_var=meteo_var, + kind="evap", + stns=stns, + tmin=tmin, + tmax=tmax, + unit_multiplier=unit_multiplier, + update=update, + **kwargs, + ) + + def download_knmi_meteo( + self, + meteo_var: str, + kind: str, + stns: Optional[list[int]] = None, + tmin: TimeType = None, + tmax: TimeType = None, + unit_multiplier: float = 1.0, + update: bool = False, + **kwargs, + ): + """Download meteorological data from KNMI and store in PastaStore. + + Parameters + ---------- + meteo_var : str, optional + variable to download, by default "RH", valid options are + e.g. ["RD", "RH", "EV24", "T", "Q"]. + kind : str + kind identifier for observations, usually "prec" or "evap". + stns : list of int/str, optional + list of station numbers to download data for, by default None + tmin : TimeType, optional + start time, by default None + tmax : TimeType, optional + end time, by default None + unit_multiplier : float, optional + multiply unit by this value before saving it in the store, + by default 1.0 (no conversion) + update : bool, optional + if True, update currently stored precipitation time series with new data + """ + # get tmin/tmax if not specified + if update: + stressnames = self._store.stresses.loc[ + self._store.stresses["kind"] == kind + ].index.tolist() + tmintmax = self._store.get_tmin_tmax("stresses", names=stressnames) + if tmin is None: + tmin = tmintmax.loc[:, "tmax"].min() + if tmax is None: + tmax = Timestamp.now().normalize() + else: + tmintmax = self._store.get_tmin_tmax("oseries") + if tmin is None: + tmin = tmintmax.loc[:, "tmin"].min() - Timedelta(days=10 * 365) + if tmax is None: + tmax = tmintmax.loc[:, "tmax"].max() + + # if update, only download data for stations in store + if update: + locations = None + if stns is None: + stns = self._store.stresses.loc[stressnames, "station"].tolist() + else: + check = np.isin( + stns, self._store.stresses.loc[stressnames, "station"].values + ) + if not check.all(): + raise ValueError( + "Not all specified stations are in the store: " + f"{np.array(stns)[~check]}" + ) + elif stns is None: + locations = self._store.oseries.loc[:, ["x", "y"]] + else: + locations = None + + # download data + knmi = hpd.read_knmi( + locations=locations, + stns=stns, + meteo_vars=[meteo_var], + starts=tmin, + ends=tmax, + **kwargs, + ) + + # add to store + self.add_obscollection( + libname="stresses", + oc=knmi, + kind=kind, + data_column=meteo_var, + unit_multiplier=unit_multiplier, + ) + + def download_bro_gmw( + self, + extent=None, + tmin=None, + tmax=None, + update=False, + **kwargs, + ): + """Download groundwater monitoring well observations from BRO. + + Parameters + ---------- + extent: tuple, optional + Extent of the area to download observations from. + tmin: pandas.Timestamp, optional + Start date of the observations to download. + tmax: pandas.Timestamp, optional + End date of the observations to download. + update: bool, optional + If True, update existing observations in the store. + **kwargs: dict, optional + Additional keyword arguments to pass to `hpd.read_bro()` + """ + if extent is not None and update: + raise ValueError("Cannot specify extent AND update=True.") + elif extent is None and not update: + raise ValueError("Either extent or update=True must be specified.") + + if update: + tmintmax = self._store.get_tmin_tmax("oseries") + for obsnam in tqdm( + self._store.oseries.index, desc="Updating oseries from BRO" + ): + bro_id, tube_number = obsnam.split("_") + tmin, tmax = tmintmax.loc[obsnam] + obs = hpd.GroundWaterObs.from_bro( + bro_id, int(tube_number), tmin=tmin, tmax=tmax, **kwargs + ) + self.add_observation("oseries", obs, name=obsnam, data_column="values") + else: + bro = hpd.read_bro( + extent=extent, + tmin=tmin, + tmax=tmax, + **kwargs, + ) + self.add_obscollection("oseries", bro, data_column="values") diff --git a/pastastore/store.py b/pastastore/store.py index abf0e37..4c4f4ad 100644 --- a/pastastore/store.py +++ b/pastastore/store.py @@ -43,6 +43,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, @@ -706,7 +708,7 @@ def create_model( 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 diff --git a/pyproject.toml b/pyproject.toml index 48c7a70..d9edd45 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -45,7 +45,7 @@ documentation = "https://pastastore.readthedocs.io/en/latest/" [project.optional-dependencies] full = ["pastastore[arcticdb,optional]"] -lint = ["black", "flake8", "isort"] +lint = ["ruff"] optional = ["contextily", "pyproj", "adjustText"] test = [ "pastastore[arcticdb,lint,optional]", diff --git a/tests/test_007_hpdextension.py b/tests/test_007_hpdextension.py new file mode 100644 index 0000000..ea06bc2 --- /dev/null +++ b/tests/test_007_hpdextension.py @@ -0,0 +1,33 @@ +# ruff: noqa: D103 +import pytest + +import pastastore as pst +from pastastore.extensions import activate_hydropandas_extension + + +@pytest.mark.slow() +def test_hpd_download_from_bro(): + activate_hydropandas_extension() + pstore = pst.PastaStore() + pstore.hpd.download_bro_gmw( + extent=(117850, 118180, 439550, 439900), tmin="2022-01-01", tmax="2022-01-02" + ) + assert pstore.n_oseries == 3 + + +def test_hpd_download_precipitation_from_knmi(): + activate_hydropandas_extension() + pstore = pst.PastaStore() + pstore.hpd.download_knmi_precipitation( + stns=[260], tmin="2022-01-01", tmax="2022-01-31" + ) + assert pstore.n_stresses == 1 + + +def test_hpd_download_evaporation_from_knmi(): + activate_hydropandas_extension() + pstore = pst.PastaStore() + pstore.hpd.download_knmi_evaporation( + stns=[260], tmin="2022-01-01", tmax="2022-01-31" + ) + assert pstore.n_stresses == 1 From edbebe2828650b2372770a711e59a725847df917 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 30 Jul 2024 15:45:36 +0200 Subject: [PATCH 02/31] ruff thingies --- pastastore/extensions/__init__.py | 1 + pastastore/extensions/accessor.py | 10 +++++++++- pastastore/extensions/hpd.py | 9 +++++++++ 3 files changed, 19 insertions(+), 1 deletion(-) diff --git a/pastastore/extensions/__init__.py b/pastastore/extensions/__init__.py index 04ac3a2..fd43a0a 100644 --- a/pastastore/extensions/__init__.py +++ b/pastastore/extensions/__init__.py @@ -1,3 +1,4 @@ +# ruff: noqa: D104 F401 from pastastore.extensions.accessor import ( register_pastastore_accessor as register_pastastore_accessor, ) diff --git a/pastastore/extensions/accessor.py b/pastastore/extensions/accessor.py index 4697748..92ee257 100644 --- a/pastastore/extensions/accessor.py +++ b/pastastore/extensions/accessor.py @@ -1,7 +1,15 @@ +# ruff: noqa: D100 from pastas.extensions.accessor import _register_accessor def register_pastastore_accessor(name: str): + """Register an extension in the PastaStore class. + + Parameters + ---------- + name : str + name of the extension to register + """ from pastastore.store import PastaStore - return _register_accessor(name, PastaStore) \ No newline at end of file + return _register_accessor(name, PastaStore) diff --git a/pastastore/extensions/hpd.py b/pastastore/extensions/hpd.py index 8b34267..ffebc19 100644 --- a/pastastore/extensions/hpd.py +++ b/pastastore/extensions/hpd.py @@ -1,3 +1,12 @@ +"""HydroPandas extension for PastaStore. + +Features: + +- Add `hpd.Obs` and `hpd.ObsCollection` to PastaStore. +- Download and store meteorological data from KNMI or groundwater observations from BRO. +- Update currently stored (KNMI or BRO) time series from last observation to tmax. +""" + import logging from typing import Optional, Union From 8e13a5a4e74d977c0aef1767bf13f46fdb9f244b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 30 Jul 2024 15:52:53 +0200 Subject: [PATCH 03/31] ruff --- tests/test_007_hpdextension.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_007_hpdextension.py b/tests/test_007_hpdextension.py index ea06bc2..31184d2 100644 --- a/tests/test_007_hpdextension.py +++ b/tests/test_007_hpdextension.py @@ -1,4 +1,4 @@ -# ruff: noqa: D103 +# ruff: noqa: D100 D103 import pytest import pastastore as pst From 24cbc01ac217de9dd9ac0d09721e5806e2a51dea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 30 Jul 2024 16:06:23 +0200 Subject: [PATCH 04/31] test hydropandas extension only once --- .github/workflows/ci.yml | 6 +++--- pastastore/extensions/__init__.py | 2 +- pyproject.toml | 5 ++++- tests/test_007_hpdextension.py | 4 +++- 4 files changed, 11 insertions(+), 6 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3ecd45c..735cd99 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -92,12 +92,12 @@ jobs: - name: Run pytest run: | - pytest -m "not bgmap" + pytest -m "not (bgmap or pastas150)" - - name: Test backgroundmap once + - name: Test marked tests once if: ${{ matrix.python-version == '3.11' && matrix.pastas-version == 'git+https://github.com/pastas/pastas.git@dev' }} run: | - pytest -m "bgmap" + pytest -m "bgmap and pastas150" - name: Run codacy-coverage-reporter if: ${{ github.repository == 'pastas/pastastore' && success() }} diff --git a/pastastore/extensions/__init__.py b/pastastore/extensions/__init__.py index fd43a0a..60dcb8e 100644 --- a/pastastore/extensions/__init__.py +++ b/pastastore/extensions/__init__.py @@ -6,7 +6,7 @@ def activate_hydropandas_extension(): """Register Plotly extension for pastas.Model class for interactive plotting.""" - from pastastore.extensions.hpd import HydroPandasExtension as HpdExt + from pastastore.extensions.hpd import HydroPandasExtension as _ print( "Registered HydroPandas extension in PastaStore class, " diff --git a/pyproject.toml b/pyproject.toml index d9edd45..5486be7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -109,7 +109,10 @@ convention = "numpy" [tool.pytest.ini_options] addopts = "--durations=0 --cov-report xml:coverage.xml --cov pastastore -v" -markers = ["bgmap: test tile download for background map"] +markers = [ + "bgmap: test tile download for background map", + "pastas150: tests only working for pastas>=1.5.0", +] [tool.mypy] python_version = "3.9" diff --git a/tests/test_007_hpdextension.py b/tests/test_007_hpdextension.py index 31184d2..9d0bbc4 100644 --- a/tests/test_007_hpdextension.py +++ b/tests/test_007_hpdextension.py @@ -5,7 +5,7 @@ from pastastore.extensions import activate_hydropandas_extension -@pytest.mark.slow() +@pytest.mark.pastas150() def test_hpd_download_from_bro(): activate_hydropandas_extension() pstore = pst.PastaStore() @@ -15,6 +15,7 @@ def test_hpd_download_from_bro(): assert pstore.n_oseries == 3 +@pytest.mark.pastas150() def test_hpd_download_precipitation_from_knmi(): activate_hydropandas_extension() pstore = pst.PastaStore() @@ -24,6 +25,7 @@ def test_hpd_download_precipitation_from_knmi(): assert pstore.n_stresses == 1 +@pytest.mark.pastas150() def test_hpd_download_evaporation_from_knmi(): activate_hydropandas_extension() pstore = pst.PastaStore() From 7b9892b619ddf991c38aececd3c589aaf42d913e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 30 Jul 2024 17:02:12 +0200 Subject: [PATCH 05/31] only attempt importing extensions when tests are run --- tests/test_007_hpdextension.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/test_007_hpdextension.py b/tests/test_007_hpdextension.py index 9d0bbc4..e3ab49a 100644 --- a/tests/test_007_hpdextension.py +++ b/tests/test_007_hpdextension.py @@ -2,11 +2,12 @@ import pytest import pastastore as pst -from pastastore.extensions import activate_hydropandas_extension @pytest.mark.pastas150() def test_hpd_download_from_bro(): + from pastastore.extensions import activate_hydropandas_extension + activate_hydropandas_extension() pstore = pst.PastaStore() pstore.hpd.download_bro_gmw( @@ -17,6 +18,8 @@ def test_hpd_download_from_bro(): @pytest.mark.pastas150() def test_hpd_download_precipitation_from_knmi(): + from pastastore.extensions import activate_hydropandas_extension + activate_hydropandas_extension() pstore = pst.PastaStore() pstore.hpd.download_knmi_precipitation( @@ -27,6 +30,8 @@ def test_hpd_download_precipitation_from_knmi(): @pytest.mark.pastas150() def test_hpd_download_evaporation_from_knmi(): + from pastastore.extensions import activate_hydropandas_extension + activate_hydropandas_extension() pstore = pst.PastaStore() pstore.hpd.download_knmi_evaporation( From c3c38d225b691fad71a7ef0aa91fbbc2d7f3ec9a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 30 Jul 2024 17:10:40 +0200 Subject: [PATCH 06/31] all tests once --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 735cd99..49811a9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -94,10 +94,10 @@ jobs: run: | pytest -m "not (bgmap or pastas150)" - - name: Test marked tests once + - name: Run all tests once if: ${{ matrix.python-version == '3.11' && matrix.pastas-version == 'git+https://github.com/pastas/pastas.git@dev' }} run: | - pytest -m "bgmap and pastas150" + pytest -m "" - name: Run codacy-coverage-reporter if: ${{ github.repository == 'pastas/pastastore' && success() }} From 3a1c07c4c6dad9ce694954c29e46ff882ddb042f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Mon, 5 Aug 2024 15:06:33 +0200 Subject: [PATCH 07/31] add hydropandas to extensions optional dependency group --- pyproject.toml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 5486be7..26c12e6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -45,8 +45,10 @@ documentation = "https://pastastore.readthedocs.io/en/latest/" [project.optional-dependencies] full = ["pastastore[arcticdb,optional]"] -lint = ["ruff"] +extensions = ["hydropandas"] optional = ["contextily", "pyproj", "adjustText"] +arcticdb = ["arcticdb"] +lint = ["ruff"] test = [ "pastastore[arcticdb,lint,optional]", "hydropandas[full]", @@ -69,7 +71,6 @@ test_py312 = [ "pytest-benchmark", "codacy-coverage", ] -arcticdb = ["arcticdb"] docs = [ "pastastore[optional]", "sphinx_rtd_theme", From 4e2e3b036a4dbc0634cd3fffaec0eb58f46a635a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 6 Aug 2024 11:39:18 +0200 Subject: [PATCH 08/31] improve message --- pastastore/extensions/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pastastore/extensions/__init__.py b/pastastore/extensions/__init__.py index 60dcb8e..e5b7151 100644 --- a/pastastore/extensions/__init__.py +++ b/pastastore/extensions/__init__.py @@ -10,5 +10,5 @@ def activate_hydropandas_extension(): print( "Registered HydroPandas extension in PastaStore class, " - "e.g. `pstore.hpd.download_bro()`." + "e.g. `pstore.hpd.download_bro_gmw()`." ) From 7c69904f985d33dca97e05241fdd224529d2403b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 6 Aug 2024 11:40:24 +0200 Subject: [PATCH 09/31] separate update from download to simplify functions - modify to use upsert to add or update time series --- pastastore/extensions/hpd.py | 222 +++++++++++++++++++++++------------ 1 file changed, 147 insertions(+), 75 deletions(-) diff --git a/pastastore/extensions/hpd.py b/pastastore/extensions/hpd.py index ffebc19..c3ff8ed 100644 --- a/pastastore/extensions/hpd.py +++ b/pastastore/extensions/hpd.py @@ -8,7 +8,7 @@ """ import logging -from typing import Optional, Union +from typing import List, Optional, Union import hydropandas as hpd import numpy as np @@ -50,6 +50,7 @@ def add_obscollection( kind: Optional[str] = None, data_column: Optional[str] = None, unit_multiplier: float = 1.0, + update: bool = False, ): """Add an ObsCollection to the PastaStore. @@ -66,12 +67,20 @@ def add_obscollection( name of column containing observation values, by default None. unit_multiplier : float, optional multiply unit by this value before saving it in the store + update : bool, optional + if True, update currently stored time series with new data """ for name, row in oc.iterrows(): obs = row["obs"] # metadata = row.drop("obs").to_dict() self.add_observation( - libname, obs, name=name, kind=kind, data_column=data_column + libname, + obs, + name=name, + kind=kind, + data_column=data_column, + unit_multiplier=unit_multiplier, + update=update, ) def add_observation( @@ -82,6 +91,7 @@ def add_observation( kind: Optional[str] = None, data_column: Optional[str] = None, unit_multiplier: float = 1.0, + update: bool = False, ): """Add an hydropandas observation series to the PastaStore. @@ -101,6 +111,8 @@ def add_observation( name of column containing observation values, by default None. unit_multiplier : float, optional multiply unit by this value before saving it in the store + update : bool, optional + if True, update currently stored time series with new data """ # if data_column is not None, use data_column if data_column is not None: @@ -126,6 +138,13 @@ def add_observation( # gather metadata from obs object metadata = {key: getattr(obs, key) for key in obs._metadata} + # convert np dtypes to builtins + for k, v in metadata.items(): + if isinstance(v, np.integer): + metadata[k] = int(v) + elif isinstance(v, np.floating): + metadata[k] = float(v) + metadata.pop("name", None) metadata.pop("meta", None) unit = metadata.get("unit", None) @@ -138,18 +157,28 @@ def add_observation( if len(source) > 0: source = f"{source} " + if update: + action_msg = "updated in" + else: + action_msg = "added to" + if libname == "oseries": - self._store.add_oseries(o, name, metadata=metadata) - logger.info("%sobservation '%s' added to oseries library.", source, name) + self._store.upsert_oseries(o, name, metadata=metadata) + logger.info( + "%sobservation '%s' %s oseries library.", source, name, action_msg + ) elif libname == "stresses": if kind is None: raise ValueError("`kind` must be specified for stresses!") - self._store.add_stress(o * unit_multiplier, name, kind, metadata=metadata) + self._store.upsert_stress( + o * unit_multiplier, name, kind, metadata=metadata + ) logger.info( - "%sstress '%s' (kind='%s') added to stresses library.", + "%sstress '%s' (kind='%s') %s stresses library.", source, name, kind, + action_msg, ) else: raise ValueError("libname must be 'oseries' or 'stresses'.") @@ -161,7 +190,6 @@ def download_knmi_precipitation( tmin: TimeType = None, tmax: TimeType = None, unit_multiplier: float = 1e3, - update: bool = False, **kwargs, ): """Download precipitation data from KNMI and store in PastaStore. @@ -179,8 +207,6 @@ def download_knmi_precipitation( unit_multiplier : float, optional multiply unit by this value before saving it in the store, by default 1e3 to convert m to mm - update : bool, optional - if True, update currently stored precipitation time series with new data """ self.download_knmi_meteo( meteo_var=meteo_var, @@ -189,7 +215,6 @@ def download_knmi_precipitation( tmin=tmin, tmax=tmax, unit_multiplier=unit_multiplier, - update=update, **kwargs, ) @@ -200,7 +225,6 @@ def download_knmi_evaporation( tmin: TimeType = None, tmax: TimeType = None, unit_multiplier: float = 1e3, - update: bool = False, **kwargs, ): """Download evaporation data from KNMI and store in PastaStore. @@ -218,8 +242,6 @@ def download_knmi_evaporation( unit_multiplier : float, optional multiply unit by this value before saving it in the store, by default 1e3 to convert m to mm - update : bool, optional - if True, update currently stored evaporation time series with new data """ self.download_knmi_meteo( meteo_var=meteo_var, @@ -228,7 +250,6 @@ def download_knmi_evaporation( tmin=tmin, tmax=tmax, unit_multiplier=unit_multiplier, - update=update, **kwargs, ) @@ -240,7 +261,6 @@ def download_knmi_meteo( tmin: TimeType = None, tmax: TimeType = None, unit_multiplier: float = 1.0, - update: bool = False, **kwargs, ): """Download meteorological data from KNMI and store in PastaStore. @@ -261,41 +281,15 @@ def download_knmi_meteo( unit_multiplier : float, optional multiply unit by this value before saving it in the store, by default 1.0 (no conversion) - update : bool, optional - if True, update currently stored precipitation time series with new data """ # get tmin/tmax if not specified - if update: - stressnames = self._store.stresses.loc[ - self._store.stresses["kind"] == kind - ].index.tolist() - tmintmax = self._store.get_tmin_tmax("stresses", names=stressnames) - if tmin is None: - tmin = tmintmax.loc[:, "tmax"].min() - if tmax is None: - tmax = Timestamp.now().normalize() - else: - tmintmax = self._store.get_tmin_tmax("oseries") - if tmin is None: - tmin = tmintmax.loc[:, "tmin"].min() - Timedelta(days=10 * 365) - if tmax is None: - tmax = tmintmax.loc[:, "tmax"].max() + tmintmax = self._store.get_tmin_tmax("oseries") + if tmin is None: + tmin = tmintmax.loc[:, "tmin"].min() - Timedelta(days=10 * 365) + if tmax is None: + tmax = tmintmax.loc[:, "tmax"].max() - # if update, only download data for stations in store - if update: - locations = None - if stns is None: - stns = self._store.stresses.loc[stressnames, "station"].tolist() - else: - check = np.isin( - stns, self._store.stresses.loc[stressnames, "station"].values - ) - if not check.all(): - raise ValueError( - "Not all specified stations are in the store: " - f"{np.array(stns)[~check]}" - ) - elif stns is None: + if stns is None: locations = self._store.oseries.loc[:, ["x", "y"]] else: locations = None @@ -317,14 +311,71 @@ def download_knmi_meteo( kind=kind, data_column=meteo_var, unit_multiplier=unit_multiplier, + update=False, ) + def update_knmi_meteo( + self, + names: Optional[List[str]] = None, + tmin: TimeType = None, + tmax: TimeType = None, + ): + """Update meteorological data from KNMI in PastaStore. + + Parameters + ---------- + names : list of str, optional + list of names of observations to update, by default None + tmin : TimeType, optional + start time, by default None, which uses current last observation timestamp + as tmin + tmax : TimeType, optional + end time, by default None, which defaults to today + """ + if names is None: + names = self._store.stresses.loc[ + self._store.stresses["source"] == "KNMI" + ].index.tolist() + + tmintmax = self._store.get_tmin_tmax("stresses", names=names) + + for name in tqdm(names, desc="Updating KNMI meteo stresses"): + stn = self._store.stresses.loc[name, "station"] + meteo_var = self._store.stresses.loc[name, "meteo_var"] + unit = self._store.stresses.loc[name, "unit"] + kind = self._store.stresses.loc[name, "kind"] + + if unit == "mm": + unit_multiplier = 1e3 + else: + unit_multiplier = 1.0 + + if tmin is None: + tmin = tmintmax.loc[name, "tmax"] + + knmi = hpd.read_knmi( + stns=[stn], + meteo_vars=[meteo_var], + starts=tmin, + ends=tmax, + ) + + self.add_observation( + "stresses", + knmi["obs"].iloc[0], + name=name, + kind=kind, + data_column=meteo_var, + unit_multiplier=unit_multiplier, + update=True, + ) + def download_bro_gmw( self, - extent=None, - tmin=None, - tmax=None, - update=False, + extent: Optional[List[float | int]] = None, + tmin: TimeType = None, + tmax: TimeType = None, + update: bool = False, **kwargs, ): """Download groundwater monitoring well observations from BRO. @@ -337,32 +388,53 @@ def download_bro_gmw( Start date of the observations to download. tmax: pandas.Timestamp, optional End date of the observations to download. - update: bool, optional - If True, update existing observations in the store. **kwargs: dict, optional Additional keyword arguments to pass to `hpd.read_bro()` """ - if extent is not None and update: - raise ValueError("Cannot specify extent AND update=True.") - elif extent is None and not update: - raise ValueError("Either extent or update=True must be specified.") + bro = hpd.read_bro( + extent=extent, + tmin=tmin, + tmax=tmax, + **kwargs, + ) + self.add_obscollection("oseries", bro, data_column="values", update=update) - if update: - tmintmax = self._store.get_tmin_tmax("oseries") - for obsnam in tqdm( - self._store.oseries.index, desc="Updating oseries from BRO" - ): - bro_id, tube_number = obsnam.split("_") - tmin, tmax = tmintmax.loc[obsnam] - obs = hpd.GroundWaterObs.from_bro( - bro_id, int(tube_number), tmin=tmin, tmax=tmax, **kwargs - ) - self.add_observation("oseries", obs, name=obsnam, data_column="values") - else: - bro = hpd.read_bro( - extent=extent, - tmin=tmin, - tmax=tmax, - **kwargs, + def update_bro_gmw( + self, + names: Optional[List[str]] = None, + tmin: TimeType = None, + tmax: TimeType = None, + **kwargs, + ): + """Update groundwater monitoring well observations from BRO. + + Parameters + ---------- + names : list of str, optional + list of names of observations to update, by default None which updates all + stored oseries. + tmin : TimeType, optional + start time, by default None, which uses current last observation timestamp + as tmin + tmax : TimeType, optional + end time, by default None, which defaults to today + **kwargs : dict, optional + Additional keyword arguments to pass to `hpd.GroundwaterObs.from_bro()` + """ + if names is None: + names = self._store.oseries.index.to_list() + + tmintmax = self._store.get_tmin_tmax("oseries") + + for obsnam in tqdm(names, desc="Updating BRO oseries"): + bro_id, tube_number = obsnam.split("_") + + if tmin is None: + _, tmin = tmintmax.loc[obsnam] # tmin is stored tmax + + obs = hpd.GroundwaterObs.from_bro( + bro_id, int(tube_number), tmin=tmin, tmax=tmax, **kwargs + ) + self.add_observation( + "oseries", obs, name=obsnam, data_column="values", update=True ) - self.add_obscollection("oseries", bro, data_column="values") From 1c96b1cfc2b64378ed64b63639a3acbae96c1edd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 6 Aug 2024 11:40:34 +0200 Subject: [PATCH 10/31] expand tests to check update functions as well --- tests/test_007_hpdextension.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/tests/test_007_hpdextension.py b/tests/test_007_hpdextension.py index e3ab49a..181d00a 100644 --- a/tests/test_007_hpdextension.py +++ b/tests/test_007_hpdextension.py @@ -1,5 +1,6 @@ # ruff: noqa: D100 D103 import pytest +from pandas import Timestamp import pastastore as pst @@ -38,3 +39,28 @@ def test_hpd_download_evaporation_from_knmi(): stns=[260], tmin="2022-01-01", tmax="2022-01-31" ) assert pstore.n_stresses == 1 + + +@pytest.mark.pastas150() +def test_update_oseries(): + from pastastore.extensions import activate_hydropandas_extension + + activate_hydropandas_extension() + + pstore = pst.PastaStore.from_zip("tests/data/test_hpd_update.zip") + pstore.hpd.update_bro_gmw(tmax="2024-01-31") + tmintmax = pstore.get_tmin_tmax("oseries") + assert tmintmax.loc["GMW000000036319_1", "tmax"] >= Timestamp("2024-01-30") + assert tmintmax.loc["GMW000000036327_1", "tmax"] >= Timestamp("2024-01-20") + + +@pytest.mark.pastas150() +def test_update_stresses(): + from pastastore.extensions import activate_hydropandas_extension + + activate_hydropandas_extension() + + pstore = pst.PastaStore.from_zip("tests/data/test_hpd_update.zip") + pstore.hpd.update_knmi_meteo(tmax="2024-01-31") + tmintmax = pstore.get_tmin_tmax("stresses") + assert (tmintmax["tmax"] >= Timestamp("2024-01-31")).all() From 8c1755edbf7d283c4a6baa142c9cd5a75f46068e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 6 Aug 2024 11:40:48 +0200 Subject: [PATCH 11/31] add test pastastore for update tests --- tests/data/test_hpd_update.zip | Bin 0 -> 4310 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/data/test_hpd_update.zip diff --git a/tests/data/test_hpd_update.zip b/tests/data/test_hpd_update.zip new file mode 100644 index 0000000000000000000000000000000000000000..587c2f9ad3aa5122277290d1b08f67cd2e020bae GIT binary patch literal 4310 zcmai2c|4Ts-yT`B<=B}hdm)T{*VqSRne3A_G}#$t7=D$l$U3sGS+i#=jBR2_ksPvQ zVnWEi6q0zSbKdt=-qU&S&vQS|=lSRQT+emi*Y~==kEtO!1uFmmpaJk%QrWz<8&XT6 z0sxG70RYkk@Ikuz-*81r>Orlf{vI;&G9V=fkc2zZ$J;9dTqi8T7_t86@+QUk%S1ZV z$Hp`y)4g?d8}B;(n`HvQ+mV_V%}(Dx`u=@3LE}hN<7lFx<;d#x!QpPgQgK?dC&R|M zjw8!MEa7mQ1^qroWs~#bl!c!fO3q<>2CNF*AatWWK0lg_qUso5-r`6|E=(di_ysR7%hl&t}q-nSwXo|HWD=KnOhzG7L>wHQ}HcWda@JjKT zfqYauxV``rmy%xQQe1>nft?nr<+{~29*s4ykG&~5O(vbw!on%`U0N%sXa;?`RvR@!gX{((+(Q32-d&FprqKU%iU08ZMbePcxw z+r;#y8l+Fs5|DmM%~dn0h-pE#wdTD}OYsLfTpZs@9Je>2PI4*r)&8CY&oW0fUXUlm zD}?2Y-H7!4Kc~ zU<*XqE0AE$2ksYnRq$}3$uf#GQ|K)gDh88LiohqK9jCmTa;U!Px8P25vI6~fStSjh z@>aIhBk1NoeAo}kba^Jwe7$X#B>HSKa*<{}=*9-)V3K-xpmop6M8RufcHoy*w_x7b z?P?75>;}cE80S5FRZ>nxsLr%hZ+v@@-v)!EFMSrcmc>e;IV4AM?~^XI#>7P?mPE@f z;WC^_>$+bRJPN)soQ0*-@O#ebRf=Ih7yAxtjK=i1;*}cRC)~ZvpBPG3-pr_JPsEA>RDLv)FPWW-iAFbG;ywU0;iHa z-pe?ZQMzUm7AV0u^}+C3Dlvy+jK~u|Z*7?pa^nf3gIGP~vTuCeCF_M5B2WABhIvDV zQ`X0+j*v0vc1ijWYT}}OcN2?r?5Y@MVYXBCid4cy)eD)<2I?%RufLf6tw$09mXTRXJ*p#$` z9SlKqTu?S8YDLSMR*ewP*JO&^CED9hdtO-x1(oebKzlf5J7&NH3rrc$XhvEckiM6@ zf1kZlV931N*sNbT&jv1Kg+7xq7dkum<|wXbtrLOX6wU>2$u{TOWjdvcKwwV1xLzT; znq_hBbu(Nm6UgsjorLZ!% zNw&X633)1$WsqybjOv%=-hn*nQh&x=S~OTq$-7TqbI8#1%>?;`sed{qg92%c3D)Si z9fDk8V>Jo5B$ePO5*5@A@g1!aheQUAUe{TYiK+3y&~DSHPq)dZ>q!9Sy=C-y-F4VR zuE4GE$Y{W~e%S1VK1={gq{~of&`EV^`^k9TK2>FXhf zH?pXkn6v4WFalaEZ)ABP`QzA@)O%64&%993Cm7C8UD;m$JMf@C(m-sJF>Ha3=;*a- zZ@fTFPHYz3$FF`he1SKP)hi+DtX$cEN54Ja91Y@m>cb2NW7-Ol15o9XIn*cb%&(ll z?Yp$M+<5E7+%OAYMIri7N)>o^bxcl-eJbnw=JKgL4Td&>hNJDlBQn!p!mJJ#&(cQ< zF)$ebAnXqqR-7?jul zsmoBJ%ApnZc97v$B?jN@ZMdBR061v>CDx@C{wLN`RpQTr=(X3SYn@D)@q_lALp_Y4 ziTJ7ao(Tqaz8+FTlE`YOIh$Q_r2*Z->4Z%-x@bF6+r& zzRo1~#=HPI1d2eA%faZn%M)$SThc9*-0@cUd^O;y@yK+5u5E(OyZpHy<-xYoxT81Ki`uPd3-W zUeTxRMO=ZDKf1$JB=o{DuA5@@ouC{JWSf|Ic>v2R-PFeyzC9Ai0BTaWyc3om&C1?& z7G~ny$CxC?!*Pp7dgLg7{yF1BL#%*op9_4L5kt#4_l96fMeMj;p zj1C2`Gew*~n){)+|L}x0gIs@~`yvXXBWRkD^y9`=K~^$Ac=QUoR+xuatq_UxP*OFZ zVJo=6m;F|X=vf&R<&g}dlFi1s`&gG=7<`j>Lz^10LtZtYH3F`BI$Gk9I;3-76j8NJ zekrd}&-Ke$>)WuZD$1oruLwe|^}?fp`vuZD-);RK2qP%W%;mAna;C{F(88COJvNzj zTpJrb)fdr0hYmh=>;*62>faQa6z~!5+N^Y_Ph{^(KK?PyN}b`#e7oB%V~z^=;8Q0@lZUjTlBA{*R0GjkH1(Mq^b&zH3@)+p(t=gzNzOD;O_KE@MekT>^-J*&a z>+Rm@&@>tj!CIvu{YUkNdFT+}NBWLqFe<#BR%%yB7RNaTAy;j`_{Q(inpN_pKFe{8 z+y=FDqc@A+1cuqHyS>L^Bi7eDe%+zeFBBSjNgmbsH?RKKp~qge_}Qx-;7-T?_G&DR z%CT1^N5K9*A-P!edb<_0dS}X;JC?c|agS1~vXq>yYgoLau1MRLPZ`&gU*Lc=I=5B% zmsJ~9!$bF3OEk9p$F2Uds@t>Bnm7AKp>NjseH@K8Ykc%%Ih>Rt3oLh(uBL;^8X)uvlpR|iwMw$(@cuGU6AHWn2vt2O}2Wp3Hh zpSILEp+nxpJ+-?e9WIk};3Pef0sgK?BO<*;zv2`tPc{LpI?S>{Y5^6s=19DXtyO82mbV-lSkD`lfdGSET8hQ3MDo8ZE^oN zw}|=gCt|`mtjy*niL*LMa_*nG>sU(5{vx{Tpc>TnDTiLza=B= z%Nhkg+uXZJ5%{3}t1XuxyR_{Ptj5a*c7K|)cTG}GbEt>LjVJ*P8{Z?Wt1joVNcWWx zUtqc8>NA!l3mK8KTDqU7pizyYNtL~@L#@-^)E;304|X0L9gaU$_*H12;6wW`63J(z zdG2>)f0nwI_PG>m=5vC&CNC-?L*&Lf7ODE*A{Gbu{a TTL1WeK?86k9dR5Pf4uz{p>jMB literal 0 HcmV?d00001 From cf350d68b86e6e29a751aa756cfb49ff197377b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 6 Aug 2024 11:40:56 +0200 Subject: [PATCH 12/31] update the pastastore version --- pastastore/version.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pastastore/version.py b/pastastore/version.py index 1faf70b..7261c3f 100644 --- a/pastastore/version.py +++ b/pastastore/version.py @@ -9,7 +9,7 @@ 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: @@ -35,4 +35,6 @@ def show_versions(optional=False) -> None: except ImportError: msg += "Not Installed" + msg += f"\nPastastore version : {__version__}" + print(msg) From 200018214642d6fa2d269a7611ee69f3ae416c63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 6 Aug 2024 14:36:21 +0200 Subject: [PATCH 13/31] 1.5.0 should be the new version --- pastastore/version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pastastore/version.py b/pastastore/version.py index 7261c3f..3b1b97a 100644 --- a/pastastore/version.py +++ b/pastastore/version.py @@ -9,7 +9,7 @@ PASTAS_LEQ_022 = PASTAS_VERSION <= parse_version("0.22.0") PASTAS_GEQ_150 = PASTAS_VERSION >= parse_version("1.5.0") -__version__ = "1.6.0" +__version__ = "1.5.0" def show_versions(optional=False) -> None: From 8a0e0952a7f085b70ab2d6a42772752d0867b864 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 6 Aug 2024 14:37:10 +0200 Subject: [PATCH 14/31] Revert "1.5.0 should be the new version" This reverts commit 200018214642d6fa2d269a7611ee69f3ae416c63. --- pastastore/version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pastastore/version.py b/pastastore/version.py index 3b1b97a..7261c3f 100644 --- a/pastastore/version.py +++ b/pastastore/version.py @@ -9,7 +9,7 @@ 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: From f9e133ff5e198e09060083087d16452eec87bc42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 16:19:14 +0200 Subject: [PATCH 15/31] suggestion martin --- pastastore/extensions/hpd.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pastastore/extensions/hpd.py b/pastastore/extensions/hpd.py index c3ff8ed..da5031a 100644 --- a/pastastore/extensions/hpd.py +++ b/pastastore/extensions/hpd.py @@ -372,7 +372,7 @@ def update_knmi_meteo( def download_bro_gmw( self, - extent: Optional[List[float | int]] = None, + extent: Optional[List[float]] = None, tmin: TimeType = None, tmax: TimeType = None, update: bool = False, From e8e15d4288d735087d776175e8cff1f1fb753372 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 16:19:44 +0200 Subject: [PATCH 16/31] show pastastore version on top --- pastastore/version.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pastastore/version.py b/pastastore/version.py index 7261c3f..2b3dc6a 100644 --- a/pastastore/version.py +++ b/pastastore/version.py @@ -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" @@ -35,6 +36,4 @@ def show_versions(optional=False) -> None: except ImportError: msg += "Not Installed" - msg += f"\nPastastore version : {__version__}" - print(msg) From 12ed9393e67c80091192084b9044747ae862f800 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 17:02:34 +0200 Subject: [PATCH 17/31] add methods get_stressmodel and add_stressmodel - allow adding/getting stressmodels from pastastore using stress names - support nearest selection - add tests - update `add_recharge` to use new methods. --- pastastore/store.py | 377 +++++++++++++++++++++++++++++++++++++++----- 1 file changed, 338 insertions(+), 39 deletions(-) diff --git a/pastastore/store.py b/pastastore/store.py index 4c4f4ad..012f4a7 100644 --- a/pastastore/store.py +++ b/pastastore/store.py @@ -813,50 +813,349 @@ def add_recharge( 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 = int(item.split()[1]) + kind = item.split()[2] + elif len(item.split()) == 2: # nearest | + try: + n = int(item.split()[1]) # try converting to + except ValueError: + n = 1 + kind = item.split()[1] # interpret as + 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 ' or 'nearest '!" + ) 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 nearest 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 [] " where is optional and represents the number of + nearest stresses and and represents the kind of stress to + consider. 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]], - rfunc=rfunc, - name=recharge_name, - recharge=recharge, - settings=("prec", "evap"), + 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 + + return stressmodel( + **stresses, + rfunc=rfunc(**rfunc_kwargs), + name=stressmodel_name, metadata=metadata, + **kwargs, + ) + + def add_stressmodel( + self, + ml: ps.Model, + 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 [] " where is optional and represents the number of + nearest stresses and and represents the kind of stress to + consider. 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 + pastas.Model object to add StressModel to + 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, + rfunc_kwargs=rfunc_kwargs, + kind=kind, + oseries=ml.oseries.name, + **kwargs, ) - ml.add_stressmodel(rch) + ml.add_stressmodel(sm) def solve_models( self, From a61dc7eb971f9590095f9e0557611adbf2ff6968 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 17:02:47 +0200 Subject: [PATCH 18/31] add get_stressmodel tests --- tests/test_008_stressmodels.py | 128 +++++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 tests/test_008_stressmodels.py diff --git a/tests/test_008_stressmodels.py b/tests/test_008_stressmodels.py new file mode 100644 index 0000000..f44caf4 --- /dev/null +++ b/tests/test_008_stressmodels.py @@ -0,0 +1,128 @@ +# ruff: noqa: D100 D103 +import pastas as ps +import pytest + + +def test_stressmodel_time_series_name(pstore): + pstore.get_stressmodel("evap1") + + +def test_stressmodel_override_settings(pstore): + sm = pstore.get_stressmodel("prec1", settings="evap") + assert sm.stress[0].settings["fill_nan"] == "interpolate" + + # override settings by passing kind: bit weird, but good to check + sm = pstore.get_stressmodel("prec1", kind="evap") + assert sm.stress[0].settings["fill_nan"] == "interpolate" + + +def test_stressmodel_rfunc_kwargs(pstore): + sm = pstore.get_stressmodel("well1", rfunc=ps.Hantush, rfunc_kwargs={"quad": True}) + assert sm.rfunc.quad + + +def test_stressmodel_nearest_kind_no_oseries_specified(pstore): + with pytest.raises(ValueError, match=r"Getting nearest stress*"): + pstore.get_stressmodel("nearest evap") # error oseries + + +def test_stressmodel_nearest_no_kind_specified(pstore): + with pytest.raises(ValueError, match=r"Could not parse stresses*"): + pstore.get_stressmodel("nearest", oseries="oseries1") + + # also in dictionary mode + with pytest.raises(ValueError, match=r"Could not parse stresses*"): + pstore.get_stressmodel({"stress": ["nearest"]}, oseries="oseries1") + + +def test_stressmodel_nearest_kind(pstore): + # nearest kind + sm = pstore.get_stressmodel("nearest evap", oseries="oseries1") + assert sm.stress[0].name == "evap1" + + # nearest kind in dict + sm = pstore.get_stressmodel({"stress": "nearest evap"}, oseries="oseries1") + assert sm.stress[0].name == "evap1" + + # nearest and kind separate + sm = pstore.get_stressmodel({"stress": "nearest"}, kind="evap", oseries="oseries1") + assert sm.stress[0].name == "evap1" + + # nearest in dict and kind separate + sm = pstore.get_stressmodel( + {"stress": ["nearest"]}, kind="evap", oseries="oseries1" + ) + assert sm.stress[0].name == "evap1" + + +def test_recharge_model(pstore): + # test list of stress names + rm = pstore.get_stressmodel(["prec1", "evap1"], stressmodel="RechargeModel") + assert rm.stress[0].name == "prec1" + assert rm.stress[1].name == "evap1" + + # test list of nearest + rm = pstore.get_stressmodel( + ["nearest prec", "nearest evap"], + stressmodel="RechargeModel", + oseries="oseries1", + ) + assert rm.stress[0].name == "prec1" + assert rm.stress[1].name == "evap1" + + # test dict, no kind specified + rm = pstore.get_stressmodel( + {"prec": "nearest", "evap": "nearest"}, + stressmodel="RechargeModel", + oseries="oseries1", + ) + assert rm.stress[0].name == "prec1" + assert rm.stress[1].name == "evap1" + + # test list, bare nearest with kind specified + rm = pstore.get_stressmodel( + ["nearest", "nearest"], + kind=["prec", "evap"], + stressmodel="RechargeModel", + oseries="oseries1", + ) + assert rm.stress[0].name == "prec1" + assert rm.stress[1].name == "evap1" + + +def test_wellmodel(pstore): + # test nearest + wm = pstore.get_stressmodel( + "nearest 2 well", + stressmodel="WellModel", + oseries="oseries1", + ) + assert wm.stress[0].name == "well1" + assert wm.stress[1].name == "well2" + + # test nearest with no kind specified + wm = pstore.get_stressmodel( + "nearest 2", + stressmodel="WellModel", + oseries="oseries1", + ) + assert wm.stress[0].name == "well1" + assert wm.stress[1].name == "well2" + + # test nearest n, with non-existing kind specified + with pytest.raises(ValueError, match=r"Could not find stresses*"): + pstore.get_stressmodel( + "nearest 2", + kind="well2", + stressmodel="WellModel", + oseries="oseries1", + ) + + # test nearest n with n exceeded + with pytest.raises(ValueError, match=r"Could not find*"): + pstore.get_stressmodel( + "nearest 3", + kind="well", + stressmodel="WellModel", + oseries="oseries1", + ) From 821e7304d6e04149afe521834c397b152a966484 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 17:03:01 +0200 Subject: [PATCH 19/31] typo in docs --- docs/examples.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples.rst b/docs/examples.rst index e04b060..dc43b96 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -19,7 +19,7 @@ is stored in-memory (in dictionaries):: import pastastore as pst # define dict connector - conn = pst.DictConnect("my_db") + conn = pst.DictConnector("my_db") # create project for managing Pastas data and models store = pst.PastaStore(conn) From a64841f84fe8e4ff076372750a9cb9b632127391 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 17:05:15 +0200 Subject: [PATCH 20/31] update notebooks --- ...introduction_to_pastastore_databases.ipynb | 14 ++++++++++--- .../ex02_pastastore_plots_and_maps.ipynb | 20 +++++++++++++------ .../ex03_pastastore_yaml_interface.ipynb | 10 +++++++++- 3 files changed, 34 insertions(+), 10 deletions(-) diff --git a/examples/notebooks/ex01_introduction_to_pastastore_databases.ipynb b/examples/notebooks/ex01_introduction_to_pastastore_databases.ipynb index a0ba8b6..4fee571 100644 --- a/examples/notebooks/ex01_introduction_to_pastastore_databases.ipynb +++ b/examples/notebooks/ex01_introduction_to_pastastore_databases.ipynb @@ -59,6 +59,13 @@ "PyYAML version : 6.0\n", "\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DeprecationWarning: As of Pastas 1.5, no noisemodel is added to the pastas Model class by default anymore. To solve your model using a noisemodel, you have to explicitly add a noisemodel to your model before solving. For more information, and how to adapt your code, please see this issue on GitHub: https://github.com/pastas/pastas/issues/735" + ] } ], "source": [ @@ -1190,7 +1197,7 @@ "- `solve_models`: solve all or selection of models in database\n", "- `model_results`: get results for all or selection of models in database. Requires the `art_tools` module!\n", "\n", - "Let's add some more data to the pystore to show how the bulk operations work." + "Let's add some more data to the pastastore to show how the bulk operations work." ] }, { @@ -1202,6 +1209,7 @@ "name": "stderr", "output_type": "stream", "text": [ + "The Time Series 'oseries2' has nan-values. Pastas will use the fill_nan settings to fill up the nan-values.\n", "The Time Series 'oseries2' has nan-values. Pastas will use the fill_nan settings to fill up the nan-values.\n" ] } @@ -1285,7 +1293,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "15ac33d49a044a7a8367b8145287cc55", + "model_id": "3a1f6710cd1942a78adc916d56280bb4", "version_major": 2, "version_minor": 0 }, @@ -1342,7 +1350,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a694566aa81a4df69a55e4c0d28397c8", + "model_id": "577068d685134722a0208d807122da7b", "version_major": 2, "version_minor": 0 }, diff --git a/examples/notebooks/ex02_pastastore_plots_and_maps.ipynb b/examples/notebooks/ex02_pastastore_plots_and_maps.ipynb index 74006d1..74e175f 100644 --- a/examples/notebooks/ex02_pastastore_plots_and_maps.ipynb +++ b/examples/notebooks/ex02_pastastore_plots_and_maps.ipynb @@ -29,7 +29,15 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DeprecationWarning: As of Pastas 1.5, no noisemodel is added to the pastas Model class by default anymore. To solve your model using a noisemodel, you have to explicitly add a noisemodel to your model before solving. For more information, and how to adapt your code, please see this issue on GitHub: https://github.com/pastas/pastas/issues/735" + ] + } + ], "source": [ "import pandas as pd\n", "import pastas as ps\n", @@ -588,7 +596,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -868,7 +876,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "77a0d79a996643ba8da6de131d54809c", + "model_id": "79bfed92005546b5a2759a9d533272ea", "version_major": 2, "version_minor": 0 }, @@ -944,7 +952,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "429ee4b61c594916b272adb8dc6e7bae", + "model_id": "cca422c5cb3e44129ffc671dd3dba4e6", "version_major": 2, "version_minor": 0 }, @@ -979,7 +987,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0fe32202045340b89af9dbda195a5b02", + "model_id": "2a32a3c8cbdf4b14af5995534944b418", "version_major": 2, "version_minor": 0 }, @@ -1014,7 +1022,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "24233327b1b148409e2c80572084b16d", + "model_id": "92c6bf5df3b3447aabdb61ec1885bda8", "version_major": 2, "version_minor": 0 }, diff --git a/examples/notebooks/ex03_pastastore_yaml_interface.ipynb b/examples/notebooks/ex03_pastastore_yaml_interface.ipynb index 32ed85f..fdbae07 100644 --- a/examples/notebooks/ex03_pastastore_yaml_interface.ipynb +++ b/examples/notebooks/ex03_pastastore_yaml_interface.ipynb @@ -33,7 +33,15 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DeprecationWarning: As of Pastas 1.5, no noisemodel is added to the pastas Model class by default anymore. To solve your model using a noisemodel, you have to explicitly add a noisemodel to your model before solving. For more information, and how to adapt your code, please see this issue on GitHub: https://github.com/pastas/pastas/issues/735" + ] + } + ], "source": [ "import logging\n", "import os\n", From e7e5f5ee11a128a6d8d25605d51b06a4ed780b92 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 17:10:24 +0200 Subject: [PATCH 21/31] remove PystoreConnector and ArcticConnector and all remaining references --- .gitignore | 1 - pastastore/base.py | 3 +- pastastore/connectors.py | 418 ----------------------------------- pastastore/datasets.py | 10 +- pastastore/store.py | 5 +- pastastore/util.py | 114 +--------- pyproject.toml | 2 - tests/conftest.py | 29 +-- tests/test_002_connectors.py | 9 +- 9 files changed, 12 insertions(+), 579 deletions(-) diff --git a/.gitignore b/.gitignore index ddaa85a..0d77409 100644 --- a/.gitignore +++ b/.gitignore @@ -115,6 +115,5 @@ venv.bak/ .idea/workspace.xml */_old -examples/notebooks/pystore cov.xml *.bat diff --git a/pastastore/base.py b/pastastore/base.py index dbf4d8c..1e71486 100644 --- a/pastastore/base.py +++ b/pastastore/base.py @@ -1471,6 +1471,7 @@ def _parse_model_dict(self, mdict: dict, update_ts_settings: bool = False): 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 @@ def _set_series_name(series, name): 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 diff --git a/pastastore/connectors.py b/pastastore/connectors.py index 6a8f83b..99ca25d 100644 --- a/pastastore/connectors.py +++ b/pastastore/connectors.py @@ -4,7 +4,6 @@ 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 @@ 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 @@ def oseries_with_models(self): 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.""" diff --git a/pastastore/datasets.py b/pastastore/datasets.py index ab4dce6..b8055c6 100644 --- a/pastastore/datasets.py +++ b/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": diff --git a/pastastore/store.py b/pastastore/store.py index 012f4a7..d853eef 100644 --- a/pastastore/store.py +++ b/pastastore/store.py @@ -30,9 +30,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 ---------- diff --git a/pastastore/util.py b/pastastore/util.py index 8da4823..0cd5f7d 100644 --- a/pastastore/util.py +++ b/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, @@ -243,14 +137,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": diff --git a/pyproject.toml b/pyproject.toml index 26c12e6..175e0e4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -128,8 +128,6 @@ module = [ 'mypy-pypandoc.*', 'mypy-numpy.*', 'mypy-pandas.*', - 'mypy-pystore.*', - 'mypy-arctic.*', 'mypy-art_tools.*', 'mypy-tqdm.*', 'mypy-pastas.*', diff --git a/tests/conftest.py b/tests/conftest.py index 92f0eb3..6976b12 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -66,15 +66,9 @@ def conn(request): """Fixture that yields connection object.""" name = f"test_{request.param}" # connect to dbase - if request.param == "arctic": - connstr = "mongodb://localhost:27017/" - conn = pst.ArcticConnector(name, connstr) - elif request.param == "arcticdb": + if request.param == "arcticdb": uri = "lmdb://./arctic_db/" conn = pst.ArcticDBConnector(name, uri) - elif request.param == "pystore": - path = "./tests/data/pystore" - conn = pst.PystoreConnector(name, path) elif request.param == "dict": conn = pst.DictConnector(name) elif request.param == "pas": @@ -87,21 +81,10 @@ def conn(request): @pytest.fixture(scope="module", params=params) def pstore(request): - if request.param == "arctic": - connstr = "mongodb://localhost:27017/" - name = "test_project" - connector = pst.ArcticConnector(name, connstr) - elif request.param == "arcticdb": + if request.param == "arcticdb": name = "test_project" uri = "lmdb://./arctic_db/" connector = pst.ArcticDBConnector(name, uri) - elif request.param == "pystore": - name = "test_project" - path = "./tests/data/pystore" - import pystore - - pystore.set_path(path) - connector = pst.PystoreConnector(name, path) elif request.param == "dict": name = "test_project" connector = pst.DictConnector(name) @@ -116,14 +99,6 @@ def pstore(request): pst.util.delete_pastastore(pstore) -def delete_arctic_test_db(): - connstr = "mongodb://localhost:27017/" - name = "test_project" - connector = pst.ArcticConnector(name, connstr) - pst.util.delete_arctic_connector(connector) - print("ArcticConnector 'test_project' deleted.") - - def delete_arcticdb_test_db(): connstr = "lmdb://./arctic_db/" name = "test_project" diff --git a/tests/test_002_connectors.py b/tests/test_002_connectors.py index fc6d0cf..750497a 100644 --- a/tests/test_002_connectors.py +++ b/tests/test_002_connectors.py @@ -269,12 +269,9 @@ def test_empty_library(request, conn): @pytest.mark.dependency() def test_delete(request, conn): # no need to delete dictconnector (in memory) - if conn.conn_type == "arctic": - pst.util.delete_arctic_connector(conn, libraries=["oseries"]) - pst.util.delete_arctic_connector(conn) - elif conn.conn_type == "pystore": - pst.util.delete_pystore_connector(conn, libraries=["oseries"]) - pst.util.delete_pystore_connector(conn) + if conn.conn_type == "arcticdb": + pst.util.delete_arcticdb_connector(conn, libraries=["oseries"]) + pst.util.delete_arcticdb_connector(conn) elif conn.conn_type == "pas": pst.util.delete_pas_connector(conn, libraries=["oseries"]) pst.util.delete_pas_connector(conn) From ef2a4d3615bf2ecdac7a07d692085a382388a9e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 17:10:48 +0200 Subject: [PATCH 22/31] improve tests --- tests/conftest.py | 5 ++++- tests/test_002_connectors.py | 2 +- tests/test_003_pastastore.py | 8 ++------ 3 files changed, 7 insertions(+), 8 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 6976b12..c6cb24e 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -12,7 +12,6 @@ IS_PY312 = parse_version(python_version()) >= parse_version("3.12.0") -# "arctic" and "pystore" removed for CI, can be tested locally params = ["dict", "pas", "arcticdb"] if not IS_PY312 else ["dict", "pas"] @@ -57,6 +56,10 @@ def initialize_project(conn): # pastas<=0.22.0 pass pstore.add_stress(s, "well1", kind="well", metadata={"x": 164691, "y": 423579}) + # add second well + pstore.add_stress( + s + 10, "well2", kind="well", metadata={"x": 164691 + 200, "y": 423579_200} + ) return pstore diff --git a/tests/test_002_connectors.py b/tests/test_002_connectors.py index 750497a..30607b7 100644 --- a/tests/test_002_connectors.py +++ b/tests/test_002_connectors.py @@ -263,7 +263,7 @@ def test_empty_library(request, conn): ) s1.name = "test_series" conn.add_oseries(s1, "test_series", metadata=None) - conn.empty_library("stresses", prompt=False, progressbar=False) + conn.empty_library("oseries", prompt=False, progressbar=False) @pytest.mark.dependency() diff --git a/tests/test_003_pastastore.py b/tests/test_003_pastastore.py index 623b338..cb9577c 100644 --- a/tests/test_003_pastastore.py +++ b/tests/test_003_pastastore.py @@ -214,12 +214,8 @@ def func(ml): @pytest.mark.dependency() def test_save_and_load_model(request, pstore): - ml = pstore.create_model("oseries2") - sm = ps.StressModel( - pstore.get_stresses("well1"), ps.Gamma(), name="well1", settings="well" - ) - ml.add_stressmodel(sm) - ml.solve(tmin="1993-1-1") + ml = pstore.create_model("oseries1") + ml.solve() evp_ml = ml.stats.evp() pstore.add_model(ml, overwrite=True) ml2 = pstore.get_models(ml.name) From 80bc6d24dabb265552f2c65bea0c55c4369fe8d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 17:11:27 +0200 Subject: [PATCH 23/31] use arc.delete_library --- pastastore/store.py | 6 +++--- pastastore/util.py | 10 ++++------ 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/pastastore/store.py b/pastastore/store.py index d853eef..6aadf9d 100644 --- a/pastastore/store.py +++ b/pastastore/store.py @@ -3,7 +3,7 @@ import json 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 @@ -669,7 +669,7 @@ def get_statistics( 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", @@ -686,7 +686,7 @@ def create_model( 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 diff --git a/pastastore/util.py b/pastastore/util.py index 0cd5f7d..dda51c4 100644 --- a/pastastore/util.py +++ b/pastastore/util.py @@ -61,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() From 6d196d1d9fb8e673b5a5f7dc4eb10ec07be118eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 9 Aug 2024 17:11:37 +0200 Subject: [PATCH 24/31] improve docs --- docs/connectors.rst | 2 +- docs/examples.rst | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/connectors.rst b/docs/connectors.rst index aeaabdf..96b42ee 100644 --- a/docs/connectors.rst +++ b/docs/connectors.rst @@ -43,7 +43,7 @@ the other directories when the model is loaded from the database. ArcticDB -------- -Note: this Connector uses ArcticDB the next-generation version of Arctic. Requires arcticdb Python package. +Note: this Connector uses ArcticDB. Requires arcticdb Python package. The :ref:`ArcticDBConnector` is an object that creates a local database. This can be an existing or a new database. diff --git a/docs/examples.rst b/docs/examples.rst index dc43b96..e50e84a 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -50,7 +50,7 @@ a `PastaStore` object:: import pastastore as pst - # define arctic connector + # define ArcticDB connector uri = "lmdb://./my_path_here/" conn = pst.ArcticDBConnector("my_db", uri) From 1685361a65c3f97de9b4305808190cab2d3459c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Sun, 11 Aug 2024 14:13:09 +0200 Subject: [PATCH 25/31] fix for pastas 0.22 --- pastastore/store.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pastastore/store.py b/pastastore/store.py index 6aadf9d..8c10032 100644 --- a/pastastore/store.py +++ b/pastastore/store.py @@ -16,7 +16,7 @@ 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] @@ -1086,11 +1086,14 @@ def get_stressmodel( # 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, - metadata=metadata, **kwargs, ) From bdc4490152987a66e73187291d889e4c26674abf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Sun, 11 Aug 2024 15:26:57 +0200 Subject: [PATCH 26/31] try fix CI error --- .github/workflows/ci.yml | 3 +- tests/conftest.py | 7 +- tests/data/well_month_end.csv | 265 ++++++++++++++++++++++++++++++++++ 3 files changed, 271 insertions(+), 4 deletions(-) create mode 100644 tests/data/well_month_end.csv diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 49811a9..08a6c71 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -86,7 +86,8 @@ jobs: if: ${{ matrix.python-version == '3.12'}} run: | pip install --upgrade pip - pip install numpy + # TODO: remove numpy pin when numba or ? doesn't crash on NaN being deprecated + pip install "numpy<2.0" pip install ${{ matrix.pastas-version }} pip install -e .[test_py312] diff --git a/tests/conftest.py b/tests/conftest.py index c6cb24e..f6a466c 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -47,11 +47,12 @@ def initialize_project(conn): pstore.add_stress(s, "evap2", kind="evap", metadata={"x": 164000, "y": 423030}) # well 1 - s = pd.read_csv("./tests/data/well.csv", index_col=0, parse_dates=True) + s = pd.read_csv("./tests/data/well_month_end.csv", index_col=0, parse_dates=True) try: s = ps.ts.timestep_weighted_resample( - s, pd.date_range(s.index[0], s.index[-1], freq="D") - ) + s, + pd.date_range(s.index[0] - pd.offsets.MonthBegin(), s.index[-1], freq="D"), + ).bfill() except AttributeError: # pastas<=0.22.0 pass diff --git a/tests/data/well_month_end.csv b/tests/data/well_month_end.csv new file mode 100644 index 0000000..bb75a7c --- /dev/null +++ b/tests/data/well_month_end.csv @@ -0,0 +1,265 @@ +maand,extraction_rate +1994-12-31,0.03838 +1995-01-31,0.00897 +1995-02-28,0.02393 +1995-03-31,0.49484 +1995-04-30,0.52439 +1995-05-31,0.20929 +1995-06-30,0.28054 +1995-07-31,0.36799 +1995-08-31,0.45723 +1995-09-30,0.44319 +1995-10-31,0.34961 +1995-11-30,0.2618 +1995-12-31,0.25599 +1996-01-31,0.26198 +1996-02-29,0.00016 +1996-04-01,0.38567 +1996-05-01,0.40382 +1996-06-01,0.39721 +1996-07-01,0.31524 +1996-08-01,0.35538 +1996-09-01,0.22886 +1996-10-01,0.23693 +1996-11-01,0.14038 +1996-12-01,0.10601 +1997-01-01,0.18302 +1997-02-01,0.30582 +1997-03-01,0.32931 +1997-04-01,0.19434 +1997-05-01,0.14636 +1997-06-01,0.22482 +1997-07-01,0.25604 +1997-08-01,0.14349 +1997-09-01,0.14365 +1997-10-01,0.11508 +1997-11-01,0.14177 +1997-12-01,0.11021 +1998-01-01,0.10881 +1998-02-01,0.13485 +1998-03-01,0.14543 +1998-04-01,0.13398 +1998-05-01,0.1495 +1998-06-01,0.1159 +1998-07-01,0.12515 +1998-08-01,0.11739 +1998-09-01,0.06723 +1998-10-01,0.05694 +1998-11-01,0.14304 +1998-12-31,0.14304 +1999-01-31,0.16197 +1999-02-28,0.13219 +1999-03-31,0.15673 +1999-04-30,0.12692 +1999-05-31,0.14126 +1999-06-30,0.09268 +1999-07-31,0.08306 +1999-08-31,0.12278 +1999-09-30,0.12872 +1999-10-31,0.12927 +1999-11-30,0.13369 +1999-12-31,0.11105 +2000-01-31,0.12203 +2000-02-29,0.12927 +2000-03-31,0.1195 +2000-04-30,0.14129 +2000-05-31,0.13844 +2000-06-30,0.10825 +2000-07-31,0.09415 +2000-08-31,0.13662 +2000-09-30,0.18055 +2000-10-31,0.0977 +2000-11-30,0.13804 +2000-12-31,0.13413 +2001-01-31,0.14157 +2001-02-28,0.12809 +2001-03-31,0.17677 +2001-04-30,0.12446 +2001-05-31,0.1428 +2001-06-30,0.12015 +2001-07-31,0.09732 +2001-08-31,0.14525 +2001-09-30,0.19072 +2001-10-31,0.21472 +2001-11-30,0.1488 +2001-12-31,0.12716 +2002-01-31,0.11136 +2002-02-28,0.13294 +2002-03-31,0.17193 +2002-04-30,0.21328 +2002-05-31,0.10809 +2002-06-30,0.23905 +2002-07-31,0.1498 +2002-08-31,0.19497 +2002-09-30,0.17893 +2002-10-31,0.2144 +2002-11-30,0.1401 +2003-01-01,0.129813 +2003-02-01,0.082792 +2003-03-01,0.084439 +2003-04-01,0.081279 +2003-05-01,0.130007 +2003-06-01,0.157477 +2003-07-01,0.103786 +2003-08-01,0.120441 +2003-09-01,0.097385 +2003-10-01,0.136799 +2003-11-01,0.116725 +2003-12-01,0.228594 +2004-01-01,0.121232 +2004-02-01,0.170342 +2004-03-01,0.262839 +2004-04-01,0.108799 +2004-05-01,0.07995 +2004-06-01,0.164452 +2004-07-01,0.080246 +2004-08-01,0.128882 +2004-09-01,0.115615 +2004-10-01,0.076441 +2004-11-01,0.135695 +2004-12-01,0.111574 +2005-01-01,0.170306 +2005-02-01,0.092 +2005-03-01,0.110507 +2005-04-01,0.107828 +2005-05-01,0.131834 +2005-06-01,0.123172 +2005-07-01,0.129447 +2005-08-01,0.205508 +2005-09-01,0.094235 +2005-10-01,0.080742 +2005-11-01,0.112639 +2005-12-01,0.168618 +2006-01-01,0.156611 +2006-02-01,0.097841 +2006-03-01,0.096902 +2006-04-01,0.072877 +2006-05-01,0.074971 +2006-06-01,-0.003211 +2006-07-01,0.098402 +2006-08-01,0.099607 +2006-09-01,0.06738 +2006-10-01,0.022963 +2006-11-01,0.087322 +2006-12-01,0.090544 +2007-01-01,0.125955 +2007-02-01,0.128656 +2007-03-01,0.09663 +2007-04-01,0.148318 +2007-05-01,0.049377 +2007-06-01,0.06263 +2007-07-01,-0.011431 +2007-08-01,0.112204 +2007-09-01,-0.014784 +2007-10-01,0.151083 +2007-11-01,0.095417 +2007-12-01,0.096788 +2008-01-01,0.107656 +2008-02-01,0.041061 +2008-03-01,0.03743 +2008-04-01,0.063964 +2008-05-01,0.111998 +2008-06-30,0.111998 +2008-07-31,0.03949 +2008-08-31,0.146439 +2008-09-30,0.011656 +2008-11-01,0.008172 +2009-01-01,0.008172 +2009-03-01,0.008172 +2009-05-01,0.008172 +2009-06-01,0.162465 +2009-08-01,0.162465 +2009-10-01,0.162465 +2009-12-01,0.162465 +2010-02-01,0.162465 +2010-04-01,0.162465 +2010-06-01,0.162465 +2010-08-01,0.162465 +2010-10-01,0.162465 +2010-11-01,0.244097 +2010-12-01,0.168849 +2011-01-01,0.232156 +2011-02-01,0.145149 +2011-03-01,0.155242 +2011-04-01,0.003238 +2011-05-01,0.226989 +2011-06-01,0.129647 +2011-07-01,0.104867 +2011-08-01,0.055698 +2011-09-01,0.066664 +2011-10-01,0.075181 +2011-11-01,0.03268 +2011-12-01,0.057656 +2012-01-01,0.06365 +2012-02-01,0.064159 +2012-03-01,0.042177 +2012-04-01,0.133896 +2012-05-01,0.130707 +2012-06-01,0.124348 +2012-07-01,0.113902 +2012-08-01,0.132095 +2012-09-01,0.199222 +2012-10-01,0.24341 +2012-11-01,0.16646 +2012-12-01,0.109427 +2013-01-01,0.157252 +2013-02-01,0.160432 +2013-03-01,0.092839 +2013-04-01,0.084148 +2013-05-01,0.094315 +2013-06-01,0.126162 +2013-07-01,0.133261 +2013-08-31,0.133261 +2013-09-30,0.097269 +2013-10-31,0.145245 +2013-11-30,0.170888 +2013-12-31,0.121974 +2014-01-31,0.240449 +2014-02-28,0.169527 +2014-03-31,0.021129 +2014-05-01,0.135889 +2014-06-01,0.146984 +2014-07-01,0.151469 +2014-08-01,0.102508 +2014-09-01,0.110702 +2014-10-01,0.120033 +2014-11-01,0.139158 +2014-12-01,0.063081 +2015-01-01,0.003573 +2015-02-01,0.117113 +2015-03-31,0.117113 +2015-04-30,0.242702 +2015-05-31,0.049549 +2015-06-30,0.143998 +2015-07-31,0.112192 +2015-08-31,0.096175 +2015-09-30,0.161869 +2015-10-31,0.177292 +2015-11-30,0.000584 +2015-12-31,0.066398 +2016-01-31,0.109151 +2016-02-29,0.034934 +2016-03-31,0.02964 +2016-04-30,0.060122 +2016-05-31,0.067732 +2016-06-30,0.105745 +2016-07-31,0.101905 +2016-08-31,0.082375 +2016-09-30,0.165833 +2016-10-31,0.096007 +2016-11-30,0.123265 +2016-12-31,0.130096 +2017-01-31,0.265398 +2017-02-28,0.11157 +2017-03-31,0.027638 +2017-04-30,0.009649 +2017-05-31,0.020002 +2017-06-30,0.028245 +2017-07-31,0.011456 +2017-08-31,0.016503 +2017-09-30,0.027984 +2017-10-31,0.12744 +2017-11-30,0.11752 +2017-12-31,0.070679 +2018-02-01,0.00073 +2018-03-01,0.0 From c35c6327967b87c6e55a928b8aaf2c130c9a386d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Mon, 12 Aug 2024 10:43:14 +0200 Subject: [PATCH 27/31] allow in-place adding of stressmdoels to model by passing model as str --- pastastore/store.py | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/pastastore/store.py b/pastastore/store.py index 8c10032..2ce3c2c 100644 --- a/pastastore/store.py +++ b/pastastore/store.py @@ -1,6 +1,7 @@ """Module containing the PastaStore object for managing time series and models.""" import json +import logging import os import warnings from typing import Dict, List, Literal, Optional, Tuple, Union @@ -22,6 +23,8 @@ 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. @@ -1099,7 +1102,7 @@ def get_stressmodel( def add_stressmodel( self, - ml: ps.Model, + ml: Union[ps.Model, str], stresses: Union[str, List[str], Dict[str, str]], stressmodel=ps.StressModel, stressmodel_name: Optional[str] = None, @@ -1120,8 +1123,10 @@ def add_stressmodel( Parameters ---------- - ml : pastas.Model - pastas.Model object to add StressModel to + 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: @@ -1157,7 +1162,16 @@ def add_stressmodel( oseries=ml.oseries.name, **kwargs, ) - ml.add_stressmodel(sm) + 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, From 9c2361cd35a7ddc41a76404971f1061af96849d0 Mon Sep 17 00:00:00 2001 From: FransSchaars Date: Wed, 14 Aug 2024 14:48:59 +0200 Subject: [PATCH 28/31] check: oseries can be a model and string --- pastastore/store.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pastastore/store.py b/pastastore/store.py index 2ce3c2c..97c71a3 100644 --- a/pastastore/store.py +++ b/pastastore/store.py @@ -1159,7 +1159,7 @@ def add_stressmodel( rfunc=rfunc, rfunc_kwargs=rfunc_kwargs, kind=kind, - oseries=ml.oseries.name, + oseries=ml if isinstance(ml, str) else ml.oseries.name, **kwargs, ) if isinstance(ml, str): From 8e66e5343da7bdf626d439dd7600e399a0b05dbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 15 Aug 2024 15:02:16 +0200 Subject: [PATCH 29/31] move timestep_weighted_resample to add_observation method - improve update knmi --- pastastore/extensions/hpd.py | 178 ++++++++++++++++++++++++++++++----- 1 file changed, 154 insertions(+), 24 deletions(-) diff --git a/pastastore/extensions/hpd.py b/pastastore/extensions/hpd.py index da5031a..cf98e09 100644 --- a/pastastore/extensions/hpd.py +++ b/pastastore/extensions/hpd.py @@ -12,12 +12,14 @@ import hydropandas as hpd import numpy as np +from hydropandas.io.knmi import _check_latest_measurement_date_de_bilt, get_stations from pandas import DataFrame, Series, Timedelta, Timestamp +from pastas.timeseries_utils import timestep_weighted_resample from tqdm.auto import tqdm from pastastore.extensions.accessor import register_pastastore_accessor -logger = logging.getLogger("hydropandas") +logger = logging.getLogger("hydropandas_extension") TimeType = Optional[Union[str, Timestamp]] @@ -51,6 +53,7 @@ def add_obscollection( data_column: Optional[str] = None, unit_multiplier: float = 1.0, update: bool = False, + normalize_datetime_index: bool = True, ): """Add an ObsCollection to the PastaStore. @@ -81,6 +84,7 @@ def add_obscollection( data_column=data_column, unit_multiplier=unit_multiplier, update=update, + normalize_datetime_index=normalize_datetime_index, ) def add_observation( @@ -92,6 +96,7 @@ def add_observation( data_column: Optional[str] = None, unit_multiplier: float = 1.0, update: bool = False, + normalize_datetime_index: bool = False, ): """Add an hydropandas observation series to the PastaStore. @@ -113,28 +118,36 @@ def add_observation( multiply unit by this value before saving it in the store update : bool, optional if True, update currently stored time series with new data + normalize_datetime_index : bool, optional + if True, normalize the datetime so stress value at midnight represents + the daily total, by default True. """ # if data_column is not None, use data_column if data_column is not None: if not obs.empty: - o = obs[data_column] + o = obs[[data_column]] else: o = Series() - # if data_column is None, check no. of columns in obs - # if only one column, use that column - elif isinstance(obs, DataFrame) and obs.columns.size == 1: - o = obs.iloc[:, 0] elif isinstance(obs, Series): o = obs # else raise error - else: + elif isinstance(obs, DataFrame) and (obs.columns.size > 1): raise ValueError("No data_column specified and obs has multiple columns.") + else: + raise TypeError("obs must be a Series or DataFrame with a single column.") # break if obs is empty if o.empty: logger.info("Observation '%s' is empty, not adding to store.", name) return + if normalize_datetime_index and o.index.size > 1: + o = self._normalize_datetime_index(o) + else: + raise ValueError( + "Must have minimum of 2 observations for timestep_weighted_resample." + ) + # gather metadata from obs object metadata = {key: getattr(obs, key) for key in obs._metadata} @@ -163,7 +176,7 @@ def add_observation( action_msg = "added to" if libname == "oseries": - self._store.upsert_oseries(o, name, metadata=metadata) + self._store.upsert_oseries(o.squeeze(), name, metadata=metadata) logger.info( "%sobservation '%s' %s oseries library.", source, name, action_msg ) @@ -171,7 +184,7 @@ def add_observation( if kind is None: raise ValueError("`kind` must be specified for stresses!") self._store.upsert_stress( - o * unit_multiplier, name, kind, metadata=metadata + (o * unit_multiplier).squeeze(), name, kind, metadata=metadata ) logger.info( "%sstress '%s' (kind='%s') %s stresses library.", @@ -190,6 +203,8 @@ def download_knmi_precipitation( tmin: TimeType = None, tmax: TimeType = None, unit_multiplier: float = 1e3, + fill_missing_obs: bool = True, + normalize_datetime_index: bool = True, **kwargs, ): """Download precipitation data from KNMI and store in PastaStore. @@ -215,6 +230,8 @@ def download_knmi_precipitation( tmin=tmin, tmax=tmax, unit_multiplier=unit_multiplier, + fill_missing_obs=fill_missing_obs, + normalize_datetime_index=normalize_datetime_index, **kwargs, ) @@ -225,6 +242,8 @@ def download_knmi_evaporation( tmin: TimeType = None, tmax: TimeType = None, unit_multiplier: float = 1e3, + fill_missing_obs: bool = True, + normalize_datetime_index: bool = True, **kwargs, ): """Download evaporation data from KNMI and store in PastaStore. @@ -242,6 +261,12 @@ def download_knmi_evaporation( unit_multiplier : float, optional multiply unit by this value before saving it in the store, by default 1e3 to convert m to mm + fill_missing_obs : bool, optional + if True, fill missing observations by getting observations from nearest + station with data. + normalize_datetime_index : bool, optional + if True, normalize the datetime so stress value at midnight represents + the daily total, by default True. """ self.download_knmi_meteo( meteo_var=meteo_var, @@ -250,6 +275,8 @@ def download_knmi_evaporation( tmin=tmin, tmax=tmax, unit_multiplier=unit_multiplier, + fill_missing_obs=fill_missing_obs, + normalize_datetime_index=normalize_datetime_index, **kwargs, ) @@ -261,6 +288,8 @@ def download_knmi_meteo( tmin: TimeType = None, tmax: TimeType = None, unit_multiplier: float = 1.0, + normalize_datetime_index: bool = True, + fill_missing_obs: bool = True, **kwargs, ): """Download meteorological data from KNMI and store in PastaStore. @@ -281,6 +310,12 @@ def download_knmi_meteo( unit_multiplier : float, optional multiply unit by this value before saving it in the store, by default 1.0 (no conversion) + fill_missing_obs : bool, optional + if True, fill missing observations by getting observations from nearest + station with data. + normalize_datetime_index : bool, optional + if True, normalize the datetime so stress value at midnight represents + the daily total, by default True. """ # get tmin/tmax if not specified tmintmax = self._store.get_tmin_tmax("oseries") @@ -301,6 +336,7 @@ def download_knmi_meteo( meteo_vars=[meteo_var], starts=tmin, ends=tmax, + fill_missing_obs=fill_missing_obs, **kwargs, ) @@ -312,6 +348,7 @@ def download_knmi_meteo( data_column=meteo_var, unit_multiplier=unit_multiplier, update=False, + normalize_datetime_index=normalize_datetime_index, ) def update_knmi_meteo( @@ -319,6 +356,10 @@ def update_knmi_meteo( names: Optional[List[str]] = None, tmin: TimeType = None, tmax: TimeType = None, + fill_missing_obs=True, + normalize_datetime_index=True, + raise_on_error=False, + **kwargs, ): """Update meteorological data from KNMI in PastaStore. @@ -331,6 +372,16 @@ def update_knmi_meteo( as tmin tmax : TimeType, optional end time, by default None, which defaults to today + fill_missing_obs : bool, optional + if True, fill missing observations by getting observations from nearest + station with data. + normalize_datetime_index : bool, optional + if True, normalize the datetime so stress value at midnight represents + the daily total, by default True. + raise_on_error : bool, optional + if True, raise error if an error occurs, by default False + **kwargs : dict, optional + Additional keyword arguments to pass to `hpd.read_knmi()` """ if names is None: names = self._store.stresses.loc[ @@ -339,36 +390,115 @@ def update_knmi_meteo( tmintmax = self._store.get_tmin_tmax("stresses", names=names) + if tmax is not None: + if tmintmax["tmax"].min() > tmax: + logger.info(f"All KNMI stresses are up to date to {tmax}.") + return + + maxtmax_rd = _check_latest_measurement_date_de_bilt("RD") + maxtmax_ev24 = _check_latest_measurement_date_de_bilt("EV24") + for name in tqdm(names, desc="Updating KNMI meteo stresses"): - stn = self._store.stresses.loc[name, "station"] meteo_var = self._store.stresses.loc[name, "meteo_var"] + if meteo_var == "RD": + maxtmax = maxtmax_rd + elif meteo_var == "EV24": + maxtmax = maxtmax_ev24 + else: + maxtmax = maxtmax_rd + + if tmin is None: + # 1 days extra to ensure computation of daily totals using + # timestep_weighted_resample + itmin = tmintmax.loc[name, "tmax"] - Timedelta(days=1) + else: + itmin = tmin + + # ensure 2 observations at least + if itmin >= (maxtmax + Timedelta(days=1)): + logger.debug("KNMI %s is already up to date." % name) + continue + + if tmax is None: + itmax = maxtmax + else: + itmax = tmax + unit = self._store.stresses.loc[name, "unit"] kind = self._store.stresses.loc[name, "kind"] + if "station" in self._store.stresses.columns and ~np.isnan( + self._store.stresses.loc[name, "station"] + ): + stn = self._store.stresses.loc[name, "station"] + else: + stns = get_stations(meteo_var) + stn_name = name.split("_")[-1].lower() + mask = stns["name"].str.lower().str.replace(" ", "-") == stn_name + if not mask.any(): + logger.warning( + f"Station '%s' not found in list of KNMI {meteo_var} stations." + % stn_name + ) + continue + stn = stns.loc[mask].index[0] if unit == "mm": unit_multiplier = 1e3 else: unit_multiplier = 1.0 - if tmin is None: - tmin = tmintmax.loc[name, "tmax"] - + logger.debug("Updating KNMI %s from %s to %s" % (name, itmin, itmax)) knmi = hpd.read_knmi( stns=[stn], meteo_vars=[meteo_var], - starts=tmin, - ends=tmax, + starts=itmin, + ends=itmax, + fill_missing_obs=fill_missing_obs, + **kwargs, ) + obs = knmi["obs"].iloc[0] + + try: + self.add_observation( + "stresses", + obs.loc[tmintmax.loc[name, "tmax"] :], + name=name, + kind=kind, + data_column=meteo_var, + unit_multiplier=unit_multiplier, + update=True, + normalize_datetime_index=normalize_datetime_index, + ) + except ValueError as e: + logger.error("Error updating KNMI %s: %s" % (name, str(e))) + if raise_on_error: + raise e + + @staticmethod + def _normalize_datetime_index(obs): + """Normalize observation datetime index (i.e. set observation time to midnight). - self.add_observation( - "stresses", - knmi["obs"].iloc[0], - name=name, - kind=kind, - data_column=meteo_var, - unit_multiplier=unit_multiplier, - update=True, - ) + Parameters + ---------- + obs : pandas.Series + observation series to normalize + + Returns + ------- + hpd.Obs + observation series with normalized datetime index + """ + if isinstance(obs, hpd.Obs): + metadata = {k: getattr(obs, k) for k in obs._metadata} + else: + metadata = {} + return obs.__class__( + timestep_weighted_resample( + obs, + obs.index.normalize(), + ).rename(obs.name), + **metadata, + ) def download_bro_gmw( self, From dac5d86319f36f9f8984d55f0434d52f8b773dcd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 15 Aug 2024 15:04:16 +0200 Subject: [PATCH 30/31] new ruff --- tests/test_002_connectors.py | 24 ++++++++++----------- tests/test_003_pastastore.py | 38 +++++++++++++++++----------------- tests/test_004_yaml.py | 14 ++++++------- tests/test_005_maps_plots.py | 12 +++++------ tests/test_007_hpdextension.py | 10 ++++----- 5 files changed, 49 insertions(+), 49 deletions(-) diff --git a/tests/test_002_connectors.py b/tests/test_002_connectors.py index 30607b7..5ac8eaa 100644 --- a/tests/test_002_connectors.py +++ b/tests/test_002_connectors.py @@ -178,7 +178,7 @@ def test_update_metadata(request, conn): conn.del_oseries("test_df") -@pytest.mark.dependency() +@pytest.mark.dependency def test_add_oseries(conn): o = pd.read_csv("./tests/data/obs.csv", index_col=0, parse_dates=True) conn.add_oseries( @@ -189,7 +189,7 @@ def test_add_oseries(conn): ) -@pytest.mark.dependency() +@pytest.mark.dependency def test_add_stress(conn): s = pd.read_csv("./tests/data/rain.csv", index_col=0, parse_dates=True) conn.add_stress( @@ -200,39 +200,39 @@ def test_add_stress(conn): ) -@pytest.mark.dependency() +@pytest.mark.dependency def test_get_oseries(request, conn): depends(request, [f"test_add_oseries[{conn.type}]"]) _ = conn.get_oseries("oseries1") -@pytest.mark.dependency() +@pytest.mark.dependency def test_get_oseries_and_metadata(request, conn): depends(request, [f"test_add_oseries[{conn.type}]"]) _ = conn.get_oseries("oseries1", return_metadata=True) -@pytest.mark.dependency() +@pytest.mark.dependency def test_get_stress(request, conn): depends(request, [f"test_add_stress[{conn.type}]"]) s = conn.get_stresses("prec") s.name = "prec" -@pytest.mark.dependency() +@pytest.mark.dependency def test_get_stress_and_metadata(request, conn): depends(request, [f"test_add_stress[{conn.type}]"]) s, _ = conn.get_stresses("prec", return_metadata=True) s.name = "prec" -@pytest.mark.dependency() +@pytest.mark.dependency def test_oseries_prop(request, conn): depends(request, [f"test_add_oseries[{conn.type}]"]) _ = conn.oseries -@pytest.mark.dependency() +@pytest.mark.dependency def test_stresses_prop(request, conn): depends(request, [f"test_add_stress[{conn.type}]"]) _ = conn.stresses @@ -242,19 +242,19 @@ def test_repr(conn): conn.__repr__() -@pytest.mark.dependency() +@pytest.mark.dependency def test_del_oseries(request, conn): depends(request, [f"test_add_oseries[{conn.type}]"]) conn.del_oseries("oseries1") -@pytest.mark.dependency() +@pytest.mark.dependency def test_del_stress(request, conn): depends(request, [f"test_add_stress[{conn.type}]"]) conn.del_stress("prec") -@pytest.mark.dependency() +@pytest.mark.dependency def test_empty_library(request, conn): s1 = pd.Series( index=pd.date_range("2000", periods=10, freq="D"), @@ -266,7 +266,7 @@ def test_empty_library(request, conn): conn.empty_library("oseries", prompt=False, progressbar=False) -@pytest.mark.dependency() +@pytest.mark.dependency def test_delete(request, conn): # no need to delete dictconnector (in memory) if conn.conn_type == "arcticdb": diff --git a/tests/test_003_pastastore.py b/tests/test_003_pastastore.py index cb9577c..3fc3b35 100644 --- a/tests/test_003_pastastore.py +++ b/tests/test_003_pastastore.py @@ -12,17 +12,17 @@ import pastastore as pst -@pytest.mark.dependency() +@pytest.mark.dependency def test_iter_oseries(pstore): _ = list(pstore.iter_oseries()) -@pytest.mark.dependency() +@pytest.mark.dependency def test_iter_stresses(pstore): _ = list(pstore.iter_stresses()) -@pytest.mark.dependency() +@pytest.mark.dependency def test_get_tmintmax(pstore): ostt = pstore.get_tmin_tmax("oseries") assert ostt.at["oseries1", "tmin"] == pd.Timestamp("2010-01-14") @@ -36,19 +36,19 @@ def test_get_tmintmax(pstore): pstore.del_model("oseries1") -@pytest.mark.dependency() +@pytest.mark.dependency def test_search(pstore): results = pstore.search("oseries", "OSER", case_sensitive=False) assert len(results) == 3 assert len(set(results) - {"oseries1", "oseries2", "oseries3"}) == 0 -@pytest.mark.dependency() +@pytest.mark.dependency def test_create_model(pstore): _ = pstore.create_model("oseries1") -@pytest.mark.dependency() +@pytest.mark.dependency def test_properties(pstore): pstore.add_oseries(pd.Series(dtype=np.float64), "deleteme", validate=False) pstore.add_stress( @@ -67,14 +67,14 @@ def test_properties(pstore): pstore.del_stress("deleteme") -@pytest.mark.dependency() +@pytest.mark.dependency def test_store_model(request, pstore): depends(request, [f"test_create_model[{pstore.type}]"]) ml = pstore.create_model("oseries1") pstore.conn.add_model(ml) -@pytest.mark.dependency() +@pytest.mark.dependency def test_model_accessor(request, pstore): depends(request, [f"test_store_model[{pstore.type}]"]) # repr @@ -93,7 +93,7 @@ def test_model_accessor(request, pstore): pstore.del_models("oseries1_2") -@pytest.mark.dependency() +@pytest.mark.dependency def test_oseries_model_accessor(request, pstore): depends(request, [f"test_store_model[{pstore.type}]"]) # repr @@ -114,7 +114,7 @@ def test_oseries_model_accessor(request, pstore): assert len(ml_list3) == 1 -@pytest.mark.dependency() +@pytest.mark.dependency def test_store_model_missing_series(request, pstore): depends( request, @@ -135,7 +135,7 @@ def test_store_model_missing_series(request, pstore): pstore.add_model(ml) -@pytest.mark.dependency() +@pytest.mark.dependency def test_get_model(request, pstore): depends( request, @@ -148,7 +148,7 @@ def test_get_model(request, pstore): _ = pstore.conn.get_models("oseries1") -@pytest.mark.dependency() +@pytest.mark.dependency def test_del_model(request, pstore): depends( request, @@ -162,7 +162,7 @@ def test_del_model(request, pstore): pstore.conn.del_models("oseries1") -@pytest.mark.dependency() +@pytest.mark.dependency def test_create_models(pstore): _ = pstore.create_models_bulk( ["oseries1", "oseries2"], store=True, progressbar=False @@ -170,7 +170,7 @@ def test_create_models(pstore): _ = pstore.conn.models -@pytest.mark.dependency() +@pytest.mark.dependency def test_get_parameters(request, pstore): depends(request, [f"test_create_models[{pstore.type}]"]) p = pstore.get_parameters(progressbar=False, param_value="initial") @@ -178,20 +178,20 @@ def test_get_parameters(request, pstore): assert p.isna().sum().sum() == 0 -@pytest.mark.dependency() +@pytest.mark.dependency def test_get_signatures(request, pstore): depends(request, [f"test_create_models[{pstore.type}]"]) s = pstore.get_signatures(progressbar=False) assert s.shape[1] == len(ps.stats.signatures.__all__) -@pytest.mark.dependency() +@pytest.mark.dependency def test_iter_models(request, pstore): depends(request, [f"test_create_models[{pstore.type}]"]) _ = list(pstore.iter_models()) -@pytest.mark.dependency() +@pytest.mark.dependency def test_solve_models_and_get_stats(request, pstore): depends(request, [f"test_create_models[{pstore.type}]"]) _ = pstore.solve_models( @@ -201,7 +201,7 @@ def test_solve_models_and_get_stats(request, pstore): assert stats.index.size == 2 -@pytest.mark.dependency() +@pytest.mark.dependency def test_apply(request, pstore): depends(request, [f"test_solve_models_and_get_stats[{pstore.type}]"]) @@ -212,7 +212,7 @@ def func(ml): assert len(result) == 2 -@pytest.mark.dependency() +@pytest.mark.dependency def test_save_and_load_model(request, pstore): ml = pstore.create_model("oseries1") ml.solve() diff --git a/tests/test_004_yaml.py b/tests/test_004_yaml.py index 3b8b98a..05893dc 100644 --- a/tests/test_004_yaml.py +++ b/tests/test_004_yaml.py @@ -20,7 +20,7 @@ def tempyaml(yaml): os.unlink(temp.name) -@pytest.mark.dependency() +@pytest.mark.dependency def test_load_yaml_rechargemodel(pstore): yamlstr = """ my_first_model: # model name @@ -38,7 +38,7 @@ def test_load_yaml_rechargemodel(pstore): pstore.add_model(ml) -@pytest.mark.dependency() +@pytest.mark.dependency def test_load_yaml_stressmodel(pstore): yamlstr = """ my_second_model: # model name @@ -54,7 +54,7 @@ def test_load_yaml_stressmodel(pstore): pstore.add_model(ml) -@pytest.mark.dependency() +@pytest.mark.dependency def test_load_yaml_wellmodel(pstore): yamlstr = """ my_third_model: # model name @@ -71,7 +71,7 @@ def test_load_yaml_wellmodel(pstore): pstore.add_model(ml) -@pytest.mark.dependency() +@pytest.mark.dependency def test_write_load_compare_yaml(request, pstore): depends( request, @@ -90,7 +90,7 @@ def test_write_load_compare_yaml(request, pstore): os.remove("my_first_model.yaml") -@pytest.mark.dependency() +@pytest.mark.dependency def test_write_yaml_per_oseries(request, pstore): depends( request, @@ -105,7 +105,7 @@ def test_write_yaml_per_oseries(request, pstore): os.remove("oseries2.yaml") -@pytest.mark.dependency() +@pytest.mark.dependency def test_write_yaml_minimal(request, pstore): depends( request, @@ -120,7 +120,7 @@ def test_write_yaml_minimal(request, pstore): os.remove("my_first_model.yaml") -@pytest.mark.dependency() +@pytest.mark.dependency def test_write_yaml_minimal_nearest(request, pstore): depends( request, diff --git a/tests/test_005_maps_plots.py b/tests/test_005_maps_plots.py index 424cbda..12b46db 100644 --- a/tests/test_005_maps_plots.py +++ b/tests/test_005_maps_plots.py @@ -22,7 +22,7 @@ def test_plot_stresses_availability(pstore): plt.close(ax.figure) -@pytest.mark.dependency() +@pytest.mark.dependency def test_cumulative_hist(request, pstore): ml1 = pstore.create_model("oseries1") pstore.add_model(ml1) @@ -35,7 +35,7 @@ def test_cumulative_hist(request, pstore): # %% maps -@pytest.mark.bgmap() +@pytest.mark.bgmap def test_map_oseries_w_bgmap(pstore): ax = pstore.maps.oseries() # only test bgmap once for pas @@ -57,25 +57,25 @@ def test_map_stresslinks(pstore): plt.close(ax.figure) -@pytest.mark.dependency() +@pytest.mark.dependency def test_map_models(request, pstore): ax = pstore.maps.models() plt.close(ax.figure) -@pytest.mark.dependency() +@pytest.mark.dependency def test_map_model(request, pstore): depends(request, [f"test_map_models[{pstore.type}]"]) ax = pstore.maps.model("oseries1") plt.close(ax.figure) -@pytest.mark.dependency() +@pytest.mark.dependency def test_map_modelstat(request, pstore): ax = pstore.maps.modelstat("evp") plt.close(ax.figure) -@pytest.mark.dependency() +@pytest.mark.dependency def test_list_ctx_providers(request, pstore): pstore.maps._list_contextily_providers() diff --git a/tests/test_007_hpdextension.py b/tests/test_007_hpdextension.py index 181d00a..befe375 100644 --- a/tests/test_007_hpdextension.py +++ b/tests/test_007_hpdextension.py @@ -5,7 +5,7 @@ import pastastore as pst -@pytest.mark.pastas150() +@pytest.mark.pastas150 def test_hpd_download_from_bro(): from pastastore.extensions import activate_hydropandas_extension @@ -17,7 +17,7 @@ def test_hpd_download_from_bro(): assert pstore.n_oseries == 3 -@pytest.mark.pastas150() +@pytest.mark.pastas150 def test_hpd_download_precipitation_from_knmi(): from pastastore.extensions import activate_hydropandas_extension @@ -29,7 +29,7 @@ def test_hpd_download_precipitation_from_knmi(): assert pstore.n_stresses == 1 -@pytest.mark.pastas150() +@pytest.mark.pastas150 def test_hpd_download_evaporation_from_knmi(): from pastastore.extensions import activate_hydropandas_extension @@ -41,7 +41,7 @@ def test_hpd_download_evaporation_from_knmi(): assert pstore.n_stresses == 1 -@pytest.mark.pastas150() +@pytest.mark.pastas150 def test_update_oseries(): from pastastore.extensions import activate_hydropandas_extension @@ -54,7 +54,7 @@ def test_update_oseries(): assert tmintmax.loc["GMW000000036327_1", "tmax"] >= Timestamp("2024-01-20") -@pytest.mark.pastas150() +@pytest.mark.pastas150 def test_update_stresses(): from pastastore.extensions import activate_hydropandas_extension From a5b70f730912bc794b4b35b485b99326ab72ef77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 15 Aug 2024 15:12:17 +0200 Subject: [PATCH 31/31] fix test errors --- pastastore/extensions/hpd.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pastastore/extensions/hpd.py b/pastastore/extensions/hpd.py index cf98e09..7e863fb 100644 --- a/pastastore/extensions/hpd.py +++ b/pastastore/extensions/hpd.py @@ -53,7 +53,7 @@ def add_obscollection( data_column: Optional[str] = None, unit_multiplier: float = 1.0, update: bool = False, - normalize_datetime_index: bool = True, + normalize_datetime_index: bool = False, ): """Add an ObsCollection to the PastaStore. @@ -72,6 +72,9 @@ def add_obscollection( multiply unit by this value before saving it in the store update : bool, optional if True, update currently stored time series with new data + normalize_datetime_index : bool, optional + if True, normalize the datetime so stress value at midnight represents + the daily total, by default True. """ for name, row in oc.iterrows(): obs = row["obs"] @@ -391,7 +394,7 @@ def update_knmi_meteo( tmintmax = self._store.get_tmin_tmax("stresses", names=names) if tmax is not None: - if tmintmax["tmax"].min() > tmax: + if tmintmax["tmax"].min() > Timestamp(tmax): logger.info(f"All KNMI stresses are up to date to {tmax}.") return