ebm 0.99.3__py3-none-any.whl

ebm/model/building_category.py

@@ -0,0 +1,150 @@
+import typing
+from enum import unique, StrEnum, EnumType
+
+import pandas as pd
+from loguru import logger
+
+RESIDENTIAL = 'residential'
+NON_RESIDENTIAL = 'non_residential'
+
+
+class MyEnumType(EnumType):
+    def __contains__(cls, value):
+        return value in cls._value2member_map_
+
+
+@unique
+class BuildingCategory(StrEnum, metaclass=MyEnumType):
+    HOUSE = 'house'
+    APARTMENT_BLOCK = 'apartment_block'
+    KINDERGARTEN = 'kindergarten'
+    SCHOOL = 'school'
+    UNIVERSITY = 'university'
+    OFFICE = 'office'
+    RETAIL = 'retail'
+    HOTEL = 'hotel'
+    HOSPITAL = 'hospital'
+    NURSING_HOME = 'nursing_home'
+    CULTURE = 'culture'
+    SPORTS = 'sports'
+    STORAGE = 'storage_repairs'
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}.{self.name}'
+
+    def yearly_construction_floor_area(self):
+        logger.warning('Using static yearly_construction_floor_area')
+        raise NotImplementedError(f'yearly_construction_floor_area does not support category {self.name} (yet)')
+
+    def is_residential(self) -> bool:
+        return self == BuildingCategory.HOUSE or self == BuildingCategory.APARTMENT_BLOCK
+
+    def is_non_residential(self) -> bool:
+        return not self.is_residential()
+
+    @staticmethod
+    def from_string(category_name: str) -> 'BuildingCategory':
+        """Create an enum object from category name
+        Args:
+            category_name (str)
+
+        Returns:
+              building_category (BuildingCategory (Enum))
+
+        Raises:
+            ValueError: category_name not found in BuildingCategory
+        """
+        search = category_name.lower().replace(' ', '').replace('_', '')
+        for building_category in iter(BuildingCategory):
+            if search == building_category.value.lower().replace('_', ''):
+                return building_category
+        raise ValueError(f'No such building category {category_name}')
+
+def from_norsk(norsk: str) -> BuildingCategory:
+    if norsk.lower() == 'småhus':
+        return BuildingCategory.HOUSE
+    if norsk.lower()  in ('leilighet', 'boligblokk'):
+        return BuildingCategory.APARTMENT_BLOCK
+    if norsk.lower() == 'barnehage':
+        return BuildingCategory.KINDERGARTEN
+    if norsk.lower() == 'kontor':
+        return BuildingCategory.OFFICE
+    if norsk.lower() == 'skole':
+        return BuildingCategory.SCHOOL
+    if norsk.lower() == 'universitet':
+        return BuildingCategory.UNIVERSITY
+    if norsk.lower() == 'sykehjem':
+        return BuildingCategory.NURSING_HOME
+    if norsk.lower() == 'sykehus':
+        return BuildingCategory.HOSPITAL
+    if norsk.lower() == 'hotell':
+        return BuildingCategory.HOTEL
+    if norsk.lower() == 'idrettsbygg':
+        return BuildingCategory.SPORTS
+    if norsk.lower() == 'forretningsbygg':
+        return BuildingCategory.RETAIL
+    if norsk.lower() == 'kulturbygg':
+        return BuildingCategory.CULTURE
+    return BuildingCategory.from_string(norsk)
+
+
+def expand_building_category(row: pd.Series) -> pd.DataFrame:
+    """
+        Expand a row of data based on the building category into multiple rows,
+        each representing a specific sub-category of either residential or non-residential buildings.
+
+        Parameters
+        ----------
+        row : pd.Series
+            A pandas Series containing the data for a single row, including a 'building_category' field.
+
+        Returns
+        -------
+        pd.DataFrame
+            A DataFrame with expanded rows for each sub-category of the building category.
+    """
+    if row['building_category'] in BuildingCategory:
+        return pd.DataFrame([row.to_dict()])
+    if row['building_category'] == NON_RESIDENTIAL:
+        categories = [b for b in BuildingCategory if b.is_non_residential()]
+    elif row['building_category'] == RESIDENTIAL:
+        categories = [b for b in BuildingCategory if b.is_residential()]
+
+    values = {k: [v] * len(categories) for k, v in row.to_dict().items() if k != 'building_category'}
+
+    return pd.DataFrame({
+        'building_category': categories,
+        **values
+    })
+
+
+# Apply the function to each row and concatenate the results
+def expand_building_categories(df: pd.DataFrame, unique_columns: typing.List[str] = None):
+    """
+    Transform input dataframe so that building_category within groups (residential/non-residential) are unpacked
+    into all containing categories. Duplicates categories are removed. Specific categories with values area
+    preferred over category groups when there is a conflict.
+
+    Parameters
+    ----------
+    df : pandas.core.frame.DataFrame
+    unique_columns : str
+        list of column names that should be treated as joint unique. default: ['building_category']
+
+
+    Returns
+    -------
+    pandas.core.frame.DataFrame
+    """
+    if unique_columns:
+        df = df.drop_duplicates(subset=unique_columns, ignore_index=True, keep='last')
+    groups = df[df.building_category.isin([RESIDENTIAL, NON_RESIDENTIAL])]
+    specific = df[~df.building_category.isin(groups.building_category)]
+
+    expanded_groups = [expand_building_category(row) for _, row in groups.iterrows()]
+
+    filtered = [d[~d.building_category.isin(specific.building_category)] for d in expanded_groups]
+
+    return pd.concat(filtered + [specific]).reindex()
+
+

