dkist-processing-common 10.8.1rc1__py3-none-any.whl → 10.8.2__py3-none-any.whl

dkist_processing_common/tests/test_input_dataset.py

@@ -1,13 +1,17 @@
 import json
+from copy import copy
 from datetime import datetime
+from pathlib import Path
 from typing import Any
 from uuid import uuid4
 
 import pytest
 
-from dkist_processing_common.codecs.basemodel import basemodel_decoder
-from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.tags import Tag
+from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
+from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetObject
+from dkist_processing_common.tests.conftest import create_parameter_files
+from dkist_processing_common.tests.conftest import InputDatasetTask
 
 
 def input_dataset_frames_part_factory(bucket_count: int = 1) -> list[dict]:
@@ -43,9 +47,7 @@ def input_dataset_parameters_part_factory(
     ]
     if has_date:
         for data in result:
-            param_list = data["parameterValues"]
-            for item in param_list:
-                item["parameterValueStartDate"] = datetime(2022, 9, 14).isoformat()
+            data["parameterValueStartDate"] = datetime(2022, 9, 14).isoformat()[:10]
     if has_file:
         for data in result:
             param_list = data["parameterValues"]
@@ -64,42 +66,99 @@ def input_dataset_parameters_part_factory(
 @pytest.mark.parametrize(
     "input_dataset_parts",
     [
+        pytest.param((None, Tag.input_dataset_observe_frames()), id="empty"),
         pytest.param(
             (input_dataset_frames_part_factory(), Tag.input_dataset_observe_frames()),
-            id="observe_single_bucket",
+            id="single_bucket",
         ),
         pytest.param(
             (input_dataset_frames_part_factory(bucket_count=2), Tag.input_dataset_observe_frames()),
-            id="observe_multi_bucket",
+            id="multi_bucket",
         ),
+    ],
+)
+def test_input_dataset_observe_frames_part_document(
+    task_with_input_dataset, input_dataset_parts: tuple[Any, str]
+):
+    """
+    Given: A task with an input dataset observe frames part document tagged as such
+    When: Accessing the document via the InputDatasetMixIn
+    Then: The contents of the file are returned
+    """
+    doc_part, _ = input_dataset_parts
+    task = task_with_input_dataset
+    assert task.input_dataset_observe_frames_part_document == doc_part
+
+
+@pytest.mark.parametrize(
+    "input_dataset_parts",
+    [
+        pytest.param((None, Tag.input_dataset_calibration_frames()), id="empty"),
         pytest.param(
             (input_dataset_frames_part_factory(), Tag.input_dataset_calibration_frames()),
-            id="calib_single_bucket",
+            id="single_bucket",
         ),
         pytest.param(
             (
                 input_dataset_frames_part_factory(bucket_count=2),
                 Tag.input_dataset_calibration_frames(),
             ),
-            id="calib_multi_bucket",
+            id="multi_bucket",
+        ),
+    ],
+)
+def test_input_dataset_calibration_frames_part_document(
+    task_with_input_dataset, input_dataset_parts: tuple[Any, str]
+):
+    """
+    Given: A task with an input dataset calibration frames part document tagged as such
+    When: Accessing the document via the InputDatasetMixIn
+    Then: The contents of the file are returned
+    """
+    doc_part, _ = input_dataset_parts
+    task = task_with_input_dataset
+    assert task.input_dataset_calibration_frames_part_document == doc_part
+
+
+@pytest.mark.parametrize(
+    "input_dataset_parts",
+    [
+        pytest.param((None, Tag.input_dataset_parameters()), id="empty"),
+        pytest.param(
+            (input_dataset_parameters_part_factory(), Tag.input_dataset_parameters()),
+            id="single_param_no_date",
+        ),
+        pytest.param(
+            (
+                input_dataset_parameters_part_factory(parameter_count=2),
+                Tag.input_dataset_parameters(),
+            ),
+            id="multi_param_no_date",
+        ),
+        pytest.param(
+            (input_dataset_parameters_part_factory(has_date=True), Tag.input_dataset_parameters()),
+            id="single_param_with_date",
+        ),
+        pytest.param(
+            (
+                input_dataset_parameters_part_factory(parameter_count=2, has_date=True),
+                Tag.input_dataset_parameters(),
+            ),
+            id="multi_param_with_date",
         ),
     ],
 )
-def test_input_dataset_frames_part_document(
+def test_input_dataset_parameters_part_document(
     task_with_input_dataset, input_dataset_parts: tuple[Any, str]
 ):
     """
-    Given: A task with an input dataset frames part document already written to file
-    When: Reading the file into a validated model
-    Then: The correct contents of the file are loaded
+    Given: A task with an input dataset parameters part document tagged as such
+    When: Accessing the document via the InputDatasetMixIn
+    Then: The contents of the file are returned
     """
-    doc_part, tag = input_dataset_parts
+    doc_part, _ = input_dataset_parts
     task = task_with_input_dataset
-    doc_from_file = next(
-        task.read(tags=tag, decoder=basemodel_decoder, model=InputDatasetPartDocumentList)
-    )
-    frames = [frames.model_dump() for frames in doc_from_file.doc_list]
-    assert frames == doc_part
+    assert task.input_dataset_parameters_part_document == doc_part
 
 
 @pytest.mark.parametrize(
@@ -115,15 +174,24 @@ def test_input_dataset_frames_part_document(
         pytest.param(
             [
                 (input_dataset_frames_part_factory(), Tag.input_dataset_observe_frames()),
+                (None, Tag.input_dataset_calibration_frames()),
             ],
             id="observe1_cal0_single_bucket",
         ),
         pytest.param(
             [
+                (None, Tag.input_dataset_observe_frames()),
                 (input_dataset_frames_part_factory(), Tag.input_dataset_calibration_frames()),
             ],
             id="observe0_cal1_single_bucket",
         ),
+        pytest.param(
+            [
+                (None, Tag.input_dataset_observe_frames()),
+                (None, Tag.input_dataset_calibration_frames()),
+            ],
+            id="observe0_cal0_single_bucket",
+        ),
         pytest.param(
             [
                 (
@@ -143,11 +211,13 @@ def test_input_dataset_frames_part_document(
                     input_dataset_frames_part_factory(bucket_count=2),
                     Tag.input_dataset_observe_frames(),
                 ),
+                (None, Tag.input_dataset_calibration_frames()),
             ],
             id="observe1_cal0_multi_bucket",
         ),
         pytest.param(
             [
+                (None, Tag.input_dataset_observe_frames()),
                 (
                     input_dataset_frames_part_factory(bucket_count=2),
                     Tag.input_dataset_calibration_frames(),
@@ -155,17 +225,21 @@ def test_input_dataset_frames_part_document(
             ],
             id="observe0_cal1_multi_bucket",
         ),
+        pytest.param(
+            [
+                (None, Tag.input_dataset_observe_frames()),
+                (None, Tag.input_dataset_calibration_frames()),
+            ],
+            id="observe0_cal0_multi_bucket",
+        ),
     ],
 )
-def test_input_dataset_frames_combination(
-    task_with_input_dataset, input_dataset_parts: list[tuple[Any, str]]
-):
+def test_input_dataset_frames(task_with_input_dataset, input_dataset_parts: list[tuple[Any, str]]):
     """
-    Given: A task with both types of input dataset frame documents written to files
-    When: Reading the file and validating into models
-    Then: The correct files are returned by the input_dataset_objects method of InputDatasetFrames
+    Given: a task with the InputDatasetMixin
+    When: getting the frames in the input dataset
+    Then: it matches the frames used to create the input dataset
     """
-    # Given
     doc_parts = [part for part, _ in input_dataset_parts]
     task = task_with_input_dataset
     expected = []
@@ -173,29 +247,7 @@ def test_input_dataset_frames_combination(
         if part:
             expected.extend(flatten_frame_parts(part))
     expected_set = set(expected)
-    # When
-    frames = []
-    observe_frames = next(
-        task.read(
-            tags=Tag.input_dataset_observe_frames(),
-            decoder=basemodel_decoder,
-            model=InputDatasetPartDocumentList,
-        ),
-        None,
-    )
-    frames += observe_frames.doc_list if observe_frames else []
-    calibration_frames = next(
-        task.read(
-            tags=Tag.input_dataset_calibration_frames(),
-            decoder=basemodel_decoder,
-            model=InputDatasetPartDocumentList,
-        ),
-        None,
-    )
-    frames += calibration_frames.doc_list if calibration_frames else []
-    # Then
-    frames_objects = sum([f.input_dataset_objects for f in frames], [])
-    actual = [(frame.bucket, frame.object_key) for frame in frames_objects]
+    actual = [(frame.bucket, frame.object_key) for frame in task.input_dataset_frames]
     actual_set = set(actual)
     assert len(actual) == len(actual_set)
     assert actual_set.difference(expected_set) == set()
@@ -204,45 +256,114 @@ def test_input_dataset_frames_combination(
 @pytest.mark.parametrize(
     "input_dataset_parts",
     [
+        pytest.param((None, Tag.input_dataset_parameters()), id="empty"),
         pytest.param(
             (input_dataset_parameters_part_factory(), Tag.input_dataset_parameters()),
             id="single_param_no_date_no_file",
         ),
         pytest.param(
             (input_dataset_parameters_part_factory(has_file=True), Tag.input_dataset_parameters()),
-            id="single_param_no_date_with_file",
+            id="single_param_no_date",
         ),
         pytest.param(
-            (input_dataset_parameters_part_factory(has_date=True), Tag.input_dataset_parameters()),
-            id="single_param_with_date_no_file",
+            (
+                input_dataset_parameters_part_factory(parameter_count=2, has_file=True),
+                Tag.input_dataset_parameters(),
+            ),
+            id="multi_param_no_date",
         ),
         pytest.param(
             (
-                input_dataset_parameters_part_factory(has_date=True, has_file=True),
+                input_dataset_parameters_part_factory(parameter_value_count=2, has_file=True),
                 Tag.input_dataset_parameters(),
             ),
-            id="single_param_with_date_with_file",
+            id="multi_param_values_no_date",
         ),
         pytest.param(
             (
-                input_dataset_parameters_part_factory(parameter_count=2),
+                input_dataset_parameters_part_factory(has_date=True, has_file=True),
                 Tag.input_dataset_parameters(),
             ),
-            id="multi_param_no_date_no_file",
+            id="single_param_with_date",
         ),
         pytest.param(
             (
-                input_dataset_parameters_part_factory(parameter_count=2, has_date=True),
+                input_dataset_parameters_part_factory(
+                    parameter_count=2, has_date=True, has_file=True
+                ),
                 Tag.input_dataset_parameters(),
             ),
-            id="multi_param_with_date_no_file",
+            id="multi_param_with_date",
+        ),
+    ],
+)
+def test_input_dataset_parameters(
+    task_with_input_dataset, input_dataset_parts: list[tuple[Any, str]]
+):
+    """
+    Given: a task with the InputDatasetMixin
+    When: getting the parameters in the input dataset
+    Then: the names of the parameters match the keys in the returned dictionary
+    """
+    task = task_with_input_dataset
+    doc_part, _ = input_dataset_parts
+    doc_part = doc_part or []  # None case parsing of expected values
+    create_parameter_files(task, doc_part)
+    expected_parameters = {item["parameterName"]: item["parameterValues"] for item in doc_part}
+    for key, values in task.input_dataset_parameters.items():
+        assert key in expected_parameters
+        expected_values = expected_parameters[key]
+        # Iterate through multiple values if they exist
+        for value in values:
+            # Find the matching expected value for this value object
+            expected_value = [
+                item
+                for item in expected_values
+                if value.parameter_value_id == item["parameterValueId"]
+            ]
+            # Make sure there's only one value
+            assert len(expected_value) == 1
+            # Now check the value
+            expected_value = expected_value[0]
+            assert value.parameter_value == json.loads(
+                expected_value["parameterValue"], object_hook=task._decode_parameter_value
+            )
+            expected_date = expected_value.get("parameterValueStartDate", datetime(1, 1, 1))
+            assert value.parameter_value_start_date == expected_date
+
+
+@pytest.mark.parametrize(
+    "input_dataset_parts",
+    [
+        pytest.param((None, Tag.input_dataset_parameters()), id="empty"),
+        pytest.param(
+            (input_dataset_parameters_part_factory(), Tag.input_dataset_parameters()),
+            id="single_param_no_date_no_file",
+        ),
+        pytest.param(
+            (input_dataset_parameters_part_factory(has_file=True), Tag.input_dataset_parameters()),
+            id="single_param_no_date",
         ),
         pytest.param(
             (
                 input_dataset_parameters_part_factory(parameter_count=2, has_file=True),
                 Tag.input_dataset_parameters(),
             ),
-            id="multi_param_no_date_with_file",
+            id="multi_param_no_date",
+        ),
+        pytest.param(
+            (
+                input_dataset_parameters_part_factory(parameter_value_count=2, has_file=True),
+                Tag.input_dataset_parameters(),
+            ),
+            id="multi_param_values_no_date",
+        ),
+        pytest.param(
+            (
+                input_dataset_parameters_part_factory(has_date=True, has_file=True),
+                Tag.input_dataset_parameters(),
+            ),
+            id="single_param_with_date",
         ),
         pytest.param(
             (
@@ -251,30 +372,138 @@ def test_input_dataset_frames_combination(
                 ),
                 Tag.input_dataset_parameters(),
             ),
-            id="multi_param_with_date_with_file",
+            id="multi_param_with_date",
         ),
     ],
 )
-def test_input_dataset_parameters(task_with_input_dataset, input_dataset_parts: tuple[Any, str]):
+def test_input_dataset_parameter_objects(
+    task_with_input_dataset, input_dataset_parts: list[tuple[Any, str]]
+):
     """
-    Given: A task with an input dataset parameters part document written to file
-    When: Reading the file and validating into models
-    Then: The correct contents of the file, including file parameters, are loaded
+    Given: a task with the InputDatasetMixin
+    When: getting the parameters objects in the input dataset
+    Then: the InputDatsetObjects returned by the task method match the objects defined by the input
+        dataset doc part
     """
-    doc_part, tag = input_dataset_parts
     task = task_with_input_dataset
-    doc_from_file = next(
-        task.read(tags=tag, decoder=basemodel_decoder, model=InputDatasetPartDocumentList)
-    )
+    doc_part, _ = input_dataset_parts
+    doc_part = doc_part or []  # None case parsing of expected values
+
+    # Create a list of InputDatasetObjects from the input dataset doc part
+    expected_parameters = list()
+    for param_item in doc_part:
+        param_values_list = param_item["parameterValues"]
+        for param_value_dict in param_values_list:
+            if "__file__" in param_value_dict["parameterValue"]:
+                file_dict = json.loads(
+                    param_value_dict["parameterValue"], object_hook=task._decode_parameter_value
+                )
+                expected_parameters.append(
+                    InputDatasetObject(
+                        bucket=file_dict["bucket"], object_key=file_dict["objectKey"]
+                    )
+                )
+    # Check that each InputDatasetObject returned by the task is in the list of expected parameters
+    input_dataset_parameter_objects = task.input_dataset_parameter_objects
+    assert len(input_dataset_parameter_objects) == len(expected_parameters)
+    for input_dataset_object in input_dataset_parameter_objects:
+        assert input_dataset_object in expected_parameters
 
-    params = [params.model_dump() for params in doc_from_file.doc_list]
-    assert params == doc_part
-    expected_files = []
-    for item in doc_part or []:
-        for val in item["parameterValues"]:
-            if "__file__" in val["parameterValue"]:
-                file_dict = json.loads(val["parameterValue"])
-                expected_files.append(file_dict["__file__"])
-    file_objects = sum([d.input_dataset_objects for d in doc_from_file.doc_list], [])
-    file_objects_dump = [f.model_dump() for f in file_objects]
-    assert file_objects_dump == expected_files
+
+@pytest.mark.parametrize(
+    "input_parameter_dict",
+    [
+        {"bucket": "data", "objectKey": "parameters/805c46/714ff939158b4253859cde5e5d6f62c3.dat"},
+        {
+            "__file__": {
+                "bucket": "data",
+                "objectKey": "parameters/805c46/714ff939158b4253859cde5e5d6f62c3.dat",
+            }
+        },
+        {"key_name_1": "value_1", "key_name_2": "value_2", "key_name_3": "value_3"},
+    ],
+)
+def test_convert_parameter_file_to_path(recipe_run_id, input_parameter_dict: dict):
+    """
+    Given: a parameter value field to be json decoded
+    When: passing the parameter value string to the json decoder hook
+    Then: the hook passes non-file parameter strings without change and modifies file parameter strings
+        by replacing the __file__ dict in the value string with a bucket field, an objectKey field
+        and adds a param_path field and an is_file field
+    """
+    # Initial test with no tags
+    with InputDatasetTask(
+        recipe_run_id=recipe_run_id,
+        workflow_name="workflow_name",
+        workflow_version="workflow_version",
+    ) as task:
+        # Test with no tags...
+        input_dict = input_parameter_dict
+        output_dict = task._decode_parameter_value(input_dict)
+        if "__file__" not in input_dict:
+            assert input_dict == output_dict
+        else:
+            value_dict = input_dict["__file__"]
+            assert output_dict["bucket"] == value_dict["bucket"]
+            assert output_dict["objectKey"] == value_dict["objectKey"]
+            assert output_dict["is_file"]
+            assert output_dict["param_path"] is None
+        # Test with tags
+        if "__file__" not in input_dict:
+            output_dict = task._decode_parameter_value(input_dict)
+            assert input_dict == output_dict
+        else:
+            # Create the destination path
+            param_path = input_dict["__file__"]["objectKey"]
+            destination_path = task.scratch.absolute_path(param_path)
+            if not destination_path.parent.exists():
+                destination_path.parent.mkdir(parents=True, exist_ok=True)
+            destination_path.write_text(data="")
+            task.tag(path=destination_path, tags=Tag.parameter(destination_path.name))
+            output_dict = task._decode_parameter_value(input_dict)
+            value_dict = input_dict["__file__"]
+            assert output_dict["bucket"] == value_dict["bucket"]
+            assert output_dict["objectKey"] == value_dict["objectKey"]
+            assert output_dict["is_file"]
+            assert output_dict["param_path"] == destination_path
+
+
+@pytest.mark.parametrize(
+    "input_dataset_parts",
+    [
+        pytest.param(
+            [
+                (input_dataset_frames_part_factory(), Tag.input_dataset_observe_frames()),
+                (input_dataset_frames_part_factory(), Tag.input_dataset_observe_frames()),
+            ],
+            id="observe",
+        ),
+        pytest.param(
+            [
+                (input_dataset_frames_part_factory(), Tag.input_dataset_calibration_frames()),
+                (input_dataset_frames_part_factory(), Tag.input_dataset_calibration_frames()),
+            ],
+            id="calibration",
+        ),
+        pytest.param(
+            [
+                (input_dataset_frames_part_factory(), Tag.input_dataset_parameters()),
+                (input_dataset_frames_part_factory(), Tag.input_dataset_parameters()),
+            ],
+            id="params",
+        ),
+    ],
+)
+def test_multiple_input_dataset_parts(
+    task_with_input_dataset, input_dataset_parts: list[tuple[Any, str]]
+):
+    """
+    Given: a task with the InputDatasetMixin and multiple tagged input datasets
+    When: reading the input dataset document
+    Then: an error is raised
+    """
+    task = task_with_input_dataset
+    with pytest.raises(ValueError):
+        task.input_dataset_parameters_part_document
+        task.input_dataset_observe_frames_part_document
+        task.input_dataset_calibration_frames_part_document

dkist_processing_common/tests/test_parameters.py

@@ -18,22 +18,22 @@ import numpy as np
 import pytest
 from astropy.io import fits
 
-from dkist_processing_common.codecs.array import array_encoder
-from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.models.parameters import ParameterArmIdMixin
 from dkist_processing_common.models.parameters import ParameterBase
 from dkist_processing_common.models.parameters import ParameterWavelengthMixin
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import WorkflowTaskBase
-from dkist_processing_common.tests.test_input_dataset import input_dataset_frames_part_factory
-
-
-FITS_FILE = "fits.dat"
-NP_FILE = "np.npy"
+from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
 
 
 @pytest.fixture
-def input_dataset_parameters():
+def input_dataset_parameters(tmp_path):
+    fits_file_path = tmp_path / "fits.dat"
+    phdu = fits.PrimaryHDU(np.ones((3, 3)) * 3)
+    ihdu = fits.ImageHDU(np.ones((4, 4)) * 4)
+    fits.HDUList([phdu, ihdu]).writeto(fits_file_path)
+    np_file_path = tmp_path / "np.npy"
+    np.save(np_file_path, np.ones((3, 3)) * 4)
     return [
         {
             "parameterName": "basic_param",
@@ -106,15 +106,7 @@ def input_dataset_parameters():
             "parameterValues": [
                 {
                     "parameterValueId": 1,
-                    "parameterValue": json.dumps(
-                        {
-                            "__file__": {
-                                "bucket": "not_used",
-                                "objectKey": "not_used",
-                                "tag": Tag.parameter(FITS_FILE),
-                            }
-                        }
-                    ),
+                    "parameterValue": json.dumps({"param_path": str(fits_file_path)}),
                 }
             ],
         },
@@ -123,15 +115,7 @@ def input_dataset_parameters():
             "parameterValues": [
                 {
                     "parameterValueId": 1,
-                    "parameterValue": json.dumps(
-                        {
-                            "__file__": {
-                                "bucket": "not_used",
-                                "objectKey": "not_used",
-                                "tag": Tag.parameter(NP_FILE),
-                            }
-                        }
-                    ),
+                    "parameterValue": json.dumps({"param_path": str(np_file_path)}),
                 }
             ],
         },
@@ -145,14 +129,16 @@ def input_dataset_parts(input_dataset_parameters) -> tuple[Any, str]:
 
 @pytest.fixture()
 def task_class_with_parameters(parameter_class) -> Type[WorkflowTaskBase]:
-    class TaskWithParameters(WorkflowTaskBase):
+    class TaskWithParameters(WorkflowTaskBase, InputDatasetMixin):
         def __init__(self, recipe_run_id: int, workflow_name: str, workflow_version: str):
             super().__init__(
                 recipe_run_id=recipe_run_id,
                 workflow_name=workflow_name,
                 workflow_version=workflow_version,
             )
-            self.parameters = parameter_class(scratch=self.scratch)
+            self.parameters = parameter_class(
+                input_dataset_parameters=self.input_dataset_parameters
+            )
 
         def run(self) -> None:
             pass
@@ -163,21 +149,11 @@ def task_class_with_parameters(parameter_class) -> Type[WorkflowTaskBase]:
 @pytest.fixture()
 def task_with_parameters(task_with_input_dataset, task_class_with_parameters):
     task_class = task_class_with_parameters
-    with task_class(
+    return task_class(
         recipe_run_id=task_with_input_dataset.recipe_run_id,
         workflow_name=task_with_input_dataset.workflow_name,
         workflow_version=task_with_input_dataset.workflow_version,
-    ) as task:
-        phdu = fits.PrimaryHDU(np.ones((3, 3)) * 3)
-        ihdu = fits.ImageHDU(np.ones((4, 4)) * 4)
-        task.write(
-            data=fits.HDUList([phdu, ihdu]),
-            tags=Tag.parameter(FITS_FILE),
-            encoder=fits_hdulist_encoder,
-        )
-        task.write(data=np.ones((3, 3)) * 4, tags=Tag.parameter(NP_FILE), encoder=array_encoder)
-        yield task
-        task._purge()
+    )
 
 
 class FilledParametersNoObsTime(ParameterBase):
@@ -206,18 +182,18 @@ class FilledParametersWithObsTime(ParameterBase):
 
     @property
     def fits_file_parameter(self):
-        param_obj = self._find_most_recent_past_value("fits_file_parameter")
-        return self._load_param_value_from_fits(param_obj=param_obj)
+        param_dict = self._find_most_recent_past_value("fits_file_parameter")
+        return self._load_param_value_from_fits(param_dict)
 
     @property
     def non_primary_fits_file_parameter(self):
-        param_obj = self._find_most_recent_past_value("fits_file_parameter")
-        return self._load_param_value_from_fits(param_obj=param_obj, hdu=1)
+        param_dict = self._find_most_recent_past_value("fits_file_parameter")
+        return self._load_param_value_from_fits(param_dict, hdu=1)
 
     @property
     def numpy_file_parameter(self):
-        param_obj = self._find_most_recent_past_value("numpy_file_parameter")
-        return self._load_param_value_from_numpy_save(param_obj=param_obj)
+        param_dict = self._find_most_recent_past_value("numpy_file_parameter")
+        return self._load_param_value_from_numpy_save(param_dict)
 
 
 def parameter_class_with_obs_ip_start_time():
@@ -367,28 +343,3 @@ def test_mixins_error_with_no_arg():
     """
     with pytest.raises(TypeError):
         parameters = FilledWavelengthParameters(input_dataset_parameters={"foo": []})
-
-
-@pytest.mark.parametrize(
-    ("input_dataset_parts", "parameter_class"),
-    [
-        pytest.param(
-            [
-                (input_dataset_frames_part_factory(), Tag.input_dataset_parameters()),
-                (input_dataset_frames_part_factory(), Tag.input_dataset_parameters()),
-            ],
-            parameter_class_with_obs_ip_start_time(),
-            id="two_param_docs",
-        ),
-    ],
-)
-def test_multiple_input_dataset_parameter_parts(
-    request, input_dataset_parts: list[tuple[Any, str]], parameter_class
-):
-    """
-    Given: a task with multiple tagged input dataset parameter docs
-    When: initializing the parameter base
-    Then: an error is raised
-    """
-    with pytest.raises(ValueError, match="more than one parameter file"):
-        request.getfixturevalue("task_with_parameters")