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.py

@@ -1,255 +0,0 @@
-import datetime
-import os
-from pathlib import Path
-from typing import Optional
-
-import pandas as pd
-
-# The fmu.ensemble dependency resdata is only available for Linux,
-# hence, ignore any import exception here to make
-# it still possible to use the PvtPlugin on
-# machines with other OSes.
-#
-# NOTE: Functions in this file cannot be used
-#       on non-Linux OSes.
-try:
-    from fmu.ensemble import ScratchEnsemble
-except ImportError:
-    pass
-
-from webviz_subsurface._providers import (
-    EnsembleSummaryProviderFactory,
-    Frequency,
-    VectorMetadata,
-)
-
-
-# Helper function for generating per-realization CSV files based on aggregated CSV file
-def _split_aggr_csv_into_per_real(aggr_csvfile: str, output_folder: str) -> None:
-    df = pd.read_csv(aggr_csvfile)
-    df = df[df["ENSEMBLE"] == "iter-0"]
-    df = df.drop(columns="ENSEMBLE")
-
-    for real in range(0, 10):
-        real_df = df[df["REAL"] == real]
-        real_df = real_df.drop(columns="REAL")
-        os.makedirs(f"{output_folder}/realization-{real}/iter-0/", exist_ok=True)
-        real_df.to_csv(
-            f"{output_folder}/realization-{real}/iter-0/smry.csv", index=False
-        )
-
-
-# Helper function dumping values obtained via fmu to CSV file.
-# Used to find the expected values in "arrow" tests
-def _dump_smry_to_csv_using_fmu(
-    ens_path: str, time_index: str, output_csv_file: str
-) -> None:
-    scratch_ensemble = ScratchEnsemble("tempEnsName", paths=ens_path)
-    df = scratch_ensemble.load_smry(time_index=time_index)
-    df.sort_values(["DATE", "REAL"], inplace=True)
-
-    print("Dataframe shape::", df.shape)
-
-    unique_dates = df["DATE"].unique()
-    print("Num unique dates:", len(unique_dates))
-    print(unique_dates)
-
-    unique_reals = df["REAL"].unique()
-    print("Num unique reals:", len(unique_reals))
-    print(unique_reals)
-
-    df.to_csv(output_csv_file, index=False)
-
-
-def test_create_from_arrow_unsmry_lazy(testdata_folder: Path, tmp_path: Path) -> None:
-    ensemble_path = str(testdata_folder / "01_drogon_ahm/realization-*/iter-0")
-
-    # Used to generate test results
-    # _dump_smry_to_csv_using_fmu(ensemble_path, "monthly", "expected_smry.csv")
-
-    factory = EnsembleSummaryProviderFactory(tmp_path, allow_storage_writes=True)
-    provider = factory.create_from_arrow_unsmry_lazy(
-        ens_path=ensemble_path, rel_file_pattern="share/results/unsmry/*.arrow"
-    )
-
-    assert provider.supports_resampling()
-
-    assert provider.vector_metadata("FOPT") is not None
-
-    vecnames = provider.vector_names()
-    assert len(vecnames) == 931
-
-    dates = provider.dates(Frequency.MONTHLY)
-    assert len(dates) == 31
-    assert isinstance(dates[0], datetime.datetime)
-    assert dates[0] == datetime.datetime(2018, 1, 1)
-    assert dates[-1] == datetime.datetime(2020, 7, 1)
-
-    realizations = provider.realizations()
-    assert len(realizations) == 100
-    assert realizations[0] == 0
-    assert realizations[-1] == 99
-
-    vecdf = provider.get_vectors_df(["FOPR"], Frequency.MONTHLY)
-    assert vecdf.shape == (3100, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "FOPR"]
-    assert vecdf["DATE"].nunique() == 31
-    assert vecdf["REAL"].nunique() == 100
-    sampleddate = vecdf["DATE"][0]
-    assert isinstance(sampleddate, datetime.datetime)
-
-    vecdf = provider.get_vectors_df(["FOPR"], Frequency.MONTHLY, [5])
-    assert vecdf.shape == (31, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "FOPR"]
-    assert vecdf["DATE"].nunique() == 31
-    assert vecdf["REAL"].nunique() == 1
-    assert vecdf["REAL"][0] == 5
-
-
-def test_arrow_unsmry_lazy_vector_metadata(
-    testdata_folder: Path, tmp_path: Path
-) -> None:
-    ensemble_path = str(testdata_folder / "01_drogon_ahm/realization-*/iter-0")
-    factory = EnsembleSummaryProviderFactory(tmp_path, allow_storage_writes=True)
-    provider = factory.create_from_arrow_unsmry_lazy(
-        ens_path=ensemble_path, rel_file_pattern="share/results/unsmry/*.arrow"
-    )
-
-    meta: Optional[VectorMetadata] = provider.vector_metadata("FOPR")
-    assert meta is not None
-    assert meta.unit == "SM3/DAY"
-    assert meta.is_total is False
-    assert meta.is_rate is True
-    assert meta.is_historical is False
-    assert meta.keyword == "FOPR"
-    assert meta.wgname is None
-    assert meta.get_num == 0
-
-    meta = provider.vector_metadata("WOPTH:A6")
-    assert meta is not None
-    assert meta.unit == "SM3"
-    assert meta.is_total is True
-    assert meta.is_rate is False
-    assert meta.is_historical is True
-    assert meta.keyword == "WOPTH"
-    assert meta.wgname == "A6"
-    assert meta.get_num == 11
-
-    meta = provider.vector_metadata("FWCT")
-    assert meta is not None
-    assert meta.unit == ""
-    assert meta.is_total is False
-    assert meta.is_rate is True
-    assert meta.is_historical is False
-    assert meta.keyword == "FWCT"
-    assert meta.wgname is None
-    assert meta.get_num == 0
-
-
-def test_create_from_arrow_unsmry_presampled_monthly(
-    testdata_folder: Path, tmp_path: Path
-) -> None:
-    ensemble_path = testdata_folder / "01_drogon_ahm/realization-*/iter-0"
-
-    factory = EnsembleSummaryProviderFactory(tmp_path, allow_storage_writes=True)
-    provider = factory.create_from_arrow_unsmry_presampled(
-        ens_path=str(ensemble_path),
-        rel_file_pattern="share/results/unsmry/*.arrow",
-        sampling_frequency=Frequency.MONTHLY,
-    )
-
-    assert not provider.supports_resampling()
-
-    assert provider.vector_metadata("FOPT") is not None
-
-    vecnames = provider.vector_names()
-    assert len(vecnames) == 931
-
-    dates = provider.dates(None)
-    assert len(dates) == 31
-    assert isinstance(dates[0], datetime.datetime)
-    assert dates[0] == datetime.datetime(2018, 1, 1)
-    assert dates[-1] == datetime.datetime(2020, 7, 1)
-
-    realizations = provider.realizations()
-    assert len(realizations) == 100
-    assert realizations[0] == 0
-    assert realizations[-1] == 99
-
-    vecdf = provider.get_vectors_df(["FOPR"], None)
-    assert vecdf.shape == (3100, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "FOPR"]
-    assert vecdf["DATE"].nunique() == 31
-    assert vecdf["REAL"].nunique() == 100
-    sampleddate = vecdf["DATE"][0]
-    assert isinstance(sampleddate, datetime.datetime)
-
-
-def test_create_from_per_realization_csv_file(
-    testdata_folder: Path, tmp_path: Path
-) -> None:
-    _split_aggr_csv_into_per_real(
-        str(testdata_folder / "reek_test_data/aggregated_data/smry.csv"),
-        str(tmp_path / "fake_data"),
-    )
-
-    factory = EnsembleSummaryProviderFactory(tmp_path, allow_storage_writes=True)
-
-    ens_path = tmp_path / "fake_data/realization-*/iter-0"
-    csvfile = "smry.csv"
-    provider = factory.create_from_per_realization_csv_file(str(ens_path), csvfile)
-
-    vecnames = provider.vector_names()
-    assert len(vecnames) == 16
-    assert vecnames[0] == "FGIP"
-    assert vecnames[15] == "YEARS"
-
-    realizations = provider.realizations()
-    assert len(realizations) == 10
-
-    vecdf = provider.get_vectors_df(["FOPR"], None)
-    assert vecdf.shape == (380, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "FOPR"]
-    assert vecdf["REAL"].nunique() == 10
-    sampleddate = vecdf["DATE"][0]
-    assert isinstance(sampleddate, datetime.datetime)
-
-    vecdf = provider.get_vectors_df(["FOPR"], None, [1])
-    assert vecdf.shape == (38, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "FOPR"]
-    assert vecdf["REAL"].nunique() == 1
-
-
-def test_create_from_ensemble_csv(testdata_folder: Path, tmp_path: Path) -> None:
-    factory = EnsembleSummaryProviderFactory(tmp_path, allow_storage_writes=True)
-
-    csv_filename = (
-        testdata_folder / "reek_test_data" / "aggregated_data" / "smry_hm.csv"
-    )
-    provider = factory.create_from_ensemble_csv_file(csv_filename, "iter-0")
-
-    vecnames = provider.vector_names()
-    assert len(vecnames) == 473
-    assert vecnames[0] == "BPR:15,28,1"
-    assert vecnames[472] == "YEARS"
-
-    realizations = provider.realizations()
-    assert len(realizations) == 10
-
-    dates = provider.dates(None)
-    assert len(dates) == 38
-    assert isinstance(dates[0], datetime.datetime)
-    assert dates[0] == datetime.datetime(2000, 1, 1)
-    assert dates[-1] == datetime.datetime(2003, 2, 1)
-
-    vecdf = provider.get_vectors_df(["FOPR"], None)
-    assert vecdf.shape == (380, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "FOPR"]
-    assert vecdf["REAL"].nunique() == 10
-    sampleddate = vecdf["DATE"][0]
-    assert isinstance(sampleddate, datetime.datetime)
-
-    vecdf = provider.get_vectors_df(["FOPR"], None, [1])
-    assert vecdf.shape == (38, 3)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "FOPR"]
-    assert vecdf["REAL"].nunique() == 1

