dapla-toolbelt-metadata 0.6.6__py3-none-any.whl → 0.7.1__py3-none-any.whl

dapla_metadata/__init__.py

@@ -7,7 +7,7 @@ warnings.filterwarnings(
     message="As the c extension couldn't be imported, `google-crc32c` is using a pure python implementation that is significantly slower.",
 )
 
-import datadoc_model.model as datadoc_model
+import datadoc_model.all_optional.model as datadoc_model
 
 from . import dapla
 from . import datasets

dapla_metadata/datasets/core.py

@@ -9,9 +9,11 @@ import warnings
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import TYPE_CHECKING
+from typing import cast
 
-from datadoc_model import model
-from datadoc_model.model import DataSetStatus
+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
@@ -30,6 +32,8 @@ 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.utils import ExistingPseudonymizationMetadataType
+from dapla_metadata.datasets.utility.utils import OptionalDatadocMetadataType
 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
@@ -84,8 +88,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.
 
@@ -101,17 +105,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.dataset = all_optional_model.Dataset()
         self.variables: list = []
-        self.pseudo_variables: list[model.PseudoVariable] = []
-        self.variables_lookup: dict[str, model.Variable] = {}
-        self.pseudo_variables_lookup: dict[str, model.PseudoVariable] = {}
+        self.pseudo_variables: list[all_optional_model.PseudoVariable] = []
+        self.variables_lookup: dict[str, all_optional_model.Variable] = {}
+        self.pseudo_variables_lookup: dict[str, all_optional_model.PseudoVariable] = {}
         self.explicitly_defined_metadata_document = False
         self.dataset_consistency_status: list = []
         if metadata_document_path:
@@ -149,9 +159,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
-        existing_pseudonymization: model.PseudonymizationMetadata | None = None
+        extracted_metadata: all_optional_model.DatadocMetadata | None = None
+        existing_metadata: OptionalDatadocMetadataType = None
+        existing_pseudonymization: ExistingPseudonymizationMetadataType = None
 
         if self.metadata_document and self.metadata_document.exists():
             existing_metadata = self._extract_metadata_from_existing_document(
@@ -166,7 +176,7 @@ 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)
@@ -215,14 +225,14 @@ class Datadoc:
             self._set_pseudonymization_metadata(existing_pseudonymization)
 
         set_default_values_variables(self.variables)
