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

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)

tests/unit_tests/model_tests/test_well_set_model.py

@@ -1,70 +0,0 @@
-from pathlib import Path
-
-import numpy as np
-import pytest
-import xtgeo
-
-from webviz_subsurface._models import WellSetModel
-
-
-@pytest.mark.usefixtures("app")
-def test_well_set_model(testdata_folder: Path) -> None:
-    wellfiles = [
-        testdata_folder / "reek_test_data" / "observed_data" / "wells" / well
-        for well in ["OP_1.w", "OP_2.w", "OP_3.w", "OP_4.w", "OP_5.w", "OP_6.w"]
-    ]
-
-    wmodel = WellSetModel(wellfiles=wellfiles)
-    assert set(wmodel.well_names) == set(
-        ["OP_1", "OP_2", "OP_3", "OP_4", "OP_5", "OP_6"]
-    )
-    for name, well in wmodel.wells.items():
-        assert isinstance(name, str)
-        assert isinstance(well, xtgeo.Well)
-    op_6 = wmodel.get_well("OP_6")
-    assert isinstance(op_6, xtgeo.Well)
-    assert op_6.name == "OP_6"
-
-
-@pytest.mark.usefixtures("app")
-def test_logs(testdata_folder: Path) -> None:
-    wmodel = WellSetModel(
-        wellfiles=[
-            testdata_folder / "reek_test_data" / "observed_data" / "wells" / "OP_6.w"
-        ],
-        zonelog="Zonelog",
-    )
-    well = wmodel.get_well("OP_6")
-    assert well.zonelogname == "Zonelog"
-
-
-@pytest.mark.usefixtures("app")
-def test_tvd_truncation(testdata_folder: Path) -> None:
-    wmodel = WellSetModel(
-        wellfiles=[
-            testdata_folder / "reek_test_data" / "observed_data" / "wells" / "OP_6.w"
-        ],
-        tvdmin=1000,
-        tvdmax=1500,
-    )
-    well = wmodel.get_well("OP_6")
-    assert well.dataframe["Z_TVDSS"].min() >= 1000
-    assert well.dataframe["Z_TVDSS"].max() <= 1501
-
-
-@pytest.mark.usefixtures("app")
-def test_get_fence(testdata_folder: Path) -> None:
-    wmodel = WellSetModel(
-        wellfiles=[
-            testdata_folder / "reek_test_data" / "observed_data" / "wells" / "OP_6.w"
-        ],
-        zonelog="Zonelog",
-    )
-    fence = wmodel.get_fence("OP_6")
-    assert isinstance(fence, np.ndarray)
-    # Test horizontal length
-    assert int(fence[:, 3].min()) == -40
-    assert int(fence[:, 3].max()) == 2713
-    # Test tvd
-    assert int(fence[:, 2].min()) == 0
-    assert int(fence[:, 2].max()) == 1643

tests/unit_tests/plugin_tests/test_grouptree.py

