pastastore 1.7.1__py3-none-any.whl → 1.8.0__py3-none-any.whl

tests/test_006_benchmark.py

@@ -0,0 +1,181 @@
+# ruff: noqa: D100 D103
+import numpy as np
+import pandas as pd
+import pytest
+from conftest import requires_pkg
+
+import pastastore as pst
+
+# %% write
+
+# data
+rng = np.random.default_rng()
+data = rng.random(int(1e5))
+s = pd.Series(index=pd.date_range("1970", periods=int(1e5), freq="h"), data=data)
+metadata = {"x": 100000.0, "y": 300000.0}
+
+
+def series_write(conn):
+    conn.add_oseries(s, "oseries1", metadata=metadata, overwrite=True)
+
+
+# @pytest.mark.benchmark(group="write_series")
+# def test_benchmark_write_series_dict(benchmark):
+#     conn = pst.DictConnector("test")
+#     _ = benchmark(series_write, conn=conn)
+
+
+@pytest.mark.benchmark(group="write_series")
+def test_benchmark_write_series_pas(benchmark):
+    conn = pst.PasConnector("test", "./tests/data/pas")
+    _ = benchmark(series_write, conn=conn)
+
+
+@pytest.mark.benchmark(group="write_series")
+@requires_pkg("arcticdb")
+def test_benchmark_write_series_arcticdb(benchmark):
+    uri = "lmdb://./arctic_db/"
+    conn = pst.ArcticDBConnector("test", uri)
+    _ = benchmark(series_write, conn=conn)
+
+
+# %% read
+
+
+def series_read(conn):
+    _ = conn.get_oseries("oseries1")
+
+
+# @pytest.mark.benchmark(group="read_series")
+# def test_benchmark_write_series_dict(benchmark):
+#     conn = pst.DictConnector("test")
+#     _ = benchmark(series_read, conn=conn)
+#
+
+
+@pytest.mark.benchmark(group="read_series")
+def test_benchmark_read_series_pas(benchmark):
+    conn = pst.PasConnector("test", "./tests/data/pas")
+    _ = benchmark(series_read, conn=conn)
+
+
+@pytest.mark.benchmark(group="read_series")
+@requires_pkg("arcticdb")
+def test_benchmark_read_series_arcticdb(benchmark):
+    uri = "lmdb://./arctic_db/"
+    conn = pst.ArcticDBConnector("test", uri)
+    _ = benchmark(series_read, conn=conn)
+
+
+# %% write model
+
+
+def build_model(conn):
+    store = pst.PastaStore(conn, "test")
+
+    # oseries nb1
+    if "oseries_nb1" not in store.oseries_names:
+        o = pd.read_csv("./tests/data/head_nb1.csv", index_col=0, parse_dates=True)
+        store.add_oseries(o, "oseries_nb1", metadata={"x": 100300, "y": 400400})
+
+    # prec nb1
+    if "prec_nb1" not in store.stresses.index:
+        s = pd.read_csv("./tests/data/rain_nb1.csv", index_col=0, parse_dates=True)
+        store.add_stress(
+            s, "prec_nb1", kind="prec", metadata={"x": 100300, "y": 400400}
+        )
+
+    # evap nb1
+    if "evap_nb1" not in store.stresses.index:
+        s = pd.read_csv("./tests/data/evap_nb1.csv", index_col=0, parse_dates=True)
+        store.add_stress(
+            s, "evap_nb1", kind="evap", metadata={"x": 100300, "y": 400400}
+        )
+
+    ml = store.create_model("oseries_nb1", add_recharge=True)
+
+    return ml
+
+
+def write_model(conn, ml):
+    conn.add_model(ml, overwrite=True)
+
+
+# @pytest.mark.benchmark(group="write_model")
+# def test_benchmark_write_model_dict(benchmark):
+#     conn = pst.DictConnector("test")
+#     ml = build_model(conn)
+#     _ = benchmark(write_model, conn=conn, ml=ml)
+
+
+@pytest.mark.benchmark(group="write_model")
+def test_benchmark_write_model_pas(benchmark):
+    conn = pst.PasConnector("test", "./tests/data/pas")
+    ml = build_model(conn)
+    _ = benchmark(write_model, conn=conn, ml=ml)
+
+
+@pytest.mark.benchmark(group="write_model")
+@requires_pkg("arcticdb")
+def test_benchmark_write_model_arcticdb(benchmark):
+    uri = "lmdb://./arctic_db/"
+    conn = pst.ArcticDBConnector("test", uri)
+    ml = build_model(conn)
+    _ = benchmark(write_model, conn=conn, ml=ml)
+
+
+# %%
+
+
+def write_model_nocheckts(conn, ml):
+    conn.set_check_model_series_values(False)
+    conn.add_model(ml, overwrite=True)
+
+
+@pytest.mark.benchmark(group="write_model")
+def test_benchmark_write_model_nocheckts_pas(benchmark):
+    conn = pst.PasConnector("test", "./tests/data/pas")
+    ml = build_model(conn)
+    _ = benchmark(write_model_nocheckts, conn=conn, ml=ml)
+
+
+@pytest.mark.benchmark(group="write_model")
+@requires_pkg("arcticdb")
+def test_benchmark_write_model_nocheckts_arcticdb(benchmark):
+    uri = "lmdb://./arctic_db/"
+    conn = pst.ArcticDBConnector("test", uri)
+    ml = build_model(conn)
+    _ = benchmark(write_model_nocheckts, conn=conn, ml=ml)
+
+
+# %% read model
+
+
+def read_model(conn):
+    ml = conn.get_models("oseries_nb1")
+    return ml
+
+
+# @pytest.mark.benchmark(group="read_model")
+# def test_benchmark_read_model_dict(benchmark):
+#     conn = pst.DictConnector("test")
+#     _ = benchmark(read_model, conn=conn, ml=ml)
+
+
+@pytest.mark.benchmark(group="read_model")
+def test_benchmark_read_model_pas(benchmark):
+    conn = pst.PasConnector("test", "./tests/data/pas")
+    _ = benchmark(read_model, conn=conn)
+    pst.util.delete_pas_connector(conn)
+
+
+@pytest.mark.benchmark(group="read_model")
+@requires_pkg("arcticdb")
+def test_benchmark_read_model_arcticdb(benchmark):
+    uri = "lmdb://./arctic_db/"
+    conn = pst.ArcticDBConnector("test", uri)
+    _ = benchmark(read_model, conn=conn)
+    pst.util.delete_arcticdb_connector(conn=conn)
+    import shutil
+
+    shutil.rmtree("./arctic_db/")

