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

dapla_metadata/datasets/compatibility/model_backwards_compatibility.py

@@ -0,0 +1,135 @@
+"""Upgrade old metadata files to be compatible with new versions.
+
+An important principle of Datadoc is that we ALWAYS guarantee backwards
+compatibility of existing metadata documents. This means that we guarantee
+that a user will never lose data, even if their document is decades old.
+
+For each document version we release with breaking changes, we implement a
+handler and register the version by defining a BackwardsCompatibleVersion
+instance. These documents will then be upgraded when they're opened in Datadoc.
+
+A test must also be implemented for each new version.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from typing import Any
+
+from dapla_metadata.datasets.compatibility._handlers import handle_current_version
+from dapla_metadata.datasets.compatibility._handlers import handle_version_0_1_1
+from dapla_metadata.datasets.compatibility._handlers import handle_version_1_0_0
+from dapla_metadata.datasets.compatibility._handlers import handle_version_2_1_0
+from dapla_metadata.datasets.compatibility._handlers import handle_version_2_2_0
+from dapla_metadata.datasets.compatibility._handlers import handle_version_3_1_0
+from dapla_metadata.datasets.compatibility._handlers import handle_version_3_2_0
+from dapla_metadata.datasets.compatibility._handlers import handle_version_3_3_0
+from dapla_metadata.datasets.compatibility._handlers import handle_version_4_0_0
+from dapla_metadata.datasets.compatibility._handlers import handle_version_5_0_1
+from dapla_metadata.datasets.compatibility._handlers import handle_version_6_0_0
+from dapla_metadata.datasets.compatibility._utils import DATADOC_KEY
+from dapla_metadata.datasets.compatibility._utils import DOCUMENT_VERSION_KEY
+from dapla_metadata.datasets.compatibility._utils import UnknownModelVersionError
+from dapla_metadata.datasets.compatibility._utils import (
+    is_metadata_in_container_structure,
+)
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+SUPPORTED_VERSIONS: OrderedDict[str, BackwardsCompatibleVersion] = OrderedDict()
+
+
+@dataclass()
+class BackwardsCompatibleVersion:
+    """A version which we support with backwards compatibility.
+
+    This class registers a version and its corresponding handler function
+    for backwards compatibility.
+    """
+
+    version: str
+    handler: Callable[[dict[str, Any]], dict[str, Any]]
+
+    def __post_init__(self) -> None:
+        """Register this version in the supported versions map.
+
+        This method adds the instance to the `SUPPORTED_VERSIONS` dictionary
+        using the version as the key.
+        """
+        SUPPORTED_VERSIONS[self.version] = self
+
+    def upgrade(self, metadata: dict[str, Any]) -> dict[str, Any]:
+        """Upgrade metadata from the format of the previous version to the format of this version.
+
+        This method handles bumping the Document Version field so it's not necessary to do this in
+        the individual handler functions.
+
+        Args:
+            metadata (dict[str, Any]): Metadata in the format of the previous version, to be upgraded.
+
+        Returns:
+            dict[str, Any]: The metadata upgraded to the version specified
+        """
+        metadata = self.handler(metadata)
+        if is_metadata_in_container_structure(metadata):
+            metadata[DATADOC_KEY][DOCUMENT_VERSION_KEY] = self.version
+        else:
+            metadata[DOCUMENT_VERSION_KEY] = self.version
+        return metadata
+
+
+# Register all the supported versions and their handlers.
+BackwardsCompatibleVersion(version="0.1.1", handler=handle_version_0_1_1)
+BackwardsCompatibleVersion(version="1.0.0", handler=handle_version_1_0_0)
+BackwardsCompatibleVersion(version="2.1.0", handler=handle_version_2_1_0)
+BackwardsCompatibleVersion(version="2.2.0", handler=handle_version_2_2_0)
+BackwardsCompatibleVersion(version="3.1.0", handler=handle_version_3_1_0)
+BackwardsCompatibleVersion(version="3.2.0", handler=handle_version_3_2_0)
+BackwardsCompatibleVersion(version="3.3.0", handler=handle_version_3_3_0)
+BackwardsCompatibleVersion(version="4.0.0", handler=handle_version_4_0_0)
+BackwardsCompatibleVersion(version="5.0.1", handler=handle_version_5_0_1)
+BackwardsCompatibleVersion(version="6.0.0", handler=handle_version_6_0_0)
+BackwardsCompatibleVersion(version="6.1.0", handler=handle_current_version)
+
+
+def upgrade_metadata(fresh_metadata: dict[str, Any]) -> dict[str, Any]:
+    """Upgrade the metadata to the latest version using registered handlers.
+
+    This function checks the version of the provided metadata and applies a series
+    of upgrade handlers to migrate the metadata to the latest version.
+    It starts from the provided version and applies all subsequent handlers in
+    sequence. If the metadata is already in the latest version or the version
+    cannot be determined, appropriate actions are taken.
+
+    Args:
+        fresh_metadata: The metadata dictionary to be upgraded. This dictionary
+            must include version information that determines which handlers to apply.
+
+    Returns:
+        The upgraded metadata dictionary, after applying all necessary handlers.
+
+    Raises:
+        UnknownModelVersionError: If the metadata's version is unknown or unsupported.
+    """
+    if is_metadata_in_container_structure(fresh_metadata):
+        if fresh_metadata[DATADOC_KEY] is None:
+            return fresh_metadata
+        supplied_version = fresh_metadata[DATADOC_KEY][DOCUMENT_VERSION_KEY]
+    else:
+        supplied_version = fresh_metadata[DOCUMENT_VERSION_KEY]
+    start_running_handlers = False
+    # Run all the handlers in order from the supplied version onwards
+    for k, v in SUPPORTED_VERSIONS.items():
+        if k == supplied_version:
+            start_running_handlers = True
+        if start_running_handlers:
+            fresh_metadata = v.upgrade(fresh_metadata)
+    if not start_running_handlers:
+        raise UnknownModelVersionError(supplied_version)
+    return fresh_metadata

dapla_metadata/datasets/core.py

@@ -5,35 +5,42 @@ from __future__ import annotations
 import copy
 import json
 import logging
-import warnings
 from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
 from typing import TYPE_CHECKING
-
-from datadoc_model import model
-from datadoc_model.model import DataSetStatus
-
-from dapla_metadata.datasets import config
-from dapla_metadata.datasets import user_info
+from typing import cast
+
+import datadoc_model.all_optional.model as all_optional_model
+import datadoc_model.required.model as required_model
+from datadoc_model.all_optional.model import DataSetStatus
+
+from dapla_metadata._shared import config
+from dapla_metadata.dapla import user_info
+from dapla_metadata.datasets._merge import DatasetConsistencyStatus
+from dapla_metadata.datasets._merge import check_dataset_consistency
+from dapla_metadata.datasets._merge import check_ready_to_merge
+from dapla_metadata.datasets._merge import check_variables_consistency
+from dapla_metadata.datasets._merge import merge_metadata
+from dapla_metadata.datasets.compatibility import is_metadata_in_container_structure
+from dapla_metadata.datasets.compatibility import upgrade_metadata
 from dapla_metadata.datasets.dapla_dataset_path_info import DaplaDatasetPathInfo
 from dapla_metadata.datasets.dataset_parser import DatasetParser
-from dapla_metadata.datasets.model_backwards_compatibility import (
-    is_metadata_in_container_structure,
-)
-from dapla_metadata.datasets.model_backwards_compatibility import upgrade_metadata
 from dapla_metadata.datasets.model_validation import ValidateDatadocMetadata
 from dapla_metadata.datasets.statistic_subject_mapping import StatisticSubjectMapping
 from dapla_metadata.datasets.utility.constants import (
     DEFAULT_SPATIAL_COVERAGE_DESCRIPTION,
 )
-from dapla_metadata.datasets.utility.constants import INCONSISTENCIES_MESSAGE
 from dapla_metadata.datasets.utility.constants import METADATA_DOCUMENT_FILE_SUFFIX
 from dapla_metadata.datasets.utility.constants import NUM_OBLIGATORY_DATASET_FIELDS
 from dapla_metadata.datasets.utility.constants import NUM_OBLIGATORY_VARIABLES_FIELDS
+from dapla_metadata.datasets.utility.urn import convert_uris_to_urns
+from dapla_metadata.datasets.utility.urn import klass_urn_converter
+from dapla_metadata.datasets.utility.urn import vardef_urn_converter
+from dapla_metadata.datasets.utility.utils import OptionalDatadocMetadataType
+from dapla_metadata.datasets.utility.utils import VariableListType
+from dapla_metadata.datasets.utility.utils import VariableType
 from dapla_metadata.datasets.utility.utils import calculate_percentage
 from dapla_metadata.datasets.utility.utils import derive_assessment_from_state
 from dapla_metadata.datasets.utility.utils import get_timestamp_now
-from dapla_metadata.datasets.utility.utils import merge_variables
 from dapla_metadata.datasets.utility.utils import normalize_path
 from dapla_metadata.datasets.utility.utils import (
     num_obligatory_dataset_fields_completed,
@@ -41,8 +48,9 @@ from dapla_metadata.datasets.utility.utils import (
 from dapla_metadata.datasets.utility.utils import (
     num_obligatory_variables_fields_completed,
 )
-from dapla_metadata.datasets.utility.utils import override_dataset_fields
+from dapla_metadata.datasets.utility.utils import set_dataset_owner
 from dapla_metadata.datasets.utility.utils import set_default_values_dataset
+from dapla_metadata.datasets.utility.utils import set_default_values_pseudonymization
 from dapla_metadata.datasets.utility.utils import set_default_values_variables
 
 if TYPE_CHECKING:
@@ -51,18 +59,9 @@ if TYPE_CHECKING:
 
     from cloudpathlib import CloudPath
 
-
 logger = logging.getLogger(__name__)
 
 
-class InconsistentDatasetsWarning(UserWarning):
-    """Existing and new datasets differ significantly from one another."""
-
-
-class InconsistentDatasetsError(ValueError):
-    """Existing and new datasets differ significantly from one another."""
-
-
 class Datadoc:
     """Handle reading, updating and writing of metadata.
 
