Fix logging of missing wildcard rft responses

The logging will now take into account the cases where well, time
or both are wildcards ('*')

Author: SAKavli

src/ert/config/rft_config.py

@@ -6,6 +6,7 @@
 import os
 import re
 from collections import defaultdict
+from copy import copy
 from dataclasses import InitVar, dataclass
 from functools import lru_cache
 from pathlib import Path
@@ -289,18 +290,33 @@ def _warn_about_missing_rft_responses(
         rft_data: dict[tuple[WellName, datetime.date], RFTConfig.ValidRFTEntry],
         rft_filename: str,
     ) -> None:
-        well_time_keys = {
+        well_times = {
             (well, time)
             for well, time_dict in self.data_to_read.items()
             for time in time_dict
         }
-        well_time_keys_rft_data = {(well, time.isoformat()) for well, time in rft_data}
-        well_time_without_response: set[tuple[str, str]] = (
-            well_time_keys - well_time_keys_rft_data
-        )
+        well_times_with_response = {(well, time.isoformat()) for well, time in rft_data}
+
+        well_times_to_warn: set[tuple[str, str]] = well_times - well_times_with_response
+
+        # Given well / time wildcard, only warn if there are no responses for
+        # the corresponding well / time value
+        wells_with_responses = {well for well, time in well_times_with_response}
+        times_with_responses = {time for well, time in well_times_with_response}
+        for well, time in copy(well_times_to_warn):
+            if well == "*" and time in times_with_responses:
+                well_times_to_warn.remove((well, time))
+            if time == "*" and well in wells_with_responses:
+                well_times_to_warn.remove((well, time))
+
+        # Only warn about wildcard well and time if there are no responses
+        if (wildcard_well_time := ("*", "*")) in well_times and len(
+            well_times_with_response
+        ) > 0:
+            well_times_to_warn.remove(wildcard_well_time)
 
         formatted_items = [
-            f"{well}: {time}" for well, time in sorted(well_time_without_response)
+            f"{well=} : {time=}" for well, time in sorted(well_times_to_warn)
         ]
         _warn_about_missing_responses(
             formatted_items, "well(s) at time(s)", rft_filename

tests/ert/unit_tests/config/test_rft_config.py

@@ -1,4 +1,5 @@
 import re
+import warnings
 from datetime import datetime
 from io import BytesIO
 from pathlib import Path
@@ -1288,7 +1289,8 @@ def test_that_approximate_missing_rft_values_keyword_sets_interpolation_to_true_
     assert rft_config.approximate_missing_values is expected_setting
 
 
-def test_that_missing_response_for_rft_well_raises_warning(mock_resfo_file, egrid):
+@pytest.fixture(name="setup_mock_resfo_file")
+def setup_mock_resfo_file(mock_resfo_file, egrid):
     mock_resfo_file(
         "/tmp/does_not_exist/BASE.RFT",
         [
@@ -1309,6 +1311,8 @@ def test_that_missing_response_for_rft_well_raises_warning(mock_resfo_file, egri
         egrid,
     )
 
+
+def test_that_missing_response_for_rft_well_raises_warning(setup_mock_resfo_file):
     rft_config = RFTConfig(
         input_files=["BASE.RFT"],
         data_to_read={
@@ -1321,29 +1325,14 @@ def test_that_missing_response_for_rft_well_raises_warning(mock_resfo_file, egri
 
     expected_warnings = [
         "Could not find responses for well(s) at time(s) in 'BASE.RFT':",
-        "NOT_A_WELL: 2000-01-01",
+        "well='NOT_A_WELL' : time='2000-01-01'",
     ]
     assert any(all(m in str(w) for m in expected_warnings) for w in warnings)
 
 
 def test_that_one_existing_and_one_missing_rft_response_warns_about_the_one_missing(
-    mock_resfo_file, egrid
+    setup_mock_resfo_file,
 ):
-    mock_resfo_file(
-        "/tmp/does_not_exist/BASE.RFT",
-        [
-            *cell_start(date=(1, 1, 2000), well_name="WELL"),
-            ("PRESSURE", float_arr([100.0, 200.0])),
-            ("SWAT    ", float_arr([0.1, 0.2])),
-            ("SGAS    ", float_arr([0.3, 0.4])),
-            ("DEPTH   ", float_arr([20.0, 30.0])),
-        ],
-    )
-    mock_resfo_file(
-        "/tmp/does_not_exist/BASE.EGRID",
-        egrid,
-    )
-
     rft_config = RFTConfig(
         input_files=["BASE.RFT"],
         data_to_read={
@@ -1357,26 +1346,12 @@ def test_that_one_existing_and_one_missing_rft_response_warns_about_the_one_miss
         rft_config.read_from_file("/tmp/does_not_exist", 1, 1)
     expected_warnings = [
         "Could not find responses for well(s) at time(s) in 'BASE.RFT':",
-        "WELL: 4000-01-01",
+        "well='WELL' : time='4000-01-01'",
     ]
     assert any(all(m in str(w) for m in expected_warnings) for w in warnings)
 
 
-def test_that_many_missing_response_warnings_are_truncated(mock_resfo_file, egrid):
-    mock_resfo_file(
-        "/tmp/does_not_exist/BASE.RFT",
-        [
-            *cell_start(date=(1, 1, 2000), well_name="WELL"),
-            ("PRESSURE", float_arr([100.0, 200.0])),
-            ("SWAT    ", float_arr([0.1, 0.2])),
-            ("SGAS    ", float_arr([0.3, 0.4])),
-            ("DEPTH   ", float_arr([20.0, 30.0])),
-        ],
-    )
-    mock_resfo_file(
-        "/tmp/does_not_exist/BASE.EGRID",
-        egrid,
-    )
+def test_that_many_missing_response_warnings_are_truncated(setup_mock_resfo_file):
     num_missing_responses = 9
     rft_config = RFTConfig(
         input_files=["BASE.RFT"],
@@ -1400,3 +1375,117 @@ def test_that_many_missing_response_warnings_are_truncated(mock_resfo_file, egri
     match = re.search(r"and (\d+) other missing responses", last_line)
     excess_warnings = int(match.group(1))
     assert excess_warnings == num_missing_responses - _RESPONSE_WARNING_LIMIT
+
+
+def test_that_wildcard_wells_are_not_warned_about(setup_mock_resfo_file):
+    rft_config = RFTConfig(
+        input_files=["BASE.RFT"],
+        data_to_read={
+            "*": {"2000-01-01": ["PRESSURE", "SWAT"]},
+        },
+    )
+    with warnings.catch_warnings():
+        warnings.simplefilter(  # Asserts no PostExperimentWarnings were raised
+            "error", PostExperimentWarning
+        )
+        rft_config.read_from_file("/tmp/does_not_exist", 1, 1)
+
+
+def test_that_wildcard_times_are_not_warned_about_given_any_well_response(
+    setup_mock_resfo_file,
+):
+    rft_config = RFTConfig(
+        input_files=["BASE.RFT"],
+        data_to_read={
+            "WELL": {"*": ["PRESSURE", "SWAT"]},
+        },
+    )
+    with warnings.catch_warnings():
+        warnings.simplefilter(  # Asserts no PostExperimentWarnings were raised
+            "error", PostExperimentWarning
+        )
+        rft_config.read_from_file("/tmp/does_not_exist", 1, 1)
+
+
+def test_that_wildcard_times_are_warned_about_given_no_well_response(
+    setup_mock_resfo_file,
+):
+    rft_config = RFTConfig(
+        input_files=["BASE.RFT"],
+        data_to_read={
+            "DIFFERENT_WELL": {"*": ["PRESSURE", "SWAT"]},
+        },
+    )
+    with pytest.warns(PostExperimentWarning) as warnings:
+        rft_config.read_from_file("/tmp/does_not_exist", 1, 1)
+
+    expected_warnings = [
+        "Could not find responses for well(s) at time(s)",
+        "well='DIFFERENT_WELL' : time='*'",
+    ]
+    # Assert one warning contains all expected warnings
+    assert any(all(e_w in str(w) for e_w in expected_warnings) for w in warnings)
+
+
+def test_that_wildcard_wells_are_warned_about_given_no_time_response(
+    setup_mock_resfo_file,
+):
+    rft_config = RFTConfig(
+        input_files=["BASE.RFT"],
+        data_to_read={
+            "*": {"2010-10-10": ["PRESSURE", "SWAT"]},
+        },
+    )
+    with pytest.warns(PostExperimentWarning) as warnings:
+        rft_config.read_from_file("/tmp/does_not_exist", 1, 1)
+
+    expected_warnings = [
+        "Could not find responses for well(s) at time(s)",
+        "well='*' : time='2010-10-10'",
+    ]
+    # Assert one warning contains all expected warnings
+    assert any(all(e_w in str(w) for e_w in expected_warnings) for w in warnings)
+
+
+def test_that_wildcard_well_with_wildcard_time_without_any_response_is_warned_about(
+    mock_resfo_file, egrid
+):
+    mock_resfo_file(
+        "/tmp/does_not_exist/BASE.RFT",
+        [],
+    )
+    mock_resfo_file(
+        "/tmp/does_not_exist/BASE.EGRID",
+        egrid,
+    )
+    rft_config = RFTConfig(
+        input_files=["BASE.RFT"],
+        data_to_read={
+            "*": {"*": ["PRESSURE", "SWAT"]},
+        },
+    )
+    with pytest.warns(PostExperimentWarning) as warnings:
+        rft_config.read_from_file("/tmp/does_not_exist", 1, 1)
+
+    expected_warnings = [
+        "Could not find responses for well(s) at time(s)",
+        "well='*' : time='*'",
+    ]
+    # Assert one warning contains all expected warnings
+    assert any(all(e_w in str(w) for e_w in expected_warnings) for w in warnings)
+
+
+def test_that_wildcard_well_with_wildcard_time_with_any_response_is_not_warned_about(
+    setup_mock_resfo_file,
+):
+    rft_config = RFTConfig(
+        input_files=["BASE.RFT"],
+        data_to_read={
+            "*": {"*": ["PRESSURE", "SWAT"]},
+        },
+    )
+    with warnings.catch_warnings():
+        warnings.simplefilter(  # Asserts no PostExperimentWarnings were raised
+            "error", PostExperimentWarning
+        )
+        rft_config.read_from_file("/tmp/does_not_exist", 1, 1)