dapla-toolbelt-metadata 0.2.1__py3-none-any.whl → 0.9.11__py3-none-any.whl

dapla_metadata/variable_definitions/_generated/vardef_client/models/vardok_id_response.py

@@ -0,0 +1,81 @@
+"""Internal Variable Definitions Administration API
+
+## 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.
+"""
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any
+from typing import ClassVar
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from pydantic import StrictStr
+from typing_extensions import Self
+
+
+class VardokIdResponse(BaseModel):
+    """VardokIdResponse"""
+
+    vardok_id: StrictStr
+    __properties: ClassVar[list[str]] = ["vardok_id"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self | None:
+        """Create an instance of VardokIdResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict[str, Any] | None) -> Self | None:
+        """Create an instance of VardokIdResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"vardok_id": obj.get("vardok_id")})
+        return _obj

dapla_metadata/variable_definitions/_generated/vardef_client/models/vardok_vardef_id_pair_response.py

@@ -0,0 +1,84 @@
+"""Internal Variable Definitions Administration API
+
+## 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.
+"""
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any
+from typing import ClassVar
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from pydantic import StrictStr
+from typing_extensions import Self
+
+
+class VardokVardefIdPairResponse(BaseModel):
+    """VardokVardefIdPairResponse"""
+
+    vardok_id: StrictStr
+    vardef_id: StrictStr
+    __properties: ClassVar[list[str]] = ["vardok_id", "vardef_id"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self | None:
+        """Create an instance of VardokVardefIdPairResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict[str, Any] | None) -> Self | None:
+        """Create an instance of VardokVardefIdPairResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {"vardok_id": obj.get("vardok_id"), "vardef_id": obj.get("vardef_id")}
+        )
+        return _obj

dapla_metadata/variable_definitions/_generated/vardef_client/models/variable_status.py