@@ -83,8 +82,8 @@ class Datadoc:
         dataset_path: str | None = None,
         metadata_document_path: str | None = None,
         statistic_subject_mapping: StatisticSubjectMapping | None = None,
-        *,
         errors_as_warnings: bool = False,
+        validate_required_fields_on_existing_metadata: bool = False,
     ) -> None:
         """Initialize the Datadoc instance.
 
@@ -100,16 +99,23 @@ class Datadoc:
                 Defaults to None
             errors_as_warnings: Disable raising exceptions if inconsistencies
                 are found between existing and extracted metadata.
+            validate_required_fields_on_existing_metadata: Use a Pydantic model
+                which validates whether required fields are present when reading
+                in an existing metadata file.
         """
         self._statistic_subject_mapping = statistic_subject_mapping
         self.errors_as_warnings = errors_as_warnings
+        self.validate_required_fields_on_existing_metadata = (
+            validate_required_fields_on_existing_metadata
+        )
         self.metadata_document: pathlib.Path | CloudPath | None = None
-        self.container: model.MetadataContainer | None = None
+        self.container: all_optional_model.MetadataContainer | None = None
         self.dataset_path: pathlib.Path | CloudPath | None = None
-        self.dataset = model.Dataset()
-        self.variables: list = []
-        self.variables_lookup: dict[str, model.Variable] = {}
+        self.dataset = all_optional_model.Dataset()
+        self.variables: VariableListType = []
+        self.variables_lookup: dict[str, VariableType] = {}
         self.explicitly_defined_metadata_document = False
