webviz-subsurface 0.2.39__py3-none-any.whl → 0.2.41__py3-none-any.whl

tests/unit_tests/data_input/test_calc_from_cumulatives.py

@@ -1,178 +0,0 @@
-from pathlib import Path
-from typing import List
-
-import pandas as pd
-import pytest
-
-import webviz_subsurface._datainput.from_timeseries_cumulatives as from_cum
-
-
-def get_data_df(testdata_folder: Path) -> pd.DataFrame:
-    data_df = pd.read_csv(
-        testdata_folder / "reek_test_data" / "aggregated_data" / "unsmry--monthly.csv"
-    )
-    data_df.DATE = data_df.DATE.astype(str)
-    return data_df
-
-
-def test_calc_from_cumulatives(testdata_folder: Path) -> None:
-    # Includes monthly data, 10 reals x 4 ensembles, 3 years and 1 month (2000-01-01 to 2003-02-01)
-    data_df = get_data_df(testdata_folder)
-
-    ## Test single column key, FOPT as average rate avg_fopr, monthly
-    calc_df = from_cum.calc_from_cumulatives(
-        data=data_df,
-        column_keys="FOPT",
-        time_index="monthly",
-        time_index_input="monthly",
-        as_rate=True,
-    )
-
-    # Test real 0, iter-2
-    real_data = data_df[(data_df["REAL"] == 0) & (data_df["ENSEMBLE"] == "iter-2")]
-    real_calc = calc_df[(calc_df["REAL"] == 0) & (calc_df["ENSEMBLE"] == "iter-2")]
-
-    assert real_calc[real_calc.DATE == "2000-01-01"]["AVG_FOPR"].values == (
-        (
-            real_data[real_data.DATE == "2000-02-01"]["FOPT"].values
-            - real_data[real_data.DATE == "2000-01-01"]["FOPT"].values
-        )
-        / 31
-    )
-
-    assert real_calc[real_calc.DATE == "2002-05-01"]["AVG_FOPR"].values == (
-        (
-            real_data[real_data.DATE == "2002-06-01"]["FOPT"].values
-            - real_data[real_data.DATE == "2002-05-01"]["FOPT"].values
-        )
-        / 31
-    )
-
-    ## Test multiple column keys, WOPT:OP_1 as average rate avg_fopr, monthly
-    calc_df = from_cum.calc_from_cumulatives(
-        data=data_df,
-        column_keys=["WOPT:OP_1", "GOPT:OP"],
-        time_index="yearly",
-        time_index_input="monthly",
-        as_rate=True,
-    )
-    # Test real 4, iter-0
-    real_data = data_df[(data_df["REAL"] == 4) & (data_df["ENSEMBLE"] == "iter-0")]
-    real_calc = calc_df[(calc_df["REAL"] == 4) & (calc_df["ENSEMBLE"] == "iter-0")]
-
-    assert real_calc[real_calc.DATE == "2000-01-01"]["AVG_WOPR:OP_1"].values == (
-        (
-            real_data[real_data.DATE == "2001-01-01"]["WOPT:OP_1"].values
-            - real_data[real_data.DATE == "2000-01-01"]["WOPT:OP_1"].values
-        )
-        / 366
-    )
-
-    assert real_calc[real_calc.DATE == "2002-01-01"]["AVG_GOPR:OP"].values == (
-        (
-            real_data[real_data.DATE == "2003-01-01"]["GOPT:OP"].values
-            - real_data[real_data.DATE == "2002-01-01"]["GOPT:OP"].values
-        )
-        / 365
-    )
-
-    assert real_calc[real_calc.DATE == "2002-01-01"]["AVG_WOPR:OP_1"].values == (
-        (
-            real_data[real_data.DATE == "2003-01-01"]["WOPT:OP_1"].values
-            - real_data[real_data.DATE == "2002-01-01"]["WOPT:OP_1"].values
-        )
-        / 365
-    )
-
-    assert real_calc[real_calc.DATE == "2001-01-01"]["AVG_GOPR:OP"].values == (
-        (
-            real_data[real_data.DATE == "2002-01-01"]["GOPT:OP"].values
-            - real_data[real_data.DATE == "2001-01-01"]["GOPT:OP"].values
-        )
-        / 365
-    )
-
-    ## Test multiple column keys, WOPR_OP as average rate avg_fopr, monthly
-    calc_df = from_cum.calc_from_cumulatives(
-        data=data_df,
-        column_keys=["WGPT:OP_2", "GWPT:OP"],
-        time_index="monthly",
-        time_index_input="monthly",
-        as_rate=False,
-    )
-    # Test real 9, iter-0
-    real_data = data_df[(data_df["REAL"] == 9) & (data_df["ENSEMBLE"] == "iter-0")]
-    real_calc = calc_df[(calc_df["REAL"] == 9) & (calc_df["ENSEMBLE"] == "iter-0")]
-
-    assert real_calc[real_calc.DATE == "2000-01-01"]["INTVL_WGPT:OP_2"].values == (
-        real_data[real_data.DATE == "2000-01-01"]["WGPT:OP_2"].values
-        - real_data[real_data.DATE == "2000-02-01"]["WGPT:OP_2"].values
-    )
-
-    assert real_calc[real_calc.DATE == "2002-05-01"]["INTVL_GWPT:OP"].values == (
-        real_data[real_data.DATE == "2002-06-01"]["GWPT:OP"].values
-        - real_data[real_data.DATE == "2002-05-01"]["GWPT:OP"].values
-    )
-
-    assert real_calc[real_calc.DATE == "2000-12-01"]["INTVL_WGPT:OP_2"].values == (
-        real_data[real_data.DATE == "2001-01-01"]["WGPT:OP_2"].values
-        - real_data[real_data.DATE == "2000-12-01"]["WGPT:OP_2"].values
-    )
-
-    assert real_calc[real_calc.DATE == "2002-02-01"]["INTVL_GWPT:OP"].values == (
-        real_data[real_data.DATE == "2002-03-01"]["GWPT:OP"].values
-        - real_data[real_data.DATE == "2002-02-01"]["GWPT:OP"].values
-    )
-
-    # Resample the data to yearly datapoints:
-    data_df = data_df[
-        data_df["DATE"].isin(["2000-01-01", "2001-01-01", "2002-01-01", "2003-01-01"])
-    ]
-    calc_df = from_cum.calc_from_cumulatives(
-        data=data_df,
-        column_keys=["WGPT:OP_2", "GWPT:OP"],
-        time_index="yearly",
-        time_index_input="yearly",
-        as_rate=False,
-    )
-    # Test real 9, iter-0
-    real_data = data_df[(data_df["REAL"] == 9) & (data_df["ENSEMBLE"] == "iter-0")]
-    real_calc = calc_df[(calc_df["REAL"] == 9) & (calc_df["ENSEMBLE"] == "iter-0")]
-
-    assert real_calc[real_calc.DATE == "2000-01-01"]["INTVL_WGPT:OP_2"].values == (
-        real_data[real_data.DATE == "2001-01-01"]["WGPT:OP_2"].values
-        - real_data[real_data.DATE == "2000-01-01"]["WGPT:OP_2"].values
-    )
-
-    assert real_calc[real_calc.DATE == "2002-01-01"]["INTVL_GWPT:OP"].values == (
-        real_data[real_data.DATE == "2003-01-01"]["GWPT:OP"].values
-        - real_data[real_data.DATE == "2002-01-01"]["GWPT:OP"].values
-    )
-
-
-@pytest.mark.parametrize(
-    "column_keys,time_index,time_index_input,as_rate",
-    [
-        (["WGPT:OP_2", "GWPT:OP"], "monthly", "yearly", False),
-        (["WGPT:OP_2", "GWPT:OP"], "daily", "monthly", True),
-        (["WGPT:OP_2", "GWPT:OP"], "daily", "yearly", True),
-    ],
-)
-def test_calc_from_cumulatives_errors(
-    column_keys: List[str],
-    time_index: str,
-    time_index_input: str,
-    as_rate: bool,
-    testdata_folder: Path,
-) -> None:
-    data_df = get_data_df(testdata_folder)
-    with pytest.raises(ValueError):
-        # Is this variable necessary?
-        # pylint: disable=unused-variable
-        calc_df = from_cum.calc_from_cumulatives(
-            data=data_df,
-            column_keys=column_keys,
-            time_index=time_index,
-            time_index_input=time_index_input,
-            as_rate=as_rate,
-        )

