dkist-processing-common 10.8.3__py3-none-any.whl → 10.9.0__py3-none-any.whl

dkist_processing_common/tests/conftest.py

@@ -45,7 +45,6 @@ from dkist_processing_common.models.graphql import RecipeRunStatusResponse
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 from dkist_processing_common.tasks import WorkflowTaskBase
-from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
 
 TILE_SIZE = 64
 
@@ -359,7 +358,7 @@ class FakeGQLClient:
                 {
                     "parameterValueId": 1,
                     "parameterValue": json.dumps([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
-                    "parameterValueStartDate": "2000-01-01",
+                    "parameterValueStartDate": datetime(2000, 1, 1).isoformat(),
                 }
             ],
         },
@@ -376,7 +375,7 @@ class FakeGQLClient:
                             }
                         }
                     ),
-                    "parameterValueStartDate": "2000-01-01",
+                    "parameterValueStartDate": datetime(2000, 1, 1).isoformat(),
                 },
                 {
                     "parameterValueId": 3,
@@ -388,7 +387,7 @@ class FakeGQLClient:
                             }
                         }
                     ),
-                    "parameterValueStartDate": "2000-01-02",
+                    "parameterValueStartDate": datetime(2000, 1, 2).isoformat(),
                 },
             ],
         },
@@ -400,7 +399,7 @@ class FakeGQLClient:
                     "parameterValue": json.dumps(
                         {"a": 1, "b": 3.14159, "c": "foo", "d": [1, 2, 3]}
                     ),
-                    "parameterValueStartDate": "2000-01-01",
+                    "parameterValueStartDate": datetime(2000, 1, 1).isoformat(),
                 }
             ],
         },
@@ -796,7 +795,7 @@ def post_fit_polcal_fitter(
     return fitter
 
 
-class InputDatasetTask(WorkflowTaskBase, InputDatasetMixin):
+class InputDatasetTask(WorkflowTaskBase):
     def run(self):
         pass
 
@@ -824,7 +823,7 @@ def task_with_input_dataset(
         task.scratch.workflow_base_path = tmp_path / str(recipe_run_id)
         for part, tag in input_dataset_parts:
             file_path = task.scratch.workflow_base_path / Path(f"{uuid4().hex[:6]}.ext")
-            file_path.write_text(data=json.dumps(part))
+            file_path.write_text(data=json.dumps({"doc_list": part}))
             task.tag(path=file_path, tags=tag)
         yield task
 
@@ -851,6 +850,24 @@ def create_parameter_files(
             task.tag(path=file_path, tags=Tag.parameter(param_path))
 
 
+def create_input_frames(
+    task: WorkflowTaskBase,
+    input_frame_docs: list[dict] = FakeGQLClient.observe_frames_doc_object
+    + FakeGQLClient.calibration_frames_doc_object,
+):
+    """
+    Create the observe and calibration frame files specified in the input dataset documents
+    returned by the metadata store.
+    """
+    for frame in input_frame_docs:
+        for object_key in frame["object_keys"]:
+            file_path = task.scratch.workflow_base_path / Path(object_key)
+            if not file_path.parent.exists():
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+            file_path.write_text(data="")
+            task.tag(path=file_path, tags=[Tag.frame(), Tag.input()])
+
+
 @pytest.fixture()
 def fake_constants_db() -> dict:
     """

dkist_processing_common/tests/test_codecs.py

@@ -19,10 +19,15 @@ from astropy.io.fits import CompImageHDU
 from astropy.io.fits import HDUList
 from astropy.io.fits import Header
 from astropy.io.fits import PrimaryHDU
+from pydantic import BaseModel
+from pydantic import create_model
+from pydantic import Field
 
 from dkist_processing_common.codecs.asdf import asdf_decoder
 from dkist_processing_common.codecs.asdf import asdf_encoder
 from dkist_processing_common.codecs.asdf import asdf_fileobj_encoder
+from dkist_processing_common.codecs.basemodel import basemodel_decoder
+from dkist_processing_common.codecs.basemodel import basemodel_encoder
 from dkist_processing_common.codecs.bytes import bytes_decoder
 from dkist_processing_common.codecs.bytes import bytes_encoder
 from dkist_processing_common.codecs.fits import fits_access_decoder
@@ -100,6 +105,14 @@ def path_to_json(dictionary, tmp_file) -> Path:
     return tmp_file
 
 
+@pytest.fixture
+def pydantic_basemodel() -> BaseModel:
+    class Foo(BaseModel):
+        bar: int
+
+    return Foo(bar=123)
+
+
 @pytest.fixture
 def string() -> str:
     return "string"
@@ -356,6 +369,7 @@ class DummyFitsAccess(FitsAccessBase):
         pytest.param("primary_hdu_list", fits_hdulist_encoder, id="fits uncompressed HDUList"),
         pytest.param("compressed_hdu_list", fits_hdulist_encoder, id="fits compressed HDUList"),
         pytest.param("dictionary", json_encoder, id="json"),
+        pytest.param("pydantic_basemodel", basemodel_encoder, id="pydantic basemodel"),
         pytest.param("string", str_encoder, id="str"),
         pytest.param("asdf_tree", asdf_encoder, id="asdf"),
         pytest.param("asdf_obj", asdf_fileobj_encoder, id="asdf_obj"),
@@ -600,6 +614,30 @@ def test_json_encoder_invalid(python_object: Any, expected_exception_type: type[
         json_encoder(python_object)
 
 
+def test_basemodel_decoder(valid_json_codec, path_to_text_file):
+    """
+    Given: a python object that can be validated to a Pydantic BaseModel object is written to file as json
+    When: basemodel decoding is applied to the json file
+    Then: the string gets decoded to the correct Pydantic BaseModel object
+    """
+    # write python object to file as json string
+    python_object = valid_json_codec["python_object"]
+    path = path_to_text_file(json.dumps({"foo": python_object}))
+
+    # create basemodel on the fly
+    DynamicBaseModel = create_model(
+        "DynamicBaseModel", foo=(Any, Field(default_factory=type(python_object)))
+    )
+
+    # get the same object via the basemodel decoder
+    decoded_obj = basemodel_decoder(path, model=DynamicBaseModel)
+    if python_object is nan:
+        # By definition, nan != nan
+        assert isnan(decoded_obj.foo)
+    else:
+        assert decoded_obj.foo == python_object
+
+
 def test_quality_data_encoder_valid(valid_quality_codec):
     """
     Given: a python object that can be encoded as a json string

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