dapla-toolbelt-metadata 0.4.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

dapla_metadata/__init__.py

@@ -1,6 +1,15 @@
 """Tools and clients for working with the Dapla Metadata system."""
 
+import warnings
+
+warnings.filterwarnings(
+    "ignore",
+    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
 
+from . import dapla
 from . import datasets
+from . import standards
 from . import variable_definitions

dapla_metadata/dapla/__init__.py

@@ -0,0 +1,4 @@
+"""Expose information specific to the Dapla platform."""
+
+from .user_info import DaplaLabUserInfo
+from .user_info import UserInfo

dapla_metadata/{_shared → dapla}/user_info.py

@@ -13,9 +13,6 @@ from dapla_metadata._shared.enums import DaplaService
 logger = logging.getLogger(__name__)
 
 
-PLACEHOLDER_EMAIL_ADDRESS = "default_user@ssb.no"
-
-
 class UserInfo(Protocol):
     """Information about the current user.
 
@@ -27,6 +24,16 @@ class UserInfo(Protocol):
         """Get the short email address."""
         ...
 
+    @property
+    def current_group(self) -> str:
+        """Get the group which the user is currently representing."""
+        ...
+
+    @property
+    def current_team(self) -> str:
+        """Get the team which the user is currently representing."""
+        ...
+
 
 class UnknownUserInfo:
     """Fallback when no implementation is found."""
@@ -36,14 +43,38 @@ class UnknownUserInfo:
         """Unknown email address."""
         return None
 
+    @property
+    def current_group(self) -> str:
+        """Get the group which the user is currently representing."""
+        return ""
+
+    @property
+    def current_team(self) -> str:
+        """Get the team which the user is currently representing."""
+        return ""
+
 
 class TestUserInfo:
     """Information about the current user for local development and testing."""
 
+    PLACEHOLDER_EMAIL_ADDRESS = "default_user@ssb.no"
+    PLACEHOLDER_GROUP = "default-team-developers"
+    PLACEHOLDER_TEAM = "default-team"
+
     @property
     def short_email(self) -> str | None:
         """Get the short email address."""
-        return PLACEHOLDER_EMAIL_ADDRESS
+        return TestUserInfo.PLACEHOLDER_EMAIL_ADDRESS
+
+    @property
+    def current_group(self) -> str | None:
+        """Get the group which the user is currently representing."""
+        return TestUserInfo.PLACEHOLDER_GROUP
+
+    @property
+    def current_team(self) -> str | None:
+        """Get the team which the user is currently representing."""
+        return TestUserInfo.PLACEHOLDER_TEAM
 
 
 class DaplaLabUserInfo:
@@ -65,6 +96,19 @@ class DaplaLabUserInfo:
         )
         return None
 
+    @property
+    def current_group(self) -> str:
+        """Get the group which the user is currently representing."""
+        if group := config.get_dapla_group_context():
+            return group
+        msg = "DAPLA_GROUP_CONTEXT environment variable not found"
+        raise OSError(msg)
+
+    @property
+    def current_team(self) -> str:
+        """Get the team which the user is currently representing."""
+        return parse_team_name(self.current_group)
+
 
 class JupyterHubUserInfo:
     """Information about the current user when running on JupyterHub."""
@@ -74,6 +118,16 @@ class JupyterHubUserInfo:
         """Get the short email address."""
         return config.get_jupyterhub_user()
 
+    @property
+    def current_group(self) -> str:
+        """Get the group which the user is currently representing."""
+        raise NotImplementedError
+
+    @property
+    def current_team(self) -> str:
+        """Get the team which the user is currently representing."""
+        raise NotImplementedError
+
 
 def get_user_info_for_current_platform() -> UserInfo:
     """Return the correct implementation of UserInfo for the current platform."""
@@ -88,28 +142,20 @@ def get_user_info_for_current_platform() -> UserInfo:
         return UnknownUserInfo()
 
 
-def get_owner() -> str:
-    """Returns the owner read from the GROUP_CONTEXT environment variable."""
-    if group := config.get_dapla_group_context():
-        return parse_team_name(group)
-    msg = "DAPLA_GROUP_CONTEXT environment variable not found"
-    raise OSError(msg)
-
-
 def parse_team_name(group: str) -> str:
     """Parses the group to get the current team.
 
-    >>> parse_team_name(dapla-metadata-developers)
-    (dapla-metadata)
+    >>> parse_team_name("dapla-metadata-developers")
+    'dapla-metadata'
 
-    >>> parse_team_name(dapla-metadata-data-admins)
-    (dapla-metadata)
+    >>> parse_team_name("dapla-metadata-data-admins")
+    'dapla-metadata'
 
-    >>> parse_team_name(dapla-metadata)
-    (dapla)
+    >>> parse_team_name("dapla-metadata")
+    'dapla'
 
-    >>> parse_team_name(dapla-metadata-not-real-name)
-    (dapla-metadata-not-real)
+    >>> parse_team_name("dapla-metadata-not-real-name")
+    'dapla-metadata-not-real'
     """
     parts = group.split("-")
     return "-".join(parts[:-2] if group.endswith("data-admins") else parts[:-1])

dapla_metadata/datasets/code_list.py

@@ -127,7 +127,7 @@ class CodeList(GetExternalSource):
                     .get_codes()
                     .data
                 )
-            except Exception:  # noqa: PERF203
+            except Exception:
                 logger.exception(
                     "Exception while getting classifications from Klass",
                 )

dapla_metadata/datasets/core.py

@@ -14,7 +14,7 @@ from datadoc_model import model
 from datadoc_model.model import DataSetStatus
 
 from dapla_metadata._shared import config
-from dapla_metadata._shared import user_info
+from dapla_metadata.dapla import user_info
 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 (

dapla_metadata/datasets/dapla_dataset_path_info.py

@@ -478,7 +478,7 @@ class DaplaDatasetPathInfo:
         """Extract the bucket name from the dataset path.
 
         Returns:
-            The bucket name or None if the dataset path is not a GCS path.
+            The bucket name or None if the dataset path is not a GCS path nor ssb bucketeer path.
 
         Examples:
             >>> DaplaDatasetPathInfo('gs://ssb-staging-dapla-felles-data-delt/datadoc/utdata/person_data_p2021_v2.parquet').bucket_name
@@ -492,17 +492,35 @@ class DaplaDatasetPathInfo:
 
             >>> DaplaDatasetPathInfo('ssb-staging-dapla-felles-data-delt/datadoc/utdata/person_data_p2021_v2.parquet').bucket_name
             None
+
+            >>> DaplaDatasetPathInfo('ssb-staging-dapla-felles-data-delt/datadoc/utdata/person_data_p2021_v2.parquet').bucket_name
+            None
+
+            >>> DaplaDatasetPathInfo('buckets/ssb-staging-dapla-felles-data-delt/stat/utdata/person_data_p2021_v2.parquet').bucket_name
+            ssb-staging-dapla-felles-data-delt
+
+            >>> DaplaDatasetPathInfo('buckets/ssb-staging-dapla-felles-data-delt/person_data_p2021_v2.parquet').bucket_name
+            ssb-staging-dapla-felles-data-delt
+
+            >>> DaplaDatasetPathInfo('home/work/buckets/ssb-staging-dapla-felles-produkt/stat/utdata/person_data_p2021_v2.parquet').bucket_name
+            ssb-staging-dapla-felles-produkt
         """
         prefix: str | None = None
-        if self.dataset_string.startswith(GSPath.cloud_prefix):
+        dataset_string = str(self.dataset_string)
+        if GSPath.cloud_prefix in self.dataset_string:
             prefix = GSPath.cloud_prefix
-        elif self.dataset_string.startswith(GS_PREFIX_FROM_PATHLIB):
+            _, bucket_and_rest = dataset_string.split(prefix, 1)
+        elif GS_PREFIX_FROM_PATHLIB in self.dataset_string:
             prefix = GS_PREFIX_FROM_PATHLIB
+            _, bucket_and_rest = self.dataset_string.split(prefix, 1)
+        elif "buckets/" in self.dataset_string:
+            prefix = "buckets/"
+            _, bucket_and_rest = self.dataset_string.split(prefix, 1)
         else:
             return None
 
         return pathlib.Path(
-            self.dataset_string.removeprefix(prefix),
+            bucket_and_rest,
         ).parts[0]
 
     @property
@@ -528,6 +546,15 @@ class DaplaDatasetPathInfo:
 
             >>> DaplaDatasetPathInfo('my_data/simple_dataset_name.parquet').dataset_short_name
             simple_dataset_name
+
+            >>> DaplaDatasetPathInfo('gs:/ssb-staging-dapla-felles-data-delt/datadoc/utdata/person_data_p2021_v2.parquet').dataset_short_name
+            person_data
+
+            >>> DaplaDatasetPathInfo('buckets/ssb-staging-dapla-felles-data-delt/stat/utdata/folk_data_p2021_v2.parquet').dataset_short_name
+            folk_data
+
+            >>> DaplaDatasetPathInfo('buckets/ssb-staging-dapla-felles-data-delt/stat/utdata/dapla/bus_p2021_v2.parquet').dataset_short_name
+            bus
         """
         if self.contains_data_from or self.contains_data_until:
             short_name_sections = self.dataset_name_sections[
@@ -601,6 +628,9 @@ class DaplaDatasetPathInfo:
             >>> DaplaDatasetPathInfo('utdata/min_statistikk/person_data_v1.parquet').dataset_state
             <DataSetState.OUTPUT_DATA: 'OUTPUT_DATA'>
 
+            >>> DaplaDatasetPathInfo('buckets/bucket_name/stat_name/inndata/min_statistikk/person_data_v1.parquet').dataset_state
+            <DataSetState.INPUT_DATA: 'INPUT_DATA'>
+
             >>> DaplaDatasetPathInfo('my_special_data/person_data_v1.parquet').dataset_state
             None
         """
@@ -632,6 +662,12 @@ class DaplaDatasetPathInfo:
 
             >>> DaplaDatasetPathInfo('person_data.parquet').dataset_version
             None
+
+            >>> DaplaDatasetPathInfo('buckets/bucket_name/stat_name/inndata/min_statistikk/person_data_v1.parquet').dataset_version
+            '1'
+
+            >>> DaplaDatasetPathInfo('buckets/bucket_name/stat_name/inndata/min_statistikk/person_data.parquet').dataset_version
+            None
         """
         minimum_elements_in_file_name: Final[int] = 2
         minimum_characters_in_version_string: Final[int] = 2
@@ -645,13 +681,37 @@ class DaplaDatasetPathInfo:
                 return last_filename_element[1:]
         return None
 
+    def _get_left_parts(
+        self,
+        dataset_path_parts: list[str],
+        state_index: int,
+    ) -> list[str]:
+        """Retrieve the path parts before the dataset state, considering bucket prefixes."""
+        bucket_prefix = {"gs:", "buckets"}
+        left_parts = dataset_path_parts[:state_index]
+
+        # Stop checking beyond the bucket prefix
+        prefix_intersection = bucket_prefix & set(left_parts)
+        if prefix_intersection:
+            first_prefix = min(
+                left_parts.index(prefix) for prefix in prefix_intersection
+            )
+            left_parts = left_parts[first_prefix:]
+
+        return (
+            []
+            if left_parts == ["/"]
+            or (left_parts[0] in bucket_prefix and len(left_parts) <= 2)
+            else left_parts
+        )
+
     @property
     def statistic_short_name(
         self,
     ) -> str | None:
         """Extract the statistical short name from the filepath.
 
-        Extract the statistical short name from the filepath right before the
+        Extract the statistical short name from the filepath either after bucket name or right before the
         dataset state based on the Dapla filepath naming convention.
 
         Returns:
@@ -662,21 +722,75 @@ class DaplaDatasetPathInfo:
             >>> DaplaDatasetPathInfo('prosjekt/befolkning/klargjorte_data/person_data_v1.parquet').statistic_short_name
             befolkning
 
+            >>> DaplaDatasetPathInfo('buckets/prosjekt/befolkning/person_data_v1.parquet').statistic_short_name
+            befolkning
+
             >>> DaplaDatasetPathInfo('befolkning/inndata/person_data_v1.parquet').statistic_short_name
             befolkning
 
+            >>> DaplaDatasetPathInfo('buckets/bucket_name/stat_name/inndata/min_statistikk/person_data.parquet').statistic_short_name
+            stat_name
+
+            >>> DaplaDatasetPathInfo('buckets/stat_name/utdata/person_data.parquet').statistic_short_name
+            None
+
             >>> DaplaDatasetPathInfo('befolkning/person_data.parquet').statistic_short_name
             None
+
+            >>> DaplaDatasetPathInfo('buckets/produkt/befolkning/utdata/person_data.parquet').statistic_short_name
+            befolkning
+
+            >>> DaplaDatasetPathInfo('resources/buckets/produkt/befolkning/utdata/person_data.parquet').statistic_short_name
+            befolkning
+
+            >>> DaplaDatasetPathInfo('gs://statistikk/produkt/klargjorte-data/persondata_p1990-Q1_p2023-Q4_v1/aar=2019/data.parquet').statistic_short_name
+            produkt
+
+            >>> DaplaDatasetPathInfo('gs://statistikk/produkt/persondata_p1990-Q1_p2023-Q4_v1/aar=2019/data.parquet').statistic_short_name
+            None
+
+            >>> DaplaDatasetPathInfo('buckets/ssb-staging-dapla-felles-data-delt/person_data_p2021_v2.parquet').statistic_short_name
+            None
         """
-        dataset_state = self.dataset_state
-        if dataset_state is not None:
-            dataset_state_names = self._extract_norwegian_dataset_state_path_part(
-                dataset_state,
-            )
-            dataset_path_parts = list(self.dataset_path.parts)
-            for i in dataset_state_names:
-                if i in dataset_path_parts and dataset_path_parts.index(i) != 0:
-                    return dataset_path_parts[dataset_path_parts.index(i) - 1]
+        if not self.dataset_state:
+            if self.bucket_name:
+                parts = self.dataset_path.parent.parts
+
+                if self.bucket_name not in parts:
+                    return None
+
+                # Find the index of bucket_name in the path
+                bucket_name_index = self.dataset_path.parent.parts.index(
+                    self.bucket_name,
+                )
+
+                # If there are parts after bucket_name, return the part immediately after it
+                if len(self.dataset_path.parent.parts) > bucket_name_index + 1:
+                    return self.dataset_path.parent.parts[bucket_name_index + 1]
+
+            return None
+
+        dataset_state_names = self._extract_norwegian_dataset_state_path_part(
+            self.dataset_state,
+        )
+        dataset_path_parts = list(self.dataset_path.parts)
+
+        for state in dataset_state_names:
+            if state not in dataset_path_parts:
+                continue
+
+            index = dataset_path_parts.index(state)
+
+            if index == 0:
+                continue
+
+            left_parts = self._get_left_parts(dataset_path_parts, index)
+
+            if not left_parts:
+                return None
+
+            return dataset_path_parts[index - 1]
+
         return None
 
     def path_complies_with_naming_standard(self) -> bool:

dapla_metadata/datasets/dataset_parser.py

@@ -5,7 +5,7 @@ Handles reading in the data and transforming data types to generic metadata type
 
 from __future__ import annotations
 
-import pathlib  # noqa: TCH003 import is needed for docs build
+import pathlib  # noqa: TC003 import is needed for docs build
 import re
 import typing as t
 from abc import ABC
@@ -89,7 +89,7 @@ TYPE_CORRESPONDENCE: list[tuple[tuple[str, ...], DataType]] = [
 ]
 TYPE_MAP: dict[str, DataType] = {}
 for concrete_type, abstract_type in TYPE_CORRESPONDENCE:
-    TYPE_MAP.update({c: abstract_type for c in concrete_type})
+    TYPE_MAP.update(dict.fromkeys(concrete_type, abstract_type))
 
 TDatasetParser = t.TypeVar("TDatasetParser", bound="DatasetParser")
 
@@ -112,31 +112,23 @@ class DatasetParser(ABC):
     @staticmethod
     def for_file(dataset: pathlib.Path | CloudPath) -> DatasetParser:
         """Return the correct subclass based on the given dataset file."""
-        supported_file_types: dict[
-            str,
-            type[DatasetParser],
-        ] = {
-            ".parquet": DatasetParserParquet,
-            ".sas7bdat": DatasetParserSas7Bdat,
-            ".parquet.gzip": DatasetParserParquet,
-        }
         file_type = "Unknown"
         try:
             file_type = dataset.suffix
             # Gzipped parquet files can be read with DatasetParserParquet
-            match = re.search(r"(.parquet.gzip)", str(dataset).lower())
-            file_type = ".parquet.gzip" if match else file_type
+            match = re.search(PARQUET_GZIP_FILE_SUFFIX, str(dataset).lower())
+            file_type = PARQUET_GZIP_FILE_SUFFIX if match else file_type
             # Extract the appropriate reader class from the SUPPORTED_FILE_TYPES dict and return an instance of it
-            reader = supported_file_types[file_type](dataset)
+            reader = SUPPORTED_DATASET_FILE_SUFFIXES[file_type](dataset)
         except IndexError as e:
             # Thrown when just one element is returned from split, meaning there is no file extension supplied
-            msg = f"Could not recognise file type for provided {dataset = }. Supported file types are: {', '.join(supported_file_types.keys())}"
+            msg = f"Could not recognise file type for provided {dataset = }. Supported file types are: {', '.join(SUPPORTED_DATASET_FILE_SUFFIXES.keys())}"
             raise FileNotFoundError(
                 msg,
             ) from e
         except KeyError as e:
             # In this case the file type is not supported, so we throw a helpful exception
-            msg = f"{file_type = } is not supported. Please open one of the following supported files types: {', '.join(supported_file_types.keys())} or contact the maintainers to request support."
+            msg = f"{file_type = } is not supported. Please open one of the following supported files types: {', '.join(SUPPORTED_DATASET_FILE_SUFFIXES.keys())} or contact the maintainers to request support."
             raise NotImplementedError(
                 msg,
             ) from e
@@ -239,3 +231,17 @@ class DatasetParserSas7Bdat(DatasetParser):
             )
 
         return fields
+
+
+PARQUET_FILE_SUFFIX = ".parquet"
+PARQUET_GZIP_FILE_SUFFIX = ".parquet.gzip"
+SAS7BDAT_FILE_SUFFIX = ".sas7bdat"
+
+SUPPORTED_DATASET_FILE_SUFFIXES: dict[
+    str,
+    type[DatasetParser],
+] = {
+    PARQUET_FILE_SUFFIX: DatasetParserParquet,
+    PARQUET_GZIP_FILE_SUFFIX: DatasetParserParquet,
+    SAS7BDAT_FILE_SUFFIX: DatasetParserSas7Bdat,
+}

dapla_metadata/datasets/model_backwards_compatibility.py

@@ -15,8 +15,8 @@ from __future__ import annotations
 
 from collections import OrderedDict
 from dataclasses import dataclass
+from datetime import UTC
 from datetime import datetime
-from datetime import timezone
 from typing import TYPE_CHECKING
 from typing import Any
 
@@ -305,10 +305,10 @@ def handle_version_2_2_0(supplied_metadata: dict[str, Any]) -> dict[str, Any]:
         )
         supplied_metadata["datadoc"]["variables"][i]["special_value"] = None
         supplied_metadata["datadoc"]["variables"][i]["custom_type"] = None