tests/unit_tests/data_input/test_image_processing.py

@@ -1,11 +0,0 @@
-import numpy as np
-
-from webviz_subsurface._datainput.image_processing import array_to_png
-
-with open("tests/data/surface_png.txt", "r") as file:
-    BASE64_SURFACE = file.read()
-
-
-def test_array_to_png() -> None:
-    data = np.loadtxt("tests/data/surface_zarr.np.gz")
-    assert array_to_png(data) == BASE64_SURFACE

tests/unit_tests/mocks/ensemble_summary_provider_dummy.py

@@ -1,67 +0,0 @@
-import datetime
-from typing import List, Optional, Sequence
-
-import pandas as pd
-
-from webviz_subsurface._providers import (
-    EnsembleSummaryProvider,
-    Frequency,
-    VectorMetadata,
-)
-
-
-class EnsembleSummaryProviderDummy(EnsembleSummaryProvider):
-    """Class for EnsembleSummaryProvider mock implementations
-
-    Creates dummy class implementing all methods in EnsembleSummaryProvider with
-    NotImplementedError. Derived class is responsible to override necessary methods
-    to obtain wanted functionality
-    """
-
-    #####################################################e
-    #
-    # Interface methods raise NotImplementedError
-    #
-    #####################################################
-
-    def vector_names(self) -> List[str]:
-        raise NotImplementedError("Method not implemented for mock!")
-
-    def realizations(self) -> List[int]:
-        raise NotImplementedError("Method not implemented for mock!")
-
-    def vector_metadata(self, vector_name: str) -> Optional[VectorMetadata]:
-        raise NotImplementedError("Method not implemented for mock!")
-
-    def vector_names_filtered_by_value(
-        self,
-        exclude_all_values_zero: bool = False,
-        exclude_constant_values: bool = False,
-    ) -> List[str]:
-        raise NotImplementedError("Method not implemented for mock!")
-
-    def dates(
-        self,
-        resampling_frequency: Optional[Frequency],
-        realizations: Optional[Sequence[int]] = None,
-    ) -> List[datetime.datetime]:
-        raise NotImplementedError("Method not implemented for mock!")
-
-    def supports_resampling(self) -> bool:
-        raise NotImplementedError("Method not implemented for mock!")
-
-    def get_vectors_df(
-        self,
-        vector_names: Sequence[str],
-        resampling_frequency: Optional[Frequency],
-        realizations: Optional[Sequence[int]] = None,
-    ) -> pd.DataFrame:
-        raise NotImplementedError("Method not implemented for mock!")
-
-    def get_vectors_for_date_df(
-        self,
-        date: datetime.datetime,
-        vector_names: Sequence[str],
-        realizations: Optional[Sequence[int]] = None,
-    ) -> pd.DataFrame:
-        raise NotImplementedError("Method not implemented for mock!")

