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

tests/unit_tests/provider_tests/test_ensemble_summary_provider_impl_arrow_presampled.py

@@ -1,160 +0,0 @@
-from datetime import date, datetime
-from pathlib import Path
-
-import pandas as pd
-import pytest
-from _pytest.fixtures import SubRequest
-
-from webviz_subsurface._providers.ensemble_summary_provider._provider_impl_arrow_presampled import (
-    ProviderImplArrowPresampled,
-)
-from webviz_subsurface._providers.ensemble_summary_provider.ensemble_summary_provider import (
-    EnsembleSummaryProvider,
-)
-
-# fmt: off
-INPUT_DATA_DATETIME = [
-    ["DATE",                          "REAL",  "A",  "C",   "Z"],
-    [datetime(2021, 12, 20, 23, 59),  0,       10.0,  1.0,  0.0 ],
-    [datetime(2021, 12, 20, 23, 59),  1,       12.0,  1.0,  0.0 ],
-    [datetime(2021, 12, 21, 22, 58),  1,       13.0,  1.0,  0.0 ],
-]
-
-INPUT_DATA_AFTER_2262 = [
-    ["DATE",                          "REAL",  "A",  "C",   "Z"],
-    [datetime(2500, 12, 20, 23, 59),  0,       10.0,  1.0,  0.0 ],
-    [datetime(2500, 12, 20, 23, 59),  1,       12.0,  1.0,  0.0 ],
-    [datetime(2500, 12, 21, 22, 58),  1,       13.0,  1.0,  0.0 ],
-]
-
-INPUT_DATA_DATE = [
-    ["DATE",              "REAL",  "A",  "C",   "Z"],
-    [date(2022, 12, 20),  0,       10.0,  1.0,  0.0 ],
-    [date(2022, 12, 20),  1,       12.0,  1.0,  0.0 ],
-    [date(2022, 12, 21),  1,       13.0,  1.0,  0.0 ],
-]
-
-INPUT_DATA_STR = [
-    ["DATE",       "REAL",  "A",  "C",   "Z"],
-    ["2023-12-20",  0,      10.0,  1.0,  0.0 ],
-    ["2023-12-20",  1,      12.0,  1.0,  0.0 ],
-    ["2023-12-21",  1,      13.0,  1.0,  0.0 ],
-]
-# fmt: on
-
-
-@pytest.fixture(
-    name="provider",
-    params=[
-        INPUT_DATA_DATETIME,
-        INPUT_DATA_AFTER_2262,
-        INPUT_DATA_DATE,
-        INPUT_DATA_STR,
-    ],
-)
-def fixture_provider(request: SubRequest, tmp_path: Path) -> EnsembleSummaryProvider:
-    input_py = request.param
-    storage_dir = tmp_path
-
-    input_df = pd.DataFrame(input_py[1:], columns=input_py[0])
-
-    ProviderImplArrowPresampled.write_backing_store_from_ensemble_dataframe(
-        storage_dir, "dummy_key", input_df
-    )
-    new_provider = ProviderImplArrowPresampled.from_backing_store(
-        storage_dir, "dummy_key"
-    )
-
-    if not new_provider:
-        raise ValueError("Failed to create EnsembleSummaryProvider")
-
-    return new_provider
-
-
-def test_get_vector_names(provider: EnsembleSummaryProvider) -> None:
-    all_vecnames = provider.vector_names()
-    assert len(all_vecnames) == 3
-    assert all_vecnames == ["A", "C", "Z"]
-
-    non_const_vec_names = provider.vector_names_filtered_by_value(
-        exclude_constant_values=True
-    )
-    assert len(non_const_vec_names) == 1
-    assert non_const_vec_names == ["A"]
-
-    non_zero_vec_names = provider.vector_names_filtered_by_value(
-        exclude_all_values_zero=True
-    )
-    assert len(non_zero_vec_names) == 2
-    assert non_zero_vec_names == ["A", "C"]
-
-
-def test_get_realizations(provider: EnsembleSummaryProvider) -> None:
-    all_realizations = provider.realizations()
-    assert len(all_realizations) == 2
-
-
-def test_get_dates(provider: EnsembleSummaryProvider) -> None:
-    intersection_of_dates = provider.dates(resampling_frequency=None)
-    assert len(intersection_of_dates) == 1
-    assert isinstance(intersection_of_dates[0], datetime)
-
-    r0_dates = provider.dates(resampling_frequency=None, realizations=[0])
-    r1_dates = provider.dates(resampling_frequency=None, realizations=[1])
-    assert len(r0_dates) == 1
-    assert len(r1_dates) == 2
-
-
-def test_get_vectors(provider: EnsembleSummaryProvider) -> None:
-    all_vecnames = provider.vector_names()
-    assert len(all_vecnames) == 3
-
-    vecdf = provider.get_vectors_df(["A"], resampling_frequency=None)
-    assert vecdf.shape == (3, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "A"]
-
-    sampleddate = vecdf["DATE"][0]
-    assert isinstance(sampleddate, datetime)
-
-    vecdf = provider.get_vectors_df(["A"], resampling_frequency=None, realizations=[1])
-    assert vecdf.shape == (2, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "A"]
-
-    vecdf = provider.get_vectors_df(
-        ["C", "A"], resampling_frequency=None, realizations=[0]
-    )
-    assert vecdf.shape == (1, 4)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "C", "A"]
-
-
-def test_get_vectors_for_date(provider: EnsembleSummaryProvider) -> None:
-    intersection_of_dates = provider.dates(resampling_frequency=None)
-    assert len(intersection_of_dates) == 1
-
-    date_to_get = intersection_of_dates[0]
-    assert isinstance(date_to_get, datetime)
-
-    vecdf = provider.get_vectors_for_date_df(date_to_get, ["A"])
-    assert vecdf.shape == (2, 2)
-    assert vecdf.columns.tolist() == ["REAL", "A"]
-
-    date_to_get = intersection_of_dates[0]
-    vecdf = provider.get_vectors_for_date_df(date_to_get, ["A", "C"], [0])
-    assert vecdf.shape == (1, 3)
-    assert vecdf.columns.tolist() == ["REAL", "A", "C"]
-
-    date_to_get = intersection_of_dates[0]
-    vecdf = provider.get_vectors_for_date_df(date_to_get, ["A", "Z"], [0])
-    assert vecdf.shape == (1, 3)
-    assert vecdf.columns.tolist() == ["REAL", "A", "Z"]
-
-    real1_dates = provider.dates(resampling_frequency=None, realizations=[1])
-    assert len(real1_dates) == 2
-    date_to_get = real1_dates[0]
-    vecdf = provider.get_vectors_for_date_df(date_to_get, ["A", "Z"])
-    assert vecdf.shape == (2, 3)
-    assert vecdf.columns.tolist() == ["REAL", "A", "Z"]
-    date_to_get = real1_dates[1]
-    vecdf = provider.get_vectors_for_date_df(date_to_get, ["A", "Z"])
-    assert vecdf.shape == (1, 3)
-    assert vecdf.columns.tolist() == ["REAL", "A", "Z"]