-        supplied_metadata["datadoc"]["variables"][
-            i
-        ] = _find_and_update_language_strings(
-            supplied_metadata["datadoc"]["variables"][i],
+        supplied_metadata["datadoc"]["variables"][i] = (
+            _find_and_update_language_strings(
+                supplied_metadata["datadoc"]["variables"][i],
+            )
         )
     supplied_metadata["datadoc"]["dataset"]["custom_type"] = None
     supplied_metadata["datadoc"]["dataset"] = _find_and_update_language_strings(
@@ -384,7 +384,7 @@ def handle_version_1_0_0(supplied_metadata: dict[str, Any]) -> dict[str, Any]:
         if supplied_metadata["dataset"][field]:
             supplied_metadata["dataset"][field] = datetime.isoformat(
                 datetime.fromisoformat(supplied_metadata["dataset"][field]).astimezone(
-                    tz=timezone.utc,
+                    tz=UTC,
                 ),
                 timespec="seconds",
             )

dapla_metadata/datasets/model_validation.py

@@ -5,11 +5,11 @@ from __future__ import annotations
 import logging
 import warnings
 from typing import TYPE_CHECKING
+from typing import Self
 from typing import TextIO
 
 from datadoc_model import model
 from pydantic import model_validator
-from typing_extensions import Self
 
 from dapla_metadata.datasets.utility.constants import DATE_VALIDATION_MESSAGE
 from dapla_metadata.datasets.utility.constants import NUM_OBLIGATORY_DATASET_FIELDS
@@ -176,7 +176,7 @@ class ObligatoryVariableWarning(UserWarning):
     """Custom warning for checking obligatory metadata for variables."""
 
 
-def custom_warning_handler(  # noqa: PLR0913 remove fields causes incompatible types
+def custom_warning_handler(
     message: Warning | str,
     category: type[Warning],
     filename: str,

dapla_metadata/datasets/utility/constants.py

@@ -87,6 +87,7 @@ DATASET_FIELDS_FROM_EXISTING_METADATA = [
     "use_restriction_date",
     "custom_type",
     "owner",
+    "version_description",
 ]
 
 METADATA_DOCUMENT_FILE_SUFFIX = "__DOC.json"

dapla_metadata/datasets/utility/enums.py

@@ -11,6 +11,6 @@ class SupportedLanguages(str, Enum):
     Reference: https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry
     """
 
-    NORSK_BOKMÅL = "nb"
+    NORSK_BOKMÅL = "nb"  # noqa: PLC2401 the listed problems do not apply in this case
     NORSK_NYNORSK = "nn"
     ENGLISH = "en"

dapla_metadata/datasets/utility/utils.py

@@ -5,16 +5,16 @@ import logging
 import pathlib
 import uuid
 
+import google.auth
 from cloudpathlib import CloudPath
 from cloudpathlib import GSClient
 from cloudpathlib import GSPath
-from dapla import AuthClient
 from datadoc_model import model
 from datadoc_model.model import Assessment
 from datadoc_model.model import DataSetState
 from datadoc_model.model import VariableRole
 
-from dapla_metadata._shared import user_info
+from dapla_metadata.dapla import user_info
 from dapla_metadata.datasets.utility.constants import (
     DATASET_FIELDS_FROM_EXISTING_METADATA,
 )
@@ -37,7 +37,7 @@ logger = logging.getLogger(__name__)
 
 def get_timestamp_now() -> datetime.datetime:
     """Return a timestamp for the current moment."""
-    return datetime.datetime.now(tz=datetime.timezone.utc)
+    return datetime.datetime.now(tz=datetime.UTC)
 
 
 def normalize_path(path: str) -> pathlib.Path | CloudPath:
@@ -52,7 +52,7 @@ def normalize_path(path: str) -> pathlib.Path | CloudPath:
         Pathlib compatible object.
     """
     if path.startswith(GSPath.cloud_prefix):
-        client = GSClient(credentials=AuthClient.fetch_google_credentials())
+        client = GSClient(credentials=google.auth.default()[0])
         return GSPath(path, client=client)
     return pathlib.Path(path)
 
@@ -79,7 +79,7 @@ def derive_assessment_from_state(state: DataSetState) -> Assessment:
     Returns:
         The derived assessment of the dataset.
     """
-    match (state):
+    match state:
         case (
             DataSetState.INPUT_DATA
             | DataSetState.PROCESSED_DATA
@@ -147,7 +147,7 @@ def set_dataset_owner(dataset: model.Dataset) -> None:
         dataset: The dataset object to set default values on.
     """
     try:
-        dataset.owner = user_info.get_owner()
+        dataset.owner = user_info.get_user_info_for_current_platform().current_team
     except OSError:
         logger.exception("Failed to find environment variable DAPLA_GROUP_CONTEXT")
 
@@ -245,10 +245,7 @@ def _is_missing_multilanguage_value(
             len(field_value[0]) > 0
             and not field_value[0]["languageText"]
             and (len(field_value) <= 1 or not field_value[1]["languageText"])
-            and (
-                len(field_value) <= 2  # noqa: PLR2004 approve magic value
-                or not field_value[2]["languageText"]
-            )
+            and (len(field_value) <= 2 or not field_value[2]["languageText"])
         ),
     )
 
@@ -277,8 +274,7 @@ def _is_missing_metadata(
         True if the field doesn't have a value, False otherwise.
     """
     return bool(
-        field_name in obligatory_list
-        and field_value is None
+        (field_name in obligatory_list and field_value is None)
         or _is_missing_multilanguage_value(
             field_name,
             field_value,

dapla_metadata/standards/__init__.py

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