ebm/model/building_condition.py

@@ -0,0 +1,78 @@
+import typing
+
+from enum import StrEnum, unique, auto
+
+
+@unique
+class BuildingCondition(StrEnum):
+    ORIGINAL_CONDITION = auto()
+    SMALL_MEASURE = auto()
+    RENOVATION = auto()
+    RENOVATION_AND_SMALL_MEASURE = auto()
+    DEMOLITION = auto()
+
+    @classmethod
+    def _missing_(cls, value: str):
+        """
+        Attempts to create an enum member from a given value by normalizing the string.
+
+        This method is called when a value is not found in the enumeration. It converts the input value 
+        to lowercase, replaces spaces and hyphens with underscores, and then checks if this transformed 
+        value matches the value of any existing enum member.
+
+        Parameters:
+        - value (str): The input value to convert and check against existing enum members.
+
+        Returns:
+        - Enum member: The corresponding enum member if a match is found.
+
+        Raises:
+        - ValueError: If no matching enum member is found.
+        """
+        value = value.lower().replace(' ', '_').replace('-', '_')
+        for member in cls:
+            if member.value == value:
+                return member
+        return ValueError(f'No such building condition: {value}')
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}.{self.name}'
+
+    @staticmethod
+    def get_scruve_condition_list() -> typing.List[str]:
+        """
+        Retrieves a list with the building conditions used in S-curve calculations (in lower case). 
+        
+        Returns:
+        - condition_list (list[str]): list of building conditions
+        """
+        condition_list = [BuildingCondition.SMALL_MEASURE.value, BuildingCondition.RENOVATION.value, BuildingCondition.DEMOLITION.value]
+        return condition_list
+    
+    @staticmethod
+    def get_full_condition_list() -> typing.List[str]:
+        """
+        Retrieves a list with all building conditions (in lower case).
+        
+        Returns:
+        - condition_list (list[str]): list of building conditions 
+        """
+        condition_list = [condition.value for condition in iter(BuildingCondition)]
+        return condition_list
+
+    @staticmethod
+    def existing_conditions() -> typing.Iterable['BuildingCondition']:
+        """
+        Returns all BuildingCondition except demolition
+
+        Returns
+        -------
+            Iterable of all BuildingCondition except demolition
+        """
+        yield from (b for b in BuildingCondition if b != BuildingCondition.DEMOLITION)
+
+
+if __name__ == '__main__':
+    for building_condition in BuildingCondition:
+        print(building_condition)
+        print(repr(building_condition))

ebm/model/calibrate_energy_requirements.py