@@ -1,175 +0,0 @@
-import datetime
-from pathlib import Path
-from typing import List, Tuple
-
-import pandas as pd
-import pytest
-from _pytest.fixtures import SubRequest
-
-from webviz_subsurface._providers import EnsembleSummaryProvider
-from webviz_subsurface._providers.ensemble_summary_provider._provider_impl_arrow_presampled import (
-    ProviderImplArrowPresampled,
-)
-from webviz_subsurface.plugins._group_tree._utils._ensemble_group_tree_data import (
-    add_nodetype,
-)
-
-ADD_NODETYPE_CASES = [
-    # Group leaf nodes:
-    # NODE1 has summary data>0 and will be classified as prod and inj
-    # NODE2 has summary data==0 and will be classified as other
-    # NODE3 has no summary data and will be classified as other
-    # FIELD and TMPL are classified as all three types
-    (
-        pd.DataFrame(
-            columns=["DATE", "CHILD", "KEYWORD", "PARENT"],
-            data=[
-                ["2000-01-01", "FIELD", "GRUPTREE", None],
-                ["2000-01-01", "TMPL", "GRUPTREE", "FIELD"],
-                ["2000-01-01", "NODE1", "GRUPTREE", "TMPL"],
-                ["2000-01-01", "NODE2", "GRUPTREE", "TMPL"],
-                ["2000-01-01", "NODE3", "GRUPTREE", "TMPL"],
-            ],
-        ),
-        pd.DataFrame(
-            columns=[
-                "DATE",
-                "REAL",
-                "GGPR:NODE1",
-                "GGIR:NODE1",
-                "GGPR:NODE2",
-                "GGIR:NODE2",
-            ],
-            data=[
-                [datetime.date(2000, 1, 1), 0, 1, 1, 0, 0],
-            ],
-        ),
-        pd.DataFrame(
-            columns=[
-                "DATE",
-                "CHILD",
-                "KEYWORD",
-                "PARENT",
-                "IS_PROD",
-                "IS_INJ",
-                "IS_OTHER",
-            ],
-            data=[
-                ["2000-01-01", "FIELD", "GRUPTREE", None, True, True, True],
-                ["2000-01-01", "TMPL", "GRUPTREE", "FIELD", True, True, True],
-                ["2000-01-01", "NODE1", "GRUPTREE", "TMPL", True, True, False],
-                ["2000-01-01", "NODE2", "GRUPTREE", "TMPL", False, False, True],
-                ["2000-01-01", "NODE3", "GRUPTREE", "TMPL", False, False, True],
-            ],
-        ),
-    ),
-    # Well leaf nodes:
-    # WELL1 has WSTAT==1 and will be classified as producer
-    # WELL2 has WSTAT==2 and will be classified as injector
-    # WELL3 has first WSTAT==1 and then WSTAT==2 and will be classified as both
-    # WELL4 has WSTAT==0 and will be classified as other
-    # TMPL_A is classified as prod and inj
-    # TMPL_B is classified as other
-    (
-        pd.DataFrame(
-            columns=["DATE", "CHILD", "KEYWORD", "PARENT"],
-            data=[
-                ["2000-01-01", "FIELD", "GRUPTREE", None],
-                ["2000-01-01", "TMPL_A", "GRUPTREE", "FIELD"],
-                ["2000-01-01", "TMPL_B", "GRUPTREE", "FIELD"],
-                ["2000-01-01", "WELL1", "WELSPECS", "TMPL_A"],
-                ["2000-01-01", "WELL2", "WELSPECS", "TMPL_A"],
-                ["2000-01-01", "WELL3", "WELSPECS", "TMPL_A"],
-                ["2000-01-01", "WELL4", "WELSPECS", "TMPL_B"],
-            ],
-        ),
-        pd.DataFrame(
-            columns=[
-                "DATE",
-                "REAL",
-                "WSTAT:WELL1",
-                "WSTAT:WELL2",
-                "WSTAT:WELL3",
-                "WSTAT:WELL4",
-            ],
-            data=[
-                [datetime.date(2000, 1, 1), 0, 1, 2, 1, 0],
-                [datetime.date(2000, 2, 1), 0, 1, 2, 2, 0],
-            ],
-        ),
-        pd.DataFrame(
-            columns=[
-                "DATE",
-                "CHILD",
-                "KEYWORD",
-                "PARENT",
-                "IS_PROD",
-                "IS_INJ",
-                "IS_OTHER",
-            ],
-            data=[
-                ["2000-01-01", "FIELD", "GRUPTREE", None, True, True, True],
-                ["2000-01-01", "TMPL_A", "GRUPTREE", "FIELD", True, True, False],
-                ["2000-01-01", "TMPL_B", "GRUPTREE", "FIELD", False, False, True],
-                ["2000-01-01", "WELL1", "WELSPECS", "TMPL_A", True, False, False],
-                ["2000-01-01", "WELL2", "WELSPECS", "TMPL_A", False, True, False],
-                ["2000-01-01", "WELL3", "WELSPECS", "TMPL_A", True, True, False],
-                ["2000-01-01", "WELL4", "WELSPECS", "TMPL_B", False, False, True],
-            ],
-        ),
-    ),
-]
-
-
-@pytest.fixture(
-    name="testdata",
-    params=ADD_NODETYPE_CASES,
-)
-def fixture_provider(
-    request: SubRequest, tmp_path: Path
-) -> Tuple[pd.DataFrame, EnsembleSummaryProvider, pd.DataFrame]:
-    input_py = request.param
-    storage_dir = tmp_path
-    gruptree_df = input_py[0]
-    smry_df = input_py[1]
-    expected_df = input_py[2]
-
-    ProviderImplArrowPresampled.write_backing_store_from_ensemble_dataframe(
-        storage_dir, "dummy_key", smry_df
-    )
-    new_provider = ProviderImplArrowPresampled.from_backing_store(
-        storage_dir, "dummy_key"
-    )
-
-    if not new_provider:
-        raise ValueError("Failed to create EnsembleSummaryProvider")
-
-    return gruptree_df, new_provider, expected_df
-
-
-def test_add_nodetype(
-    testdata: Tuple[pd.DataFrame, EnsembleSummaryProvider, pd.DataFrame]
-) -> None:
-    """Test functionality for the add_nodetype function"""
-    gruptree_df = testdata[0]
-    provider = testdata[1]
-    expected_df = testdata[2]
-
-    columns_to_check = [
-        "DATE",
-        "CHILD",
-        "KEYWORD",
-        "PARENT",
-        "IS_PROD",
-        "IS_INJ",
-        "IS_OTHER",
-    ]
-
-    wells: List[str] = gruptree_df[gruptree_df["KEYWORD"] == "WELSPECS"][
-        "CHILD"
-    ].unique()
-
-    output = add_nodetype(gruptree_df, provider, wells, "FIELD")
-    pd.testing.assert_frame_equal(
-        output[columns_to_check], expected_df[columns_to_check]
-    )