-        set_default_values_dataset(self.dataset)
+        set_default_values_dataset(cast("all_optional_model.Dataset", self.dataset))
         set_dataset_owner(self.dataset)
         self._create_variables_lookup()
         self._create_pseudo_variables_lookup()
 
     def _get_existing_file_path(
         self,
-        extracted_metadata: model.DatadocMetadata | None,
+        extracted_metadata: all_optional_model.DatadocMetadata | None,
     ) -> str:
         if (
             extracted_metadata is not None
@@ -235,19 +245,19 @@ class Datadoc:
 
     def _set_metadata(
         self,
-        merged_metadata: model.DatadocMetadata | None,
+        merged_metadata: OptionalDatadocMetadataType,
     ) -> None:
         if not merged_metadata or not (
             merged_metadata.dataset and merged_metadata.variables
         ):
             msg = "Could not read metadata"
             raise ValueError(msg)
-        self.dataset = merged_metadata.dataset
+        self.dataset = cast("all_optional_model.Dataset", merged_metadata.dataset)
         self.variables = merged_metadata.variables
 
     def _set_pseudonymization_metadata(
         self,
-        existing_pseudonymization: model.PseudonymizationMetadata | None,
+        existing_pseudonymization: ExistingPseudonymizationMetadataType,
     ) -> None:
         if not existing_pseudonymization or not (
             existing_pseudonymization.pseudo_variables is not None
@@ -255,7 +265,10 @@ class Datadoc:
             msg = "Error reading pseudonymization metadata"
             logger.error(msg)
             return
-        self.pseudo_variables = existing_pseudonymization.pseudo_variables
+        self.pseudo_variables = cast(
+            "list[all_optional_model.PseudoVariable]",
+            existing_pseudonymization.pseudo_variables,
+        )
 
     def _create_variables_lookup(self) -> None:
         self.variables_lookup = {
@@ -272,8 +285,8 @@ class Datadoc:
     def _check_dataset_consistency(
         new_dataset_path: Path | CloudPath,
         existing_dataset_path: Path,
-        extracted_metadata: model.DatadocMetadata,
-        existing_metadata: model.DatadocMetadata,
+        extracted_metadata: all_optional_model.DatadocMetadata,
+        existing_metadata: OptionalDatadocMetadataType,
     ) -> list[dict[str, object]]:
         """Run consistency tests.
 
@@ -320,14 +333,16 @@ class Datadoc:
             {
                 "name": "Variable names",
                 "success": (
-                    {v.short_name for v in extracted_metadata.variables or []}
+                    existing_metadata is not None
+                    and {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 []]
+                    existing_metadata is not None
+                    and [v.data_type for v in extracted_metadata.variables or []]
                     == [v.data_type for v in existing_metadata.variables or []]
                 ),
             },
@@ -361,27 +376,29 @@ class Datadoc:
 
     @staticmethod
     def _merge_metadata(
-        extracted_metadata: model.DatadocMetadata | None,
-        existing_metadata: model.DatadocMetadata | None,
-    ) -> model.DatadocMetadata:
+        extracted_metadata: all_optional_model.DatadocMetadata | None,
+        existing_metadata: OptionalDatadocMetadataType,
+    ) -> all_optional_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()
+            return extracted_metadata or all_optional_model.DatadocMetadata()
 
         if not extracted_metadata:
-            return existing_metadata
+            return cast("all_optional_model.DatadocMetadata", existing_metadata)
 
         # Use the extracted metadata as a base
-        merged_metadata = model.DatadocMetadata(
+        merged_metadata = all_optional_model.DatadocMetadata(
             dataset=copy.deepcopy(extracted_metadata.dataset),
             variables=[],
         )
 
         override_dataset_fields(
             merged_metadata=merged_metadata,
-            existing_metadata=existing_metadata,
+            existing_metadata=cast(
+                "all_optional_model.DatadocMetadata", existing_metadata
+            ),
         )
 
         # Merge variables.
@@ -395,7 +412,7 @@ class Datadoc:
     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
@@ -410,7 +427,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:
@@ -420,7 +443,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"]
@@ -428,7 +451,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:
@@ -443,7 +466,11 @@ class Datadoc:
     def _extract_pseudonymization_from_existing_document(
         self,
         document: pathlib.Path | CloudPath,
-    ) -> model.PseudonymizationMetadata | None:
+    ) -> (
+        all_optional_model.PseudonymizationMetadata
+        | required_model.PseudonymizationMetadata
+        | None
+    ):
         """Read pseudo metadata from an existing metadata document.
 
         If there is pseudo metadata in the document supplied, the method validates and returns the pseudonymization structure.
@@ -453,7 +480,14 @@ 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
+        )
+
         try:
             with document.open(mode="r", encoding="utf-8") as file:
                 fresh_metadata = json.load(file)
@@ -472,7 +506,7 @@ class Datadoc:
         if pseudonymization_metadata is None:
             return None
 
-        return model.PseudonymizationMetadata.model_validate_json(
+        return metadata_model.PseudonymizationMetadata.model_validate_json(
             json.dumps(pseudonymization_metadata),
         )
 
@@ -508,7 +542,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.
@@ -528,9 +562,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,
@@ -594,12 +628,14 @@ class Datadoc:
         if self.container:
             self.container.datadoc = datadoc
             if not self.container.pseudonymization:
-                self.container.pseudonymization = model.PseudonymizationMetadata(
-                    pseudo_dataset=model.PseudoDataset()
+                self.container.pseudonymization = (
+                    all_optional_model.PseudonymizationMetadata(
+                        pseudo_dataset=all_optional_model.PseudoDataset()
+                    )
                 )
             self.container.pseudonymization.pseudo_variables = self.pseudo_variables
         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)
@@ -629,14 +665,44 @@ class Datadoc:
         return calculate_percentage(num_set_fields, num_all_fields)
 
     def add_pseudo_variable(self, variable_short_name: str) -> None:
-        """Adds a new pseudo variable to the list of pseudonymized variables."""
+        """Adds a new pseudo variable to the list of pseudonymized variables.
+
+        Sets is_personal_data to pseudonymized encrypted personal data.
+        """
         if self.variables_lookup[variable_short_name] is not None:
-            pseudo_variable = model.PseudoVariable(short_name=variable_short_name)
+            pseudo_variable = all_optional_model.PseudoVariable(
+                short_name=variable_short_name
+            )
             self.pseudo_variables.append(pseudo_variable)
             self.pseudo_variables_lookup[variable_short_name] = pseudo_variable
+            self.variables_lookup[
+                variable_short_name
+            ].is_personal_data = (
+                all_optional_model.IsPersonalData.PSEUDONYMISED_ENCRYPTED_PERSONAL_DATA
+            )
+
+    def remove_pseudo_variable(self, variable_short_name: str) -> None:
+        """Removes a pseudo variable by using the shortname.
+
+        Updates the pseudo variable lookup by creating a new one.
+        Sets is_personal_data to non pseudonymized encrypted personal data.
+        """
+        if self.pseudo_variables_lookup[variable_short_name] is not None:
+            pseudo_variable = self.get_pseudo_variable(variable_short_name)
+
+            if pseudo_variable is not None:
+                self.pseudo_variables = [
+                    pseudo_variable
+                    for pseudo_variable in self.pseudo_variables
+                    if pseudo_variable.short_name != variable_short_name
+                ]
+            self._create_pseudo_variables_lookup()
+            self.variables_lookup[
+                variable_short_name
+            ].is_personal_data = all_optional_model.IsPersonalData.NON_PSEUDONYMISED_ENCRYPTED_PERSONAL_DATA
 
     def get_pseudo_variable(
         self, variable_short_name: str
-    ) -> model.PseudoVariable | None:
+    ) -> all_optional_model.PseudoVariable | None:
         """Finds a pseudo variable by shortname."""
         return self.pseudo_variables_lookup.get(variable_short_name)

dapla_metadata/datasets/dapla_dataset_path_info.py

@@ -14,7 +14,7 @@ from typing import Literal
 
 import arrow
 from cloudpathlib import GSPath
-from datadoc_model.model import DataSetState
+from datadoc_model.all_optional.model import DataSetState
 
 if TYPE_CHECKING:
     import datetime

dapla_metadata/datasets/dataset_parser.py

@@ -12,10 +12,10 @@ from abc import abstractmethod
 from typing import TYPE_CHECKING
 
 import pandas as pd
-from datadoc_model.model import DataType
-from datadoc_model.model import LanguageStringType
-from datadoc_model.model import LanguageStringTypeItem
-from datadoc_model.model import Variable
+from datadoc_model.all_optional.model import DataType
+from datadoc_model.all_optional.model import LanguageStringType
+from datadoc_model.all_optional.model import LanguageStringTypeItem
+from datadoc_model.all_optional.model import Variable
 from pyarrow import parquet as pq
 
 from dapla_metadata.datasets.utility.enums import SupportedLanguages

dapla_metadata/datasets/statistic_subject_mapping.py

@@ -140,7 +140,11 @@ class StatisticSubjectMapping(GetExternalSource):
                 SecondarySubject(
                     self._extract_titles(s.titler),
                     s["emnekode"],
-                    [statistikk["kortnavn"] for statistikk in s.find_all("Statistikk")],
+                    [
+                        statistikk["kortnavn"]
+                        for statistikk in s.find_all("Statistikk")
+                        if statistikk["isPrimaerPlassering"] == "true"
+                    ],
                 )
                 for s in p.find_all("delemne")
             ]

dapla_metadata/datasets/utility/constants.py

@@ -1,7 +1,7 @@
 """Repository for constant values in Datadoc backend."""
 
-from datadoc_model.model import LanguageStringType
-from datadoc_model.model import LanguageStringTypeItem
+from datadoc_model.all_optional.model import LanguageStringType
+from datadoc_model.all_optional.model import LanguageStringTypeItem
 
 VALIDATION_ERROR = "Validation error: "
 

dapla_metadata/datasets/utility/utils.py

@@ -4,15 +4,19 @@ import datetime  # import is needed in xdoctest
 import logging
 import pathlib
 import uuid
+from typing import cast
 
+import datadoc_model
+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 datadoc_model import model
-from datadoc_model.model import Assessment
-from datadoc_model.model import DataSetState
-from datadoc_model.model import VariableRole
+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 (
@@ -34,6 +38,17 @@ from dapla_metadata.datasets.utility.constants import (
 
 logger = logging.getLogger(__name__)
 
+DatadocMetadataType = (
+    all_optional_model.DatadocMetadata | required_model.DatadocMetadata
+)
+DatasetType = all_optional_model.Dataset | required_model.Dataset
+OptionalDatadocMetadataType = DatadocMetadataType | None
+ExistingPseudonymizationMetadataType = (
+    all_optional_model.PseudonymizationMetadata
+    | required_model.PseudonymizationMetadata
+    | None
+)
+
 
 def get_timestamp_now() -> datetime.datetime:
     """Return a timestamp for the current moment."""
@@ -119,7 +134,9 @@ def set_default_values_variables(variables: list) -> 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:
@@ -140,7 +157,9 @@ def set_default_values_dataset(dataset: model.Dataset) -> None:
         dataset.contains_personal_data = False
 
 
-def set_dataset_owner(dataset: model.Dataset) -> None:
+def set_dataset_owner(
+    dataset: DatasetType,
+) -> None:
     """Sets the owner of the dataset from the DAPLA_GROUP_CONTEXT enviornment variable.
 
     Args:
@@ -153,7 +172,7 @@ def set_dataset_owner(dataset: model.Dataset) -> None:
 
 
 def set_variables_inherit_from_dataset(
-    dataset: model.Dataset,
+    dataset: DatasetType,
     variables: list,
 ) -> None:
     """Set specific dataset values on a list of variable objects.
@@ -283,7 +302,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
@@ -345,7 +366,9 @@ 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 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
@@ -422,8 +445,9 @@ def running_in_notebook() -> bool:
 
 
 def override_dataset_fields(
-    merged_metadata: model.DatadocMetadata,
-    existing_metadata: model.DatadocMetadata,
+    merged_metadata: all_optional_model.DatadocMetadata,
+    existing_metadata: all_optional_model.DatadocMetadata
+    | required_model.DatadocMetadata,
 ) -> None:
     """Overrides specific fields in the dataset of `merged_metadata` with values from the dataset of `existing_metadata`.
 
@@ -449,10 +473,10 @@ def override_dataset_fields(
 
 
 def merge_variables(
-    existing_metadata: model.DatadocMetadata,
-    extracted_metadata: model.DatadocMetadata,
-    merged_metadata: model.DatadocMetadata,
-) -> model.DatadocMetadata:
+    existing_metadata: OptionalDatadocMetadataType,
+    extracted_metadata: all_optional_model.DatadocMetadata,
+    merged_metadata: all_optional_model.DatadocMetadata,
+) -> all_optional_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`.
@@ -466,11 +490,12 @@ def merge_variables(
         merged_metadata: The metadata object that will contain the result of the merge.
 
     Returns:
-        model.DatadocMetadata: The `merged_metadata` object containing variables from both `existing_metadata`
+        all_optional_model.DatadocMetadata: The `merged_metadata` object containing variables from both `existing_metadata`
         and `extracted_metadata`.
     """
     if (
-        existing_metadata.variables is not None
+        existing_metadata is not None
+        and 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
@@ -494,7 +519,9 @@ def merge_variables(
                 existing.contains_data_until = (
                     extracted.contains_data_until or existing.contains_data_until
                 )
-                merged_metadata.variables.append(existing)
+                merged_metadata.variables.append(
+                    cast("datadoc_model.all_optional.model.Variable", existing)
+                )
             else:
                 # If there is no existing metadata for this variable, we just use what we have extracted
                 merged_metadata.variables.append(extracted)

{dapla_toolbelt_metadata-0.6.6.dist-info → dapla_toolbelt_metadata-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dapla-toolbelt-metadata
-Version: 0.6.6
+Version: 0.7.1
 Summary: Dapla Toolbelt Metadata
 License: MIT
 Author: Team Metadata
@@ -24,7 +24,7 @@ Requires-Dist: pyjwt (>=2.8.0)
 Requires-Dist: python-dotenv (>=1.0.1)
 Requires-Dist: requests (>=2.31.0)
 Requires-Dist: ruamel-yaml (>=0.18.10)
-Requires-Dist: ssb-datadoc-model (==6.0.0)
+Requires-Dist: ssb-datadoc-model (==6.1.0)
 Requires-Dist: ssb-klass-python (>=1.0.1)
 Requires-Dist: typing-extensions (>=4.12.2)
 Project-URL: Changelog, https://github.com/statisticsnorway/dapla-toolbelt-metadata/releases

{dapla_toolbelt_metadata-0.6.6.dist-info → dapla_toolbelt_metadata-0.7.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dapla_metadata/__init__.py,sha256=LI-qV1Vq1nKw8KkO0uppNwjOoXwd8niQFCx9jECn6Aw,415
+dapla_metadata/__init__.py,sha256=37yh9XWYQoLIVIS_fDdwNN8OXzbYY-6kMYwvjQrLMJQ,428
 dapla_metadata/_shared/__init__.py,sha256=qUFgnVhBVlPRQP0ePmY76c8FvWRrJ-9c5GvzibwERnQ,103
 dapla_metadata/_shared/config.py,sha256=QqXcmP66AfXF8wi6FMsa7et7kH2k4EJPOF4IELKuQig,3213
 dapla_metadata/_shared/enums.py,sha256=WHkH1d8xw41gOly6au_izZB1_-6XTcKu5rhBWUImjp8,509
@@ -7,19 +7,19 @@ dapla_metadata/dapla/__init__.py,sha256=tkapF-YwmruPPrKvN3pEoCZqb7xvJx_ogBM8XyGM
 dapla_metadata/dapla/user_info.py,sha256=bENez-ICt9ySR8orYebO68Q3_2LkIW9QTL58DTctmEQ,4833
 dapla_metadata/datasets/__init__.py,sha256=TvzskpdFC6hGcC9_55URT5jr5wNAPzXuISd2UjJWM_8,280
 dapla_metadata/datasets/code_list.py,sha256=kp1O6sUiUAP9WKlWY8IgHWx_1IOzJA63WveHqolgKmg,9082
-dapla_metadata/datasets/core.py,sha256=Q6-sEcI2gNht5uIyM6Y4w99TQfSyGfA2mMyvsJfXe_8,26064
-dapla_metadata/datasets/dapla_dataset_path_info.py,sha256=zdkVjxlqXMBe7eTAneUrTDP0_fx7JsEQ_0JrKjREhfU,26854
-dapla_metadata/datasets/dataset_parser.py,sha256=bc3KOIDQGgdZMPh3XVHhiKMsY6FxIY9glvGlwTM4g7I,8233
+dapla_metadata/datasets/core.py,sha256=4fB9q_pUDmFfBN9RDjhUg1ney66juL1B_bDgtwijTwM,29329
+dapla_metadata/datasets/dapla_dataset_path_info.py,sha256=WPeV_mwKk2B9sXd14SaP-kTb1bOQ_8W2KtrqOG7sJIY,26867
+dapla_metadata/datasets/dataset_parser.py,sha256=3dtRXNy1C8SfG8zTYWdY26nV4l-dG25IC_0J5t2bYwI,8285
 dapla_metadata/datasets/external_sources/__init__.py,sha256=qvIdXwqyEmXNUCB94ZtZXRzifdW4hiXASFFPtC70f6E,83
 dapla_metadata/datasets/external_sources/external_sources.py,sha256=9eIcOIUbaodNX1w9Tj2wl4U4wUmr5kF1R0i01fKUzGs,2974
 dapla_metadata/datasets/model_backwards_compatibility.py,sha256=RKhi6cjqmPKW8lTYQ0mIXTAwhMGo_X-QMad4Y5tvq_0,19136
 dapla_metadata/datasets/model_validation.py,sha256=pGT-jqaQQY4z7jz-7UQd0BQoTWDxDWPYAnDoRC2vd_c,6818
 dapla_metadata/datasets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dapla_metadata/datasets/statistic_subject_mapping.py,sha256=QdC22DUBOdRgsfmTTEUr9CKCE8fKjMq6-Ezdr6Eof_A,6254
+dapla_metadata/datasets/statistic_subject_mapping.py,sha256=ovT-bZv6eGPD3L0UIs5nIw4AjJrfZn0hyWyD72JBmhs,6395
 dapla_metadata/datasets/utility/__init__.py,sha256=pp6tUcgUbo8iq9OPtFKQrTbLuI3uY7NHptwWSTpasOU,33
-dapla_metadata/datasets/utility/constants.py,sha256=SqZMc1v8rO2b_nRFJR7frVd0TAGvvxzIPEIzkqOuBSw,2444
+dapla_metadata/datasets/utility/constants.py,sha256=YEs2ECLNJMM1SSORPTDnzNep_Qut5YbJ5JJx_oP3ios,2470
 dapla_metadata/datasets/utility/enums.py,sha256=SpV4xlmP1YMaJPbmX03hqRLHUOhXIk5gquTeJ8G_5OE,432
-dapla_metadata/datasets/utility/utils.py,sha256=fAevz9X0PHw-JL0_4V0geTkoBV31qoO7-dVLFJaIfbo,18370
+dapla_metadata/datasets/utility/utils.py,sha256=JpJuvYEXmNUXTgaxPhUg24aiiZS201wRNnAOWyH_DO0,19210
 dapla_metadata/standards/__init__.py,sha256=n8jnMrudLuScSdfQ4UMJorc-Ptg3Y1-ilT8zAaQnM70,179
 dapla_metadata/standards/name_validator.py,sha256=6-DQE_EKVd6UjL--EXpFcZDQtusVbSFaWaUY-CfOV2c,9184
 dapla_metadata/standards/standard_validators.py,sha256=tcCiCI76wUVtMzXA2oCgdauZc0uGgUi11FKu-t7KGwQ,3767
@@ -81,7 +81,7 @@ dapla_metadata/variable_definitions/_utils/variable_definition_files.py,sha256=P
 dapla_metadata/variable_definitions/exceptions.py,sha256=z6Gtd84FboDu7vWjC3wathIF7I0gF0imtRhwMkr16lY,7851
 dapla_metadata/variable_definitions/vardef.py,sha256=KYd31nCGhxuzC0hpKR6foQjO39Tlb3vu9IDqUoMvTeY,11352
 dapla_metadata/variable_definitions/variable_definition.py,sha256=sj49uot0e4UJW4QJ3dEJGgjY4yfCHOkxS2NdD2t60b8,14883
-dapla_toolbelt_metadata-0.6.6.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
-dapla_toolbelt_metadata-0.6.6.dist-info/METADATA,sha256=o2piO1Eg_WDfqRBTRCj4sCQNbb7ipN09IIrytccqzjI,4905
-dapla_toolbelt_metadata-0.6.6.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-dapla_toolbelt_metadata-0.6.6.dist-info/RECORD,,
+dapla_toolbelt_metadata-0.7.1.dist-info/LICENSE,sha256=np3IfD5m0ZUofn_kVzDZqliozuiO6wrktw3LRPjyEiI,1073
+dapla_toolbelt_metadata-0.7.1.dist-info/METADATA,sha256=-fHBhP0AR_dZpEO98V4CFS97b3maRScHuO8NxzmWc8M,4905
+dapla_toolbelt_metadata-0.7.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+dapla_toolbelt_metadata-0.7.1.dist-info/RECORD,,