@@ -0,0 +1,84 @@
+import pathlib
+import typing
+
+from loguru import logger
+import pandas as pd
+
+from ebm.model.file_handler import FileHandler
+
+
+class EnergyRequirementCalibrationWriter:
+
+    def __init__(self):
+        pass
+
+    def load(self, df: pd.DataFrame, to_file: typing.Union[str, pathlib.Path] = None):
+        logger.debug(f'Save {to_file}')
+        if to_file is None:
+            to_file = pathlib.Path('input') / FileHandler.CALIBRATE_ENERGY_REQUIREMENT
+        file_path: pathlib.Path = to_file if isinstance(to_file, pathlib.Path) else pathlib.Path(to_file)
+        df = df[df['group'].isin(['energy_requirements', 'energy_requirement'])]
+        df = df.rename(columns={'variable': 'purpose'})
+        df = df[['building_category', 'purpose', 'heating_rv_factor']].reset_index(drop=True)
+        if file_path.suffix == '.csv':
+            df.to_csv(file_path, index=False)
+        elif file_path.suffix == '.xlsx':
+            df.to_excel(file_path, index=False)
+        logger.info(f'Wrote {to_file}')
+
+
+class EnergyConsumptionCalibrationWriter:
+    df: pd.DataFrame
+
+    def __init__(self):
+        pass
+
+    def transform(self, df):
+        df = df[df['group'] == 'energy_consumption']
+        df = df[['building_category', 'variable', 'extra', 'heating_rv_factor']].reset_index(drop=True)
+        df = df.rename(columns={'variable': 'to',
+                                'extra': 'from',
+                                'heating_rv_factor': 'factor'}, errors='ignore')
+
+        self.df = df
+        return df
+
+    def load(self, df: pd.DataFrame, to_file: typing.Union[str, pathlib.Path] = None):
+        logger.debug(f'Save {to_file}')
+        if to_file is None:
+            to_file = pathlib.Path('input/calibrate_energy_consumption.xlsx')
+        file_path: pathlib.Path = to_file if isinstance(to_file, pathlib.Path) else pathlib.Path(to_file)
+
+        if file_path.suffix == '.csv':
+            df.to_csv(file_path, index=False)
+        elif file_path.suffix == '.xlsx':
+            df.to_excel(file_path, index=False)
+        logger.info(f'Wrote {to_file}')
+
+
+def transform(heating_rv: pd.Series, heating_rv_factor=None) -> pd.Series:
+    if heating_rv_factor is None:
+        return heating_rv
+    calibrated = heating_rv * heating_rv_factor
+    calibrated.name = heating_rv.name
+    return calibrated
+
+
+class EbmCalibration:
+    energy_requirement_original_condition: pd.Series
+    pass
+
+
+class CalibrationReader:
+    def extract(self) -> pd.Series:
+        pass
+
+    def transform(self) -> pd.Series:
+        pass
+
+    def load(self) -> None:
+        pass
+
+
+class CalibrationWriter:
+    pass

ebm/model/calibrate_heating_systems.py