tests/test_007_hpdextension.py

@@ -0,0 +1,87 @@
+# ruff: noqa: D100 D103
+import pytest
+from pandas import Timestamp
+
+import pastastore as pst
+
+
+@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(
+        extent=(117850, 118180, 439550, 439900), tmin="2022-01-01", tmax="2022-01-02"
+    )
+    assert pstore.n_oseries == 3
+
+
+@pytest.mark.xfail(reason="KNMI is being flaky, so allow this test to xfail/xpass.")
+@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(
+        stns=[260], meteo_var="RH", tmin="2022-01-01", tmax="2022-01-31"
+    )
+    assert pstore.n_stresses == 1
+
+
+@pytest.mark.xfail(reason="KNMI is being flaky, so allow this test to xfail/xpass.")
+@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(
+        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="2022-02-28")
+    tmintmax = pstore.get_tmin_tmax("oseries")
+    assert tmintmax.loc["GMW000000036319_1", "tmax"] >= Timestamp("2022-02-27")
+    assert tmintmax.loc["GMW000000036327_1", "tmax"] >= Timestamp("2022-02-27")
+
+
+@pytest.mark.xfail(reason="KNMI is being flaky, so allow this test to xfail/xpass.")
+@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="2022-02-28", normalize_datetime_index=True)
+    tmintmax = pstore.get_tmin_tmax("stresses")
+    assert (tmintmax["tmax"] >= Timestamp("2024-02-27")).all()
+
+
+@pytest.mark.xfail(reason="KNMI is being flaky, so allow this test to xfail/xpass.")
+@pytest.mark.pastas150
+def test_nearest_stresses():
+    from pastastore.extensions import activate_hydropandas_extension
+
+    activate_hydropandas_extension()
+
+    pstore = pst.PastaStore.from_zip("tests/data/test_hpd_update.zip")
+    pstore.hpd.download_nearest_knmi_precipitation(
+        "GMW000000036319_1", tmin="2024-01-01", tmax="2024-01-31"
+    )
+    assert "RD_GROOT-AMMERS" in pstore.stresses_names
+    pstore.hpd.download_nearest_knmi_evaporation(
+        "GMW000000036319_1", tmin="2024-01-01", tmax="2024-01-31"
+    )
+    assert "EV24_CABAUW-MAST" in pstore.stresses_names

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 <n> <kind>
+    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",
+        )