tests/unit_tests/model_tests/test_ensemble_model.py

@@ -1,176 +0,0 @@
-import datetime
-from pathlib import Path
-
-import numpy as np
-import pytest
-
-from webviz_subsurface._models.ensemble_model import EnsembleModel
-
-
-@pytest.mark.usefixtures("app")
-def test_ensemble_set_init(testdata_folder):
-    emodel = EnsembleModel(
-        ensemble_name="iter-0",
-        ensemble_path=Path(testdata_folder)
-        / "01_drogon_ahm"
-        / "realization-*"
-        / "iter-0",
-    )
-    assert emodel.ens_folder == {"iter-0": f"{testdata_folder}/01_drogon_ahm/"}
-    assert not emodel.webviz_store
-
-
-@pytest.mark.usefixtures("app")
-def test_bad_ensemble_path():
-    emodel = EnsembleModel(ensemble_name="iter-0", ensemble_path="some_path")
-    with pytest.raises(ValueError) as exception:
-        emodel.load_ensemble()
-    assert (
-        exception.value.args[0]
-        == "No realizations found for ensemble iter-0, located at 'some_path'. Aborting..."
-    )
-
-
-@pytest.mark.usefixtures("app")
-def test_smry_load(testdata_folder):
-    emodel = EnsembleModel(
-        ensemble_name="iter-0",
-        ensemble_path=Path(testdata_folder)
-        / "01_drogon_ahm"
-        / "realization-*"
-        / "iter-0",
-    )
-    smry = emodel.load_smry()
-    assert len(smry.columns) == 933
-    assert len(smry["DATE"].unique()) == 2369
-
-
-@pytest.mark.usefixtures("app")
-def test_smry_load_filter_and_dtypes(testdata_folder):
-    emodel = EnsembleModel(
-        ensemble_name="iter-0",
-        ensemble_path=Path(testdata_folder)
-        / "01_drogon_ahm"
-        / "realization-*"
-        / "iter-0",
-    )
-    smry = emodel.load_smry(column_keys=["FO*"], time_index="yearly")
-    assert set(smry.columns) == set(
-        [
-            "DATE",
-            "REAL",
-            "FOPRF",
-            "FOPRS",
-            "FOPRH",
-            "FOPTH",
-            "FOPR",
-            "FOPTS",
-            "FOPTF",
-            "FOPT",
-            "FOIP",
-            "FOPP",
-        ]
-    )
-    assert set(smry["DATE"].unique()) == set(
-        [
-            datetime.date(2021, 1, 1),
-            datetime.date(2019, 1, 1),
-            datetime.date(2020, 1, 1),
-            datetime.date(2018, 1, 1),
-        ]
-    )
-    assert smry["DATE"].dtype == np.dtype("O")
-    assert smry["REAL"].dtype == np.dtype("int64")
-    assert all(
-        np.issubdtype(dtype, np.number)
-        for dtype in smry.drop(["REAL", "DATE"], axis=1).dtypes
-    )
-    smry = emodel.load_smry(column_keys=["F[OGW]P?", "FOIP"], time_index="yearly")
-    assert set(smry.columns) == set(
-        [
-            "REAL",
-            "DATE",
-            "FGPP",
-            "FGPR",
-            "FGPT",
-            "FOPP",
-            "FOPR",
-            "FOPT",
-            "FWPP",
-            "FWPR",
-            "FWPT",
-            "FOIP",
-        ]
-    )
-
-
-@pytest.mark.usefixtures("app")
-def test_smry_meta(testdata_folder):
-    emodel = EnsembleModel(
-        ensemble_name="iter-0",
-        ensemble_path=Path(testdata_folder)
-        / "01_drogon_ahm"
-        / "realization-*"
-        / "iter-0",
-    )
-    smeta = emodel.load_smry_meta()
-    assert set(smeta.columns) == set(
-        ["unit", "is_total", "is_rate", "is_historical", "keyword", "wgname", "get_num"]
-    )
-    assert len(smeta) == 931
-    assert "FOPT" in smeta.index
-
-
-@pytest.mark.usefixtures("app")
-def test_parameter_loading(testdata_folder):
-    emodel = EnsembleModel(
-        ensemble_name="iter-0",
-        ensemble_path=Path(testdata_folder)
-        / "01_drogon_ahm"
-        / "realization-*"
-        / "iter-0",
-    )
-    parameters = emodel.load_parameters()
-    assert "REAL" in parameters.columns
-    assert parameters["REAL"].dtype == np.dtype("int64")
-    assert len(parameters.columns) == 55
-
-
-@pytest.mark.usefixtures("app")
-def test_load_csv(testdata_folder):
-    emodel = EnsembleModel(
-        ensemble_name="iter-0",
-        ensemble_path=Path(testdata_folder)
-        / "01_drogon_ahm"
-        / "realization-*"
-        / "iter-0",
-    )
-    dframe = emodel.load_csv(Path("share") / "results" / "tables" / "rft.csv")
-    assert "REAL" in dframe.columns
-    assert dframe["REAL"].dtype == np.dtype("int64")
-    assert len(dframe.columns) == 14
-
-
-@pytest.mark.usefixtures("app")
-def test_webviz_store(testdata_folder):
-    emodel = EnsembleModel(
-        ensemble_name="iter-0",
-        ensemble_path=Path(testdata_folder)
-        / "01_drogon_ahm"
-        / "realization-*"
-        / "iter-0",
-    )
-    emodel.load_parameters()
-    assert len(emodel.webviz_store) == 1
-    emodel.load_smry()
-    assert len(emodel.webviz_store) == 2
-    emodel.load_smry(column_keys=["FOIP"])
-    assert len(emodel.webviz_store) == 3
-    emodel.load_smry(time_index="raw")
-    assert len(emodel.webviz_store) == 4
-    emodel.load_smry_meta()
-    assert len(emodel.webviz_store) == 5
-    emodel.load_smry_meta(column_keys=["R*", "GW?T*"])
-    assert len(emodel.webviz_store) == 6
-    emodel.load_csv(Path("share") / "results" / "tables" / "rft.csv")
-    assert len(emodel.webviz_store) == 7