@@ -0,0 +1,180 @@
+from loguru import logger
+import pandas as pd
+
+from ebm.cmd.run_calculation import calculate_building_category_area_forecast
+from ebm.cmd.run_calculation import calculate_building_category_energy_requirements, calculate_heating_systems
+from ebm.model.data_classes import YearRange
+from ebm.model.building_category import BuildingCategory
+
+from ebm.energy_consumption import (HEATING_RV_BASE_TOTAL, HEATING_RV_PEAK_TOTAL, BASE_LOAD_ENERGY_PRODUCT, PEAK_LOAD_ENERGY_PRODUCT,
+                                    TERTIARY_LOAD_ENERGY_PRODUCT, HEATING_RV_TERTIARY_TOTAL, COOLING_TOTAL, OTHER_TOTAL, DHW_TOTAL,
+                                    DOMESTIC_HOT_WATER_ENERGY_PRODUCT, HEAT_PUMP, HP_ENERGY_SOURCE)
+
+ELECTRICITY = 'Elektrisitet'
+DISTRICT_HEATING = 'Fjernvarme'
+BIO = 'Bio'
+FOSSIL = 'Fossil'
+
+DOMESTIC_HOT_WATER = 'Tappevann'
+
+HEATPUMP_AIR_SOURCE = 'Luft/luft'
+HEATPUMP_WATER_SOUCE = 'Vannbåren varme'
+
+CALIBRATION_YEAR = 2023
+
+model_period = YearRange(2020, 2050)
+start_year = model_period.start
+end_year = model_period.end
+
+
+def extract_area_forecast(database_manager) -> pd.DataFrame:
+    area_forecasts = []
+    for building_category in BuildingCategory:
+        area_forecast_result = calculate_building_category_area_forecast(
+            building_category=building_category,
+            database_manager=database_manager,
+            start_year=start_year,
+            end_year=end_year)
+        area_forecasts.append(area_forecast_result)
+
+    area_forecast = pd.concat(area_forecasts)
+    return area_forecast
+
+
+def extract_energy_requirements(area_forecast: pd.DataFrame, database_manager) -> pd.DataFrame:
+    en_req = calculate_building_category_energy_requirements(
+        building_category=list(BuildingCategory),
+        area_forecast=area_forecast,
+        database_manager=database_manager,
+        start_year=start_year,
+        end_year=end_year)
+
+    return en_req
+
+
+def extract_heating_systems(energy_requirements, database_manager) -> pd.DataFrame:
+    heating_systems = calculate_heating_systems(energy_requirements=energy_requirements,
+                                                database_manager=database_manager)
+
+    # heating_systems[heating_systems['purpose']=='heating_rv']
+    return heating_systems
+
+
+def transform_by_energy_source(df, energy_class_column, energy_source_column):
+    rv_gl = df.loc[:, [energy_class_column, energy_source_column, 'building_group']]
+    rv_gl = rv_gl[rv_gl[energy_class_column] > 0]
+    rv_gl['typ'] = energy_class_column
+    rv_gl = rv_gl.rename(columns={energy_source_column: 'energy_source',
+                                  energy_class_column: 'energy_use'})
+    rv_gl = rv_gl.reset_index().set_index(['building_category',
+                                   'building_condition',
+                                   'purpose',
+                                   'building_code',
+                                   'year',
+                                   'heating_systems',
+                                   'typ'])
+    return rv_gl
+
+
+def group_heating_systems_by_energy_carrier(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.reindex()
+    df = df.sort_index()
+    df['building_group'] = 'yrkesbygg'
+    try:
+        df.loc[('house', slice(None),slice(None),slice(None),slice(None), slice(None),), 'building_group'] = 'bolig'
+    except KeyError as key_error:
+        logger.error('Missing key when setting group bolig for house')
+        logger.error(key_error)
+    try:
+        df.loc[('apartment_block', slice(None),slice(None),slice(None), slice(None), slice(None),), 'building_group'] = 'bolig'
+    except KeyError as key_error:
+        logger.error('Missing key when setting group bolig for apartment_block')
+        logger.error(key_error)
+
+    # df.loc['apartment_block', 'building_group'] = 'bolig'
+
+    df['ALWAYS_ELECTRICITY'] = 'Electricity'
+    rv_gl = transform_by_energy_source(df, HEATING_RV_BASE_TOTAL, BASE_LOAD_ENERGY_PRODUCT)
+    rv_sl = transform_by_energy_source(df, HEATING_RV_PEAK_TOTAL, PEAK_LOAD_ENERGY_PRODUCT)
+    rv_el = transform_by_energy_source(df, HEATING_RV_TERTIARY_TOTAL, TERTIARY_LOAD_ENERGY_PRODUCT)
+    cooling = transform_by_energy_source(df, COOLING_TOTAL, 'ALWAYS_ELECTRICITY')
+    spesifikt_elforbruk = transform_by_energy_source(df, OTHER_TOTAL, 'ALWAYS_ELECTRICITY')
+    tappevann = transform_by_energy_source(df, DHW_TOTAL, DOMESTIC_HOT_WATER_ENERGY_PRODUCT)
+    rv_hp = transform_by_energy_source(df, HEAT_PUMP, HP_ENERGY_SOURCE)
+
+    energy_use = pd.concat([rv_gl, rv_sl, rv_el, cooling, spesifikt_elforbruk, tappevann, rv_hp])
+
+    sums = energy_use.groupby(by=['building_group', 'energy_source', 'year']).sum() / (10**6)
+    df = sums.reset_index()
+    df = df.rename(columns={'building_group': 'building_category'})
+    try:
+        df.loc[df.energy_source == 'DH', 'energy_source'] = 'Fjernvarme'
+    except KeyError as ex:
+        logger.exception(ex)
+    try:
+        df.loc[df.energy_source == 'Electricity', 'energy_source'] = 'Elektrisitet'
+    except KeyError as ex:
+        logger.exception(ex)
+    try:
+        df.loc[df.building_category == 'bolig', 'building_category'] = 'Bolig'
+    except KeyError as ex:
+        logger.exception(ex)
+    try:
+        df.loc[df.building_category == 'yrkesbygg', 'building_category'] = 'Yrkesbygg'
+    except KeyError as ex:
+        logger.exception(ex)
+    return df.set_index(['building_category', 'energy_source', 'year'])
+
+
+def transform_pumps(df: pd.DataFrame, calibration_year) -> pd.DataFrame:
+    df['building_group'] = 'Yrkesbygg'
+    df.loc['house', 'building_group'] = 'Bolig'
+    df.loc['apartment_block', 'building_group'] = 'Bolig'
+
+    return df
+
+
+def _calculate_energy_source(df, heating_type, primary_source, secondary_source=None):
+    if secondary_source and primary_source == secondary_source:
+        df.loc[(heating_type, slice(None)), primary_source] = df.loc[(heating_type, slice(None)), HEATING_RV_BASE_TOTAL] + \
+                                                              df.loc[(heating_type, slice(None)), HEATING_RV_PEAK_TOTAL]
+
+        return df
+    df.loc[(heating_type, slice(None)), primary_source] = df.loc[(heating_type, slice(None)), HEATING_RV_BASE_TOTAL]
+    if secondary_source:
+        df.loc[(heating_type, slice(None)), secondary_source] = df.loc[
+            (heating_type, slice(None)), HEATING_RV_PEAK_TOTAL]
+
+    return df
+
+
+def sort_heating_systems_by_energy_source(transformed):
+    custom_order = [ELECTRICITY, BIO, FOSSIL, DISTRICT_HEATING]
+
+    unsorted = transformed.reset_index()
+    unsorted['energy_source'] = pd.Categorical(unsorted['energy_source'], categories=custom_order, ordered=True)
+    df_sorted = unsorted.sort_values(by=['energy_source'])
+    df_sorted = df_sorted.set_index([('energy_source', '')])
+
+    return df_sorted
+
+
+class DistributionOfHeatingSystems:
+    @staticmethod
+    def extract(database_manager):
+        return database_manager.get_heating_systems_shares_start_year()
+
+    @staticmethod
+    def transform(df):
+        df = df.reset_index()
+        df['building_group'] = 'Yrkesbygg'
+
+        df = df[df['building_category'] != 'storage_repairs']
+        df.loc[df['building_category'].isin(['apartment_block']), 'building_group'] = 'Boligblokk'
+        df.loc[df['building_category'].isin(['house']), 'building_group'] = 'Småhus'
+
+        distribution_of_heating_systems_by_building_group = df.groupby(by=['building_group', 'heating_systems'])[
+            ['heating_system_share']].mean()
+        return distribution_of_heating_systems_by_building_group
+
+

ebm/model/column_operations.py

@@ -0,0 +1,157 @@
+import pathlib
+from typing import List, Optional
+
+import pandas as pd
+from pandera.typing.common import DataFrameBase
+
+from ebm.model.building_category import BuildingCategory
+
+
+def explode_building_category_column(df: pd.DataFrame, unique_columns: List[str]) -> pd.DataFrame:
+    """
+        Explodes the 'building_category' column in the DataFrame into multiple columns based on residential and non-residential categories.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            The input DataFrame containing the 'building_category' column.
+        unique_columns : List[str]
+            List of columns to use for de-duplication.
+
+        Returns
+        -------
+        pd.DataFrame
+            The DataFrame with exploded 'building_category' columns.
+    """
+    df = explode_column_alias(df=df, column='building_category',
+                              values=[bc for bc in BuildingCategory if bc.is_residential()],
+                              alias='residential',
+                              de_dup_by=unique_columns)
+    df = explode_column_alias(df=df, column='building_category',
+                              values=[bc for bc in BuildingCategory if not bc.is_residential()],
+                              alias='non_residential',
+                              de_dup_by=unique_columns)
+    df = explode_column_alias(df=df, column='building_category',
+                              values=[bc for bc in BuildingCategory],
+                              alias='default',
+                              de_dup_by=unique_columns)
+    return df
+
+
+def explode_building_code_column(df: pd.DataFrame, unique_columns: List[str],
+                       default_building_code: None | pd.DataFrame = None) -> pd.DataFrame:
+    """
+        Explodes the 'building_code' column in the DataFrame into multiple columns based on the provided building_codelist.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            The input DataFrame containing the 'building_code' column.
+        unique_columns : List[str]
+            List of columns to use for de-duplication.
+        default_building_code : Optional[pd.DataFrame], optional
+            DataFrame containing default building_codevalues. If not provided, building_codevalues are read from 'input/building_codes.csv'.
+
+        Returns
+        -------
+        pd.DataFrame
+            The DataFrame with exploded 'building_code' columns.
+        """
+    # Hvor skal building_code_list hentes fra?
+    building_code_list = pd.read_csv(pathlib.Path(__file__).parent.parent / 'data' / 'building_code_parameters.csv')['building_code'].unique() if default_building_code is None else default_building_code
+    df = explode_column_alias(df=df,
+                              column='building_code',
+                              values=building_code_list,
+                              de_dup_by=unique_columns)
+    return df
+
+
+def explode_unique_columns(df: pd.DataFrame| DataFrameBase,
+                           unique_columns: List[str],
+                           default_building_code: List[str]|None = None) -> pd.DataFrame:
+    """
+    Explodes 'building_code' and 'building_category' columns in df.
+
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The input DataFrame containing the columns to be exploded.
+    unique_columns : List[str]
+        List of columns to use for de-duplication.
+    default_building_code : List[str], optional
+        List of TEKs to replace default
+
+    Returns
+    -------
+    pd.DataFrame
+        The DataFrame with exploded columns.
+    """
+
+    df = explode_building_code_column(df, unique_columns, default_building_code=default_building_code)
+    df = explode_building_category_column(df, unique_columns)
+    return df
+
+
+def explode_column_alias(df, column, values: list|dict=None, alias='default', de_dup_by: list[str]=None):
+    """
+    Explodes a specified column in the DataFrame into multiple rows based on provided values and alias.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The input DataFrame containing the column to be exploded.
+    column : str
+        The name of the column to be exploded.
+    values : Optional[List[str], dict[str, list[str]], optional
+        List or dict of values to explode the column by. If not provided, unique values from the column excluding the
+        alias are used.
+    alias : str, optional
+        The alias to be used for default values. Default is 'default'.
+        When values is a dict the parameter alias is ignored
+    de_dup_by : Optional[List[str]], optional
+        List of columns to use for de-duplication. If not provided, no de-duplication is performed.
+
+    Returns
+    -------
+    pd.DataFrame
+        The DataFrame with the exploded column.
+
+    Examples
+    --------
+    >>> d_f = pd.DataFrame({'category': ['A', 'B', 'default']})
+    >>> explode_column_alias(d_f, column='category', values=['A', 'B'], alias='default')
+       category
+    0         A
+    1         B
+    2         A
+    2         B
+    """
+    if column not in df.columns:
+        raise ValueError(f"The DataFrame (df) must contain the column: {column}")
+
+    df = replace_column_alias(df, column=column, values=values, alias=alias, de_dup_by=None)
+
+    df = df.assign(**{column: df[column].str.split('+')}).explode(column)
+    if de_dup_by:
+        df = df.sort_values(by='_explode_column_alias_default', ascending=True)
+        df = df.drop_duplicates(de_dup_by)
+    return df.drop(columns=['_explode_column_alias_default'], errors='ignore')
+
+
+def replace_column_alias(df: pd.DataFrame, column: str, values: Optional[list|dict]=None, alias: Optional[str]='default',
+                         de_dup_by=None) -> pd.DataFrame:
+    values = values if values is not None else [c for c in df[column].unique().tolist() if c != alias]
+    aliases = {alias: values} if not isinstance(values, dict) else values
+    df = df.copy()
+    for k, v in aliases.items():
+        df['_explode_column_alias_default'] = df[column] == k
+        df.loc[df[df[column] == k].index, column] = '+'.join(v)
+    if not de_dup_by:
+        return df
+    return df.drop(columns=['_explode_column_alias_default'], errors='ignore')
+
+
+def explode_column(df: pd.DataFrame, column: str) -> pd.DataFrame:
+    df = df.assign(**{column: df[column].str.split('+')}).explode(column)
+    return df