dkist-processing-common 11.7.0rc3__py3-none-any.whl → 11.9.1__py3-none-any.whl

dkist_processing_common/tasks/parse_l0_input_data.py

@@ -37,7 +37,9 @@ from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.average_bud import TaskAverageBud
 from dkist_processing_common.parsers.experiment_id_bud import ContributingExperimentIdsBud
 from dkist_processing_common.parsers.experiment_id_bud import ExperimentIdBud
-from dkist_processing_common.parsers.id_bud import TaskContributingIdsBud
+from dkist_processing_common.parsers.observing_program_id_bud import (
+    TaskContributingObservingProgramExecutionIdsBud,
+)
 from dkist_processing_common.parsers.proposal_id_bud import ContributingProposalIdsBud
 from dkist_processing_common.parsers.proposal_id_bud import ProposalIdBud
 from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
@@ -88,27 +90,19 @@ def dataset_extra_bud_factory() -> list[S]:
             constant_name=BudName.hls_version,
             metadata_key=MetadataKey.hls_version,
         ),
-        TaskContributingIdsBud(
-            constant_name=BudName.dark_observing_program_execution_id,
-            metadata_key=MetadataKey.observing_program_execution_id,
+        TaskContributingObservingProgramExecutionIdsBud(
+            constant_name=BudName.dark_observing_program_execution_ids,
             ip_task_types=TaskName.dark,
         ),
-        TaskContributingIdsBud(
-            constant_name=BudName.solar_gain_observing_program_execution_id,
-            metadata_key=MetadataKey.observing_program_execution_id,
+        TaskContributingObservingProgramExecutionIdsBud(
+            constant_name=BudName.solar_gain_observing_program_execution_ids,
             ip_task_types=TaskName.solar_gain,
             task_type_parsing_function=parse_header_ip_task_with_gains,
         ),
-        TaskContributingIdsBud(
-            constant_name=BudName.polcal_observing_program_execution_id,
-            metadata_key=MetadataKey.observing_program_execution_id,
+        TaskContributingObservingProgramExecutionIdsBud(
+            constant_name=BudName.polcal_observing_program_execution_ids,
             ip_task_types=TaskName.polcal,
         ),
-        TaskUniqueBud(
-            constant_name=BudName.dark_num_raw_frames_per_fpa,
-            metadata_key=MetadataKey.num_raw_frames_per_fpa,
-            ip_task_types=TaskName.dark,
-        ),
         TaskUniqueBud(
             constant_name=BudName.solar_gain_num_raw_frames_per_fpa,
             metadata_key=MetadataKey.num_raw_frames_per_fpa,
@@ -120,11 +114,6 @@ def dataset_extra_bud_factory() -> list[S]:
             metadata_key=MetadataKey.num_raw_frames_per_fpa,
             ip_task_types=TaskName.polcal,
         ),
-        TaskUniqueBud(
-            constant_name=BudName.dark_telescope_tracking_mode,
-            metadata_key=MetadataKey.telescope_tracking_mode,
-            ip_task_types=TaskName.dark,
-        ),
         TaskUniqueBud(
             constant_name=BudName.solar_gain_telescope_tracking_mode,
             metadata_key=MetadataKey.telescope_tracking_mode,
@@ -136,11 +125,6 @@ def dataset_extra_bud_factory() -> list[S]:
             metadata_key=MetadataKey.telescope_tracking_mode,
             ip_task_types=TaskName.polcal,
         ),
-        TaskUniqueBud(
-            constant_name=BudName.dark_coude_table_tracking_mode,
-            metadata_key=MetadataKey.coude_table_tracking_mode,
-            ip_task_types=TaskName.dark,
-        ),
         TaskUniqueBud(
             constant_name=BudName.solar_gain_coude_table_tracking_mode,
             metadata_key=MetadataKey.coude_table_tracking_mode,
@@ -152,11 +136,6 @@ def dataset_extra_bud_factory() -> list[S]:
             metadata_key=MetadataKey.coude_table_tracking_mode,
             ip_task_types=TaskName.polcal,
         ),
-        TaskUniqueBud(
-            constant_name=BudName.dark_telescope_scanning_mode,
-            metadata_key=MetadataKey.telescope_scanning_mode,
-            ip_task_types=TaskName.dark,
-        ),
         TaskUniqueBud(
             constant_name=BudName.solar_gain_telescope_scanning_mode,
             metadata_key=MetadataKey.telescope_scanning_mode,

dkist_processing_common/tasks/trial_catalog.py

@@ -5,15 +5,18 @@ import logging
 from datetime import datetime
 from itertools import chain
 from pathlib import Path
+from typing import Any
 from typing import Generator
 from uuid import uuid4
 
 from dkist_processing_common.codecs.asdf import asdf_fileobj_encoder
+from dkist_processing_common.codecs.basemodel import basemodel_decoder
 from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.json import json_encoder
 from dkist_processing_common.codecs.path import path_decoder
 from dkist_processing_common.codecs.quality import quality_data_decoder
 from dkist_processing_common.models.fits_access import FitsAccessBase
+from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks.output_data_base import OutputDataBase
 
@@ -27,6 +30,7 @@ INVENTORY_EXTRA_INSTALLED = False
 try:
     from dkist_inventory.inventory import generate_asdf_filename
     from dkist_inventory.inventory import generate_inventory_from_frame_inventory
+    from dkist_inventory.inventory import generate_quality_report_filename
 
     INVENTORY_EXTRA_INSTALLED = True
 except ModuleNotFoundError:
@@ -138,11 +142,15 @@ class CreateTrialAsdf(OutputDataBase):
 
     def run(self) -> None:
         """Generate an ASDF file simulating the ASDF file that would be produced when cataloging the dataset."""
+        with self.telemetry_span("Collate input dataset parameters"):
+            parameters = self.parse_input_dataset_parameters()
+
         with self.telemetry_span("Generate ASDF tree"):
             tree = asdf_tree_from_filenames(
                 filenames=self.absolute_output_frame_paths,
                 hdu=1,  # compressed
                 relative_to=self.scratch.workflow_base_path,
+                parameters=parameters,
             )
 
         trial_history = [
@@ -169,6 +177,37 @@ class CreateTrialAsdf(OutputDataBase):
                     ),
                 )
 
+    def parse_input_dataset_parameters(self) -> list[dict[str, Any]]:
+        """
+        Return the parameters associated with the dataset.
+
+        Returns
+        -------
+        list[dict[str, Any]]
+            A list of dictionaries, each containing a parameter name and its values.
+
+        Raises
+        ------
+        ValueError
+            If there is not exactly one ``InputDatasetPartDocumentList`` found.
+        """
+        part_docs_iter = self.read(
+            tags=Tag.input_dataset_parameters(),
+            decoder=basemodel_decoder,
+            model=InputDatasetPartDocumentList,
+        )
+        docs = list(part_docs_iter)
+
+        if not docs:
+            logger.warning("No parameter list decoded from files")
+            return []
+
+        if len(docs) > 1:
+            raise ValueError(f"Expected 1 parameter list, found {len(docs)}")
+
+        parameters = docs[0].model_dump(by_alias=True).get("doc_list", [])
+        return parameters
+
 
 class CreateTrialQualityReport(OutputDataBase):
     """
@@ -186,6 +225,13 @@ class CreateTrialQualityReport(OutputDataBase):
                 f" but the required dependencies were not found."
             )
 
+        if not INVENTORY_EXTRA_INSTALLED:
+            raise ModuleNotFoundError(
+                f"{self.__class__.__name__} Task requires the dkist-inventory package "
+                f"(e.g. via an 'inventory' pip_extra on dkist_processing_core.Workflow().add_node())"
+                f" but the required dependencies were not found."
+            )
+
     def run(self) -> None:
         """Generate the quality report for the dataset."""
         self.create_trial_quality_report()
@@ -207,5 +253,7 @@ class CreateTrialQualityReport(OutputDataBase):
             self.write(
                 quality_report,
                 tags=[Tag.output(), Tag.quality_report()],
-                relative_path=f"{self.constants.dataset_id}_quality_report.pdf",
+                relative_path=generate_quality_report_filename(
+                    dataset_id=self.constants.dataset_id
+                ),
             )

dkist_processing_common/tasks/trial_output_data.py

@@ -100,7 +100,7 @@ class TransferTrialData(TransferDataBase, GlobusMixin):
         tag_list = []
         tag_list += [[Tag.output(), Tag.dataset_inventory()]]
         tag_list += [[Tag.output(), Tag.asdf()]]
-        tag_list += [[Tag.quality_data()]]  # quality data is not tagged as OUTPUT
+        tag_list += [[Tag.output(), Tag.quality_data()]]
         tag_list += [[Tag.output(), Tag.quality_report()]]
         tag_list += [[Tag.output(), Tag.movie()]]
         return tag_list

dkist_processing_common/tests/mock_metadata_store.py

@@ -6,6 +6,7 @@ import json
 from abc import ABC
 from abc import abstractmethod
 from datetime import datetime
+from datetime import timedelta
 from pathlib import Path
 from uuid import uuid4
 
@@ -134,10 +135,6 @@ class InputDatasetRecipeRunResponseMapping(ResponseMapping):
         return Unset
 
 
-class QualityResponseMapping(ResponseMapping):
-    pass  # TODO
-
-
 def make_default_recipe_run_status_response() -> RecipeRunStatusResponse:
     return RecipeRunStatusResponse(recipeRunStatusId=1)
 
@@ -234,3 +231,41 @@ def fake_gql_client():
     Convenience fixture for default mock GQL client. To customize, use fake_gql_client_factory.
     """
     return fake_gql_client_factory()
+
+
+def input_dataset_parameters_part_factory(
+    parameter_count: int = 1,
+    parameter_value_count: int = 1,
+    has_date: bool = False,
+    has_file: bool = False,
+) -> list[dict]:
+    """Create a mock InputDatasetPartDocumentList with parameters."""
+    result = [
+        {
+            "parameterName": uuid4().hex[:6],
+            "parameterValues": [
+                {"parameterValueId": i, "parameterValue": json.dumps(uuid4().hex)}
+                for i in range(parameter_value_count)
+            ],
+        }
+        for _ in range(parameter_count)
+    ]
+    if has_date:
+        base = datetime(2018, 9, 14, 0, 0, 0)  # This date is before any possible start dates
+        for parameter_index, data in enumerate(result):
+            for item in data["parameterValues"]:
+                dt = base + timedelta(days=parameter_index)
+                item["parameterValueStartDate"] = dt.isoformat()
+    if has_file:
+        for data in result:
+            param_list = data["parameterValues"]
+            for item in param_list:
+                item["parameterValue"] = json.dumps(
+                    {
+                        "__file__": {
+                            "bucket": "data",
+                            "objectKey": f"parameters/{data['parameterName']}/{uuid4().hex}.dat",
+                        }
+                    }
+                )
+    return result

dkist_processing_common/tests/test_input_dataset.py

@@ -1,5 +1,4 @@
 import json
-from datetime import datetime
 from typing import Any
 from uuid import uuid4
 
@@ -8,6 +7,7 @@ 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.tests.mock_metadata_store import input_dataset_parameters_part_factory
 
 
 def input_dataset_frames_part_factory(bucket_count: int = 1) -> list[dict]:
@@ -25,42 +25,6 @@ def flatten_frame_parts(frame_parts: list[dict]) -> list[tuple[str, str]]:
     return result
 
 
-def input_dataset_parameters_part_factory(
-    parameter_count: int = 1,
-    parameter_value_count: int = 1,
-    has_date: bool = False,
-    has_file: bool = False,
-) -> list[dict]:
-    result = [
-        {
-            "parameterName": uuid4().hex[:6],
-            "parameterValues": [
-                {"parameterValueId": i, "parameterValue": json.dumps(uuid4().hex)}
-                for i in range(parameter_value_count)
-            ],
-        }
-        for _ in range(parameter_count)
-    ]
-    if has_date:
-        for data in result:
-            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"]
-            for item in param_list:
-                item["parameterValue"] = json.dumps(
-                    {
-                        "__file__": {
-                            "bucket": "data",
-                            "objectKey": f"parameters/{data['parameterName']}/{uuid4().hex}.dat",
-                        }
-                    }
-                )
-    return result
-
-
 @pytest.mark.parametrize(
     "input_dataset_parts",
     [

dkist_processing_common/tests/test_parse_l0_input_data.py

@@ -260,7 +260,7 @@ def test_subclass_flowers(visp_parse_inputs_task, max_cs_step_time_sec):
     tag_pot, constant_pot = visp_parse_inputs_task.make_flower_pots()
 
     assert len(tag_pot.stems) == 1
-    assert len(constant_pot.stems) == 64
+    assert len(constant_pot.stems) == 60
     all_flower_names = [StemName.modstate]
     assert sorted([f.stem_name for f in tag_pot.stems]) == sorted(all_flower_names)
     all_bud_names = [b.stem_name for b in default_constant_bud_factory()] + [BudName.num_modstates]
@@ -277,7 +277,7 @@ def test_dataset_extra_bud_factory(visp_parse_inputs_task, max_cs_step_time_sec)
     stem_names = [f.stem_name.value for f in constant_pot.stems]
     bud_name_base = [
         "DATE_BEGIN",
-        "OBSERVING_PROGRAM_EXECUTION_ID",
+        "OBSERVING_PROGRAM_EXECUTION_IDS",
         "NUM_RAW_FRAMES_PER_FPA",
         "TELESCOPE_TRACKING_MODE",
         "COUDE_TABLE_TRACKING_MODE",
@@ -295,8 +295,14 @@ def test_dataset_extra_bud_factory(visp_parse_inputs_task, max_cs_step_time_sec)
         "GOS_LEVEL0_STATUS",
     ]
     for base in bud_name_base:
-        assert "DARK_" + base in stem_names
         assert "SOLAR_GAIN_" + base in stem_names
+        if base not in [
+            "NUM_RAW_FRAMES_PER_FPA",
+            "TELESCOPE_TRACKING_MODE",
+            "COUDE_TABLE_TRACKING_MODE",
+            "TELESCOPE_SCANNING_MODE",
+        ]:
+            assert "DARK_" + base in stem_names
         if "GOS" not in base:
             assert "POLCAL_" + base in stem_names
 

dkist_processing_common/tests/test_publish_catalog_messages.py

@@ -57,24 +57,3 @@ def test_object_messages(publish_catalog_and_quality_messages_task):
         assert message.body.conversationId == str(task.recipe_run_id)
         assert message.body.objectType == object_type
         assert message.body.groupId == task.constants.dataset_id
-
-
-def test_quality_report_message(publish_catalog_and_quality_messages_task):
-    """
-    :Given: a PublishCatalogAndQualityMessages task
-    :When: creating quality report message
-    :Then: the attributes are correctly populated
-    """
-    # Given
-    task, proposal_id = publish_catalog_and_quality_messages_task
-    # When
-    message = task.quality_report_message
-    # Then
-    assert isinstance(message, CreateQualityReportMessage)
-    assert message.body.bucket == task.destination_bucket
-    # objectName exists and can be evaluated as a valid path
-    assert message.body.objectName
-    _ = Path(message.body.objectName)
-    assert message.body.datasetId == task.constants.dataset_id
-    assert message.body.conversationId == str(task.recipe_run_id)
-    assert message.body.incrementDatasetCatalogReceiptCount is True

dkist_processing_common/tests/test_quality_mixin.py

@@ -1214,12 +1214,20 @@ def wavecal_weights(wavecal_input_wavelength) -> np.ndarray:
 
 
 @pytest.fixture(scope="session")
-def wavecal_fit_result(wavecal_input_wavelength) -> FitResult:
+def wavecal_fit_result(wavecal_input_wavelength, wavecal_input_spectrum) -> FitResult:
     wavelength_params = WavelengthParameters(
         crpix=1, crval=10.0, dispersion=1, grating_constant=1, order=1, incident_light_angle=0
     )
-    minimizer_result = MinimizerResult(residual=np.random.random(wavecal_input_wavelength.size))
-    return FitResult(wavelength_parameters=wavelength_params, minimizer_result=minimizer_result)
+
+    residuals = np.random.random(wavecal_input_wavelength.size)
+    residuals[-1] = np.nan
+    minimizer_result = MinimizerResult(residual=residuals)
+    return FitResult(
+        wavelength_parameters=wavelength_params,
+        minimizer_result=minimizer_result,
+        input_wavelength_vector=wavecal_input_wavelength,
+        input_spectrum=wavecal_input_spectrum,
+    )
 
 
 @pytest.mark.parametrize(

dkist_processing_common/tests/test_stems.py

@@ -19,6 +19,9 @@ from dkist_processing_common.parsers.experiment_id_bud import ExperimentIdBud
 from dkist_processing_common.parsers.id_bud import TaskContributingIdsBud
 from dkist_processing_common.parsers.near_bud import NearFloatBud
 from dkist_processing_common.parsers.near_bud import TaskNearFloatBud
+from dkist_processing_common.parsers.observing_program_id_bud import (
+    TaskContributingObservingProgramExecutionIdsBud,
+)
 from dkist_processing_common.parsers.proposal_id_bud import ContributingProposalIdsBud
 from dkist_processing_common.parsers.proposal_id_bud import ProposalIdBud
 from dkist_processing_common.parsers.retarder import RetarderNameBud
@@ -51,6 +54,7 @@ class FitsReaderMetadataKey(StrEnum):
     near_thing = "near"
     proposal_id = "ID___013"
     experiment_id = "ID___012"
+    observing_program_execution_id = "ID___008"
     ip_task_type = "DKIST004"
     ip_start_time = "DKIST011"
     fpa_exposure_time_ms = "XPOSURE"
@@ -77,6 +81,9 @@ class FitsReader(FitsAccessBase):
         self.name = name
         self.proposal_id: str = self.header.get(FitsReaderMetadataKey.proposal_id)
         self.experiment_id: str = self.header.get(FitsReaderMetadataKey.experiment_id)
+        self.observing_program_execution_id: str = self.header.get(
+            FitsReaderMetadataKey.observing_program_execution_id
+        )
         self.ip_task_type: str = self.header.get(FitsReaderMetadataKey.ip_task_type)
         self.ip_start_time: str = self.header.get(FitsReaderMetadataKey.ip_start_time)
         self.fpa_exposure_time_ms: float = self.header.get(
@@ -113,6 +120,7 @@ def basic_header_objs():
                 "DKIST004": "observe",
                 "ID___012": "experiment_id_1",
                 "ID___013": "proposal_id_1",
+                "ID___008": "observing_program_execution_id_1",
                 "XPOSURE": 0.0013000123,
                 "TEXPOSUR": 10.0,
                 "NSUMEXP": 3,
@@ -131,6 +139,7 @@ def basic_header_objs():
                 "DKIST004": "observe",
                 "ID___012": "experiment_id_1",
                 "ID___013": "proposal_id_1",
+                "ID___008": "observing_program_execution_id_2",
                 "XPOSURE": 0.0013000987,
                 "TEXPOSUR": 10.0,
                 "NSUMEXP": 3,
@@ -150,6 +159,7 @@ def basic_header_objs():
                 "DKIST004": "dark",
                 "ID___012": "experiment_id_2",
                 "ID___013": "proposal_id_2",
+                "ID___008": "observing_program_execution_id_2",
                 "XPOSURE": 12.345,
                 "TEXPOSUR": 1.123456789,
                 "NSUMEXP": 1,
@@ -170,6 +180,7 @@ def basic_header_objs():
                 "DKIST004": "observe",
                 "ID___012": "experiment_id_1",
                 "ID___013": "proposal_id_1",
+                "ID___008": "observing_program_execution_id_1",
                 "XPOSURE": 100.0,
                 "TEXPOSUR": 11.0,
                 "NSUMEXP": 4,
@@ -185,6 +196,7 @@ def basic_header_objs():
             {
                 "DKIST004": "gain",
                 "ID___013": "proposal_id_1",
+                "ID___008": "observing_program_execution_id_1",
                 "id_key": 0,
                 "constant": 6.28,
                 "near": 1.23,
@@ -603,6 +615,29 @@ def test_task_contributing_ids_bud(basic_header_objs):
     assert sorted(list(petal[0].value)) == ["experiment_id_2"]
 
 
+def test_task_contributing_observing_program_execution_ids_bud(basic_header_objs):
+    """
+    Given: A set of headers with observing program execution ID values for different tasks
+    When: Ingesting the headers with a TaskContributingObservingProgramExecutionIdsBud for a task type
+    Then: The Bud's petal is the observing program execution IDs for the that task type
+    """
+    bud = TaskContributingObservingProgramExecutionIdsBud(
+        constant_name="NOT_A_REAL_BUD",
+        ip_task_types=TaskName.observe,
+    )
+    assert bud.stem_name == "NOT_A_REAL_BUD"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud.update(key, fo)
+
+    petal = list(bud.petals)
+    assert len(petal) == 1
+    assert sorted(list(petal[0].value)) == [
+        "observing_program_execution_id_1",
+        "observing_program_execution_id_2",
+    ]
+
+
 def test_exp_time_flower(basic_header_objs):
     """
     Given: A set of filepaths and associated headers with XPOSURE keywords

dkist_processing_common/tests/test_submit_dataset_metadata.py

@@ -95,13 +95,10 @@ def test_submit_dataset_metadata(
     mocker.patch(
         "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
-    # intercept these two GraphQLClient calls so they can be confirmed
+    # intercept this GraphQLClient call so it can be confirmed
     mocked_metadata_store_add_dataset_receipt_account = mocker.patch.object(
         metadata_store.MetadataStoreMixin, "metadata_store_add_dataset_receipt_account"
     )
-    mocked_metadata_store_add_quality_data = mocker.patch.object(
-        metadata_store.MetadataStoreMixin, "metadata_store_add_quality_data"
-    )
     task = submit_dataset_metadata_task
 
     # When
@@ -109,4 +106,3 @@ def test_submit_dataset_metadata(
 
     # Then
     mocked_metadata_store_add_dataset_receipt_account.assert_called_once()
-    mocked_metadata_store_add_quality_data.assert_called_once()

dkist_processing_common/tests/test_trial_catalog.py

@@ -12,14 +12,30 @@ from sqids import Sqids
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.asdf import asdf_decoder
+from dkist_processing_common.codecs.basemodel import basemodel_encoder
 from dkist_processing_common.codecs.bytes import bytes_decoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.codecs.quality import quality_data_encoder
+from dkist_processing_common.models.input_dataset import InputDatasetParameter
+from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import CreateTrialAsdf
 from dkist_processing_common.tasks import CreateTrialDatasetInventory
 from dkist_processing_common.tasks import CreateTrialQualityReport
+from dkist_processing_common.tests.mock_metadata_store import input_dataset_parameters_part_factory
+
+
+@pytest.fixture()
+def mock_input_dataset_parts() -> InputDatasetPartDocumentList:
+    """An InputDatasetPartDocumentList with two parameters, each with one value and a date."""
+    raw = input_dataset_parameters_part_factory(
+        parameter_count=2,
+        parameter_value_count=1,
+        has_date=True,
+        has_file=False,
+    )
+    return InputDatasetPartDocumentList.model_validate({"doc_list": raw})
 
 
 @pytest.fixture()
@@ -41,6 +57,24 @@ def scratch_with_l1_frames(recipe_run_id, tmp_path) -> WorkflowFileSystem:
         scratch.write(
             file_obj, tags=[Tag.output(), Tag.frame()], relative_path=f"{uuid4().hex}.dat"
         )
+
+    return scratch
+
+
+@pytest.fixture()
+def scratch_with_l1_frames_and_parameters(
+    scratch_with_l1_frames, mock_input_dataset_parts
+) -> WorkflowFileSystem:
+    """Scratch instance for a recipe run id with tagged L1 frames and input parameters."""
+    scratch = scratch_with_l1_frames
+
+    # Write validated Pydantic model bytes expected by InputDatasetPartDocumentList
+    file_obj = basemodel_encoder(mock_input_dataset_parts)
+    scratch.write(
+        file_obj,
+        tags=Tag.input_dataset_parameters(),
+        relative_path=f"{uuid4().hex}.json",
+    )
     return scratch
 
 
@@ -85,6 +119,22 @@ def create_trial_asdf_task(
     task._purge()
 
 
+@pytest.fixture(scope="function")
+def create_trial_asdf_task_with_params(
+    recipe_run_id, tmp_path, scratch_with_l1_frames_and_parameters, fake_constants_db
+) -> CreateTrialAsdf:
+    """An instance of CreateTrialAsdf with L1 frames and input parameters tagged in scratch."""
+    task = CreateTrialAsdf(
+        recipe_run_id=recipe_run_id,
+        workflow_name="trial_asdf",
+        workflow_version="trial_asdf_version",
+    )
+    task.scratch = scratch_with_l1_frames_and_parameters
+    task.constants._update(fake_constants_db)
+    yield task
+    task._purge()
+
+
 @pytest.fixture()
 def create_trial_quality_report_task(
     recipe_run_id, tmp_path, fake_constants_db
@@ -143,25 +193,32 @@ def test_create_trial_dataset_inventory(create_trial_dataset_inventory_task):
     assert len(inventory) > 20  # a bunch
 
 
-def test_create_trial_asdf(create_trial_asdf_task, recipe_run_id):
+@pytest.mark.parametrize("with_params", [False, True], ids=["no_params", "with_params"])
+def test_create_trial_asdf(with_params, request, recipe_run_id, mock_input_dataset_parts):
     """
     :Given: An instance of CreateTrialAsdf with L1 frames tagged in scratch
     :When: CreateTrialAsdf is run
     :Then: An asdf file for the dataset is tagged in scratch
     """
-    task = create_trial_asdf_task
+    task = request.getfixturevalue(
+        "create_trial_asdf_task_with_params" if with_params else "create_trial_asdf_task"
+    )
     # When
     task()
+
     # Then
     asdf_tags = [Tag.output(), Tag.asdf()]
     filepaths = list(task.scratch.find_all(tags=asdf_tags))
     assert len(filepaths) == 1
     dataset_id = Sqids(min_length=6, alphabet=ascii_uppercase).encode([recipe_run_id])
     assert filepaths[0].name == f"INSTRUMENT_L1_20240416T160000_{dataset_id}_metadata.asdf"
+
     results = list(task.read(tags=asdf_tags, decoder=asdf_decoder))
     assert len(results) == 1
+
     tree = results[0]
     assert isinstance(tree, dict)
+
     for file_name in tree["dataset"].files.filenames:
         # This is a slightly better than check that `not Path(file_name).is_absolute()` because it confirms
         # we've correctly stripped the path of *all* parents (not just those that start at root).
@@ -169,6 +226,19 @@ def test_create_trial_asdf(create_trial_asdf_task, recipe_run_id):
         # `scratch.workflow_base_path`
         assert Path(file_name).name == file_name
 
+    # Only check parameters when present
+    ds = tree["dataset"]
+    assert "parameters" in ds.meta
+    parameters = ds.meta["parameters"]
+    assert isinstance(parameters, list)
+    if with_params:
+        assert parameters, f"ASDF tree must include input parameters: {parameters}"
+        assert len(parameters) == len(mock_input_dataset_parts.doc_list)
+        for param in parameters:
+            assert InputDatasetParameter.model_validate(param) in mock_input_dataset_parts.doc_list
+    else:
+        assert ds.meta["parameters"] == []
+
 
 def test_create_trial_quality_report(create_trial_quality_report_task):
     """

dkist_processing_common/tests/test_trial_output_data.py

@@ -158,13 +158,12 @@ def complete_trial_output_task(
         task.write(asdf_file_obj, relative_path=asdf_file_name, tags=[Tag.output(), Tag.asdf()])
 
         # Write quality data
-        # quality data is not tagged as OUTPUT
         quality_data_obj = uuid4().hex.encode("utf8")
         quality_data_name = "quality_data.json"
         task.write(
             quality_data_obj,
             relative_path=quality_data_name,
-            tags=Tag.quality_data(),
+            tags=[Tag.output(), Tag.quality_data()],
         )
 
         # Write a quality report file