dapla-toolbelt-metadata 0.2.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

dapla_metadata/__init__.py

@@ -3,3 +3,4 @@
 import datadoc_model.model as datadoc_model
 
 from . import datasets
+from . import variable_definitions

dapla_metadata/_shared/__init__.py

@@ -0,0 +1 @@
+"""Utility code intended to be used by multiple packages within this project, but not by end users."""

dapla_metadata/{datasets → _shared}/config.py

@@ -10,11 +10,12 @@ from pprint import pformat
 from dotenv import dotenv_values
 from dotenv import load_dotenv
 
+from dapla_metadata._shared.enums import DaplaEnvironment
+from dapla_metadata._shared.enums import DaplaRegion
+from dapla_metadata._shared.enums import DaplaService
 from dapla_metadata.datasets.utility.constants import (
     DATADOC_STATISTICAL_SUBJECT_SOURCE_URL,
 )
-from dapla_metadata.datasets.utility.enums import DaplaRegion
-from dapla_metadata.datasets.utility.enums import DaplaService
 
 logger = logging.getLogger(__name__)
 
@@ -22,7 +23,10 @@ DOT_ENV_FILE_PATH = Path(__file__).parent.joinpath(".env")
 
 JUPYTERHUB_USER = "JUPYTERHUB_USER"
 DAPLA_REGION = "DAPLA_REGION"
+DAPLA_ENVIRONMENT = "DAPLA_ENVIRONMENT"
 DAPLA_SERVICE = "DAPLA_SERVICE"
+DAPLA_GROUP_CONTEXT = "DAPLA_GROUP_CONTEXT"
+OIDC_TOKEN = "OIDC_TOKEN"  # noqa: S105
 
 env_loaded = False
 
@@ -38,43 +42,70 @@ def _load_dotenv_file() -> None:
         )
 
 
-def _get_config_item(item: str) -> str | None:
-    """Get a config item. Makes sure all access is logged."""
+def get_config_item(item: str, *, raising: bool = False) -> str | None:
+    """Get a config item. Makes sure all access is logged.
+
+    Args:
+        item: The name of the environment variable to obtain.
+        raising: `True` if an exception should be raised when the item isn't present.
+
+    Returns:
+        The set value or `None`
+
+    Raises:
+        OSError: Only if `raising` is True and the item is not found.
+    """
     _load_dotenv_file()
-    value = os.getenv(item)
+    value = os.environ.get(item)
+    if raising and not value:
+        msg = f"Environment variable {item} not defined."
+        raise OSError(msg)
     logger.debug("Config accessed. %s", item)
     return value
 
 
 def get_jupyterhub_user() -> str | None:
     """Get the JupyterHub user name."""
-    return _get_config_item(JUPYTERHUB_USER)
+    return get_config_item(JUPYTERHUB_USER)
 
 
 def get_statistical_subject_source_url() -> str | None:
     """Get the URL to the statistical subject source."""
     return (
-        _get_config_item("DATADOC_STATISTICAL_SUBJECT_SOURCE_URL")
+        get_config_item("DATADOC_STATISTICAL_SUBJECT_SOURCE_URL")
         or DATADOC_STATISTICAL_SUBJECT_SOURCE_URL
     )
 
 
 def get_dapla_region() -> DaplaRegion | None:
     """Get the Dapla region we're running on."""
-    if region := _get_config_item(DAPLA_REGION):
+    if region := get_config_item(DAPLA_REGION):
         return DaplaRegion(region)
 
     return None
 
 
+def get_dapla_environment() -> DaplaEnvironment | None:
+    """Get the Dapla environment we're running on."""
+    if env := get_config_item(DAPLA_ENVIRONMENT):
+        return DaplaEnvironment(env)
+
+    return None
+
+
 def get_dapla_service() -> DaplaService | None:
     """Get the Dapla service we're running on."""