tests/unit_tests/plugin_tests/test_simulation_time_series/mocks/derived_vectors_accessor_ensemble_summary_provider_mock.py

@@ -1,60 +0,0 @@
-from typing import List, Optional, Sequence
-
-import pandas as pd
-
-from webviz_subsurface._providers import Frequency
-
-from ....mocks.ensemble_summary_provider_dummy import EnsembleSummaryProviderDummy
-
-
-class EnsembleSummaryProviderMock(EnsembleSummaryProviderDummy):
-    """Mock implementation of EnsembleSummaryProvider for testing derived
-    ensemble vectors accessor.
-
-    Implements necessary methods for obtaining wanted test data
-    """
-
-    def __init__(self, df: pd.DataFrame) -> None:
-        super().__init__()
-        self._df = df
-        self._vectors: List[str] = [
-            elm for elm in df.columns if elm not in ["DATE", "REAL"]
-        ]
-        self._realizations: List[int] = list(df["REAL"]) if "REAL" in df.columns else []
-
-    #####################################
-    #
-    # Override methods
-    #
-    #####################################
-    def supports_resampling(self) -> bool:
-        return False
-
-    def realizations(self) -> List[int]:
-        return self._realizations
-
-    def vector_names(self) -> List[str]:
-        return self._vectors
-
-    def get_vectors_df(
-        self,
-        vector_names: Sequence[str],
-        __resampling_frequency: Optional[Frequency],
-        realizations: Optional[Sequence[int]] = None,
-    ) -> pd.DataFrame:
-        for elm in vector_names:
-            if elm not in self._vectors:
-                raise ValueError(
-                    f'Requested vector "{elm}" not among provider vectors!'
-                )
-        if realizations:
-            # Note: Reset index as providers reset index counter when filtering
-            # realization query.
-            output = (
-                self._df[["DATE", "REAL"] + list(vector_names)]
-                .loc[self._df["REAL"].isin(realizations)]
-                .reset_index()
-            )
-            output.drop("index", inplace=True, axis=1)
-            return output
-        return self._df[["DATE", "REAL"] + list(vector_names)]