+        self.dataset_consistency_status: list[DatasetConsistencyStatus] = []
         if metadata_document_path:
             self.metadata_document = normalize_path(metadata_document_path)
             self.explicitly_defined_metadata_document = True
@@ -145,8 +151,9 @@ class Datadoc:
         - The 'contains_personal_data' attribute is set to False if not specified.
         - A lookup dictionary for variables is created based on their short names.
         """
-        extracted_metadata: model.DatadocMetadata | None = None
-        existing_metadata: model.DatadocMetadata | None = None
+        extracted_metadata: all_optional_model.DatadocMetadata | None = None
+        existing_metadata: OptionalDatadocMetadataType = None
+
         if self.metadata_document and self.metadata_document.exists():
             existing_metadata = self._extract_metadata_from_existing_document(
                 self.metadata_document,
@@ -154,11 +161,28 @@ class Datadoc:
 
         if (
             self.dataset_path is not None
-            and self.dataset == model.Dataset()
+            and self.dataset == all_optional_model.Dataset()
             and len(self.variables) == 0
         ):
             extracted_metadata = self._extract_metadata_from_dataset(self.dataset_path)
 
+        if (
+            self.dataset_path
+            and self.metadata_document
+            and extracted_metadata
+            and existing_metadata
+        ):
+            self.dataset_consistency_status = check_dataset_consistency(
+                self.dataset_path,
+                self.metadata_document,
+            )
+            self.dataset_consistency_status.extend(
+                check_variables_consistency(
+                    extracted_metadata.variables or [],
+                    existing_metadata.variables or [],
+                )
+            )
+
         if (
             self.dataset_path
             and self.explicitly_defined_metadata_document
@@ -167,15 +191,11 @@ class Datadoc:
             and extracted_metadata is not None
             and existing_metadata is not None
         ):
-            existing_file_path = self._get_existing_file_path(extracted_metadata)
-            self._check_ready_to_merge(
-                self.dataset_path,
-                Path(existing_file_path),
-                extracted_metadata,
-                existing_metadata,
+            check_ready_to_merge(
+                self.dataset_consistency_status,
                 errors_as_warnings=self.errors_as_warnings,
             )
-            merged_metadata = self._merge_metadata(
+            merged_metadata = merge_metadata(
                 extracted_metadata,
                 existing_metadata,
             )
@@ -187,157 +207,35 @@ class Datadoc:
             self._set_metadata(merged_metadata)
         else:
             self._set_metadata(existing_metadata or extracted_metadata)
-        set_default_values_variables(self.variables)
-        set_default_values_dataset(self.dataset)
-        self._create_variables_lookup()
-
-    def _get_existing_file_path(
-        self,
-        extracted_metadata: model.DatadocMetadata | None,
-    ) -> str:
-        if (
-            extracted_metadata is not None
-            and extracted_metadata.dataset is not None
-            and extracted_metadata.dataset.file_path is not None
-        ):
-            return extracted_metadata.dataset.file_path
-        msg = "Could not access existing dataset file path"
-        raise ValueError(msg)
 
     def _set_metadata(
         self,
-        merged_metadata: model.DatadocMetadata | None,
+        metadata: OptionalDatadocMetadataType,
     ) -> None:
-        if not merged_metadata or not (
-            merged_metadata.dataset and merged_metadata.variables
-        ):
+        if not metadata or not (metadata.dataset and metadata.variables):
             msg = "Could not read metadata"
             raise ValueError(msg)
-        self.dataset = merged_metadata.dataset
-        self.variables = merged_metadata.variables
+        self.dataset = cast("all_optional_model.Dataset", metadata.dataset)
+        self.variables = metadata.variables
+
+        set_default_values_variables(self.variables)
+        set_default_values_dataset(cast("all_optional_model.Dataset", self.dataset))
+        set_dataset_owner(self.dataset)
+        convert_uris_to_urns(self.variables, "definition_uri", [vardef_urn_converter])
+        convert_uris_to_urns(
+            self.variables, "classification_uri", [klass_urn_converter]
+        )
+        self._create_variables_lookup()
 
     def _create_variables_lookup(self) -> None:
         self.variables_lookup = {
             v.short_name: v for v in self.variables if v.short_name
         }
 
-    @staticmethod
-    def _check_ready_to_merge(
-        new_dataset_path: Path | CloudPath,
-        existing_dataset_path: Path,
-        extracted_metadata: model.DatadocMetadata,
-        existing_metadata: model.DatadocMetadata,
-        *,
-        errors_as_warnings: bool,
-    ) -> None:
-        """Check if the datasets are consistent enough to make a successful merge of metadata.
-
-        Args:
-            new_dataset_path: Path to the dataset to be documented.
-            existing_dataset_path: Path stored in the existing metadata.
-            extracted_metadata: Metadata extracted from a physical dataset.
-            existing_metadata: Metadata from a previously created metadata document.
-            errors_as_warnings: True if failing checks should be raised as warnings, not errors.
-
-        Raises:
-            InconsistentDatasetsError: If inconsistencies are found and `errors_as_warnings == False`
-        """
-        new_dataset_path_info = DaplaDatasetPathInfo(new_dataset_path)
-        existing_dataset_path_info = DaplaDatasetPathInfo(existing_dataset_path)
-        results = [
-            {
-                "name": "Bucket name",
-                "success": (
-                    new_dataset_path_info.bucket_name
-                    == existing_dataset_path_info.bucket_name
-                ),
-            },
-            {
-                "name": "Data product name",
-                "success": (
-                    new_dataset_path_info.statistic_short_name
-                    == existing_dataset_path_info.statistic_short_name
-                ),
-            },
-            {
-                "name": "Dataset state",
-                "success": (
-                    new_dataset_path_info.dataset_state
-                    == existing_dataset_path_info.dataset_state
-                ),
-            },
-            {
-                "name": "Dataset short name",
-                "success": (
-                    new_dataset_path_info.dataset_short_name
-                    == existing_dataset_path_info.dataset_short_name
-                ),
-            },
-            {
-                "name": "Variable names",
-                "success": (
-                    {v.short_name for v in extracted_metadata.variables or []}
-                    == {v.short_name for v in existing_metadata.variables or []}
-                ),
-            },
-            {
-                "name": "Variable datatypes",
-                "success": (
-                    [v.data_type for v in extracted_metadata.variables or []]
-                    == [v.data_type for v in existing_metadata.variables or []]
-                ),
-            },
-        ]
-        if failures := [result for result in results if not result["success"]]:
-            msg = f"{INCONSISTENCIES_MESSAGE} {', '.join(str(f['name']) for f in failures)}"
-            if errors_as_warnings:
-                warnings.warn(
-                    message=msg,
-                    category=InconsistentDatasetsWarning,
-                    stacklevel=2,
-                )
-            else:
-                raise InconsistentDatasetsError(
-                    msg,
-                )
-
-    @staticmethod
-    def _merge_metadata(
-        extracted_metadata: model.DatadocMetadata | None,
-        existing_metadata: model.DatadocMetadata | None,
-    ) -> model.DatadocMetadata:
-        if not existing_metadata:
-            logger.warning(
-                "No existing metadata found, no merge to perform. Continuing with extracted metadata.",
-            )
-            return extracted_metadata or model.DatadocMetadata()
-
-        if not extracted_metadata:
-            return existing_metadata
-
-        # Use the extracted metadata as a base
-        merged_metadata = model.DatadocMetadata(
-            dataset=copy.deepcopy(extracted_metadata.dataset),
-            variables=[],
-        )
-
-        override_dataset_fields(
-            merged_metadata=merged_metadata,
-            existing_metadata=existing_metadata,
-        )
-
-        # Merge variables.
-        # For each extracted variable, copy existing metadata into the merged metadata
-        return merge_variables(
-            existing_metadata=existing_metadata,
-            extracted_metadata=extracted_metadata,
-            merged_metadata=merged_metadata,
-        )
-
     def _extract_metadata_from_existing_document(
         self,
         document: pathlib.Path | CloudPath,
-    ) -> model.DatadocMetadata | None:
+    ) -> OptionalDatadocMetadataType:
         """Read metadata from an existing metadata document.
 
         If an existing metadata document is available, this method reads and