-    if service := _get_config_item(DAPLA_SERVICE):
+    if service := get_config_item(DAPLA_SERVICE):
         return DaplaService(service)
 
     return None
 
 
-def get_oidc_token() -> str | None:
+def get_oidc_token(*, raising: bool = False) -> str | None:
     """Get the JWT token from the environment."""
-    return _get_config_item("OIDC_TOKEN")
+    return get_config_item(OIDC_TOKEN, raising=raising)
+
+
+def get_dapla_group_context(*, raising: bool = False) -> str | None:
+    """Get the group which the user has chosen to represent."""
+    return get_config_item(DAPLA_GROUP_CONTEXT, raising=raising)

dapla_metadata/_shared/enums.py

@@ -0,0 +1,28 @@
+from enum import Enum
+
+
+class DaplaRegion(str, Enum):
+    """Dapla platforms/regions."""
+
+    DAPLA_LAB = "DAPLA_LAB"
+    BIP = "BIP"
+    ON_PREM = "ON_PREM"
+    CLOUD_RUN = "CLOUD_RUN"
+
+
+class DaplaEnvironment(str, Enum):
+    """Dapla lifecycle environment."""
+
+    PROD = "PROD"
+    TEST = "TEST"
+    DEV = "DEV"
+
+
+class DaplaService(str, Enum):
+    """Dapla services."""
+
+    DATADOC = "DATADOC"
+    JUPYTERLAB = "JUPYTERLAB"
+    VS_CODE = "VS_CODE"
+    R_STUDIO = "R_STUDIO"
+    KILDOMATEN = "KILDOMATEN"

dapla_metadata/{datasets → _shared}/user_info.py

@@ -6,9 +6,9 @@ from typing import Protocol
 
 import jwt
 
-from dapla_metadata.datasets import config
-from dapla_metadata.datasets.utility.enums import DaplaRegion
-from dapla_metadata.datasets.utility.enums import DaplaService
+from dapla_metadata._shared import config
+from dapla_metadata._shared.enums import DaplaRegion
+from dapla_metadata._shared.enums import DaplaService
 
 logger = logging.getLogger(__name__)
 
@@ -86,3 +86,30 @@ def get_user_info_for_current_platform() -> UserInfo:
             "Was not possible to retrieve user information! Some fields may not be set.",
         )
         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-data-admins)
+    (dapla-metadata)
+
+    >>> parse_team_name(dapla-metadata)
+    (dapla)
+
+    >>> 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/core.py

