dkist-processing-common 10.6.0rc2__tar.gz → 10.6.1rc1__tar.gz

{dkist_processing_common-10.6.0rc2 → dkist_processing_common-10.6.1rc1}/CHANGELOG.rst

@@ -1,3 +1,13 @@
+v10.6.0 (2025-03-03)
+====================
+
+Features
+--------
+
+- Add the `RetarderNameBud` that can parse the name of the GOS retarder and ensure that only a single retarder was used
+  for the given set of POLCAL input data. (`#235 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/235>`__)
+
+
 v10.5.15 (2025-02-24)
 =====================
 

{dkist_processing_common-10.6.0rc2 → dkist_processing_common-10.6.1rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dkist-processing-common
-Version: 10.6.0rc2
+Version: 10.6.1rc1
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause

dkist_processing_common-10.6.1rc1/changelog/236.misc.1.rst

@@ -0,0 +1 @@
+Change returns from the metadata store queries into Pydantic BaseModel instances.  Remove unnecessary parsing and error checking.

dkist_processing_common-10.6.1rc1/changelog/236.misc.rst

@@ -0,0 +1 @@
+Convert dataclasses in the graphql model to Pydantic BaseModels for additional validation. In the RecipeRunResponse class, configuration is now returned as a dictionary. In the InputDatasetPartResponse class, inputDatasetPartDocument is now returned as a list of dictionaries.

{dkist_processing_common-10.6.0rc2 → dkist_processing_common-10.6.1rc1}/dkist_processing_common/models/graphql.py

@@ -1,24 +1,22 @@
 """GraphQL Data models for the metadata store api."""
-from dataclasses import dataclass
+from pydantic import BaseModel
+from pydantic import Json
 
 
-@dataclass
-class RecipeRunMutation:
+class RecipeRunMutation(BaseModel):
     """Recipe run mutation record."""
 
     recipeRunId: int
     recipeRunStatusId: int
 
 
-@dataclass
-class RecipeRunStatusQuery:
+class RecipeRunStatusQuery(BaseModel):
     """Recipe run status query for the recipeRunStatuses endpoint."""
 
     recipeRunStatusName: str
 
 
-@dataclass
-class RecipeRunStatusMutation:
+class RecipeRunStatusMutation(BaseModel):
     """Recipe run status mutation record."""
 
     recipeRunStatusName: str
@@ -26,38 +24,33 @@ class RecipeRunStatusMutation:
     recipeRunStatusDescription: str
 
 
-@dataclass
-class RecipeRunStatusResponse:
+class RecipeRunStatusResponse(BaseModel):
     """Response to a recipe run status query."""
 
     recipeRunStatusId: int
 
 
-@dataclass
-class InputDatasetPartTypeResponse:
+class InputDatasetPartTypeResponse(BaseModel):
     """Response class for the input dataset part type entity."""
 
     inputDatasetPartTypeName: str
 
 
-@dataclass
-class InputDatasetPartResponse:
+class InputDatasetPartResponse(BaseModel):
     """Response class for the input dataset part entity."""
 
     inputDatasetPartId: int
-    inputDatasetPartDocument: str
+    inputDatasetPartDocument: Json[list[dict]]
     inputDatasetPartType: InputDatasetPartTypeResponse
 
 
-@dataclass
-class InputDatasetInputDatasetPartResponse:
+class InputDatasetInputDatasetPartResponse(BaseModel):
     """Response class for the join entity between input datasets and input dataset parts."""
 
     inputDatasetPart: InputDatasetPartResponse
 
 
-@dataclass
-class InputDatasetResponse:
+class InputDatasetResponse(BaseModel):
     """Input dataset query response."""
 
     inputDatasetId: int
@@ -65,62 +58,54 @@ class InputDatasetResponse:
     inputDatasetInputDatasetParts: list[InputDatasetInputDatasetPartResponse]
 
 
-@dataclass
-class InputDatasetRecipeInstanceResponse:
+class InputDatasetRecipeInstanceResponse(BaseModel):
     """Recipe instance query response."""
 
     inputDataset: InputDatasetResponse
 
 
-@dataclass
-class InputDatasetRecipeRunResponse:
+class InputDatasetRecipeRunResponse(BaseModel):
     """Recipe run query response."""
 
     recipeInstance: InputDatasetRecipeInstanceResponse
 
 
-@dataclass
-class RecipeInstanceResponse:
+class RecipeInstanceResponse(BaseModel):
     """Recipe instance query response."""
 
     recipeId: int
     inputDatasetId: int
 
 
-@dataclass
-class RecipeRunProvenanceResponse:
+class RecipeRunProvenanceResponse(BaseModel):
     """Response for the metadata store recipeRunProvenances and mutations endpoints."""
 
     recipeRunProvenanceId: int
     isTaskManual: bool
 
 
-@dataclass
-class RecipeRunResponse:
+class RecipeRunResponse(BaseModel):
     """Recipe run query response."""
 
     recipeInstance: RecipeInstanceResponse
     recipeInstanceId: int
     recipeRunProvenances: list[RecipeRunProvenanceResponse]
-    configuration: str = None
+    configuration: Json[dict] | None = {}
 
 
-@dataclass
-class RecipeRunMutationResponse:
+class RecipeRunMutationResponse(BaseModel):
     """Recipe run mutation response."""
 
     recipeRunId: int
 
 
-@dataclass
-class RecipeRunQuery:
+class RecipeRunQuery(BaseModel):
     """Query parameters for the metadata store endpoint recipeRuns."""
 
     recipeRunId: int
 
 
-@dataclass
-class DatasetCatalogReceiptAccountMutation:
+class DatasetCatalogReceiptAccountMutation(BaseModel):
     """
     Dataset catalog receipt account mutation record.
 
@@ -132,15 +117,13 @@ class DatasetCatalogReceiptAccountMutation:
     expectedObjectCount: int
 
 
-@dataclass
-class DatasetCatalogReceiptAccountResponse:
+class DatasetCatalogReceiptAccountResponse(BaseModel):
     """Dataset catalog receipt account response for query and mutation endpoints."""
 
     datasetCatalogReceiptAccountId: int
 
 
-@dataclass
-class RecipeRunProvenanceMutation:
+class RecipeRunProvenanceMutation(BaseModel):
     """Recipe run provenance mutation record."""
 
     inputDatasetId: int
@@ -152,8 +135,7 @@ class RecipeRunProvenanceMutation:
     codeVersion: str = None
 
 
-@dataclass
-class QualityCreation:
+class QualityCreation(BaseModel):
     """Quality data creation record."""
 
     datasetId: str
@@ -173,15 +155,13 @@ class QualityCreation:
     efficiencyData: str | None = None
 
 
-@dataclass
-class QualitiesRequest:
+class QualitiesRequest(BaseModel):
     """Query parameters for quality data."""
 
     datasetId: str
 
 
-@dataclass
-class QualityResponse:
+class QualityResponse(BaseModel):
     """Query Response for quality data."""
 
     qualityId: int

{dkist_processing_common-10.6.0rc2 → dkist_processing_common-10.6.1rc1}/dkist_processing_common/tasks/mixin/metadata_store.py

@@ -2,6 +2,7 @@
 import json
 import logging
 from functools import cached_property
+from typing import Literal
 
 from dkist_processing_common._util.graphql import GraphQLClient
 from dkist_processing_common.codecs.quality import QualityDataEncoder
@@ -26,8 +27,6 @@ from dkist_processing_common.models.graphql import RecipeRunStatusResponse
 
 logger = logging.getLogger(__name__)
 
-input_dataset_part_document_type_hint = list | dict | str | int | float | None
-
 
 class MetadataStoreMixin:
     """Mixin for a WorkflowDataTaskBase which implements Metadata Store access functionality."""
@@ -37,6 +36,8 @@ class MetadataStoreMixin:
         """Get the graphql client."""
         return GraphQLClient(common_configurations.metadata_store_api_base)
 
+    # RECIPE RUN STATUS
+
     def metadata_store_change_recipe_run_to_inprogress(self):
         """Set the recipe run status to "INPROGRESS"."""
         self._metadata_store_change_status(status="INPROGRESS", is_complete=False)
@@ -49,6 +50,76 @@ class MetadataStoreMixin:
         """Set the recipe run status to "TRIALSUCCESS"."""
         self._metadata_store_change_status(status="TRIALSUCCESS", is_complete=False)
 
+    def _metadata_store_recipe_run_status_id(self, status: str) -> None | int:
+        """Find the id of a recipe run status."""
+        params = RecipeRunStatusQuery(recipeRunStatusName=status)
+        response = self.metadata_store_client.execute_gql_query(
+            query_base="recipeRunStatuses",
+            query_response_cls=RecipeRunStatusResponse,
+            query_parameters=params,
+        )
+        if len(response) > 0:
+            return response[0].recipeRunStatusId
+
+    def _metadata_store_create_recipe_run_status(self, status: str, is_complete: bool) -> int:
+        """
+        Add a new recipe run status to the db.
+
+        :param status: name of the status to add
+        :param is_complete: does the new status correspond to an accepted completion state
+        """
+        recipe_run_statuses = {
+            "INPROGRESS": "Recipe run is currently undergoing processing",
+            "COMPLETEDSUCCESSFULLY": "Recipe run processing completed with no errors",
+            "TRIALSUCCESS": "Recipe run trial processing completed with no errors. Recipe run not "
+            "marked complete.",
+        }
+
+        if not isinstance(status, str):
+            raise TypeError(f"status must be of type str: {status}")
+        if not isinstance(is_complete, bool):
+            raise TypeError(f"is_complete must be of type bool: {is_complete}")
+        params = RecipeRunStatusMutation(
+            recipeRunStatusName=status,
+            isComplete=is_complete,
+            recipeRunStatusDescription=recipe_run_statuses[status],
+        )
+        recipe_run_status_response = self.metadata_store_client.execute_gql_mutation(
+            mutation_base="createRecipeRunStatus",
+            mutation_response_cls=RecipeRunStatusResponse,
+            mutation_parameters=params,
+        )
+        return recipe_run_status_response.recipeRunStatus.recipeRunStatusId
+
+    def _metadata_store_change_status(self, status: str, is_complete: bool):
+        """Change the recipe run status of a recipe run to the given status."""
+        recipe_run_status_id = self._metadata_store_recipe_run_status_id(status=status)
+        if not recipe_run_status_id:
+            recipe_run_status_id = self._metadata_store_create_recipe_run_status(
+                status=status, is_complete=is_complete
+            )
+        self._metadata_store_update_status(recipe_run_status_id=recipe_run_status_id)
+
+    def _metadata_store_update_status(
+        self,
+        recipe_run_status_id: int,
+    ):
+        """
+        Change the status of a given recipe run id.
+
+        :param recipe_run_status_id: the new status to use
+        """
+        params = RecipeRunMutation(
+            recipeRunId=self.recipe_run_id, recipeRunStatusId=recipe_run_status_id
+        )
+        self.metadata_store_client.execute_gql_mutation(
+            mutation_base="updateRecipeRun",
+            mutation_parameters=params,
+            mutation_response_cls=RecipeRunMutationResponse,
+        )
+
+    # RECEIPT
+
     def metadata_store_add_dataset_receipt_account(
         self, dataset_id: str, expected_object_count: int
     ):
@@ -62,10 +133,12 @@ class MetadataStoreMixin:
             mutation_response_cls=DatasetCatalogReceiptAccountResponse,
         )
 
+    # PROVENANCE
+
     def metadata_store_record_provenance(self, is_task_manual: bool, library_versions: str):
         """Record the provenance record in the metadata store."""
         params = RecipeRunProvenanceMutation(
-            inputDatasetId=self.metadata_store_input_dataset_id,
+            inputDatasetId=self.metadata_store_recipe_run.recipeInstance.inputDatasetId,
             isTaskManual=is_task_manual,
             recipeRunId=self.recipe_run_id,
             taskName=self.task_name,
@@ -78,6 +151,8 @@ class MetadataStoreMixin:
             mutation_response_cls=RecipeRunProvenanceResponse,
         )
 
+    # QUALITY
+
     def metadata_store_add_quality_data(self, dataset_id: str, quality_data: list[dict]):
         """Add the quality data to the metadata-store."""
         if self.metadata_store_quality_data_exists(dataset_id):
@@ -119,222 +194,60 @@ class MetadataStoreMixin:
         )
         return bool(response)
 
-    def metadata_store_recipe_run_configuration(self) -> dict:
-        """Get the recipe run configuration from the metadata store."""
-        configuration_json = self._metadata_store_recipe_run().configuration
-        if configuration_json is None:
-            return {}
-        try:
-            configuration = json.loads(configuration_json)
-            if not isinstance(configuration, dict):
-                raise ValueError(
-                    f"Invalid recipe run configuration format.  "
-                    f"Expected json encoded dictionary, received json encoded {type(configuration)}"
-                )
-            return configuration
-        except (json.JSONDecodeError, ValueError, TypeError, UnicodeDecodeError) as e:
-            logger.error(f"Invalid recipe run configuration")
-            raise e
+    # INPUT DATASET RECIPE RUN
 
     @cached_property
-    def metadata_store_input_dataset_parts(self) -> list[InputDatasetPartResponse]:
-        """Get the input dataset parts from the metadata store."""
+    def metadata_store_input_dataset_recipe_run_response(self) -> InputDatasetRecipeRunResponse:
+        """Get the input dataset recipe run response from the metadata store."""
         params = RecipeRunQuery(recipeRunId=self.recipe_run_id)
         response = self.metadata_store_client.execute_gql_query(
             query_base="recipeRuns",
             query_response_cls=InputDatasetRecipeRunResponse,
             query_parameters=params,
-        )  # queried independently of other recipe run metadata for performance
-        recipe_run = response[0]
-        return [
-            part_link.inputDatasetPart
-            for part_link in recipe_run.recipeInstance.inputDataset.inputDatasetInputDatasetParts
-        ]
-
-    def _metadata_store_filter_input_dataset_parts(
-        self, input_dataset_part_type_name: str
-    ) -> InputDatasetPartResponse | None:
-        """Filter the input dataset parts based on the input dataset part type name."""
-        target_parts = [
-            part
-            for part in self.metadata_store_input_dataset_parts
-            if part.inputDatasetPartType.inputDatasetPartTypeName == input_dataset_part_type_name
-        ]
-        if not target_parts:
-            return
-        if len(target_parts) == 1:
-            return target_parts[0]
-        raise ValueError(
-            f"Multiple ({len(target_parts)}) input dataset parts found for "
-            f"{input_dataset_part_type_name=}."
-        )
-
-    @property
-    def _metadata_store_input_dataset_observe_frames_part(
-        self,
-    ) -> InputDatasetPartResponse | None:
-        """Get the input dataset part for observe frames."""
-        return self._metadata_store_filter_input_dataset_parts(
-            input_dataset_part_type_name="observe_frames",
-        )
-
-    @property
-    def metadata_store_input_dataset_observe_frames_part_id(self) -> int | None:
-        """Get the input dataset part id for observe frames."""
-        if part := self._metadata_store_input_dataset_observe_frames_part:
-            return part.inputDatasetPartId
-
-    @property
-    def metadata_store_input_dataset_observe_frames_part_document(
-        self,
-    ) -> input_dataset_part_document_type_hint:
-        """Get the input dataset part document for observe frames."""
-        if part := self._metadata_store_input_dataset_observe_frames_part:
-            return part.inputDatasetPartDocument
-
-    @property
-    def _metadata_store_input_dataset_calibration_frames_part(
-        self,
-    ) -> InputDatasetPartResponse | None:
-        """Get the input dataset part for calibration frames."""
-        return self._metadata_store_filter_input_dataset_parts(
-            input_dataset_part_type_name="calibration_frames"
+            response_encoder=InputDatasetRecipeRunResponse.model_validate,
         )
-
-    @property
-    def metadata_store_input_dataset_calibration_frames_part_id(self) -> int | None:
-        """Get the input dataset part id for calibration frames."""
-        if part := self._metadata_store_input_dataset_calibration_frames_part:
-            return part.inputDatasetPartId
-
-    @property
-    def metadata_store_input_dataset_calibration_frames_part_document(
-        self,
-    ) -> input_dataset_part_document_type_hint:
-        """Get the input dataset part document for calibration frames."""
-        if part := self._metadata_store_input_dataset_calibration_frames_part:
-            return part.inputDatasetPartDocument
-
-    @property
-    def _metadata_store_input_dataset_parameters_part(
-        self,
-    ) -> InputDatasetPartResponse | None:
-        """Get the input dataset part for parameters."""
-        return self._metadata_store_filter_input_dataset_parts(
-            input_dataset_part_type_name="parameters"
+        return response[0]
+
+    def _metadata_store_input_dataset_part(
+        self, part_type: Literal["observe_frames", "calibration_frames", "parameters"]
+    ) -> InputDatasetPartResponse:
+        """Get the input dataset part by input dataset part type name."""
+        part_type_dict = {}
+        parts = (
+            self.metadata_store_input_dataset_recipe_run_response.recipeInstance.inputDataset.inputDatasetInputDatasetParts
         )
+        for part in parts:
+            part_type_name = part.inputDatasetPart.inputDatasetPartType.inputDatasetPartTypeName
+            if part_type_name in part_type_dict.keys():
+                raise ValueError(f"Multiple input dataset parts found for {part_type_name=}.")
+            part_type_dict[part_type_name] = part.inputDatasetPart
+        return part_type_dict.get(part_type)
 
     @property
-    def metadata_store_input_dataset_parameters_part_id(self) -> int | None:
-        """Get the input dataset part id for parameters."""
-        if part := self._metadata_store_input_dataset_parameters_part:
-            return part.inputDatasetPartId
+    def metadata_store_input_dataset_observe_frames(self) -> InputDatasetPartResponse:
+        """Get the input dataset part for the observe frames."""
+        return self._metadata_store_input_dataset_part(part_type="observe_frames")
 
     @property
-    def metadata_store_input_dataset_parameters_part_document(
-        self,
-    ) -> input_dataset_part_document_type_hint:
-        """Get the input dataset part document for parameters."""
-        if part := self._metadata_store_input_dataset_parameters_part:
-            return part.inputDatasetPartDocument
+    def metadata_store_input_dataset_calibration_frames(self) -> InputDatasetPartResponse:
+        """Get the input dataset part for the calibration frames."""
+        return self._metadata_store_input_dataset_part(part_type="calibration_frames")
 
     @property
-    def metadata_store_input_dataset_id(self) -> int:
-        """Get the input dataset id from the metadata store."""
-        return self._metadata_store_recipe_run().recipeInstance.inputDatasetId
+    def metadata_store_input_dataset_parameters(self) -> InputDatasetPartResponse:
+        """Get the input dataset part for the parameters."""
+        return self._metadata_store_input_dataset_part(part_type="parameters")
 
-    @property
-    def metadata_store_recipe_instance_id(self) -> int:
-        """Get the recipe instance id from the metadata store."""
-        return self._metadata_store_recipe_run().recipeInstanceId
-
-    @property
-    def metadata_store_recipe_id(self) -> int:
-        """Get the recipe id from the metadata store."""
-        return self._metadata_store_recipe_run().recipeInstance.recipeId
+    # RECIPE RUN
 
-    @property
-    def metadata_store_recipe_run_provenance(self) -> list[RecipeRunProvenanceResponse]:
-        """Get all the provenance records for the recipe run."""
-        return self._metadata_store_recipe_run().recipeRunProvenances
-
-    def _metadata_store_recipe_run(self, allow_cache: bool = True) -> RecipeRunResponse:
-        is_cached = bool(getattr(self, "_recipe_run_cache", False))
-        if is_cached and allow_cache:
-            return self._recipe_run_cache
+    @cached_property
+    def metadata_store_recipe_run(self) -> RecipeRunResponse:
+        """Get the recipe run response from the metadata store."""
         params = RecipeRunQuery(recipeRunId=self.recipe_run_id)
         response = self.metadata_store_client.execute_gql_query(
             query_base="recipeRuns",
             query_response_cls=RecipeRunResponse,
             query_parameters=params,
+            response_encoder=RecipeRunResponse.model_validate,
         )
-        self._recipe_run_cache = response[0]
-        return self._recipe_run_cache
-
-    def _metadata_store_change_status(self, status: str, is_complete: bool):
-        """Change the recipe run status of a recipe run to the given status."""
-        recipe_run_status_id = self._metadata_store_recipe_run_status_id(status=status)
-        if not recipe_run_status_id:
-            recipe_run_status_id = self._metadata_store_create_recipe_run_status(
-                status=status, is_complete=is_complete
-            )
-        self._metadata_store_update_status(recipe_run_status_id=recipe_run_status_id)
-
-    def _metadata_store_recipe_run_status_id(self, status: str) -> None | int:
-        """Find the id of a recipe run status."""
-        params = RecipeRunStatusQuery(recipeRunStatusName=status)
-        response = self.metadata_store_client.execute_gql_query(
-            query_base="recipeRunStatuses",
-            query_response_cls=RecipeRunStatusResponse,
-            query_parameters=params,
-        )
-        if len(response) > 0:
-            return response[0].recipeRunStatusId
-
-    def _metadata_store_create_recipe_run_status(self, status: str, is_complete: bool) -> int:
-        """
-        Add a new recipe run status to the db.
-
-        :param status: name of the status to add
-        :param is_complete: does the new status correspond to an accepted completion state
-        """
-        recipe_run_statuses = {
-            "INPROGRESS": "Recipe run is currently undergoing processing",
-            "COMPLETEDSUCCESSFULLY": "Recipe run processing completed with no errors",
-            "TRIALSUCCESS": "Recipe run trial processing completed with no errors. Recipe run not "
-            "marked complete.",
-        }
-
-        if not isinstance(status, str):
-            raise TypeError(f"status must be of type str: {status}")
-        if not isinstance(is_complete, bool):
-            raise TypeError(f"is_complete must be of type bool: {is_complete}")
-        params = RecipeRunStatusMutation(
-            recipeRunStatusName=status,
-            isComplete=is_complete,
-            recipeRunStatusDescription=recipe_run_statuses[status],
-        )
-        recipe_run_status_response = self.metadata_store_client.execute_gql_mutation(
-            mutation_base="createRecipeRunStatus",
-            mutation_response_cls=RecipeRunStatusResponse,
-            mutation_parameters=params,
-        )
-        return recipe_run_status_response.recipeRunStatus.recipeRunStatusId
-
-    def _metadata_store_update_status(
-        self,
-        recipe_run_status_id: int,
-    ):
-        """
-        Change the status of a given recipe run id.
-
-        :param recipe_run_status_id: the new status to use
-        """
-        params = RecipeRunMutation(
-            recipeRunId=self.recipe_run_id, recipeRunStatusId=recipe_run_status_id
-        )
-        self.metadata_store_client.execute_gql_mutation(
-            mutation_base="updateRecipeRun",
-            mutation_parameters=params,
-            mutation_response_cls=RecipeRunMutationResponse,
-        )
+        return response[0]

{dkist_processing_common-10.6.0rc2 → dkist_processing_common-10.6.1rc1}/dkist_processing_common/tasks/output_data_base.py

@@ -19,7 +19,7 @@ class OutputDataBase(WorkflowTaskBase, ABC):
     @cached_property
     def destination_bucket(self) -> str:
         """Get the destination bucket."""
-        return self.metadata_store_recipe_run_configuration().get("destination_bucket", "data")
+        return self.metadata_store_recipe_run.configuration.get("destination_bucket", "data")
 
     def format_object_key(self, path: Path) -> str:
         """

{dkist_processing_common-10.6.0rc2 → dkist_processing_common-10.6.1rc1}/dkist_processing_common/tasks/teardown.py

@@ -22,7 +22,7 @@ class TeardownBase(WorkflowTaskBase, ABC):
     @property
     def teardown_enabled(self) -> bool:
         """Recipe run configuration indicating if data should be removed at the end of a run."""
-        return self.metadata_store_recipe_run_configuration().get("teardown_enabled", True)
+        return self.metadata_store_recipe_run.configuration.get("teardown_enabled", True)
 
     def run(self) -> None:
         """Run method for Teardown class."""

{dkist_processing_common-10.6.0rc2 → dkist_processing_common-10.6.1rc1}/dkist_processing_common/tasks/transfer_input_data.py

@@ -19,11 +19,11 @@ class TransferL0Data(WorkflowTaskBase, GlobusMixin, InputDatasetMixin):
 
     def download_input_dataset(self):
         """Get the input dataset document parts and save it to scratch with the appropriate tags."""
-        if doc := self.metadata_store_input_dataset_observe_frames_part_document:
+        if doc := self.metadata_store_input_dataset_observe_frames.inputDatasetPartDocument:
             self.write(doc.encode("utf-8"), tags=Tag.input_dataset_observe_frames())
-        if doc := self.metadata_store_input_dataset_calibration_frames_part_document:
+        if doc := self.metadata_store_input_dataset_calibration_frames.inputDatasetPartDocument:
             self.write(doc.encode("utf-8"), tags=Tag.input_dataset_calibration_frames())
-        if doc := self.metadata_store_input_dataset_parameters_part_document:
+        if doc := self.metadata_store_input_dataset_parameters.inputDatasetPartDocument:
             self.write(doc.encode("utf-8"), tags=Tag.input_dataset_parameters())
 
     def format_transfer_items(