tests/unit_tests/provider_tests/test_ensemble_summary_provider_resampling.py

@@ -1,320 +0,0 @@
-import numpy as np
-import pyarrow as pa
-
-from webviz_subsurface._providers.ensemble_summary_provider._resampling import (
-    Frequency,
-    generate_normalized_sample_dates,
-    interpolate_backfill,
-    sample_segmented_multi_real_table_at_date,
-)
-
-
-def _create_table_from_row_data(
-    per_row_input_data: list, schema: pa.Schema
-) -> pa.Table:
-    # Turn rows into columns
-    columns_with_header = list(zip(*per_row_input_data))
-
-    input_dict = {}
-    for col in columns_with_header:
-        colname = col[0]
-        coldata = col[1:]
-        input_dict[colname] = coldata
-
-    table = pa.Table.from_pydict(input_dict, schema=schema)
-
-    return table
-
-
-def test_generate_sample_dates_daily() -> None:
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-12-30"), np.datetime64("2021-01-05"), Frequency.DAILY
-    )
-    assert len(dates) == 7
-    assert dates[0] == np.datetime64("2020-12-30")
-    assert dates[-1] == np.datetime64("2021-01-05")
-
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-12-30T01:30"),
-        np.datetime64("2021-01-05T02:30"),
-        Frequency.DAILY,
-    )
-    assert len(dates) == 8
-    assert dates[0] == np.datetime64("2020-12-30")
-    assert dates[-1] == np.datetime64("2021-01-06")
-
-
-def test_generate_sample_dates_weekly() -> None:
-    # Mondays
-    #   2020-12-21
-    #   2020-12-28
-    #   2021-01-04
-    #   2021-01-11
-
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-12-28"), np.datetime64("2021-01-11"), Frequency.WEEKLY
-    )
-    assert len(dates) == 3
-    assert dates[0] == np.datetime64("2020-12-28")
-    assert dates[-1] == np.datetime64("2021-01-11")
-
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-12-27T00:01"),
-        np.datetime64("2021-01-05T02:30"),
-        Frequency.WEEKLY,
-    )
-    assert len(dates) == 4
-    assert dates[0] == np.datetime64("2020-12-21")
-    assert dates[-1] == np.datetime64("2021-01-11")
-
-
-def test_generate_sample_dates_monthly() -> None:
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-12-01"), np.datetime64("2021-01-01"), Frequency.MONTHLY
-    )
-    assert len(dates) == 2
-    assert dates[0] == np.datetime64("2020-12-01")
-    assert dates[-1] == np.datetime64("2021-01-01")
-
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-12-30"),
-        np.datetime64("2022-01-01T01:01"),
-        Frequency.MONTHLY,
-    )
-    assert len(dates) == 15
-    assert dates[0] == np.datetime64("2020-12-01")
-    assert dates[-1] == np.datetime64("2022-02-01")
-
-
-def test_generate_sample_dates_yearly() -> None:
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-01-01"), np.datetime64("2020-01-02"), Frequency.YEARLY
-    )
-    assert len(dates) == 2
-    assert dates[0] == np.datetime64("2020-01-01")
-    assert dates[-1] == np.datetime64("2021-01-01")
-
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-01-01"), np.datetime64("2022-01-01"), Frequency.YEARLY
-    )
-    assert len(dates) == 3
-    assert dates[0] == np.datetime64("2020-01-01")
-    assert dates[-1] == np.datetime64("2022-01-01")
-
-    dates = generate_normalized_sample_dates(
-        np.datetime64("2020-12-30"),
-        np.datetime64("2022-01-01T01:01"),
-        Frequency.YEARLY,
-    )
-    assert len(dates) == 4
-    assert dates[0] == np.datetime64("2020-01-01")
-    assert dates[-1] == np.datetime64("2023-01-01")
-
-
-def test_interpolate_backfill() -> None:
-    raw_x = np.array([0, 2, 4, 6])
-    raw_y = np.array([0, 20, 40, 60])
-
-    x = np.array([0, 2, 4, 6])
-    y = interpolate_backfill(x, raw_x, raw_y, -99, 99)
-    assert (y == raw_y).all()
-
-    x = np.array([-1, 1, 5, 7])
-    expected_y = np.array([-99, 20, 60, 99])
-    y = interpolate_backfill(x, raw_x, raw_y, -99, 99)
-    assert (y == expected_y).all()
-
-    x = np.array([-2, -1, 0, 3, 3, 6, 7, 8])
-    expected_y = np.array([-99, -99, 0, 40, 40, 60, 99, 99])
-    y = interpolate_backfill(x, raw_x, raw_y, -99, 99)
-    assert (y == expected_y).all()
-
-
-def test_sample_segmented_multi_real_table_at_date_with_single_real() -> None:
-    # pylint: disable=too-many-statements
-    # fmt:off
-    input_data = [
-        ["DATE",                             "REAL",  "T",   "R"],
-        [np.datetime64("2020-01-01", "ms"),  1,       10.0,  1],
-        [np.datetime64("2020-01-04", "ms"),  1,       40.0,  4],
-        [np.datetime64("2020-01-06", "ms"),  1,       60.0,  6],
-    ]
-    # fmt:on
-
-    schema = pa.schema(
-        [
-            pa.field("DATE", pa.timestamp("ms")),
-            pa.field("REAL", pa.int64()),
-            pa.field("T", pa.float32(), metadata={b"is_rate": b"False"}),
-            pa.field("R", pa.float32(), metadata={b"is_rate": b"True"}),
-        ]
-    )
-
-    table = _create_table_from_row_data(per_row_input_data=input_data, schema=schema)
-
-    # Exact hit, first actual date
-    sampledate = np.datetime64("2020-01-01", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 1
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["REAL"][0].as_py() == 1
-    assert res["T"][0].as_py() == 10
-    assert res["R"][0].as_py() == 1
-
-    # Exact hit, last actual date
-    sampledate = np.datetime64("2020-01-06", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 1
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["REAL"][0].as_py() == 1
-    assert res["T"][0].as_py() == 60
-    assert res["R"][0].as_py() == 6
-
-    # Exact hit, middle date
-    sampledate = np.datetime64("2020-01-04", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 1
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["REAL"][0].as_py() == 1
-    assert res["T"][0].as_py() == 40
-    assert res["R"][0].as_py() == 4
-
-    # Before first date
-    sampledate = np.datetime64("2019-01-01", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 1
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["REAL"][0].as_py() == 1
-    assert res["T"][0].as_py() == 10
-    assert res["R"][0].as_py() == 0
-
-    # After last date
-    sampledate = np.datetime64("2020-01-10", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 1
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["REAL"][0].as_py() == 1
-    assert res["T"][0].as_py() == 60
-    assert res["R"][0].as_py() == 0
-
-    # Interpolated
-    sampledate = np.datetime64("2020-01-02", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 1
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["REAL"][0].as_py() == 1
-    assert res["T"][0].as_py() == 20
-    assert res["R"][0].as_py() == 4
-
-    # Interpolated
-    sampledate = np.datetime64("2020-01-03", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 1
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["REAL"][0].as_py() == 1
-    assert res["T"][0].as_py() == 30
-    assert res["R"][0].as_py() == 4
-
-
-def test_sample_segmented_multi_real_table_at_date() -> None:
-    # pylint: disable=too-many-statements
-    # fmt:off
-    input_data = [
-        ["DATE",                             "REAL",  "T",    "R"],
-        [np.datetime64("2020-01-01", "ms"),  0,       10.0,   1],
-        [np.datetime64("2020-01-04", "ms"),  0,       40.0,   4],
-        [np.datetime64("2020-01-06", "ms"),  0,       60.0,   6],
-        [np.datetime64("2020-01-02", "ms"),  1,       2000.0,  200],
-        [np.datetime64("2020-01-05", "ms"),  1,       5000.0,  500],
-        [np.datetime64("2020-01-07", "ms"),  1,       7000.0,  700],
-    ]
-    # fmt:on
-
-    schema = pa.schema(
-        [
-            pa.field("DATE", pa.timestamp("ms")),
-            pa.field("REAL", pa.int64()),
-            pa.field("T", pa.float32(), metadata={b"is_rate": b"False"}),
-            pa.field("R", pa.float32(), metadata={b"is_rate": b"True"}),
-        ]
-    )
-
-    table = _create_table_from_row_data(per_row_input_data=input_data, schema=schema)
-
-    # Exact hit on first date in R=0
-    sampledate = np.datetime64("2020-01-01", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 2
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["DATE"].to_numpy()[1] == sampledate
-    assert res["REAL"][0].as_py() == 0
-    assert res["REAL"][1].as_py() == 1
-    assert res["T"][0].as_py() == 10
-    assert res["T"][1].as_py() == 2000
-    assert res["R"][0].as_py() == 1
-    assert res["R"][1].as_py() == 0
-
-    # Exact hit on first date in R=1
-    sampledate = np.datetime64("2020-01-02", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 2
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["DATE"].to_numpy()[1] == sampledate
-    assert res["REAL"][0].as_py() == 0
-    assert res["REAL"][1].as_py() == 1
-    assert res["T"][0].as_py() == 20
-    assert res["T"][1].as_py() == 2000
-    assert res["R"][0].as_py() == 4
-    assert res["R"][1].as_py() == 200
-
-    # Exact hit on last actual date in R=0
-    sampledate = np.datetime64("2020-01-06", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 2
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["DATE"].to_numpy()[1] == sampledate
-    assert res["REAL"][0].as_py() == 0
-    assert res["REAL"][1].as_py() == 1
-    assert res["T"][0].as_py() == 60
-    assert res["T"][1].as_py() == 6000
-    assert res["R"][0].as_py() == 6
-    assert res["R"][1].as_py() == 700
-
-    # Exact hit on last actual date in R=1
-    sampledate = np.datetime64("2020-01-07", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 2
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["DATE"].to_numpy()[1] == sampledate
-    assert res["REAL"][0].as_py() == 0
-    assert res["REAL"][1].as_py() == 1
-    assert res["T"][0].as_py() == 60
-    assert res["T"][1].as_py() == 7000
-    assert res["R"][0].as_py() == 0
-    assert res["R"][1].as_py() == 700
-
-    # Interpolated
-    sampledate = np.datetime64("2020-01-02", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 2
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["DATE"].to_numpy()[1] == sampledate
-    assert res["REAL"][0].as_py() == 0
-    assert res["REAL"][1].as_py() == 1
-    assert res["T"][0].as_py() == 20
-    assert res["T"][1].as_py() == 2000
-    assert res["R"][0].as_py() == 4
-    assert res["R"][1].as_py() == 200
-
-    # Interpolated
-    sampledate = np.datetime64("2020-01-03", "ms")
-    res = sample_segmented_multi_real_table_at_date(table, sampledate)
-    assert res.num_rows == 2
-    assert res["DATE"].to_numpy()[0] == sampledate
-    assert res["DATE"].to_numpy()[1] == sampledate
-    assert res["REAL"][0].as_py() == 0
-    assert res["REAL"][1].as_py() == 1
-    assert res["T"][0].as_py() == 30
-    assert res["T"][1].as_py() == 3000
-    assert res["R"][0].as_py() == 4
-    assert res["R"][1].as_py() == 500

tests/unit_tests/provider_tests/test_ensemble_table_provider.py

@@ -1,190 +0,0 @@
-from pathlib import Path
-from typing import Dict, Optional
-
-import pandas as pd
-
-from webviz_subsurface._providers import (
-    ColumnMetadata,
-    EnsembleTableProvider,
-    EnsembleTableProviderFactory,
-)
-from webviz_subsurface._providers.ensemble_table_provider import (
-    EnsembleTableProviderImplArrow,
-)
-
-
-def _create_synthetic_table_provider(
-    storage_dir: Path,
-) -> EnsembleTableProvider:
-    # fmt: off
-    input_data = [
-        ["REAL",  "A",   "B",  "STR" ],
-        [     0,  1.0,  11.0,   "aa" ],
-        [     0,  2.0,  12.0,   "bb" ],
-        [     0,  3.0,  13.0,   "cc" ],
-        [     1,  4.0,  14.0,   "dd" ],
-        [     1,  5.0,  15.0,   "ee" ],
-        [     1,  6.0,  16.0,   "ff" ],
-        [     1,  7.0,  17.0,   "gg" ],
-    ]
-    # fmt: on
-
-    input_df = pd.DataFrame(input_data[1:], columns=input_data[0])
-
-    provider: Optional[EnsembleTableProvider]
-
-    EnsembleTableProviderImplArrow.write_backing_store_from_ensemble_dataframe(
-        storage_dir, "dummy_key", input_df
-    )
-    provider = EnsembleTableProviderImplArrow.from_backing_store(
-        storage_dir, "dummy_key"
-    )
-
-    if not provider:
-        raise ValueError("Failed to create EnsembleTableProvider")
-
-    return provider
-
-
-def test_synthetic_get_column_data(testdata_folder: Path) -> None:
-    model = _create_synthetic_table_provider(testdata_folder)
-    assert model.column_names() == ["A", "B", "STR"]
-    assert model.realizations() == [0, 1]
-
-    df = model.get_column_data(["A"])
-    assert df.shape == (7, 2)
-    assert df.columns.tolist() == ["REAL", "A"]
-
-    df = model.get_column_data(["STR"], [1])
-    assert df.shape == (4, 2)
-    assert df.columns.tolist() == ["REAL", "STR"]
-
-    assert model.column_metadata("REAL") is None
-
-
-def test_create_from_aggregated_csv_file_smry_csv(
-    testdata_folder: Path, tmp_path: Path
-) -> None:
-    factory = EnsembleTableProviderFactory(tmp_path, allow_storage_writes=True)
-    provider = factory.create_from_ensemble_csv_file(
-        testdata_folder / "reek_test_data" / "aggregated_data" / "smry.csv"
-    )
-
-    assert len(provider.column_names()) == 17
-    assert provider.column_names()[0] == "DATE"
-    assert provider.column_names()[16] == "YEARS"
-
-    assert len(provider.realizations()) == 40
-
-    valdf = provider.get_column_data(["YEARS"])
-    assert len(valdf.columns) == 2
-    assert valdf.columns[0] == "REAL"
-    assert valdf.columns[1] == "YEARS"
-    assert valdf["REAL"].nunique() == 40
-
-    valdf = provider.get_column_data(["YEARS"], [0, 39, 10])
-    assert len(valdf.columns) == 2
-    assert valdf.columns[0] == "REAL"
-    assert valdf.columns[1] == "YEARS"
-    assert valdf["REAL"].nunique() == 3
-
-    # No metadata in csv files
-    meta: Optional[ColumnMetadata] = provider.column_metadata("FOPR")
-    assert meta is None
-
-
-def test_create_from_per_realization_csv_file(
-    testdata_folder: Path, tmp_path: Path
-) -> None:
-    factory = EnsembleTableProviderFactory(tmp_path, allow_storage_writes=True)
-    provider = factory.create_from_per_realization_csv_file(
-        str(testdata_folder / "01_drogon_ahm/realization-*/iter-0"),
-        "share/results/tables/rft.csv",
-    )
-
-    all_column_names = provider.column_names()
-    # print(all_column_names)
-    assert len(all_column_names) == 13
-
-    assert len(provider.realizations()) == 100
-
-    valdf = provider.get_column_data(["CONIDX"], [2])
-    assert valdf.shape == (218, 2)
-    assert valdf.columns[0] == "REAL"
-    assert valdf.columns[1] == "CONIDX"
-    assert valdf["REAL"].unique() == [2]
-    assert valdf["CONIDX"].nunique() == 24
-    assert sorted(valdf["CONIDX"].unique()) == list(range(1, 25))
-
-    # No metadata in csv files
-    meta: Optional[ColumnMetadata] = provider.column_metadata("CONIDX")
-    assert meta is None
-
-
-def test_create_from_per_realization_arrow_file(
-    testdata_folder: Path, tmp_path: Path
-) -> None:
-    factory = EnsembleTableProviderFactory(tmp_path, allow_storage_writes=True)
-    provider = factory.create_from_per_realization_arrow_file(
-        str(testdata_folder / "01_drogon_ahm/realization-*/iter-0"),
-        "share/results/unsmry/*arrow",
-    )
-
-    valdf = provider.get_column_data(provider.column_names())
-    assert valdf.shape[0] == 25284
-    assert "FOPT" in valdf.columns
-    assert valdf["REAL"].nunique() == 100
-
-    # Test metadata
-    meta: Optional[ColumnMetadata] = provider.column_metadata("FOPR")
-    assert meta is not None
-    assert meta.unit == "SM3/DAY"
-
-
-def test_create_from_per_realization_parameter_file(
-    testdata_folder: Path, tmp_path: Path
-) -> None:
-    factory = EnsembleTableProviderFactory(tmp_path, allow_storage_writes=True)
-    provider = factory.create_from_per_realization_parameter_file(
-        str(testdata_folder / "01_drogon_ahm/realization-*/iter-0")
-    )
-
-    valdf = provider.get_column_data(provider.column_names())
-    assert "GLOBVAR:FAULT_SEAL_SCALING" in valdf.columns
-    assert valdf["REAL"].nunique() == 100
-
-    # No metadata in parameter files
-    meta: Optional[ColumnMetadata] = provider.column_metadata(
-        "GLOBVAR:FAULT_SEAL_SCALING"
-    )
-    assert meta is None
-
-
-def test_create_provider_set_from_aggregated_csv_file(tmp_path: Path) -> None:
-    """This tests importing a csv file with an ensemble column with multiple
-    ensembles. It will return a dictionary of providers, one for each ensemble.
-    """
-    factory = EnsembleTableProviderFactory(tmp_path, allow_storage_writes=True)
-    provider_set: Dict[
-        str, EnsembleTableProvider
-    ] = factory.create_provider_set_from_aggregated_csv_file("tests/data/volumes.csv")
-    assert set(provider_set.keys()) == {"iter-0", "iter-1"}
-
-    for _, provider in provider_set.items():
-        valdf = provider.get_column_data(provider.column_names())
-        print(valdf)
-        print(provider.column_names())
-        assert set(valdf["REAL"].unique()) == {0, 1}
-        assert {
-            "ZONE",
-            "REGION",
-            "BULK_OIL",
-            "PORE_OIL",
-            "HCPV_OIL",
-            "STOIIP_OIL",
-            "SOURCE",
-        }.issubset(set(provider.column_names()))
-
-        # No metadata in csv files
-        meta: Optional[ColumnMetadata] = provider.column_metadata("ZONE")
-        assert meta is None