dapla-toolbelt-metadata 0.8.1__tar.gz → 0.8.3__tar.gz

{dapla_toolbelt_metadata-0.8.1 → dapla_toolbelt_metadata-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dapla-toolbelt-metadata
-Version: 0.8.1
+Version: 0.8.3
 Summary: Dapla Toolbelt Metadata
 License: MIT
 Author: Team Metadata

{dapla_toolbelt_metadata-0.8.1 → dapla_toolbelt_metadata-0.8.3}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "dapla-toolbelt-metadata"
 description = "Dapla Toolbelt Metadata"
 license = "MIT"
-version = "0.8.1"
+version = "0.8.3"
 dynamic = ["classifiers"]
 readme = "README.md"
 authors = [{ name = "Team Metadata", email = "metadata@ssb.no" }]

{dapla_toolbelt_metadata-0.8.1 → dapla_toolbelt_metadata-0.8.3}/src/dapla_metadata/datasets/core.py

@@ -517,6 +517,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.
 

{dapla_toolbelt_metadata-0.8.1 → dapla_toolbelt_metadata-0.8.3}/src/dapla_metadata/variable_definitions/_utils/constants.py

@@ -60,3 +60,7 @@ DOUBLE_QUOTE_FIELDS = [
     "id",
     "last_updated_by",
 ]
+
+PUBLISHING_BLOCKED_ERROR_MESSAGE = "Publishing blocked: Publishing variable definitions is not allowed until further notice."
+VARDEF_PROD_URL = "https://metadata.intern.ssb.no"
+VARDEF_TEST_URL = "https://metadata.intern.test.ssb.no"

{dapla_toolbelt_metadata-0.8.1 → dapla_toolbelt_metadata-0.8.3}/src/dapla_metadata/variable_definitions/exceptions.py

@@ -15,6 +15,14 @@ from dapla_metadata.variable_definitions._generated.vardef_client.exceptions imp
 from dapla_metadata.variable_definitions._generated.vardef_client.exceptions import (
     UnauthorizedException,
 )
+from dapla_metadata.variable_definitions._generated.vardef_client.models.variable_status import (
+    VariableStatus,
+)
+from dapla_metadata.variable_definitions._utils._client import VardefClient
+from dapla_metadata.variable_definitions._utils.constants import (
+    PUBLISHING_BLOCKED_ERROR_MESSAGE,
+)
+from dapla_metadata.variable_definitions._utils.constants import VARDEF_PROD_URL
 
 # Use MappingProxyType so the dict is immutable
 STATUS_EXPLANATIONS: MappingProxyType[HTTPStatus | None, str] = MappingProxyType(
@@ -194,3 +202,54 @@ def vardef_file_error_handler(method):  # noqa: ANN201, ANN001
             raise VardefFileError(msg) from e
 
     return _impl
+
+
+class PublishingBlockedError(RuntimeError):
+    """Exception raised when publishing variable definitions is blocked in the production environment."""
+
+    default_message = PUBLISHING_BLOCKED_ERROR_MESSAGE
+
+    def __str__(self) -> str:
+        """Return the default publishing blocked error message."""
+        return self.default_message
+
+
+def publishing_blocked_error_handler(method):  # noqa: ANN201, ANN001
+    """Decorator that blocks publishing variable definitions in production.
+
+    - If the environment is production:
+        - If `variable_status` is present in the arguments and set to `PUBLISHED_INTERNAL` or `PUBLISHED_EXTERNAL`,
+        publishing is blocked by raising a `PublishingBlockedError`.
+        - If `variable_status` is set to `DRAFT`, the method is allowed to proceed.
+        - If no arguments are provided, all publishing attempts are blocked.
+    """
+
+    @wraps(method)
+    def _impl(*method_args, **method_kwargs):  # noqa: ANN002, ANN003
+        try:
+            client = VardefClient()
+            host = client.get_config().host
+        except VardefClientError as e:
+            msg = f"Failed to get VardefClient config: {e}"
+            raise RuntimeError(msg) from e
+
+        if host == VARDEF_PROD_URL:
+            if len(method_args) > 1:
+                status = method_args[1].variable_status
+                if status == VariableStatus.DRAFT:
+                    return method(
+                        *method_args,
+                        **method_kwargs,
+                    )
+                if status in (
+                    VariableStatus.PUBLISHED_INTERNAL,
+                    VariableStatus.PUBLISHED_EXTERNAL,
+                ):
+                    raise PublishingBlockedError
+            raise PublishingBlockedError
+        return method(
+            *method_args,
+            **method_kwargs,
+        )
+
+    return _impl

{dapla_toolbelt_metadata-0.8.1 → dapla_toolbelt_metadata-0.8.3}/src/dapla_metadata/variable_definitions/variable_definition.py

@@ -41,6 +41,9 @@ from dapla_metadata.variable_definitions._utils.variable_definition_files import
 from dapla_metadata.variable_definitions._utils.variable_definition_files import (
     create_variable_yaml,
 )
+from dapla_metadata.variable_definitions.exceptions import (
+    publishing_blocked_error_handler,
+)
 from dapla_metadata.variable_definitions.exceptions import vardef_exception_handler
 from dapla_metadata.variable_definitions.exceptions import vardef_file_error_handler
 
@@ -99,6 +102,7 @@ class VariableDefinition(CompleteResponse):
             )
         ]
 
+    @publishing_blocked_error_handler
     @vardef_exception_handler
     def update_draft(
         self,
@@ -340,6 +344,7 @@ class VariableDefinition(CompleteResponse):
             ),
         )
 
+    @publishing_blocked_error_handler
     def publish_internal(self) -> "VariableDefinition":
         """Publish this variable definition internally."""
         if self.variable_status != VariableStatus.DRAFT.name:
@@ -358,6 +363,7 @@ class VariableDefinition(CompleteResponse):
         )
         return update
 
+    @publishing_blocked_error_handler
     def publish_external(self) -> "VariableDefinition":
         """Publish this variable definition externally."""
         if self.variable_status == VariableStatus.PUBLISHED_EXTERNAL.name: