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

dkist_processing_common/tests/test_input_dataset.py

@@ -1,17 +1,13 @@
 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]:
@@ -47,7 +43,9 @@ def input_dataset_parameters_part_factory(
     ]
     if has_date:
         for data in result:
-            data["parameterValueStartDate"] = datetime(2022, 9, 14).isoformat()[:10]
+            param_list = data["parameterValues"]
+            for item in param_list:
+                item["parameterValueStartDate"] = datetime(2022, 9, 14).isoformat()
     if has_file:
         for data in result:
             param_list = data["parameterValues"]
@@ -66,99 +64,42 @@ 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="single_bucket",
+            id="observe_single_bucket",
         ),
         pytest.param(
             (input_dataset_frames_part_factory(bucket_count=2), Tag.input_dataset_observe_frames()),
-            id="multi_bucket",
+            id="observe_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="single_bucket",
+            id="calib_single_bucket",
         ),
         pytest.param(
             (
                 input_dataset_frames_part_factory(bucket_count=2),
                 Tag.input_dataset_calibration_frames(),
             ),
-            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",
+            id="calib_multi_bucket",
         ),
     ],
 )
-def test_input_dataset_parameters_part_document(
+def test_input_dataset_frames_part_document(
     task_with_input_dataset, input_dataset_parts: tuple[Any, str]
 ):
     """
-    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
+    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
     """
-    doc_part, _ = input_dataset_parts
+    doc_part, tag = input_dataset_parts
     task = task_with_input_dataset
-    assert task.input_dataset_parameters_part_document == doc_part
+    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
 
 
 @pytest.mark.parametrize(
@@ -174,24 +115,15 @@ def test_input_dataset_parameters_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(
             [
                 (
@@ -211,13 +143,11 @@ def test_input_dataset_parameters_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(),
@@ -225,21 +155,17 @@ def test_input_dataset_parameters_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(task_with_input_dataset, input_dataset_parts: list[tuple[Any, str]]):
+def test_input_dataset_frames_combination(
+    task_with_input_dataset, input_dataset_parts: list[tuple[Any, str]]
+):
     """
-    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: 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
     doc_parts = [part for part, _ in input_dataset_parts]
     task = task_with_input_dataset
     expected = []
@@ -247,7 +173,29 @@ def test_input_dataset_frames(task_with_input_dataset, input_dataset_parts: list
         if part:
             expected.extend(flatten_frame_parts(part))
     expected_set = set(expected)
-    actual = [(frame.bucket, frame.object_key) for frame in task.input_dataset_frames]
+    # 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_set = set(actual)
     assert len(actual) == len(actual_set)
     assert actual_set.difference(expected_set) == set()
@@ -256,114 +204,45 @@ def test_input_dataset_frames(task_with_input_dataset, input_dataset_parts: list
 @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",
+            id="single_param_no_date_with_file",
         ),
         pytest.param(
-            (
-                input_dataset_parameters_part_factory(parameter_value_count=2, has_file=True),
-                Tag.input_dataset_parameters(),
-            ),
-            id="multi_param_values_no_date",
+            (input_dataset_parameters_part_factory(has_date=True), Tag.input_dataset_parameters()),
+            id="single_param_with_date_no_file",
         ),
         pytest.param(
             (
                 input_dataset_parameters_part_factory(has_date=True, has_file=True),
                 Tag.input_dataset_parameters(),
             ),
-            id="single_param_with_date",
+            id="single_param_with_date_with_file",
         ),
         pytest.param(
             (
-                input_dataset_parameters_part_factory(
-                    parameter_count=2, has_date=True, has_file=True
-                ),
-                Tag.input_dataset_parameters(),
-            ),
-            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),
+                input_dataset_parameters_part_factory(parameter_count=2),
                 Tag.input_dataset_parameters(),
             ),
-            id="multi_param_no_date",
+            id="multi_param_no_date_no_file",
         ),
         pytest.param(
             (
-                input_dataset_parameters_part_factory(parameter_value_count=2, has_file=True),
+                input_dataset_parameters_part_factory(parameter_count=2, has_date=True),
                 Tag.input_dataset_parameters(),
             ),
-            id="multi_param_values_no_date",
+            id="multi_param_with_date_no_file",
         ),
         pytest.param(
             (
-                input_dataset_parameters_part_factory(has_date=True, has_file=True),
+                input_dataset_parameters_part_factory(parameter_count=2, has_file=True),
                 Tag.input_dataset_parameters(),
             ),
-            id="single_param_with_date",
+            id="multi_param_no_date_with_file",
         ),
         pytest.param(
             (
@@ -372,138 +251,30 @@ def test_input_dataset_parameters(
                 ),
                 Tag.input_dataset_parameters(),
             ),
-            id="multi_param_with_date",
+            id="multi_param_with_date_with_file",
         ),
     ],
 )
-def test_input_dataset_parameter_objects(
-    task_with_input_dataset, input_dataset_parts: list[tuple[Any, str]]
-):
+def test_input_dataset_parameters(task_with_input_dataset, input_dataset_parts: tuple[Any, str]):
     """
-    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
+    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
     """
+    doc_part, tag = input_dataset_parts
     task = task_with_input_dataset
-    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
+    doc_from_file = next(
+        task.read(tags=tag, decoder=basemodel_decoder, model=InputDatasetPartDocumentList)
+    )
 
-
-@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
+    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

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.tasks.mixin.input_dataset import InputDatasetMixin
+from dkist_processing_common.tests.test_input_dataset import input_dataset_frames_part_factory
+
+
+FITS_FILE = "fits.dat"
+NP_FILE = "np.npy"
 
 
 @pytest.fixture
-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)
+def input_dataset_parameters():
     return [
         {
             "parameterName": "basic_param",
@@ -106,7 +106,15 @@ def input_dataset_parameters(tmp_path):
             "parameterValues": [
                 {
                     "parameterValueId": 1,
-                    "parameterValue": json.dumps({"param_path": str(fits_file_path)}),
+                    "parameterValue": json.dumps(
+                        {
+                            "__file__": {
+                                "bucket": "not_used",
+                                "objectKey": "not_used",
+                                "tag": Tag.parameter(FITS_FILE),
+                            }
+                        }
+                    ),
                 }
             ],
         },
@@ -115,7 +123,15 @@ def input_dataset_parameters(tmp_path):
             "parameterValues": [
                 {
                     "parameterValueId": 1,
-                    "parameterValue": json.dumps({"param_path": str(np_file_path)}),
+                    "parameterValue": json.dumps(
+                        {
+                            "__file__": {
+                                "bucket": "not_used",
+                                "objectKey": "not_used",
+                                "tag": Tag.parameter(NP_FILE),
+                            }
+                        }
+                    ),
                 }
             ],
         },
@@ -129,16 +145,14 @@ def input_dataset_parts(input_dataset_parameters) -> tuple[Any, str]:
 
 @pytest.fixture()
 def task_class_with_parameters(parameter_class) -> Type[WorkflowTaskBase]:
-    class TaskWithParameters(WorkflowTaskBase, InputDatasetMixin):
+    class TaskWithParameters(WorkflowTaskBase):
         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(
-                input_dataset_parameters=self.input_dataset_parameters
-            )
+            self.parameters = parameter_class(scratch=self.scratch)
 
         def run(self) -> None:
             pass
@@ -149,11 +163,21 @@ 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
-    return task_class(
+    with 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):
@@ -182,18 +206,18 @@ class FilledParametersWithObsTime(ParameterBase):
 
     @property
     def fits_file_parameter(self):
-        param_dict = self._find_most_recent_past_value("fits_file_parameter")
-        return self._load_param_value_from_fits(param_dict)
+        param_obj = self._find_most_recent_past_value("fits_file_parameter")
+        return self._load_param_value_from_fits(param_obj=param_obj)
 
     @property
     def non_primary_fits_file_parameter(self):
-        param_dict = self._find_most_recent_past_value("fits_file_parameter")
-        return self._load_param_value_from_fits(param_dict, hdu=1)
+        param_obj = self._find_most_recent_past_value("fits_file_parameter")
+        return self._load_param_value_from_fits(param_obj=param_obj, hdu=1)
 
     @property
     def numpy_file_parameter(self):
-        param_dict = self._find_most_recent_past_value("numpy_file_parameter")
-        return self._load_param_value_from_numpy_save(param_dict)
+        param_obj = self._find_most_recent_past_value("numpy_file_parameter")
+        return self._load_param_value_from_numpy_save(param_obj=param_obj)
 
 
 def parameter_class_with_obs_ip_start_time():
@@ -343,3 +367,28 @@ 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")