nudb_use.variables.derive package

nudb_use.variables.derive.all_data_helpers module

enforce_datetime_s(series)

Enforce the datetime dtype to datetime64[s].

Return type:

Series

Parameters:

series (Series)

get_source_data(variable_name, df_left=None)

Load and prepare source data for deriving a variable.

This function reads one or more parquet datasets defined in config, selects only the columns needed for derivation, unions all datasets, and (optionally) filters rows down to only those whose join-key values overlap with df_left.

Filtering is performed inside DuckDB by registering a temporary in-memory key table derived from df_left[derived_join_keys] and performing an INNER JOIN on the derived join keys.

Parameters:

• variable_name (str) – Name of the variable being derived (used for config lookup).

• df_left (DataFrame | None) – If provided, limits source rows to those matching the join-key combinations present in this dataframe.

Returns:

A pandas DataFrame containing the unioned (and possibly filtered) source data.

Return type:

pd.DataFrame

Raises:

• ValueError – If required config fields are missing or invalid.

• KeyError – If df_left is missing required join key columns.

join_variable_data(variable_name, df_right, df_left)

Left-join a derived variable dataframe onto an input dataframe using config keys.

Parameters:

• variable_name (str) – Name of the variable being derived (used for config lookup).

• df_right (DataFrame) – Derived data containing at least the join keys and derived columns.

• df_left (DataFrame) – Base dataframe to enrich.

Returns:

df_left with df_right merged in using a left join on the config keys.

Return type:

pd.DataFrame

Raises:

• ValueError – If derived join keys are missing in config.

• KeyError – If either dataframe is missing required join key columns.

nudb_use.variables.derive.bof module

bof_eierforhold(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘orgnr_foretak’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing bof_eierforhold values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with bof_eierforhold added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive bof_eierforhold.

Base Function Source Code:

@wrap_derive def bof_eierforhold(df: pd.DataFrame) -> pd.Series:

“””Derive bof_eierforhold.””” metadata = settings.variables[“bof_eierforhold”] datasets = metadata.derived_uses_datasets

if datasets is None or len(datasets) != 1:

raise ValueError(f”Expected a single dataset name, got: {datasets}.”)

else:

dataset: str = datasets[0]

unique_orgnr_foretak = “’, ‘”.join(

df[“orgnr_foretak”].replace(“000000000”, pd.NA).dropna().unique()

) where = f”orgnr_foretak in (‘{unique_orgnr_foretak}’)” if “orgnrbed” in df.columns:

unique_orgnrbed = “’, ‘”.join(

df[“orgnrbed”].replace(“000000000”, pd.NA).dropna().unique()

) where += f” or orgnrbed in (‘{unique_orgnrbed}’)”

logger.info(

“Getting bof-catalogue for bof_eierforhold (combination of bof-situttak).”

) catalogue = (

NudbData(dataset) .select(“orgnr_foretak, orgnrbed, bof_eierforhold”) .where(where) .df()

)

eierf = (

df.merge(

(

catalogue[[“orgnr_foretak”, “bof_eierforhold”]].drop_duplicates(

subset=[“orgnr_foretak”], keep=”last”

)

), # This assumes that “the last eierforhold is the correct one”… on=”orgnr_foretak”, how=”left”, validate=”m:1”,

)[“bof_eierforhold”] .astype(“string[pyarrow]”) .set_axis(df.index)

) logger.info(

f”Joining bof_eierforhold first on orgnr_fortak (preferred by UH). Filled on {_percent_notna(eierf)}%”

)

if “orgnrbed” in df.columns:

orgnr_bed_missing_value = (

df.loc[eierf.isna(), “orgnrbed”] .replace(“000000000”, pd.NA) .dropna() .unique()

) filtered_catalogue = catalogue[

catalogue[“orgnrbed”].isin(orgnr_bed_missing_value).astype(“bool[pyarrow]”)

][[“orgnrbed”, “bof_eierforhold”]].drop_duplicates(

subset=”orgnrbed”, keep=”last”

) # This assumes that “the last eierforhold is the correct one”… eierf = eierf.fillna(

df.merge(filtered_catalogue, on=”orgnrbed”, how=”left”, validate=”m:1”)[

“bof_eierforhold”

] .astype(“string[pyarrow]”) .set_axis(df.index)

) logger.info(

f”Joining bof_eierforhold second on orgnrbed. After both joins, eierforhold filled on {_percent_notna(eierf)}%”

)

else:

logger.info(“Did not find orgnrbed to join bof_eierforhold on.”)

return eierf

nudb_use.variables.derive.derive_decorator module

exception DeriveError

Bases: Exception

For errors that occur during deriving variables.

get_derive_function(varname)

Return the derive function for a variable if it exists.

Parameters:

varname (str) – The name of the variable to get the derive function for.

Returns:

The derive function, or None if no function was found.

Return type:

Callable[…, pd.DataFrame] | None

wrap_derive(basefunc)

Decorator for derive functions that enforces config metadata and logging.

Notes

• Validates that the variable exists in config and has a derived_from definition.

• Recursively derives missing prerequisites before calling the decorated function.

• Logs fill percentages and merges existing data with derived data based on priority.

Parameters:

basefunc (Callable[[Concatenate[DataFrame, ParamSpec(P)]], Series | DataFrame]) – Function that derives a single variable from an input dataframe.

Returns:

Wrapped derive function that writes/updates the derived column.

Return type:

Callable[…, pd.DataFrame]

wrap_derive_join_all_data(basefunc)

Decorator for derive functions that need specific data as a base, specified in the config.

Parameters:

basefunc (Callable[[Concatenate[DataFrame, ParamSpec(P)]], DataFrame]) – Function that derives a single variable from an input dataframe.

Returns:

Wrapped derive function that writes/updates the derived column using whole NUDB-datasets.

Return type:

Callable[…, pd.DataFrame]

nudb_use.variables.derive.derive_decorator_utils module

fillna_by_priority(newvals, oldvals, priority='old')

Fill missing values in prioritized order when a column already exists.

Parameters:

• newvals (Series | None) – A pandas series with the newly added values.

• oldvals (Series | None) – A pandas series with the old values.

• priority (Literal['old', 'new']) – “old” if we should prioritze the old values, “new” if we should prioritize the new.

Returns:

The resulting merged columns using fillna-methods. Returns None if both newvals and oldvals is None.

Return type:

pd.Series | None

Raises:

ValueError – If you are sending in a non-specific Literal for the priority-arg.

swap_temp_colnames_from_temp(df, rename_state)

Restore original column names after temporary derive-time renaming.

Parameters:

• df (DataFrame) – Dataframe whose columns should be restored after derivation.

• rename_state (dict[str, dict[str, str]] | None) – Rename operations that were actually applied in swap_temp_colnames_to_temp.

