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

dapla_metadata/standards/name_validator.py

@@ -0,0 +1,250 @@
+import asyncio
+import logging
+import os
+import re
+from collections.abc import AsyncGenerator
+from pathlib import Path
+
+from dapla_metadata.datasets.dapla_dataset_path_info import DaplaDatasetPathInfo
+from dapla_metadata.datasets.dataset_parser import SUPPORTED_DATASET_FILE_SUFFIXES
+from dapla_metadata.standards.utils.constants import FILE_DOES_NOT_EXIST
+from dapla_metadata.standards.utils.constants import FILE_IGNORED
+from dapla_metadata.standards.utils.constants import IGNORED_FOLDERS
+from dapla_metadata.standards.utils.constants import INVALID_SYMBOLS
+from dapla_metadata.standards.utils.constants import MISSING_DATA_STATE
+from dapla_metadata.standards.utils.constants import MISSING_DATASET_SHORT_NAME
+from dapla_metadata.standards.utils.constants import MISSING_PERIOD
+from dapla_metadata.standards.utils.constants import MISSING_SHORT_NAME
+from dapla_metadata.standards.utils.constants import MISSING_VERSION
+from dapla_metadata.standards.utils.constants import NAME_STANDARD_SUCCESS
+from dapla_metadata.standards.utils.constants import NAME_STANDARD_VIOLATION
+from dapla_metadata.standards.utils.constants import PATH_IGNORED
+from dapla_metadata.standards.utils.constants import SSB_NAMING_STANDARD_REPORT
+from dapla_metadata.standards.utils.constants import SSB_NAMING_STANDARD_REPORT_FILES
+from dapla_metadata.standards.utils.constants import (
+    SSB_NAMING_STANDARD_REPORT_RESULT_AVERAGE,
+)
+from dapla_metadata.standards.utils.constants import (
+    SSB_NAMING_STANDARD_REPORT_RESULT_BEST,
+)
+from dapla_metadata.standards.utils.constants import (
+    SSB_NAMING_STANDARD_REPORT_RESULT_GOOD,
+)
+from dapla_metadata.standards.utils.constants import (
+    SSB_NAMING_STANDARD_REPORT_RESULT_LOW,
+)
+from dapla_metadata.standards.utils.constants import (
+    SSB_NAMING_STANDARD_REPORT_RESULT_NO_SCORE,
+)
+from dapla_metadata.standards.utils.constants import SSB_NAMING_STANDARD_REPORT_SUCCESS
+from dapla_metadata.standards.utils.constants import (
+    SSB_NAMING_STANDARD_REPORT_SUCCESS_RATE,
+)
+from dapla_metadata.standards.utils.constants import (
+    SSB_NAMING_STANDARD_REPORT_VIOLATIONS,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ValidationResult:
+    """Result object for name standard validation."""
+
+    def __init__(
+        self,
+        success: bool,
+        file_path: str,
+    ) -> None:
+        """Initialize the validatation result."""
+        self.success = success
+        self.file_path = file_path
+        self.messages: list[str] = []
+        self.violations: list[str] = []
+
+    def add_message(self, message: str) -> None:
+        """Add message to list."""
+        if message not in self.messages:
+            self.messages.append(message)
+
+    def add_violation(self, violation: str) -> None:
+        """Add violation to list."""
+        if violation not in self.violations:
+            self.violations.append(violation)
+        if self.success:
+            self.success = False
+
+    def __repr__(self) -> str:
+        """Representation for debugging."""
+        return f"ValidationResult(success={self.success}, file_path={self.file_path}, messages={self.messages}, violations={self.violations})"
+
+    def to_dict(self) -> dict:
+        """Return result as a dictionary."""
+        return {
+            "success": self.success,
+            "file_path": self.file_path,
+            "messages": self.messages,
+            "violations": self.violations,
+        }
+
+
+class NamingStandardReport:
+    """Report object for name standard validation."""
+
+    def __init__(self, validation_results: list[ValidationResult]) -> None:
+        """Initialize the naming standard report."""
+        self.validation_results = validation_results
+        self.num_files_validated = len(validation_results)
+        self.num_success = len(
+            [result for result in validation_results if result.success is True],
+        )
+        self.num_failures = len(
+            [result for result in validation_results if result.success is False],
+        )
+
+    def generate_report(self) -> str:
+        """Format the report as a string."""
+        return (
+            f"{SSB_NAMING_STANDARD_REPORT}\n"
+            f"=============================\n"
+            f"{self.evaluate_result()}"
+            f"{SSB_NAMING_STANDARD_REPORT_SUCCESS_RATE}: {self.success_rate():.2f}%\n"
+            f"{SSB_NAMING_STANDARD_REPORT_FILES}: {self.num_files_validated}\n"
+            f"{SSB_NAMING_STANDARD_REPORT_SUCCESS}: {self.num_success}\n"
+            f"{SSB_NAMING_STANDARD_REPORT_VIOLATIONS}s: {self.num_failures}\n"
+        )
+
+    def success_rate(self) -> int | float | None:
+        """Calculate the success rate as a percentage.
+
+        Returns:
+            int | float | None: The success rate as a percentage, or None if
+            no files were validated.
+        """
+        if self.num_files_validated == 0:
+            return None
+        return self.num_success / self.num_files_validated * 100
+
+    def evaluate_result(self) -> str:
+        """Returns an appropriate message based on the success rate."""
+        rate = self.success_rate()
+        if rate is not None:
+            if 95 <= rate <= 100:
+                return SSB_NAMING_STANDARD_REPORT_RESULT_BEST
+            if 70 < rate < 95:
+                return SSB_NAMING_STANDARD_REPORT_RESULT_GOOD
+            if 40 <= rate <= 70:
+                return SSB_NAMING_STANDARD_REPORT_RESULT_AVERAGE
+            if rate < 40:
+                return SSB_NAMING_STANDARD_REPORT_RESULT_LOW
+        return SSB_NAMING_STANDARD_REPORT_RESULT_NO_SCORE
+
+
+def _has_invalid_symbols(path: os.PathLike[str]) -> bool:
+    """Return True if string contains illegal symbols.
+
+    Examples:
+        >>> _has_invalid_symbols("åregang-øre")
+        True
+
+        >>> _has_invalid_symbols("Azor89")
+        False
+
+        >>> _has_invalid_symbols("ssbÆ-dapla-example-data-produkt-prod/ledstill/oppdrag/skjema_p2018_p2020_v1")
+        True
+
+        >>> _has_invalid_symbols("ssb-dapla-example-data-produkt-prod/ledstill/oppdrag/skjema_p2018_p2020_v1")
+        False
+
+        >>> _has_invalid_symbols("ssb-dapla-example-data-produkt-prod/ledstill/inndata/skjema_p2018_p202_v1/aar=2018/data.parquet")
+        False
+    """
+    # TODO @mmwinther: The = symbol is allowed to avoid failures on subdirectories of partioned parquet datasets.
+    # DPMETA-824
+    return bool(re.search(r"[^a-zA-Z0-9\./:_\-=]", str(path).strip()))
+
+
+def _check_violations(
+    file: Path,
+) -> list[str]:
+    """Check for missing attributes and invalid symbols."""
+    path_info = DaplaDatasetPathInfo(file)
+    checks = {
+        MISSING_SHORT_NAME: path_info.statistic_short_name,
+        MISSING_DATA_STATE: path_info.dataset_state,
+        MISSING_PERIOD: path_info.contains_data_from,
+        MISSING_DATASET_SHORT_NAME: path_info.dataset_short_name,
+        MISSING_VERSION: path_info.dataset_version,
+        INVALID_SYMBOLS: not _has_invalid_symbols(file),
+    }
+
+    return [message for message, value in checks.items() if not value]
+
+
+async def _validate_file(
+    file: Path,
+    check_file_exists: bool = False,
+) -> ValidationResult:
+    """Check for naming standard violations.
+
+    Returns:
+        A ValidationResult object containing messages and violations
+    """
+    logger.info("Validating file: %s", file)
+    if file.suffix not in SUPPORTED_DATASET_FILE_SUFFIXES:
+        logger.info("Skipping validation on non-dataset file: %s", file)
+        return await _ignored_file_type_result(file)
+
+    result = ValidationResult(success=True, file_path=str(file))
+
+    if check_file_exists and not file.exists():
+        result.add_message(
+            FILE_DOES_NOT_EXIST,
+        )
+
+    result.violations = await asyncio.get_running_loop().run_in_executor(
+        None,
+        lambda: _check_violations(file),
+    )
+
+    if result.violations:
+        result.success = False
+        result.add_message(NAME_STANDARD_VIOLATION)
+    else:
+        result.success = True
+        result.add_message(
+            NAME_STANDARD_SUCCESS,
+        )
+    return result
+
+
+async def _ignored_folder_result(file: Path) -> ValidationResult:
+    r = ValidationResult(success=True, file_path=str(file))
+    r.add_message(PATH_IGNORED)
+    return r
+
+
+async def _ignored_file_type_result(file: Path) -> ValidationResult:
+    r = ValidationResult(success=True, file_path=str(file))
+    r.add_message(FILE_IGNORED)
+    return r
+
+
+async def validate_directory(
+    path: Path,
+) -> AsyncGenerator[AsyncGenerator | asyncio.Task]:
+    """Validate a file or recursively validate all files in a directory."""
+    if set(path.parts).intersection(IGNORED_FOLDERS):
+        logger.info("File path ignored: %s", path)
+        yield asyncio.create_task(_ignored_folder_result(path))
+    elif path.suffix:
+        yield asyncio.create_task(_validate_file(path, check_file_exists=True))
+    else:
+        for obj in await asyncio.get_running_loop().run_in_executor(
+            None,
+            lambda: path.glob("*"),
+        ):
+            if obj.suffix:
+                yield asyncio.create_task(_validate_file(obj), name=obj.name)
+            else:
+                logger.debug("Recursing into: %s", obj)
+                yield validate_directory(obj)

dapla_metadata/standards/standard_validators.py

@@ -0,0 +1,98 @@
+import asyncio
+import logging
+import os
+import time
+from collections.abc import AsyncGenerator
+
+from dapla_metadata.datasets.utility.utils import normalize_path
+from dapla_metadata.standards.name_validator import NamingStandardReport
+from dapla_metadata.standards.name_validator import ValidationResult
+from dapla_metadata.standards.name_validator import validate_directory
+
+logger = logging.getLogger(__name__)
+
+
+async def check_naming_standard(
+    file_path: str | os.PathLike[str],
+) -> list[ValidationResult]:
+    """Check whether a given path follows the SSB naming standard.
+
+    This function checks whether the provided `file_path` and subdirectories thereof comply
+    with the naming standard. Currently we only examine '.parquet' files. Other files are ignored.
+
+    Args:
+        file_path: The path to a bucket, directory, or specific file to validate.
+                This can be in the following forms:
+                  - A bucket URL in the form 'gs://ssb-dapla-felles-data-produkt-test'
+                  - An absolute path to a mounted bucket in the form '/buckets/produkt'
+                  - Any subdirectory or file thereof
+                We also accept paths which don't yet exist so that you can test if a path will comply.
+
+    Returns:
+        list[ValidationResult]: A list of validation results,
+        including success status, checked file path, messages, and any detected violations.
+
+    Examples:
+        >>> check_naming_standard("/data/example_file.parquet").success
+        False
+
+        >>> check_naming_standard("/buckets/produkt/datadoc/utdata/person_data_p2021_v2.parquet").success
+        True
+    """
+    results = []
+
+    # Begin validation.
+    # For each file this returns a task which we can wait on to complete.
+    # For each directory this returns another AsyncGenerator which must be unpacked below
+    tasks = [t async for t in validate_directory(normalize_path(str(file_path)))]  # type:ignore [arg-type]
+
+    # 5 minute timeout for safety
+    start_time = time.time()
+    while time.time() < start_time + (5 * 60):
+        for item in tasks:
+            if isinstance(item, AsyncGenerator):
+                # Drill down into lower directories to get the validation tasks from them
+                tasks.remove(item)
+                new_tasks = [t async for t in item]
+                logger.debug("New Tasks: %s %s", len(new_tasks), new_tasks)
+                tasks.extend(
+                    new_tasks,
+                )
+            elif isinstance(item, asyncio.Task):
+                if item.done():
+                    logger.info("Validated %s", item.get_name())
+                    tasks.remove(item)
+                    results.append(item.result())
+
+        logger.debug("Tasks: %s %s", len(tasks), tasks)
+        logger.debug("Results: %s", len(results))
+
+        if len(tasks) == 0:
+            logger.info("Completed validation")
+            break
+
+        # Allow time for other processing to be performed
+        await asyncio.sleep(0.001)
+
+    return results
+
+
+def generate_validation_report(
+    validation_results: list[ValidationResult],
+) -> NamingStandardReport:
+    """Generate and print a formatted naming standard validation report.
+
+    This function takes a list of `ValidationResult` objects, creates a
+    `NamingStandardReport` instance, and prints the generated report.
+
+    Args:
+        validation_results: A list of ValidationResult objects that
+        contain the outcomes of the name standard checks.
+
+    Returns:
+        NamingStandardReport: An instance of `NamingStandardReport` containing
+        the validation results.
+    """
+    report = NamingStandardReport(validation_results=validation_results)
+    print(report.generate_report())  # noqa: T201
+    return report

dapla_metadata/standards/utils/__init__.py

@@ -0,0 +1 @@
+"""Utils for validating ssb standards."""

dapla_metadata/standards/utils/constants.py

@@ -0,0 +1,49 @@
+"""Constants used in validate ssb name standard."""
+
+from dapla_metadata.datasets.dataset_parser import SUPPORTED_DATASET_FILE_SUFFIXES
+
+SUCCESS = "Suksess"
+
+NAME_STANDARD_SUCCESS = "Filene dine er i samsvar med SSB-navnestandarden"
+
+NAME_STANDARD_VIOLATION = "Det er oppdaget brudd på SSB-navnestandard:"
+
+MISSING_BUCKET_NAME = "Filnavn mangler bøttenavn ref: https://manual.dapla.ssb.no/statistikkere/navnestandard.html#obligatoriske-mapper"
+MISSING_VERSION = "Filnavn mangler versjon, hvis ikke filen er nyeste versjon kan dette være brudd på navnestandarden ref: https://manual.dapla.ssb.no/statistikkere/navnestandard.html#versjonering-av-datasett"
+MISSING_PERIOD = "Filnavn mangler gyldighetsperiode ref: https://manual.dapla.ssb.no/statistikkere/navnestandard.html#filnavn"
+MISSING_SHORT_NAME = "Kortnavn for statistikk mangler ref: https://manual.dapla.ssb.no/statistikkere/navnestandard.html#obligatoriske-mapper"
+MISSING_DATA_STATE = "Mappe for datatilstand mangler ref: https://manual.dapla.ssb.no/statistikkere/navnestandard.html#obligatoriske-mapper"
+MISSING_DATASET_SHORT_NAME = "Filnavn mangler datasett kortnavn ref: https://manual.dapla.ssb.no/statistikkere/navnestandard.html#filnavn"
+
+INVALID_SYMBOLS = "Filnavn inneholder ulovlige tegn ref: https://manual.dapla.ssb.no/statistikkere/navnestandard.html#filnavn"
+
+PATH_IGNORED = "Ignorert, mappen er ikke underlagt krav til navnestandard."
+FILE_IGNORED = f"Ignorert, kun datasett med {', '.join(SUPPORTED_DATASET_FILE_SUFFIXES.keys())} filendelser valideres foreløpig."
+
+FILE_DOES_NOT_EXIST = "Filen eksisterer ikke. Validerer uansett."
+
+BUCKET_NAME_UNKNOWN = "Kan ikke validere bøttenavn"
+
+SSB_NAMING_STANDARD_REPORT = "SSB navnestandard rapport"
+SSB_NAMING_STANDARD_REPORT_SUCCESS_RATE = "Suksess rate"
+SSB_NAMING_STANDARD_REPORT_RESULT_BEST = "🚀 Fantastisk! 🎉\n"
+SSB_NAMING_STANDARD_REPORT_RESULT_GOOD = (
+    "✅ Bra jobba! Fortsatt litt rom for forbedring. 😊\n"
+)
+SSB_NAMING_STANDARD_REPORT_RESULT_AVERAGE = (
+    "⚠️ Ikke verst! Men det er noen feil å fikse. 🔧\n"
+)
+SSB_NAMING_STANDARD_REPORT_RESULT_LOW = "❌ Mye å forbedre! Ta en grundig sjekk. 🛠️\n"
+SSB_NAMING_STANDARD_REPORT_RESULT_NO_SCORE = "👀 Ingen filer ble validert\n"
+SSB_NAMING_STANDARD_REPORT_FILES = "Antall filer validert"
+SSB_NAMING_STANDARD_REPORT_SUCCESS = "Antall filer som følger SSB navnestandard"
+SSB_NAMING_STANDARD_REPORT_VIOLATIONS = "Antall filer som bryter SSB navnestandard"
+
+IGNORED_FOLDERS = [
+    "temp",
+    "oppdrag",
+    "konfigurasjon",
+    "logg",
+    "tidsserier",
+    "migrert",
+]

dapla_metadata/variable_definitions/__init__.py

@@ -0,0 +1,11 @@
+"""Client for working with Variable Definitions at Statistics Norway."""
+
+from ._generated.vardef_client import models
+from ._generated.vardef_client.exceptions import *  # noqa: F403
+from ._utils.constants import DEFAULT_DATE
+from ._utils.constants import GENERATED_CONTACT
+from .exceptions import VardefClientError
+from .exceptions import VardefFileError
+from .exceptions import VariableNotFoundError
+from .vardef import Vardef
+from .variable_definition import VariableDefinition

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

@@ -0,0 +1,20 @@
+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/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/get_vardok_vardef_mapping_by_id200_response.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/update_draft.py
+vardef_client/models/validity_period.py
+vardef_client/models/vardok_id_response.py
+vardef_client/models/vardok_vardef_id_pair_response.py
+vardef_client/models/variable_status.py

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

@@ -0,0 +1 @@
+7.11.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,47 @@
+# 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.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.language_string_type import LanguageStringType
+from .models.owner import Owner
+from .models.patch import Patch
+from .models.problem import Problem
+from .models.update_draft import UpdateDraft
+from .models.validity_period import ValidityPeriod
+from .models.variable_status import VariableStatus

dapla_metadata/variable_definitions/_generated/vardef_client/api/__init__.py

@@ -0,0 +1,8 @@
+# flake8: noqa
+
+# import apis into api package
+from ..api.data_migration_api import DataMigrationApi
+from ..api.draft_variable_definitions_api import DraftVariableDefinitionsApi
+from ..api.patches_api import PatchesApi
+from ..api.validity_periods_api import ValidityPeriodsApi
+from ..api.variable_definitions_api import VariableDefinitionsApi