tests/unit_tests/provider_tests/test_ensemble_summary_provider_impl_arrow_lazy.py

@@ -1,388 +0,0 @@
-from datetime import datetime
-from pathlib import Path
-from typing import Dict
-
-import numpy as np
-import pyarrow as pa
-import pyarrow.compute as pc
-import pytest
-
-from webviz_subsurface._providers.ensemble_summary_provider._provider_impl_arrow_lazy import (
-    Frequency,
-    ProviderImplArrowLazy,
-    _find_first_non_increasing_date_pair,
-    _is_date_column_monotonically_increasing,
-)
-from webviz_subsurface._providers.ensemble_summary_provider.ensemble_summary_provider import (
-    EnsembleSummaryProvider,
-)
-
-
-def _add_mock_smry_meta_to_table(table: pa.Table) -> pa.Table:
-    schema = table.schema
-    for colname in schema.names:
-        is_rate = bool("_r" in colname)
-        is_total = bool("_t" in colname)
-
-        metadata = None
-        if is_rate or is_total:
-            metadata = {
-                b"unit": b"N/A",
-                b"is_rate": b"True" if is_rate else b"False",
-                b"is_total": b"True" if is_total else b"False",
-                b"is_historical": b"False",
-                b"keyword": b"UNKNOWN",
-            }
-
-        if metadata:
-            idx = schema.get_field_index(colname)
-            field = schema.field(idx)
-            field = field.with_metadata(metadata)
-            schema = schema.set(idx, field)
-
-    table = table.cast(schema)
-    return table
-
-
-def _split_into_per_realization_tables(table: pa.Table) -> Dict[int, pa.Table]:
-    per_real_tables: Dict[int, pa.Table] = {}
-    unique_reals = table.column("REAL").unique().to_pylist()
-    for real in unique_reals:
-        # pylint: disable=no-member
-        mask = pc.is_in(table["REAL"], value_set=pa.array([real]))
-        real_table = table.filter(mask).drop(["REAL"])
-        per_real_tables[real] = real_table
-
-    return per_real_tables
-
-
-def _create_provider_obj_with_data(
-    input_data: list,
-    storage_dir: Path,
-) -> EnsembleSummaryProvider:
-    # Turn rows into columns
-    columns_with_header = list(zip(*input_data))
-
-    input_dict = {}
-    for col in columns_with_header:
-        colname = col[0]
-        coldata = col[1:]
-        input_dict[colname] = coldata
-    input_table = pa.Table.from_pydict(input_dict)
-
-    input_table = _add_mock_smry_meta_to_table(input_table)
-
-    # Split into per realization tables
-    per_real_tables = _split_into_per_realization_tables(input_table)
-
-    ProviderImplArrowLazy.write_backing_store_from_per_realization_tables(
-        storage_dir, "dummy_key", per_real_tables
-    )
-    new_provider = ProviderImplArrowLazy.from_backing_store(storage_dir, "dummy_key")
-
-    if not new_provider:
-        raise ValueError("Failed to create EnsembleSummaryProvider")
-
-    return new_provider
-
-
-def test_create_with_dates_after_2262(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                                 "REAL", "A"],
-        [np.datetime64("2000-01-02T00:00", "ms"), 1,     10.0],
-        [np.datetime64("2500-12-20T23:59", "ms"), 1,     12.0],
-        [np.datetime64("2500-12-21T22:58", "ms"), 1,     13.0],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    dates = provider.dates(resampling_frequency=None)
-    assert len(dates) == 3
-    assert dates[0] == datetime(2000, 1, 2, 00, 00)
-    assert dates[1] == datetime(2500, 12, 20, 23, 59)
-    assert dates[2] == datetime(2500, 12, 21, 22, 58)
-
-
-def test_get_vector_names(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                            "REAL",  "A",  "C",   "Z"],
-        [np.datetime64("2023-12-20", "ms"),  0,      10.0,  1.0,  0.0 ],
-        [np.datetime64("2023-12-20", "ms"),  1,      12.0,  1.0,  0.0 ],
-        [np.datetime64("2023-12-21", "ms"),  1,      13.0,  1.0,  0.0 ],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    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"]
-
-    all_realizations = provider.realizations()
-    assert len(all_realizations) == 2
-
-
-def test_get_dates_without_resampling(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                            "REAL",  "A"],
-        [np.datetime64("2023-12-20", "ms"),  0,      10.0],
-        [np.datetime64("2023-12-20", "ms"),  1,      12.0],
-        [np.datetime64("2023-12-21", "ms"),  1,      13.0],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    all_realizations = provider.realizations()
-    assert len(all_realizations) == 2
-
-    all_dates = provider.dates(resampling_frequency=None)
-    assert len(all_dates) == 1
-    assert isinstance(all_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_dates_with_daily_resampling(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                            "REAL",  "A",],
-        [np.datetime64("2020-01-01", "ms"),  0,      10.0],
-        [np.datetime64("2020-01-04", "ms"),  0,      40.0],
-        [np.datetime64("2020-01-06", "ms"),  1,      60.0],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    all_realizations = provider.realizations()
-    assert len(all_realizations) == 2
-
-    all_dates = provider.dates(resampling_frequency=Frequency.DAILY)
-    assert len(all_dates) == 6
-    assert isinstance(all_dates[0], datetime)
-    assert all_dates[0] == datetime(2020, 1, 1)
-    assert all_dates[1] == datetime(2020, 1, 2)
-    assert all_dates[4] == datetime(2020, 1, 5)
-    assert all_dates[5] == datetime(2020, 1, 6)
-
-    r0_dates = provider.dates(resampling_frequency=Frequency.DAILY, realizations=[0])
-    assert len(r0_dates) == 4
-
-    r1_dates = provider.dates(resampling_frequency=Frequency.DAILY, realizations=[1])
-    assert len(r1_dates) == 1
-
-
-def test_get_vector_metadata(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                            "REAL",  "A",  "B_r",  "C_t",   "D_r_t"],
-        [np.datetime64("2023-12-20", "ms"),  0,      1.0,  10.0,   21.0,    31.0 ],
-        [np.datetime64("2023-12-20", "ms"),  1,      2.0,  12.0,   22.0,    32.0 ],
-        [np.datetime64("2023-12-21", "ms"),  1,      3.0,  13.0,   23.0,    33.0 ],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    meta = provider.vector_metadata("A")
-    assert meta is None
-
-    meta = provider.vector_metadata("B_r")
-    assert meta and meta.is_rate is True
-
-    meta = provider.vector_metadata("C_t")
-    assert meta and meta.is_total is True
-
-    meta = provider.vector_metadata("D_r_t")
-    assert meta and meta.is_rate is True
-    assert meta and meta.is_total is True
-
-
-def test_get_vectors_without_resampling(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                            "REAL",  "A",  "B"],
-        [np.datetime64("2023-12-20", "ms"),  0,      10.0,  21.0],
-        [np.datetime64("2023-12-20", "ms"),  1,      12.0,  22.0],
-        [np.datetime64("2023-12-21", "ms"),  1,      13.0,  23.0],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    all_vecnames = provider.vector_names()
-    assert len(all_vecnames) == 2
-
-    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(
-        ["B", "A"], resampling_frequency=None, realizations=[0]
-    )
-    assert vecdf.shape == (1, 4)
-    assert vecdf.columns.tolist() == ["DATE", "REAL", "B", "A"]
-
-
-def test_get_vectors_with_daily_resampling(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                            "REAL",  "TOT_t",  "RATE_r"],
-        [np.datetime64("2020-01-01", "ms"),  1,      10.0,     1.0],
-        [np.datetime64("2020-01-04", "ms"),  1,      40.0,     4.0],
-        [np.datetime64("2020-01-06", "ms"),  1,      60.0,     6.0],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    vecdf = provider.get_vectors_df(
-        ["TOT_t", "RATE_r"], resampling_frequency=Frequency.DAILY
-    )
-
-    date_arr = vecdf["DATE"].to_numpy()
-    assert date_arr[0] == np.datetime64("2020-01-01", "ms")
-    assert date_arr[1] == np.datetime64("2020-01-02", "ms")
-    assert date_arr[2] == np.datetime64("2020-01-03", "ms")
-    assert date_arr[3] == np.datetime64("2020-01-04", "ms")
-    assert date_arr[4] == np.datetime64("2020-01-05", "ms")
-    assert date_arr[5] == np.datetime64("2020-01-06", "ms")
-
-    # Check interpolation for the total column
-    tot_arr = vecdf["TOT_t"].to_numpy()
-    assert tot_arr[0] == 10
-    assert tot_arr[1] == 20
-    assert tot_arr[2] == 30
-    assert tot_arr[3] == 40
-    assert tot_arr[4] == 50
-    assert tot_arr[5] == 60
-
-    # Check backfill for the rate column
-    tot_arr = vecdf["RATE_r"].to_numpy()
-    assert tot_arr[0] == 1
-    assert tot_arr[1] == 4
-    assert tot_arr[2] == 4
-    assert tot_arr[3] == 4
-    assert tot_arr[4] == 6
-    assert tot_arr[5] == 6
-
-
-def test_get_vectors_for_date_without_resampling(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                            "REAL",  "A",   "B",   "C"],
-        [np.datetime64("2023-12-20", "ms"),  0,      10.0,  21.0,  31.0 ],
-        [np.datetime64("2023-12-20", "ms"),  1,      12.0,  22.0,  32.0 ],
-        [np.datetime64("2023-12-21", "ms"),  1,      13.0,  23.0,  33.0 ],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    all_dates = provider.dates(resampling_frequency=None)
-    assert len(all_dates) == 1
-
-    date_to_get = all_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 = all_dates[0]
-    vecdf = provider.get_vectors_for_date_df(date_to_get, ["A", "B"], [0])
-    assert vecdf.shape == (1, 3)
-    assert vecdf.columns.tolist() == ["REAL", "A", "B"]
-
-    date_to_get = all_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"]
-
-
-def test_get_vectors_for_date_with_resampling(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                            "REAL",  "TOT_t",  "RATE_r"],
-        [np.datetime64("2020-01-01", "ms"),  1,      10.0,     1.0],
-        [np.datetime64("2020-01-04", "ms"),  1,      40.0,     4.0],
-        [np.datetime64("2020-01-06", "ms"),  1,      60.0,     6.0],
-    ]
-    # fmt:on
-    provider = _create_provider_obj_with_data(input_data, tmp_path)
-
-    date_to_get = datetime(2020, 1, 3)
-
-    df = provider.get_vectors_for_date_df(date_to_get, ["TOT_t", "RATE_r"])
-    assert df.shape == (1, 3)
-
-    assert df["REAL"][0] == 1
-    assert df["TOT_t"][0] == 30.0
-    assert df["RATE_r"][0] == 4.0
-
-
-def test_monotonically_increasing_date_util_functions() -> None:
-    table_with_duplicate = pa.Table.from_pydict(
-        {
-            "DATE": [
-                np.datetime64("2020-01-01", "ms"),
-                np.datetime64("2020-01-02", "ms"),
-                np.datetime64("2020-01-02", "ms"),
-                np.datetime64("2020-01-03", "ms"),
-            ],
-        },
-    )
-
-    table_with_decrease = pa.Table.from_pydict(
-        {
-            "DATE": [
-                np.datetime64("2020-01-01", "ms"),
-                np.datetime64("2020-01-05", "ms"),
-                np.datetime64("2020-01-04", "ms"),
-                np.datetime64("2020-01-10", "ms"),
-            ],
-        },
-    )
-
-    assert not _is_date_column_monotonically_increasing(table_with_duplicate)
-    offending_pair = _find_first_non_increasing_date_pair(table_with_duplicate)
-    assert offending_pair[0] == np.datetime64("2020-01-02", "ms")
-    assert offending_pair[1] == np.datetime64("2020-01-02", "ms")
-
-    assert not _is_date_column_monotonically_increasing(table_with_decrease)
-    offending_pair = _find_first_non_increasing_date_pair(table_with_decrease)
-    assert offending_pair[0] == np.datetime64("2020-01-05", "ms")
-    assert offending_pair[1] == np.datetime64("2020-01-04", "ms")
-
-
-def test_create_with_repeated_dates(tmp_path: Path) -> None:
-    # fmt:off
-    input_data = [
-        ["DATE",                                 "REAL", "A"],
-        [np.datetime64("2000-01-02T00:00", "ms"), 1,     10.0],
-        [np.datetime64("2500-12-20T23:59", "ms"), 1,     11.0],
-        [np.datetime64("2500-12-20T23:59", "ms"), 1,     12.0],
-    ]
-    # fmt:on
-
-    with pytest.raises(ValueError):
-        _create_provider_obj_with_data(input_data, tmp_path)