@@ -352,7 +250,13 @@ class Datadoc:
 
         Raises:
             json.JSONDecodeError: If the metadata document cannot be parsed.
+            pydantic.ValidationError: If the data does not successfully validate.
         """
+        metadata_model = (
+            required_model
+            if self.validate_required_fields_on_existing_metadata
+            else all_optional_model
+        )
         fresh_metadata = {}
         try:
             with document.open(mode="r", encoding="utf-8") as file:
@@ -362,7 +266,7 @@ class Datadoc:
                 fresh_metadata,
             )
             if is_metadata_in_container_structure(fresh_metadata):
-                self.container = model.MetadataContainer.model_validate_json(
+                self.container = metadata_model.MetadataContainer.model_validate_json(
                     json.dumps(fresh_metadata),
                 )
                 datadoc_metadata = fresh_metadata["datadoc"]
@@ -370,7 +274,7 @@ class Datadoc:
                 datadoc_metadata = fresh_metadata
             if datadoc_metadata is None:
                 return None
-            return model.DatadocMetadata.model_validate_json(
+            return metadata_model.DatadocMetadata.model_validate_json(
                 json.dumps(datadoc_metadata),
             )
         except json.JSONDecodeError:
@@ -414,7 +318,7 @@ class Datadoc:
     def _extract_metadata_from_dataset(
         self,
         dataset: pathlib.Path | CloudPath,
-    ) -> model.DatadocMetadata:
+    ) -> all_optional_model.DatadocMetadata:
         """Obtain what metadata we can from the dataset itself.
 
         This makes it easier for the user by 'pre-filling' certain fields.
