dapla-toolbelt-metadata 0.4.2__py3-none-any.whl → 0.6.0__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 rate == 100:
+                return SSB_NAMING_STANDARD_REPORT_RESULT_BEST
+            if 70 < rate < 100:
+                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 ref: https://manual.dapla.ssb.no/statistikkere/navnestandard.html#filnavn"
+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! Alt bestått! 🎉\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

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

dapla_metadata/variable_definitions/{generated → _generated}/.openapi-generator/FILES

@@ -2,21 +2,16 @@ 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.11.0

dapla_metadata/variable_definitions/{generated → _generated}/vardef_client/__init__.py

@@ -20,7 +20,6 @@ __version__ = "1.0.0"
 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
 
@@ -39,14 +38,10 @@ from .exceptions import ApiException
 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

dapla_metadata/variable_definitions/{generated → _generated}/vardef_client/api/__init__.py

@@ -4,6 +4,5 @@
 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

dapla_metadata/variable_definitions/{generated → _generated}/vardef_client/api/data_migration_api.py

@@ -1,6 +1,6 @@
-"""Variable Definitions
+"""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.
+## 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

dapla_metadata/variable_definitions/{generated → _generated}/vardef_client/api/draft_variable_definitions_api.py

@@ -1,6 +1,6 @@
-"""Variable Definitions
+"""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.
+## 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
@@ -46,7 +46,7 @@ class DraftVariableDefinitionsApi:
             StrictStr,
             Field(description="The group which the user currently represents."),
         ],
-        draft: Draft,
+        draft: Draft | None = None,
         _request_timeout: None
         | Annotated[StrictFloat, Field(gt=0)]
         | tuple[
@@ -63,7 +63,7 @@ class DraftVariableDefinitionsApi:
 
         :param active_group: The group which the user currently represents. (required)
         :type active_group: str
-        :param draft: (required)
+        :param draft:
         :type draft: Draft
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -117,7 +117,7 @@ class DraftVariableDefinitionsApi:
             StrictStr,
             Field(description="The group which the user currently represents."),
         ],
-        draft: Draft,
+        draft: Draft | None = None,
         _request_timeout: None
         | Annotated[StrictFloat, Field(gt=0)]
         | tuple[
@@ -134,7 +134,7 @@ class DraftVariableDefinitionsApi:
 
         :param active_group: The group which the user currently represents. (required)
         :type active_group: str
-        :param draft: (required)
+        :param draft:
         :type draft: Draft
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -188,7 +188,7 @@ class DraftVariableDefinitionsApi:
             StrictStr,
             Field(description="The group which the user currently represents."),
         ],
-        draft: Draft,
+        draft: Draft | None = None,
         _request_timeout: None
         | Annotated[StrictFloat, Field(gt=0)]
         | tuple[
@@ -205,7 +205,7 @@ class DraftVariableDefinitionsApi:
 
         :param active_group: The group which the user currently represents. (required)
         :type active_group: str
-        :param draft: (required)
+        :param draft:
         :type draft: Draft
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -615,7 +615,7 @@ class DraftVariableDefinitionsApi:
             StrictStr,
             Field(description="The group which the user currently represents."),
         ],
-        update_draft: UpdateDraft,
+        update_draft: UpdateDraft | None = None,
         _request_timeout: None
         | Annotated[StrictFloat, Field(gt=0)]
         | tuple[
@@ -634,7 +634,7 @@ class DraftVariableDefinitionsApi:
         :type variable_definition_id: str
         :param active_group: The group which the user currently represents. (required)
         :type active_group: str
-        :param update_draft: (required)
+        :param update_draft:
         :type update_draft: UpdateDraft
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -695,7 +695,7 @@ class DraftVariableDefinitionsApi:
             StrictStr,
             Field(description="The group which the user currently represents."),
         ],
-        update_draft: UpdateDraft,
+        update_draft: UpdateDraft | None = None,
         _request_timeout: None
         | Annotated[StrictFloat, Field(gt=0)]
         | tuple[
@@ -714,7 +714,7 @@ class DraftVariableDefinitionsApi:
         :type variable_definition_id: str
         :param active_group: The group which the user currently represents. (required)
         :type active_group: str
-        :param update_draft: (required)
+        :param update_draft:
         :type update_draft: UpdateDraft
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -775,7 +775,7 @@ class DraftVariableDefinitionsApi:
             StrictStr,
             Field(description="The group which the user currently represents."),
         ],
-        update_draft: UpdateDraft,
+        update_draft: UpdateDraft | None = None,
         _request_timeout: None
         | Annotated[StrictFloat, Field(gt=0)]
         | tuple[
@@ -794,7 +794,7 @@ class DraftVariableDefinitionsApi:
         :type variable_definition_id: str
         :param active_group: The group which the user currently represents. (required)
         :type active_group: str
-        :param update_draft: (required)
+        :param update_draft:
         :type update_draft: UpdateDraft
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request