pastastore-1.7.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-pastastore/__init__.py,sha256=wpGHiNYYS2mAJIx6HjFPajUubBU4A6C0XP_L68OS_LY,281
-pastastore/base.py,sha256=LLSg8CaKQDoRV0aOWQCSXTYQkBDH9t-xkhgLxiPxQ9Y,67333
-pastastore/connectors.py,sha256=YK3I_Jb2uNwzBQvN2VwZvmTRfPeUETW-4ddcFSWkHVw,16820
-pastastore/datasets.py,sha256=FHVfmKqb8beEs9NONsWrCoJY37BmlvFLSEQ1VAFmE8A,6415
-pastastore/plotting.py,sha256=t6gEeHVGzrwvM6q1l8V3OkklpU75O2Y4h6nKEHRWdjo,46416
-pastastore/store.py,sha256=xbv1prv6QqYj8M-2c77CT0ZQejjmNSldpuqu_M4WxoU,60906
-pastastore/styling.py,sha256=4xAY0FmhKrvmAGIuoMM7Uucww_X4KAxTpEoHlsxMldc,2280
-pastastore/util.py,sha256=iXHoGHfK6VDbUpufNsnzdV71oBVp-koZUD4VJj6MOwo,28250
-pastastore/version.py,sha256=nDiQD4EnDPyhOloSR17RfiDAMPuUxG1wLT1hQr1pU0s,1205
-pastastore/yaml_interface.py,sha256=MddELxWe8_aqJRMUydOCbjoU1-ZodzxFKYnAaqJ5SqA,29947
-pastastore/extensions/__init__.py,sha256=lCN9xfX1qefUzUbE2FQ12c6NjLbf5HoNo-D8cGb5CTw,461
-pastastore/extensions/accessor.py,sha256=kftQM6dqMDoySbyTKcvmkjC5gJRp465KA18G4NVXUO0,367
-pastastore/extensions/hpd.py,sha256=E7YdmndaagXjVcRxHuFr1YDrIoEUf-R78YQagHUtNvo,21097
-pastastore-1.7.1.dist-info/LICENSE,sha256=DtHftfUEm99KzgwLr3rQUTg8H3kAS0Z-p5WWJgLf_OY,1082
-pastastore-1.7.1.dist-info/METADATA,sha256=E1nuAqgM1KnHIIRNUjxduDvd7k8vsR1xQcY5nvR0iGA,8021
-pastastore-1.7.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-pastastore-1.7.1.dist-info/top_level.txt,sha256=QKfonr1KJZN46MFsj8eGRBw9Mg-jO-HFvgE2orVX7Sk,11
-pastastore-1.7.1.dist-info/RECORD,,