dapla-toolbelt-metadata 0.6.5__tar.gz → 0.7.0__tar.gz

{dapla_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dapla-toolbelt-metadata
-Version: 0.6.5
+Version: 0.7.0
 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.5 → dapla_toolbelt_metadata-0.7.0}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "dapla-toolbelt-metadata"
 description = "Dapla Toolbelt Metadata"
 license = "MIT"
-version = "0.6.5"
+version = "0.7.0"
 dynamic = ["classifiers"]
 readme = "README.md"
 authors = [{ name = "Team Metadata", email = "metadata@ssb.no" }]
@@ -17,7 +17,7 @@ dependencies = [
     'cloudpathlib[gs] >=0.17.0',
     'pyjwt >=2.8.0',
     'ssb-klass-python >=1.0.1',
-    'ssb-datadoc-model ==6.0.0',
+    'ssb-datadoc-model ==6.1.0',
     'typing-extensions >=4.12.2',
     'ruamel-yaml >=0.18.10',
     'google-auth >=2.38.0',
@@ -112,19 +112,7 @@ disable_error_code = ["unreachable"]
 
 [[tool.mypy.overrides]]
 # Allow missing type hints in third-party libraries without type information.
-module = [
-    "nox",
-    "dapla",
-    "gcsfs",
-    "pyarrow",
-    "pyarrow.parquet",
-    "datadoc_model",
-    "datadoc_model.model",
-    "pytest_mock",
-    "testcontainers.*",
-    "httpx",
-    "ruamel.*",
-]
+module = ["nox", "dapla", "gcsfs", "pyarrow", "pyarrow.parquet", "pytest_mock", "testcontainers.*", "httpx", "ruamel.*"]
 ignore_missing_imports = true
 
 # Disable specific error codes in the 'tests' package

{dapla_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/src/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_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/src/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,11 +176,26 @@ 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 extracted_metadata is not None:
+            existing_file_path = self._get_existing_file_path(extracted_metadata)
+            if (
+                self.dataset_path
+                and existing_file_path is not None
+                and extracted_metadata is not None
+                and existing_metadata is not None
+            ):
+                self.dataset_consistency_status = self._check_dataset_consistency(
+                    self.dataset_path,
+                    Path(existing_file_path),
+                    extracted_metadata,
+                    existing_metadata,
+                )
+
         if (
             self.dataset_path
             and self.explicitly_defined_metadata_document
@@ -179,13 +204,6 @@ 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.dataset_consistency_status = self._check_dataset_consistency(
-                self.dataset_path,
-                Path(existing_file_path),
-                extracted_metadata,
-                existing_metadata,
-            )
             self._check_ready_to_merge(
                 self.dataset_consistency_status,
                 errors_as_warnings=self.errors_as_warnings,
@@ -207,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
@@ -227,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
@@ -247,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 = {
@@ -264,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.
 
@@ -312,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 []]
                 ),
             },
@@ -353,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.
@@ -387,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
@@ -402,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:
@@ -412,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"]
@@ -420,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:
@@ -435,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.
@@ -445,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)
@@ -464,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),
         )
 
@@ -500,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.
@@ -520,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,
@@ -586,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)
@@ -623,12 +667,14 @@ class Datadoc:
     def add_pseudo_variable(self, variable_short_name: str) -> None:
         """Adds a new pseudo variable to the list of pseudonymized variables."""
         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
 
     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_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/src/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_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/src/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_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/src/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_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/src/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_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/src/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.5 → dapla_toolbelt_metadata-0.7.0}/src/dapla_metadata/variable_definitions/_utils/config.py

@@ -9,24 +9,6 @@ from dapla_metadata.variable_definitions._generated.vardef_client.configuration
 
 VARDEF_HOST_TEST = "https://metadata.intern.test.ssb.no"
 WORKSPACE_DIR = "WORKSPACE_DIR"
-VARDEF_DESCRIPTIONS_FILE_PATH = "VARDEF_DESCRIPTIONS_FILE_PATH"
-VARDEF_DEFAULT_DESCRIPTION_PATH = (
-    "variable_definitions/resources/vardef_model_descriptions_nb.yaml"
-)
-
-
-def get_descriptions_path() -> str:
-    """Get the relative file path from the repo root to the Norwegian descriptions.
-
-    First checks the `VARDEF_DESCRIPTIONS_FILE_PATH` environment variable; if not set, returns a default path.
-
-    Returns:
-        str: The file path to the descriptions.
-    """
-    return (
-        get_config_item(VARDEF_DESCRIPTIONS_FILE_PATH)
-        or VARDEF_DEFAULT_DESCRIPTION_PATH
-    )
 
 
 def get_workspace_dir() -> str | None:

{dapla_toolbelt_metadata-0.6.5 → dapla_toolbelt_metadata-0.7.0}/src/dapla_metadata/variable_definitions/_utils/constants.py

@@ -24,8 +24,6 @@ TEMPLATE_SECTION_HEADER_MACHINE_GENERATED_EN = (
     "\n--- Machine generated fields. Do not edit ---\n"
 )
 
-NORWEGIAN_DESCRIPTIONS = "norwegian_description"
-
 DEFAULT_DATE = date(1000, 1, 1)
 
 MACHINE_GENERATED_FIELDS = [