Returns:

Dataframe with original source names restored.

Return type:

pd.DataFrame

swap_temp_colnames_to_temp(df, derived_from, temp_col_renames)

Temporarily rename input columns to the prerequisite names used by derive functions.

Parameters:

• df (DataFrame) – Dataframe that may contain columns to rename before derivation.

• derived_from (list[str]) – Prerequisite column names expected by the derive function.

• temp_col_renames (dict[str, str] | None) – Mapping from existing column names in df to the prerequisite names the derive function expects.

Returns:

Dataframe with relevant columns renamed for derivation, together with the applied rename state needed to restore the original names.

Return type:

tuple[pd.DataFrame, TempColRenameState]

nudb_use.variables.derive.fullfoert module

gr_ergrunnskole_fullfoert(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’, ‘nus2000’, ‘utd_erutland’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gr_ergrunnskole_fullfoert values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gr_ergrunnskole_fullfoert added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gr_ergrunnskole_fullfoert from nus2000, utd_fullfoertkode, utd_erutland.

Base Function Source Code:

@wrap_derive def gr_ergrunnskole_fullfoert( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive gr_ergrunnskole_fullfoert from nus2000, utd_fullfoertkode, utd_erutland.””” return (

(df[“nus2000”].str[0] == “2”) & (~df[“utd_erutland”]) & (df[“utd_fullfoertkode”] == FULLFOERTKODE)

).astype(BOOL_DTYPE)

uh_erbachelor_fullfoert(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’, ‘uh_gradmerke_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_erbachelor_fullfoert values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_erbachelor_fullfoert added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_erbachelor_fullfoert from uh_gradmerke_nus.

Base Function Source Code:

@wrap_derive def uh_erbachelor_fullfoert( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive uh_erbachelor_fullfoert from uh_gradmerke_nus.””” from nudb_use.nudb_logger import logger

logger.critical(df) return (

(df[“uh_gradmerke_nus”] == “B”) & (df[“utd_fullfoertkode”] == FULLFOERTKODE)

).astype(BOOL_DTYPE)

uh_erdoktorgrad_fullfoert(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’, ‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_erdoktorgrad_fullfoert values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_erdoktorgrad_fullfoert added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_erdoktorgrad_fullfoert from nus2000, utd_fullfoertkode.

Base Function Source Code:

@wrap_derive def uh_erdoktorgrad_fullfoert( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive uh_erdoktorgrad_fullfoert from nus2000, utd_fullfoertkode.””” return (

(df[“nus2000”].str[0] == “8”) & (df[“utd_fullfoertkode”] == FULLFOERTKODE)

).astype(BOOL_DTYPE)

uh_erhoeyskolekandidat_fullfoert(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’, ‘nus2000’, ‘uh_gruppering_nus’, ‘utd_klassetrinn’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_erhoeyskolekandidat_fullfoert values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_erhoeyskolekandidat_fullfoert added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_eryrkesfag_fullfoert from nus2000, vg_utdprogram, utd_fullfoertkode, vg_kompetanse_nus and utd_aktivitet_start.

Base Function Source Code:

@wrap_derive def uh_erhoeyskolekandidat_fullfoert( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive vg_eryrkesfag_fullfoert from nus2000, vg_utdprogram, utd_fullfoertkode, vg_kompetanse_nus and utd_aktivitet_start.””” return (

(df[“nus2000”].str[0] == “6”) & (df[“utd_fullfoertkode”] == FULLFOERTKODE) & (df[“utd_klassetrinn”].astype(“Int64”).isin([15, 16])) & (

~df[“uh_gruppering_nus”].isin([“01”, “02”])

) # Ikke “Forberedende prøver”, eller “Lavere nivås utdanning”

).astype(BOOL_DTYPE)

uh_ermaster_fullfoert(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’, ‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_ermaster_fullfoert values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_ermaster_fullfoert added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_ermaster_fullfoert from nus2000, utd_fullfoertkode.

Base Function Source Code:

@wrap_derive def uh_ermaster_fullfoert( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive uh_ermaster_fullfoert from nus2000, utd_fullfoertkode.””” return (

(df[“nus2000”].str[0] == “7”) & (df[“utd_fullfoertkode”] == FULLFOERTKODE)

).astype(BOOL_DTYPE)

vg_erstudiespess_fullfoert(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’, ‘nus2000’, ‘vg_utdprogram’, ‘vg_kompetanse_nus’, ‘utd_aktivitet_start’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_erstudiespess_fullfoert values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_erstudiespess_fullfoert added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_erstudiespess_fullfoert from nus2000, vg_utdprogram, utd_fullfoertkode, vg_kompetanse_nus and utd_aktivitet_start.

Base Function Source Code:

@wrap_derive def vg_erstudiespess_fullfoert( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive vg_erstudiespess_fullfoert from nus2000, vg_utdprogram, utd_fullfoertkode, vg_kompetanse_nus and utd_aktivitet_start.””” raise_vg_utdprogram_outside_ranges(df[“vg_utdprogram”]) return (

vg_ervgo_fullfoert(df)[“vg_ervgo_fullfoert”] & (df[“vg_utdprogram”].isin(PRG_RANGES[“studiespess”]))

).astype(BOOL_DTYPE)

vg_ervgo_fullfoert(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’, ‘nus2000’, ‘vg_kompetanse_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_ervgo_fullfoert values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_ervgo_fullfoert added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_ervgo_fullfoert from nus2000, utd_fullfoertkode, vg_kompetanse_nus and utd_aktivitet_start.

Base Function Source Code:

@wrap_derive def vg_ervgo_fullfoert( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive vg_ervgo_fullfoert from nus2000, utd_fullfoertkode, vg_kompetanse_nus and utd_aktivitet_start.””” return (

(df[“nus2000”].str[0].isin([“4”, “5”])) & (df[“utd_fullfoertkode”] == FULLFOERTKODE) & (

(df[“vg_kompetanse_nus”].isin([“1”, “2”, “3”, “5”])) | (

df[“utd_aktivitet_start”] < datetime.datetime.strptime(“2000-08-01”, r”%Y-%m-%d”)

) # Komp ikke utylt før 2000?

)

).astype(BOOL_DTYPE)

vg_eryrkesfag_fullfoert(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’, ‘nus2000’, ‘vg_utdprogram’, ‘vg_kompetanse_nus’, ‘utd_aktivitet_start’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_eryrkesfag_fullfoert values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_eryrkesfag_fullfoert added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_eryrkesfag_fullfoert from nus2000, vg_utdprogram, utd_fullfoertkode, vg_kompetanse_nus and utd_aktivitet_start.

Base Function Source Code:

@wrap_derive def vg_eryrkesfag_fullfoert( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive vg_eryrkesfag_fullfoert from nus2000, vg_utdprogram, utd_fullfoertkode, vg_kompetanse_nus and utd_aktivitet_start.””” raise_vg_utdprogram_outside_ranges(df[“vg_utdprogram”]) return (

vg_ervgo_fullfoert(df)[“vg_ervgo_fullfoert”] & (df[“vg_utdprogram”].isin(PRG_RANGES[“yrkesfag”]))

).astype(BOOL_DTYPE)

nudb_use.variables.derive.fullfoert_foerste module

gr_foerste_fullfoert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing gr_foerste_fullfoert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gr_foerste_fullfoert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gr_foerste_fullfoert_dato from avslutta.

Args:

df: Source dataset containing at least snr, gr_ergrunnskole_fullfoert, utd_aktivitet_slutt.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

uh_bachelor_foerste_fullfoert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_bachelor_foerste_fullfoert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_bachelor_foerste_fullfoert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_bachelor_foerste_fullfoert_dato from avslutta.

Args:

df: Source dataset containing at least snr, uh_erbachelor_fullfoert, utd_aktivitet_slutt.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

uh_doktorgrad_foerste_fullfoert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_doktorgrad_foerste_fullfoert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_doktorgrad_foerste_fullfoert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_doktorgrad_foerste_fullfoert_dato from avslutta.

Args:

df: Source dataset containing at least snr, uh_erdoktorgrad_fullfoert, utd_aktivitet_slutt.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

uh_hoeyskolekandidat_foerste_fullfoert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_hoeyskolekandidat_foerste_fullfoert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_hoeyskolekandidat_foerste_fullfoert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_hoeyskolekandidat_foerste_fullfoert_dato from avslutta.

Args:

df: Source dataset containing at least snr, uh_erhoeyskolekandidat_fullfoert, utd_aktivitet_slutt.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

uh_master_foerste_fullfoert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_master_foerste_fullfoert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_master_foerste_fullfoert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_master_foerste_fullfoert_dato from avslutta.

Args:

df: Source dataset containing at least snr, uh_ermaster_fullfoert, utd_aktivitet_slutt.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

vg_foerste_fullfoert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_foerste_fullfoert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_foerste_fullfoert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_foerste_fullfoert_dato from avslutta.

Args:

df: Source dataset containing at least snr, vg_ervgo_fullfoert, utd_aktivitet_slutt.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

vg_studiespess_foerste_fullfoert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_studiespess_foerste_fullfoert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_studiespess_foerste_fullfoert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_studiespess_foerste_fullfoert_dato from avslutta.

Args:

df: Source dataset containing at least snr, vg_erstudiespess_fullfoert, utd_aktivitet_slutt.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

vg_yrkesfag_foerste_fullfoert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_yrkesfag_foerste_fullfoert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_yrkesfag_foerste_fullfoert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_yrkesfag_foerste_fullfoert_dato from avslutta.

Args:

df: Source dataset containing at least snr, vg_eryrkesfag_fullfoert, utd_aktivitet_slutt.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

nudb_use.variables.derive.klass_correspondences_and_variants module

fa_erfagskole_nokut_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing fa_erfagskole_nokut_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with fa_erfagskole_nokut_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘fa_erfagskole_nokut_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

fa_studiepoeng_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing fa_studiepoeng_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with fa_studiepoeng_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘fa_studiepoeng_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

uh_gradmerke_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_gradmerke_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_gradmerke_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘uh_gradmerke_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

uh_gruppering_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_gruppering_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_gruppering_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘uh_gruppering_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

uh_studiepoeng_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_studiepoeng_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_studiepoeng_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘uh_studiepoeng_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

utd_foreldet_kode_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_foreldet_kode_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_foreldet_kode_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘utd_foreldet_kode_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

utd_isced2011_attainment_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_isced2011_attainment_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_isced2011_attainment_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘utd_isced2011_attainment_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_correspondence(

df, corresponds_to=derived_from[0], varname=varname

)

utd_isced2011_programmes_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_isced2011_programmes_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_isced2011_programmes_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘utd_isced2011_programmes_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_correspondence(

df, corresponds_to=derived_from[0], varname=varname

)

utd_isced2013_fagfelt_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_isced2013_fagfelt_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_isced2013_fagfelt_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘utd_isced2013_fagfelt_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_correspondence(

df, corresponds_to=derived_from[0], varname=varname

)

utd_klassetrinn_lav_hoey_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_klassetrinn_lav_hoey_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_klassetrinn_lav_hoey_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘utd_klassetrinn_lav_hoey_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

utd_samle_eller_enkeltutd_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_samle_eller_enkeltutd_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_samle_eller_enkeltutd_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘utd_samle_eller_enkeltutd_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

utd_utdanningsprogram_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_utdanningsprogram_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_utdanningsprogram_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘utd_utdanningsprogram_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

utd_varighet_antall_mnd_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_varighet_antall_mnd_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_varighet_antall_mnd_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘utd_varighet_antall_mnd_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

vg_kompetanse_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_kompetanse_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_kompetanse_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘vg_kompetanse_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

vg_kurstrinn_nus(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_kurstrinn_nus values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_kurstrinn_nus added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive ‘vg_kurstrinn_nus’ from ‘[‘nus2000’]’.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

return _map_klass_variant(df, variant_of=derived_from[0], varname=varname)

nudb_use.variables.derive.klass_labels module

bof_eierforhold_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘bof_eierforhold’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing bof_eierforhold_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with bof_eierforhold_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive bof_eierforhold_label, with klass labels for bof_eierforhold.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

fa_erfagskole_nokut_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘fa_erfagskole_nokut_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing fa_erfagskole_nokut_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with fa_erfagskole_nokut_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive fa_erfagskole_nokut_nus_label, with klass labels for fa_erfagskole_nokut_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

fa_studiepoeng_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘fa_studiepoeng_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing fa_studiepoeng_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with fa_studiepoeng_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive fa_studiepoeng_nus_label, with klass labels for fa_studiepoeng_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

fuh_nett_eller_stedbasert_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘fuh_nett_eller_stedbasert’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing fuh_nett_eller_stedbasert_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with fuh_nett_eller_stedbasert_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive fuh_nett_eller_stedbasert_label, with klass labels for fuh_nett_eller_stedbasert.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

fuh_opptaksgrunnlag_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘fuh_opptaksgrunnlag’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing fuh_opptaksgrunnlag_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with fuh_opptaksgrunnlag_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive fuh_opptaksgrunnlag_label, with klass labels for fuh_opptaksgrunnlag.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

fuh_utvekslingsland_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘fuh_utvekslingsland’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing fuh_utvekslingsland_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with fuh_utvekslingsland_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive fuh_utvekslingsland_label, with klass labels for fuh_utvekslingsland.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_elevstatus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_elevstatus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_elevstatus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_elevstatus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_elevstatus_label, with klass labels for gro_elevstatus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_fagstatus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_fagstatus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_fagstatus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_fagstatus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_fagstatus_label, with klass labels for gro_fagstatus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_karakter_muntlig_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_karakter_muntlig’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_karakter_muntlig_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_karakter_muntlig_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_karakter_muntlig_label, with klass labels for gro_karakter_muntlig.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_karakter_praktisk_muntlig_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_karakter_praktisk_muntlig’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_karakter_praktisk_muntlig_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_karakter_praktisk_muntlig_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_karakter_praktisk_muntlig_label, with klass labels for gro_karakter_praktisk_muntlig.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_karakter_skriftlig_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_karakter_skriftlig’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_karakter_skriftlig_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_karakter_skriftlig_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_karakter_skriftlig_label, with klass labels for gro_karakter_skriftlig.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_karakter_standpunkt_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_karakter_standpunkt’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_karakter_standpunkt_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_karakter_standpunkt_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_karakter_standpunkt_label, with klass labels for gro_karakter_standpunkt.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_karakter_termin1_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_karakter_termin1’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_karakter_termin1_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_karakter_termin1_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_karakter_termin1_label, with klass labels for gro_karakter_termin1.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_karakter_termin2_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_karakter_termin2’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_karakter_termin2_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_karakter_termin2_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_karakter_termin2_label, with klass labels for gro_karakter_termin2.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

gro_karakterstatus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘gro_karakterstatus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gro_karakterstatus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gro_karakterstatus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gro_karakterstatus_label, with klass labels for gro_karakterstatus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

nus2000_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing nus2000_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with nus2000_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive nus2000_label, with klass labels for nus2000.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_bokommune_16aar_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_bokommune_16aar’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_bokommune_16aar_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_bokommune_16aar_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_bokommune_16aar_label, with klass labels for pers_bokommune_16aar.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_bokommune_nr_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_bokommune_nr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_bokommune_nr_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_bokommune_nr_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_bokommune_nr_label, with klass labels for pers_bokommune_nr.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_bydel_nr_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_bydel_nr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_bydel_nr_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_bydel_nr_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_bydel_nr_label, with klass labels for pers_bydel_nr.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_foedeland_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_foedeland’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_foedeland_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_foedeland_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_foedeland_label, with klass labels for pers_foedeland.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_fra_land_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_fra_land’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_fra_land_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_fra_land_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_fra_land_label, with klass labels for pers_fra_land.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_gkrets_nr_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_gkrets_nr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_gkrets_nr_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_gkrets_nr_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_gkrets_nr_label, with klass labels for pers_gkrets_nr.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_inngrunn1_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_inngrunn1’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_inngrunn1_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_inngrunn1_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_inngrunn1_label, with klass labels for pers_inngrunn1.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_invkat_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_invkat’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_invkat_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_invkat_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_invkat_label, with klass labels for pers_invkat.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_kjoenn_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_kjoenn’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_kjoenn_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_kjoenn_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_kjoenn_label, with klass labels for pers_kjoenn.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_landbak3gen_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_landbak3gen’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_landbak3gen_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_landbak3gen_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_landbak3gen_label, with klass labels for pers_landbak3gen.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

pers_statsborgerskap_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘pers_statsborgerskap’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_statsborgerskap_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_statsborgerskap_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_statsborgerskap_label, with klass labels for pers_statsborgerskap.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_campus_kommune_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_campus_kommune’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_campus_kommune_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_campus_kommune_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_campus_kommune_label, with klass labels for uh_campus_kommune.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_foerste_nus2000_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_foerste_nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_foerste_nus2000_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_foerste_nus2000_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_foerste_nus2000_label, with klass labels for uh_foerste_nus2000.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_fullfoertkode_inn_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_fullfoertkode_inn’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_fullfoertkode_inn_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_fullfoertkode_inn_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_fullfoertkode_inn_label, with klass labels for uh_fullfoertkode_inn.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_gradmerke_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_gradmerke_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_gradmerke_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_gradmerke_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_gradmerke_nus_label, with klass labels for uh_gradmerke_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_gruppering_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_gruppering_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_gruppering_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_gruppering_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_gruppering_nus_label, with klass labels for uh_gruppering_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_institusjon_id_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_institusjon_id’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_institusjon_id_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_institusjon_id_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_institusjon_id_label, with klass labels for uh_institusjon_id.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_statsborgerskap_inn_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_statsborgerskap_inn’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_statsborgerskap_inn_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_statsborgerskap_inn_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_statsborgerskap_inn_label, with klass labels for uh_statsborgerskap_inn.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_studgrunnlagsland_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_studgrunnlagsland’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_studgrunnlagsland_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_studgrunnlagsland_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_studgrunnlagsland_label, with klass labels for uh_studgrunnlagsland.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_studiepoeng_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_studiepoeng_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_studiepoeng_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_studiepoeng_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_studiepoeng_nus_label, with klass labels for uh_studiepoeng_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_studierett_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_studierett’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_studierett_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_studierett_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_studierett_label, with klass labels for uh_studierett.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

uh_univ_eller_hoegskole_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘uh_univ_eller_hoegskole’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_univ_eller_hoegskole_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_univ_eller_hoegskole_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_univ_eller_hoegskole_label, with klass labels for uh_univ_eller_hoegskole.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_aktivitetsnivaa_heltid_deltid_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_aktivitetsnivaa_heltid_deltid’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_aktivitetsnivaa_heltid_deltid_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_aktivitetsnivaa_heltid_deltid_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_aktivitetsnivaa_heltid_deltid_label, with klass labels for utd_aktivitetsnivaa_heltid_deltid.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_datakilde_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_datakilde’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_datakilde_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_datakilde_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_datakilde_label, with klass labels for utd_datakilde.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_foreldet_kode_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_foreldet_kode_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_foreldet_kode_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_foreldet_kode_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_foreldet_kode_nus_label, with klass labels for utd_foreldet_kode_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_foreldres_utdnivaa_16aar_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_foreldres_utdnivaa_16aar’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_foreldres_utdnivaa_16aar_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_foreldres_utdnivaa_16aar_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_foreldres_utdnivaa_16aar_label, with klass labels for utd_foreldres_utdnivaa_16aar.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_fullfoertkode_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_fullfoertkode’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_fullfoertkode_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_fullfoertkode_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_fullfoertkode_label, with klass labels for utd_fullfoertkode.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_hoeyeste_nus2000_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_hoeyeste_nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_hoeyeste_nus2000_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_hoeyeste_nus2000_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_hoeyeste_nus2000_label, with klass labels for utd_hoeyeste_nus2000.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_isced2011_attainment_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_isced2011_attainment_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_isced2011_attainment_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_isced2011_attainment_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_isced2011_attainment_nus_label, with klass labels for utd_isced2011_attainment_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_isced2011_programmes_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_isced2011_programmes_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_isced2011_programmes_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_isced2011_programmes_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_isced2011_programmes_nus_label, with klass labels for utd_isced2011_programmes_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_isced2013_fagfelt_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_isced2013_fagfelt_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_isced2013_fagfelt_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_isced2013_fagfelt_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_isced2013_fagfelt_nus_label, with klass labels for utd_isced2013_fagfelt_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_klassetrinn_lav_hoey_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_klassetrinn_lav_hoey_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_klassetrinn_lav_hoey_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_klassetrinn_lav_hoey_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_klassetrinn_lav_hoey_nus_label, with klass labels for utd_klassetrinn_lav_hoey_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_samle_eller_enkeltutd_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_samle_eller_enkeltutd_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_samle_eller_enkeltutd_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_samle_eller_enkeltutd_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_samle_eller_enkeltutd_nus_label, with klass labels for utd_samle_eller_enkeltutd_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_skolekom_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_skolekom’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_skolekom_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_skolekom_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_skolekom_label, with klass labels for utd_skolekom.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_studieland_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_studieland’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_studieland_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_studieland_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_studieland_label, with klass labels for utd_studieland.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_utdanningsprogram_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_utdanningsprogram_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_utdanningsprogram_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_utdanningsprogram_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_utdanningsprogram_nus_label, with klass labels for utd_utdanningsprogram_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_utdanningstype_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_utdanningstype’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_utdanningstype_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_utdanningstype_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_utdanningstype_label, with klass labels for utd_utdanningstype.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_utveksling_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_utveksling’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_utveksling_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_utveksling_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_utveksling_label, with klass labels for utd_utveksling.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_varighet_antall_mnd_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_varighet_antall_mnd_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_varighet_antall_mnd_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_varighet_antall_mnd_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_varighet_antall_mnd_nus_label, with klass labels for utd_varighet_antall_mnd_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

utd_viderutd_nettbasert_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_viderutd_nettbasert’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_viderutd_nettbasert_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_viderutd_nettbasert_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_viderutd_nettbasert_label, with klass labels for utd_viderutd_nettbasert.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_bevistype_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_bevistype’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_bevistype_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_bevistype_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_bevistype_label, with klass labels for vg_bevistype.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_fullfoertkode_detaljert_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_fullfoertkode_detaljert’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_fullfoertkode_detaljert_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_fullfoertkode_detaljert_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_fullfoertkode_detaljert_label, with klass labels for vg_fullfoertkode_detaljert.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_kompetanse_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_kompetanse_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_kompetanse_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_kompetanse_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_kompetanse_nus_label, with klass labels for vg_kompetanse_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_kontraktstype_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_kontraktstype’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_kontraktstype_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_kontraktstype_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_kontraktstype_label, with klass labels for vg_kontraktstype.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_kurstrinn_nus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_kurstrinn_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_kurstrinn_nus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_kurstrinn_nus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_kurstrinn_nus_label, with klass labels for vg_kurstrinn_nus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_proevekandtype_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_proevekandtype’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_proevekandtype_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_proevekandtype_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_proevekandtype_label, with klass labels for vg_proevekandtype.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_proevestatus_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_proevestatus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_proevestatus_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_proevestatus_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_proevestatus_label, with klass labels for vg_proevestatus.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_resultat_praktisk_proeve_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_resultat_praktisk_proeve’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_resultat_praktisk_proeve_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_resultat_praktisk_proeve_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_resultat_praktisk_proeve_label, with klass labels for vg_resultat_praktisk_proeve.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_resultat_teori_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_resultat_teori’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_resultat_teori_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_resultat_teori_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_resultat_teori_label, with klass labels for vg_resultat_teori.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_rettstype_inntak_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_rettstype_inntak’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_rettstype_inntak_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_rettstype_inntak_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_rettstype_inntak_label, with klass labels for vg_rettstype_inntak.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_utdprogram_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_utdprogram’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_utdprogram_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_utdprogram_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_utdprogram_label, with klass labels for vg_utdprogram.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

vg_yrkes_og_studiekompetanse_label(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘vg_yrkes_og_studiekompetanse’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_yrkes_og_studiekompetanse_label values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_yrkes_og_studiekompetanse_label added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_yrkes_og_studiekompetanse_label, with klass labels for vg_yrkes_og_studiekompetanse.

Base Function Source Code:

def basefunc(df: pd.DataFrame) -> pd.Series:

mapping = get_klass_label_mapping(variable)

if mapping:

return df[variable].map(mapping)

else:

raise MissingLabelMappingError(

f”Unable to generate label mapping for ‘{variable}’”

)

nudb_use.variables.derive.land module

utd_erutland(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘utd_skolekom’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_erutland values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_erutland added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_erutland from utd_skolekom.

Base Function Source Code:

@wrap_derive def utd_erutland( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive utd_erutland from utd_skolekom.””” utd_erutland: pd.Series = (

df[“utd_skolekom”] .isin([“0025”, “1025”, “2025”, “2400”, “2580”]) .astype(“bool[pyarrow]”)

) return utd_erutland

nudb_use.variables.derive.nus_variants module

nudb_use.variables.derive.person module

pers_bokommune_16aar(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_bokommune_16aar values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_bokommune_16aar added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive bokommune_16aar.

Base Function Source Code:

@wrap_derive def pers_bokommune_16aar( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive bokommune_16aar.””” return _apply_pers320_mapping(

left=df, name360=”pers_bokommune_16aar”, name320=”komm_nr”

)

pers_bokommune_nr(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_bokommune_nr values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_bokommune_nr added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_bokommune_nr.

Base Function Source Code:

@wrap_derive def pers_bokommune_nr( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_bokommune_nr.””” return _apply_pers320_mapping(

left=df, name360=”pers_bokommune_nr”, name320=”komm_nr”

)

pers_bydel_nr(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_bydel_nr values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_bydel_nr added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_bydel_nr.

Base Function Source Code:

@wrap_derive def pers_bydel_nr( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_bydel_nr.””” return _apply_pers320_mapping(left=df, name360=”pers_bydel_nr”, name320=”bydel_nr”)

pers_foedeland(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_foedeland values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_foedeland added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_foedeland.

Base Function Source Code:

@wrap_derive def pers_foedeland( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_foedeland.””” return _apply_pers320_mapping(

left=df, name360=”pers_foedeland”, name320=”foedeland”

)

pers_foedselsdato(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_foedselsdato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_foedselsdato added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_foedselsdato.

Base Function Source Code:

@wrap_derive def pers_foedselsdato( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_foedselsdato.””” return _apply_pers320_mapping(

left=df, name360=”pers_foedselsdato”, name320=”foedselsdato”

)

pers_foerste_bosattdato(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_foerste_bosattdato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_foerste_bosattdato added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_foerste_bosattdato.

Base Function Source Code:

@wrap_derive def pers_foerste_bosattdato( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_foerste_bosattdato.””” return _apply_pers320_mapping(

left=df, name360=”pers_foerste_bosattdato”, name320=”foerste_bosattdato”

)

pers_fra_land(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_fra_land values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_fra_land added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_fra_land.

Base Function Source Code:

@wrap_derive def pers_fra_land( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_fra_land.””” return _apply_pers320_mapping(left=df, name360=”pers_fra_land”, name320=”fra_land”)

pers_gkrets_nr(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_gkrets_nr values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_gkrets_nr added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_gkrets_nr.

Base Function Source Code:

@wrap_derive def pers_gkrets_nr( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_gkrets_nr.””” return _apply_pers320_mapping(

left=df, name360=”pers_gkrets_nr”, name320=”gkrets_nr”

)

pers_innflyttingsdato(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_innflyttingsdato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_innflyttingsdato added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_innflyttingsdato.

Base Function Source Code:

@wrap_derive def pers_innflyttingsdato( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_innflyttingsdato.””” return _apply_pers320_mapping(

left=df, name360=”pers_innflyttingsdato”, name320=”innflyttingsdato”

)

pers_inngrunn1(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_inngrunn1 values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_inngrunn1 added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_inngrunn1.

Base Function Source Code:

@wrap_derive def pers_inngrunn1( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_inngrunn1.””” return _apply_pers320_mapping(

left=df, name360=”pers_inngrunn1”, name320=”inngrunn1”

)

pers_invkat(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_invkat values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_invkat added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_invkat.

Base Function Source Code:

@wrap_derive def pers_invkat( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_invkat.””” return _apply_pers320_mapping(left=df, name360=”pers_invkat”, name320=”invkat”)

pers_kjoenn(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_kjoenn values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_kjoenn added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_kjoenn.

Base Function Source Code:

@wrap_derive def pers_kjoenn( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_kjoenn.””” return _apply_pers320_mapping(left=df, name360=”pers_kjoenn”, name320=”kjoenn”)

pers_landbak3gen(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_landbak3gen values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_landbak3gen added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_landbak3gen.

Base Function Source Code:

@wrap_derive def pers_landbak3gen( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_landbak3gen.””” return _apply_pers320_mapping(

left=df, name360=”pers_landbak3gen”, name320=”landbak3gen”

)

pers_statsborgerskap(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing pers_statsborgerskap values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with pers_statsborgerskap added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive pers_statsborgerskap.

Base Function Source Code:

@wrap_derive def pers_statsborgerskap( # noqa:DOC201

df: pd.DataFrame,

) -> pd.DataFrame:

“””Derive pers_statsborgerskap.””” name360 = “pers_statsborgerskap” name320 = “statsborgerskap”

def _materialize_func(nudbdata: NudbData) -> pd.DataFrame:

query = f”””

SELECT DISTINCT

snr, MAX({name320}) AS {name360} – don’t select 000 for dual citizenship

FROM

{nudbdata.alias}

GROUP BY

snr

“””

result = nudbdata.sql(query).df()

if isinstance(result, pd.DataFrame): # make mypy happy

return result

else:

raise TypeError(“Expected result to be of type pandas.DataFrame!”)

return _apply_pers320_mapping(

left=df, name360=name360, name320=name320, right_materialize_func=_materialize_func,

)

nudb_use.variables.derive.person_idents module

snr_mrk(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing snr_mrk values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with snr_mrk added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive the column snr_mrk from snr-column, True if values in snr_col is notna, has a length of 7 and are wholly alphanumeric.

Base Function Source Code:

@wrap_derive def snr_mrk( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive the column snr_mrk from snr-column, True if values in snr_col is notna, has a length of 7 and are wholly alphanumeric.””” with LoggerStack(“Looking for weird content in the snr column”):

if df[“snr”].str.contains(” “).any():

logger.warning(“Some of your snr contain spaces, why bro?”)

# If there is above the threshold percent snr that are 7 digit snr that contain only numbers, give a warning. # Would indicate that the snrs are not pseudonomized, or that they might be cut off fake snr, probably not UUID because of the hyphens. allnumber_7_digits = (df[“snr”].str.len() == 7) & df[“snr”].str.isnumeric() percent = (

round((allnumber_7_digits.sum() / len(df) * 100), 2) if len(df) else 0.00

) if percent > ALLNUMERIC_7DIGIT_THRESHOLD_PERCENT:

logger.warning(

f”We found {percent}% rows where snr is 7 characters, but contain all digits. This is highly suspicious if you are working with pseudonomized data… Did you cut the column down to 7 characters by mistake somewhere?”

)

with LoggerStack(“Deriving snr_mrk from snr.”):

# This function helps mypy realize that we might reach isascii def is_str(x: object) -> TypeGuard[str]:

return isinstance(x, str)

snr_mrk: pd.Series = (

(df[“snr”].notna()) & (df[“snr”].str.strip().str.len() == 7) & (df[“snr”].str.strip().str.isalnum()) & (

df[“snr”] .str.strip() .apply(lambda x: is_str(x) and x.isascii()) .astype(BOOL_DTYPE)

) # Workaround because isascii is not supported in earlier versions of pandas, isascii fails on NAtypes?

).astype(BOOL_DTYPE) percent = round(snr_mrk.sum() / len(snr_mrk) * 100, 2) if len(snr_mrk) else 0.00 logger.info(

f”{percent}%: {snr_mrk.sum()} of {len(snr_mrk)} rows have valid snr -> snr_mrk.”

)

return snr_mrk

nudb_use.variables.derive.registrert module

gr_ergrunnskole_registrering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’, ‘utd_erutland’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing gr_ergrunnskole_registrering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gr_ergrunnskole_registrering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gr_ergrunnskole_registrering from nus2000 and utland, as a boolean filter for registrations on gr-level.

Base Function Source Code:

@wrap_derive def gr_ergrunnskole_registrering( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive gr_ergrunnskole_registrering from nus2000 and utland, as a boolean filter for registrations on gr-level.””” bool_mask: pd.Series = (

(df[“nus2000”].str[0] == “2”) & (~df[“utd_erutland”])

).astype(BOOL_DTYPE) return bool_mask

uh_erbachelor_registrering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’, ‘uh_gradmerke_nus’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_erbachelor_registrering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_erbachelor_registrering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_erbachelor_registrering from nus2000 as a boolean filter.

Base Function Source Code:

@wrap_derive def uh_erbachelor_registrering( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive uh_erbachelor_registrering from nus2000 as a boolean filter.””” bool_mask: pd.Series = (df[“uh_gradmerke_nus”] == “B”).astype(BOOL_DTYPE) logger.info(type(bool_mask)) logger.info(bool_mask) return bool_mask

uh_erhoeyereutd_registrering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_erhoeyereutd_registrering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_erhoeyereutd_registrering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_erhoeyereutd_registrering from nus2000 as a boolean filter.

Base Function Source Code:

@wrap_derive def uh_erhoeyereutd_registrering( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive uh_erhoeyereutd_registrering from nus2000 as a boolean filter.””” bool_mask: pd.Series = (df[“nus2000”].str[0].isin([“6”, “7”, “8”])).astype(

BOOL_DTYPE

) return bool_mask

uh_ermaster_registrering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_ermaster_registrering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_ermaster_registrering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_erbachelor_registrering from nus2000 as a boolean filter.

Base Function Source Code:

@wrap_derive def uh_ermaster_registrering( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive uh_erbachelor_registrering from nus2000 as a boolean filter.””” bool_mask: pd.Series = (df[“nus2000”].str[0] == “7”).astype(BOOL_DTYPE) return bool_mask

vg_erstudiespess_registrering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’, ‘vg_utdprogram’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_erstudiespess_registrering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_erstudiespess_registrering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_erstudiespess_registrering from nus2000 and vg_utdprogram, as a boolean filter.

Base Function Source Code:

@wrap_derive def vg_erstudiespess_registrering( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive vg_erstudiespess_registrering from nus2000 and vg_utdprogram, as a boolean filter.””” raise_vg_utdprogram_outside_ranges(df[“vg_utdprogram”]) bool_mask: pd.Series = (

(df[“nus2000”].str[0].isin([“3”, “4”])) & (df[“vg_utdprogram”].isin(PRG_RANGES[“studiespess”]))

).astype(BOOL_DTYPE) return bool_mask

vg_ervgo_erutdprogram_registrering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’, ‘vg_utdprogram’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_ervgo_erutdprogram_registrering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_ervgo_erutdprogram_registrering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_ervgo_erutdprogram_registrering from nus2000 and vg_utdprogram, as a boolean filter for registrations on vg-level.

Base Function Source Code:

@wrap_derive def vg_ervgo_erutdprogram_registrering( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive vg_ervgo_erutdprogram_registrering from nus2000 and vg_utdprogram, as a boolean filter for registrations on vg-level.””” bool_mask: pd.Series = (

df[“nus2000”].str[0].isin([“3”, “4”]).astype(BOOL_DTYPE) & (df[“vg_utdprogram”].notna()) & (df[“vg_utdprogram”].str.strip() != “”)

) return bool_mask

vg_ervgo_registrering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_ervgo_registrering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_ervgo_registrering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_ervgo_registrering from nus2000, as a boolean filter for registrations on vg-level.

Base Function Source Code:

@wrap_derive def vg_ervgo_registrering( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive vg_ervgo_registrering from nus2000, as a boolean filter for registrations on vg-level.””” bool_mask: pd.Series = df[“nus2000”].str[0].isin([“3”, “4”]).astype(BOOL_DTYPE) return bool_mask

vg_eryrkesfag_registrering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’, ‘vg_utdprogram’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_eryrkesfag_registrering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_eryrkesfag_registrering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_eryrkesfag_registrering from nus2000 and vg_utdprogram, as a boolean filter.

Base Function Source Code:

@wrap_derive def vg_eryrkesfag_registrering( # noqa:DOC201

df: pd.DataFrame,

) -> pd.Series:

“””Derive vg_eryrkesfag_registrering from nus2000 and vg_utdprogram, as a boolean filter.””” raise_vg_utdprogram_outside_ranges(df[“vg_utdprogram”]) bool_mask: pd.Series = (

(df[“nus2000”].str[0].isin([“3”, “4”])) & (df[“vg_utdprogram”].isin(PRG_RANGES[“yrkesfag”]))

).astype(BOOL_DTYPE) return bool_mask

nudb_use.variables.derive.registrert_foerste module

gr_foerste_registrert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing gr_foerste_registrert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with gr_foerste_registrert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive gr_foerste_registrert_dato from avslutta.

Args:

df: Source dataset containing at least snr, gr_ergrunnskole_registrering, utd_aktivitet_start.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

uh_bachelor_foerste_registrert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_bachelor_foerste_registrert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_bachelor_foerste_registrert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_bachelor_foerste_registrert_dato from avslutta.

Args:

df: Source dataset containing at least snr, uh_erbachelor_registrering, utd_aktivitet_start.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

uh_foerste_nus2000(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_foerste_nus2000 values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_foerste_nus2000 added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive the first nus2000 a person has on UH-level.

Args:

df: Source dataset containing at least snr, nus2000, utd_aktivitet_start.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

uh_foerste_registrert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_foerste_registrert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_foerste_registrert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_foerste_registrert_dato from avslutta.

Args:

df: Source dataset containing at least snr, uh_erhoeyereutd_registrering, utd_aktivitet_start.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

uh_master_foerste_registrert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing uh_master_foerste_registrert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with uh_master_foerste_registrert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive uh_master_foerste_registrert_dato from avslutta.

Args:

df: Source dataset containing at least snr, uh_ermaster_registrering, utd_aktivitet_start.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

vg_foerste_registrert_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_foerste_registrert_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_foerste_registrert_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_foerste_registrert_dato from avslutta.

Args:

df: Source dataset containing at least snr, vg_ervgo_registrering, utd_aktivitet_start.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

vg_foerste_registrert_erutdprogram_dato(df=None, priority='old', temp_col_renames=None, *args, **kwargs)

Parameters:

• df (DataFrame | None) – Dataframe that we should merge the variable data onto.

• priority (Literal['old', 'new']) – ‘old’ keeps existing vg_foerste_registrert_erutdprogram_dato values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None) – Temporary source-to-prerequisite rename mapping passed through to wrap_derive.

• args (~P)

• kwargs (~P)

Returns:

The dataframe with vg_foerste_registrert_erutdprogram_dato added/updated.

Return type:

pd.DataFrame

Base Function Documentation:

Derive vg_foerste_registrert_dato from avslutta.

Args:

df: Source dataset containing at least snr, vg_ervgo_erstudretn_registrering, utd_aktivitet_start.

Returns:

pd.DataFrame: A column suitable for adding as a new column to the df.

Base Function Source Code:

def subfunc(

df: pd.DataFrame | None = None, priority: Literal[“old”, “new”] = “old”, temp_col_renames: dict[str, str] | None = None, *args: P.args, **kwargs: P.kwargs,

) -> pd.DataFrame:

with LoggerStack(f”Deriving variable {name}, using whole NUDB-datasets.”):

source_data = get_source_data(name, df)

basefunc_wrapped = wrap_derive(basefunc) derived_source = basefunc_wrapped(

source_data, *args, priority=priority, temp_col_renames=temp_col_renames, **kwargs,

)

if df is None:

logger.warning(“data is None, why u do this?”) return derived_source

try:

return join_variable_data(name, derived_source, df)

except Exception:

logger.warning(f”Unable to join {name} onto data! Returning as is…”) return df

nudb_use.variables.derive.uh_univ_eller_hoegskole module

nudb_use.variables.derive.utd_foreldres_utdnivaa module

utd_foreldres_utdnivaa_16aar(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’, ‘utd_foreldres_utdnivaa_16aar_nus2000’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_foreldres_utdnivaa_16aar values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_foreldres_utdnivaa_16aar added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_foreldres_utdnivaa_16aar.

Base Function Source Code:

@wrap_derive def utd_foreldres_utdnivaa_16aar(df: pd.DataFrame) -> pd.DataFrame:

“””Derive utd_foreldres_utdnivaa_16aar.””” sosbak_map = { # Matches this codelist in klass https://www.ssb.no/klass/klassifikasjoner/227/koder

“0”: “4”, “1”: “4”, “2”: “4”, “3”: “3”, “4”: “3”, “5”: “3”, “6”: “2”, “7”: “1”, “8”: “1”,

} df[“utd_foreldres_utdnivaa_16aar”] = (

df[“utd_foreldres_utdnivaa_16aar_nus2000”].str[0].map(sosbak_map).fillna(“9”)

) return df

utd_foreldres_utdnivaa_16aar_nus2000(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_foreldres_utdnivaa_16aar_nus2000 values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_foreldres_utdnivaa_16aar_nus2000 added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_foreldres_utdnivaa_16aar_nus2000.

Base Function Source Code:

@wrap_derive def utd_foreldres_utdnivaa_16aar_nus2000(df: pd.DataFrame) -> pd.Series:

“””Derive utd_foreldres_utdnivaa_16aar_nus2000.””” return _derive_utd_foreldres_utdnivaa_var(

df, varname=”utd_foreldres_utdnivaa_16aar_nus2000”

)

utd_hoeyeste_far_nus2000(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_hoeyeste_far_nus2000 values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_hoeyeste_far_nus2000 added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_hoeyeste_far_nus2000.

Base Function Source Code:

@wrap_derive def utd_hoeyeste_far_nus2000(df: pd.DataFrame) -> pd.Series:

“””Derive utd_hoeyeste_far_nus2000.””” return _derive_utd_foreldres_utdnivaa_var(df, varname=”utd_hoeyeste_far_nus2000”)

utd_hoeyeste_mor_nus2000(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_hoeyeste_mor_nus2000 values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_hoeyeste_mor_nus2000 added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_hoeyeste_mor_nus2000.

Base Function Source Code:

@wrap_derive def utd_hoeyeste_mor_nus2000(df: pd.DataFrame) -> pd.Series:

“””Derive utd_hoeyeste_mor_nus2000.””” return _derive_utd_foreldres_utdnivaa_var(df, varname=”utd_hoeyeste_mor_nus2000”)

nudb_use.variables.derive.utd_hoeyeste module

utd_hoeyeste_nus2000(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘snr’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_hoeyeste_nus2000 values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_hoeyeste_nus2000 added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_hoyeste_nus2000.

Base Function Source Code:

@wrap_derive def utd_hoeyeste_nus2000(df: pd.DataFrame, year_col: str | None = None) -> pd.Series:

“””Derive utd_hoyeste_nus2000.””” df = df.copy()

varname = “utd_hoeyeste_nus2000” if varname in df.columns:

logger.warning(

f’{varname} already exists… If priority=”old” some values might not get updated!’

) df = df.drop(columns=varname)

year_col_right = “utd_hoeyeste_aar” if not year_col:

year_col = year_col_right df[year_col] = dt.datetime.now().year

df[“snr”] = df[“snr”].astype(STRING_DTYPE) df[year_col_right] = df[year_col].astype(INTEGER_DTYPE)

utd_hoeyeste = NudbData(“utd_hoeyeste”)

con = nudb_database.get_connection() con.register(“_tmp_df”, df[[“snr”, year_col_right]].drop_duplicates())

mapping = con.sql(f”””

SELECT DISTINCT

T1.snr, T1.{year_col_right}, T2.utd_hoeyeste_nus2000 AS {varname}

FROM

_tmp_df AS T1

ASOF LEFT JOIN

{utd_hoeyeste.alias} AS T2

ON

T1.snr = T2.snr AND T2.{year_col_right} <= T1.{year_col_right};

“””).df()

result = df.merge(

right=mapping, on=[“snr”, year_col_right], how=”left”, validate=”m:1”

)

if result.shape[0] > df.shape[0]:

logger.warning(

f”Number of observations grew from {df.shape[0]} to {result.shape[0]}!”

)

elif result.shape[0] < df.shape[0]:

logger.warning(

f”Number of observations decreased from {df.shape[0]} to {result.shape[0]}!”

)

return result[varname]

utd_hoeyeste_rangering(df, priority='old', temp_col_renames=None, raise_errors=False, *args, **kwargs)

Parameters:

• df (DataFrame) – Dataframe that should contain prerequisites listed in [‘nus2000’, ‘utd_klassetrinn’, ‘uh_gruppering_nus’, ‘utd_skoleaar_start’, ‘uh_eksamen_studpoeng’, ‘uh_eksamen_dato’, ‘utd_aktivitet_slutt’].

• priority (Literal['old', 'new']) – ‘old’ keeps existing utd_hoeyeste_rangering values when present, ‘new’ prefers freshly derived values.

• temp_col_renames (dict[str, str] | None)

• raise_errors (bool)

• args (~P)

• kwargs (~P)

Returns:

The dataframe with utd_hoeyeste_rangering added/updated when all prerequisites are available.

Return type:

pd.DataFrame

Base Function Documentation:

Derive utd_hoyeste_rangering.

Base Function Source Code:

@wrap_derive def utd_hoeyeste_rangering(df: pd.DataFrame) -> pd.Series:

“””Derive utd_hoyeste_rangering.””” df = df.reset_index(drop=True).reset_index(

names=”__index_level_0”

) # drop twice in case of MultiIndex… con = nudb_database.get_connection() con.register(“tmp_df_rangering”, df)

result = con.sql(“””

SELECT

UTD_HOEYESTE_RANGERING(

nus2000, uh_eksamen_dato, uh_eksamen_studpoeng, uh_gruppering_nus, utd_aktivitet_slutt, utd_klassetrinn, utd_skoleaar_start

) AS rangering

FROM

tmp_df_rangering

ORDER BY

__index_level_0 ASC;

“””).df()

return result[“rangering”]

nudb_use.variables.derive.utd_skoleaar module