tests/unit_tests/model_tests/test_ensemble_set_model.py

@@ -1,105 +0,0 @@
-from pathlib import Path
-
-import numpy as np
-import pytest
-
-from webviz_subsurface._models.ensemble_set_model import EnsembleSetModel
-
-
-@pytest.mark.usefixtures("app")
-def test_single_ensemble(testdata_folder):
-    emodel = EnsembleSetModel(
-        ensemble_paths={
-            "iter-0": str(
-                Path(testdata_folder / "01_drogon_ahm" / "realization-*" / "iter-0")
-            )
-        }
-    )
-    assert emodel.ens_folders == {"iter-0": Path(testdata_folder) / "01_drogon_ahm"}
-    smry = emodel.get_or_load_smry_cached()
-    assert len(smry.columns) == 934
-    assert len(smry["DATE"].unique()) == 2369
-    assert smry["ENSEMBLE"].unique() == ["iter-0"]
-    assert smry["ENSEMBLE"].dtype == np.dtype("O")
-    assert all(
-        np.issubdtype(dtype, np.number)
-        for dtype in smry.drop(["REAL", "ENSEMBLE", "DATE"], axis=1).dtypes
-    )
-
-    parameters = emodel.load_parameters()
-    assert all(col in parameters.columns for col in ["ENSEMBLE", "REAL"])
-    assert parameters["ENSEMBLE"].dtype == np.dtype("O")
-    assert parameters["REAL"].dtype == np.dtype("int64")
-    assert len(parameters.columns) == 56
-
-
-@pytest.mark.usefixtures("app")
-def test_smry_load_multiple_ensembles(testdata_folder):
-    emodel = EnsembleSetModel(
-        ensemble_paths={
-            "iter-0": str(
-                Path(testdata_folder / "01_drogon_ahm" / "realization-*" / "iter-0")
-            ),
-            "iter-3": str(
-                Path(testdata_folder / "01_drogon_ahm" / "realization-*" / "iter-3")
-            ),
-        }
-    )
-    smry = emodel.get_or_load_smry_cached()
-    assert len(smry.columns) == 934
-    assert len(smry["DATE"].unique()) == 4167
-    assert set(smry["ENSEMBLE"].unique()) == set(["iter-0", "iter-3"])
-    assert smry["ENSEMBLE"].dtype == np.dtype("O")
-    # assert smry["DATE"].dtype == np.dtype("O") # Fails due to wrong input data?
-    assert smry["REAL"].dtype == np.dtype("int64")
-    assert all(
-        np.issubdtype(dtype, np.number)
-        for dtype in smry.drop(["REAL", "ENSEMBLE", "DATE"], axis=1).dtypes
-    )
-    smeta = emodel.load_smry_meta()
-    assert set(smeta.columns) == set(
-        ["unit", "is_total", "is_rate", "is_historical", "keyword", "wgname", "get_num"]
-    )
-    assert len(smeta) == 931
-    assert "FOPT" in smeta.index
-
-    parameters = emodel.load_parameters()
-    assert all(col in parameters.columns for col in ["ENSEMBLE", "REAL"])
-    assert parameters["ENSEMBLE"].dtype == np.dtype("O")
-    assert parameters["REAL"].dtype == np.dtype("int64")
-    assert len(parameters.columns) == 56
-
-    dframe = emodel.load_csv(Path("share") / "results" / "tables" / "rft.csv")
-    assert "ENSEMBLE" in dframe.columns
-    assert dframe["ENSEMBLE"].dtype == np.dtype("O")
-    assert len(dframe["ENSEMBLE"].unique()) == 2
-    assert len(dframe.columns) == 15
-
-    with pytest.raises(KeyError) as exc:
-        emodel.load_csv("some_path")
-    assert (
-        exc.value.args[0]
-        == "No data found for load_csv with arguments: {'csv_file': 'some_path'}"
-    )
-
-
-@pytest.mark.usefixtures("app")
-def test_webvizstore(testdata_folder):
-    emodel = EnsembleSetModel(
-        ensemble_paths={
-            "iter-0": str(
-                Path(testdata_folder / "01_drogon_ahm" / "realization-*" / "iter-0")
-            ),
-            "iter-3": str(
-                Path(testdata_folder / "01_drogon_ahm" / "realization-*" / "iter-3")
-            ),
-        }
-    )
-    emodel.load_parameters()
-    assert len(emodel.webvizstore) == 2
-    emodel.get_or_load_smry_cached()
-    assert len(emodel.webvizstore) == 4
-    emodel.load_smry_meta()
-    assert len(emodel.webvizstore) == 6
-    emodel.load_csv(Path("share") / "results" / "tables" / "rft.csv")
-    assert len(emodel.webvizstore) == 8

