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

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",
-        ]
-    )

tests/unit_tests/model_tests/test_surface_set_model.py

@@ -1,48 +0,0 @@
-from pathlib import Path
-
-import pytest
-import xtgeo
-
-from webviz_subsurface._datainput.fmu_input import find_surfaces
-from webviz_subsurface._models.surface_set_model import SurfaceSetModel
-
-
-@pytest.mark.usefixtures("app")
-def test_surface_set_model(testdata_folder):
-    ensemble_paths = {
-        "iter-0": str(
-            Path(testdata_folder / "01_drogon_ahm" / "realization-*" / "iter-0")
-        )
-    }
-
-    surface_table = find_surfaces(ensemble_paths)
-    surface_table = surface_table.drop("ENSEMBLE", axis=1)
-
-    smodel = SurfaceSetModel(surface_table)
-    assert set(smodel.attributes) == set(
-        [
-            "ds_extract_postprocess",
-            "amplitude_mean",
-            "ds_extract_geogrid",
-            "amplitude_rms",
-            "oilthickness",
-        ]
-    )
-    assert set(smodel.names_in_attribute("ds_extract_postprocess")) == set(
-        ["basevolantis", "topvolantis", "toptherys", "topvolon"]
-    )
-    real_surf = smodel.get_realization_surface(
-        attribute="ds_extract_postprocess", name="topvolon", realization=0
-    )
-    assert isinstance(real_surf, xtgeo.RegularSurface)
-    assert real_surf.values.mean() == pytest.approx(1735.42, 0.00001)
-    stat_surf = smodel.calculate_statistical_surface(
-        attribute="ds_extract_postprocess", name="topvolon"
-    )
-    assert isinstance(stat_surf, xtgeo.RegularSurface)
-    assert stat_surf.values.mean() == pytest.approx(1741.04, 0.00001)
-
-    stat_surf = smodel.calculate_statistical_surface(
-        attribute="ds_extract_postprocess", name="topvolon", realizations=[0, 1]
-    )
-    assert stat_surf.values.mean() == pytest.approx(1741.04, 0.00001)

tests/unit_tests/model_tests/test_well_attributes_model.py

@@ -1,110 +0,0 @@
-import io
-import json
-
-import numpy as np
-import pandas as pd
-import pytest
-
-from webviz_subsurface._models.well_attributes_model import WellAttributesModel
-
-LOAD_DATA_FUNCTION = (
-    "webviz_subsurface._models.well_attributes_model.WellAttributesModel._load_data"
-)
-
-
-def test_simplest_possible_input(mocker):
-    mocker.patch(
-        LOAD_DATA_FUNCTION,
-        lambda self: io.BytesIO(json.dumps({"version": "0.1", "wells": []}).encode()),
-    )
-    well_attr = WellAttributesModel("ens_name", "ens_path", "file_name")
-    assert well_attr.data == {}
-
-
-def test_not_implemented_version(mocker):
-    mocker.patch(
-        LOAD_DATA_FUNCTION,
-        lambda self: io.BytesIO(json.dumps({"version": "0.2", "wells": []}).encode()),
-    )
-    with pytest.raises(NotImplementedError):
-        WellAttributesModel("ens_name", "ens_path", "file_name")
-
-
-def test_object_properties(mocker):
-    mock_data = {
-        "version": "0.1",
-        "wells": [
-            {
-                "alias": {"eclipse": "OP_1"},
-                "attributes": {
-                    "attr1": "value1",
-                    "attr2": "value2",
-                },
-                "name": "OP_1",
-            },
-            {
-                "alias": {"eclipse": "OP_2"},
-                "attributes": {
-                    "attr1": "value1",
-                },
-                "name": "OP_2",
-            },
-        ],
-    }
-    mocker.patch(
-        LOAD_DATA_FUNCTION,
-        lambda self: io.BytesIO(json.dumps(mock_data).encode()),
-    )
-    well_attr = WellAttributesModel("ens_name", "ens_path", "file_name")
-
-    # Test categories
-    assert set(well_attr.categories) == {"attr1", "attr2"}
-
-    # Test data
-    assert well_attr.data == {
-        "OP_1": {
-            "attr1": "value1",
-            "attr2": "value2",
-        },
-        "OP_2": {
-            "attr1": "value1",
-        },
-    }
-
-    # Test category_dict (This will replace nan with Undefined)
-    assert well_attr.category_dict == {
-        "attr1": ["value1"],
-        "attr2": ["value2", "Undefined"],
-    }
-
-    # Test dataframe
-    pd.testing.assert_frame_equal(
-        well_attr.dataframe,
-        pd.DataFrame(
-            columns=["WELL", "attr1", "attr2"],
-            data=[["OP_1", "value1", "value2"], ["OP_2", "value1", np.nan]],
-        ),
-    )
-
-    # Test melted dataframe
-    df_melted = well_attr.dataframe_melted
-    assert df_melted.shape[0] == 4
-    assert df_melted.shape[1] == 3
-    assert set(df_melted["WELL"]) == {"OP_1", "OP_2"}
-    assert set(df_melted["CATEGORY"]) == {"attr1", "attr2"}
-    assert set(df_melted["VALUE"]) == {"value1", "value2", np.nan}
-
-    # This is the expected dataframe, but I'm not able to test it with
-    # assert_frame_equal because the row order of the melted dataframe is
-    # randomly changing.
-    #
-    # exp_df_melted = pd.DataFrame(
-    #     columns=["WELL", "CATEGORY", "VALUE"],
-    #     data=[
-    #         ["OP_1", "attr1", "value1"],
-    #         ["OP_2", "attr1", "value1"],
-    #         ["OP_1", "attr2", "value2"],
-    #         ["OP_2", "attr2", np.nan],
-    #     ],
-    # )
-    # pd.testing.assert_frame_equal(df, exp_df, check_like=True)