dapla-toolbelt-metadata 0.2.1__py3-none-any.whl → 0.9.11__py3-none-any.whl

dapla_metadata/datasets/utility/urn.py

@@ -0,0 +1,234 @@
+"""Validate, parse and render URNs."""
+
+import logging
+import re
+from collections.abc import Iterable
+from dataclasses import dataclass
+from enum import Enum
+from enum import auto
+from typing import Literal
+
+from pydantic import AnyUrl
+
+from dapla_metadata._shared.config import get_dapla_environment
+from dapla_metadata._shared.enums import DaplaEnvironment
+from dapla_metadata.datasets.utility.utils import VariableListType
+
+logger = logging.getLogger(__name__)
+
+URN_ERROR_MESSAGE_BASE = "The URL is not in a supported format"
+
+URN_ERROR_MESSAGE_TEMPLATE = (
+    URN_ERROR_MESSAGE_BASE
+    + " for field '{field_name}' of variable '{short_name}'. URL: '{value}'. Please contact Team Metadata if this URL should be supported."
+)
+
+
+VARDEF_URL_TEMPLATE = "https://{subdomain}.{domain}/variable-definitions"
+
+
+class SsbNaisDomains(str, Enum):
+    """The available domains on SSBs Nais instance."""
+
+    TEST_EXTERNAL = "test.ssb.no"
+    TEST_INTERNAL = "intern.test.ssb.no"
+    PROD_EXTERNAL = "ssb.no"
+    PROD_INTERNAL = "intern.ssb.no"
+
+
+class ReferenceUrlTypes(Enum):
+    """The general category of the URL.
+
+    This can be useful to refer to when constructing a URL from a URN for a
+    specific context.
+    """
+
+    API = auto()
+    FRONTEND = auto()
+
+
+UrlVisibility = Literal["public", "internal"]
+
+
+@dataclass
+class UrnConverter:
+    """Converts URLs to URNs and vice versa.
+
+    Fields:
+        urn_base: The format for the URN, up to the identifier.
+        id_pattern: A capturing group pattern which matches identifiers for this resource.
+        url_bases: The list of all the different URL representations for a resource. There
+            will typically be a number of URL representations for a particular resource,
+            depending on which system or technology they are accessed through and other
+            technical factors. This list defines which concrete URLs can be considered
+            equivalent to a URN.
+    """
+
+    urn_base: str
+    id_pattern: str
+    url_bases: list[tuple[ReferenceUrlTypes, str]]
+
+    def _extract_id(self, url: str, pattern: re.Pattern[str]) -> str | None:
+        if match := pattern.match(url):
+            return match.group(1)
+        return None
+
+    def _build_pattern(self, url_base: str) -> re.Pattern[str]:
+        return re.compile(f"^{url_base}/{self.id_pattern}")
+
+    def get_urn(self, identifier: str) -> str:
+        """Build a URN for the given identifier."""
+        return f"{self.urn_base}:{identifier}"
+
+    def get_url(
+        self,
+        identifier: str,
+        url_type: ReferenceUrlTypes,
+        visibility: Literal["public", "internal"] = "public",
+    ) -> str | None:
+        """Build concrete URL to reference a resource.
+
+        There are typically multiple URLs used to refer to one resource, this method attempts to support known variations.
+
+        Args:
+            identifier (str): The identifier of the resource the URL refers to.
+            url_type (ReferenceUrlTypes): The representation type of the URL
+            visibility (UrlVisibility, optional): Whether the URL should be that which is publicly available or not. Defaults to "public".
+
+        Returns:
+            str | None: The concrete URL. None if we cannot satisfy the supplied requirements.
+        """
+        candidates = [base[-1] for base in self.url_bases if base[0] == url_type]
+
+        def matches_visibility(url: str, visibility: UrlVisibility):
+            return (".intern." in url) is (visibility == "internal")
+
+        def matches_environment(url: str):
+            current_environment = get_dapla_environment()
+            if current_environment == DaplaEnvironment.TEST:
+                return ".test." in url
+            return ".test." not in url
+
+        if url := next(
+            (
+                url
+                for url in candidates
+                if matches_visibility(url, visibility) and matches_environment(url)
+            ),
+            None,
+        ):
+            return url + "/" + identifier
+        return None
+
+    def get_id(self, urn_or_url: str | AnyUrl) -> str | None:
+        """Get an identifier from a URN or URL.
+
+        Args:
+            urn_or_url (str | AnyUrl): The URN or URL refering to a particular resource
+
+        Returns:
+            str | None: The identifier for the resource, or None if it cannot be extracted.
+        """
+        if str(urn_or_url).startswith(self.urn_base):
+            return str(urn_or_url).removeprefix(self.urn_base + ":")
+        return self._extract_id_from_url(urn_or_url)
+
+    def is_id(self, value: str) -> bool:
+        """Check if the value is an identifier for this URN type.
+
+        Args:
+            value (str): The value to check.
+        """
+        if not isinstance(value, str):
+            # Mypy thinks it's impossible to reach this branch, but there are no guarantees in Python.
+            return False  # type: ignore [unreachable]
+        pattern = re.compile(f"^{self.id_pattern}$")
+        return bool(pattern.match(value))
+
+    def _extract_id_from_url(self, url: str | AnyUrl) -> str | None:
+        patterns = (self._build_pattern(url[-1]) for url in self.url_bases)
+        matches = (self._extract_id(str(url), p) for p in patterns)
+        return next((m for m in matches if m), None)
+
+    def convert_url_to_urn(self, url: str | AnyUrl) -> AnyUrl | None:
+        """Convert a URL to a generalized URN for that same resource.
+
+        Args:
+            url (str | AnyUrl): The URL to convert.
+
+        Returns:
+            str | None: The URN or None if it can't be converted.
+        """
+        if str(url).startswith(self.urn_base):
+            # In this case the value is already in the expected format and nothing needs to be done.
+            return AnyUrl(url)
+        if identifier := self._extract_id_from_url(url):
+            return AnyUrl(self.get_urn(identifier))
+
+        return None
+
+
+vardef_urn_converter = UrnConverter(
+    urn_base="urn:ssb:variable-definition:vardef",
+    id_pattern=r"([a-z0-9]{8})",
+    url_bases=[
+        *[
+            (
+                ReferenceUrlTypes.API,
+                VARDEF_URL_TEMPLATE.format(
+                    subdomain="metadata", domain=nais_domain.value
+                ),
+            )
+            for nais_domain in SsbNaisDomains
+        ],
+        *[
+            (
+                ReferenceUrlTypes.FRONTEND,
+                VARDEF_URL_TEMPLATE.format(
+                    subdomain="catalog", domain=nais_domain.value
+                ),
+            )
+            for nais_domain in SsbNaisDomains
+        ],
+    ],
+)
+
+klass_urn_converter = UrnConverter(
+    urn_base="urn:ssb:classification:klass",
+    id_pattern=r"([0-9]{1,5})",
+    url_bases=[
+        (ReferenceUrlTypes.FRONTEND, "https://www.ssb.no/klass/klassifikasjoner"),
+        (ReferenceUrlTypes.FRONTEND, "https://www.ssb.no/en/klass/klassifikasjoner"),
+        (ReferenceUrlTypes.API, "https://data.ssb.no/api/klass/v1/classifications"),
+    ],
+)
+
+
+def convert_uris_to_urns(
+    variables: VariableListType, field_name: str, converters: Iterable[UrnConverter]
+) -> None:
+    """Where URIs are recognized URLs, convert them to URNs.
+
+    Where the value is not a known URL we preserve the value as it is and log an
+    ERROR level message.
+
+    Args:
+        variables (VariableListType): The list of variables.
+        field_name (str): The name of the field which has URLs to convert to URNs
+        converters (Iterable[UrnConverter]): One or more converters which implement
+            conversion of URLs into one specific URN format. These will typically be
+            specific to an individual metadata reference system.
+    """
+    for v in variables:
+        field = getattr(v, field_name, None)
+        if field:
+            if urn := next((c.convert_url_to_urn(field) for c in converters), None):
+                setattr(v, field_name, urn)
+            else:
+                logger.error(
+                    URN_ERROR_MESSAGE_TEMPLATE.format(
+                        field_name=field_name,
+                        short_name=v.short_name,
+                        value=field,
+                    )
+                )