tests/unit_tests/model_tests/test_gruptree_model.py

@@ -1,89 +0,0 @@
-import datetime
-from pathlib import Path
-from typing import Optional
-
-import pandas as pd
-import pytest
-from pandas._testing import assert_frame_equal
-
-from webviz_subsurface._models.gruptree_model import GruptreeModel, TreeType
-
-CHECK_COLUMNS = ["DATE", "CHILD", "KEYWORD", "PARENT"]
-ENSEMBLE = "01_drogon_ahm"
-GRUPTREE_FILE = "share/results/tables/gruptree.csv"
-
-
-@pytest.fixture(name="gruptree_model")
-def fixture_model(testdata_folder) -> GruptreeModel:
-    ens_path = Path(testdata_folder) / ENSEMBLE / "realization-*" / "iter-0"
-    return GruptreeModel(
-        ens_name="iter-0",
-        ens_path=ens_path,
-        gruptree_file=GRUPTREE_FILE,
-        tree_type="GRUPTREE",
-    )
-
-
-# Mock class that loads local csv file
-class MockGruptreeModel(GruptreeModel):
-    # pylint: disable=super-init-not-called
-    def __init__(self, tree_type: Optional[TreeType] = None):
-        self._tree_type = tree_type
-        df_files = pd.DataFrame([{"REAL": 0, "FULLPATH": "tests/data/gruptree.csv"}])
-        self._dataframe = self.read_ensemble_gruptree(df_files=df_files)
-
-
-@pytest.mark.usefixtures("app")
-def test_gruptree_model_init(testdata_folder, gruptree_model: GruptreeModel):
-    # Check that there is only one REAL (means that the gruptree is
-    # the same for all realizations)
-    assert gruptree_model.dataframe["REAL"].nunique() == 1
-
-    # Load gruptree table from realization-0 and compare with
-    # the dataframe from the gruptree_model
-    r0_path = f"{testdata_folder}/{ENSEMBLE}/realization-0/iter-0/{GRUPTREE_FILE}"
-    exp_df = pd.read_csv(r0_path)
-    exp_df["DATE"] = pd.to_datetime(exp_df["DATE"])
-    exp_df = exp_df.where(pd.notnull(exp_df), None)
-
-    assert_frame_equal(gruptree_model.dataframe[CHECK_COLUMNS], exp_df[CHECK_COLUMNS])
-
-
-@pytest.mark.usefixtures("app")
-def test_get_filtered_dataframe(gruptree_model: GruptreeModel):
-    # Test the get_filtered_dataframe function with terminal node different than FIELD
-    filtered_df = gruptree_model.get_filtered_dataframe(terminal_node="OP")
-    filtered_df = filtered_df[
-        filtered_df["DATE"] == filtered_df["DATE"].max()
-    ].reset_index()
-    exp_filtered_df = pd.DataFrame(
-        columns=["DATE", "CHILD", "KEYWORD", "PARENT"],
-        data=[
-            [datetime.datetime(year=2018, month=11, day=17), "OP", "GRUPTREE", "FIELD"],
-            [datetime.datetime(year=2018, month=11, day=17), "A1", "WELSPECS", "OP"],
-            [datetime.datetime(year=2018, month=11, day=17), "A2", "WELSPECS", "OP"],
-            [datetime.datetime(year=2018, month=11, day=17), "A3", "WELSPECS", "OP"],
-            [datetime.datetime(year=2018, month=11, day=17), "A4", "WELSPECS", "OP"],
-        ],
-    )
-    assert_frame_equal(filtered_df[CHECK_COLUMNS], exp_filtered_df)
-
-    # Test excl_wells_startswith and excl_wells_endswith
-    assert set(
-        gruptree_model.get_filtered_dataframe(
-            excl_well_startswith=["R_"],
-            excl_well_endswith=["3", "5"],
-        )["CHILD"].unique()
-    ) == {"FIELD", "OP", "RFT", "WI", "A1", "A2", "A4", "A6"}
-
-
-def test_tree_type_filtering():
-    mock_model = MockGruptreeModel(tree_type=TreeType.GRUPTREE)
-    assert "BRANPROP" not in mock_model.dataframe["KEYWORD"].unique()
-
-    mock_model = MockGruptreeModel(tree_type=TreeType.BRANPROP)
-    assert "GRUPTREE" not in mock_model.dataframe["KEYWORD"].unique()
-
-    # If tree_type is defaulted then the BRANPROP tree is selected
-    mock_model = MockGruptreeModel()
-    assert "GRUPTREE" not in mock_model.dataframe["KEYWORD"].unique()

tests/unit_tests/model_tests/test_property_statistics_model.py

@@ -1,42 +0,0 @@
-from pathlib import Path
-
-import pandas as pd
-from webviz_config.themes import default_theme
-
-from webviz_subsurface.plugins._property_statistics.models.property_statistics_model import (
-    PropertyStatisticsModel,
-)
-
-
-def get_data_df(testdata_folder: Path) -> pd.DataFrame:
-    return pd.read_csv(
-        testdata_folder
-        / "reek_test_data"
-        / "aggregated_data"
-        / "property_statistics.csv"
-    )
-
-
-def test_init(testdata_folder: Path) -> None:
-    data_df = get_data_df(testdata_folder)
-    model = PropertyStatisticsModel(dataframe=data_df, theme=default_theme)
-    assert set(model.dataframe.columns) == set(
-        [
-            "PROPERTY",
-            "ZONE",
-            "REGION",
-            "FACIES",
-            "Avg",
-            "Avg_Weighted",
-            "Max",
-            "Min",
-            "P10",
-            "P90",
-            "Stddev",
-            "SOURCE",
-            "ID",
-            "REAL",
-            "ENSEMBLE",
-            "label",
-        ]
-    )