@@ -13,8 +13,8 @@ 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 dapla_metadata._shared import config
+from dapla_metadata._shared 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 (
@@ -42,6 +42,7 @@ 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_variables
 
@@ -189,6 +190,7 @@ class Datadoc:
             self._set_metadata(existing_metadata or extracted_metadata)
         set_default_values_variables(self.variables)
         set_default_values_dataset(self.dataset)
+        set_dataset_owner(self.dataset)
         self._create_variables_lookup()
 
     def _get_existing_file_path(

dapla_metadata/datasets/utility/enums.py

@@ -5,25 +5,6 @@ from __future__ import annotations
 from enum import Enum
 
 
-class DaplaRegion(str, Enum):
-    """Dapla platforms/regions."""
-
-    DAPLA_LAB = "DAPLA_LAB"
-    BIP = "BIP"
-    ON_PREM = "ON_PREM"
-    CLOUD_RUN = "CLOUD_RUN"
-
-
-class DaplaService(str, Enum):
-    """Dapla services."""
-
-    DATADOC = "DATADOC"
-    JUPYTERLAB = "JUPYTERLAB"
-    VS_CODE = "VS_CODE"
-    R_STUDIO = "R_STUDIO"
-    KILDOMATEN = "KILDOMATEN"
-
-
 class SupportedLanguages(str, Enum):
     """The list of languages metadata may be recorded in.
 

dapla_metadata/datasets/utility/utils.py

@@ -14,6 +14,7 @@ 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.datasets.utility.constants import (
     DATASET_FIELDS_FROM_EXISTING_METADATA,
 )
@@ -139,6 +140,18 @@ def set_default_values_dataset(dataset: model.Dataset) -> None:
         dataset.contains_personal_data = False
 
 
+def set_dataset_owner(dataset: model.Dataset) -> None:
+    """Sets the owner of the dataset from the DAPLA_GROUP_CONTEXT enviornment variable.
+
+    Args:
+        dataset: The dataset object to set default values on.
+    """
+    try:
+        dataset.owner = user_info.get_owner()
+    except OSError:
+        logger.exception("Failed to find environment variable DAPLA_GROUP_CONTEXT")
+
+
 def set_variables_inherit_from_dataset(
     dataset: model.Dataset,
     variables: list,

dapla_metadata/variable_definitions/__init__.py

@@ -0,0 +1,7 @@
+"""Client for working with Variable Definitions at Statistics Norway."""
+
+from .generated.vardef_client import models
+from .generated.vardef_client.exceptions import *  # noqa: F403
+from .vardef import Vardef
+from .variable_definition import CompletePatchOutput
+from .variable_definition import VariableDefinition

dapla_metadata/variable_definitions/_client.py

@@ -0,0 +1,30 @@
+from dapla_metadata.variable_definitions.config import get_vardef_client_configuration
+from dapla_metadata.variable_definitions.generated.vardef_client.api_client import (
+    ApiClient,
+)
+from dapla_metadata.variable_definitions.generated.vardef_client.configuration import (
+    Configuration,
+)
+
+
+class VardefClient:
+    _client: ApiClient | None = None
+    _config: Configuration | None = None
+
+    @classmethod
+    def get_config(cls) -> Configuration | None:
+        """Get the client configuration object."""
+        return cls._config
+
+    @classmethod
+    def set_config(cls, config: Configuration) -> None:
+        """Set the client configuration object."""
+        cls._config = config
+
+    @classmethod
+    def get_client(cls) -> ApiClient:
+        if not cls._client:
+            if not cls._config:
+                cls._config = get_vardef_client_configuration()
+            cls._client = ApiClient(cls._config)
+        return cls._client

dapla_metadata/variable_definitions/config.py

@@ -0,0 +1,49 @@
+from dapla_metadata._shared.config import get_config_item
+from dapla_metadata._shared.config import get_dapla_environment
+from dapla_metadata._shared.config import get_dapla_group_context
+from dapla_metadata._shared.config import get_oidc_token
+from dapla_metadata._shared.enums import DaplaEnvironment
+from dapla_metadata.variable_definitions.generated.vardef_client.configuration import (
+    Configuration,
+)
+
+VARDEF_HOST_TEST = "https://metadata.intern.test.ssb.no"
+
+
+def get_active_group() -> str:
+    """Get the group the user currently represents.
+
+    Returns:
+        A string with the active group.
+    """
+    return str(get_dapla_group_context(raising=True))
+
+
+def get_vardef_host() -> str:
+    """Get the host for the server to make requests to.
+
+    Based on standard Dapla platform environment variables, or variables specific
+    to Vardef if these are not available.
+
+    Raises:
+        NotImplementedError: When Vardef is not available for the current environment.
+    """
+    match get_dapla_environment():
+        case DaplaEnvironment.PROD:
+            msg = "Vardef is not available in prod."
+            raise NotImplementedError(msg)
+        case DaplaEnvironment.TEST:
+            return VARDEF_HOST_TEST
+        case DaplaEnvironment.DEV:
+            msg = "Vardef is not available in dev."
+            raise NotImplementedError(msg)
+        case _:
+            return get_config_item("VARDEF_HOST") or "http://localhost:8080"
+
+
+def get_vardef_client_configuration() -> Configuration:
+    """Build a config to be supplied to the `ApiClient`."""
+    return Configuration(
+        host=get_vardef_host(),
+        access_token=get_oidc_token(raising=True),
+    )

dapla_metadata/variable_definitions/exceptions.py

@@ -0,0 +1,66 @@
+"""Vardef client exceptions."""
+
+import json
+from functools import wraps
+
+from dapla_metadata.variable_definitions.generated.vardef_client.exceptions import (
+    OpenApiException,
+)
+
+
+class VardefClientException(OpenApiException):
+    """Custom exception to represent errors encountered in the Vardef client.
+
+    This exception extracts and formats error details from a JSON response body
+    provided by the Vardef API, enabling more descriptive error messages.
+    If the response body cannot be parsed as JSON or lacks expected keys,
+    default values are used to provide meaningful feedback.
+    """
+
+    def __init__(self, response_body: str) -> None:
+        """Initialize the exception with a JSON-formatted response body.
+
+        Args:
+            response_body (str): The JSON string containing error details
+                                from the Vardef API response.
+
+        Attributes:
+            status (str): The status code from the response, or "Unknown status"
+                        if not available or the response is invalid.
+            detail (str || list): A detailed error message from the response, or
+                        "No detail provided" if not provided. If "Constraint violation"
+                        detail contains 'field' and 'message'.
+            response_body (str): The raw response body string, stored for
+                                debugging purposes.
+        """
+        try:
+            data = json.loads(response_body)
+            self.status = data.get("status", "Unknown status")
+            if data.get("title") == "Constraint Violation":
+                violations = data.get("violations", [])
+                self.detail = "".join(
+                    f"\n{violation.get('field', 'Unknown field')}: {violation.get('message', 'No message provided')}"
+                    for violation in violations
+                )
+
+            else:
+                self.detail = data.get("detail", "No detail provided")
+            self.response_body = response_body
+        except (json.JSONDecodeError, TypeError):
+            self.status = "Unknown"
+            self.detail = "Could not decode error response from API"
+            data = None
+        super().__init__(f"Status {self.status}: {self.detail}")
+
+
+def vardef_exception_handler(method):  # noqa: ANN201, ANN001
+    """Decorator for handling exceptions in Vardef."""
+
+    @wraps(method)
+    def _impl(self, *method_args, **method_kwargs):  # noqa: ANN001, ANN002, ANN003
+        try:
+            return method(self, *method_args, **method_kwargs)
+        except OpenApiException as e:
+            raise VardefClientException(e.body) from e
+
+    return _impl

dapla_metadata/variable_definitions/generated/.openapi-generator/FILES

@@ -0,0 +1,22 @@
+vardef_client/api/__init__.py
+vardef_client/api/data_migration_api.py
+vardef_client/api/draft_variable_definitions_api.py
+vardef_client/api/patches_api.py
+vardef_client/api/public_api.py
+vardef_client/api/validity_periods_api.py
+vardef_client/api/variable_definitions_api.py
+vardef_client/models/__init__.py
+vardef_client/models/complete_response.py
+vardef_client/models/contact.py
+vardef_client/models/draft.py
+vardef_client/models/klass_reference.py
+vardef_client/models/language_string_type.py
+vardef_client/models/owner.py
+vardef_client/models/patch.py
+vardef_client/models/problem.py
+vardef_client/models/rendered_contact.py
+vardef_client/models/rendered_variable_definition.py
+vardef_client/models/supported_languages.py
+vardef_client/models/update_draft.py
+vardef_client/models/validity_period.py
+vardef_client/models/variable_status.py

dapla_metadata/variable_definitions/generated/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.9.0

dapla_metadata/variable_definitions/generated/.openapi-generator-ignore

@@ -0,0 +1,6 @@
+# Ignore everything to make sure we don't get extra cruft
+**
+# Unignore the directories with domain code
+!vardef_client/api/
+!vardef_client/docs/
+!vardef_client/models/

dapla_metadata/variable_definitions/generated/README.md

@@ -0,0 +1,148 @@
+# vardef-client
+
+No description provided (generated by Openapi Generator <https://github.com/openapitools/openapi-generator>)
+
+This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project:
+
+- API version: 0.1
+- Package version: 1.0.0
+- Generator version: 7.9.0
+- Build package: org.openapitools.codegen.languages.PythonClientCodegen
+
+## Requirements
+
+Python 3.7+
+
+## Installation & Usage
+
+### pip install
+
+If the python package is hosted on a repository, you can install directly using:
+
+```sh
+pip install git+https://github.com/statisticsnorway/dapla-toolbelt-metadata.git
+```
+
+(you may need to run `pip` with root permission: `sudo pip install git+https://github.com/statisticsnorway/dapla-toolbelt-metadata.git`)
+
+Then import the package:
+
+```python
+import vardef_client
+```
+
+### Setuptools
+
+Install via [Setuptools](http://pypi.python.org/pypi/setuptools).
+
+```sh
+python setup.py install --user
+```
+
+(or `sudo python setup.py install` to install the package for all users)
+
+Then import the package:
+
+```python
+import vardef_client
+```
+
+### Tests
+
+Execute `pytest` to run the tests.
+
+## Getting Started
+
+Please follow the [installation procedure](#installation--usage) and then run the following:
+
+```python
+
+import vardef_client
+from vardef_client.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://metadata.intern.test.ssb.no
+# See configuration.py for a list of all supported configuration parameters.
+configuration = vardef_client.Configuration(
+    host = "https://metadata.intern.test.ssb.no"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): Keycloak token
+configuration = vardef_client.Configuration(
+    access_token = os.environ["BEARER_TOKEN"]
+)
+
+
+# Enter a context with an instance of the API client
+with vardef_client.ApiClient(configuration) as api_client:
+    # Create an instance of the API class
+    api_instance = vardef_client.DataMigrationApi(api_client)
+    vardok_id = '1607' # str | The ID of the definition in Vardok.
+    active_group = 'dapla-felles-developers' # str | The group which the user currently represents.
+
+    try:
+        # Create a variable definition from a VarDok variable definition.
+        api_response = api_instance.create_variable_definition_from_var_dok(vardok_id, active_group)
+        print("The response of DataMigrationApi->create_variable_definition_from_var_dok:\n")
+        pprint(api_response)
+    except ApiException as e:
+        print("Exception when calling DataMigrationApi->create_variable_definition_from_var_dok: %s\n" % e)
+
+```
+
+## Documentation for API Endpoints
+
+All URIs are relative to *<https://metadata.intern.test.ssb.no>*
+
+Class | Method | HTTP request | Description
+------------ | ------------- | ------------- | -------------
+*DataMigrationApi* | [**create_variable_definition_from_var_dok**](vardef_client/docs/DataMigrationApi.md#create_variable_definition_from_var_dok) | **POST** /vardok-migration/{vardok-id} | Create a variable definition from a VarDok variable definition.
+*DraftVariableDefinitionsApi* | [**create_variable_definition**](vardef_client/docs/DraftVariableDefinitionsApi.md#create_variable_definition) | **POST** /variable-definitions | Create a variable definition.
+*DraftVariableDefinitionsApi* | [**delete_variable_definition_by_id**](vardef_client/docs/DraftVariableDefinitionsApi.md#delete_variable_definition_by_id) | **DELETE** /variable-definitions/{variable-definition-id} | Delete a variable definition.
+*DraftVariableDefinitionsApi* | [**update_variable_definition_by_id**](vardef_client/docs/DraftVariableDefinitionsApi.md#update_variable_definition_by_id) | **PATCH** /variable-definitions/{variable-definition-id} | Update a variable definition.
+*PatchesApi* | [**create_patch**](vardef_client/docs/PatchesApi.md#create_patch) | **POST** /variable-definitions/{variable-definition-id}/patches | Create a new patch for a variable definition.
+*PatchesApi* | [**get_all_patches**](vardef_client/docs/PatchesApi.md#get_all_patches) | **GET** /variable-definitions/{variable-definition-id}/patches | List all patches for the given variable definition.
+*PatchesApi* | [**get_one_patch**](vardef_client/docs/PatchesApi.md#get_one_patch) | **GET** /variable-definitions/{variable-definition-id}/patches/{patch-id} | Get one concrete patch for the given variable definition.
+*PublicApi* | [**get_public_variable_definition_by_id**](vardef_client/docs/PublicApi.md#get_public_variable_definition_by_id) | **GET** /public/variable-definitions/{variable-definition-id} | Get one variable definition.
+*PublicApi* | [**list_public_validity_periods**](vardef_client/docs/PublicApi.md#list_public_validity_periods) | **GET** /public/variable-definitions/{variable-definition-id}/validity-periods | List all validity periods.
+*PublicApi* | [**list_public_variable_definitions**](vardef_client/docs/PublicApi.md#list_public_variable_definitions) | **GET** /public/variable-definitions | List all variable definitions.
+*ValidityPeriodsApi* | [**create_validity_period**](vardef_client/docs/ValidityPeriodsApi.md#create_validity_period) | **POST** /variable-definitions/{variable-definition-id}/validity-periods | Create a new validity period for a variable definition.
+*ValidityPeriodsApi* | [**list_public_validity_periods_0**](vardef_client/docs/ValidityPeriodsApi.md#list_public_validity_periods_0) | **GET** /public/variable-definitions/{variable-definition-id}/validity-periods | List all validity periods.
+*ValidityPeriodsApi* | [**list_validity_periods**](vardef_client/docs/ValidityPeriodsApi.md#list_validity_periods) | **GET** /variable-definitions/{variable-definition-id}/validity-periods | List all validity periods.
+*VariableDefinitionsApi* | [**get_public_variable_definition_by_id_0**](vardef_client/docs/VariableDefinitionsApi.md#get_public_variable_definition_by_id_0) | **GET** /public/variable-definitions/{variable-definition-id} | Get one variable definition.
+*VariableDefinitionsApi* | [**get_variable_definition_by_id**](vardef_client/docs/VariableDefinitionsApi.md#get_variable_definition_by_id) | **GET** /variable-definitions/{variable-definition-id} | Get one variable definition.
+*VariableDefinitionsApi* | [**list_public_variable_definitions_0**](vardef_client/docs/VariableDefinitionsApi.md#list_public_variable_definitions_0) | **GET** /public/variable-definitions | List all variable definitions.
+*VariableDefinitionsApi* | [**list_variable_definitions**](vardef_client/docs/VariableDefinitionsApi.md#list_variable_definitions) | **GET** /variable-definitions | List all variable definitions.
+
+## Documentation For Models
+
+- [CompleteResponse](vardef_client/docs/CompleteResponse.md)
+- [Contact](vardef_client/docs/Contact.md)
+- [Draft](vardef_client/docs/Draft.md)
+- [LanguageStringType](vardef_client/docs/LanguageStringType.md)
+- [Owner](vardef_client/docs/Owner.md)
+- [Patch](vardef_client/docs/Patch.md)
+- [SupportedLanguages](vardef_client/docs/SupportedLanguages.md)
+- [UpdateDraft](vardef_client/docs/UpdateDraft.md)
+- [ValidityPeriod](vardef_client/docs/ValidityPeriod.md)
+- [VariableStatus](vardef_client/docs/VariableStatus.md)
+
+<a id="documentation-for-authorization"></a>
+
+## Documentation For Authorization
+
+Authentication schemes defined for the API:
+<a id="Keycloak token"></a>
+
+### Keycloak token
+
+- **Type**: Bearer authentication (JWT)
+
+## Author
+
+<metadata@ssb.no>

dapla_metadata/variable_definitions/generated/vardef_client/__init__.py

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+Variable Definitions
+
+## Introduction  Variable Definitions are centralized definitions of concrete variables which are typically present in multiple datasets. Variable Definitions support standardization of data and metadata and facilitate sharing and joining of data by clarifying when variables have an identical definition.  ## Maintenance of Variable Definitions This API allows for creation, maintenance and access of Variable Definitions.  ### Ownership Creation and maintenance of variables may only be performed by Statistics Norway employees representing a specific Dapla team, who are defined as the owners of a given Variable Definition. The team an owner represents must be specified when making a request through the `active_group` query parameter. All maintenance is to be performed by the owners, with no intervention from administrators.  ### Status All Variable Definitions have an associated status. The possible values for status are `DRAFT`, `PUBLISHED_INTERNAL` and `PUBLISHED_EXTERNAL`.   #### Draft When a Variable Definition is created it is assigned the status `DRAFT`. Under this status the Variable Definition is:  - Only visible to Statistics Norway employees. - Mutable (it may be changed directly without need for versioning). - Not suitable to refer to from other systems.  This status may be changed to `PUBLISHED_INTERNAL` or `PUBLISHED_EXTERNAL` with a direct update.  #### Published Internal Under this status the Variable Definition is:  - Only visible to Statistics Norway employees. - Immutable (all changes are versioned). - Suitable to refer to in internal systems for statistics production. - Not suitable to refer to for external use (for example in Statistikkbanken).  This status may be changed to `PUBLISHED_EXTERNAL` by creating a Patch version.  #### Published External Under this status the Variable Definition is:  - Visible to the general public. - Immutable (all changes are versioned). - Suitable to refer to from any system.  This status may not be changed as it would break immutability. If a Variable Definition is no longer relevant then its period of validity should be ended by specifying a `valid_until` date in a Patch version.  ### Immutability Variable Definitions are immutable. This means that any changes must be performed in a strict versioning system. Consumers can avoid being exposed to breaking changes by specifying a `date_of_validity` when they request a Variable Definition.  #### Patches Patches are for changes which do not affect the fundamental meaning of the Variable Definition.  #### Validity Periods Validity Periods are versions with a period defined by a `valid_from` date and optionally a `valid_until` date. If the fundamental meaning of a Variable Definition is to be changed, it should be done by creating a new Validity Period.
+
+The version of the OpenAPI document: 0.1
+Contact: metadata@ssb.no
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from .api.data_migration_api import DataMigrationApi
+from .api.draft_variable_definitions_api import DraftVariableDefinitionsApi
+from .api.patches_api import PatchesApi
+from .api.public_api import PublicApi
+from .api.validity_periods_api import ValidityPeriodsApi
+from .api.variable_definitions_api import VariableDefinitionsApi
+
+# import ApiClient
+from .api_response import ApiResponse
+from .api_client import ApiClient
+from .configuration import Configuration
+from .exceptions import OpenApiException
+from .exceptions import ApiTypeError
+from .exceptions import ApiValueError
+from .exceptions import ApiKeyError
+from .exceptions import ApiAttributeError
+from .exceptions import ApiException
+
+# import models into sdk package
+from .models.complete_response import CompleteResponse
+from .models.contact import Contact
+from .models.draft import Draft
+from .models.klass_reference import KlassReference
+from .models.language_string_type import LanguageStringType
+from .models.owner import Owner
+from .models.patch import Patch
+from .models.problem import Problem
+from .models.rendered_contact import RenderedContact
+from .models.rendered_variable_definition import RenderedVariableDefinition
+from .models.supported_languages import SupportedLanguages
+from .models.update_draft import UpdateDraft
+from .models.validity_period import ValidityPeriod
+from .models.variable_status import VariableStatus