dapla_metadata/datasets/utility/utils.py

@@ -4,19 +4,25 @@ import datetime  # import is needed in xdoctest
 import logging
 import pathlib
 import uuid
+from typing import Any
+from typing import TypeAlias
 
+import datadoc_model.all_optional.model as all_optional_model
+import datadoc_model.required.model as required_model
+import google.auth
 from cloudpathlib import CloudPath
 from cloudpathlib import GSClient
 from cloudpathlib import GSPath
-from dapla import AuthClient
-from datadoc_model import model
-from datadoc_model.model import Assessment
-from datadoc_model.model import DataSetState
-from datadoc_model.model import VariableRole
-
-from dapla_metadata.datasets.utility.constants import (
-    DATASET_FIELDS_FROM_EXISTING_METADATA,
-)
+from datadoc_model.all_optional.model import Assessment
+from datadoc_model.all_optional.model import DataSetState
+from datadoc_model.all_optional.model import VariableRole
+
+from dapla_metadata.dapla import user_info
+from dapla_metadata.datasets.utility.constants import DAEAD_ENCRYPTION_KEY_REFERENCE
+from dapla_metadata.datasets.utility.constants import ENCRYPTION_PARAMETER_KEY_ID
+from dapla_metadata.datasets.utility.constants import ENCRYPTION_PARAMETER_SNAPSHOT_DATE
+from dapla_metadata.datasets.utility.constants import ENCRYPTION_PARAMETER_STRATEGY
+from dapla_metadata.datasets.utility.constants import ENCRYPTION_PARAMETER_STRATEGY_SKIP
 from dapla_metadata.datasets.utility.constants import NUM_OBLIGATORY_VARIABLES_FIELDS
 from dapla_metadata.datasets.utility.constants import (
     OBLIGATORY_DATASET_METADATA_IDENTIFIERS,
@@ -30,9 +36,33 @@ from dapla_metadata.datasets.utility.constants import (
 from dapla_metadata.datasets.utility.constants import (
     OBLIGATORY_VARIABLES_METADATA_IDENTIFIERS_MULTILANGUAGE,
 )
+from dapla_metadata.datasets.utility.constants import (
+    OBLIGATORY_VARIABLES_PSEUDONYMIZATION_IDENTIFIERS,
+)
+from dapla_metadata.datasets.utility.constants import PAPIS_ENCRYPTION_KEY_REFERENCE
+from dapla_metadata.datasets.utility.constants import PAPIS_STABLE_IDENTIFIER_TYPE
+from dapla_metadata.datasets.utility.enums import EncryptionAlgorithm
 
 logger = logging.getLogger(__name__)
 
+DatadocMetadataType: TypeAlias = (
+    all_optional_model.DatadocMetadata | required_model.DatadocMetadata
+)
+DatasetType: TypeAlias = all_optional_model.Dataset | required_model.Dataset
+VariableType: TypeAlias = all_optional_model.Variable | required_model.Variable
+PseudonymizationType: TypeAlias = (
+    all_optional_model.Pseudonymization | required_model.Pseudonymization
+)
+VariableListType: TypeAlias = (
+    list[all_optional_model.Variable] | list[required_model.Variable]
+)
+OptionalDatadocMetadataType: TypeAlias = DatadocMetadataType | None
+
+
+def get_current_date() -> str:
+    """Return a current date as str."""
+    return datetime.datetime.now(tz=datetime.timezone.utc).date().isoformat()
+
 
 def get_timestamp_now() -> datetime.datetime:
     """Return a timestamp for the current moment."""
@@ -51,7 +81,7 @@ def normalize_path(path: str) -> pathlib.Path | CloudPath:
         Pathlib compatible object.
     """
     if path.startswith(GSPath.cloud_prefix):
-        client = GSClient(credentials=AuthClient.fetch_google_credentials())
+        client = GSClient(credentials=google.auth.default()[0])
         return GSPath(path, client=client)
     return pathlib.Path(path)
 
@@ -78,7 +108,7 @@ def derive_assessment_from_state(state: DataSetState) -> Assessment:
     Returns:
         The derived assessment of the dataset.
     """
-    match (state):
+    match state:
         case (
             DataSetState.INPUT_DATA
             | DataSetState.PROCESSED_DATA
@@ -91,56 +121,67 @@ def derive_assessment_from_state(state: DataSetState) -> Assessment:
             return Assessment.SENSITIVE
 
 
-def set_default_values_variables(variables: list) -> None:
+def set_default_values_variables(variables: VariableListType) -> None:
     """Set default values on variables.
 
     Args:
         variables: A list of variable objects to set default values on.
 
     Example:
-        >>> variables = [model.Variable(short_name="pers",id=None, is_personal_data = None), model.Variable(short_name="fnr",id='9662875c-c245-41de-b667-12ad2091a1ee', is_personal_data='PSEUDONYMISED_ENCRYPTED_PERSONAL_DATA')]
+        >>> variables = [all_optional_model.Variable(short_name="pers",id=None, is_personal_data = None), all_optional_model.Variable(short_name="fnr",id='9662875c-c245-41de-b667-12ad2091a1ee', is_personal_data=True)]
         >>> set_default_values_variables(variables)
         >>> isinstance(variables[0].id, uuid.UUID)
         True
 
-        >>> variables[1].is_personal_data == 'PSEUDONYMISED_ENCRYPTED_PERSONAL_DATA'
+        >>> variables[1].is_personal_data == True
         True
 
-        >>> variables[0].is_personal_data == 'NOT_PERSONAL_DATA'
+        >>> variables[0].is_personal_data == False
         True
     """
     for v in variables:
         if v.id is None:
             v.id = uuid.uuid4()
         if v.is_personal_data is None:
-            v.is_personal_data = model.IsPersonalData.NOT_PERSONAL_DATA
+            v.is_personal_data = False
         if v.variable_role is None:
             v.variable_role = VariableRole.MEASURE
 
 
-def set_default_values_dataset(dataset: model.Dataset) -> None:
+def set_default_values_dataset(
+    dataset: DatasetType,
+) -> None:
     """Set default values on dataset.
 
     Args:
         dataset: The dataset object to set default values on.
 
     Example:
-        >>> dataset = model.Dataset(id=None, contains_personal_data=None)
+        >>> dataset = all_optional_model.Dataset(id=None)
         >>> set_default_values_dataset(dataset)
         >>> dataset.id is not None
         True
-
-        >>> dataset.contains_personal_data == False
-        True
     """
     if not dataset.id:
         dataset.id = uuid.uuid4()
-    if dataset.contains_personal_data is None:
-        dataset.contains_personal_data = False
+
+
+def set_dataset_owner(
+    dataset: DatasetType,
+) -> None:
+    """Sets the owner of the dataset from the DAPLA_GROUP_CONTEXT enviornment variable.
+
+    Args:
+        dataset: The dataset object to set default values on.
+    """
+    try:
+        dataset.owner = user_info.get_user_info_for_current_platform().current_team
+    except OSError:
+        logger.exception("Failed to find environment variable DAPLA_GROUP_CONTEXT")
 
 
 def set_variables_inherit_from_dataset(
-    dataset: model.Dataset,
+    dataset: DatasetType,
     variables: list,
 ) -> None:
     """Set specific dataset values on a list of variable objects.
@@ -154,14 +195,9 @@ def set_variables_inherit_from_dataset(
         variables: A list of variable objects to update with dataset values.
 
     Example:
-        >>> dataset = model.Dataset(short_name='person_data_v1',data_source='01',temporality_type='STATUS',id='9662875c-c245-41de-b667-12ad2091a1ee',contains_data_from="2010-09-05",contains_data_until="2022-09-05")
-        >>> variables = [model.Variable(short_name="pers",data_source =None,temporality_type = None, contains_data_from = None,contains_data_until = None)]
+        >>> dataset = all_optional_model.Dataset(short_name='person_data_v1', id='9662875c-c245-41de-b667-12ad2091a1ee', contains_data_from="2010-09-05", contains_data_until="2022-09-05")
+        >>> variables = [all_optional_model.Variable(short_name="pers", data_source=None, temporality_type=None, contains_data_from=None, contains_data_until=None)]
         >>> set_variables_inherit_from_dataset(dataset, variables)
-        >>> variables[0].data_source == dataset.data_source
-        True
-
-        >>> variables[0].temporality_type is None
-        False
 
         >>> variables[0].contains_data_from == dataset.contains_data_from
         True
@@ -172,8 +208,6 @@ def set_variables_inherit_from_dataset(
     for v in variables:
         v.contains_data_from = v.contains_data_from or dataset.contains_data_from
         v.contains_data_until = v.contains_data_until or dataset.contains_data_until
-        v.temporality_type = v.temporality_type or dataset.temporality_type
-        v.data_source = v.data_source or dataset.data_source
 
 
 def incorrect_date_order(
@@ -232,10 +266,7 @@ def _is_missing_multilanguage_value(
             len(field_value[0]) > 0
             and not field_value[0]["languageText"]
             and (len(field_value) <= 1 or not field_value[1]["languageText"])
-            and (
-                len(field_value) <= 2  # noqa: PLR2004 approve magic value
-                or not field_value[2]["languageText"]
-            )
+            and (len(field_value) <= 2 or not field_value[2]["languageText"])
         ),
     )
 
@@ -264,8 +295,7 @@ def _is_missing_metadata(
         True if the field doesn't have a value, False otherwise.
     """
     return bool(
-        field_name in obligatory_list
-        and field_value is None
+        (field_name in obligatory_list and field_value is None)
         or _is_missing_multilanguage_value(
             field_name,
             field_value,
@@ -274,7 +304,9 @@ def _is_missing_metadata(
     )
 
 
-def num_obligatory_dataset_fields_completed(dataset: model.Dataset) -> int:
+def num_obligatory_dataset_fields_completed(
+    dataset: DatasetType,
+) -> int:
     """Count the number of completed obligatory dataset fields.
 
     This function returns the total count of obligatory fields in the dataset that
@@ -310,7 +342,9 @@ def num_obligatory_variables_fields_completed(variables: list) -> int:
     return num_completed
 
 
-def num_obligatory_variable_fields_completed(variable: model.Variable) -> int:
+def num_obligatory_variable_fields_completed(
+    variable: all_optional_model.Variable,
+) -> int:
     """Count the number of obligatory fields completed for one variable.
 
     This function calculates the total number of obligatory fields that have
@@ -336,7 +370,28 @@ def num_obligatory_variable_fields_completed(variable: model.Variable) -> int:
     return NUM_OBLIGATORY_VARIABLES_FIELDS - len(missing_metadata)
 
 
-def get_missing_obligatory_dataset_fields(dataset: model.Dataset) -> list:
+def num_obligatory_pseudo_fields_missing(
+    variables: list[all_optional_model.Variable],
+) -> int:
+    """Counts the number of obligatory pseudonymization fields are missing.
+
+    Args:
+        variables: The variables to count obligatory fields for.
+
+    Returns:
+        The number of obligatory pseudonymization fields that are missing.
+    """
+    return sum(
+        getattr(v.pseudonymization, field, None) is None
+        for v in variables
+        if v.pseudonymization is not None
+        for field in OBLIGATORY_VARIABLES_PSEUDONYMIZATION_IDENTIFIERS
+    )
+
+
+def get_missing_obligatory_dataset_fields(
+    dataset: DatasetType,
+) -> list:
     """Identify all obligatory dataset fields that are missing values.
 
     This function checks for obligatory fields that are either directly missing
@@ -400,6 +455,40 @@ def get_missing_obligatory_variables_fields(variables: list) -> list[dict]:
     return [item for item in missing_variables_fields if next(iter(item.values()))]
 
 
+def get_missing_obligatory_variables_pseudo_fields(
+    variables: list[all_optional_model.Variable],
+) -> list[dict]:
+    """Identify obligatory variable pseudonymization fields that are missing values for each variable.
+
+    This function checks for obligatory fields that are directly missing
+    (i.e., set to `None`).
+
+    Args:
+        variables: A list of variable objects to check for missing obligatory pseudonymization fields.
+
+    Returns:
+        A list of dictionaries with variable short names as keys and list of missing
+        obligatory variable pseudonymization fields as values. This includes:
+            - Fields that are directly `None` and are listed as obligatory metadata.
+    """
+    return [
+        {
+            v.short_name: [
+                key
+                for key, value in v.pseudonymization.model_dump().items()
+                if _is_missing_metadata(
+                    key,
+                    value,
+                    OBLIGATORY_VARIABLES_PSEUDONYMIZATION_IDENTIFIERS,
+                    [],
+                )
+            ]
+        }
+        for v in variables
+        if v.pseudonymization is not None
+    ]
+
+
 def running_in_notebook() -> bool:
     """Return True if running in Jupyter Notebook."""
     try:
@@ -412,81 +501,64 @@ def running_in_notebook() -> bool:
         return False
 
 
-def override_dataset_fields(
-    merged_metadata: model.DatadocMetadata,
-    existing_metadata: model.DatadocMetadata,
-) -> None:
-    """Overrides specific fields in the dataset of `merged_metadata` with values from the dataset of `existing_metadata`.
+def _ensure_encryption_parameters(
+    existing: list[dict[str, Any]] | None,
+    required: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """Ensure required key/value pairs exist in parameters list."""
+    result = list(existing or [])
 
-    This function iterates over a predefined list of fields, `DATASET_FIELDS_FROM_EXISTING_METADATA`,
-    and sets the corresponding fields in the `merged_metadata.dataset` object to the values
-    from the `existing_metadata.dataset` object.
-
-    Args:
-        merged_metadata: An instance of `DatadocMetadata` containing the dataset to be updated.
-        existing_metadata: An instance of `DatadocMetadata` containing the dataset whose values are used to update `merged_metadata.dataset`.
-
-    Returns:
-        `None`.
-    """
-    if merged_metadata.dataset and existing_metadata.dataset:
-        # Override the fields as defined
-        for field in DATASET_FIELDS_FROM_EXISTING_METADATA:
-            setattr(
-                merged_metadata.dataset,
-                field,
-                getattr(existing_metadata.dataset, field),
-            )
+    # Ensure each required key is present in at least one dict
+    for key, value in required.items():
+        if not any(key in d for d in result):
+            result.append({key: value})
 
+    return result
 
-def merge_variables(
-    existing_metadata: model.DatadocMetadata,
-    extracted_metadata: model.DatadocMetadata,
-    merged_metadata: model.DatadocMetadata,
-) -> model.DatadocMetadata:
-    """Merges variables from the extracted metadata into the existing metadata and updates the merged metadata.
 
-    This function compares the variables from `extracted_metadata` with those in `existing_metadata`.
-    For each variable in `extracted_metadata`, it checks if a variable with the same `short_name` exists
-    in `existing_metadata`. If a match is found, it updates the existing variable with information from
-    `extracted_metadata`. If no match is found, the variable from `extracted_metadata` is directly added to `merged_metadata`.
-
-    Args:
-        existing_metadata: The metadata object containing the current state of variables.
-        extracted_metadata: The metadata object containing new or updated variables to merge.
-        merged_metadata: The metadata object that will contain the result of the merge.
+def set_default_values_pseudonymization(
+    variable: VariableType,
+    pseudonymization: PseudonymizationType | None,
+) -> None:
+    """Populate pseudonymization fields with defaults based on the encryption algorithm.
 
-    Returns:
-        model.DatadocMetadata: The `merged_metadata` object containing variables from both `existing_metadata`
-        and `extracted_metadata`.
+    Updates the encryption key reference and encryption parameters if they are not set,
+    handling both PAPIS and DAED algorithms. Leaves unknown algorithms unchanged.
     """
-    if (
-        existing_metadata.variables is not None
-        and extracted_metadata is not None
-        and extracted_metadata.variables is not None
-        and merged_metadata.variables is not None
-    ):
-        for extracted in extracted_metadata.variables:
-            existing = next(
-                (
-                    existing
-                    for existing in existing_metadata.variables
-                    if existing.short_name == extracted.short_name
-                ),
-                None,
-            )
-            if existing:
-                existing.id = (
-                    None  # Set to None so that it will be set assigned a fresh ID later
+    if pseudonymization is None:
+        return
+    if variable.pseudonymization is None:
+        variable.pseudonymization = pseudonymization
+    match pseudonymization.encryption_algorithm:
+        case EncryptionAlgorithm.PAPIS_ENCRYPTION_ALGORITHM.value:
+            if not pseudonymization.encryption_key_reference:
+                pseudonymization.encryption_key_reference = (
+                    PAPIS_ENCRYPTION_KEY_REFERENCE
+                )
+            base_params = {
+                ENCRYPTION_PARAMETER_KEY_ID: PAPIS_ENCRYPTION_KEY_REFERENCE,
+                ENCRYPTION_PARAMETER_STRATEGY: ENCRYPTION_PARAMETER_STRATEGY_SKIP,
+            }
+            if pseudonymization.stable_identifier_type == PAPIS_STABLE_IDENTIFIER_TYPE:
+                base_params[ENCRYPTION_PARAMETER_SNAPSHOT_DATE] = get_current_date()
+            pseudonymization.encryption_algorithm_parameters = (
+                _ensure_encryption_parameters(
+                    pseudonymization.encryption_algorithm_parameters,
+                    base_params,
                 )
-                existing.contains_data_from = (
-                    extracted.contains_data_from or existing.contains_data_from
+            )
+        case EncryptionAlgorithm.DAEAD_ENCRYPTION_ALGORITHM.value:
+            if not pseudonymization.encryption_key_reference:
+                pseudonymization.encryption_key_reference = (
+                    DAEAD_ENCRYPTION_KEY_REFERENCE
                 )
-                existing.contains_data_until = (
-                    extracted.contains_data_until or existing.contains_data_until
+            pseudonymization.encryption_algorithm_parameters = (
+                _ensure_encryption_parameters(
+                    pseudonymization.encryption_algorithm_parameters,
+                    {
+                        ENCRYPTION_PARAMETER_KEY_ID: DAEAD_ENCRYPTION_KEY_REFERENCE,
+                    },
                 )
-                merged_metadata.variables.append(existing)
-            else:
-                # If there is no existing metadata for this variable, we just use what we have extracted
-                merged_metadata.variables.append(extracted)
-    return merged_metadata
+            )
+        case _:
+            pass

dapla_metadata/standards/__init__.py

@@ -0,0 +1,4 @@
+"""Expose information specific to validating ssb standards."""
+
+from .standard_validators import check_naming_standard
+from .standard_validators import generate_validation_report