Reference¶

datadoc package¶

datadoc.app module¶

Top-level entrypoint, configuration and layout for the datadoc app.

Members of this module should not be imported into any sub-modules, this will cause circular imports.

build_app(app)¶

Define the layout, register callbacks.

Return type:: Dash
Parameters:: app (type[Dash])

collect_data_from_external_sources(executor)¶

Call classes and methods which collect data from external sources.

Must be non-blocking to prevent delays in app startup.

Return type:: None
Parameters:: executor (ThreadPoolExecutor)

get_app(executor, dataset_path=None)¶

Centralize all the ugliness around initializing the app.

Return type:

tuple[Dash, int]

Parameters:

executor (ThreadPoolExecutor)
dataset_path (str | None)

main(dataset_path=None)¶

Entrypoint when running as a script.

Return type:: None
Parameters:: dataset_path (str | None)

datadoc.enums module¶

Enumerations used in Datadoc.

class Assessment(language_strings)¶

Bases: LanguageStringsEnum

Sensitivity of data.

OPEN = 'OPEN'¶

PROTECTED = 'PROTECTED'¶

SENSITIVE = 'SENSITIVE'¶

class DaplaRegion(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: str, Enum

Dapla platforms/regions.

BIP = 'BIP'¶

CLOUD_RUN = 'CLOUD_RUN'¶

DAPLA_LAB = 'DAPLA_LAB'¶

ON_PREM = 'ON_PREM'¶

class DaplaService(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: str, Enum

Dapla services.

DATADOC = 'DATADOC'¶

JUPYTERLAB = 'JUPYTERLAB'¶

KILDOMATEN = 'KILDOMATEN'¶

R_STUDIO = 'R_STUDIO'¶

VS_CODE = 'VS_CODE'¶

class DataSetState(language_strings)¶

Bases: LanguageStringsEnum

Processing state of a dataset.

INPUT_DATA = 'INPUT_DATA'¶

OUTPUT_DATA = 'OUTPUT_DATA'¶

PROCESSED_DATA = 'PROCESSED_DATA'¶

SOURCE_DATA = 'SOURCE_DATA'¶

STATISTICS = 'STATISTICS'¶

class DataSetStatus(language_strings)¶

Bases: LanguageStringsEnum

Lifecycle status of a dataset.

DEPRECATED = 'DEPRECATED'¶

DRAFT = 'DRAFT'¶

EXTERNAL = 'EXTERNAL'¶

INTERNAL = 'INTERNAL'¶

class DataType(language_strings)¶

Bases: LanguageStringsEnum

Simplified data types for metadata purposes.

BOOLEAN = 'BOOLEAN'¶

DATETIME = 'DATETIME'¶

FLOAT = 'FLOAT'¶

INTEGER = 'INTEGER'¶

STRING = 'STRING'¶

class LanguageStringsEnum(language_strings)¶

Bases: Enum

Enum class for storing LanguageStringType objects.

get_value_for_language(language)¶

Retrieve the string for the relevant language.

Return type:: str | None
Parameters:: language (SupportedLanguages)

class SupportedLanguages(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: str, Enum

The list of languages metadata may be recorded in.

Reference: https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry

ENGLISH = 'en'¶

NORSK_BOKMÅL = 'nb'¶

NORSK_NYNORSK = 'nn'¶

class TemporalityTypeType(language_strings)¶

Bases: LanguageStringsEnum

Temporality of a dataset.

More information about temporality type: https://statistics-norway.atlassian.net/l/c/HV12q90R

ACCUMULATED = 'ACCUMULATED'¶

EVENT = 'EVENT'¶

FIXED = 'FIXED'¶

STATUS = 'STATUS'¶

class UseRestriction(language_strings)¶

Bases: LanguageStringsEnum

Lifecycle status of a dataset.

DELETION_ANONYMIZATION = 'DELETION_ANONYMIZATION'¶

PROCESS_LIMITATIONS = 'PROCESS_LIMITATIONS'¶

SECONDARY_USE_RESTRICTIONS = 'SECONDARY_USE_RESTRICTIONS'¶

class VariableRole(language_strings)¶

Bases: LanguageStringsEnum

The role of a variable in a dataset.

ATTRIBUTE = 'ATTRIBUTE'¶

IDENTIFIER = 'IDENTIFIER'¶

MEASURE = 'MEASURE'¶

START_TIME = 'START_TIME'¶

STOP_TIME = 'STOP_TIME'¶

datadoc.state module¶

Global state.

DANGER: This global is safe when Datadoc is run as designed, with an individual instance per user run within a Jupyter Notebook.

If Datadoc is redeployed as a multi-user web app then this storage strategy must be modified, since users will modify each others data. See here: https://dash.plotly.com/sharing-data-between-callbacks

data_sources: CodeList¶

measurement_units: CodeList¶

metadata: DataDocMetadata¶

organisational_units: CodeList¶

statistic_subject_mapping: StatisticSubjectMapping¶

unit_types: CodeList¶

datadoc.utils module¶

General utilities.

calculate_percentage(completed, total)¶

Calculate percentage as a rounded integer.

Return type:

int

Parameters:

completed (int)
total (int)

get_app_version()¶

Get the version of the Datadoc package.

Return type:: str

get_timestamp_now()¶

Return a timestamp for the current moment.

Return type:: datetime

pick_random_port()¶

Pick a random free port number.

The function will bind a socket to port 0, and a random free port from 1024 to 65535 will be selected by the operating system.

Return type:: int

running_in_notebook()¶

Return True if running in Jupyter Notebook.

Return type:: bool

datadoc.wsgi module¶

datadoc.backend package¶

datadoc.backend.datadoc_metadata module¶

Handle reading, updating and writing of metadata.

class DataDocMetadata(statistic_subject_mapping, dataset_path=None, metadata_document_path=None)¶

Bases: object

Handle reading, updating and writing of metadata.

Parameters:

statistic_subject_mapping (StatisticSubjectMapping)
dataset_path (str | None)
metadata_document_path (str | None)

extract_metadata_from_dataset(dataset)¶

Obtain what metadata we can from the dataset itself.

This makes it easier for the user by ‘pre-filling’ certain fields. Certain elements are dependent on the dataset being saved according to SSB’s standard.

Return type:: None
Parameters:: dataset (Path | CloudPath)

extract_metadata_from_existing_document(document)¶

There’s an existing metadata document, so read in the metadata from that.

Return type:: None
Parameters:: document (Path | CloudPath)

extract_metadata_from_files()¶

Read metadata from an existing metadata document.

If no metadata document exists, create one from scratch by extracting metadata from the dataset file.

Return type:: None

static get_assessment_by_state(state)¶

Find assessment derived by dataset state.

Return type:: Assessment | None
Parameters:: state (DataSetState | None)

property percent_complete: int¶

The percentage of obligatory metadata completed.

A metadata field is counted as complete when any non-None value is assigned. Used for a live progress bar in the UI, as well as being saved in the datadoc as a simple quality indicator.

set_default_spatial_coverage_description()¶

Returns the default value ‘Norge’.

Return type:: LanguageStringType

write_metadata_document()¶

Write all currently known metadata to file.

Return type:: None

datadoc.backend.dataset_parser module¶

Abstractions for dataset file formats.

Handles reading in the data and transforming data types to generic metadata types.

class DatasetParser(dataset)¶

Bases: ABC

Abstract Base Class for all Dataset parsers.

Implements: - A static factory method to get the correct implementation for each file extension. - A static method for data type conversion.

Requires implementation by subclasses: - A method to extract variables (columns) from the dataset, so they may be documented.

Parameters:: dataset (pathlib.Path | CloudPath)

static for_file(dataset)¶

Return the correct subclass based on the given dataset file.

Return type:: DatasetParser
Parameters:: dataset (pathlib.Path | CloudPath)

abstract get_fields()¶

Abstract method, must be implemented by subclasses.

Return type:: list[Variable]

static transform_data_type(data_type)¶

Transform a concrete data type to an abstract data type.

In statistical metadata, one is not interested in how the data is technically stored, but in the meaning of the data type. Because of this, we transform known data types to their abstract metadata representations.

If we encounter a data type we don’t know, we just ignore it and let the user handle it in the GUI.

Return type:: DataType | None
Parameters:: data_type (str)

class DatasetParserParquet(dataset)¶

Bases: DatasetParser

Concrete implementation for parsing parquet files.

Parameters:: dataset (pathlib.Path | CloudPath)

get_fields()¶

Extract the fields from this dataset.

Return type:: list[Variable]

class DatasetParserSas7Bdat(dataset)¶

Bases: DatasetParser

Concrete implementation for parsing SAS7BDAT files.

Parameters:: dataset (pathlib.Path | CloudPath)

get_fields()¶

Extract the fields from this dataset.

Return type:: list[Variable]

datadoc.backend.model_backwards_compatibility module¶

Upgrade old metadata files to be compatible with new versions of the datadoc model.

An important principle of Datadoc is that we ALWAYS guarantee backwards compatibility of existing metadata documents. This means that we guarantee that a user will never lose data, even if their document is decades old.

For each document version we release with breaking changes, we implement a handler and register the version by defining a BackwardsCompatibleVersion instance. These documents will then be upgraded when they’re opened in Datadoc.

A test must also be implemented for each new version.

class BackwardsCompatibleVersion(version, handler)¶

Bases: object

A version which we support with backwards compatibility.

Parameters:

version (str)
handler (Callable[[dict[str, Any]], dict[str, Any]])

handler: Callable[[dict[str, Any]], dict[str, Any]]¶

version: str¶

exception UnknownModelVersionError(supplied_version, *args)¶

Bases: Exception

Throw this error if we haven’t seen the version before.

Parameters:

supplied_version (str)
args (tuple[Any, ...])

Return type:

None

add_container(existing_metadata)¶

Add container for previous versions.

Return type:: dict
Parameters:: existing_metadata (dict)

handle_current_version(supplied_metadata)¶

Nothing to do here.

Return type:: dict[str, Any]
Parameters:: supplied_metadata (dict[str, Any])

handle_version_0_1_1(supplied_metadata)¶

Handle breaking changes for v0.1.1.

PR ref: https://github.com/statisticsnorway/ssb-datadoc-model/pull/4.

Return type:: dict[str, Any]
Parameters:: supplied_metadata (dict[str, Any])

handle_version_1_0_0(supplied_metadata)¶

Handle breaking changes for v1.0.0.

Return type:: dict[str, Any]
Parameters:: supplied_metadata (dict[str, Any])

handle_version_2_1_0(supplied_metadata)¶

Handle breaking changes for v2.1.0.

Datatype changed from LanguageStringType to str for owner

Return type:: dict[str, Any]
Parameters:: supplied_metadata (dict[str, Any])

handle_version_2_2_0(supplied_metadata)¶

Handle breaking changes for v2.2.0.

Return type:: dict[str, Any]
Parameters:: supplied_metadata (dict[str, Any])

handle_version_3_1_0(supplied_metadata)¶

Handle breaking changes for v3.1.0.

Return type:: dict[str, Any]
Parameters:: supplied_metadata (dict[str, Any])

handle_version_3_2_0(supplied_metadata)¶

Update the type of contains_data_* fields.

Return type:: dict[str, Any]
Parameters:: supplied_metadata (dict[str, Any])

is_metadata_in_container_structure(metadata)¶

At a certain point a metadata ‘container’ was introduced.

The container provides a structure for different ‘types’ of metadata, such as ‘datadoc’, ‘pseudonymization’ etc. This method returns True if the metadata is in the container structure, False otherwise.

Return type:: bool
Parameters:: metadata (dict)

upgrade_metadata(fresh_metadata)¶

Run the handler for this version to upgrade the document to the latest version.

Return type:: dict[str, Any]
Parameters:: fresh_metadata (dict[str, Any])

datadoc.backend.storage_adapter module¶

datadoc.frontend package¶

datadoc.frontend.callbacks package¶

datadoc.frontend.callbacks.dataset module¶

Callbacks relating to datasets.

accept_dataset_metadata_date_input(dataset_identifier, contains_data_from, contains_data_until)¶

Validate and save date range inputs.

Return type:

tuple[bool, str, bool, str]

Parameters:

dataset_identifier (DatasetIdentifiers)
contains_data_from (str | None)
contains_data_until (str | None)

accept_dataset_metadata_input(value, metadata_identifier, language=None)¶

Handle user inputs of dataset metadata values.

Return type:

tuple[bool, str]

Parameters:

value (str | list[str] | int | float | bool | date | None | LanguageStringType)
metadata_identifier (str)
language (str | None)

dataset_metadata_control()¶

Check obligatory metadata values for dataset.

Return type:: Alert | None

open_dataset_handling(n_clicks, file_path, dataset_opened_counter)¶

Handle errors and other logic around opening a dataset file.

Return type:

tuple[Alert, int]

Parameters:

n_clicks (int)
file_path (str)
dataset_opened_counter (int)

open_file(file_path=None)¶

Load the given dataset into a DataDocMetadata instance.

Return type:: DataDocMetadata
Parameters:: file_path (str | None)

process_keyword(value)¶

Convert a comma separated string to a list of strings.

e.g. ‘a,b ,c’ -> [‘a’, ‘b’, ‘c’]

Return type:: list[str]
Parameters:: value (str)

process_special_cases(value, metadata_identifier, language=None)¶

Pre-process metadata where needed.

Some types of metadata need processing before being saved to the model. Handle these cases here, other values are returned unchanged.

Return type:

Parameters:

value (str | list[str] | int | float | bool | date | None | LanguageStringType)
metadata_identifier (str)
language (str | None)

datadoc.frontend.callbacks.register_callbacks module¶

All decorated callback functions should be defined here.

Implementations of the callback functionality should be in other functions (in other files), to enable unit testing.

register_callbacks(app)¶

Define and register callbacks.

Return type:: None
Parameters:: app (Dash)

datadoc.frontend.callbacks.utils module¶

Functions which aren’t directly called from a decorated callback.

find_existing_language_string(metadata_model_object, value, metadata_identifier, language)¶

Get or create a LanguageStrings object and return it.

Return type:

LanguageStringType | None

Parameters:

metadata_model_object (pydantic.BaseModel)
value (str)
metadata_identifier (str)
language (str)

get_dataset_path()¶

Extract the path to the dataset from the potential sources.

Return type:: Path | CloudPath | str

get_language_strings_enum(enum)¶

Get the correct language strings enum for the given enum.

We need multiple languages to display in the front end, but the model only defines a single language in the enums.

Return type:: LanguageStringsEnum
Parameters:: enum (Enum | type[LanguageStringsEnum])

get_metadata_field_display_name(field, filter_list)¶

Return field display name if tuple in list.

Return type:

str

Parameters:

field (str | tuple)
filter_list (list)

obligatory_metadata(metadata, obligatory_metadata)¶

Hard check metadata field.

Tuple contains identifier and value.

Return type:

bool

Parameters:

metadata (tuple)
obligatory_metadata (list)

parse_and_validate_dates(start_date, end_date)¶

Parse and validate the given dates.

Return type:

tuple[datetime | None, datetime | None]

Parameters:

start_date (str | datetime | None)
end_date (str | datetime | None)

Validate that:

The dates are in YYYY-MM-DD format
The start date is earlier or identical to the end date.

Examples: >>> parse_and_validate_dates(“2021-01-01”, “2021-01-01”) (datetime.datetime(2021, 1, 1, 0, 0, tzinfo=datetime.timezone.utc), datetime.datetime(2021, 1, 1, 0, 0, tzinfo=datetime.timezone.utc))

>>> parse_and_validate_dates("1990-01-01", "2050-01-01")
(datetime.datetime(1990, 1, 1, 0, 0, tzinfo=datetime.timezone.utc), datetime.datetime(2050, 1, 1, 0, 0, tzinfo=datetime.timezone.utc))

>>> parse_and_validate_dates(None, None)
(None, None)

>>> parse_and_validate_dates("1st January 2021", "1st January 2021")
Traceback (most recent call last):
...
ValueError: Validation error: Expected an ISO 8601-like string, but was given '1st January 2021'. Try passing in a format string to resolve this.

>>> parse_and_validate_dates(datetime.datetime(2050, 1, 1, 0, 0, tzinfo=datetime.timezone.utc), "1990-01-01")
Traceback (most recent call last):
...
ValueError: Validation error: contains_data_from must be the same or earlier date than contains_data_until

>>> parse_and_validate_dates("2050-01-01", "1990-01-01")
Traceback (most recent call last):
...
ValueError: Validation error: contains_data_from must be the same or earlier date than contains_data_until

render_tabs(tab)¶

Render tab content.

Return type:: Article | None
Parameters:: tab (str)

datadoc.frontend.callbacks.variables module¶

Callback functions to do with variables metadata.

accept_variable_metadata_date_input(variable_identifier, variable_short_name, contains_data_from, contains_data_until)¶

Validate and save date range inputs.

Return type:

tuple[bool, str, bool, str]

Parameters:

variable_identifier (VariableIdentifiers)
variable_short_name (str)
contains_data_from (str)
contains_data_until (str)

accept_variable_metadata_input(value, variable_short_name, metadata_field, language=None)¶

Validate and save the value when variable metadata is updated.

Returns an error message if an exception was raised, otherwise returns None.

Return type:

str | None

Parameters:

value (str | list[str] | int | float | bool | date | None)
variable_short_name (str)
metadata_field (str)
language (str | None)

handle_multi_language_metadata(metadata_field, new_value, updated_row_id, language)¶

Handle updates to fields which support multiple languages.

Return type:

Parameters:

metadata_field (str)
new_value (str | list[str] | int | float | bool | date | None | LanguageStringType)
updated_row_id (str)
language (str)

populate_variables_workspace(variables, search_query, dataset_opened_counter)¶

Create variable workspace with accordions for variables.

Allows for filtering which variables are displayed via the search box.

Return type:

list

Parameters:

variables (list[Variable])
search_query (str)
dataset_opened_counter (int)

set_variables_value_multilanguage_inherit_dataset_values(value, metadata_identifier, language)¶

Set variable multilanguage value based on dataset value.

Return type:

None

Parameters:

value (str | list[str] | int | float | bool | date | None | LanguageStringType)
metadata_identifier (str)
language (str)

set_variables_values_inherit_dataset_derived_date_values()¶

Set variable date values if variables date values are not set.

Covers the case for inherit dataset date values where dates are derived from dataset path and must be set on file opening.

Return type:: None

set_variables_values_inherit_dataset_values(value, metadata_identifier)¶

Set variable value based on dataset value.

Return type:

None

Parameters:

value (str | list[str] | int | float | bool | date | None | LanguageStringType)
metadata_identifier (str)

variable_identifier(dataset_identifier)¶

Pair corresponding identifiers.

Return type:: str | None
Parameters:: dataset_identifier (str)

variable_identifier_multilanguage(dataset_identifier)¶

Pair corresponding identifiers for multilanguage fields.

Return type:: str | None
Parameters:: dataset_identifier (str)

variables_metadata_control()¶

Check obligatory metadata values for dataset.

Return type:: Alert | None

datadoc.frontend.components package¶

datadoc.frontend.components.alerts module¶

datadoc.frontend.components.builders module¶

Factory functions for different components are defined here.

class AlertType(color)¶

Bases: object

Attributes of a concrete alert type.

Parameters:: color (str)

color: str¶

static get_type(alert_type)¶

Get a concrete alert type based on the given enum values.

Return type:: AlertType
Parameters:: alert_type (AlertTypes)

class AlertTypes(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: Enum

Types of alerts.

ERROR = 3¶

SUCCESS = 1¶

WARNING = 2¶

build_dataset_edit_section(title, metadata_inputs, dataset, key)¶

Create edit section for dataset workspace.

Return type:

Section

Parameters:

title (str)
metadata_inputs (list[MetadataInputField | MetadataDropdownField | MetadataCheckboxField | MetadataPeriodField | MetadataMultiLanguageField])
dataset (Dataset)
key (dict)

build_edit_section(metadata_inputs, title, variable)¶

Create input section for variable workspace.

Return type:

Section

Parameters:

metadata_inputs (list)
title (str)
variable (Variable)

build_input_field_section(metadata_fields, variable)¶

Create form with input fields for variable workspace.

Return type:

Form

Parameters:

metadata_fields (list[MetadataInputField | MetadataDropdownField | MetadataCheckboxField | MetadataPeriodField | MetadataMultiLanguageField])
variable (Variable)

build_link_object(text, href)¶

Build link object with text and URL.

Return type:

dict | None

Parameters:

text (str)
href (str)

build_ssb_accordion(header, key, variable_short_name, children)¶

Build Accordion for one variable in variable workspace.

Return type:

Accordion

Parameters:

header (str)
key (dict)
variable_short_name (str)
children (list)

build_ssb_alert(alert_type, title, message=None, link=None, alert_list=None)¶

Make a Dash Alert according to SSBs Design System.

Return type:

Alert

Parameters:

alert_type (AlertTypes)
title (str)
message (str | None)
link (dict | None)
alert_list (list | None)

datadoc.frontend.components.control_bars module¶

Components and layout which are not inside a tab.

build_controls_bar()¶

Build the Controls Bar.

This contains: - A text input to specify the path to a dataset - A button to open a dataset - A button to save metadata to disk

Return type:: Section

build_footer_control_bar()¶

Build footer control bar which resides below all the content.

Return type:: Aside

datadoc.frontend.components.dataset_tab module¶

Components and layout for the Dataset metadata tab.

build_dataset_tab()¶

Build the Dataset metadata tab.

Return type:: Article

datadoc.frontend.components.variables_tab module¶

Components and layout for variables tab.

build_variables_tab()¶

Build the framework for the variables tab.

Return type:: Article

datadoc.frontend.fields package¶

datadoc.frontend.fields.display_base module¶

Functionality common to displaying dataset and variables metadata.

class DisplayMetadata(identifier, display_name, description, obligatory=False, editable=True)¶

Bases: ABC

Controls how a given metadata field should be displayed.

Parameters:

identifier (str)
display_name (str)
description (str)
obligatory (bool)
editable (bool)

description: str¶

display_name: str¶

editable: bool = True¶

identifier: str¶

obligatory: bool = False¶

abstract render(component_id, metadata)¶

Build a component.

Return type:

Component

Parameters:

component_id (dict)
metadata (BaseModel)

class MetadataCheckboxField(identifier, display_name, description, obligatory=False, editable=True)¶

Bases: DisplayMetadata

Controls for how a checkbox metadata field should be displayed.

Parameters:

identifier (str)
display_name (str)
description (str)
obligatory (bool)
editable (bool)

render(component_id, metadata)¶

Build Checkbox component.

Return type:

Checkbox

Parameters:

component_id (dict)
metadata (BaseModel)

class MetadataDropdownField(identifier, display_name, description, obligatory=False, editable=True, options_getter=<class 'list'>)¶

Bases: DisplayMetadata

Controls how a Dropdown should be displayed.

Parameters:

identifier (str)
display_name (str)
description (str)
obligatory (bool)
editable (bool)
options_getter (Callable[[], list[dict[str, str]]])

options_getter¶: alias of list

render(component_id, metadata)¶

Build Dropdown component.

Return type:

Dropdown

Parameters:

component_id (dict)
metadata (BaseModel)

class MetadataInputField(identifier, display_name, description, obligatory=False, editable=True, type='text', value_getter=<function get_metadata_and_stringify>)¶

Bases: DisplayMetadata

Controls how an input field should be displayed.

Parameters:

identifier (str)
display_name (str)
description (str)
obligatory (bool)
editable (bool)
type (str)
value_getter (Callable[[BaseModel, str], Any])

render(component_id, metadata)¶

Build an Input component.

Return type:

Input

Parameters:

component_id (dict)
metadata (BaseModel)

type: str = 'text'¶

value_getter(identifier)¶

Get a metadata value from the model and cast to string.

Return type:

str | None

Parameters:

metadata (BaseModel)
identifier (str)

class MetadataMultiLanguageField(identifier, display_name, description, obligatory=False, editable=True, id_type='', type='text')¶

Bases: DisplayMetadata

Controls how fields which support multi-language are displayed.

These are a special case since they return a group of input fields..

Parameters:

identifier (str)
display_name (str)
description (str)
obligatory (bool)
editable (bool)
id_type (str)
type (str)

id_type: str = ''¶

render(component_id, metadata)¶

Build fieldset group.

Return type:

Fieldset

Parameters:

component_id (dict)
metadata (BaseModel)

render_input_group(component_id, metadata)¶

Build section with Input components for each language.

Return type:

Section

Parameters:

component_id (dict)
metadata (BaseModel)

type: str = 'text'¶

class MetadataPeriodField(identifier, display_name, description, obligatory=False, editable=True, id_type='')¶

Bases: DisplayMetadata

Controls how fields which define a time period are displayed.

These are a special case since two fields have a relationship to one another.

Parameters:

identifier (str)
display_name (str)
description (str)
obligatory (bool)
editable (bool)
id_type (str)

id_type: str = ''¶

render(component_id, metadata)¶

Build Input date component.

Return type:

Input

Parameters:

component_id (dict)
metadata (BaseModel)

get_comma_separated_string(metadata, identifier)¶

Get a metadata value which is a list of strings from the model and convert it to a comma separated string.

Return type:

str

Parameters:

metadata (BaseModel)
identifier (str)

get_data_source_options()¶

Collect the unit type options.

Return type:: list[dict[str, str]]

get_enum_options(enum)¶

Generate the list of options based on the currently chosen language.

Return type:: list[dict[str, str]]
Parameters:: enum (Enum)

get_metadata_and_stringify(metadata, identifier)¶

Get a metadata value from the model and cast to string.

Return type:

str | None

Parameters:

metadata (BaseModel)
identifier (str)

get_multi_language_metadata_and_stringify(metadata, identifier, language)¶

Get a metadata value supporting multiple languages from the model.

Return type:

str | None

Parameters:

metadata (BaseModel)
identifier (str)
language (SupportedLanguages)

get_standard_metadata(metadata, identifier)¶

Get a metadata value from the model.

Return type:

Parameters:

metadata (BaseModel)
identifier (str)

datadoc.frontend.fields.display_dataset module¶

Functionality for displaying dataset metadata.

class DatasetIdentifiers(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: str, Enum

As defined here: https://statistics-norway.atlassian.net/l/c/aoSfEWJU.

ASSESSMENT = 'assessment'¶

CONTAINS_DATA_FROM = 'contains_data_from'¶

CONTAINS_DATA_UNTIL = 'contains_data_until'¶

CONTAINS_PERSONAL_DATA = 'contains_personal_data'¶

DATASET_STATE = 'dataset_state'¶

DATASET_STATUS = 'dataset_status'¶

DATA_SOURCE = 'data_source'¶

DESCRIPTION = 'description'¶

FILE_PATH = 'file_path'¶

ID = 'id'¶

KEYWORD = 'keyword'¶

METADATA_CREATED_BY = 'metadata_created_by'¶

METADATA_CREATED_DATE = 'metadata_created_date'¶

METADATA_LAST_UPDATED_BY = 'metadata_last_updated_by'¶

METADATA_LAST_UPDATED_DATE = 'metadata_last_updated_date'¶

NAME = 'name'¶

OWNER = 'owner'¶

POPULATION_DESCRIPTION = 'population_description'¶

SHORT_NAME = 'short_name'¶

SPATIAL_COVERAGE_DESCRIPTION = 'spatial_coverage_description'¶

SUBJECT_FIELD = 'subject_field'¶

TEMPORALITY_TYPE = 'temporality_type'¶

UNIT_TYPE = 'unit_type'¶

USE_RESTRICTION = 'use_restriction'¶

USE_RESTRICTION_DATE = 'use_restriction_date'¶

VERSION = 'version'¶

VERSION_DESCRIPTION = 'version_description'¶

get_owner_options()¶

Collect the owner options.

Return type:: list[dict[str, str]]

get_statistical_subject_options()¶

Generate the list of options for statistical subject.

Return type:: list[dict[str, str]]

get_unit_type_options()¶

Collect the unit type options.

Return type:: list[dict[str, str]]

datadoc.frontend.fields.display_variables module¶

Functionality for displaying variables metadata.

class VariableIdentifiers(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: str, Enum

As defined here: https://statistics-norway.atlassian.net/wiki/spaces/MPD/pages/3042869256/Variabelforekomst.

CLASSIFICATION_URI = 'classification_uri'¶

COMMENT = 'comment'¶

CONTAINS_DATA_FROM = 'contains_data_from'¶

CONTAINS_DATA_UNTIL = 'contains_data_until'¶

DATA_ELEMENT_PATH = 'data_element_path'¶

DATA_SOURCE = 'data_source'¶

DATA_TYPE = 'data_type'¶

DEFINITION_URI = 'definition_uri'¶

DIRECT_PERSON_IDENTIFYING = 'direct_person_identifying'¶

FORMAT = 'format'¶

IDENTIFIER = 'id'¶

INVALID_VALUE_DESCRIPTION = 'invalid_value_description'¶

MEASUREMENT_UNIT = 'measurement_unit'¶

MULTIPLICATION_FACTOR = 'multiplication_factor'¶

NAME = 'name'¶

POPULATION_DESCRIPTION = 'population_description'¶

SHORT_NAME = 'short_name'¶

TEMPORALITY_TYPE = 'temporality_type'¶

VARIABLE_ROLE = 'variable_role'¶

get_measurement_unit_options()¶

Collect the unit type options.

Return type:: list[dict[str, str]]