@@ -434,9 +338,9 @@ class Datadoc:
                 - variables: A list of fields extracted from the dataset schema.
         """
         dapla_dataset_path_info = DaplaDatasetPathInfo(dataset)
-        metadata = model.DatadocMetadata()
+        metadata = all_optional_model.DatadocMetadata()
 
-        metadata.dataset = model.Dataset(
+        metadata.dataset = all_optional_model.Dataset(
             short_name=dapla_dataset_path_info.dataset_short_name,
             dataset_state=dapla_dataset_path_info.dataset_state,
             dataset_status=DataSetStatus.DRAFT,
@@ -471,6 +375,19 @@ class Datadoc:
         """
         return dataset_path.parent / (dataset_path.stem + METADATA_DOCUMENT_FILE_SUFFIX)
 
+    def datadoc_model(self) -> all_optional_model.MetadataContainer:
+        """Return the underlying datadoc model."""
+        datadoc: ValidateDatadocMetadata = ValidateDatadocMetadata(
+            percentage_complete=self.percent_complete,
+            dataset=self.dataset,
+            variables=self.variables,
+        )
+        if self.container:
+            res = copy.deepcopy(self.container)
+            res.datadoc = datadoc
+            return res
+        return all_optional_model.MetadataContainer(datadoc=datadoc)
+
     def write_metadata_document(self) -> None:
         """Write all currently known metadata to file.
 
@@ -500,12 +417,15 @@ class Datadoc:
         if self.container:
             self.container.datadoc = datadoc
         else:
-            self.container = model.MetadataContainer(datadoc=datadoc)
+            self.container = all_optional_model.MetadataContainer(datadoc=datadoc)
         if self.metadata_document:
             content = self.container.model_dump_json(indent=4)
             self.metadata_document.write_text(content)
             logger.info("Saved metadata document %s", self.metadata_document)
-            logger.info("Metadata content:\n%s", content)
+            logger.info(
+                "Metadata content",
+                extra={"metadata_content": json.loads(content)},
+            )
         else:
             msg = "No metadata document to save"
             raise ValueError(msg)
@@ -525,3 +445,37 @@ class Datadoc:
             self.dataset,
         ) + num_obligatory_variables_fields_completed(self.variables)
         return calculate_percentage(num_set_fields, num_all_fields)
+
+    def add_pseudonymization(
+        self,
+        variable_short_name: str,
+        pseudonymization: all_optional_model.Pseudonymization | None = None,
+    ) -> None:
+        """Adds a new pseudo variable to the list of pseudonymized variables.
+
+        If `pseudonymization` is not supplied, an empty Pseudonymization structure
+        will be created and assigned to the variable.
+        If an encryption algorithm is recognized (one of the standard Dapla algorithms), default values are filled
+        for any missing fields.
+
+        Args:
+            variable_short_name: The short name for the variable that one wants to update the pseudo for.
+            pseudonymization: The updated pseudonymization.
+
+        """
+        variable = self.variables_lookup[variable_short_name]
+        if pseudonymization:
+            set_default_values_pseudonymization(variable, pseudonymization)
+        else:
+            variable.pseudonymization = all_optional_model.Pseudonymization()
+
+    def remove_pseudonymization(self, variable_short_name: str) -> None:
+        """Removes a pseudo variable by using the shortname.
+
+        Updates the pseudo variable lookup by creating a new one.
+
+        Args:
+            variable_short_name: The short name for the variable that one wants to remove the pseudo for.
+        """
+        if self.variables_lookup[variable_short_name].pseudonymization is not None:
+            self.variables_lookup[variable_short_name].pseudonymization = None