@@ -0,0 +1,33 @@
+"""Internal Variable Definitions Administration API
+
+## 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.
+"""
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+
+from typing_extensions import Self
+
+
+class VariableStatus(str, Enum):
+    """Life cycle status of a variable definition."""
+
+    """
+    allowed enum values
+    """
+    DRAFT = "DRAFT"
+    PUBLISHED_INTERNAL = "PUBLISHED_INTERNAL"
+    PUBLISHED_EXTERNAL = "PUBLISHED_EXTERNAL"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of VariableStatus from a JSON string"""
+        return cls(json.loads(json_str))

dapla_metadata/variable_definitions/_generated/vardef_client/rest.py

@@ -0,0 +1,249 @@
+"""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.
+"""
+
+import io
+import json
+import re
+import ssl
+
+import urllib3
+
+from .exceptions import ApiException
+from .exceptions import ApiValueError
+
+SUPPORTED_SOCKS_PROXIES = {"socks5", "socks5h", "socks4", "socks4a"}
+RESTResponseType = urllib3.HTTPResponse
+
+
+def is_socks_proxy_url(url):
+    if url is None:
+        return False
+    split_section = url.split("://")
+    if len(split_section) < 2:
+        return False
+    return split_section[0].lower() in SUPPORTED_SOCKS_PROXIES
+
+
+class RESTResponse(io.IOBase):
+    def __init__(self, resp) -> None:
+        self.response = resp
+        self.status = resp.status
+        self.reason = resp.reason
+        self.data = None
+
+    def read(self):
+        if self.data is None:
+            self.data = self.response.data
+        return self.data
+
+    def getheaders(self):
+        """Returns a dictionary of the response headers."""
+        return self.response.headers
+
+    def getheader(self, name, default=None):
+        """Returns a given response header."""
+        return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+    def __init__(self, configuration) -> None:
+        # urllib3.PoolManager will pass all kw parameters to connectionpool
+        # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75
+        # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680
+        # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html
+
+        # cert_reqs
+        if configuration.verify_ssl:
+            cert_reqs = ssl.CERT_REQUIRED
+        else:
+            cert_reqs = ssl.CERT_NONE
+
+        pool_args = {
+            "cert_reqs": cert_reqs,
+            "ca_certs": configuration.ssl_ca_cert,
+            "cert_file": configuration.cert_file,
+            "key_file": configuration.key_file,
+        }
+        if configuration.assert_hostname is not None:
+            pool_args["assert_hostname"] = configuration.assert_hostname
+
+        if configuration.retries is not None:
+            pool_args["retries"] = configuration.retries
+
+        if configuration.tls_server_name:
+            pool_args["server_hostname"] = configuration.tls_server_name
+
+        if configuration.socket_options is not None:
+            pool_args["socket_options"] = configuration.socket_options
+
+        if configuration.connection_pool_maxsize is not None:
+            pool_args["maxsize"] = configuration.connection_pool_maxsize
+
+        # https pool manager
+        self.pool_manager: urllib3.PoolManager
+
+        if configuration.proxy:
+            if is_socks_proxy_url(configuration.proxy):
+                from urllib3.contrib.socks import SOCKSProxyManager
+
+                pool_args["proxy_url"] = configuration.proxy
+                pool_args["headers"] = configuration.proxy_headers
+                self.pool_manager = SOCKSProxyManager(**pool_args)
+            else:
+                pool_args["proxy_url"] = configuration.proxy
+                pool_args["proxy_headers"] = configuration.proxy_headers
+                self.pool_manager = urllib3.ProxyManager(**pool_args)
+        else:
+            self.pool_manager = urllib3.PoolManager(**pool_args)
+
+    def request(
+        self,
+        method,
+        url,
+        headers=None,
+        body=None,
+        post_params=None,
+        _request_timeout=None,
+    ):
+        """Perform requests.
+
+        :param method: http request method
+        :param url: http request url
+        :param headers: http request headers
+        :param body: request json body, for `application/json`
+        :param post_params: request post parameters,
+                            `application/x-www-form-urlencoded`
+                            and `multipart/form-data`
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        """
+        method = method.upper()
+        assert method in [
+            "GET",
+            "HEAD",
+            "DELETE",
+            "POST",
+            "PUT",
+            "PATCH",
+            "OPTIONS",
+        ]
+
+        if post_params and body:
+            raise ApiValueError(
+                "body parameter cannot be used with post_params parameter.",
+            )
+
+        post_params = post_params or {}
+        headers = headers or {}
+
+        timeout = None
+        if _request_timeout:
+            if isinstance(_request_timeout, (int, float)):
+                timeout = urllib3.Timeout(total=_request_timeout)
+            elif isinstance(_request_timeout, tuple) and len(_request_timeout) == 2:
+                timeout = urllib3.Timeout(
+                    connect=_request_timeout[0],
+                    read=_request_timeout[1],
+                )
+
+        try:
+            # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+            if method in ["POST", "PUT", "PATCH", "OPTIONS", "DELETE"]:
+                # no content type provided or payload is json
+                content_type = headers.get("Content-Type")
+                if not content_type or re.search("json", content_type, re.IGNORECASE):
+                    request_body = None
+                    if body is not None:
+                        request_body = json.dumps(body)
+                    r = self.pool_manager.request(
+                        method,
+                        url,
+                        body=request_body,
+                        timeout=timeout,
+                        headers=headers,
+                        preload_content=False,
+                    )
+                elif content_type == "application/x-www-form-urlencoded":
+                    r = self.pool_manager.request(
+                        method,
+                        url,
+                        fields=post_params,
+                        encode_multipart=False,
+                        timeout=timeout,
+                        headers=headers,
+                        preload_content=False,
+                    )
+                elif content_type == "multipart/form-data":
+                    # must del headers['Content-Type'], or the correct
+                    # Content-Type which generated by urllib3 will be
+                    # overwritten.
+                    del headers["Content-Type"]
+                    # Ensures that dict objects are serialized
+                    post_params = [
+                        (a, json.dumps(b)) if isinstance(b, dict) else (a, b)
+                        for a, b in post_params
+                    ]
+                    r = self.pool_manager.request(
+                        method,
+                        url,
+                        fields=post_params,
+                        encode_multipart=True,
+                        timeout=timeout,
+                        headers=headers,
+                        preload_content=False,
+                    )
+                # Pass a `string` parameter directly in the body to support
+                # other content types than JSON when `body` argument is
+                # provided in serialized form.
+                elif isinstance(body, str) or isinstance(body, bytes):
+                    r = self.pool_manager.request(
+                        method,
+                        url,
+                        body=body,
+                        timeout=timeout,
+                        headers=headers,
+                        preload_content=False,
+                    )
+                elif headers["Content-Type"].startswith("text/") and isinstance(
+                    body, bool
+                ):
+                    request_body = "true" if body else "false"
+                    r = self.pool_manager.request(
+                        method,
+                        url,
+                        body=request_body,
+                        preload_content=False,
+                        timeout=timeout,
+                        headers=headers,
+                    )
+                else:
+                    # Cannot generate the request from given parameters
+                    msg = """Cannot prepare a request message for provided
+                             arguments. Please check that your arguments match
+                             declared content type."""
+                    raise ApiException(status=0, reason=msg)
+            # For `GET`, `HEAD`
+            else:
+                r = self.pool_manager.request(
+                    method,
+                    url,
+                    fields={},
+                    timeout=timeout,
+                    headers=headers,
+                    preload_content=False,
+                )
+        except urllib3.exceptions.SSLError as e:
+            msg = "\n".join([type(e).__name__, str(e)])
+            raise ApiException(status=0, reason=msg)
+
+        return RESTResponse(r)

dapla_metadata/variable_definitions/_utils/__init__.py

@@ -0,0 +1 @@
+"""Util methods for variable definitions."""

dapla_metadata/variable_definitions/_utils/_client.py

@@ -0,0 +1,32 @@
+from dapla_metadata.variable_definitions._generated.vardef_client.api_client import (
+    ApiClient,
+)
+from dapla_metadata.variable_definitions._generated.vardef_client.configuration import (
+    Configuration,
+)
+from dapla_metadata.variable_definitions._utils.config import (
+    get_vardef_client_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/_utils/config.py

@@ -0,0 +1,54 @@
+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_PROD = "https://metadata.intern.ssb.no"
+VARDEF_HOST_TEST = "https://metadata.intern.test.ssb.no"
+WORKSPACE_DIR = "WORKSPACE_DIR"
+
+
+def get_workspace_dir() -> str | None:
+    """Get the path to work directory from workspace environment variable."""
+    return get_config_item(WORKSPACE_DIR)
+
+
+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:
+            return VARDEF_HOST_PROD
+        case DaplaEnvironment.TEST:
+            return VARDEF_HOST_TEST
+        case DaplaEnvironment.DEV:
+            return VARDEF_HOST_TEST
+        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/_utils/constants.py

@@ -0,0 +1,80 @@
+"""Constants for variable definitions."""
+
+from datetime import date
+
+from dapla_metadata.variable_definitions._generated.vardef_client.models.contact import (
+    Contact,
+)
+from dapla_metadata.variable_definitions._generated.vardef_client.models.language_string_type import (
+    LanguageStringType,
+)
+
+VARIABLE_DEFINITIONS_DIR = "variable_definitions"
+
+VARIABLE_STATUS_FIELD_NAME = "variable_status"
+OWNER_FIELD_NAME = "owner"
+
+TEMPLATE_HEADER = "--- Variabeldefinisjon mal ---\n"
+HEADER = "--- Variabeldefinisjon ---\n"
+
+TEMPLATE_SECTION_HEADER_STATUS = "\n--- Statusfelt. Verdi 'DRAFT' før publisering. Ikke rediger hvis du oppretter en ny variabeldefinisjon. ---\n"
+TEMPLATE_SECTION_HEADER_OWNER = "\n--- Eierteam og grupper. Ikke rediger hvis du oppretter en ny variabeldefinisjon, verdien genereres ---\n"
+TEMPLATE_SECTION_HEADER_MACHINE_GENERATED = (
+    "\n--- Maskin-genererte felt. Ikke rediger. ---\n"
+)
+
+TEMPLATE_HEADER_EN = "--- Variable definition template ---\n"
+HEADER_EN = "--- Variable definition ---\n"
+TEMPLATE_SECTION_HEADER_STATUS_EN = "\n--- Status field. Value 'DRAFT' before publishing. Do not edit if creating new variable defintion ---\n"
+TEMPLATE_SECTION_HEADER_OWNER_EN = "\n--- Owner team and groups. Do not edit if creating new variable defintion, value is generated ---\n"
+TEMPLATE_SECTION_HEADER_MACHINE_GENERATED_EN = (
+    "\n--- Machine generated fields. Do not edit ---\n"
+)
+
+DEFAULT_DATE = date(1000, 1, 1)
+
+GENERATED_CONTACT = Contact(
+    title=LanguageStringType(
+        nb="generert tittel",
+    ),
+    email="generert@ssb.no",
+)
+
+MACHINE_GENERATED_FIELDS = [
+    "id",
+    "patch_id",
+    "created_at",
+    "created_by",
+    "last_updated_at",
+    "last_updated_by",
+]
+
+OPTIONAL_FIELD = "~ Valgfritt felt ~"
+REQUIRED_FIELD = "! Obligatorisk felt !"
+
+YAML_STR_TAG = "tag:yaml.org,2002:str"
+
+BLOCK_FIELDS = [
+    "definition",
+    "name",
+    "contact.title",
+    "comment",
+]
+
+DOUBLE_QUOTE_FIELDS = [
+    "unit_types",
+    "subject_fields",
+    "related_variable_definition_uris",
+    "owner",
+    "short_name",
+    "classification_reference",
+    "measurement_type",
+    "external_reference_uri",
+    "created_by",
+    "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"