From 4010812fd494c00ec5818c70b27839eee1bd703a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 7 Apr 2026 09:34:52 +0200 Subject: [PATCH 01/23] Adds cost income --- climada/entity/measures/cost_income.py | 415 +++++++++++++++++++++++++ 1 file changed, 415 insertions(+) create mode 100644 climada/entity/measures/cost_income.py diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py new file mode 100644 index 0000000000..564bbd251f --- /dev/null +++ b/climada/entity/measures/cost_income.py @@ -0,0 +1,415 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Define the Cash Flows class. +""" + +# Define default discount rates +# DISC_RATES = DiscRates(years=np.arange(1900, 2100), rates=np.ones(np.arange(1900, 2100).size)) + +from datetime import datetime +from typing import Any, List, Optional, Tuple + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + +from climada.entity.measures.measure_config import CostIncomeConfig + + +class CostIncome: + """ + Manages costs and incomes related to a measure over time. + + Income are stored a positive numbers and costs as negative + ones. + + Attributes + ---------- + freq : str + Frequency of the cash flows (e.g., 'Y', 'M', 'D'). + mkt_price_year : datetime + The reference year for market prices. + cost_growth_rate : float + Yearly growth rate of costs. + init_cost : float + Initial implementation cost (stored as negative). + periodic_cost : float + Recurring cost per period (stored as negative). + periodic_income : float + Recurring income per period. + income_growth_rate : float + Yearly growth rate of income. + custom_cash_flows : pd.DataFrame, optional + User-defined cash flows indexed by date. + """ + + def __init__( + self, + *, + mkt_price_year: Optional[int] = None, + init_cost: float = 0.0, + periodic_cost: float = 0.0, + periodic_income: float = 0.0, + cost_yearly_growth_rate: float = 0.0, + income_yearly_growth_rate: float = 0.0, + custom_cash_flows: Optional[pd.DataFrame] = None, + freq: str = "Y", + ): + """Initialize CostIncome with parameters.""" + self.freq = freq + self.mkt_price_year = datetime(mkt_price_year or datetime.today().year, 1, 1) + self.cost_growth_rate = cost_yearly_growth_rate + + self.init_cost = -abs(init_cost) + self.periodic_cost = -abs(periodic_cost) + self.periodic_income = abs(periodic_income) + + self.income_growth_rate = income_yearly_growth_rate + + if custom_cash_flows is not None: + self.custom_cash_flows = self._prepare_custom_flows(custom_cash_flows) + else: + self.custom_cash_flows = None + + def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: + """Process and resample custom cash flow dataframe.""" + df = df.copy() + if "cost" in df.columns: + df["cost"] = -df["cost"].abs() + if "date" in df.columns: + df["date"] = pd.to_datetime(df["date"]) + df = df.set_index("date") + return df.resample(self.freq).sum() + + @classmethod + def from_config(cls, config: CostIncomeConfig) -> "CostIncome": + df = None + if config.custom_cash_flows is not None: + df = pd.DataFrame(config.custom_cash_flows) + df["date"] = pd.to_datetime(df["date"]) + return cls( + mkt_price_year=config.mkt_price_year, + init_cost=config.init_cost, + periodic_cost=config.periodic_cost, + periodic_income=config.periodic_income, + cost_yearly_growth_rate=config.cost_yearly_growth_rate, + income_yearly_growth_rate=config.income_yearly_growth_rate, + custom_cash_flows=df, + freq=config.freq, + ) + + @classmethod + def from_dict(cls, d: dict) -> "CostIncome": + return cls.from_config( + CostIncomeConfig( + mkt_price_year=d.get("mkt_price_year"), + init_cost=d.get("init_cost", 0.0), + periodic_cost=d.get("periodic_cost", 0.0), + periodic_income=d.get("periodic_income", 0.0), + cost_yearly_growth_rate=d.get("cost_yearly_growth_rate", 0.0), + income_yearly_growth_rate=d.get("income_yearly_growth_rate", 0.0), + freq=d.get("freq", "Y"), + custom_cash_flows=d.get("custom_cash_flows"), + ) + ) + + @classmethod + def from_yaml(cls, path: str) -> "CostIncome": + import yaml + + with open(path) as f: + return cls.from_dict(yaml.safe_load(f)["cost_income"]) + + @staticmethod + def _freq_to_days(freq: str) -> str: + """ + Convert a frequency string to the equivalent number of days. + + Parameters: + ----------- + freq : str + A frequency string (e.g., 'D' for daily, 'M' for monthly, 'Y' for yearly). + + Returns: + -------- + float + The equivalent number of days for the given frequency string. + """ + try: + # Convert the frequency string to a DateOffset object + offset = pd.tseries.frequencies.to_offset(freq) + + # Calculate the number of days by applying the offset to a base date + base_date = pd.Timestamp("2000-01-01") + end_date = base_date + offset + + # Return the difference in days + return f"{(end_date - base_date).days}d" + except ValueError: + raise ValueError(f"Invalid frequency string: {freq}") + + def _get_width_days(self) -> float: + """Return the number of days in the current frequency.""" + ref = pd.Timestamp("2000-01-01") + offset = pd.tseries.frequencies.to_offset(self.freq) + return float(((ref + offset) - ref).days) + + def _get_custom_val(self, date, column: str) -> float: + if self.custom_cash_flows is not None: + return self.custom_cash_flows.loc[date, column] + + raise AttributeError("No custom cash flow is defined.") + + def _calc_at_date( + self, impl_date: pd.Timestamp, curr_date: pd.Timestamp + ) -> Tuple[float, float, float]: + """Calculate cash flows for a single timestamp.""" + # Calculate growth factor based on years from market price reference + years_passed = (curr_date - self.mkt_price_year).days / 365.0 + + cost_factor = (1 + self.cost_growth_rate) ** years_passed + inc_factor = (1 + self.income_growth_rate) ** years_passed + + if curr_date < impl_date: + cost, income = 0.0, 0.0 + elif curr_date == impl_date: + cost = self.init_cost * cost_factor + income = self.periodic_income * inc_factor + else: + cost = self.periodic_cost * cost_factor + income = self.periodic_income * inc_factor + + c_cost = self._get_custom_val(curr_date, "cost") + c_inc = self._get_custom_val(curr_date, "income") + + total_cost = cost + c_cost + total_inc = income + c_inc + return (total_inc + total_cost), total_cost, total_inc + + def calc_cash_flows( + self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Calculate net cash flows, costs, and incomes over a period. + + Parameters + ---------- + impl_date : Any + Date the measure is implemented. + start_date : Any + Start of the calculation period. + end_date : Any + End of the calculation period. + disc : DiscRates, optional + Discount rates object to calculate Net Present Value. + + Returns + ------- + Tuple[np.ndarray, np.ndarray, np.ndarray] + (net, costs, incomes) + """ + impl_ts = pd.Timestamp(impl_date) + periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) + + results = [self._calc_at_date(impl_ts, p.start_time) for p in periods] + net, costs, incs = map(np.array, zip(*results)) + + if disc is not None: + # Vectorized discounting + years = np.array([p.year for p in periods]) + # Note: Assumes disc.rates is indexed/aligned with disc.years + rate_map = dict(zip(disc.years, disc.rates)) + factors = np.array( + [ + 1 + / (1 + rate_map.get(yr, 0.0)) + ** (yr - pd.Timestamp(start_date).year) + for yr in years + ] + ) + # Handle potential length mismatch if years aren't in disc + valid = np.array([yr in rate_map for yr in years]) + return ( + net[valid] * factors[valid], + costs[valid] * factors[valid], + incs[valid] * factors[valid], + ) + + return net, costs, incs + + def calc_total( + self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + ) -> Tuple[float, float, float]: + """ + Calculate the total or net present value of the cash flows over a given period + + Parameters: + ----------- + impl_year: int + the year the measure is implemented + + start_year: int + the start year of the period + + end_year: int + the end year of the period + + disc: DiscRates object + the discount rates (required if discounted is True) + + Returns: + -------- + Tuple[float, float, float] + the total net, cost, and income present values over the given period + """ + + net_cash_flows, costs, incomes = self.calc_cash_flows( + impl_date, start_date, end_date, disc=disc + ) + return np.sum(net_cash_flows), np.sum(costs), np.sum(incomes) + + def plot_cash_flows( + self, + impl_date: Any, + start_date: Any, + end_date: Any, + disc: Optional[Any] = None, + to_plot: List[str] = ["net", "cost", "income"], + ): + """ + Plot the cash flows over a given period. + + Parameters: + ----------- + impl_date: datetime + The date the measure is implemented. + start_date: datetime + The start date of the period. + end_date: datetime + The end date of the period. + disc: DiscRates object + The discount rates (optional). + to_plot: list + List of strings indicating which cash flows to plot. Options are 'net', 'cost', 'income'. + """ + # Calculate the cash flows over the given period + net_cash_flows, costs, incomes = self.calc_cash_flows( + impl_date, start_date, end_date, disc=disc + ) + + # Plot the cash flows with colors + date_range = pd.date_range( + start=start_date, end=end_date, freq=self._freq_to_days(self.freq) + ) + width = self._get_width_days() * 0.8 # 80% width for visibility + fig, ax = plt.subplots() + + if "cost" in to_plot: + ax.bar(date_range, costs, color="red", label="Cost", width=width) + if "income" in to_plot: + ax.bar( + date_range, + incomes, + color="blue", + label="Income", + alpha=0.7, + width=width, + ) + if "net" in to_plot: + ax.bar( + date_range, + net_cash_flows, + color="blue", + edgecolor="red", + hatch="//", + label="Net", + alpha=0.5, + width=width, + ) + + ax.xaxis_date() # <---- treat x-ticks as datetime + fig.autofmt_xdate() + plt.xlabel("Date") + plt.ylabel("Cash Flow") + plt.title("Discounted Cash Flows" if disc else "Cash Flows") + plt.legend() + plt.show() + return ax + + def to_dataframe( + self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + ) -> pd.DataFrame: + """Return cash flows as a formatted DataFrame.""" + net, costs, incs = self.calc_cash_flows( + impl_date, start_date, end_date, disc=disc + ) + periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) + + return pd.DataFrame( + {"date": periods, "net": net, "cost": costs, "income": incs} + ) + + @staticmethod + def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": + """Sum costs and incomes from all measures.""" + first_ci = cost_incomes[0] + + if not all( + [ + first_ci.mkt_price_year.year == c.mkt_price_year.year + for c in cost_incomes + ] + ): + raise ValueError( + "Measure cost incomes have different market price years, combination is not possible." + ) + + if not all( + [first_ci.cost_growth_rate == c.cost_growth_rate for c in cost_incomes] + ): + raise ValueError( + "Measure cost incomes have different cost_growth_rate, combination is not possible." + ) + + if not all( + [first_ci.income_growth_rate == c.income_growth_rate for c in cost_incomes] + ): + raise ValueError( + "Measure cost incomes have different income_growth_rate, combination is not possible." + ) + + return CostIncome( + mkt_price_year=first_ci.mkt_price_year.year, + cost_yearly_growth_rate=first_ci.cost_growth_rate, + init_cost=sum(c.init_cost for c in cost_incomes), + periodic_cost=sum(c.periodic_cost for c in cost_incomes), + periodic_income=sum(c.periodic_income for c in cost_incomes), + income_yearly_growth_rate=first_ci.income_growth_rate, + ) + + @staticmethod + def from_kwargs(kwargs) -> "CostIncome": + """Extracts financial keys from the excel row data.""" + return CostIncome( + init_cost=kwargs.get("init_cost", 0.0), + periodic_cost=kwargs.get("periodic_cost", 0.0), + periodic_income=kwargs.get("periodic_income", 0.0), + income_yearly_growth_rate=kwargs.get("income_yearly_growth_rate", 0.0), + cost_yearly_growth_rate=kwargs.get("cost_yearly_growth_rate", 0.0), + ) From ff6733eb1ad166d55d55157cc3d347b1e44339f1 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 10:30:36 +0200 Subject: [PATCH 02/23] Docstringyfies and cleans up a bit --- climada/entity/measures/cost_income.py | 282 ++++++++++++++++++------- 1 file changed, 209 insertions(+), 73 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 564bbd251f..bda1d6ac2a 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -16,19 +16,17 @@ --- -Define the Cash Flows class. +Define the CostIncome class to handle the cash flow of measures. """ -# Define default discount rates -# DISC_RATES = DiscRates(years=np.arange(1900, 2100), rates=np.ones(np.arange(1900, 2100).size)) - from datetime import datetime -from typing import Any, List, Optional, Tuple +from typing import Any, List, Optional, Tuple, cast import matplotlib.pyplot as plt import numpy as np import pandas as pd +from climada.entity.disc_rates.base import DiscRates from climada.entity.measures.measure_config import CostIncomeConfig @@ -41,22 +39,22 @@ class CostIncome: Attributes ---------- - freq : str - Frequency of the cash flows (e.g., 'Y', 'M', 'D'). - mkt_price_year : datetime + mkt_price_year : datetime, default to today's year. The reference year for market prices. - cost_growth_rate : float - Yearly growth rate of costs. init_cost : float Initial implementation cost (stored as negative). periodic_cost : float Recurring cost per period (stored as negative). periodic_income : float Recurring income per period. - income_growth_rate : float + cost_yearly_growth_rate : float + Yearly growth rate of costs. + income_yearly_growth_rate : float Yearly growth rate of income. custom_cash_flows : pd.DataFrame, optional User-defined cash flows indexed by date. + freq : str + Frequency of the cash flows (e.g., 'Y', '3M', '7D'). """ def __init__( @@ -71,7 +69,28 @@ def __init__( custom_cash_flows: Optional[pd.DataFrame] = None, freq: str = "Y", ): - """Initialize CostIncome with parameters.""" + """Initialize CostIncome with parameters. + + Parameters + ---------- + mkt_price_year : datetime, default to today's year. + The reference year for market prices. + init_cost : float + Initial implementation cost (stored as negative). + periodic_cost : float + Recurring cost per period (stored as negative). + periodic_income : float + Recurring income per period. + cost_yearly_growth_rate : float + Yearly growth rate of costs. + income_yearly_growth_rate : float + Yearly growth rate of income. + custom_cash_flows : pd.DataFrame, optional + User-defined cash flows indexed by date. + freq : str + Frequency of the cash flows (e.g., 'Y', '3M', '7D'). + """ + self.freq = freq self.mkt_price_year = datetime(mkt_price_year or datetime.today().year, 1, 1) self.cost_growth_rate = cost_yearly_growth_rate @@ -88,7 +107,21 @@ def __init__( self.custom_cash_flows = None def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: - """Process and resample custom cash flow dataframe.""" + """Process and resample custom cash flow dataframe + + Enforce costs as negative numbers and date to the correct frequency. + + Parameters + ---------- + df : pd.DataFrame + Custom cashflow + + Returns + ------- + pd.DataFrame + Processed custom cashflow + """ + df = df.copy() if "cost" in df.columns: df["cost"] = -df["cost"].abs() @@ -99,6 +132,17 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: @classmethod def from_config(cls, config: CostIncomeConfig) -> "CostIncome": + """Create a `CostIncome` from a `CostIncomeConfig`. + + Parameters + ---------- + config : CostIncomeConfig + + Returns + ------- + CostIncome + """ + df = None if config.custom_cash_flows is not None: df = pd.DataFrame(config.custom_cash_flows) @@ -115,22 +159,47 @@ def from_config(cls, config: CostIncomeConfig) -> "CostIncome": ) @classmethod - def from_dict(cls, d: dict) -> "CostIncome": + def from_dict(cls, args_dict: dict) -> "CostIncome": + """Create a `CostIncome` from a dictionary. + + Parameters + ---------- + args_dict : dict + + Returns + ------- + CostIncome + """ + return cls.from_config( CostIncomeConfig( - mkt_price_year=d.get("mkt_price_year"), - init_cost=d.get("init_cost", 0.0), - periodic_cost=d.get("periodic_cost", 0.0), - periodic_income=d.get("periodic_income", 0.0), - cost_yearly_growth_rate=d.get("cost_yearly_growth_rate", 0.0), - income_yearly_growth_rate=d.get("income_yearly_growth_rate", 0.0), - freq=d.get("freq", "Y"), - custom_cash_flows=d.get("custom_cash_flows"), + mkt_price_year=args_dict.get("mkt_price_year"), + init_cost=args_dict.get("init_cost", 0.0), + periodic_cost=args_dict.get("periodic_cost", 0.0), + periodic_income=args_dict.get("periodic_income", 0.0), + cost_yearly_growth_rate=args_dict.get("cost_yearly_growth_rate", 0.0), + income_yearly_growth_rate=args_dict.get( + "income_yearly_growth_rate", 0.0 + ), + freq=args_dict.get("freq", "Y"), + custom_cash_flows=args_dict.get("custom_cash_flows"), ) ) @classmethod def from_yaml(cls, path: str) -> "CostIncome": + """Create a `CostIncome` from a yaml file. + + Parameters + ---------- + path : str + Path to the yaml file. + + Returns + ------- + CostIncome + """ + import yaml with open(path) as f: @@ -151,6 +220,7 @@ def _freq_to_days(freq: str) -> str: float The equivalent number of days for the given frequency string. """ + try: # Convert the frequency string to a DateOffset object offset = pd.tseries.frequencies.to_offset(freq) @@ -166,20 +236,71 @@ def _freq_to_days(freq: str) -> str: def _get_width_days(self) -> float: """Return the number of days in the current frequency.""" + ref = pd.Timestamp("2000-01-01") offset = pd.tseries.frequencies.to_offset(self.freq) return float(((ref + offset) - ref).days) - def _get_custom_val(self, date, column: str) -> float: - if self.custom_cash_flows is not None: - return self.custom_cash_flows.loc[date, column] - - raise AttributeError("No custom cash flow is defined.") - def _calc_at_date( self, impl_date: pd.Timestamp, curr_date: pd.Timestamp ) -> Tuple[float, float, float]: - """Calculate cash flows for a single timestamp.""" + r"""Calculate cash flows for a single timestamp. + + Computes the total cash flow, total cost, and total income for a given + evaluation date, accounting for growth rates applied to base costs and + incomes, as well as any custom cash flow overrides. + + The calculation applies compound growth to both costs and incomes based + on the number of years elapsed since the market price reference date + (`self.mkt_price_year`). Different base amounts are used depending on + whether the current date is before, at, or after the implementation date. + + Parameters + ---------- + impl_date : pd.Timestamp + The implementation date that determines which cost/income regime + applies. Dates before this use zero base amounts; at or after this + date use the initialized or periodic amounts respectively. + curr_date : pd.Timestamp + The evaluation date for which cash flows are being calculated. This + is compared against `impl_date` to determine the applicable base + amounts and is also used to index into `custom_cash_flows` if present. + + Returns + ------- + Tuple[float, float, float] + A tuple containing: + + * total_cash_flow : float + Net cash flow for the period, calculated as `total_income + total_cost`. + Note: Costs are typically negative values in financial contexts, + so this represents the net position. + * total_cost : float + Total cost amount for the period, including both standard and + custom cost components. + * total_income : float + Total income amount for the period, including both standard and + custom income components. + + Notes + ----- + Growth calculations use compound interest formula: + + .. math:: + factor = (1 + rate)^{years\_passed} + + where `years_passed` is computed as `(curr_date - mkt_price_year).days / 365.0`. + + Cost and income regimes: + + - **Before impl_date**: Both base cost and income are zero + - **At impl_date**: Uses `init_cost` for cost and `periodic_income` for income + - **After impl_date**: Uses `periodic_cost` for cost and `periodic_income` for income + + Custom cash flows (if `self.custom_cash_flows` is not None) are added + on top of the calculated standard amounts. Missing dates in the custom + cash flow DataFrame will raise a KeyError. + """ # Calculate growth factor based on years from market price reference years_passed = (curr_date - self.mkt_price_year).days / 365.0 @@ -195,46 +316,69 @@ def _calc_at_date( cost = self.periodic_cost * cost_factor income = self.periodic_income * inc_factor - c_cost = self._get_custom_val(curr_date, "cost") - c_inc = self._get_custom_val(curr_date, "income") + if self.custom_cash_flows is not None: + c_cost = cast(float, self.custom_cash_flows.loc[curr_date, "cost"]) + c_inc = cast(float, self.custom_cash_flows.loc[curr_date, "income"]) + else: + c_cost, c_inc = 0.0, 0.0 total_cost = cost + c_cost total_inc = income + c_inc return (total_inc + total_cost), total_cost, total_inc def calc_cash_flows( - self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + self, impl_date, start_date, end_date, disc_rates: Optional[DiscRates] = None ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: - """ - Calculate net cash flows, costs, and incomes over a period. + """Calculate net cash flows, costs, and incomes over a period. + + Computes cash flow metrics across a specified date range by iterating + through each period. Optionally + applies discounting to calculate Net Present Value (NPV) when discount + rates are provided. + + The method creates a period range based on the configured frequency + (`self.freq`) and evaluates cash flows at the start time of each period. + Results are returned as NumPy arrays for efficient downstream processing. Parameters ---------- - impl_date : Any - Date the measure is implemented. - start_date : Any - Start of the calculation period. - end_date : Any - End of the calculation period. - disc : DiscRates, optional - Discount rates object to calculate Net Present Value. + impl_date : + The implementation date that determines which cost/income regime + applies. + start_date : + The beginning of the calculation period. + end_date : + The end of the calculation period. + disc_rates : DiscRates, optional + An object containing discount rate information for NPV calculations. Returns ------- Tuple[np.ndarray, np.ndarray, np.ndarray] - (net, costs, incomes) + A tuple containing three NumPy arrays of equal length: + + * net : np.ndarray + Net cash flow for each period (income + cost). May be discounted + if `disc_rates` is provided. + * costs : np.ndarray + Total costs for each period. May be discounted if `disc_rates` + is provided. + * incomes : np.ndarray + Total incomes for each period. May be discounted if `disc_rates` + is provided. """ + impl_ts = pd.Timestamp(impl_date) periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) results = [self._calc_at_date(impl_ts, p.start_time) for p in periods] net, costs, incs = map(np.array, zip(*results)) - if disc is not None: + if disc_rates is not None: # Vectorized discounting years = np.array([p.year for p in periods]) # Note: Assumes disc.rates is indexed/aligned with disc.years - rate_map = dict(zip(disc.years, disc.rates)) + rate_map = dict(zip(disc_rates.years, disc_rates.rates)) factors = np.array( [ 1 @@ -254,24 +398,21 @@ def calc_cash_flows( return net, costs, incs def calc_total( - self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + self, impl_date, start_date, end_date, disc: Optional[DiscRates] = None ) -> Tuple[float, float, float]: """ - Calculate the total or net present value of the cash flows over a given period + Calculate the total or net present value of the cash flows over a given period. Parameters: ----------- - impl_year: int - the year the measure is implemented - - start_year: int - the start year of the period - + impl_date: + The date the measure is implemented. + start_year: + The start date of the period. end_year: int - the end year of the period - - disc: DiscRates object - the discount rates (required if discounted is True) + The end year of the period. + disc: DiscRates, optional + The discount rates to apply. Returns: -------- @@ -280,7 +421,7 @@ def calc_total( """ net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date, disc=disc + impl_date, start_date, end_date, disc_rates=disc ) return np.sum(net_cash_flows), np.sum(costs), np.sum(incomes) @@ -308,9 +449,10 @@ def plot_cash_flows( to_plot: list List of strings indicating which cash flows to plot. Options are 'net', 'cost', 'income'. """ + # Calculate the cash flows over the given period net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date, disc=disc + impl_date, start_date, end_date, disc_rates=disc ) # Plot the cash flows with colors @@ -353,11 +495,11 @@ def plot_cash_flows( return ax def to_dataframe( - self, impl_date: Any, start_date: Any, end_date: Any, disc: Optional[Any] = None + self, impl_date, start_date, end_date, disc_rates: Optional[DiscRates] = None ) -> pd.DataFrame: """Return cash flows as a formatted DataFrame.""" net, costs, incs = self.calc_cash_flows( - impl_date, start_date, end_date, disc=disc + impl_date, start_date, end_date, disc_rates=disc_rates ) periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) @@ -367,7 +509,12 @@ def to_dataframe( @staticmethod def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": - """Sum costs and incomes from all measures.""" + """Combine multiple CostIncomes together. + + Combination sums the costs and incomes from all provided CostIncome + objects. + """ + first_ci = cost_incomes[0] if not all( @@ -402,14 +549,3 @@ def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": periodic_income=sum(c.periodic_income for c in cost_incomes), income_yearly_growth_rate=first_ci.income_growth_rate, ) - - @staticmethod - def from_kwargs(kwargs) -> "CostIncome": - """Extracts financial keys from the excel row data.""" - return CostIncome( - init_cost=kwargs.get("init_cost", 0.0), - periodic_cost=kwargs.get("periodic_cost", 0.0), - periodic_income=kwargs.get("periodic_income", 0.0), - income_yearly_growth_rate=kwargs.get("income_yearly_growth_rate", 0.0), - cost_yearly_growth_rate=kwargs.get("cost_yearly_growth_rate", 0.0), - ) From 66a3f70a38ed11e58558ed115361a4c1e2ee9720 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 12:01:55 +0200 Subject: [PATCH 03/23] Fix resampling issues, few docstring adjustments --- climada/entity/measures/cost_income.py | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index bda1d6ac2a..305047f007 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -55,6 +55,7 @@ class CostIncome: User-defined cash flows indexed by date. freq : str Frequency of the cash flows (e.g., 'Y', '3M', '7D'). + """ def __init__( @@ -128,7 +129,17 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: if "date" in df.columns: df["date"] = pd.to_datetime(df["date"]) df = df.set_index("date") - return df.resample(self.freq).sum() + match self.freq: + case "Y": + resampling_freq = "YS" + case "M": + resampling_freq = "MS" + case "Q": + resampling_freq = "QS" + case _: + resampling_freq = self.freq + + return df.resample(resampling_freq).sum() @classmethod def from_config(cls, config: CostIncomeConfig) -> "CostIncome": @@ -248,19 +259,19 @@ def _calc_at_date( Computes the total cash flow, total cost, and total income for a given evaluation date, accounting for growth rates applied to base costs and - incomes, as well as any custom cash flow overrides. + incomes, as well as the custom cash flow if provided. The calculation applies compound growth to both costs and incomes based on the number of years elapsed since the market price reference date - (`self.mkt_price_year`). Different base amounts are used depending on - whether the current date is before, at, or after the implementation date. + (`self.mkt_price_year`). Parameters ---------- impl_date : pd.Timestamp The implementation date that determines which cost/income regime - applies. Dates before this use zero base amounts; at or after this - date use the initialized or periodic amounts respectively. + applies. Dates before this use have no cost or income; "at the date" uses + the implementation cost, and dates after use the initialized or + periodic amounts respectively. curr_date : pd.Timestamp The evaluation date for which cash flows are being calculated. This is compared against `impl_date` to determine the applicable base @@ -294,7 +305,7 @@ def _calc_at_date( Cost and income regimes: - **Before impl_date**: Both base cost and income are zero - - **At impl_date**: Uses `init_cost` for cost and `periodic_income` for income + - **At impl_date**: Uses `init_cost` for cost - **After impl_date**: Uses `periodic_cost` for cost and `periodic_income` for income Custom cash flows (if `self.custom_cash_flows` is not None) are added From 1a1c97dc1c5f08a2c07b27e31157adcb9cea0992 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 12:02:44 +0200 Subject: [PATCH 04/23] Removes periodic income from implementation period for consistency --- climada/entity/measures/cost_income.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 305047f007..df0641358e 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -322,7 +322,7 @@ def _calc_at_date( cost, income = 0.0, 0.0 elif curr_date == impl_date: cost = self.init_cost * cost_factor - income = self.periodic_income * inc_factor + income = 0.0 else: cost = self.periodic_cost * cost_factor income = self.periodic_income * inc_factor From 5822a697bee394624b299d4c1cacc760072f17d0 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 12:03:07 +0200 Subject: [PATCH 05/23] Removes discount rate logic (to be handled in StaticAppraiser) --- climada/entity/measures/cost_income.py | 66 +++++--------------------- 1 file changed, 13 insertions(+), 53 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index df0641358e..60c9c8f8eb 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -338,14 +338,12 @@ def _calc_at_date( return (total_inc + total_cost), total_cost, total_inc def calc_cash_flows( - self, impl_date, start_date, end_date, disc_rates: Optional[DiscRates] = None + self, impl_date, start_date, end_date ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """Calculate net cash flows, costs, and incomes over a period. Computes cash flow metrics across a specified date range by iterating - through each period. Optionally - applies discounting to calculate Net Present Value (NPV) when discount - rates are provided. + through each period. The method creates a period range based on the configured frequency (`self.freq`) and evaluates cash flows at the start time of each period. @@ -360,8 +358,6 @@ def calc_cash_flows( The beginning of the calculation period. end_date : The end of the calculation period. - disc_rates : DiscRates, optional - An object containing discount rate information for NPV calculations. Returns ------- @@ -369,14 +365,11 @@ def calc_cash_flows( A tuple containing three NumPy arrays of equal length: * net : np.ndarray - Net cash flow for each period (income + cost). May be discounted - if `disc_rates` is provided. + Net cash flow for each period (income + cost). * costs : np.ndarray - Total costs for each period. May be discounted if `disc_rates` - is provided. + Total costs for each period. * incomes : np.ndarray - Total incomes for each period. May be discounted if `disc_rates` - is provided. + Total incomes for each period. """ impl_ts = pd.Timestamp(impl_date) @@ -384,35 +377,11 @@ def calc_cash_flows( results = [self._calc_at_date(impl_ts, p.start_time) for p in periods] net, costs, incs = map(np.array, zip(*results)) - - if disc_rates is not None: - # Vectorized discounting - years = np.array([p.year for p in periods]) - # Note: Assumes disc.rates is indexed/aligned with disc.years - rate_map = dict(zip(disc_rates.years, disc_rates.rates)) - factors = np.array( - [ - 1 - / (1 + rate_map.get(yr, 0.0)) - ** (yr - pd.Timestamp(start_date).year) - for yr in years - ] - ) - # Handle potential length mismatch if years aren't in disc - valid = np.array([yr in rate_map for yr in years]) - return ( - net[valid] * factors[valid], - costs[valid] * factors[valid], - incs[valid] * factors[valid], - ) - return net, costs, incs - def calc_total( - self, impl_date, start_date, end_date, disc: Optional[DiscRates] = None - ) -> Tuple[float, float, float]: + def calc_total(self, impl_date, start_date, end_date) -> Tuple[float, float, float]: """ - Calculate the total or net present value of the cash flows over a given period. + Calculate the total value of the cash flows over a given period. Parameters: ----------- @@ -422,17 +391,15 @@ def calc_total( The start date of the period. end_year: int The end year of the period. - disc: DiscRates, optional - The discount rates to apply. Returns: -------- Tuple[float, float, float] - the total net, cost, and income present values over the given period + the total net, cost, and income values over the given period. """ net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date, disc_rates=disc + impl_date, start_date, end_date ) return np.sum(net_cash_flows), np.sum(costs), np.sum(incomes) @@ -441,7 +408,6 @@ def plot_cash_flows( impl_date: Any, start_date: Any, end_date: Any, - disc: Optional[Any] = None, to_plot: List[str] = ["net", "cost", "income"], ): """ @@ -455,15 +421,13 @@ def plot_cash_flows( The start date of the period. end_date: datetime The end date of the period. - disc: DiscRates object - The discount rates (optional). to_plot: list List of strings indicating which cash flows to plot. Options are 'net', 'cost', 'income'. """ # Calculate the cash flows over the given period net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date, disc_rates=disc + impl_date, start_date, end_date ) # Plot the cash flows with colors @@ -500,18 +464,14 @@ def plot_cash_flows( fig.autofmt_xdate() plt.xlabel("Date") plt.ylabel("Cash Flow") - plt.title("Discounted Cash Flows" if disc else "Cash Flows") + plt.title("Cash Flows") plt.legend() plt.show() return ax - def to_dataframe( - self, impl_date, start_date, end_date, disc_rates: Optional[DiscRates] = None - ) -> pd.DataFrame: + def to_dataframe(self, impl_date, start_date, end_date) -> pd.DataFrame: """Return cash flows as a formatted DataFrame.""" - net, costs, incs = self.calc_cash_flows( - impl_date, start_date, end_date, disc_rates=disc_rates - ) + net, costs, incs = self.calc_cash_flows(impl_date, start_date, end_date) periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) return pd.DataFrame( From 971a77255722f51e0b624f2a019f2e33eafe7147 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 12:07:12 +0200 Subject: [PATCH 06/23] Adds unit tests --- .../entity/measures/test/test_cost_income.py | 397 ++++++++++++++++++ 1 file changed, 397 insertions(+) create mode 100644 climada/entity/measures/test/test_cost_income.py diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py new file mode 100644 index 0000000000..bf546b9b91 --- /dev/null +++ b/climada/entity/measures/test/test_cost_income.py @@ -0,0 +1,397 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Unit tests for the CostIncome class. +""" + +from datetime import datetime +from unittest.mock import MagicMock, patch + +import numpy as np +import pandas as pd +import pytest + +from climada.entity.disc_rates.base import DiscRates +from climada.entity.measures.cost_income import CostIncome + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + + +def make_disc_rates(years=None, rates=None): + """Build a minimal DiscRates stub.""" + dr = MagicMock(spec=DiscRates) + dr.years = np.array(years or list(range(2020, 2031))) + dr.rates = np.array(rates or [0.05] * len(dr.years)) + return dr + + +# --------------------------------------------------------------------------- +# __init__ / construction +# --------------------------------------------------------------------------- + + +class TestInit: + def test_defaults(self): + ci = CostIncome() + assert ci.init_cost == 0.0 + assert ci.periodic_cost == 0.0 + assert ci.periodic_income == 0.0 + assert ci.cost_growth_rate == 0.0 + assert ci.income_growth_rate == 0.0 + assert ci.freq == "Y" + assert ci.custom_cash_flows is None + + def test_costs_stored_negative(self): + ci = CostIncome(init_cost=100, periodic_cost=50) + assert ci.init_cost == -100.0 + assert ci.periodic_cost == -50.0 + + def test_costs_already_negative_stay_negative(self): + ci = CostIncome(init_cost=-200, periodic_cost=-30) + assert ci.init_cost == -200.0 + assert ci.periodic_cost == -30.0 + + def test_income_stored_positive(self): + ci = CostIncome(periodic_income=-80) + assert ci.periodic_income == 80.0 + + def test_mkt_price_year_default_is_current_year(self): + ci = CostIncome() + assert ci.mkt_price_year.year == datetime.today().year + + def test_mkt_price_year_custom(self): + ci = CostIncome(mkt_price_year=2015) + assert ci.mkt_price_year.year == 2015 + + def test_custom_cash_flows_processed(self): + df = pd.DataFrame( + { + "date": ["2020-01-01", "2020-06-01"], + "cost": [100, 200], + "income": [50, 60], + } + ) + ci = CostIncome(custom_cash_flows=df, freq="Y") + # After resampling to yearly, should have one row per year + assert isinstance(ci.custom_cash_flows, pd.DataFrame) + assert "cost" in ci.custom_cash_flows.columns + # Costs should be negative after processing + assert (ci.custom_cash_flows["cost"] <= 0).all() + + +# --------------------------------------------------------------------------- +# from_dict / from_config / from_yaml +# --------------------------------------------------------------------------- + + +class TestFromDict: + def test_basic(self): + d = { + "mkt_price_year": 2020, + "init_cost": 500, + "periodic_cost": 100, + "periodic_income": 200, + "cost_yearly_growth_rate": 0.02, + "income_yearly_growth_rate": 0.03, + "freq": "Y", + } + ci = CostIncome.from_dict(d) + assert ci.init_cost == -500.0 + assert ci.periodic_income == 200.0 + assert ci.cost_growth_rate == 0.02 + + def test_defaults_for_missing_keys(self): + ci = CostIncome.from_dict({}) + assert ci.init_cost == 0.0 + assert ci.freq == "Y" + + def test_with_custom_cash_flows(self): + d = { + "freq": "Y", + "custom_cash_flows": [ + {"date": "2021-01-01", "cost": 100, "income": 50}, + ], + } + ci = CostIncome.from_dict(d) + assert ci.custom_cash_flows is not None + + +class TestFromYaml: + def test_from_yaml(self, tmp_path): + yaml_content = """ +cost_income: + mkt_price_year: 2020 + init_cost: 1000 + periodic_cost: 200 + periodic_income: 300 + cost_yearly_growth_rate: 0.01 + income_yearly_growth_rate: 0.02 + freq: Y +""" + p = tmp_path / "ci.yaml" + p.write_text(yaml_content) + ci = CostIncome.from_yaml(str(p)) + assert ci.init_cost == -1000.0 + assert ci.periodic_income == 300.0 + + +# --------------------------------------------------------------------------- +# _freq_to_days +# --------------------------------------------------------------------------- + + +class TestFreqToDays: + def test_yearly(self): + result = CostIncome._freq_to_days("Y") + assert result == "365d" + + def test_monthly(self): + result = CostIncome._freq_to_days("M") + assert result == "30d" + + def test_daily(self): + result = CostIncome._freq_to_days("D") + assert result == "1d" + + def test_invalid(self): + with pytest.raises(ValueError): + CostIncome._freq_to_days("INVALID_FREQ_XYZ") + + +# --------------------------------------------------------------------------- +# _get_width_days +# --------------------------------------------------------------------------- + + +class TestGetWidthDays: + def test_yearly(self): + ci = CostIncome(freq="Y") + assert ci._get_width_days() == 365.0 + + def test_daily(self): + ci = CostIncome(freq="D") + assert ci._get_width_days() == 1.0 + + +# --------------------------------------------------------------------------- +# _calc_at_date +# --------------------------------------------------------------------------- + + +class TestCalcAtDate: + def test_before_impl_date_is_zero(self): + ci = CostIncome(mkt_price_year=2020, init_cost=1000, periodic_income=500) + impl = pd.Timestamp("2021-01-01") + curr = pd.Timestamp("2020-01-01") + net, cost, inc = ci._calc_at_date(impl, curr) + assert net == 0.0 + assert cost == 0.0 + assert inc == 0.0 + + def test_at_impl_date_uses_init_cost(self): + ci = CostIncome(mkt_price_year=2021, init_cost=1000, periodic_income=0) + impl = pd.Timestamp("2021-01-01") + net, cost, inc = ci._calc_at_date(impl, impl) + assert cost == pytest.approx(-1000.0, rel=1e-3) + assert inc == pytest.approx(0.0) + + def test_after_impl_date_uses_periodic_cost(self): + ci = CostIncome(mkt_price_year=2020, periodic_cost=200, periodic_income=0) + impl = pd.Timestamp("2021-01-01") + curr = pd.Timestamp("2022-01-01") + net, cost, inc = ci._calc_at_date(impl, curr) + assert cost < 0 + assert abs(cost) == 200 + + def test_income_growth_applied(self): + ci = CostIncome( + mkt_price_year=2020, periodic_income=100, income_yearly_growth_rate=0.10 + ) + impl = pd.Timestamp("2020-01-01") + curr = pd.Timestamp("2021-01-01") + _, _, inc = ci._calc_at_date(impl, curr) + expected = 100 * (1.10**1.0) + assert inc == pytest.approx(expected, rel=1e-2) + + def test_net_equals_income_plus_cost(self): + ci = CostIncome(mkt_price_year=2020, periodic_cost=100, periodic_income=150) + impl = pd.Timestamp("2020-01-01") + curr = pd.Timestamp("2021-01-01") + net, cost, inc = ci._calc_at_date(impl, curr) + assert net == pytest.approx(cost + inc) + + def test_custom_cash_flows_added(self): + df = pd.DataFrame( + { + "date": ["2021-01-01"], + "cost": [500.0], + "income": [200.0], + } + ) + ci = CostIncome(mkt_price_year=2021, custom_cash_flows=df, freq="Y") + print(ci.custom_cash_flows) + impl = pd.Timestamp("2021-01-01") + curr = pd.Timestamp("2021-01-01") + net, cost, inc = ci._calc_at_date(impl, curr) + assert inc == pytest.approx(200.0, rel=1e-3) + assert cost == pytest.approx(-500.0, rel=1e-3) + + +# --------------------------------------------------------------------------- +# calc_cash_flows +# --------------------------------------------------------------------------- + + +class TestCalcCashFlows: + def test_returns_three_arrays(self): + ci = CostIncome(mkt_price_year=2020, periodic_income=100) + net, costs, incs = ci.calc_cash_flows("2020-01-01", "2020-01-01", "2025-01-01") + assert isinstance(net, np.ndarray) + assert isinstance(costs, np.ndarray) + assert isinstance(incs, np.ndarray) + + def test_length_matches_periods(self): + ci = CostIncome(freq="Y") + net, costs, incs = ci.calc_cash_flows("2020-01-01", "2020-01-01", "2024-01-01") + periods = pd.period_range("2020-01-01", "2024-01-01", freq="Y") + assert len(net) == len(periods) + + def test_zero_cost_income(self): + ci = CostIncome() + net, costs, incs = ci.calc_cash_flows("2020-01-01", "2020-01-01", "2023-01-01") + np.testing.assert_array_equal(net, 0.0) + + def test_nonzero_cost_income(self): + ci = CostIncome( + mkt_price_year=2020, init_cost=5000, periodic_cost=200, periodic_income=1000 + ) + net, cost, income = ci.calc_cash_flows( + impl_date="2020-01-01", start_date="2019-01-01", end_date="2025-01-01" + ) + np.testing.assert_array_equal( + net, [0.0, -5000.0, 800.0, 800.0, 800.0, 800.0, 800.0] + ) + np.testing.assert_array_equal( + cost, [0.0, -5000.0, -200.0, -200.0, -200.0, -200.0, -200.0] + ) + np.testing.assert_array_equal( + income, [0.0, 0.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0] + ) + + +# --------------------------------------------------------------------------- +# calc_total +# --------------------------------------------------------------------------- + + +class TestCalcTotal: + def test_total_is_sum_of_cash_flows(self): + ci = CostIncome(mkt_price_year=2020, periodic_income=100, periodic_cost=50) + net_arr, cost_arr, inc_arr = ci.calc_cash_flows( + "2020-01-01", "2020-01-01", "2024-01-01" + ) + total_net, total_cost, total_inc = ci.calc_total( + "2020-01-01", "2020-01-01", "2024-01-01" + ) + assert total_net == pytest.approx(float(np.sum(net_arr))) + assert total_cost == pytest.approx(float(np.sum(cost_arr))) + assert total_inc == pytest.approx(float(np.sum(inc_arr))) + + def test_returns_floats(self): + ci = CostIncome() + result = ci.calc_total("2020-01-01", "2020-01-01", "2022-01-01") + assert all(isinstance(v, (float, np.floating)) for v in result) + + +# --------------------------------------------------------------------------- +# to_dataframe +# --------------------------------------------------------------------------- + + +class TestToDataframe: + def test_columns(self): + ci = CostIncome(periodic_income=100) + df = ci.to_dataframe("2020-01-01", "2020-01-01", "2023-01-01") + assert set(df.columns) == {"date", "net", "cost", "income"} + + def test_row_count(self): + ci = CostIncome(freq="Y") + df = ci.to_dataframe("2020-01-01", "2020-01-01", "2022-01-01") + expected = len(pd.period_range("2020-01-01", "2022-01-01", freq="Y")) + assert len(df) == expected + + +# --------------------------------------------------------------------------- +# comb_cost_income +# --------------------------------------------------------------------------- + + +class TestCombCostIncome: + def test_costs_are_summed(self): + ci1 = CostIncome(mkt_price_year=2020, init_cost=100, periodic_cost=50) + ci2 = CostIncome(mkt_price_year=2020, init_cost=200, periodic_cost=30) + combined = CostIncome.comb_cost_income([ci1, ci2]) + assert combined.init_cost == -300.0 + assert combined.periodic_cost == -80.0 + + def test_incomes_are_summed(self): + ci1 = CostIncome(mkt_price_year=2020, periodic_income=100) + ci2 = CostIncome(mkt_price_year=2020, periodic_income=200) + combined = CostIncome.comb_cost_income([ci1, ci2]) + assert combined.periodic_income == 300.0 + + def test_mismatched_mkt_price_year_raises(self): + ci1 = CostIncome(mkt_price_year=2020) + ci2 = CostIncome(mkt_price_year=2021) + with pytest.raises(ValueError, match="market price years"): + CostIncome.comb_cost_income([ci1, ci2]) + + def test_mismatched_cost_growth_rate_raises(self): + ci1 = CostIncome(mkt_price_year=2020, cost_yearly_growth_rate=0.02) + ci2 = CostIncome(mkt_price_year=2020, cost_yearly_growth_rate=0.05) + with pytest.raises(ValueError, match="cost_growth_rate"): + CostIncome.comb_cost_income([ci1, ci2]) + + def test_mismatched_income_growth_rate_raises(self): + ci1 = CostIncome(mkt_price_year=2020, income_yearly_growth_rate=0.01) + ci2 = CostIncome(mkt_price_year=2020, income_yearly_growth_rate=0.03) + with pytest.raises(ValueError, match="income_growth_rate"): + CostIncome.comb_cost_income([ci1, ci2]) + + def test_single_element_list(self): + ci = CostIncome(mkt_price_year=2020, init_cost=500, periodic_income=100) + combined = CostIncome.comb_cost_income([ci]) + assert combined.init_cost == -500.0 + assert combined.periodic_income == 100.0 + + def test_preserves_growth_rates(self): + ci1 = CostIncome( + mkt_price_year=2020, + cost_yearly_growth_rate=0.02, + income_yearly_growth_rate=0.03, + ) + ci2 = CostIncome( + mkt_price_year=2020, + cost_yearly_growth_rate=0.02, + income_yearly_growth_rate=0.03, + ) + combined = CostIncome.comb_cost_income([ci1, ci2]) + assert combined.cost_growth_rate == 0.02 + assert combined.income_growth_rate == 0.03 From 243cbacdc95380a0ed8c347f1e932fd62fdb80ae Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 14:24:10 +0200 Subject: [PATCH 07/23] Adds nice __repr__ --- climada/entity/measures/cost_income.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 60c9c8f8eb..1d205f093c 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -107,6 +107,21 @@ def __init__( else: self.custom_cash_flows = None + def __repr__(self) -> str: + lines = [ + "CostIncome(", + f" mkt_price_year = {self.mkt_price_year.year}", + f" freq = {self.freq!r}", + f" init_cost = {self.init_cost:,.2f}", + f" periodic_cost = {self.periodic_cost:,.2f}", + f" periodic_income = {self.periodic_income:,.2f}", + f" cost_yearly_growth_rate = {self.cost_growth_rate:.2%}", + f" income_yearly_growth_rate = {self.income_growth_rate:.2%}", + f" custom_cash_flows = {None if self.custom_cash_flows is None else f'DataFrame({len(self.custom_cash_flows)} rows)'}", + ")", + ] + return "\n".join(lines) + def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: """Process and resample custom cash flow dataframe From a17f2e27ce8cd4d479f973be2ce28250e248a705 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 14:26:08 +0200 Subject: [PATCH 08/23] Improves freq handling, nicer plot --- climada/entity/measures/cost_income.py | 157 +++++++++++++++---------- 1 file changed, 94 insertions(+), 63 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 1d205f093c..33ece8de1c 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -144,17 +144,22 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: if "date" in df.columns: df["date"] = pd.to_datetime(df["date"]) df = df.set_index("date") - match self.freq: + + freq = self._make_offset_compat(self.freq) + return df.resample(freq).sum() + + @staticmethod + def _make_offset_compat(freq: str, start=True) -> str: + suffix = "S" if start else "E" + match freq: case "Y": - resampling_freq = "YS" + return "Y" + suffix case "M": - resampling_freq = "MS" + return "M" + suffix case "Q": - resampling_freq = "QS" + return "Q" + suffix case _: - resampling_freq = self.freq - - return df.resample(resampling_freq).sum() + return freq @classmethod def from_config(cls, config: CostIncomeConfig) -> "CostIncome": @@ -231,8 +236,8 @@ def from_yaml(cls, path: str) -> "CostIncome": with open(path) as f: return cls.from_dict(yaml.safe_load(f)["cost_income"]) - @staticmethod - def _freq_to_days(freq: str) -> str: + @classmethod + def _freq_to_days(cls, freq: str) -> str: """ Convert a frequency string to the equivalent number of days. @@ -249,6 +254,7 @@ def _freq_to_days(freq: str) -> str: try: # Convert the frequency string to a DateOffset object + freq = cls._make_offset_compat(freq, start=False) offset = pd.tseries.frequencies.to_offset(freq) # Calculate the number of days by applying the offset to a base date @@ -264,7 +270,8 @@ def _get_width_days(self) -> float: """Return the number of days in the current frequency.""" ref = pd.Timestamp("2000-01-01") - offset = pd.tseries.frequencies.to_offset(self.freq) + freq = self._make_offset_compat(self.freq, start=False) + offset = pd.tseries.frequencies.to_offset(freq) return float(((ref + offset) - ref).days) def _calc_at_date( @@ -342,7 +349,10 @@ def _calc_at_date( cost = self.periodic_cost * cost_factor income = self.periodic_income * inc_factor - if self.custom_cash_flows is not None: + if ( + self.custom_cash_flows is not None + and curr_date in self.custom_cash_flows.index + ): c_cost = cast(float, self.custom_cash_flows.loc[curr_date, "cost"]) c_inc = cast(float, self.custom_cash_flows.loc[curr_date, "income"]) else: @@ -423,66 +433,87 @@ def plot_cash_flows( impl_date: Any, start_date: Any, end_date: Any, - to_plot: List[str] = ["net", "cost", "income"], + figsize: Tuple[int, int] = (12, 7), + title: Optional[str] = None, ): - """ - Plot the cash flows over a given period. + """Plot periodic and cumulative cash flows over a given period. - Parameters: - ----------- - impl_date: datetime + Displays a two-panel figure: + - Top panel: stacked bar chart of costs and incomes per period, + with a net cash flow line overlay. + - Bottom panel: cumulative net cash flow over time. + + Parameters + ---------- + impl_date : The date the measure is implemented. - start_date: datetime - The start date of the period. - end_date: datetime - The end date of the period. - to_plot: list - List of strings indicating which cash flows to plot. Options are 'net', 'cost', 'income'. + start_date : + Start of the evaluation period. + end_date : + End of the evaluation period. + figsize : tuple, optional + Figure size as (width, height). Default is (12, 7). + title : str, optional + Overall figure title. Defaults to 'Cash Flow Analysis'. + + Returns + ------- + plt.Figure """ + net, costs, incomes = self.calc_cash_flows(impl_date, start_date, end_date) + periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) + dates = [p.start_time for p in periods] + cumulative_net = np.cumsum(net) - # Calculate the cash flows over the given period - net_cash_flows, costs, incomes = self.calc_cash_flows( - impl_date, start_date, end_date - ) + width = pd.Timedelta(days=self._get_width_days() * 0.6) - # Plot the cash flows with colors - date_range = pd.date_range( - start=start_date, end=end_date, freq=self._freq_to_days(self.freq) + fig, (ax_bar, ax_cum) = plt.subplots( + 2, + 1, + figsize=figsize, + sharex=True, + gridspec_kw={"height_ratios": [3, 1], "hspace": 0.08}, ) - width = self._get_width_days() * 0.8 # 80% width for visibility - fig, ax = plt.subplots() - - if "cost" in to_plot: - ax.bar(date_range, costs, color="red", label="Cost", width=width) - if "income" in to_plot: - ax.bar( - date_range, - incomes, - color="blue", - label="Income", - alpha=0.7, - width=width, - ) - if "net" in to_plot: - ax.bar( - date_range, - net_cash_flows, - color="blue", - edgecolor="red", - hatch="//", - label="Net", - alpha=0.5, - width=width, - ) - ax.xaxis_date() # <---- treat x-ticks as datetime - fig.autofmt_xdate() - plt.xlabel("Date") - plt.ylabel("Cash Flow") - plt.title("Cash Flows") - plt.legend() - plt.show() - return ax + # --- top panel: stacked bars + net line --- + ax_bar.bar( + dates, incomes, width=width, color="#4C9BE8", label="Income", zorder=2 + ) + ax_bar.bar(dates, costs, width=width, color="#E8604C", label="Cost", zorder=2) + ax_bar.plot( + dates, + net, + color="black", + linewidth=1.5, + marker="o", + markersize=4, + label="Net", + zorder=3, + ) + ax_bar.axhline(0, color="black", linewidth=0.6, linestyle="--", zorder=1) + + ax_bar.set_ylabel("Cash flow") + ax_bar.legend(frameon=False, fontsize=9) + ax_bar.spines[["top", "right"]].set_visible(False) + ax_bar.tick_params(axis="x", which="both", bottom=False) + ax_bar.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:,.0f}")) + + # --- bottom panel: cumulative net --- + # dates = dates.append() + positive = np.maximum(cumulative_net, 0) + negative = np.minimum(cumulative_net, 0) + ax_cum.fill_between(dates, positive, alpha=0.25, color="#4C9BE8", step="mid") + ax_cum.fill_between(dates, negative, alpha=0.25, color="#E8604C", step="mid") + # ax_cum.plot(dates, cumulative_net, color="black", linewidth=1.5, zorder=3) + ax_cum.axhline(0, color="black", linewidth=0.6, linestyle="--", zorder=1) + + ax_cum.set_ylabel("Cumulative net") + ax_cum.spines[["top", "right"]].set_visible(False) + ax_cum.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:,.0f}")) + + fig.autofmt_xdate(rotation=30, ha="right") + fig.suptitle(title or "Cash Flow Analysis", fontsize=13, y=1.01) + return (ax_bar, ax_cum) def to_dataframe(self, impl_date, start_date, end_date) -> pd.DataFrame: """Return cash flows as a formatted DataFrame.""" From abe1fdffe0a126c11a4ece74f75f95776cc5dc0a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 14:26:43 +0200 Subject: [PATCH 09/23] Adds test for freq manipulations --- climada/entity/measures/test/test_cost_income.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index bf546b9b91..f9d6667db3 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -185,6 +185,14 @@ def test_yearly(self): ci = CostIncome(freq="Y") assert ci._get_width_days() == 365.0 + def test_3yearly(self): + ci = CostIncome(freq="3Y") + assert ci._get_width_days() == 3 * 365.0 + + def test_monthly(self): + ci = CostIncome(freq="M") + assert ci._get_width_days() == 30.0 + def test_daily(self): ci = CostIncome(freq="D") assert ci._get_width_days() == 1.0 From 1513c115b37f20b9d56deff06eab488d33f63234 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 14:28:14 +0200 Subject: [PATCH 10/23] Adds tutorial file --- doc/user-guide/climada_cost_income.ipynb | 1020 ++++++++++++++++++++++ 1 file changed, 1020 insertions(+) create mode 100644 doc/user-guide/climada_cost_income.ipynb diff --git a/doc/user-guide/climada_cost_income.ipynb b/doc/user-guide/climada_cost_income.ipynb new file mode 100644 index 0000000000..bf1834140e --- /dev/null +++ b/doc/user-guide/climada_cost_income.ipynb @@ -0,0 +1,1020 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2147f042", + "metadata": {}, + "source": [ + "(cost-income-tutorial)=\n", + "# Measure cash flows with `CostIncome`\n", + "\n", + "This notebook introduces the `CostIncome` class from CLIMADA, which is used to model the financial cash flows of adaptation or risk-reduction measures over time.\n", + "\n", + "A `CostIncome` object tracks:\n", + "- **Initial (one-off) costs** — the upfront implementation cost\n", + "- **Periodic costs** — recurring expenses (e.g., maintenance)\n", + "- **Periodic income** — recurring revenues (e.g., insurance savings, avoided losses)\n", + "- **Growth rates** — how costs and incomes evolve over time\n", + "- **Custom cash flows** — arbitrary user-defined flows (layered on top)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a73bc8d1", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Adjust the import path if running outside the CLIMADA package tree\n", + "from climada.entity.measures.cost_income import CostIncome" + ] + }, + { + "cell_type": "markdown", + "id": "a97e1043", + "metadata": {}, + "source": [ + "## Quickstart\n", + "\n", + "The simplest way to create a `CostIncome` is by passing keyword arguments directly.\n", + "\n", + "| Parameter | Meaning | Sign convention |\n", + "|---|---|---|\n", + "| `init_cost` | One-off implementation cost | stored negative |\n", + "| `periodic_cost` | Recurring cost each period | stored negative |\n", + "| `periodic_income` | Recurring income each period | stored positive |\n", + "| `mkt_price_year` | Reference year for price levels | — |\n", + "| `freq` | Period frequency (e.g. `'Y'`, `'M'`, `'Q'`) | — |\n", + "\n", + "```{note} **Sign convention**\n", + "`CostIncome` stores costs as negative numbers internally.\n", + "```\n", + "\n", + "```{note}\n", + "Financial values in `CostIncome` are currently unitless (no currency is specified)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4ba16743", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CostIncome(\n", + " mkt_price_year = 2020\n", + " freq = 'Y'\n", + " init_cost = -20,000.00\n", + " periodic_cost = -5,000.00\n", + " periodic_income = 12,000.00\n", + " cost_yearly_growth_rate = 0.00%\n", + " income_yearly_growth_rate = 0.00%\n", + " custom_cash_flows = None\n", + ")\n" + ] + } + ], + "source": [ + "ci = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=20_000, # 50 000 upfront\n", + " periodic_cost=5_000, # 5 000 / year maintenance\n", + " periodic_income=12_000, # 8 000 / year in avoided losses\n", + " freq=\"Y\", # annual cash flows\n", + ")\n", + "\n", + "print(ci)" + ] + }, + { + "cell_type": "markdown", + "id": "3c9a8398", + "metadata": {}, + "source": [ + "## Calculating cash flows\n", + "\n", + "Three methods are available:\n", + "\n", + "| Method | Returns |\n", + "|---|---|\n", + "| `calc_cash_flows(impl_date, start_date, end_date)` | Three `np.ndarray`: net, costs, incomes |\n", + "| `calc_total(...)` | Three scalars: summed net, cost, income |\n", + "| `to_dataframe(...)` | A tidy `pd.DataFrame` |\n", + "\n", + "The `impl_date` is when the measure is *deployed*. Cash flows before this date are zero; the initial cost lands on `impl_date`; periodic flows start the following period." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "25bf1e1f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Period | Net | Cost | Income\n", + "---------------------------------------------\n", + "2020 | 0 | 0 | 0\n", + "2021 | 0 | 0 | 0\n", + "2022 | -20000 | -20000 | 0\n", + "2023 | 7000 | -5000 | 12000\n", + "2024 | 7000 | -5000 | 12000\n", + "2025 | 7000 | -5000 | 12000\n", + "2026 | 7000 | -5000 | 12000\n", + "2027 | 7000 | -5000 | 12000\n", + "2028 | 7000 | -5000 | 12000\n", + "2029 | 7000 | -5000 | 12000\n", + "2030 | 7000 | -5000 | 12000\n" + ] + } + ], + "source": [ + "impl_date = \"2022-01-01\"\n", + "start_date = \"2020-01-01\"\n", + "end_date = \"2030-01-01\"\n", + "\n", + "net, costs, incomes = ci.calc_cash_flows(impl_date, start_date, end_date)\n", + "\n", + "print(\"Period | Net | Cost | Income\")\n", + "print(\"-\" * 45)\n", + "periods = pd.period_range(start=start_date, end=end_date, freq=\"Y\")\n", + "for p, n, c, i in zip(periods, net, costs, incomes):\n", + " print(f\"{p} | {n:>9.0f} | {c:>9.0f} | {i:>6.0f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "971ce0dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total net : 36000\n", + "Total cost : -60000\n", + "Total income : 96000\n" + ] + } + ], + "source": [ + "total_net, total_cost, total_income = ci.calc_total(impl_date, start_date, end_date)\n", + "print(f\"Total net : {total_net:>10.0f}\")\n", + "print(f\"Total cost : {total_cost:>10.0f}\")\n", + "print(f\"Total income : {total_income:>10.0f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f3fd0c35", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datenetcostincome
020200.00.00.0
120210.00.00.0
22022-20000.0-20000.00.0
320237000.0-5000.012000.0
420247000.0-5000.012000.0
520257000.0-5000.012000.0
620267000.0-5000.012000.0
720277000.0-5000.012000.0
820287000.0-5000.012000.0
920297000.0-5000.012000.0
1020307000.0-5000.012000.0
\n", + "
" + ], + "text/plain": [ + " date net cost income\n", + "0 2020 0.0 0.0 0.0\n", + "1 2021 0.0 0.0 0.0\n", + "2 2022 -20000.0 -20000.0 0.0\n", + "3 2023 7000.0 -5000.0 12000.0\n", + "4 2024 7000.0 -5000.0 12000.0\n", + "5 2025 7000.0 -5000.0 12000.0\n", + "6 2026 7000.0 -5000.0 12000.0\n", + "7 2027 7000.0 -5000.0 12000.0\n", + "8 2028 7000.0 -5000.0 12000.0\n", + "9 2029 7000.0 -5000.0 12000.0\n", + "10 2030 7000.0 -5000.0 12000.0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = ci.to_dataframe(impl_date, start_date, end_date)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "612c0b66", + "metadata": {}, + "source": [ + "## Visualising cash flows\n", + "\n", + "`plot_cash_flows` draws a bar chart. You can choose which series to display via the `to_plot` argument." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "315fc0ac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ci.plot_cash_flows(\n", + " impl_date,\n", + " start_date,\n", + " end_date,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4bb73614", + "metadata": {}, + "source": [ + "## Growth rates\n", + "\n", + "Costs and incomes can grow year-over-year using compound-interest factors anchored to `mkt_price_year`.\n", + "\n", + "$$\\text{value}(t) = \\text{base} \\times (1 + r)^{\\frac{t - t_0}{365}}$$\n", + "\n", + "Pass `cost_yearly_growth_rate` and / or `income_yearly_growth_rate` (as decimals, e.g. `0.02` for 2 %)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b69f1ae7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ci_growth = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=50_000,\n", + " periodic_cost=5_000,\n", + " periodic_income=8_000,\n", + " cost_yearly_growth_rate=0.02, # costs grow 2% / year\n", + " income_yearly_growth_rate=0.03, # income grows 3% / year\n", + " freq=\"Y\",\n", + ")\n", + "\n", + "ci_growth.plot_cash_flows(impl_date, start_date, end_date)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "067c07aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " No growth With growth\n", + "Net 36000 -19821\n", + "Cost -60000 -97569\n", + "Income 96000 77748\n" + ] + } + ], + "source": [ + "# Compare totals with and without growth\n", + "no_growth = ci.calc_total(impl_date, start_date, end_date)\n", + "with_growth = ci_growth.calc_total(impl_date, start_date, end_date)\n", + "\n", + "labels = [\"Net\", \"Cost\", \"Income\"]\n", + "print(f\"{'':15s} {'No growth':>12s} {'With growth':>12s}\")\n", + "for label, ng, wg in zip(labels, no_growth, with_growth):\n", + " print(f\"{label:15s} {ng:>12.0f} {wg:>12.0f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1408d2db", + "metadata": {}, + "source": [ + "## Custom cash flows\n", + "\n", + "For irregular or one-off flows, pass a `pd.DataFrame` with columns `date`, `cost`, and/or `income`.\n", + "\n", + "These are **added on top** of any periodic amounts; dates not present in the DataFrame simply contribute zero." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c469839c-e2e2-43e9-ac33-93de7f04a6d9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datenetcostincome
020200.00.00.0
120210.00.00.0
22022-50000.0-50000.00.0
320233000.0-5000.08000.0
42024-7000.0-15000.08000.0
520253000.0-5000.08000.0
6202618000.0-5000.023000.0
720273000.0-5000.08000.0
82028-17000.0-25000.08000.0
920293000.0-5000.08000.0
1020303000.0-5000.08000.0
\n", + "
" + ], + "text/plain": [ + " date net cost income\n", + "0 2020 0.0 0.0 0.0\n", + "1 2021 0.0 0.0 0.0\n", + "2 2022 -50000.0 -50000.0 0.0\n", + "3 2023 3000.0 -5000.0 8000.0\n", + "4 2024 -7000.0 -15000.0 8000.0\n", + "5 2025 3000.0 -5000.0 8000.0\n", + "6 2026 18000.0 -5000.0 23000.0\n", + "7 2027 3000.0 -5000.0 8000.0\n", + "8 2028 -17000.0 -25000.0 8000.0\n", + "9 2029 3000.0 -5000.0 8000.0\n", + "10 2030 3000.0 -5000.0 8000.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "custom_flows = pd.DataFrame(\n", + " {\n", + " \"date\": [\"2024-01-01\", \"2026-01-01\", \"2028-01-01\"],\n", + " \"cost\": [10_000, 0, 20_000], # extra one-off costs\n", + " \"income\": [0, 15_000, 0], # extra one-off income\n", + " }\n", + ")\n", + "\n", + "ci_custom = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=50_000,\n", + " periodic_cost=5_000,\n", + " periodic_income=8_000,\n", + " custom_cash_flows=custom_flows,\n", + " freq=\"Y\",\n", + ")\n", + "ci_custom.to_dataframe(impl_date, start_date, end_date)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "11f21296", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ci_custom.plot_cash_flows(impl_date, start_date, end_date)" + ] + }, + { + "cell_type": "markdown", + "id": "f1f011b6", + "metadata": {}, + "source": [ + "## Sub-annual frequencies\n", + "\n", + "`freq` accepts any pandas-compatible period string. Common options:\n", + "\n", + "| `freq` | Meaning |\n", + "|---|---|\n", + "| `\"Y\"` | Annual |\n", + "| `\"Q\"` | Quarterly |\n", + "| `\"M\"` | Monthly |\n", + "| `\"7D\"` | Every 7 days |\n", + "\n", + "```{note}\n", + "The periodic amounts are interpreted as **per-period** values, not annualised.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "277e6948", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datenetcostincome
02022-01-5000.0-5000.00.0
12022-02200.0-500.0700.0
22022-03200.0-500.0700.0
32022-04200.0-500.0700.0
42022-05200.0-500.0700.0
52022-06200.0-500.0700.0
62022-07200.0-500.0700.0
72022-08200.0-500.0700.0
82022-09200.0-500.0700.0
92022-10200.0-500.0700.0
102022-11200.0-500.0700.0
112022-12200.0-500.0700.0
\n", + "
" + ], + "text/plain": [ + " date net cost income\n", + "0 2022-01 -5000.0 -5000.0 0.0\n", + "1 2022-02 200.0 -500.0 700.0\n", + "2 2022-03 200.0 -500.0 700.0\n", + "3 2022-04 200.0 -500.0 700.0\n", + "4 2022-05 200.0 -500.0 700.0\n", + "5 2022-06 200.0 -500.0 700.0\n", + "6 2022-07 200.0 -500.0 700.0\n", + "7 2022-08 200.0 -500.0 700.0\n", + "8 2022-09 200.0 -500.0 700.0\n", + "9 2022-10 200.0 -500.0 700.0\n", + "10 2022-11 200.0 -500.0 700.0\n", + "11 2022-12 200.0 -500.0 700.0" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ci_monthly = CostIncome(\n", + " mkt_price_year=2022,\n", + " init_cost=5_000,\n", + " periodic_cost=500,\n", + " periodic_income=700,\n", + " freq=\"M\",\n", + ")\n", + "\n", + "df_monthly = ci_monthly.to_dataframe(\n", + " impl_date=\"2022-01-01\",\n", + " start_date=\"2022-01-01\",\n", + " end_date=\"2022-12-01\",\n", + ")\n", + "df_monthly" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "03a80747", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ci_monthly.plot_cash_flows(\n", + " \"2022-01-01\",\n", + " \"2022-01-01\",\n", + " \"2022-12-01\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "10191dfd", + "metadata": {}, + "source": [ + "## Combining multiple CostIncome objects\n", + "\n", + "`CostIncome.comb_cost_income()` aggregates a list of `CostIncome` objects into a single one by summing costs and incomes.\n", + "\n", + "```{warning}\n", + "All objects must share the same `mkt_price_year`, `cost_growth_rate`, and `income_growth_rate`.\n", + "```\n", + "\n", + "```{note}\n", + "`custom_cash_flows` are **not** carried over to the combined object. Merge custom flows manually beforehand if needed.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "666fd82b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CostIncome(\n", + " mkt_price_year = 2020\n", + " freq = 'Y'\n", + " init_cost = -50,000.00\n", + " periodic_cost = -5,000.00\n", + " periodic_income = 8,000.00\n", + " cost_yearly_growth_rate = 0.00%\n", + " income_yearly_growth_rate = 0.00%\n", + " custom_cash_flows = None\n", + ")\n" + ] + } + ], + "source": [ + "ci_a = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=30_000,\n", + " periodic_cost=2_000,\n", + " periodic_income=4_000,\n", + " freq=\"Y\",\n", + ")\n", + "\n", + "ci_b = CostIncome(\n", + " mkt_price_year=2020,\n", + " init_cost=20_000,\n", + " periodic_cost=3_000,\n", + " periodic_income=4_000,\n", + " freq=\"Y\",\n", + ")\n", + "\n", + "ci_combined = CostIncome.comb_cost_income([ci_a, ci_b])\n", + "\n", + "print(ci_combined)" + ] + }, + { + "cell_type": "markdown", + "id": "8a15baaf", + "metadata": {}, + "source": [ + "## Loading from dict / YAML\n", + "\n", + "### From a Python dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "eeac2088", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CostIncome(\n", + " mkt_price_year = 2020\n", + " freq = 'Y'\n", + " init_cost = -50,000.00\n", + " periodic_cost = -5,000.00\n", + " periodic_income = 8,000.00\n", + " cost_yearly_growth_rate = 2.00%\n", + " income_yearly_growth_rate = 3.00%\n", + " custom_cash_flows = None\n", + ")\n" + ] + } + ], + "source": [ + "config_dict = {\n", + " \"mkt_price_year\": 2020,\n", + " \"init_cost\": 50_000,\n", + " \"periodic_cost\": 5_000,\n", + " \"periodic_income\": 8_000,\n", + " \"cost_yearly_growth_rate\": 0.02,\n", + " \"income_yearly_growth_rate\": 0.03,\n", + " \"freq\": \"Y\",\n", + "}\n", + "\n", + "ci_from_dict = CostIncome.from_dict(config_dict)\n", + "print(ci_from_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "0b2a868e", + "metadata": {}, + "source": [ + "### From a YAML file\n", + "\n", + "Create a YAML file structured as follows, then load it with `CostIncome.from_yaml`.\n", + "\n", + "```yaml\n", + "# measure_cost.yaml\n", + "cost_income:\n", + " mkt_price_year: 2020\n", + " init_cost: 50000\n", + " periodic_cost: 5000\n", + " periodic_income: 8000\n", + " cost_yearly_growth_rate: 0.02\n", + " income_yearly_growth_rate: 0.03\n", + " freq: \"Y\"\n", + " # Optional custom flows:\n", + " # custom_cash_flows:\n", + " # - date: \"2024-01-01\"\n", + " # cost: 10000\n", + " # income: 0\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:climada_env_dev]", + "language": "python", + "name": "conda-env-climada_env_dev-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 53ccaf7477808db1d618c325e5d6b78c6cd86953 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 9 Apr 2026 15:05:47 +0200 Subject: [PATCH 11/23] Includes notebook in documentation index --- doc/user-guide/adaptation.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/user-guide/adaptation.rst b/doc/user-guide/adaptation.rst index a7424da05b..647eddc7ac 100644 --- a/doc/user-guide/adaptation.rst +++ b/doc/user-guide/adaptation.rst @@ -9,6 +9,6 @@ These guides show everything you need to know in order to evaluate adapation opt .. Adaptation measures in CLIMADA Using measure configurations - .. Defining measure cash flows + Defining measure cash flows .. Cost benefit evaluation .. Adapation planning evaluation From a9fd1c699f0e03575c3e6b5af4bc3c2eafcdd68a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 09:25:41 +0200 Subject: [PATCH 12/23] Updates changelog --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 58775e3ef1..36ccd483c0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,7 +12,8 @@ Code freeze date: YYYY-MM-DD ### Added -- Better type hints and overloads signatures for ImpactFuncSet [#1250](https://github.com/CLIMADA-project/climada_python/pull/1250) +- Better type hints and overloads signatures for `ImpactFuncSet` [#1250](https://github.com/CLIMADA-project/climada_python/pull/1250) +- Adds `CostIncome` class and related tutorial for future new `Measure` class. [#1277](https://github.com/CLIMADA-project/climada_python/pull/1277) ### Changed - Updated Impact Calculation Tutorial (`doc.climada_engine_Impact.ipynb`) [#1095](https://github.com/CLIMADA-project/climada_python/pull/1095). From d787844f3d6b86201ab1dd5e0d973789788478ae Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 11:29:45 +0200 Subject: [PATCH 13/23] Adds class to rst index --- doc/api/climada/measures.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/api/climada/measures.rst b/doc/api/climada/measures.rst index 62f8b2d949..d0557c58e3 100644 --- a/doc/api/climada/measures.rst +++ b/doc/api/climada/measures.rst @@ -12,3 +12,11 @@ climada\.entity\.measures\.measure_config module :members: :undoc-members: :show-inheritance: + +climada\.entity\.measures\.cost_income module +--------------------------------------------- + +.. automodule:: climada.entity.measures.cost_income + :members: + :undoc-members: + :show-inheritance: From ef39bde4cbfc769dac0e62b44b1bb81bed717c29 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 10 Apr 2026 11:35:30 +0200 Subject: [PATCH 14/23] Adds class to rst index --- doc/api/climada/climada.entity.measures.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/api/climada/climada.entity.measures.rst b/doc/api/climada/climada.entity.measures.rst index 62f8b2d949..82207c7a9a 100644 --- a/doc/api/climada/climada.entity.measures.rst +++ b/doc/api/climada/climada.entity.measures.rst @@ -12,3 +12,11 @@ climada\.entity\.measures\.measure_config module :members: :undoc-members: :show-inheritance: + +climada\.entity\.measures\.cost_income module +------------------------------------------------ + +.. automodule:: climada.entity.measures.cost_income + :members: + :undoc-members: + :show-inheritance: From 0003869c13e1458ee7869b0da7e98c47f15e8928 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 11:21:39 +0200 Subject: [PATCH 15/23] Improves custom cash flows, updates tests --- climada/entity/measures/cost_income.py | 64 ++++++++++++++--- .../entity/measures/test/test_cost_income.py | 72 ++++++++++++------- 2 files changed, 100 insertions(+), 36 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 33ece8de1c..9b61b25437 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -20,13 +20,12 @@ """ from datetime import datetime -from typing import Any, List, Optional, Tuple, cast +from typing import Any, Optional, Tuple, cast import matplotlib.pyplot as plt import numpy as np import pandas as pd -from climada.entity.disc_rates.base import DiscRates from climada.entity.measures.measure_config import CostIncomeConfig @@ -101,11 +100,7 @@ def __init__( self.periodic_income = abs(periodic_income) self.income_growth_rate = income_yearly_growth_rate - - if custom_cash_flows is not None: - self.custom_cash_flows = self._prepare_custom_flows(custom_cash_flows) - else: - self.custom_cash_flows = None + self.custom_cash_flows = custom_cash_flows def __repr__(self) -> str: lines = [ @@ -122,6 +117,21 @@ def __repr__(self) -> str: ] return "\n".join(lines) + @property + def custom_cash_flows(self) -> pd.DataFrame | None: + return self._custom_cash_flows + + @custom_cash_flows.setter + def custom_cash_flows(self, value, /): + if value is None: + self._custom_cash_flows = None + + else: + if not isinstance(value, pd.DataFrame): + raise ValueError("Custom cash flows only accept pandas DataFrame.") + + self._custom_cash_flows = self._prepare_custom_flows(value) + def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: """Process and resample custom cash flow dataframe @@ -138,9 +148,18 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: Processed custom cashflow """ + if "date" not in df.columns: + raise ValueError("No 'date' column found in custom cash flow DataFrame.") + + if "cost" not in df.columns and "income" not in df.columns: + raise ValueError( + "No 'cost' or 'income' column found in custom cash flow DataFrame." + ) + df = df.copy() if "cost" in df.columns: df["cost"] = -df["cost"].abs() + if "date" in df.columns: df["date"] = pd.to_datetime(df["date"]) df = df.set_index("date") @@ -274,7 +293,7 @@ def _get_width_days(self) -> float: offset = pd.tseries.frequencies.to_offset(freq) return float(((ref + offset) - ref).days) - def _calc_at_date( + def calc_at_date( self, impl_date: pd.Timestamp, curr_date: pd.Timestamp ) -> Tuple[float, float, float]: r"""Calculate cash flows for a single timestamp. @@ -397,10 +416,12 @@ def calc_cash_flows( Total incomes for each period. """ - impl_ts = pd.Timestamp(impl_date) + # 'Trick' to make sure that e.g., impl_date "2020-01-05" falls in + # period "2020-01" if freq is "M" + impl_ts = pd.Timestamp(str(impl_date)).to_period(self.freq).start_time periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) - results = [self._calc_at_date(impl_ts, p.start_time) for p in periods] + results = [self.calc_at_date(impl_ts, p.start_time) for p in periods] net, costs, incs = map(np.array, zip(*results)) return net, costs, incs @@ -558,11 +579,32 @@ def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": "Measure cost incomes have different income_growth_rate, combination is not possible." ) + if not all([first_ci.freq == c.freq for c in cost_incomes]): + raise ValueError( + "Measure cost incomes have different period frequencies, combination is not possible." + ) + + try: + custom_cash_flows = cast( + pd.DataFrame, + pd.concat([c.custom_cash_flows for c in cost_incomes]) # type: ignore + .groupby(level=0) + .sum() + .reset_index(), + ) + except ValueError as err: + if str(err) == "All objects passed were None": + custom_cash_flows = None + else: + raise err + return CostIncome( mkt_price_year=first_ci.mkt_price_year.year, - cost_yearly_growth_rate=first_ci.cost_growth_rate, init_cost=sum(c.init_cost for c in cost_incomes), periodic_cost=sum(c.periodic_cost for c in cost_incomes), periodic_income=sum(c.periodic_income for c in cost_incomes), + cost_yearly_growth_rate=first_ci.cost_growth_rate, income_yearly_growth_rate=first_ci.income_growth_rate, + freq=first_ci.freq, + custom_cash_flows=custom_cash_flows, ) diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index f9d6667db3..edc35528a8 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -20,32 +20,14 @@ """ from datetime import datetime -from unittest.mock import MagicMock, patch import numpy as np import pandas as pd import pytest +from pandas.testing import assert_frame_equal -from climada.entity.disc_rates.base import DiscRates from climada.entity.measures.cost_income import CostIncome -# --------------------------------------------------------------------------- -# Helpers -# --------------------------------------------------------------------------- - - -def make_disc_rates(years=None, rates=None): - """Build a minimal DiscRates stub.""" - dr = MagicMock(spec=DiscRates) - dr.years = np.array(years or list(range(2020, 2031))) - dr.rates = np.array(rates or [0.05] * len(dr.years)) - return dr - - -# --------------------------------------------------------------------------- -# __init__ / construction -# --------------------------------------------------------------------------- - class TestInit: def test_defaults(self): @@ -208,7 +190,7 @@ def test_before_impl_date_is_zero(self): ci = CostIncome(mkt_price_year=2020, init_cost=1000, periodic_income=500) impl = pd.Timestamp("2021-01-01") curr = pd.Timestamp("2020-01-01") - net, cost, inc = ci._calc_at_date(impl, curr) + net, cost, inc = ci.calc_at_date(impl, curr) assert net == 0.0 assert cost == 0.0 assert inc == 0.0 @@ -216,7 +198,7 @@ def test_before_impl_date_is_zero(self): def test_at_impl_date_uses_init_cost(self): ci = CostIncome(mkt_price_year=2021, init_cost=1000, periodic_income=0) impl = pd.Timestamp("2021-01-01") - net, cost, inc = ci._calc_at_date(impl, impl) + net, cost, inc = ci.calc_at_date(impl, impl) assert cost == pytest.approx(-1000.0, rel=1e-3) assert inc == pytest.approx(0.0) @@ -224,7 +206,7 @@ def test_after_impl_date_uses_periodic_cost(self): ci = CostIncome(mkt_price_year=2020, periodic_cost=200, periodic_income=0) impl = pd.Timestamp("2021-01-01") curr = pd.Timestamp("2022-01-01") - net, cost, inc = ci._calc_at_date(impl, curr) + net, cost, inc = ci.calc_at_date(impl, curr) assert cost < 0 assert abs(cost) == 200 @@ -234,7 +216,7 @@ def test_income_growth_applied(self): ) impl = pd.Timestamp("2020-01-01") curr = pd.Timestamp("2021-01-01") - _, _, inc = ci._calc_at_date(impl, curr) + _, _, inc = ci.calc_at_date(impl, curr) expected = 100 * (1.10**1.0) assert inc == pytest.approx(expected, rel=1e-2) @@ -242,7 +224,7 @@ def test_net_equals_income_plus_cost(self): ci = CostIncome(mkt_price_year=2020, periodic_cost=100, periodic_income=150) impl = pd.Timestamp("2020-01-01") curr = pd.Timestamp("2021-01-01") - net, cost, inc = ci._calc_at_date(impl, curr) + net, cost, inc = ci.calc_at_date(impl, curr) assert net == pytest.approx(cost + inc) def test_custom_cash_flows_added(self): @@ -257,7 +239,7 @@ def test_custom_cash_flows_added(self): print(ci.custom_cash_flows) impl = pd.Timestamp("2021-01-01") curr = pd.Timestamp("2021-01-01") - net, cost, inc = ci._calc_at_date(impl, curr) + net, cost, inc = ci.calc_at_date(impl, curr) assert inc == pytest.approx(200.0, rel=1e-3) assert cost == pytest.approx(-500.0, rel=1e-3) @@ -403,3 +385,43 @@ def test_preserves_growth_rates(self): combined = CostIncome.comb_cost_income([ci1, ci2]) assert combined.cost_growth_rate == 0.02 assert combined.income_growth_rate == 0.03 + + def test_merges_custom_cash_flows(self): + df1 = pd.DataFrame( + { + "date": ["2020-01-01", "2020-03-01"], + "cost": [100, 200], + "income": [50, 60], + } + ) + df2 = pd.DataFrame( + { + "date": ["2020-01-01", "2020-03-01", "2020-04-01"], + "cost": [100, 200, 300], + "income": [50, 60, 70], + } + ) + + expected = pd.DataFrame( + { + "date": ["2020-01", "2020-02", "2020-03", "2020-04"], + "cost": [-200, 0, -400, -300], + "income": [100, 0, 120, 70], + } + ) + + expected["date"] = pd.to_datetime(expected["date"]) + expected = expected.set_index("date") + expected = expected.resample("MS").sum() + + ci1 = CostIncome( + mkt_price_year=2020, periodic_income=100, freq="M", custom_cash_flows=df1 + ) + ci2 = CostIncome( + mkt_price_year=2020, periodic_cost=50, freq="M", custom_cash_flows=df2 + ) + + combined = CostIncome.comb_cost_income([ci1, ci2]) + print(combined.custom_cash_flows) + print(expected) + pd.testing.assert_frame_equal(combined.custom_cash_flows, expected) From 22c45b169fe97060bec865268693ef7cc4dee62d Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 11:31:12 +0200 Subject: [PATCH 16/23] Updates tutorial --- doc/user-guide/climada_cost_income.ipynb | 647 ++++++++++++++++------- 1 file changed, 462 insertions(+), 185 deletions(-) diff --git a/doc/user-guide/climada_cost_income.ipynb b/doc/user-guide/climada_cost_income.ipynb index bf1834140e..fd53c2585e 100644 --- a/doc/user-guide/climada_cost_income.ipynb +++ b/doc/user-guide/climada_cost_income.ipynb @@ -8,7 +8,15 @@ "(cost-income-tutorial)=\n", "# Measure cash flows with `CostIncome`\n", "\n", - "This notebook introduces the `CostIncome` class from CLIMADA, which is used to model the financial cash flows of adaptation or risk-reduction measures over time.\n", + "This notebook introduces the `CostIncome` class from CLIMADA, which is used to model the financial cash flows of adaptation or risk-reduction measures over time." + ] + }, + { + "cell_type": "markdown", + "id": "a97e1043", + "metadata": {}, + "source": [ + "## Quickstart\n", "\n", "A `CostIncome` object tracks:\n", "- **Initial (one-off) costs** — the upfront implementation cost\n", @@ -21,34 +29,197 @@ { "cell_type": "code", "execution_count": 1, - "id": "a73bc8d1", + "id": "eca21610-32a8-477d-999e-54255557a3cc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datenetcostincome
020200.0000000.0000000.000000
120210.0000000.0000000.000000
22022-9705.636889-9705.6368890.000000
320232940.807977-4901.3466297842.154606
420242970.216057-4950.3600957920.576152
520253000.000000-5000.0000008000.000000
620263030.000000-5050.0000008080.000000
720273060.300000-5100.5000008160.800000
820283090.903000-5151.5050008242.408000
920293121.897135-5203.1618928325.059028
1020303153.116107-5255.1935118408.309618
\n", + "
" + ], + "text/plain": [ + " date net cost income\n", + "0 2020 0.000000 0.000000 0.000000\n", + "1 2021 0.000000 0.000000 0.000000\n", + "2 2022 -9705.636889 -9705.636889 0.000000\n", + "3 2023 2940.807977 -4901.346629 7842.154606\n", + "4 2024 2970.216057 -4950.360095 7920.576152\n", + "5 2025 3000.000000 -5000.000000 8000.000000\n", + "6 2026 3030.000000 -5050.000000 8080.000000\n", + "7 2027 3060.300000 -5100.500000 8160.800000\n", + "8 2028 3090.903000 -5151.505000 8242.408000\n", + "9 2029 3121.897135 -5203.161892 8325.059028\n", + "10 2030 3153.116107 -5255.193511 8408.309618" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", + "from climada.entity.measures.cost_income import CostIncome\n", + "\n", + "ci = CostIncome(\n", + " mkt_price_year=2025,\n", + " init_cost=10_000, # 10 000 upfront\n", + " periodic_cost=5_000, # 5 000 / year maintenance\n", + " periodic_income=8_000, # 8 000 / year in avoided losses\n", + " cost_yearly_growth_rate=0.01,\n", + " income_yearly_growth_rate=0.01,\n", + " freq=\"Y\", # annual cash flows\n", + ")\n", "\n", - "# Adjust the import path if running outside the CLIMADA package tree\n", - "from climada.entity.measures.cost_income import CostIncome" + "impl_date = \"2022-01-01\"\n", + "start_date = \"2020-01-01\"\n", + "end_date = \"2030-01-01\"\n", + "\n", + "\n", + "display(ci.to_dataframe(impl_date, start_date, end_date))\n", + "ci.plot_cash_flows(impl_date, start_date, end_date)" ] }, { "cell_type": "markdown", - "id": "a97e1043", + "id": "e75b7d54-6785-48af-9134-6dc4b564a76d", "metadata": {}, "source": [ - "## Quickstart\n", + "## Defining a `CostIncome`\n", "\n", "The simplest way to create a `CostIncome` is by passing keyword arguments directly.\n", "\n", - "| Parameter | Meaning | Sign convention |\n", - "|---|---|---|\n", - "| `init_cost` | One-off implementation cost | stored negative |\n", - "| `periodic_cost` | Recurring cost each period | stored negative |\n", - "| `periodic_income` | Recurring income each period | stored positive |\n", - "| `mkt_price_year` | Reference year for price levels | — |\n", - "| `freq` | Period frequency (e.g. `'Y'`, `'M'`, `'Q'`) | — |\n", + "| Parameter | Meaning |\n", + "|---|---|\n", + "| `init_cost` | One-off implementation cost |\n", + "| `periodic_cost` | Recurring cost each period |\n", + "| `periodic_income` | Recurring income each period |\n", + "| `mkt_price_year` | Reference year for cost/income growth rates |\n", + "| `cost_yearly_growth_rate` | Growth rate for costs |\n", + "| `income_yearly_growth_rate` | Growth rate for costs |\n", + "| `freq` | Period frequency (e.g. `'Y'` for yearly, `'M'` for monthly, `'Q'` for quaterly)
see more [here](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#period-aliases))\n", "\n", "```{note} **Sign convention**\n", "`CostIncome` stores costs as negative numbers internally.\n", @@ -62,36 +233,21 @@ { "cell_type": "code", "execution_count": 2, - "id": "4ba16743", + "id": "41147b9d-9fef-4e58-9070-b384a5377f59", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CostIncome(\n", - " mkt_price_year = 2020\n", - " freq = 'Y'\n", - " init_cost = -20,000.00\n", - " periodic_cost = -5,000.00\n", - " periodic_income = 12,000.00\n", - " cost_yearly_growth_rate = 0.00%\n", - " income_yearly_growth_rate = 0.00%\n", - " custom_cash_flows = None\n", - ")\n" - ] - } - ], + "outputs": [], "source": [ + "from climada.entity.measures.cost_income import CostIncome\n", + "\n", "ci = CostIncome(\n", - " mkt_price_year=2020,\n", - " init_cost=20_000, # 50 000 upfront\n", + " mkt_price_year=2025,\n", + " init_cost=10_000, # 10 000 upfront\n", " periodic_cost=5_000, # 5 000 / year maintenance\n", - " periodic_income=12_000, # 8 000 / year in avoided losses\n", + " periodic_income=8_000, # 8 000 / year in avoided losses\n", + " cost_yearly_growth_rate=0.01,\n", + " income_yearly_growth_rate=0.01,\n", " freq=\"Y\", # annual cash flows\n", - ")\n", - "\n", - "print(ci)" + ")" ] }, { @@ -101,15 +257,19 @@ "source": [ "## Calculating cash flows\n", "\n", - "Three methods are available:\n", + "Three methods are available to calculate cash flows:\n", "\n", "| Method | Returns |\n", "|---|---|\n", "| `calc_cash_flows(impl_date, start_date, end_date)` | Three `np.ndarray`: net, costs, incomes |\n", - "| `calc_total(...)` | Three scalars: summed net, cost, income |\n", - "| `to_dataframe(...)` | A tidy `pd.DataFrame` |\n", + "| `calc_total(impl_date, start_date, end_date)` | Three scalars: summed net, cost, income |\n", + "| `to_dataframe(impl_date, start_date, end_date)` | A tidy `pd.DataFrame` |\n", "\n", - "The `impl_date` is when the measure is *deployed*. Cash flows before this date are zero; the initial cost lands on `impl_date`; periodic flows start the following period." + "The `impl_date` is when the measure is *deployed*. Cash flows before this date are zero; the initial cost lands on `impl_date`; periodic flows start the following period.\n", + "\n", + "```{note}\n", + "Dates should follow the standard format \"yyyy-mm-dd\" or be an integer representing the year.\n", + "```" ] }, { @@ -126,58 +286,48 @@ "---------------------------------------------\n", "2020 | 0 | 0 | 0\n", "2021 | 0 | 0 | 0\n", - "2022 | -20000 | -20000 | 0\n", - "2023 | 7000 | -5000 | 12000\n", - "2024 | 7000 | -5000 | 12000\n", - "2025 | 7000 | -5000 | 12000\n", - "2026 | 7000 | -5000 | 12000\n", - "2027 | 7000 | -5000 | 12000\n", - "2028 | 7000 | -5000 | 12000\n", - "2029 | 7000 | -5000 | 12000\n", - "2030 | 7000 | -5000 | 12000\n" + "2022 | -9706 | -9706 | 0\n", + "2023 | 2941 | -4901 | 7842\n", + "2024 | 2970 | -4950 | 7921\n", + "2025 | 3000 | -5000 | 8000\n", + "2026 | 3030 | -5050 | 8080\n", + "2027 | 3060 | -5100 | 8161\n", + "2028 | 3091 | -5152 | 8242\n", + "2029 | 3122 | -5203 | 8325\n", + "2030 | 3153 | -5255 | 8408\n", + "---------------------------------------------\n", + "Total net : 14662\n", + "Total cost : -50318\n", + "Total income : 64979\n", + "---------------------------------------------\n" ] } ], "source": [ + "import pandas as pd\n", + "\n", "impl_date = \"2022-01-01\"\n", "start_date = \"2020-01-01\"\n", "end_date = \"2030-01-01\"\n", "\n", "net, costs, incomes = ci.calc_cash_flows(impl_date, start_date, end_date)\n", + "total_net, total_cost, total_income = ci.calc_total(impl_date, start_date, end_date)\n", "\n", "print(\"Period | Net | Cost | Income\")\n", "print(\"-\" * 45)\n", "periods = pd.period_range(start=start_date, end=end_date, freq=\"Y\")\n", "for p, n, c, i in zip(periods, net, costs, incomes):\n", - " print(f\"{p} | {n:>9.0f} | {c:>9.0f} | {i:>6.0f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "971ce0dd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total net : 36000\n", - "Total cost : -60000\n", - "Total income : 96000\n" - ] - } - ], - "source": [ - "total_net, total_cost, total_income = ci.calc_total(impl_date, start_date, end_date)\n", + " print(f\"{p} | {n:>9.0f} | {c:>9.0f} | {i:>6.0f}\")\n", + "print(\"-\" * 45)\n", "print(f\"Total net : {total_net:>10.0f}\")\n", "print(f\"Total cost : {total_cost:>10.0f}\")\n", - "print(f\"Total income : {total_income:>10.0f}\")" + "print(f\"Total income : {total_income:>10.0f}\")\n", + "print(\"-\" * 45)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "f3fd0c35", "metadata": {}, "outputs": [ @@ -212,107 +362,106 @@ " \n", " 0\n", " 2020\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 0.000000\n", + " 0.000000\n", + " 0.000000\n", " \n", " \n", " 1\n", " 2021\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 0.000000\n", + " 0.000000\n", + " 0.000000\n", " \n", " \n", " 2\n", " 2022\n", - " -20000.0\n", - " -20000.0\n", - " 0.0\n", + " -9705.636889\n", + " -9705.636889\n", + " 0.000000\n", " \n", " \n", " 3\n", " 2023\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 2940.807977\n", + " -4901.346629\n", + " 7842.154606\n", " \n", " \n", " 4\n", " 2024\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 2970.216057\n", + " -4950.360095\n", + " 7920.576152\n", " \n", " \n", " 5\n", " 2025\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3000.000000\n", + " -5000.000000\n", + " 8000.000000\n", " \n", " \n", " 6\n", " 2026\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3030.000000\n", + " -5050.000000\n", + " 8080.000000\n", " \n", " \n", " 7\n", " 2027\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3060.300000\n", + " -5100.500000\n", + " 8160.800000\n", " \n", " \n", " 8\n", " 2028\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3090.903000\n", + " -5151.505000\n", + " 8242.408000\n", " \n", " \n", " 9\n", " 2029\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3121.897135\n", + " -5203.161892\n", + " 8325.059028\n", " \n", " \n", " 10\n", " 2030\n", - " 7000.0\n", - " -5000.0\n", - " 12000.0\n", + " 3153.116107\n", + " -5255.193511\n", + " 8408.309618\n", " \n", " \n", "\n", "" ], "text/plain": [ - " date net cost income\n", - "0 2020 0.0 0.0 0.0\n", - "1 2021 0.0 0.0 0.0\n", - "2 2022 -20000.0 -20000.0 0.0\n", - "3 2023 7000.0 -5000.0 12000.0\n", - "4 2024 7000.0 -5000.0 12000.0\n", - "5 2025 7000.0 -5000.0 12000.0\n", - "6 2026 7000.0 -5000.0 12000.0\n", - "7 2027 7000.0 -5000.0 12000.0\n", - "8 2028 7000.0 -5000.0 12000.0\n", - "9 2029 7000.0 -5000.0 12000.0\n", - "10 2030 7000.0 -5000.0 12000.0" + " date net cost income\n", + "0 2020 0.000000 0.000000 0.000000\n", + "1 2021 0.000000 0.000000 0.000000\n", + "2 2022 -9705.636889 -9705.636889 0.000000\n", + "3 2023 2940.807977 -4901.346629 7842.154606\n", + "4 2024 2970.216057 -4950.360095 7920.576152\n", + "5 2025 3000.000000 -5000.000000 8000.000000\n", + "6 2026 3030.000000 -5050.000000 8080.000000\n", + "7 2027 3060.300000 -5100.500000 8160.800000\n", + "8 2028 3090.903000 -5151.505000 8242.408000\n", + "9 2029 3121.897135 -5203.161892 8325.059028\n", + "10 2030 3153.116107 -5255.193511 8408.309618" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df = ci.to_dataframe(impl_date, start_date, end_date)\n", - "df" + "ci.to_dataframe(impl_date, start_date, end_date)" ] }, { @@ -322,12 +471,14 @@ "source": [ "## Visualising cash flows\n", "\n", - "`plot_cash_flows` draws a bar chart. You can choose which series to display via the `to_plot` argument." + "`plot_cash_flows` draws a bar chart of the cash flows. The top panel of the plot shows costs, incomes and net values for each period, while the bottom panel shows the cumulated net value.\n", + "\n", + "Figure size and title can be customized directly in the method. The method returns a tuple with the two matplotlib axes objects." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "315fc0ac", "metadata": {}, "outputs": [ @@ -337,15 +488,15 @@ "(, )" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABT4AAAJyCAYAAADtk984AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkbxJREFUeJzs3Qd4U9Ubx/E33ayWvbGUIXtZlCFLkeUAxIELQQFBUJkyBGTIVEFQhgIq6F8QFwqCCjgYgoiIgMgWKKOAzDI783/eg4ndtKVtktvv53libu5ITu5Niv31PefY7Ha7XQAAAAAAAADAQrxc3QAAAAAAAAAAyGwEnwAAAAAAAAAsh+ATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8AkAAAAAAADAcgg+AQAAAAAAAFgOwScAAAAAAAAAyyH4BAAAAAAAAGA5BJ8AAAA5zKhRo8Rms8nBgwfTtP+8efPM/j/99FOmt+XPP/+Uli1bSsGCBc1r9O3bV6wss87lmTNn5Omnn5ZSpUqJl5eX1K5d26xv1qyZlC1bVnLKZxMAACA1PqluBQAAcENXr16VOXPmyGeffWaCs4iICClQoIDUqVNHHnzwQXnyySfF398/y15/6tSpkj9/funSpYu4Kw3W9KZBorb1ev744w/58ssvzXvKruAsJiZGOnToYK7n6NGjzTWsUqVKtry2pxs4cKB89NFH8tJLL0n58uVNcAwxgamGy+3bt3eGwQAAIOci+AQAAB4XbNxzzz3y119/yZ133imDBw+WIkWKyOnTp03Q17NnT9m0aZPMnj07S4NPDQfdPfjUMFHbmDj4HD58uAwZMiRBOKzBp+6fnRWDf//9t+zdu1emTJkizz//fLa8plV8++230rp1axk5cqSrm+J2Px/0c6yfYYJPAABA8AkAADyGVgbee++9snv3bvnkk0/koYceSlIFpxWgK1ascFkbPYGPj4+5udrx48fNvVZ6ZraLFy9K3rx5xar03GXFeQMAALASxvgEAAAe491335UdO3ZI//79k4SeDtWrVzfbHbTyS6sYk6uI1LEEtVts/GBVxxisXLmy5M6dWwIDA83yCy+84Kwm02MOHTokq1evNsuOW3zvv/++1K1b1zxHvnz55I477kg2jHW0Tast77rrLhPUFS1aVAYMGGC6gWt7NMzVcRwDAgKkcePG5v1fjz6nVr2pkJAQZxsd7zXxOIpaFfrUU0+ZZW2rY3/dLzWRkZEyfvx4qVatmmmfVpbed999smXLljS1sWnTpmZZX9vxmo42xcbGyuuvv26upz63hnwaems1b2J6nL6H77//Xho1amTOo+57Pfv27TOvXbp0afHz85OSJUtKu3btZPPmzc599Lp17NhRypUrJ7ly5TLvUcck1eufmF6bhx9+2Pl8Woms10yHEEgsLi5OJk2aZJ5XK29vvvlmmT9//nXb7Lh2drvd7J/42qbk559/NhWi2n59H7Vq1ZK33nrLPI/D//73vyTjj+p1CAoKMut/+eWXBNdeP986rERqHN8ZbffChQulZs2a5nqWKVNGXn75ZYmOjpa0CAsLM9e4RIkS5tzqd0e/5+fPn09wbvTzm/gz5c6V2QAAIGu5/k/9AAAAafTpp5+a+x49emTJOevdu7e899570qlTJzM2poZT+/fvl5UrV5rtGmR9+OGH0q9fPylcuLAMGzYsyXPomIsTJkyQ0NBQeeWVV0x4qYGthk567OOPP55g/yNHjpgg7dFHHzXjk+praddvb29v2blzp1y5csV0Sz916pQJAnXswl27dpntKdF26ZiPixcvljfeeMO0VTVs2DDZ/fV8avimwwNo+x3jbGpIlRINrPQ9rV+/3pyv5557zoRQc+fOldtvv13WrFljwt/U2qj7aXD6zDPPmIDQcY6VBmoLFiwwwxnodh3KYObMmSbY1G7ejoDL4bfffpMvvvhCunXrJp07d07xdePv37x5c/M+9BgNb3XCIA009T3p9VMaKJ47d84EaRq6HT161LxHPfbHH390tlvbp21VOtxCcHCwWff777/Lhg0bzHWLb+jQoeazoftqkPf222+bgK5ChQrmvKREx0TVffSc62vruUnt2qrly5ebQFc/B/q51hD5888/N4H+9u3bncNC6HtSGiA7/ligQbOOoasTKOn6+vXrm/X6nvSz6XjP17N06VIzRIR+x4oXLy5Lliwx3w8NRj/44INUjz18+LDcdttt5vro+dI/Rujr62f7hx9+MMsa5uq50euZ+DOlY6ACAIAcyg4AAOAhChYsaM+XL1+6jgkODrY3bdo0yfoff/xRS93s77//vnNdgQIF7HfffXeGn3P37t12m81mr1evnv3q1avO9adOnbIXL17cPP/FixcTPI+24fPPP0/wPKGhoeZ52rdvb4+Li3OunzZtmtn/m2++uW4bR44cafY9cOBAmrbpedB1el4SS27b5MmTk23L+fPn7WXKlEn2/KTlGqiVK1ea9R06dLDHxsY61+/bt88eEBBgr1SpUoLzovvq7fvvv7enhR5brVo1u7+/v/3PP/9Msj3+a8a/Xg7Hjx+3FypUyN6mTRvnuq+++sq04ZNPPkn1tR3nsnbt2vbIyEjn+iNHjtj9/PzsjzzySJregz5H586dk6zX866fK4eYmBjzWL83hw8fTrC+devW5nl+/vln53o9tw0aNHA+HjdunD0wMNDetm1b+x133OFcP2LECHPsoUOHUm2nfsZ0Py8vL/vmzZsTXAP9fOu2devWpfrZfPzxx826L7/8MsFzjx071qzXNl7vMwUAAHImuroDAACPoZVn2v08q2g3YB0jVKvgMuKrr74yXYcHDRqUYOKgQoUKSa9eveTs2bOmSjA+7RatlWrxacWfPo9WUcbvRu+oYNMu2q6mM4pXrFjRVHVqNarjFhUVJS1atJB169aZisCM0EpVR1WoVho6aOXeY489ZsZ4TdzlXyeySWv1oQ4toMdrhaVWeiYW/zXz5MmTYNxQreLUatt69erJxo0bndscE0hpdWX87tcp0c+DVno66HAG2t1dJ3vKTFpxqkMz6HvVz5qDvget7lVaKeug51CrPC9cuGAea0WlVn9qVbJWwmqVqmO9Vp7edNNNaWqHfiZuueUW52P9XOv3JP71To5WXWt1aI0aNUzVanza1V2HNYjffgAAgPgIPgEAgMfQ0NMRyGSFadOmmW7N2sVbx17s2rWrCWU0fEnrLOUquTBNg5v4+zgkN4O6Y9KaxNsc6zV8czXthq8hnXZNT3zT4QJ0bEgNQjPCcY6qVq2a5vOoIWxaOcJFHefyenSog0ceecScex2vVbuL63vUgFODbIcmTZqY7vDaNV63a9dzHcNSg/Tk6OcrMQ3IM/vapvczqcGnji+rQxXoOJ4aduo6veljHSv00qVL8uuvvzq7xqeFY/iE+BzXV89xSv755x/znU+u/dq9XcPwxJ8FAAAAB8b4BAAAHkODGh2DUYOStI7bl3jiIQcNdxLTiXl0zMFvvvnGTPCiVW0a4ml1n1ZqatCSmvgTxaR1W2pjdaa0LbXXyS7aBg2uNCxOiWO8zow8d0rXLaX3rhPtpOf500IDN62yvXz5shkbUz9/Gn5qRaiO46qfj/j0s6KTUWkoqhWvOgbluHHjzCRGut4V1za9z+eY3ErH89RqV63a1YBTg0sd41TX6ziaektrha1K6Xpeb9v12u8O3wUAAOC+CD4BAIDH0Ml/NPicM2eOTJw4MU3H6CQ/OilKYilViWlln3an1pvS2dF1tuiPP/7YOfN5SkGNI4zVbtSVKlVKsM3RNTu7JlpJLUzKjP21W3Z4eLgJv+J3Dc8Meo400Prrr78SdI/OrPPouDba5T01Gmzqe9RA03HtHYYPH57sMRoG602DTh2aQYNT7VKuEwnF79qeXeJ/JhNzVKPGP5dadaoVz47gs1ixYlK9enWzTa+1I/jUz0viCaZSo9cypXXJVb86FC1a1ITNybVfu93r91gnO8ro5xgAAFgbXd0BAIDH0K7nWnk2efLkFMf10/E5dXv8gE5nQdfZuB20y+6MGTMSHKdds7Wbe2KO4C1+eKrjCsbv5uygM3dr8KKzr+tYlw56rM5IrqGqY7bsrKZtVMm1MzP211nFtRvya6+9luz2EydOSEbdf//95l6rKuNX9B04cMDM9K7BZXLd4NNKu7hr1+n58+cnG6g5XtNRlZm4qnDFihUJxvd0XOPEQyLo0Aw6DqYGhVk5RENq9POrM8zre43/HdC26vmNf74dNODU79Fnn32WoKpTlzdv3uwcczM9Fb0rV64044066Dl99dVXk339+DRUb9u2rWnP119/nWCbzhKv467GHyM3vZ9jAABgbVR8AgAAj6FdzTX8uOeee+SBBx6Qu+66y0y6ouMu6tiIWg2q3Yy7d+/uPEYnCNJqTd23Z8+eJpD88MMPk3SN1mBKu/JqyKIT5Wilm04K8/bbb5swJX64ol3ftQpQK0E1hNOwU8eB1HEmhwwZYgIlnaDo0UcfNVVp7777rhw/flw++OCDBJPlZCVtoxo6dKhph062pOtCQkKS3V8nKXJ04dbQSM+PVvo5qv0S69Onjwmz9P3qsADaHVqDvrCwMFMVGBAQkGQip7TSa6VtXrhwoZkURye10eur4bEG1LNmzbqhyj499v333zdtvu2220ygru9Tg2/9DLVu3Vqef/55adSokRQvXlwGDBhghkDQyYG0SlQ/Pxr8xZ8ES6+tdm3XEE8rKPV8a3d3Dej186qVlK6g4a2eNz2Ht956q/To0cME8Noufa/6XdHxSOPTgFPfi/7BIH4XfT1fev737Nljuv6nN2zW5+3du7f5nulEYKtWrTIBun5XUqOfSd1Xv/P6HdYKz19++cWcc31e/Sw6aCCu31d9z/pd08+kfuYd3wcAAJDDuHpaeQAAgPS6dOmSferUqfZGjRrZCxQoYPfx8bEXKVLE3qpVK/u7775rj4yMTLD/vHnz7DfffLPd19fXXrZsWfukSZPs33//vZbx2d9//32zjx4zZMgQ+2233WYvWLCg3c/Pz37TTTfZO3XqZP/rr78SPF94eLi9Xbt29qCgIPMcif+XSttwyy232AMCAux58uSxN23a1P7tt98meR/BwcFmW2IjR440z3ngwIEE6/WxrtftaTFu3DjzHry9vRO815SeX9ut50nPZ/zX0eP08Y8//phg/+joaPu0adPsdevWtefOndvcKlSoYH/sscfs33333XXbp88Xv13xxcTE2F977TV71apVzbXQc3333XfbN27cmGRffY7OnTvb02vXrl32xx9/3F6sWDHz2ShRooS5rps3b3bus3XrVvO5yp8/vz1v3rzmeq1Zs8a8XvzrvmXLFrNO37+eh3z58tmrV69unzBhgv3y5cvO/VI6l0qfWz8TaZHSe07pOdauXWtv2bKlPTAw0O7v72/aptcuLi4uyb4RERHOz8Dff/+dYFu5cuXM+iVLlqSpnfE/swsWLLDXqFHDXM/SpUvbR4wYYY+Kikqwf0qfzYMHD9qffPJJ57XSz3W/fv3s586dS/Ka2raaNWua18noZwMAAFiDTf/j6vAVAAAAgPVopaxWXI4cOdJUSAMAAGQnxvgEAAAAAAAAYDkEnwAAAAAAAAAsh+ATAAAAAAAAgOUwxicAAAAAAAAAy6HiEwAAAAAAAIDlEHwCAAAAAAAAsByCTwAAAAAAAACWQ/AJAAAAAAAAwHIIPgEAAAAAAABYDsEnAAAAAAAAAMsh+AQAAAAAAABgOQSfAAAAAAAAACyH4BMAAAAAAACA5RB8AgAAAAAAALAcgk8AAAAAAAAAlkPwCQAAAAAAAMByCD4BAAAAAAAAWA7BJwAAAAAAAADLIfgEAAAAAAAAYDkEnwAAAAAAAAAsh+ATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8AkAAAAAAADAcgg+AQAAAAAAAFgOwScAAAAAAAAAyyH4BAAAAAAAAGA5BJ8AAAAAAAAALIfgEwAAAAAAAIDlEHwCAAAAAAAAsByCTwAAAAAAAACWQ/AJAAAAAAAAwHIIPgEAAAAAAABYDsEnAAAAAAAAAMsh+AQAAAAAAABgOQSfAAAAAAAAACyH4BMAAAAAAACA5RB8AgAAAAAAALAcgk8AAAAAAAAAlkPwCQAAAAAAAMByCD4BAAAAAAAAWA7BJwAAAAAAAADLIfgEAAAAAAAAYDkEnwAAAAAAAAAsh+ATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8AkAAAAAAADAcgg+AQAAAAAAAFgOwScAAAAAAAAAyyH4BAAAAAAAAGA5BJ8AAAAAAAAALIfgEwAAAAAAAIDlEHwCAAAAAAAAsByCTwAAAAAAAACWQ/AJAAAAAAAAwHIIPgEAAAAAAABYDsEnAAAAAAAAAMsh+AQAAAAAAABgOQSfAAAAAAAAACyH4BMAAAAAAACA5RB8AgAAAAAAALAcgk8AAAAAAAAAlkPwCQAAAAAAAMByCD4BAAAAAAAAWA7BJwAAAAAAAADLIfgEAAAAAAAAYDkEnwAAAAAAAAAsh+ATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8AkAAAAAAADAcgg+AQAAAAAAAFgOwScAAAAAAAAAyyH4zGZ2u10iIiLMPQAAAAAAAICsQfCZzS5cuCBBQUHmHgAAAAAAAEDWIPgEAAAAAAAAYDkEnwAAAAAAAAAsh+ATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8AkAAAAAAADAcgg+AQAAAAAAAFgOwScAAAAAAAAAyyH4BAAAAAAAAGA5BJ8AAAAAAAAALIfgEwAAAAAAAIDlEHwCAAAAAAAAsByCT6RLs2bNxNvbW7Zt2+Zcd+7cObHZbHLw4ME0HT916lTOOgAAAAAAALIUwaeFfPHFF1KrVi3JlSuXudfHWaFAgQIydOjQLHluAAAAAAAAIDMQfLopu90uly5dSvNtwYIF8sADD8j27dvl6tWr5l4f6/q0HK+vl1a9evWS9evXy5o1a5Ld/vHHH0vNmjUlf/78cuutt5p91YABA2Tt2rUyePBgyZs3r7Rp0ybTzhcAAAAAAAAQn82ensQLNywiIkKCgoLk/PnzEhgYmOJ+GkZqOJhdLl68KHny5ElTV/X27dvLlStXZOnSpSbU1K7uWgV64MAB+euvv+SZZ56RJUuWSO3ateXLL7+U7t27y549e6RQoULO4/v27Zst7wsAAAAAAORM9809ITnZ0m7FJKfzcXUD4Jk0uJw+fboJNjXMdJgxY4a8+OKLcsstt5jHHTp0kMmTJ8vy5culU6dOLmwxAAAAAACZIycHaoRp8CQEn24qd+7cpgozrerXry87duxI0GVdJxyqXr26bNiwIU2vlx46jujIkSPlpZdeMt3XHXSCI12n2xyio6Pl6NGj6Xp+AAAAAAAA4EYQfLopDS3T0vXcYfTo0WZMTz1Ow0/Hva5Pz/OkR9euXWXKlCkyf/5857oyZcrI888/Lz179kz2GC8vhpUFAAAAgOTk5CpCRSUhgMxG8GkR2qX8888/lzFjxsju3bulUqVKpury/vvvz7LX9Pb2lnHjxkmPHj2c65577jnp06ePmdRIu7vrWKA6DmjlypWldOnSUqxYMdm/f3+WtQkAAABAUjk5UCNMA4Cci/I7i4Wff/zxhwkb9T4rQ08HrTKtUKGC8/G9994rEydONBMa6YRHISEhMm3aNImLi3OODbpq1Soz47vuCwAAAAAAAGQFKj6RLj/99FOSdb/88kuCxw899JC5JadevXqyc+dOzjoAAIAF5OQqQkUlIQAA7o3gEwAAAG6HQK2Yqy8BAACAxyP4BAAAOUpODtSoTgMAAEBOwhifAAAAAAAAACyHik8AADJBTq4iVFQSAgAAAHA3VHwCAAAAAAAAsByPCz7Lli0rNpstya13794pzkKe3P67du1KsN/nn38uVatWFX9/f3O/ePHiJM81c+ZMCQkJkYCAAAkNDZW1a9dm2fsEAAAAAAAAkIOCz02bNkl4eLjztnLlSrP+oYceSvW43bt3JziuYsWKzm0bNmyQjh07SqdOnWTr1q3m/uGHH5aNGzc691m0aJH07dtXhg0bJlu2bJHGjRtLmzZtJCwsLAvfLQAAAAAAAIAcEXwWKVJEihcv7rx9/fXXUr58eWnatGmqxxUtWjTBcd7e3s5tU6dOlRYtWsjQoUOlcuXK5r558+ZmvcOUKVOka9eu0q1bN6lSpYrZVqZMGZk1a1aWvl8AAAAAAAAAOSD4jC8qKkr+97//ydNPP226r6emTp06UqJECRNo/vjjjwm2acVny5YtE6xr1aqVrF+/3vk6mzdvTrKPPnbsk5LIyEiJiIhIcAMAAAAAAACQtTx6Vvcvv/xSzp07J126dElxHw07Z8+ebcbk1BDyww8/NOGnjv3ZpEkTs8/x48elWLFiCY7Tx7penTp1SmJjY1PdJyUTJkyQ0aNHu/UswczECwAAAAAAAKvx6ODz3XffNeNslixZMsV9KlWqZG4ODRo0kMOHD8vrr7/uDD5V4opRu92eZF1a9klMu83379/f+VgrPrWLvKdq1qyZtG/f3ox3CgAAAAAAALgrjw0+Dx06JKtWrZIvvvgi3cfWr1/fdJF30DE/E1dunjx50lnhWbhwYTMmaGr7pERnidcbAAAAAAAAgOzjsWN8vv/++2bConvuuSfdx+qs7NoFPn4VqGN2eIcVK1ZIw4YNzbKfn5/pKp94H33s2Cen0aEC8ufPL3PnzjUVrIUKFZJBgwYlOT/16tUz++n51m7/Dho86yRRuq1Ro0bmmsSvKh08eLAZkiBPnjwmqD569KiMGjXKTG5VunRpWbx4cYLK2zfffNNMTKXPp8fv3Lkzm84EAAAAAAAA3JFHBp9xcXEm+OzcubP4+KRetKqzr+tYoHv37pUdO3aYrueff/65PPfcc859+vTpY4LOSZMmya5du8y9VpPG786t3dU15HvvvfdMqNavXz8JCwuTnj17Sk514cIF2b59uzm369atkxkzZphAVGmQ2a5dOxOG/vPPP+a83nHHHWbb2rVr5dlnn5V33nnHbHvwwQfNZFLnz593PvdHH30k06ZNk9OnT5vws3HjxhIUFCTh4eEycuRI6d69u0RHR5t9Z82aZYY9WLp0qRmPtUOHDnLfffeZSakAAAAAAACQM3lk8KmhpIaOOpt7YloVWLZsWedjDb8GDhwoNWvWNOGZBnTLli0z4ZiDVm1+/PHHJkzV/ebNmyeLFi0y1YoOHTt2NCHqmDFjpHbt2rJmzRpZvny5BAcHS06llZZaxRkQEGCqN/U8bt682WzTCaUeeeQReeCBB8TX19eEllq5qT744AN54oknzBiruk0D5gIFCpjr4qDbq1evbp5bn+PKlSsmbNag+/HHHzeBqA53oDRw1etSsWJFs/2FF14w+2/cuNFFZwYAAAAAAACu5pFjfLZs2dKEbsk5ePCg6ersoBWHibtgJ0erDvWWml69epkbrgkMDJTcuXM7T4dWZmoVqNJQUoPm5Bw5ciTBNVIhISFmffxxVx30NeKPpep4zYsXLzqvuQalOg5r/MA7/vMBAAAAAAAgZ/HI4DM1q1evNtWYcC2thN23b1+y23SMTg0r49PHuj4jdIxRrcZt3bp1ho4HAAAAAACA9XhkV/fUHDhwwARhcC0dg3PhwoVmEqKYmBgzfucvv/xitml1po7h+fPPP5ttb731lum6fvfdd2fotXr37i0vv/yy7N692zyOiIiQr776yll9CgAAAAAAgJzHchWfVrO0239dvD3JLbfcYiaRGjFihJmEKm/evGYSKR3ns2nTpibs7Nq1q5msSMfy/Oabb8yM7BmhE1VpN3cdt/Xw4cOSL18+M1P8nXfemenvCwAAAAAAAJ6B4BPp4pi1XZ07dy7Bti+//DLB4zZt2phbcjQM1dv1XkN16dLF3OKLP8arzWZj/FUAAAAAAABYu6s7AAAAAAAAABB8AgAAAAAAALAcgk8AAAAAAAAAlkPwCQAAAAAAAMByCD4BAAAAAAAAWA7BJwAAAAAAAADLIfgEAAAAAAAAYDkEnwAAAAAAAAAsx8fVDUDqTjx1X5afomLvL+UyAAAAAAAAwFKo+ESGrFu3Ttq0aSMFChSQ/PnzS61ateTVV1+VqKioDJ9Rm80mf/zxB1cEAAAAAAAAN4zgE+n29ddfm9CzVatWsnfvXjl37pwsWrRI/vrrLwkPD+eMAgAAAAAAwOUIPpEudrtdXnjhBRk8eLD07dtXChcubNZXrlxZ5s2bJ8HBwfLbb7/J7bffbipBq1atKgsXLnQe//vvv0v9+vUlMDDQHHvffde68t92223mvmHDhpI3b14ZP348VwYAAAAAAAAZxhifSBet8Dxw4IA8+uijyW7X6s/WrVvLyJEjpWfPnrJ+/Xq555575KabbjJh6HPPPWfCTl0fHR0tGzduNMf9+uuvpqu7rq9duzZXBQAAAAAAADeEik+kyz///GPuS5Uqlez2ZcuWSZEiReT5558XX19fadq0qTz22GMyf/58s13XHTp0SI4dOyb+/v7SpEkTrgAAAAAAAAAyHcEn0sXRtf3o0aPJbj9y5IiULVs2wbpy5cqZ9eq9996Tq1evSmhoqOkeP336dK4AAAAAAAAAMh3BJ9Ll5ptvNsHmxx9/nOz20qVLy8GDBxOs067xul6VL19ePvjgAzl+/LjMnTtXBg4cKJs3bzbbtKs7AAAAAAAAkBkIPpEuGk6+9dZbMnHiRHN/+vRps37Pnj3StWtXadSokZw8eVJmzpwpMTExsnbtWlmwYIE8+eSTZj8NPU+cOGGep0CBAuLl5SU+PteGmi1WrJjs37+fKwIAAAAAAIAbxuRGbq7Y+0vF3dx7773yzTffyNixY2XEiBFmnU5e1KlTJylRooTZpjO+Dx06VEqWLCmzZs0ygahatWqVDBo0SC5evGiCztdee01q1apltr3yyitmxvhu3bqZWeOHDBni0vcJAAAAAAAAz0XwiQzRIPPbb79Ndtttt91mZmdPjlZ8pkQDT70BAAAAAAAAN4qu7gAAAAAAAAAsh+ATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8AkAAAAAAADAcgg+AQAAAAAAAFgOwScAAAAAAAAAyyH4BAAAAAAAAGA5BJ8AAAAAAAAALMfjgs9Ro0aJzWZLcCtevHiqx6xevVpCQ0MlICBAypUrJ2+//XaSfT7//HOpWrWq+Pv7m/vFixcn2WfmzJkSEhJinkefb+3atZn63gAAAAAAAADk0OBTVatWTcLDw5237du3p7jvgQMH5O6775bGjRvLli1b5KWXXpIXXnjBBJ0OGzZskI4dO0qnTp1k69at5v7hhx+WjRs3OvdZtGiR9O3bV4YNG2aeR5+vTZs2EhYWluXvFwAAAAAAAEAOCD59fHxMlafjVqRIkRT31erOm266SaZOnSpVqlSRbt26ydNPPy2vv/66cx/d1qJFCxk6dKhUrlzZ3Ddv3tysd5gyZYp07drVHK/Po9vKlCkjs2bNyvL3CwAAAAAAACAHBJ979+6VkiVLmm7njzzyiPz9998p7qvVnC1btkywrlWrVvLbb79JdHR0qvusX7/eLEdFRcnmzZuT7KOPHfukJDIyUiIiIhLcAAAAAAAAAGQtjws+69WrJx988IF89913MmfOHDl+/Lg0bNhQTp8+nez+ur1YsWIJ1unjmJgYOXXqVKr76Hql+8XGxqa6T0omTJggQUFBzptWiQIAAAAAAADIWh4XfOq4mg888IDUqFFD7rrrLlm2bJlZP3/+/BSP0QmQ4rPb7UnWJ7dP4nVp2Scx7TZ//vx55+3w4cPXfY8AAAAAAAAAboyPp5/APHnymBBUu78nR8cATVyVefLkSTNOaKFChVLdx1HhWbhwYfH29k51n5ToLPF6AwAAAAAAAJB9PK7iM7kxNHfu3CklSpRIdnuDBg1k5cqVCdatWLFC6tatK76+vqnuo13olZ+fn4SGhibZRx879gEAAAAAAADgPjyu4nPgwIFy3333mZnateJy7NixZsKgzp07J7t/z549Zfr06dK/f3/p3r27mcjo3XfflYULFzr36dOnjzRp0kQmTZok7dq1k6+++kpWrVol69atc+6jx3fq1MkEphqUzp49W8LCwszzAwAAAAAAAHAvHhd8HjlyRB599FEz4VCRIkWkfv368ssvv0hwcLDZPmrUKJk3b54cPHjQPNaZ35cvXy79+vWTGTNmmNng33zzTTNOqINWbX788ccyfPhwGTFihJQvX14WLVpkJlJy6Nixo5lAacyYMRIeHi7Vq1c3z+t4XQAAAAAAAADuw+OCTw0oU6OBZ7NmzRKsa9q0qfz++++pHvfggw+aW2p69eplbgAAAAAAAADcm8cFn9ezevVqWbNmjaubAQAAAAAAAMCFLBd8HjhwwNVNAAAAAAAAAOBiHj+rOwAAAAAAAAAkRvAJAAAAAAAAwHIIPgEAAAAAAABYDsEnAAAAAAAAAMsh+AQAAAAAAABgOQSfAAAAAAAAACyH4BMAAAAAAACA5RB8AgAAAAAAALAcgk8AAAAAAAAAlkPwCQAAAAAAAMByCD4BAAAAAAAAWA7BJwAAAAAAAADLIfgEAAAAAAAAYDkEnwAAAAAAAAAsh+ATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8AkAAAAAAADAcgg+AQAAAAAAAFgOwScAAAAAAAAAy/FxdQMAAAAAAACQuvDfl8mepZPl0vH9kqd4ebn5vgFS4pZ7OG1uiGvlPgg+AQAAAABZgl/+PQPXyTOu0eZZXUVsNhG7XS4c3Wkehz77bpLw0263i9jj/r23i90ep2vN8rXHdvM4wX4Sb1/zWDfFJdjPbBe7HDx4ReLirh2nt5SWM7otM5/j6K/nkpyD/96jXexx8c6FbtfjkjsXic5B/PMb/5zqcsTRXRL+21fO65HatULWI/gEAAAA/sUv/56B62S9oCY9EoQ5zgDn32VnKOEIa+xy7px/moOTGwldMmPfk3+eSfJ+rr3nfwOX5N6vc7+kAdV/50lSOE9xcj7sTzm8boHz/F448pe5TqUaPCSBpSqnGO442/Tv81xbnVz74gdOJk1zti3x9h6bAjLl/GbWdUpt2/5T0YkCNMf7MI8SBGgJt/93zf47D/+Fj/HPd/xzGRN5yfEFSHCv18rm5f3ftc8GIUOy5WWsQ6+NzWaqdQk+sx/BJwAAHoxf/j0D1ylnhzQZCXKioqJuOKBJy+MbfY4z+06nUC1k3pXzF/HkwhLn+04cCPwbGFw7XpIEI+cO/CEHf3w3SUhzU9MnJahM9QT7/3dek3v9hAFDsoHNdQKdQXtyZ1qglplBTnKPtx27eu26JFOtFP+cXHuvCYOzhNfwetv/O6+REf84PuAJ7je/84z4BuRLcD6TC30SBmYZD3UK9LnRb2jOdHTDp3I0m19z9upsfkGLsMfFZv6T6r+FYhOb3tu8rt2LLtskwPfaY715eSW/nNFtmf0c28Ojxebl5Wy7zeZlFpN/b/8u/3vsf8dc2/bfMf9tj//cjucPW/tR0p9XdrsZogDZz2a/9i8MsklERIQEBQXJ+fPnJTAwkPMOABZx39wTLg9pHPeu6EaztFuxNIcqGQ1jMuu5+i4+lWKFTIJf3E34kqj7U5IKl+RClX+f69/HZ//eLAdWvnPtf4pN6nDtvuwdXSWobM00dbXKrADnkdq5MzX0yspg7bfD8UKaRCHWf+8t+RAnfZU3/2632+XyqTCxx0Yn+XzbvH3EP7BoonAo/mfh30AnhYDvetsBuE5qQUp6Qpcb2Tf+44NnYrVRGqf8F84kCG3+DWcSBC22RKGOLdntCQIa52OR41u+ST5UtnlJqXodkoZDzvY5nifl13eERNcCo2vb/tvuCJmuvZaue7xuviwJwrJi28hvzznPqfN9JnjvXsm8d/MowTmMv9+1VfHP4b/LNpv8+lanf4OzeP9u2GySt3hFqd//k3jX6L/ncD5/ouvx3+cjYaDpfO1/nye1/+/zFK74f/TVo+80fzxN8G+8zSaBpapKk5HfZ2tblnrQtcoqVHwCAOChtLuMM/RU/97/Prun5CpQIl4AJ8lULyUX1qUWAkq8CqykwY2tuyvPhKewJ7iPX7GWXV5Zmu0vaQn22Bi5evaYeIqMBi4ZeXz8QlwyYcb1wo6Uw5hrgUC8KqNktv+zc02KIU2xWq2cYc71wp7UqnWuvf6/FU9JQqb/tt9fM2+2nu8befzqD+eTCWPiBx9yne3Xrk3CwCte6JN4u81m/j26fPJgwqBGbJKnWDmp2/v9ZAIZPddJ25FcIJP2YMcmX3Ytkew5cUfuFdJUkTpdp2drW172oJBmxpHsvVaV7x+a7B+8K7UfIgH5i2drW5A6nXQquWtV8b4BnDoXIPgEAMBDmb/6J1MtphVrWrnmyVL6BT4tv+Rfb59Tl+3//mLtdZ1wJt4v1slWsqSlEkfkzN6NyVf12bykSLWmKXYj+++1JdntGQlw7qmaJ92hSUaClszYZ9qaiATXJOF5unbu0xLiJDwPiUOSeAGL2GTrvL5y+Z9DSUOaoiFS55lZyQY+yVXvJA3rJPXtyQQ1izoXT/O5ir+c00OaW3u/n61ted2DQpr/Xcj+a1XlgeHJ/vJfucMwyVfi5mxrh5+fX7a9licipPEM2ptHe/UknNV9oJS45W5XNw2JcK3cC8EnAAAeSv+HV8e2S8gmuYuWlTpPT0/YpSqFgCj+9uSrZv6rvkmu25UjwPnfE0VvOPSKf7NSUJNaSFOvz8JsbcsMDwppvoh1QUjz4IjkQ5oHhkv+4FrZ2pb8+fNn6+t5EkIaz8Ev/56B6+RZ14rJcTwD18p9EHwCAOChQpp3k23z+/+34t+QpsoDI6RA+dBsbUvRokWz9fU8CSGN5+CXf8/AdfIs/PLvGbhOAKyK4BMAAA91MXyvuffyy2XG36TLk3sipPEs/PLvGbhOAAAgLa4NDOVBJkyYILfeeqvky5fPVJe0b99edu/eneoxP/30U7Ld6Hbt2pVgv88//1yqVq0q/v7+5n7x4sVJnmvmzJkSEhIiAQEBEhoaKmvXrs309wgAwPVEXTgth1bPN8uhPWbL3bMOSdORPzDOkxuHNHp9uE4AAABA9vG44HP16tXSu3dv+eWXX2TlypUSExMjLVu2lEuXLl33WA1Iw8PDnbeKFSs6t23YsEE6duwonTp1kq1bt5r7hx9+WDZu3OjcZ9GiRdK3b18ZNmyYbNmyRRo3bixt2rSRsDDPnkACAOB5/l41W2IjL0vQTTWlaI27XN0cAAAAAHA7HtfV/dtvv03w+P333zeVn5s3b5YmTZqkeqzul9JA8VOnTpUWLVrI0KFDzWO915BV1y9ceG3igSlTpkjXrl2lW7duzmO+++47mTVrlqlEBQAgO0RdOicHf3jXLFe4p69LZnIGAAAAAHfncRWfiZ0/f97cFyxY8Lr71qlTR0qUKCHNmzeXH3/8McE2rfjUytH4WrVqJevXrzfLUVFRJlxNvI8+duyTnMjISImIiEhwAwDgRhz8fq7EXL0o+UpVluK1W3MyAQAAAMBqwafdbpf+/ftLo0aNpHr16inup2Hn7NmzzRieX3zxhVSqVMmEn2vWrHHuc/z4cSlWrFiC4/SxrlenTp2S2NjYVPdJjlaCBgUFOW9lypS5gXcMAMjpoq9ckAPfzzXLFbXa08uj/ykHAAAAgCzjcV3d43vuuedk27Ztsm7dulT306BTbw4NGjSQw4cPy+uvv56ge3ziroIarCZel5Z94tMu8xrOOmjFJ+EnACCjDv00T6Ivn5M8xStIidD7OJEAAAAAkAKPLRN5/vnnZcmSJabLeunSpdN9fP369WXv3r3Ox8WLF09SuXny5ElnhWfhwoXF29s71X2SozPEBwYGJrgBAJARMZGX5O8Vs8xyxTYviM3LmxMJAAAAAFYJPrXCUis9tcv6Dz/8ICEhIRl6Hp2VXbvAx68C1Vni41uxYoU0bNjQLPv5+UloaGiSffSxYx8AALJS2OoPJeriGcldJFhK1uvAyQYAAAAAK3V17927tyxYsEC++uoryZcvn7MCU8fPzJUrV7LH6OzrZcuWlWrVqplJiv73v/+Z8T715tCnTx/T7X3SpEnSrl078/yrVq1K0I1eu6x36tRJ6tata4JSHTc0LCxMevbsmQ3vHACQk8VGXZH9K2aa5QptXhAvb4/7JxwAAAAAspXH/dY0a9a1Ln7NmjVLsP7999+XLl26mOVRo0bJvHnz5ODBg+axhp0DBw6Uo0ePmnBUA9Bly5bJ3Xff7TxeqzY//vhjGT58uIwYMULKly8vixYtknr16jn36dixo5w+fVrGjBkj4eHhZkKl5cuXS3BwcDa9ewBAThW2boFEnj8puQqWktINHnJ1cwAAAADA7fl4Ylf369HAM34wOmjQIHO7ngcffNDcUtOrVy9zAwAgu8RGR8r+b2eY5fKtnxMvHz9OPgAAAABYLfhMi9WrV8uaNWtc3QwAADLFkQ2fyNWzx8Q/qJiUafQoZxUAAAAAcmrweeDAAVc3AQCATBEXEy37lr9plsu37i3evgGcWQAAAACw4qzuAADkJEd//UKunD4sfvkKSXDjJ1zdHAAAAADwGASfAAC4KXtcrLPas1yLnuLtn9vVTQIAAAAAj0HwCQCAmzq2aYlcOrFffPMUkLJ3POXq5gAAAACARyH4BADADdnj4mTf8qlmOeSu7uITkNfVTQIAAAAAj0LwCQCAGzq+ZblcOLZbfHLlk5A7u7q6OQAAAADgcQg+AQBwM3a7XfYu+7fa885u4ps7yNVNAgAAAACPQ/AJAICbObltpUQc/lO8/fOYbu4AAAAAgPQj+AQAwO2qPd8wy2WbdRG/vAVd3SQAAAAA8EgEnwAAuJFTf62Wcwe2iJdfLinXsqermwMAAAAAHovgEwAAd6r2/PpatWdw4yfEP7CIq5sEAAAAAB6L4BMAADdxes96ObNvo3j5+Em5Vr1c3RwAAAAA8GgEnwAAuAlHtWeZRo9KrgIlXN0cAAAAAPBoBJ8AALiBM/s2yeld68Tm7SPlWz/n6uYAAAAAQM4LPh9//HGZPXu27NmzJ2taBABADuSYyb10g4cld6Eyrm4OAAAAAOS84DNv3rwyZcoUqVy5spQsWVIeffRRefvtt2XXrl1Z00IAACzu3ME/5J8/fxCxeUmFNi+4ujkAAAAAkDODz3feeceEnMeOHTMBaFBQkEybNk2qVasmJUowHhkAAOm1d9lUc1+qXgfJU7QsJxAAAAAAXDnGZ758+aRAgQLmlj9/fvHx8ZHixYtnRpsAAMgxIo78JSf++FbEZpOKd/dxdXMAAAAAIOcGn4MHD5b69etL4cKFZfjw4RIVFSVDhw6VEydOyJYtW7KmlQAAWHwm9xKh90neEhVd3RwAAAAAsAyf9B7w2muvSZEiRWTkyJHSrl07qVKlSta0DAAAi7sQvkfCf//aLFe8p5+rmwMAAAAAOTv41KrO1atXy08//SSTJ08Wb29vadq0qTRr1szcCEIBAEibfcumidjtUqx2GwkszR8SAQAAAMClwWetWrXM7YUXrs06u3XrVpk6dap5HBcXJ7GxsZnaQAAArOjiib/l6K+LzXLFe/u6ujkAAAAAYDnpDj4dVZ9a8am3tWvXSkREhNSuXVvuuOOOzG8hAAAWtP+bt0TscVK0RnPJH1zL1c0BAAAAAMtJd/Cps7hfvHjRVH1q1/bu3btLkyZNJDAwMGtaCACAxVw+FSZHfvnULDO2JwAAAAC4SfD54YcfEnQCAHAD9n87XeyxMVK4SmMpUL4u5xIAAAAA3CH4vPfee53LR44cEZvNJqVKlcrsdgEAYElXzobL4Z8/NstUewIAAABA1vFK7wE6gdGYMWMkKChIgoOD5aabbpL8+fPLK6+8YrYBAICU7f9uhsTFREnBivWlUKWGnCoAAAAAcJeKz2HDhsm7774rEydOlNtvv13sdrv8/PPPMmrUKLl69aqMGzcua1oKAICHu3r+pISt+Z9ZrnhvP1c3BwAAAAAsLd3B5/z582Xu3LnStm1b5zqd6Ei7u/fq1YvgEwCAFPy9YpbERV+V/CG3SOEqTThPAAAAAOBOXd3PnDkjlStXTrJe1+k2AACQVNSF03Jo9XxntaeOkQ0AAAAAcKPgU6s7p0+fnmS9rtNtAAAgqb9XzZHYyMsSeFMNKVrjLk4RAAAAALhbV/dXX31V7rnnHlm1apU0aNDAVKysX79eDh8+LMuXL5ecYObMmfLaa69JeHi4VKtWTaZOnSqNGzd2dbMAAG4q+vJ5Ofjju2a54j19qfYEAAAAAHes+GzatKns2bNH7r//fjl37pzp3t6hQwfZvXt3jgj/Fi1aJH379jWTPG3ZssW85zZt2khYWJirm5bjffHFF6bqOFeuXOZeH8M9ca2Q0xz4fq7EXLkg+UpVluK127i6OQAAAACQI6S74lOVLFkyx05iNGXKFOnatat069bNPNZqz++++05mzZolEyZMcHXzcnSQ9sADD5gqKrvdLtu3bzePJ0+eLHfdRZdSd6LV4gMGDEhyrT7//HPzRxTAaqKvXJADq+aY5Qp39xWbV7r/5ggAAAAAyKrgc9u2bWl+wpo1a4pVRUVFyebNm2XIkCEJ1rds2dJ0909OZGSkuTlERERkeTtzotGjRzuDNOW414AN7in+tdJrN2bMGIJPWNKhn+ZJ9OVzkqd4BSlZ9z5XNwcAAAAAcow0BZ+1a9dOECqlRPeJjY0Vqzp16pR5f8WKFUuwXh8fP3482WO0ClRDucRuvfVW8fb2lkcffVR69+4tjRo1cm7766+/pF+/fqaSVA0fPlwqVKggXbp0MY/Lly8vS5culfvuu0/2799v1s2bN0/27dsnY8eONY9btWolb7zxhlStWtX5vOvWrZMZM2bIwoULzWN9Xd2vbdu25nGBAgXk559/ls6dO8umTZucFa6qf//+znbPnz9fbr/9djl79qxZt2TJEtNWfW7livekVYMpfT71+pw/f16io6PN48DAwAQhtK+vrwQFBZlhG+Li4pznQgPry5cvm8fafT537txy+vRp5/MWLlxYLly44Ay28+bNa66pvpby8fGR/PnzmyEhYmJizDp9Hf0MXbx40Tz29/eXfPnymc+WQ6FChczrXrlyxTzW19X9HOfby8tLChYs6LHvKbmfEXrtdLgMT/zsZcf36Zm/f5Wc7I6N+z3iOs1N5jpdio6RW5f9YJYnVMgrD2/oIVZVdYpnXCd97rk/X+u1kRNxnTzHfV8J3ycP4CnXSf/f6Md65SWn4jp5kG6e8X1SOfk7xXXyrJ9/+z3g+5TR3931mOux2a+XZmq1yqFDklbBwcFiVceOHZNSpUqZ6k6d2MlBu/1/+OGHsmvXrjRVfJYpU8YESY6wCjdOx/RMHH5qEK8VyH/88Qen2I1wrdLvxFM5u0qw2PtLxVOv0zs7/paRm/6S4Hy55ef7m4mPhbu5e8p1yunfKa6T5/CUa5WTv0+edJ1y+rXiOnkOrpVn4Dp5jmIe9O9UVknTb2A6kZGGdBpqampbpEgRs5zczcq0Gk6r3xJXd548eTJJFaiDVr/puYt/Q+YbOXKks8u0clQo63q497VSXCtY0dWYWJn557W/RL5Qo4KlQ08AAAAAcEdp+i1s586dcunSJbOs3bYdXVpzGj8/PwkNDZWVK1cmWK+PGzZs6LJ2QczYkDo5jlZ4BgQEmHud8EhDe7jvtdLvlIOWzANWsmDvYTlxJVJK5QmQh8qXdnVzAAAAACDHSfMYn0899ZTpe6+VWa+//roZ+y85L7/8sliZjlnQqVMnqVu3runuPnv2bAkLC5OePXu6umk5ngZqzAruedfq2Weflbffflt69OghW7duNcE14OmiYuNkxp/7zHLv6hXEz5tqTwAAAABwy+BTB0DV7qlff/216Z76zTffmElOEtNtVg8+O3bsaCaD0Rmow8PDpXr16rJ8+XLLd/MHssrEiRPlq6++kj179phBlh0DLQOe7JP9h+XopatSLJe/PFaxjKubAwAAAAA5UpqCz0qVKsnHH3/snFH6+++/l6JFi0pO1atXL3MDcON0Vvjp06fLAw88IJMmTTJ/XKhRowanFh4rOi5O3tx2bWzPXtXLS4CPt6ubBAAAAAA5Urr73sXFxeXo0BNA5tNu7+3bt5eYmBjp3r27xMbGcprhsb74+6iEXbwshQL8pFMlegMAAAAAgKsw6BgAt6BVn/ny5ZONGzfKrFmzXN0cIENi4+zy5rZrY3v2rFZOclPtCQAAAAAuQ/AJwC2UKlXKjPephg4dKocPH3Z1k4B0W3rwmOyPuCT5/XzlqcplOYMAAAAA4EIEnwDcRs+ePaVhw4Zy8eJF6d27t9jtdlc3CUizOLtd3vi32rN71RDJ65umYbQBAAAAAFmE4BOA29DJ02bPni2+vr6ydOlS+fzzz13dJCDNvgk7LrvPXZB8vj7SrUoIZw4AAAAAPDX4jIqKkiNHjkhYWFiCGwDciGrVqsmQIUPM8vPPPy9nz57lhMLtaXXy1K17zXLXKmUlyN/X1U0CAAAAgBwv3cHn3r17pXHjxpIrVy4JDg6WkJAQcytbtqy5B4Ab9dJLL0mlSpXk+PHjzhAUcGfLli2T7WcizGRG3auWc3VzAAAAAAAiku4ByLp06SI+Pj7y9ddfS4kSJcRms3EiAWSqgIAA0+W9adOm5v7xxx+XJk2acJbhttWer7zyilnuUjlYCgX4ubpJAAAAAICMBJ9//PGHbN68WSpXrswJBJBlNOjs3r27zJkzR5555hnzs0cDUcDdrFy5Un799VfJ5e0lz1Yr7+rmAAAAAAAy2tW9atWqcurUqfQeBgDp9uqrr0rx4sVl9+7dMmHCBM4g3NLYsWPN/RM3B0uRXP6ubg4AAAAAID3BZ0REhPM2adIkGTRokPz0009y+vTpBNv0BgCZJX/+/PLWW2+ZZQ0+d+zYwcmFW1m9erWsXbtW/Pz8pFd1xvYEAAAAAI/r6q7hQ/yxPHU8s+bNmyfYR9fpPrGxsZnfSgA51gMPPCBt27aVJUuWmC7vGjJ5eaW7WB3IEo6xPZ9++mkpcfUIZxkAAAAAPC34/PHHH7O+JQCQDP2DyvTp0+WHH36Q9evXy9tvvy29evXiXMHlNmzYIN9//72Z8G/IkCEio55zdZMAAAAAAOkNPnVmZQBwlTJlypiu7s8//7wJmNq1ayelSpXigsAtqj2ffPJJCQ4OlhNcDwAAAABwK+nuL/rtt9/KunXrnI9nzJghtWvXlscee0zOnj2b2e0DAOPZZ5+V+vXry4ULF+S556isg2v99ttv8s0335hhF4YOHcrlAAAAAAArBJ8vvviicxKj7du3S//+/eXuu++Wv//+2ywDQFbw9vaW2bNnm27FX375pXzxxRecaLh8Jnf9o1+FChW4EgAAAABgheDzwIEDUrVqVbP8+eefy3333Sfjx4+XmTNnmuoXAMgqNWrUkMGDB5tlrfo8f/48JxvZbtu2bfLVV1+Z8WdfeuklrgAAAAAAWCX49PPzk8uXL5vlVatWScuWLc1ywYIFnZWgAJBVhg8fLhUrVpTw8PBrE8oA2WzcuHHm/sEHH5QqVapw/gEAAADAKsFno0aNTJd2ndTh119/lXvuuces37Nnj5QuXTor2ggATgEBAabLu9IZ3uOPOQxktZ07d8qnn37qDOEBAAAAABYKPqdPn27G2Pvss89k1qxZzpmVtZt769ats6KNAJBAs2bNpGvXrmb5mWeekcjISM4QsoUO7WK326Vdu3ZSs2ZNzjoAAAAAuDGf9B5w0003yddff51k/RtvvJFZbQKA63rttdfMzyKtwJs4caKMHDmSs4YstW/fPlmwYIFZHjFiBGcbAAAAAKxW8RnflStXzLie8W8AkB0KFCggb775prMKTwNQICtNmDBB4uLipE2bNhIaGsrJBgAAAACrBZ+XLl0ysykXLVpU8ubNa8KH+DcAyC4PPfSQGWc4KipKunfvbkIpICscPHhQPvjgA7NMtScAAAAAWDT4HDRokPzwww8yc+ZM8ff3l7lz58ro0aOlZMmSzl8KASA72Gw287NI/wjz888/y5w5czjxyBKTJk2SmJgYad68uTRo0ICzDAAAAABWDD6XLl1qgoYHH3zQTHLUuHFjM7OtdjX96KOPsqaVAJDKuMPjxo1z/mHm2LFjnCtkqqNHj8p7771nlqn2BAAAAAALB59nzpyRkJAQsxwYGGgeq0aNGsmaNWsyv4UAcB29e/eW2267zYwz/Pzzz3O+kOkTaelwCvrvXJMmTTi7AAAAAGDV4LNcuXJmrDNVtWpV+eSTT5yVoPnz58/8FgLAdXh7e5tu7lqF/sUXX8iXX37JOUOmOHHihLzzzjvOak8dXgEAAAAAYNHg86mnnpKtW7ea5aFDhzrH+uzXr5+8+OKLWdFGALiumjVrOn8G6QRsWv0J3KjJkyfL1atXTUVxixYtOKEAAAAA4EF80nuABpwOd9xxh+zatUt+++03KV++vNSqVSuz2wcAaaYVeZ9++qns27fP/GFmxowZnD1k2KlTp8wf9xyfLao9AQAAAMDiFZ/JTSzSoUMHQk8ALpcrVy5nt+RZs2bJ+vXrXd0keLCpU6fKpUuXpE6dOnLPPfe4ujkAAAAAgKwKPn/44Qczpmdy3UfPnz8v1apVk7Vr16b39QEgU915551mSA673S7PPPOMmZQGSK9z587JW2+9ZZaHDx9OtScAAAAAWDn41MqX7t27m5ncEwsKCpIePXrIlClTMrt9AJChWbiLFCkiO3bskEmTJnEGkW4aeuof+vSPeu3bt+cMAgAAAICVg0+d0Kh169Ypbm/ZsqVs3rxZslJ0dLQMHjxYatSoIXny5JGSJUvKk08+KceOHUv1uHnz5plqncQ3nbAiPh3LLSQkRAICAiQ0NDRJBatWkI0aNcq8rnapbdasmQlWALiXQoUKybRp08zy2LFjzVjEQFpduHDB/LFPDRs2TLy8bnhUGAAAAACAC6T5t7kTJ06Ir69vitt9fHzkn3/+kax0+fJl+f33380kE3r/xRdfyJ49e6Rt27bXPVYrVcPDwxPcNOB0WLRokfTt29f8krtlyxZp3LixtGnTRsLCwpz7vPrqq6aqdfr06bJp0yYpXry4meVXf0kG4F4eeeQR8x3Wru7a5T0uLs7VTYKH0D+CnTlzRm6++WZ5+OGHXd0cAAAAAEBWB5+lSpWS7du3p7h927ZtUqJECclK2qV+5cqV5hfRSpUqSf369U13RK00jR9QJkcrPDWojH+LTwPNrl27Srdu3aRKlSqm2qdMmTJmghRHtaeu02BUJ3OqXr26zJ8/34SxCxYsyNL3DSD99Duv39/cuXOb6u13332X04jr0smMJk+ebJZfeukl8fb25qwBAAAAgNWDz7vvvltefvnlJN3D1ZUrV2TkyJFy7733SnbTiZU04MifP3+q+128eFGCg4OldOnSpp1a1emgFWEanmp3/fj0sWNW6AMHDsjx48cT7OPv7y9NmzZNdeboyMhIM05c/BuA7KHfee3qrl588UVT6Q2kZvbs2ab3gg578thjj3GyAAAAACAnBJ86q62j6592+f7qq69kyZIlZuIQrb7UbVoNmZ00hB0yZIj55TS5SZccKleubMb51PYuXLjQdHG//fbbZe/evWb7qVOnJDY2VooVK5bgOH2sYady3Ke2T3ImTJhgKlUdN60iBZB9XnjhBalbt675I0mfPn049Uj13xSdGEsNHTo01eFdAAAAAAAWCj414NPKRu3irb8Q3n///WamW+0KqOt+/vnnJKHgjfroo48kb968zlv8yYZ0oiMdw0/H7dPx2FKjXeKfeOIJqVWrlhm785NPPjEBrnaTj08rR+PT7u2J16Vln/j0XGng4rgdPnw4Te8dQObQrspz5swx959++qksXbqUU4tk6XAIWhWsf6Dq3LkzZwkAAAAAPJxPeruNLl++XM6ePSv79u0zoV/FihWlQIECWdI4nbSoXr16CcYZdYSeOs6ndj//4YcfUq32TI7O0Hvrrbc6Kz4LFy5sQpHElZsnT550hrmOMUF1n/hjmcbfJznaHV5vAFyndu3aMmDAAFOt3qtXLzNERXp/bsDadMgT7cGgBg8eLH5+fq5uEgAAAAAguyo+49OgU4PD2267LctCT5UvXz6pUKGC85YrVy5n6Kmh5apVq6RQoULpfl4NbP/44w9ngKm/4IaGhpqJk+LTxw0bNjTLOt6bhp/x99FflFevXu3cB4D70nGIy5UrJ0eOHDFDdwDxffDBB6YiX3/OP/3005wcAAAAAMipwaerxMTEyIMPPii//fab6Qav43JqBabeNIRMyejRo+W7776Tv//+2wSeOnu73vfs2dO5T//+/WXu3Lny3nvvyc6dO6Vfv35mpnjHPtqdvW/fvjJ+/HhZvHix/Pnnn9KlSxczYzQTYADuT7+r77zzjlmePn26/PLLL65uEtzo3xYdj9kxCZb+kQ0AAAAAkMO6uruaVmrpBEWOrqvx/fjjj9KsWTOzrIHkwYMH5aeffjKPz507J88884wJSHWCoTp16siaNWtMxapDx44d5fTp0zJmzBgzxpuOW6rd+rV7v8OgQYPMDPbaVVa7+2s3/BUrVpjKVADu76677pInn3zSVPd1795dNm/eTJdmyIIFC8wfxnTYkx49enBGAAAAAMAiPCr4LFu2rOmmfj0aejpCUPXGG2+Y2/VooKm3lGjV56hRo8wNgGeaPHmy+aOGVm2//vrrZoI25Fzac2DcuHFmWceBzZMnj6ubBAAAAADIiV3d0+LChQuyf/9+GThwoKubAsANaVXf1KlTzbJWeO/Zs8fVTYILffrpp+YzoONV9+7dm2sBAAAAABZiueBTu53rBBV58+Z1dVMAuCkdl7dVq1YSGRlpujanpZIc1hMXFydjx441yzqGM8OWAAAAAIC1WC74BIDr0WErZs2aZSY80rGAdVIz5Dxffvml7NixQwIDA+WFF15wdXMAAAAAAJmM4BNAjhQSEmK6uisdGuPEiROubhKykVb5Oqo9n3vuOcmfPz/nHwAAAAAshuATQI7Vp08fueWWW+TcuXNmGTmHTnC1ZcsWM5lRv379XN0cAAAAAEAWIPgEkGP5+PjInDlzxNvbWxYtWiTLli1zdZOQTdWer7zyill+9tlnzYRXAAAAAADrIfgEkKNpxaej4k9DsIsXL7q6Schiq1atko0bN0pAQIAMGDCA8w0AAAAAFkXwCSDHGzVqlBnz8/DhwzJ8+PAcfz6szlHt+cwzz0jx4sVd3RwAAAAAQBYh+ASQ4+k4j2+//bY5D2+++ab8+uuvOf6cWNXq1atl7dq14ufnJ4MGDXJ1cwAAAAAAWYjgEwBEpGXLlvLEE0+Y8R+7d+8u0dHRnBcLV3s+/fTTUqpUKVc3BwAAAACQhQg+AeBfU6ZMkUKFCsm2bdtk8uTJnBeL2bBhg3z//fdmUqvBgwe7ujkAAAAAgCxG8AkA/ypSpIgJP9Xo0aNl3759nBsLGTt2rLnv1KmTlC1b1tXNAQAAAABkMYJPAIhHQ7EWLVrI1atXpUePHqbrOzzf5s2bZfny5eLl5SUvvfSSq5sDAAAAAMgGBJ8AEI/NZjMTHeXKlUt++OEHmT9/PufHQtWejz76qFSoUMHVzQEAAAAAZAOCTwBIpFy5cqaruxowYICcPHmSc+TBdMzWL7/80oTaw4YNc3VzAAAAAADZhOATAJLRr18/qV27tpw5c0b69u3LOfJg48aNM/cPPvigVKlSxdXNAQAAAABkE4JPAEiGzvw9d+5cMybkwoUL5ZtvvuE8eaCdO3fKp59+apaHDx/u6uYAAAAAALIRwScApCA0NNRZ7fnss8/KxYsXOVceZvz48WaCqnbt2knNmjVd3RwAAAAAQDYi+ASAVOhYn8HBwXLo0CF5+eWXOVceZP/+/bJgwQKzTLUnAAAAAOQ8BJ8AkIq8efOaWd7VtGnT5LfffuN8eYgJEyZIXFyctG7dWurWrevq5gAAAAAAshnBJwBchwZnjz32mAnRunfvLtHR0ZwzN6cVuvPnzzfLI0aMcHVzAAAAAAAuQPAJAGnwxhtvSMGCBeWPP/4wy3BvkyZNkpiYGLnzzjulYcOGrm4OAAAAAMAFCD4BIA2KFi0qkydPNssjR44040fCPR09elTeffdds0y1JwAAAADkXASfAJBGnTt3lubNm8vVq1elZ8+eZrZwuJ/XXntNoqKipFGjRtK0aVNXNwcAAAAA4CIEnwCQRjabzUx0FBAQIKtWrZIPP/yQc+dmTpw4Ie+8846z2lOvGQAAAAAgZyL4BIB0qFChgunqrvr37y///PMP58+NTJkyxVTk3nrrrdKiRQtXNwcAAAAA4EIEnwCQTgMGDJBatWrJ6dOnTfgJ96DXY8aMGWaZak8AAAAAAMEnAKSTr6+vzJkzx3Sj/t///iffffcd59ANTJ06VS5duiS1a9eWe++919XNAQAAAAC4GMEnAGSAdqV+4YUXzLJOdKSBG1zn3Llz8uabb5rl4cOHM7YnAAAAAIDgEwAyauzYsXLTTTfJwYMHZdSoUZxIF3rrrbckIiJCqlWrJvfffz/XAgAAAABA8AkAGZU3b16ZNWuWc1Kd33//nZPpAhcuXDDd3NWwYcPEy4vODAAAAAAAgk8AuCF33323dOzYUeLi4qRbt24SExPDGc1mM2fOlDNnzkjFihXl4Ycf5vwDAAAAAAyPK4vp0qWLGbst/q1+/frXPe7zzz+XqlWrir+/v7lfvHhxsr88h4SESEBAgISGhsratWsTbLfb7aY7a8mSJSVXrlzSrFkz2bFjR6a+PwCeZ9q0aVKgQAHZsmWLWUb2uXz5skyePNksv/TSS+Lt7c3pBwAAAAB4ZvCpWrduLeHh4c7b8uXLU91/w4YNpiKrU6dOsnXrVnOvVUEbN2507rNo0SLp27ev6Sap4UXjxo2lTZs2EhYW5tzn1VdfNd1Zp0+fLps2bZLixYtLixYtTDdLADlXsWLF5PXXXzfLL7/8shw4cMDVTcoxZs+eLf/884+ULVtWHn/8cVc3BwAAAADgRnzEA2nVpoaOaaVjv2lAOXToUPNY71evXm3WL1y40KzTQLNr166mq6rjmO+++86M3zdhwgRT7anrNBjt0KGD2Wf+/Pkm8FiwYIH06NEjS94rAM/w1FNPyYcffig//fSTmeX922+/ZWbxLHb16lXzBynHz3VfX19xpWLvL3Xp6wMAAAAALBB8arBQtGhRyZ8/vzRt2lTGjRtnHqdW8dmvX78E61q1auWcDCMqKko2b94sQ4YMSbBPy5YtZf369WZZK7iOHz9u1sUPYPX1dZ+Ugs/IyEhzc9BZhwFYjw67odWHNWrUkBUrVshHH30kTzzxhKubZWnvvfeeqfovXbq0dO7c2dXNgQchpAYAAAByBo8LPrX7+UMPPSTBwcEmjBwxYoTceeedJrjUIDI5GlhqZWZ8+ljXq1OnTklsbGyq+zjuk9vn0KFDKbZXq0VHjx6dwXcLwJPo5Dra1V0rw/WPLTosR+HChV3dLEvSP1hNnDjRLA8ePDjFn/8APBcBNQAAACwdfGrFVPxKym+++caM1elQvXp1qVu3rglBly1b5uyCnlI1VnzadT3xuszaJz7tftm/f/8EFZ9lypRJcX8Anu3FF180Q2j8+eefMmDAADMkBjLfBx98IIcPHzbDnugwJQAA1yCgBgAA7sytg8+2bdtKvXr1nI9LlSqVZJ8SJUqY4HPv3r0pPo/+Yuyo2HQ4efKks3pTK7J0JuDU9nGMKar76Gsmt09ytAqJSiQg59BxJufOnSsNGjQw4Zx2d9cxhpF5YmJiTDW9I2jOlSsXpxcAgOsgpAYA5ERuHXzmy5fP3FJz+vRpU/UTP4xMTAOIlStXJhjnU8fga9iwoVn28/OT0NBQs8/999/v3Ecft2vXziyHhISY8FPX1alTx9nVUidJmjRp0g2/VwDWoX+wee655+Stt94yEx1t375dcufO7epmWYZOKPf333+bP1oxsRwAALASAmoAyEHBZ2IXL16UUaNGyQMPPGCCzoMHD8pLL71kfvmNH1gm1qdPH2nSpIkJKDXI/Oqrr2TVqlWybt065z7aHb1Tp06m67wGpTpJSVhYmAktlHZn79u3r4wfP96M46c3XdYw47HHHsuW9w/Ac+ika4sXLzYBnY7zyx9IMoeOx6w/ex0/t/PkyZNJzwwAAACkHSG1Z+A6waOCT+2OrpVT2n303LlzJvy84447ZNGiRQkqQ7t06WJCUZ39XWll58cffyzDhw83kyGVL1/eHBO/G72OHarVo2PGjDGzBOv4ocuXLzfd6B0GDRokV65ckV69esnZs2fN8Vo5er2qVAA5j/5cmDlzphmyY/LkyfLII484q8WRcZ999pns3r1bChQoIL179+ZUAgAAAABSZLPr7DwW06xZM3PT6lB3o5MbBQUFyfnz5yUwMNDVzQGQxR5++GH59NNPzXAaGzduNH/ASa8TT90nOZnjr7RxcXFSq1YtM3GU/nwfOXKkq5sGAAAAAHBjXmIxFy5ckP3798vAgQNd3RQAkDfffNP8sWPz5s1mGRmnw5Ro6KnVtC+88AKnEgAAAACQs4JP/YVYJzvKmzevq5sCAGZStNdee82cCR1uQ4fhQPpp54RXXnnFLD///POmqzsAAAAAADkq+AQAd9O1a1czwdrly5fl2WefNSEe0kfHXN6yZYuZzKhfv36cPgAAAADAdRF8AkAW8/LyktmzZ4u/v798++23ZrI1ZKzaU4PjwoULc/oAAAAAANdF8AkA2aBSpUqmq7vq06ePnD59mvOeRt9//72ZGCogIEAGDBjAeQMAAAAApAnBJwBkk0GDBkm1atXkn3/+YQK2dHBUe3bv3t2MmQoAAAAAQFoQfAJANvHz85M5c+aIzWaTefPmyQ8//MC5v44Nx0/LmjVrzLnT4BgAAAAAgLQi+ASAbNSgQQPp1auXWX7mmWfkypUrnP9UvLF1r7l/6qmnpHTp0pwrAAAAAECaEXwCQDYbP368lCpVSvbv3y9jxozh/Kdg88mzsib8lPj4+MiQIUM4TwAAAACAdCH4BIBsFhgYKDNmzDDLr732mmzbto1rkIwp265Ve3bq1EnKli3LOQIAAAAApAvBJwC4QLt27eSBBx6Q2NhY6datm7nHf7aeOiffHzkpXjaRoUOHcmoAAAAAAOlG8AkALvLmm29KUFCQbNq0SaZPn851iGfatn3mvn1ISalYsSLnBgAAAACQbgSfAOAiJUuWlEmTJpnlYcOGyaFDh7gWIrLzbIQsDzsuNhHpU5PQEwAAAACQMQSfAOBC3bt3l0aNGsmlS5ekd+/eYrfbc/z1mLr1WrXnPcElpFL+fDn+fAAAAAAAMobgEwBcyMvLS2bPni1+fn6ybNky+eSTT3L09dh77qIsOXjMLPerRbUnAAAAACDjCD4BwMWqVKkiL730kll+4YUX5MyZM5JTTdu+V7TmtVWZYlKtYKCrmwMAAAAA8GAEnwDgBoYMGWIC0JMnT8qgQYMkJzoYcUkW/021JwAAAAAgcxB8AoAb8Pf3lzlz5pjld999V3766SfJad7cvk9i7Xa5o1QRqV04v6ubAwAAAADwcASfAOAmbr/9dunZs6dZfuaZZ+TKlSuSUxy+eFk+2XfELPdjJncAAAAAQCYg+AQANzJx4kQpWbKk7N27V8aNGyc5xYw/90uM3S63Fy8ktxUr6OrmAAAAAAAsgOATANxIUFCQTJ8+3SxPmjRJtm/fLlZ3/PJVWbjnsFlmJncAAAAAQGYh+AQAN3P//fdL+/btJSYmRrp37y6xcTrPuXXN/HO/RMbFyW1FC5iKTwAAAAAAMgPBJwC4Ia36DAwMlI0bN8r7uw+KVf1zJVI+3H3IWe1ps9lc3SQAAAAAgEUQfAKAGypVqpQZ71NN2LxLjl6y5kRHb+/4W67ExkntwkHSrGQRVzcHAAAAAGAhBJ8A4KZ69OghDRs2lEsxsTL0lz/FbrdWl/czV6Pk/V3Xqln717qZak8AAAAAQKYi+AQAN+Xl5SVz5swRXy+brDh8QpYeChcrmfPXAbkcEyvVCgRKi9JFXd0cAAAAAIDFEHwCgBurWrWqPF+jglke9ssOORcZJVZwPjJa5u48YJb71qpAtScAAAAAINMRfAKAm3uhRgWpEJhH/rkaKWM37xIreG/XQbkQHSM3588r9wSXcHVzAAAAAAAWRPAJAG4uwMdbXr+9pln+354wWX/8tHiyi9ExMvuvv81y35oVxYuZ3AEAAAAAWYDgEwA8QP1ihaTTzTeZ5UHrt8nVmFjxVPN2HZSzkdFSLjCPtCtb0tXNAQAAAABYFMEnAHiI4aFVpGguf9kXcUmmbd8nnkgnM3p7x9/OLvzeXjZXNwkAAAAAYFEEnwDgIYL8fWVcvWpmefr2fbLr7AXxNP/bfUhOXY2SMnlzyQPlS7m6OQAAAAAAC/O44NNmsyV7e+2111I8Zt68eckec/Xq1QT7zZw5U0JCQiQgIEBCQ0Nl7dq1Cbbb7XYZNWqUlCxZUnLlyiXNmjWTHTt2ZNl7BYDE7g0uIa3KFJPoOLsMXL9N4ux2jzlJ2j1/xp/7zbLOVO/r5XH/BAEAAAAAPIjH/dYZHh6e4Pbee++ZEPOBBx5I9bjAwMAkx2rA6bBo0SLp27evDBs2TLZs2SKNGzeWNm3aSFhYmHOfV199VaZMmSLTp0+XTZs2SfHixaVFixZy4YLnVV0B8Ez6825C/eqSx8dbfvvnrMzffUg8xcf7DsuJK5FSMneAdKxQ2tXNAQAAAABYnMcFnxo2xr999dVXcscdd0i5cuWuGxYkPjY+DTS7du0q3bp1kypVqsjUqVOlTJkyMmvWLGe1p67TYLRDhw5SvXp1mT9/vly+fFkWLFiQpe8ZAOIrmSeXvBRa2SyP27xLjl264vYnKCo2Tt7afq3as1eN8uLv7e3qJgEAAAAALM7jgs/4Tpw4IcuWLTOB5fVcvHhRgoODpXTp0nLvvfeaqk6HqKgo2bx5s7Rs2TLBMfp4/fr1ZvnAgQNy/PjxBPv4+/tL06ZNnfskJzIyUiIiIhLcAOBGdalUVkKL5JeL0THy0i9/mj/OuLPP9h+Ro5euSJEAf3m84rXZ6QEAAAAAyEoeHXxqxWW+fPlMBWZqKleubMb5XLJkiSxcuNB0cb/99ttl7969ZvupU6ckNjZWihUrluA4faxhp3Lcp7ZPciZMmCBBQUHOm1aRAsCN0tnQX29YU3xsNvn28AlZHpbyzyFXi4mLc85C36t6OcnlQ7UnAAAAACCHB58fffSR5M2b13lLPNmQju/5+OOPJxirMzn169eXJ554QmrVqmXG7vzkk0/k5ptvlrfeeitJd/j4tIIq8bq07BPf0KFD5fz5887b4cOHr/u+ASAtqhQIlOdqlDfLWvV5PjLaLU/c4gPH5NCFy1LQ30+erBTs6uYAAAAAAHIIH3Fjbdu2lXr16jkflypVyrmsIeju3bvNpETp5eXlJbfeequz4rNw4cLi7e2dpHLz5MmTzgpPx5iguk+JEiWS3Sc52h1ebwCQFfrWrChLD4bL/ohLMm7zTnm1YU23OtGxcXaZtvXaz9qe1cpJHl+3/mcHAAAAAGAhbl3xqd3YK1So4LzlypXLue3dd9+V0NBQU8WZXlql+ccffzgDTD8/P/NcK1euTLCfPm7YsKFZDgkJMeFn/H10bNDVq1c79wGA7Bbg4y2v/Rt2frAnTDaeOONWF2HpoXDZF3FJgvx85anKVHsCAAAAALKPWwefKdEJgj799FMzA3tajB49Wr777jv5+++/TeCpkyHpfc+ePZ379O/fX+bOnWu6z+/cuVP69esnYWFhzn20O3vfvn1l/PjxsnjxYvnzzz+lS5cukjt3bnnsscey7L0CwPU0LF5IHq94bfzggeu3SWRsrFuctDi7Xab+W+3ZrUpZyefn6+omAQAAAAByEI/sc/jxxx+bqs1HH3002e0aSB48eFB++ukn8/jcuXPyzDPPmG7qOsFQnTp1ZM2aNXLbbbc5j+nYsaOcPn1axowZI+Hh4VK9enVZvny5mQneYdCgQXLlyhXp1auXnD171nTDX7FihalMBQBXGlG3iqw4fFL2nr8ob27bJy/WqeTyC/Jd2AnZde6C5PX1ke5VQ1zdHAAAAABADmOza4JoMc2aNTO3UaNGiTtWq2r4qhMdBQYGuro5ADzAiafuS9N+Xx04Jj1W/y6+Xjb5vm0TuTm/6/4oo/+0tPp6nWw7fV5eqFFBXgqtnOHnKvb+0kxtGwAAAAAgZ/DIru6puXDhguzfv18GDhzo6qYAQLZqW7aEtChdVKLj7KbLu3Y1d5Xvj540oWcuH295phrVngAAAACA7Ge54FO7nR8+fFjy5s3r6qYAQLbSsYgn1K8heXy85deTZ+XD3WEuq/Z849+xPTtXCpbCAf4uaQcAAAAAIGezXPAJADlZ6by5ZOgt17qVj928U8IvXcn2NqwNPyWb/zknAd5e0qtauWx/fQAAAAAAFMEnAFjMU5XLSp3C+eVCdIwM/3VHtr/+lH+rPR+/+SYpmjsg218fAAAAAABF8AkAFuPtZZPJDWuKj80myw4dl28OHc+2195w/LT8cuKMmWCpV/Xy2fa6AAAAAAAkRvAJABZUtWCgM3gcunG7RERFZ8vrTt12rdrzkQplpFSeXNnymgAAAAAAJIfgEwAsql+tihKSL7ccvxwp43/fleWv9/s/Z2X1sVPibbPJczUqZPnrAQAAAACQGoJPALCoXD7e8lrDmmZ5/q5DsunkmWwZ2/PB8qUkOF/uLH0tAAAAAACuh+ATACysUYnCptu5XUQGrN8mkbGxWfI6206fl1VHToqXTaRPTao9AQAAAACuR/AJABY38tYqUjjAT/acuygz/tyfJa8x9d9qz/YhJaVcYN4seQ0AAAAAANKD4BMALK6Av5+Mva2aWZ66dZ/sPXcxU59/59kIWR52beb4PjUrZupzAwAAAACQUQSfAJADtAspKXeWKiJRcXHy4oZtEmfXzu+ZQ8NUdU9wcamUP1+mPS8AAAAAADeC4BMAcgCbzSaTGtSQ3D7e8suJM/LRnrBMed595y/KkoPHzHI/qj0BAAAAAG6E4BMAcogyeXPLkDqVzPIrv+2UE5ev3vBzTtu2z0yc1LJMMaleKCgTWgkAAAAAQOYg+ASAHKRrlRCpVShIIqJjZNjGHTf0XIcuXJIv/j5qlvvVYmxPAAAAAIB7IfgEgBzE28smU26vJd42m3x9KFy++3dSoox4c9s+ibXb5Y6SRaRO4fyZ2k4AAAAAAG4UwScA5DDVCgbKs9XKmeUhv/wpF6Ki0/0cRy5ekU/2HzHLVHsCAAAAANwRwScA5ED9a98swflyS/jlqzLh993pPn76n/skOs4utxcvJLcVK5glbQQAAAAA4EYQfAJADqSzu7/WoIZZfn/XQfnt5Nk0H3v88lVZuOewWabaEwAAAADgrgg+ASCHalKyiDxcvrSZlX3g+m0SFRuXpuNm/rlfIuPi5NaiBUzFJwAAAAAA7ojgEwBysFG3VpWC/n6y69wFE2hezz9XIuXD3YfMcr+aFcVms2VDKwEAAAAASD+CTwDIwQoG+Mkrt1U1y29s3Sv7z19Mdf93dvwtV2LjpFahILmjVJFsaiUAAAAAAOlH8AkAOVyHcqXkjpJFTPd17fJut2vn96TOXI0y44Gq/rWo9gQAAAAAuDeCTwDI4bS7+sQGNSSXj7dsOHFGFu69NnFRYnN2HpBLMbFSrUCgtCxTLNvbCQAAAABAehB8AgAkOF9uGVT7ZnMmRv+2U05evprgrERERcu7fx0wy31rVWBsTwAAAACA2yP4BAAY3auGSM1CQXI+KlqG/7ojwVl5d+dBiYiOkYpBeeWe4BKcMQAAAACA2yP4BAAYPl5eMrlhTfG22WTJwXBZcfiEWX8xOkZm//W3We5bs4J4MZM7AAAAAMADEHwCAJxqFAqSZ6qGmOWhv2w3oef83YfkbGS0hOTLLe1CSnK2AAAAAAAewcfVDQAAuJcX61SSZYeOS9jFy1L30+/lXFS0Wd+sVBFTFQoAAAAAgCfgN1gAQAK5fbzlwXKlzLIj9FTv7zokyw6Fc7YAAAAAAB6B4BMAkMS3h48nWWcTkcl/7OFsAQAAAAA8gs1ut9td3YicJCIiQoKCguT8+fMSGBjo6uYAQLJy5colV69eTbI+ICBArly5wlkDAAAAALg9t6r4/OKLL6RVq1ZSuHBhsdls8scffyTZJzIyUp5//nmzT548eaRt27Zy5MiR6z73zJkzJSQkxPzSHhoaKmvXrk2wXfPfUaNGScmSJc0v/M2aNZMdO3ZkymsDgKe5+eabzc/h+PRxpUqVXNYmAAAAAAA8Nvi8dOmS3H777TJx4sQU9+nbt68sXrxYPv74Y1m3bp1cvHhR7r33XomNjU3xmEWLFpnjhg0bJlu2bJHGjRtLmzZtJCwszLnPq6++KlOmTJHp06fLpk2bpHjx4tKiRQu5cOHCDb02AHiikSNHmj8IOcJPvdfHuh4AAAAAAE/gll3dDx48aKozNaSsXbu2c712Dy9SpIh8+OGH0rFjR7Pu2LFjUqZMGVm+fLmpFk1OvXr15JZbbpFZs2Y511WpUkXat28vEyZMML/Ma6WnBpuDBw92VncWK1ZMJk2aJD169MjwaydGV3cAnkKr8MeMGSO7d+82lZ4aet5///2ubhYAAAAAAJ5X8Xk9mzdvlujoaGnZsqVznQaW1atXl/Xr1yd7TFRUlDku/jFKHzuOOXDggBw/fjzBPv7+/tK0aVPnPhl5bUeAqmFn/BsAeIIOHTqYIUd0TE+9J/QEAAAAAHgSjwo+NZz08/OTAgUKJFivlZm6LTmnTp0yXdF1n5SOcdxfb5/0vrbSilKdzMhx0wpRAAAAAAAAABYNPj/66CPJmzev85Z4sqH0iD8OXUoSb0/umLTsk97XHjp0qOkm77gdPnw41ecDAAAAAAAAcON8xEV0RnQde9OhVKlS1z1GJxzSrutnz55NUHl58uRJadiwYbLH6Azs3t7eSaoy9RhHhac+r9J9SpQokeI+6X1tR5d5vQEAAAAAAADIARWf+fLlkwoVKjhvuXLluu4xoaGh4uvrKytXrnSuCw8Plz///DPF8FG7p+tx8Y9R+thxjE6kpMFm/H005Fy9erVzn4y8NgAAAAAAAIAcVvGZnDNnzkhYWJiZLV3pTMJKQ0m96RiZXbt2lQEDBkihQoWkYMGCMnDgQKlRo4bcddddKT5v//79pVOnTlK3bl1p0KCBzJ4927xOz549zXbtqq4zuo8fP14qVqxobrqcO3dueeyxx8w+GX1tAAAAAAAAADk8+FyyZIk89dRTzsePPPKIuR85cqSMGjXKLL/xxhvi4+MjDz/8sJlpuHnz5jJv3jzTnd2hWbNmUrZsWbNedezYUU6fPi1jxowxVZo6E/vy5cslODjYecygQYPM8/Xq1ct0Z9du+CtWrDCVqQ5peW0AAAAAAAAArmez6+w8FqOhpwalXbp0EXcTERFhqkd1oqPAwEBXNwcAAAAAAACwJJeN8ZlVdu3aZao0n3zySVc3BQAAAAAAAICLWLLi051R8QkAAAAAAABkPctVfAIAAAAAAACAW01ulBM4Cmy18hMAAAAAAABAxuhwlzabLcXtBJ/Z7MKFC+a+TJky2f3SAAAAAAAAgGVcb/JwxvjMZnFxcXLs2LHrJtIAAAAAAAAAUna9fI3gEwAAAAAAAIDlMLkRAAAAAAAAAMsh+AQAAAAAAABgOQSfAAAAAAAAACyH4BMAAAAAAACA5RB8AgAAAAAAALAcgk8AAAAAAAAAlkPwCQAAAAAAAMByCD4BAAAAAAAAWA7BJwAAAAAAAADLIfgEAAAAAAAAYDkEnwAAAAAAAAAsh+ATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8JnN7Ha7REREmHsAAAAAAAAAWYPgM5tduHBBgoKCzD0AAAAAAACArEHwCQAAAAAAAMByCD4BAAAAAAAAWA7BJwAAAAAAAADL8XF1AwAAAAAAAJCzRcbYJTbOWhNBe3vZxN/H5upm5GjpDj7DwsKkTJkyYrMlvHA6S/nhw4flpptuysz2AQAAAAAAwOKh59ajkXIlxlrBZy4fm9Qq5U/46UnBZ0hIiISHh0vRokUTrD9z5ozZFhsbm5ntAwAAAAAAgIVppaeGnr5eNvHztkaFZFTstfd0rYrVGu8pRwSfWtmZuNpTXbx4UQICAjKrXQAAAAAAAMhBNPS0UtfwaIt13bd08Nm/f39zr6HniBEjJHfu3M5tWuW5ceNGqV27dta0EgAAAAAAAACyIvjcsmWLs+Jz+/bt4ufn59ymy7Vq1ZKBAwem57UBAAAAAAAAwLXB548//mjun3rqKZk2bZoEBgZmTYsAAAAAAAAA4AZ5pfeA999/34Se+/btk++++06uXLnirAQFAAAAAAAAAI8MPnX29ubNm8vNN98sd999t5nhXXXr1k0GDBiQFW0EAAAAAAAAgKwNPvv27Su+vr4SFhaWYIKjjh07yrfffpvepwMAAAAAAACATJfmMT4dVqxYYbq4ly5dOsH6ihUryqFDhzKzbQAAAAAAAACQPRWfly5dSlDp6XDq1Cnx9/fPWCsAAAAAAAAAwJXBZ5MmTeSDDz5wPrbZbBIXFyevvfaa3HHHHZnZNgAAAAAAAADInq7uGnA2a9ZMfvvtN4mKipJBgwbJjh07zKRHP//8c8ZaAQAAAAAAAACuDD6rVq0q27Ztk1mzZom3t7fp+t6hQwfp3bu3lChRIjPbBgAAAAAAkGGRMXaJjbNzBj3gOgFZwWa32/l0ZaOIiAgJCgqS8+fPS2BgYHa+NAAAAAAAOSpM23o0Uq4QqnmEq9F2KZLHW3y9bWKVz9+l6Di5tYy/5PZL90iTcFXFpzp37pz8+uuvcvLkSTO+Z3xPPvlkZrUNAAAAAAAgQ7TSU0NPXy+b+FkkTLOyfH5imdAT7iPdkfPSpUvlpptukjZt2shzzz0nffr0cd769u17ww1as2aN3HfffVKyZEkzcdKXX36ZYLsWqI4aNcpsz5UrlxlvVMcYvZ7PP//cdNPXmef1fvHixUn2mTlzpoSEhEhAQICEhobK2rVrM+W1AQAAAACAa2jo6e/Dzd3PAaEn3CL4HDBggDz99NNy4cIFU/l59uxZ500nOLpROmZorVq1ZPr06cluf/XVV2XKlClm+6ZNm6R48eLSokUL056UbNiwQTp27CidOnWSrVu3mvuHH35YNm7c6Nxn0aJFJrgdNmyYbNmyRRo3bmzC3bCwsBt6bQAAAAAAAAAeMMZnnjx5ZPv27VKuXDnJalrxqZWZ7du3N4+1qVptqQHl4MGDzbrIyEgpVqyYTJo0SXr06JHs82joqWNrfvPNN851rVu3lgIFCsjChQvN43r16sktt9xiJm1yqFKlinntCRMmZPi1E2OMTwAAAAAAst7lqDjZdDhS8vh6mYpCIDsxxqeHVny2atVKfvvtN3GFAwcOyPHjx6Vly5bOddp1vWnTprJ+/fpUKz7jH+N4H45joqKiZPPmzUn20ceOfTL62hqOatgZ/wYAAAAAAADAzSY3uueee+TFF1+Uv/76S2rUqCG+vr4Jtrdt21ayigaPSqss49PHhw4dSvW45I5xPN+pU6ckNjY21X0y+tpaLTp69Og0vkMAAAAAAAAALgk+u3fvbu7HjBmTbNd0DRCzmr5OfNoNPfG6jByTWfvEN3ToUOnfv7/zsVZ8lilTJtW2AgAAAAAAAMjm4DMuLk5cRScTclRflihRwrn+5MmTSSoxEx/nqNhM7pjChQuLt7d3qvtk9LW1O7zeAAAAAAAAALjxGJ+uFBISYgLIlStXOtfp+JyrV6+Whg0bpnhcgwYNEhyjVqxY4TzGz89PQkNDk+yjjx37ZPS1AQAAAAAAAHhAxWdWu3jxouzbt8/5WCcV+uOPP6RgwYJy0003mVnVx48fLxUrVjQ3Xc6dO7c89thjKT5nnz59pEmTJmb29Xbt2slXX30lq1atknXr1jn30e7onTp1krp165qgdPbs2RIWFiY9e/Y027U7e0ZeGwAAAAAAAED2c7vgU2eMv+OOO5yPHeNjdu7cWebNmyeDBg2SK1euSK9eveTs2bNSr149U72ZL18+5zFdunSRgwcPyk8//WQea0Xmxx9/LMOHD5cRI0ZI+fLlZdGiReZYh44dO8rp06fN2KXh4eFSvXp1Wb58uQQHBzv3SctrAwAAAAAAAHA9m11n57GYZs2amduoUaPE3ejkRkFBQXL+/HkJDAx0dXMAAAAAABkQGWOX2DjL/TptuWu0LTxK8vh6ib9P6hMiA1nx+bsUHSe3lvGX3H4eNdKkpbhdxeeNunDhguzfv1++/vprVzcFAAAAAGDRQGPr0Ui5EkPw6e6uRtsln5+rWwHAo4JPDRbff/99cz9t2jQpWrSofPvtt1KmTBmpVq2auJJ2Oz98+LBL2wAAAAAAsC6t9NTQ09fLJn7eVBK6Mw09fblGQI6V7uBTZzFv06aN3H777bJmzRoZN26cCT63bdsmc+fOlc8++yxrWgoAAAAAgBvR0JMu1ADgvtI9yMCQIUNk7NixsnLlSvHz+69eXCck2rBhQ2a3DwAAAAAAAACyPvjcvn273H///UnWFylSxMyKDgAAAAAAAAAeF3zmz59fwsPDk6zfsmWLlCpVKrPaBQAAAAAAAADZF3w+9thjMnjwYDl+/LjYbDaJi4uTn3/+WQYOHChPPvlkxlsCAAAAAAAAAK4KPnUyo5tuuslUd168eFGqVq0qTZo0kYYNG8rw4cMzq10AAAAAAAAAkGE2u91uz8iB+/fvN93bteKzTp06UrFixYy3IgeJiIiQoKAgOX/+vAQGBrq6OQAAAACAdLocFSebDkdKHl8vZnUHkKzIGLtcio6TW8v4S26/dNcdIpP4pPeA1atXS9OmTaV8+fLmBgAAAAAAAADuJt2Rc4sWLUxX9yFDhsiff/6ZNa0CAAAAAAAAgOwMPo8dOyaDBg2StWvXSs2aNc3t1VdflSNHjtxIOwAAAAAAAADA9WN8qgMHDsiCBQtk4cKFsmvXLjPJ0Q8//JB5rbMgxvgEAAAAkNqYcLFxGf4VDdl4nbaFRzHGJ4BUf04wxqeHB58qNjZWvvnmGxkxYoRs27bNPEbKCD4BAAAApPRL8tajkXIlhuDTE1yNtkuRPN7i621zdVMAuCGCTw+d3Mjh559/lo8++kg+++wzuXr1qrRt21bGjx+fua0DAAAAgBxCKz019PT1sokfYZrby+cnhJ4AYLXg86WXXjJd23Wsz7vuukumTp0q7du3l9y5c2dNCwEAAAAgB9HQ09+HKkIAALI9+Pzpp59k4MCB0rFjRylcuPANNwAAAAAAAAAAXB58rl+/PtMbAQAAAAAAAADZHnwuWbJE2rRpI76+vmY5NTrWJwAAAAAAAAC4/azuXl5ecvz4cSlatKhZTvHJbDZmdb8OZnUHAAAAkJzLUXGy6XCk5PH1YoxPAPBwzOruQRWfcXFxyS4DAAAAAAAAgDtKuXwzBR988IFERkYmWR8VFWW2AQAAAAAAAIDHBZ9PPfWUnD9/Psn6CxcumG0AAAAAAAAA4HHBpw4JqmN5JnbkyBEJCgrKrHYBAAAAAAAAQNaO8anq1KljAk+9NW/eXHx8/js0NjZWDhw4IK1bt854SwAAAAAAAAAgu4PP9u3bm/s//vhDWrVqJXnz5nVu8/Pzk7Jly8oDDzyQWe0CAAAAkMmzy8bG2Tmnbn6NAACAC4LPkSNHmnsNODt27CgBAQGZ2AwAAAAAWRmobT0aKVcI1tze1Wi75PNzdSsAAMhhwadD586ds6YlAAAAALKEVnpq6OnrZRM/76Tj9cN9aOjpyzUCAMA1waeO5/nGG2/IJ598ImFhYRIVFZVg+5kzZzKnZQAAAAAylYae/j4EnwAAIGdI96zuo0ePlilTpsjDDz8s58+fl/79+0uHDh3Ey8tLRo0alTWtBAAAAAAAAICsDD4/+ugjmTNnjgwcONDM7P7oo4/K3Llz5eWXX5ZffvklvU8HAAAAAAAAAK4PPo8fPy41atQwyzqzu1Z9qnvvvVeWLVuW+S0EAAAAAAAAgKwOPkuXLi3h4eFmuUKFCrJixQqzvGnTJvH395ecYObMmRISEmJmtg8NDZW1a9e6ukkAAAAAAAAAbiT4vP/+++X77783y3369JERI0ZIxYoV5cknn5Snn35arG7RokXSt29fGTZsmGzZskUaN24sbdq0MRM9AQAAAAAAAHAPNrvdbr+RJ9BxPdevX2+qP9u2bStWV69ePbnllltk1qxZznVVqlSR9u3by4QJE657fEREhAQFBZkhAgIDA7O4tQAAAIDI5ag42XQ4UvL4ejGrOwAA2SAyxi6XouPk1jL+ktsv3XWHyCQ+N/oE9evXN7ecICoqSjZv3ixDhgxJsL5ly5Ym/E1OZGSkucUPPpG1LpyJkKh45xzIVl5eIr45Y9gPAIDniIqxi/elSxJjt4uXj83VzQEAwPJiY+3i5aWxG78fun3wuWTJkjQ/oZWrPk+dOiWxsbFSrFixBOv1sU76lBytAh09enSS9bfeeqt4e3vLo48+Kr1795ZGjRo5t/3111/Sr18/+e6778zj4cOHm4raLl26mMfly5eXpUuXyn333Sf79+836+bNmyf79u2TsWPHmsetWrWSN954Q6pWrep83nXr1smMGTNk4cKF5rG+ru7nuGYFChSQn3/+WTp37mzGbFVTpkwx9/3793e2e/78+XL77bfL2bNnnZ8Pbas+t3Lle+re7RmpWjJEeg/pZx4H5guUBbPekyHjXpY/d/5l1g1+/tp7mfTWtfdWvUpVmThsjDz27NMSceFaMD1j4huy7tcNsvCLT8zju+9qJY91eFie6NXV+dpf/+8zmfDmZPn51w3mcc/OXeWmUmXkpfGjzOMypUrLrElT5dnBfeXw0SNm3fiXRknY0cPy9vx3zePbb2sgQ18YIPc+8aDzef83811Z8MUnsnzVtXP1aIeHpdFtDXhPnnKdBvcVscdJYN588vHkN2Xw5Imyfc9us8+Q7s+a+4lzrlWM17i5kkwaMEQeGfCCRFy8YNbNGjlW1m3eJB99/ZV5fE/TO+Xx+9rJYwP7OF97+Tvvy/jZM81+6tlHnpDgkqVkyJRJ5vFNJUrK26PGSc9RwyQs/Ni11+w/WA4dOyqzPv6fedwo9FZ56ZlecnePp5zPu+D1afLR0q9k2eofzOPH721n9nt29PBr3yfeE9eJzx7fJ35GePTPcrvNJnnzBcncae/KqEmjZOfua/9v1LdnX3M/9e2p5r5KpaoyavAo6danq1y4cO09vf7KZPnltw3y2Vefmcct72wpD7Z9SJ7p29352ove+0SmzJwiG3/7xTx+6vGnpUypMjLm1Wv/L1yqZCmZMvYN6T+8nxw9dtSse3nQSDl89LC8/9F75nG9uvWlf6/+0vHph53PO3vqHPlsyaey4odrcws82O5BqV+3gQwcMcA8zpcvH++J68Rnj+8TPyP4We6W/z59MP09eWZCP/l9y+8embH0dvPcSI/JlK7uXlrBlAY2m80Eg1Z17NgxKVWqlKnubNCggXP9uHHj5MMPP5Rdu3alqeKzTJkydHXPQlR8wmWiIiXu0F4Rbx8RXz8uBADAfURHiVdcrPiXqyjiR+UJAADZwdvPX3IF5eNku3vFZ1xcXNa3xAMULlzYVGkmru48efJkkipQB53pPqfMdu8u8hVk7FS4RtyVyxJ53Eu8AnKJje89gBzEHh2t/8Po6mYgFXZvb7HHxIl/wQLilSs35woAAOQINzzGZ07i5+cnoaGhsnLlSjO7vYM+bteunUvbBgAA4KrQM/bMP2ILCOACuDmbfy6xeXu7uhkAAADuG3yOGTMm1e0vv/yyWJmOWdCpUyepW7eu6e4+e/ZsCQsLk549e7q6aQAAANkvLs6Enn6Va4qNLtRuTUNPrhEAAMhJ0h18Ll68OMHj6OhoOXDggPj4+JiBRq0efHbs2FFOnz5tAuDw8HCpXr26LF++XIKDg13dNAAAAJfRQI0u1AAAAHAnaZrc6Hp0wh6dZUm7f2s1JFI/V0FBQUxuBFh1jM9tm8QrIA9jfALIMeyRkRJ39ZL417yV4BMAAABuJW3TtV9HYGCgqYAcMWJEZjwdAAAAAAAAALg++FTnzp0zVYwAAAAAAAAA4HFjfL755psJHmtPeR3r8sMPP5TWrVtnZtsAAAAAAAAAIHuCzzfeeCPBYy8vLylSpIh07txZhg4dmrFWAAAAAAAAAIArg0+dwR0AAAAAAAAAcsQYnwAAAAAAAADgsRWfV69elbfeekt+/PFHOXnypMTFxSXY/vvvv2dm+wAAAAAAAAAg64PPp59+WlauXCkPPvig3HbbbWKz2dL/qgAAAAAAAADgTsHnsmXLZPny5XL77bdnTYsAAABExB4dLZKoZwncjz0mytVNAAAAADIn+CxVqpTky5cvvYcBAACkK/SMPfOP2AICOGsewOafS2ze3q5uBgAAAHBjwefkyZNl8ODB8vbbb0twcHB6DwcAALi+uDgTevpVrik2P3/OmJvT0JPrBAAAAI8PPuvWrWsmOCpXrpzkzp1bfH19E2w/c+ZMZrYPAADkYBqmeeXK7epmAAAAAMgJweejjz4qR48elfHjx0uxYsWY3AgAAAAAAACA5wef69evlw0bNkitWrWypkUAAAAAAAAAcIO80ntA5cqV5cqVKzf6ugAAAAAAAADgPsHnxIkTZcCAAfLTTz/J6dOnJSIiIsENAAAAAAAAADyuq3vr1q3NffPmzROst9vtZrzP2NjYzGsdAAAAAAAAAGRH8Pnjjz9m5HUAAAAAAAAAwH2Dz6ZNm2ZNSwAAAAAAAADAVcHnmjVrUt3epEmTG2kPAAAAAAAAAGR/8NmsWbMk63RsTwfG+AQAAAAAAADgccHn2bNnEzyOjo6WLVu2yIgRI2TcuHGZ2TYAALKEPTpaJC6Os+vG7DFRrm4CAAAAgJwWfAYFBSVZ16JFC/H395d+/frJ5s2bM6ttAABkSegZe+YfsQUEcHbdnM0/l9i8vV3dDAAAAAA5JfhMSZEiRWT37t2Z9XQAAGSNuDgTevpVrik2P3/OshvT0JNrBAAAACDbgs9t27YleGy32yU8PFwmTpwotWrVynBDAADIThqoeeXKzUkHAAAAAItKd/BZu3ZtM5mRBp7x1a9fX957773MbBsAAAAAAAAAZE/weeDAgQSPvby8TDf3AMZKAwAAAAAAAOCpwWdwcHDWtAQAAAAAAAAAMolXWnf84YcfpGrVqhIREZFk2/nz56VatWqydu3azGoXAAAAAAAAAGR98Dl16lTp3r27BAYGJtkWFBQkPXr0kClTpmS8JQAAAAAAAACQ3cHn1q1bpXXr1ilub9mypWzevDmz2gUAAAAAAAAAWR98njhxQnx9fVPc7uPjI//880/GWwIAAAAAAAAA2R18lipVSrZv357i9m3btkmJEiVuqDFffPGFtGrVSgoXLiw2m03++OOPJPtERkbK888/b/bJkyePtG3bVo4cOXLd5545c6aEhISY2edDQ0OTjEdqt9tl1KhRUrJkScmVK5c0a9ZMduzYkSmvDQAAAAAAAMBNg8+7775bXn75Zbl69WqSbVeuXJGRI0fKvffee0ONuXTpktx+++0yceLEFPfp27evLF68WD7++GNZt26dXLx40bxubGxsiscsWrTIHDds2DDZsmWLNG7cWNq0aSNhYWHOfV599VUzRun06dNl06ZNUrx4cWnRooVcuHDhhl4bQM5jj4kSe2QkN3c9BzFRrv6IAAAAAACygc2upY5p7Op+yy23iLe3tzz33HNSqVIlU5W5c+dOmTFjhgn/fv/9dylWrNgNN+rgwYOmOlNDytq1ayeYPb5IkSLy4YcfSseOHc26Y8eOSZkyZWT58uWmWjQ59erVM22fNWuWc12VKlWkffv2MmHCBFPtqZWeGmwOHjzYWd2p72XSpElm4qaMvrY+j94cIiIizDH6fMlNFAXAc9mjIiXyr61ij7zi6qbgOmz+ucS/ai2x+flzrgAAAADAonzSuqOGgOvXr5dnn31Whg4dasJCpeGnhn7alTwzQs/U6ORJ0dHRZiIlBw0sq1evbtqWXPgYFRVljhsyZEiC9foceow6cOCAHD9+PMHz+vv7S9OmTc0+Gnxm5LWVBqujR4/OlPcPwL1piKZhmp0qcLdn8/Ym9AQAAAAAi0tz8KmCg4NNdePZs2dl3759JvysWLGiFChQQLKDhpN+fn5JXk8DV92WnFOnTplq1MShbPxjHPfJ7XPo0KEMv7bSkLh///5JKj4BWDf8tLm6EQAAAAAAIO1jfMan4d+tt94qt912W4ZDz48++kjy5s3rvCWebCg9NIDVytPUJN6e3DFp2Se9r62Vo9qlPf4NAAAAAAAAgBtVfGYmnRFdx96MP2v89eiEQ9p1XStO4weuJ0+elIYNGyZ7jM7AruOSJq7K1GMcFZ76vEr3iT8zfeJ90vvayXEMEaCVnwAAAAAAAAAyJl++fKkWJPq4smF6S4/Q0FDx9fWVlStXysMPP2zWhYeHy59//mlmZU+Odk/X4/SY+++/37leH7dr184s60RKGmzqujp16ph1GnKuXr3aTG6U0ddOjmOWeLq7AwAAAAAAABl3vcnDXRZ8JufMmTMSFhZmZktXu3fvNvcaSuotKChIunbtKgMGDJBChQpJwYIFZeDAgVKjRg256667UnxeHWOzU6dOUrduXWnQoIHMnj3bvE7Pnj3Ndk2GdUb38ePHmzFL9abLuXPnlscee8zsk9HXTkwnRDp8+PB1E2lkjGMMVT3HDCsA3Di+U0Dm4fsEZC6+UwDfKcCd8e9U9rheUaVbBZ9LliyRp556yvn4kUceMfcjR46UUaNGmeU33nhDfHx8TNXllStXpHnz5jJv3jzTnd2hWbNmUrZsWbNedezYUU6fPi1jxowxVZo6E7tO0qSTNTkMGjTIPF+vXr1Md3bthr9ixYoEJzAtr309Xl5eUrp06Rs8U7gexlMFMhffKYDvE+Cu+DcK4DsFuDP+nXItm90x6KSFaOipQWmXLl1c3RS44C8qWp17vVJnAHyngOzGv1EA3ynAnfHvFMB3yooyNKu7O9u1a5ep0nzyySdd3RQAAAAAAAAALuJWXd0zQ+XKlWX79u2ubgZcxN/f3wyNoPcA+E4B7oR/owC+U4A7498pgO+UFVmyqzsAAAAAAACAnM1yXd0BAAAAAAAAgOATAAAAAAAAgOUQfAIAAAAAAACwHIJPAAAAAAAAAJZD8AkAAAAAAADAcgg+4VHsdrurmwBYCt8pAAAAAOD3KKsi+ITHOHnypFy4cMH5mMAGuDHnz5+X2NhYvlNAJti3b5+sXLmScwlkkj179kjPnj1l7dq1nFMgExw+fFg2b94sx44d43wCN4hswrMQfMLtxcTESNeuXeW2226Tu+66Sx5//HE5deqU2Gw2VzcN8EjR0dHSu3dvufvuu83tlVdeMQEo3ykgY7Zt2yY333yzPProo3Lo0CFOI3AD4uLipF+/flK7dm25dOlSgj96A8jY//f16NFDbrnlFnn66aelVq1a8vPPP3MqgQwgm/BMBJ9w+x8sXbp0kb/++kvmz59vfqnUXzA7dOggO3fudHXzAI+jFWlVq1aVHTt2yIsvvihlypSRjz76SEaNGmW2U0kNpF9UVJS0atVKfH195dVXX+UUAjfgm2++kU2bNpn7Dz/80PyBzoF/o4D0uXjxojz44IOyd+9eWbFihXzyyScmAB0xYgTfKSCdyCY8F8En3Fp4eLj8+uuvpjqtadOmpgJAg5u///5bZs2aJSdOnHB1EwGPERERYf6HVwMa/R61b9/efI8eeeQR80vm5cuXqfoEMuD333+XAgUKmD8izJ492/y7BSBj5s6da6o99f/7Vq9ebQKaefPmSVhYGP9GAemkxSNaLKLfozp16kilSpXkoYceknz58pnqanr7AGlHNuG5CD7h1k6fPi1HjhyR+vXrm8eRkZFSvHhxGTp0qPmr5Zo1a1zdRMBjaHf2Ro0aSbdu3UxlmlbO+Pn5ydWrV+XKlSuSO3duqmmANIpfeebv7y/BwcFy5513yq233iqjR492/rEBQNq/U9qtXYczat68uYwdO9b8YW779u3y//buPbTm/w/g+Ps7o7klYjS534bGolFTzB+UIrm3sZvLGjWXzCVpkvslRcglkvudyCULKRNjbrkzRIutzJ015v3t9fp2zm/8fr++w5nPOefzfJS283HO+nzO9jrvc17v1/v1zsrK0vg6evQoTyfwk8vcpQe1jFNC4mvNmjUmIiLCbN68Wd//AagYchOBi8Qn/IZUyWzcuPG7ZGabNm000bl9+3a9HRLyz5+sVIDKTKUsg5JkKID/H1NSMSOkIi0pKUkraYTM9Hs2OWrZsqV+z8w/ULF4kljxxJBUfMpyQiFVnydPnjT9+vXT6up79+7xlAIVjCl5byeJGqn6lM2NDh48aPbv36+9c1u1aqWJGmIKqPhnqR49epi4uDiTmpqq41LDhg31s5VMfEshSXJysk4uAPietC6aNWuWro7zkIppiSFyE4GHxCcct2vXLn0BkWVMa9eu1T40Cxcu9FaoyXIMuY/snCZValKdJjIyMsyhQ4eoUAP+JaYkhjwx5UnUlJ9IuHbtmlaCCvqnAf8eT4sWLfL2ehIyPknrCHH69GmtrJGvmZmZJjIykqcUqGBMibS0NJ3YvnTpkmndurUJDQ3VpOjs2bP12OvXr3k+gQp+lhJSKX3s2DFdhSDJHImvlStXatsj2eWdyQTgP3bu3GnCw8PN4cOHtVp66tSpujmY533f8OHDyU0EIgs4aMeOHbZz58523bp1erugoMCuXr3a1qxZ0759+1aPZWdn25iYGDthwgS9/e3bN/169uxZGx4ebm/cuOHgFQCBE1Pv3r37r/s/efLENmjQwN67d897LD8/X7+WlZX9wTMHAjeekpOTbWJioo5VEk/z5s2zdevWtcuXL3fw7IHAfN9369YtGxcXZzt06GBfvHjhfeznz59trVq17L59+xw7fyBQx6mrV6/adu3a2aKiIu9nqa9fvzJWAeVs3LjRRkdH2/Xr1+vtL1++aIxVr17dvn//Xo+RmwhMVHzCqYS7fpXlTN27d9flt0L6zcgy3MaNG2szbiGVaAkJCbqru1R4ymNETk6O7k4dFRXFbxGuV5GYkub2P5IlubKzuyzdkMpPeaz01JUZTU9FKOA2PxNP0h9NqmiOHz9uunXrpnEklWkzZsww06ZNM0+fPnX0WoBAiympkp48ebLJz88369atMwUFBXr8yJEj+p6vZ8+eDl4JEJjv+6SPu+zs/vz5c29bI6kEbdGihfbPBdzMsyJOYklW66SkpOhtWXFQXFxsxo0bZ8LCwvRYbGys5iakwprcRABxOvMKd8nLy7OvX7/23n7z5o3ONpZ3/fp126hRI1tcXOw9JjOW06dPt7Vr17a9evWyw4YN05mXNWvW6P97Zi4Bt/nVmPLETEZGhh06dKidMmWKDQkJsWPGjLElJSV/8AqAwI+n3Nxce/v27e/uJ3G0dOlSKqfhar8aU2LVqlU2IiJCq9QGDRqkFWwLFiz4Y+cOBFNMvXr1ysbHx9saNWrY9PR0m5SUpJ+rsrKy+BwFV8eTxFB55fMKM2fOtKGhoTYyMlIrQbdt26ZVoKWlpTYzM5PcRAAJdTrxCnc4cOCAzt5L3zOZmZRG2rJBkfSj8cyyeKrLzpw5ow3sZSOW0tJSbb4tze6XLFmiu+XeunXLFBYW6mYSnt5pbMgCt/ndmPJszCIVNM+ePTO9evXS5vZSRQ24za/Gk2yuJ4+RselHclwqPgE3+t0xytPLXaqo5f2eVKktXrzYtG3b1tHrAgI1purVq2c2bdqkq3ykL7W4cuUKMQVX+jGepMJz/PjxuvGXJ552795tLl68qP085fipU6f0PnXq1DEDBgwwy5Yt0wpRchOB4S/Jfjp9EghuMqgmJiaa9PR007t3b12iPmfOHG28PX/+fB2I5cVF/kk5+eDBg3WZxurVq50+dSCoY0p2c5edCrt06WL69u3r2PUATmKMAogpwE3jlLQzkvsBblSReBLSxkhaRJSPlWbNmpkxY8aYrKwsB68Av4IGbqg0npy6vLh8+PDBpKammk6dOulMiby4SB802XlQ/xBDQvSfPObmzZumX79+evzBgwcmPj5eZ/oBt/N1TMmM5cyZM0l6wpUYowBiCnDjOEXSE270M/EkZMWpJ1bksdKzXRKh9evXd+wa8OtIfKLSeJafP3nyRJdRlB9kpZy8a9eu5sSJE+b27dv//DGGhJjLly/rC4pUoEn5ubwYvXr1yoSHh/Obguv5MqYaNGjg+ucT7sYYBRBTgD9jnAKci6fyrfTevHmjS9ultcTAgQP5tQQgEp/wmezsbDNx4kSzcuVKk5ub6z3eo0cPc+HCBfPy5Uu9XVZWZmrWrKkvGvKCIv0yPGRXXOmTITtMy8+T0nP5f+m/AbhNZcaUZ2dCwC0YowBiCvBnjFOA/8ST9Mfds2eP9mvv2LGjycvL0xZhjRs35tcUgEh84re9ePFCG/yOGjXKFBcXa+Ns6RfoeYGR75s3b66bE5WfPenTp49WpD169Mj7s6pWrarl41u2bNHZFpl5AdyGmAKIJ8BfMUYBxBQQ7GOULG+XQpH79+9r8lQ2Omrfvr2DV4bf4vS28ghsHz9+tMnJyXbEiBH28ePH3uMxMTE2JSVFv//69avdunWrDQkJsTk5Od89fuTIkTYuLs57u6io6A+ePeB/iCmAeAL8FWMUQEwBbhmjysrK/uDZozJR8YnfIr0DZRm69MVo0aKF7hIo+vfvb+7evavfV6lSxQwfPlzLx8eOHWvOnTunMyhSXv7w4UOdjfGg7yDcjpgCiCfAXzFGAcQU4JYxSipAERz+kuyn0yeBwPblyxddoi7kz0nKxRMTE0316tXNhg0bvMdKSkp0h8E7d+6Y6Oho7TvYtGlTs3fvXtOkSROnLwPwG8QUQDwB/ooxCiCmAH/FGIX/hcQnKkXPnj3N6NGjdbZFEp/fvn3T2ZXCwkJz8+ZN3WlaemskJCTwGwCIKeCPYowCiCnAnzFOAcQTfIfEJ3zu8ePHJjY21hw7dsy7OZHsilatWjWebYCYAhzFGAUQU4A/Y5wCiCf4Fk0L4DOergnnz583tWrV8iY9586dayZNmmSKiop4tgFiCnAEYxRATAH+jHEKIJ5QOUIr6efChaSPp8jNzTVDhgwx2dnZJi0tzXz69Mls27bNhIeHO32KQEAhpgDiCfBXjFEAMQX4K8YolMdSd/iUbGAUFRVl8vPzdWm7VHvOmDGDZxkgpgDHMUYBxBTgzxinAOIJvkfiEz7Xp08f06ZNG7NixQoTFhbGMwwQU4DfYIwCiCnAnzFOAcQTfIvEJ3yurKxMd3AHQEwB/oYxCiCmAH/GOAUQT/AtEp8AAAAAAAAAgg67ugMAAAAAAAAIOiQ+AQAAAAAAAAQdEp8AAAAAAAAAgg6JTwAAAAAAAABBh8QnAAAAAAAAgKBD4hMAAAAAAABA0CHxCQAAAAAAACDokPgEAAAAAAAAEHRIfAIAAAAAAAAIOiQ+AQAAAAAAAJhg8zcTCQQ8ePqwrAAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -357,6 +508,8 @@ " impl_date,\n", " start_date,\n", " end_date,\n", + " figsize=(16, 7),\n", + " title=\"Custom title for cash flow plot\",\n", ")" ] }, @@ -367,7 +520,7 @@ "source": [ "## Growth rates\n", "\n", - "Costs and incomes can grow year-over-year using compound-interest factors anchored to `mkt_price_year`.\n", + "Costs and incomes can grow year-over-year using compound-interest factors anchored to the `mkt_price_year` attribute.\n", "\n", "$$\\text{value}(t) = \\text{base} \\times (1 + r)^{\\frac{t - t_0}{365}}$$\n", "\n", @@ -376,7 +529,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "b69f1ae7", "metadata": {}, "outputs": [ @@ -386,13 +539,13 @@ "(, )" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -403,12 +556,12 @@ ], "source": [ "ci_growth = CostIncome(\n", - " mkt_price_year=2020,\n", - " init_cost=50_000,\n", + " mkt_price_year=2025,\n", + " init_cost=10_000,\n", " periodic_cost=5_000,\n", " periodic_income=8_000,\n", - " cost_yearly_growth_rate=0.02, # costs grow 2% / year\n", - " income_yearly_growth_rate=0.03, # income grows 3% / year\n", + " cost_yearly_growth_rate=0.15,\n", + " income_yearly_growth_rate=0.10,\n", " freq=\"Y\",\n", ")\n", "\n", @@ -417,7 +570,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "067c07aa", "metadata": {}, "outputs": [ @@ -426,9 +579,9 @@ "output_type": "stream", "text": [ " No growth With growth\n", - "Net 36000 -19821\n", - "Cost -60000 -97569\n", - "Income 96000 77748\n" + "Net 14662 17138\n", + "Cost -50318 -58474\n", + "Income 64979 75612\n" ] } ], @@ -457,7 +610,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "c469839c-e2e2-43e9-ac33-93de7f04a6d9", "metadata": {}, "outputs": [ @@ -506,8 +659,8 @@ " \n", " 2\n", " 2022\n", - " -50000.0\n", - " -50000.0\n", + " -10000.0\n", + " -10000.0\n", " 0.0\n", " \n", " \n", @@ -574,7 +727,7 @@ " date net cost income\n", "0 2020 0.0 0.0 0.0\n", "1 2021 0.0 0.0 0.0\n", - "2 2022 -50000.0 -50000.0 0.0\n", + "2 2022 -10000.0 -10000.0 0.0\n", "3 2023 3000.0 -5000.0 8000.0\n", "4 2024 -7000.0 -15000.0 8000.0\n", "5 2025 3000.0 -5000.0 8000.0\n", @@ -585,7 +738,7 @@ "10 2030 3000.0 -5000.0 8000.0" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -600,8 +753,8 @@ ")\n", "\n", "ci_custom = CostIncome(\n", - " mkt_price_year=2020,\n", - " init_cost=50_000,\n", + " mkt_price_year=2025,\n", + " init_cost=10_000,\n", " periodic_cost=5_000,\n", " periodic_income=8_000,\n", " custom_cash_flows=custom_flows,\n", @@ -612,7 +765,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "11f21296", "metadata": {}, "outputs": [ @@ -622,13 +775,13 @@ "(, )" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -648,7 +801,9 @@ "source": [ "## Sub-annual frequencies\n", "\n", - "`freq` accepts any pandas-compatible period string. Common options:\n", + "`freq` accepts any [pandas-compatible period aliases string](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#period-aliases).\n", + "\n", + "Common options:\n", "\n", "| `freq` | Meaning |\n", "|---|---|\n", @@ -658,13 +813,17 @@ "| `\"7D\"` | Every 7 days |\n", "\n", "```{note}\n", - "The periodic amounts are interpreted as **per-period** values, not annualised.\n", + "The periodic amounts are interpreted as **per-period** values. A periodic cost of 500 with a monthly frequency (\"M\"), means a cost of 500 per month. The growth rates however are always considered to be yearly.\n", + "```\n", + "\n", + "```{note}\n", + "The implementation, starting and ending dates are coerced to the period frequency. For instance `\"2022-01-05\"` with monthly frequency is considered as `\"2022-01\"`.\n", "```" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "277e6948", "metadata": {}, "outputs": [ @@ -800,7 +959,7 @@ "11 2022-12 200.0 -500.0 700.0" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -815,16 +974,16 @@ ")\n", "\n", "df_monthly = ci_monthly.to_dataframe(\n", - " impl_date=\"2022-01-01\",\n", - " start_date=\"2022-01-01\",\n", - " end_date=\"2022-12-01\",\n", + " impl_date=\"2022-01-05\",\n", + " start_date=\"2022-01\",\n", + " end_date=\"2022-12\",\n", ")\n", "df_monthly" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "03a80747", "metadata": {}, "outputs": [ @@ -834,7 +993,7 @@ "(, )" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, @@ -851,9 +1010,9 @@ ], "source": [ "ci_monthly.plot_cash_flows(\n", - " \"2022-01-01\",\n", - " \"2022-01-01\",\n", - " \"2022-12-01\",\n", + " \"2022-01\",\n", + " \"2022-01\",\n", + " \"2022-12\",\n", ")" ] }, @@ -871,39 +1030,144 @@ "```\n", "\n", "```{note}\n", - "`custom_cash_flows` are **not** carried over to the combined object. Merge custom flows manually beforehand if needed.\n", + "`custom_cash_flows` are merged by summing them together.\n", "```" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "666fd82b", + "execution_count": 12, + "id": "39c99bd5-3a54-4d5c-bf0d-ffbb713ce1a8", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "CostIncome(\n", - " mkt_price_year = 2020\n", - " freq = 'Y'\n", - " init_cost = -50,000.00\n", - " periodic_cost = -5,000.00\n", - " periodic_income = 8,000.00\n", - " cost_yearly_growth_rate = 0.00%\n", - " income_yearly_growth_rate = 0.00%\n", - " custom_cash_flows = None\n", - ")\n" - ] + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
costincome
date
2022-01-01-20000
2023-01-0100
2024-01-01-100000
2025-01-0100
2026-01-01020000
2027-01-0100
2028-01-01-200000
2029-01-01-100000
\n", + "
" + ], + "text/plain": [ + " cost income\n", + "date \n", + "2022-01-01 -2000 0\n", + "2023-01-01 0 0\n", + "2024-01-01 -10000 0\n", + "2025-01-01 0 0\n", + "2026-01-01 0 20000\n", + "2027-01-01 0 0\n", + "2028-01-01 -20000 0\n", + "2029-01-01 -10000 0" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ + "import pandas as pd\n", + "\n", + "custom_flows_a = pd.DataFrame(\n", + " {\n", + " \"date\": [\"2024\", \"2026\", \"2028\"],\n", + " \"cost\": [10_000, 0, 20_000], # extra one-off costs\n", + " \"income\": [0, 15_000, 0], # extra one-off income\n", + " }\n", + ")\n", + "\n", + "custom_flows_b = pd.DataFrame(\n", + " {\n", + " \"date\": [\"2022\", \"2026\", \"2029\"],\n", + " \"cost\": [2_000, 0, 10_000], # extra one-off costs\n", + " \"income\": [0, 5_000, 0], # extra one-off income\n", + " }\n", + ")\n", + "\n", "ci_a = CostIncome(\n", " mkt_price_year=2020,\n", " init_cost=30_000,\n", " periodic_cost=2_000,\n", " periodic_income=4_000,\n", + " custom_cash_flows=custom_flows_a,\n", " freq=\"Y\",\n", ")\n", "\n", @@ -912,12 +1176,18 @@ " init_cost=20_000,\n", " periodic_cost=3_000,\n", " periodic_income=4_000,\n", + " custom_cash_flows=custom_flows_b,\n", " freq=\"Y\",\n", ")\n", "\n", "ci_combined = CostIncome.comb_cost_income([ci_a, ci_b])\n", + "ci_combined.plot_cash_flows(\n", + " \"2025\",\n", + " \"2020\",\n", + " \"2030\",\n", + ")\n", "\n", - "print(ci_combined)" + "ci_combined.custom_cash_flows" ] }, { @@ -932,7 +1202,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "eeac2088", "metadata": {}, "outputs": [ @@ -975,7 +1245,7 @@ "source": [ "### From a YAML file\n", "\n", - "Create a YAML file structured as follows, then load it with `CostIncome.from_yaml`.\n", + "Create a YAML file structured as follows, then load it with `CostIncome.from_yaml()`.\n", "\n", "```yaml\n", "# measure_cost.yaml\n", @@ -992,6 +1262,13 @@ " # - date: \"2024-01-01\"\n", " # cost: 10000\n", " # income: 0\n", + "```\n", + "\n", + "---\n", + "\n", + "```python\n", + "# Inside Notebook or script\n", + "ci_from_yaml = CostIncome.from_yaml(\"measure_cost.yaml\")\n", "```" ] } From 7b9be554fcedd8afb8adc9e303e402482a7ebe32 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 11:35:13 +0200 Subject: [PATCH 17/23] Removes advanced test debugging mechanisms --- climada/entity/measures/test/test_cost_income.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index edc35528a8..04be3bbd10 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -236,7 +236,6 @@ def test_custom_cash_flows_added(self): } ) ci = CostIncome(mkt_price_year=2021, custom_cash_flows=df, freq="Y") - print(ci.custom_cash_flows) impl = pd.Timestamp("2021-01-01") curr = pd.Timestamp("2021-01-01") net, cost, inc = ci.calc_at_date(impl, curr) @@ -422,6 +421,4 @@ def test_merges_custom_cash_flows(self): ) combined = CostIncome.comb_cost_income([ci1, ci2]) - print(combined.custom_cash_flows) - print(expected) pd.testing.assert_frame_equal(combined.custom_cash_flows, expected) From 2ee944b34498caaef67ac5cff8c584579f79cf72 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Tue, 21 Apr 2026 11:49:42 +0200 Subject: [PATCH 18/23] Fixes remaining pylint remarks --- climada/entity/measures/cost_income.py | 39 +++++++++++++++++--------- 1 file changed, 25 insertions(+), 14 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 9b61b25437..01d5afe5d5 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -25,6 +25,7 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd +import yaml from climada.entity.measures.measure_config import CostIncomeConfig @@ -112,13 +113,21 @@ def __repr__(self) -> str: f" periodic_income = {self.periodic_income:,.2f}", f" cost_yearly_growth_rate = {self.cost_growth_rate:.2%}", f" income_yearly_growth_rate = {self.income_growth_rate:.2%}", - f" custom_cash_flows = {None if self.custom_cash_flows is None else f'DataFrame({len(self.custom_cash_flows)} rows)'}", + " custom_cash_flows = " + f"{None if self.custom_cash_flows is None else f'DataFrame({len(self.custom_cash_flows)} rows)'}", ")", ] return "\n".join(lines) @property def custom_cash_flows(self) -> pd.DataFrame | None: + """:obj:`pd.DataFrame` : Get or set the optional user-defined cash + flows. + + Input cash flow have to contain a "date" column as well as at least one + of "cost" and "income". The custom cash flow is coerced to the internal + period frequency. + """ return self._custom_cash_flows @custom_cash_flows.setter @@ -250,8 +259,6 @@ def from_yaml(cls, path: str) -> "CostIncome": CostIncome """ - import yaml - with open(path) as f: return cls.from_dict(yaml.safe_load(f)["cost_income"]) @@ -282,8 +289,8 @@ def _freq_to_days(cls, freq: str) -> str: # Return the difference in days return f"{(end_date - base_date).days}d" - except ValueError: - raise ValueError(f"Invalid frequency string: {freq}") + except ValueError as exc: + raise ValueError(f"Invalid frequency string: {freq}") from exc def _get_width_days(self) -> float: """Return the number of days in the current frequency.""" @@ -556,32 +563,36 @@ def comb_cost_income(cost_incomes: list["CostIncome"]) -> "CostIncome": first_ci = cost_incomes[0] if not all( - [ + ( first_ci.mkt_price_year.year == c.mkt_price_year.year for c in cost_incomes - ] + ) ): raise ValueError( - "Measure cost incomes have different market price years, combination is not possible." + "Measure cost incomes have different market price years," + " combination is not possible." ) if not all( - [first_ci.cost_growth_rate == c.cost_growth_rate for c in cost_incomes] + first_ci.cost_growth_rate == c.cost_growth_rate for c in cost_incomes ): raise ValueError( - "Measure cost incomes have different cost_growth_rate, combination is not possible." + "Measure cost incomes have different cost_growth_rate," + " combination is not possible." ) if not all( - [first_ci.income_growth_rate == c.income_growth_rate for c in cost_incomes] + first_ci.income_growth_rate == c.income_growth_rate for c in cost_incomes ): raise ValueError( - "Measure cost incomes have different income_growth_rate, combination is not possible." + "Measure cost incomes have different income_growth_rate," + " combination is not possible." ) - if not all([first_ci.freq == c.freq for c in cost_incomes]): + if not all(first_ci.freq == c.freq for c in cost_incomes): raise ValueError( - "Measure cost incomes have different period frequencies, combination is not possible." + "Measure cost incomes have different period frequencies," + " combination is not possible." ) try: From dc29f9b393ba519b3651cf727199a1a17ab8ca9e Mon Sep 17 00:00:00 2001 From: spjuhel Date: Thu, 28 May 2026 16:55:16 +0200 Subject: [PATCH 19/23] Implement somes comments from Vale --- climada/entity/measures/cost_income.py | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 01d5afe5d5..e4ae304026 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -39,7 +39,7 @@ class CostIncome: Attributes ---------- - mkt_price_year : datetime, default to today's year. + mkt_price_year : int, default to today's year. The reference year for market prices. init_cost : float Initial implementation cost (stored as negative). @@ -54,7 +54,8 @@ class CostIncome: custom_cash_flows : pd.DataFrame, optional User-defined cash flows indexed by date. freq : str - Frequency of the cash flows (e.g., 'Y', '3M', '7D'). + Periodicity (frequency) of the cash flows (e.g., 'Y', '3M', '7D'). + All pandas aliases are possible. See [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#period-aliases). """ @@ -74,7 +75,7 @@ def __init__( Parameters ---------- - mkt_price_year : datetime, default to today's year. + mkt_price_year : int, default to today's year. The reference year for market prices. init_cost : float Initial implementation cost (stored as negative). @@ -247,7 +248,8 @@ def from_dict(cls, args_dict: dict) -> "CostIncome": @classmethod def from_yaml(cls, path: str) -> "CostIncome": - """Create a `CostIncome` from a yaml file. + """Create a `CostIncome` from a yaml file of a `MeasureConfig` + object. Parameters ---------- @@ -317,9 +319,11 @@ def calc_at_date( ---------- impl_date : pd.Timestamp The implementation date that determines which cost/income regime - applies. Dates before this use have no cost or income; "at the date" uses + applies. Dates before this have no cost or income; "at the date" uses the implementation cost, and dates after use the initialized or periodic amounts respectively. + Note that if a custom cash flow is defined for `curr_date`, + before `impl_date`, it will be accounted for. curr_date : pd.Timestamp The evaluation date for which cash flows are being calculated. This is compared against `impl_date` to determine the applicable base @@ -389,7 +393,7 @@ def calc_at_date( return (total_inc + total_cost), total_cost, total_inc def calc_cash_flows( - self, impl_date, start_date, end_date + self, impl_date: pd.Timestamp, start_date: pd.Timestamp, end_date: pd.Timestamp ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """Calculate net cash flows, costs, and incomes over a period. @@ -402,12 +406,12 @@ def calc_cash_flows( Parameters ---------- - impl_date : + impl_date : pd.Timestamp The implementation date that determines which cost/income regime applies. - start_date : + start_date : pd.Timestamp The beginning of the calculation period. - end_date : + end_date : pd.Timestamp The end of the calculation period. Returns @@ -486,7 +490,7 @@ def plot_cash_flows( Returns ------- - plt.Figure + tuple(plt.Axis, plt.Axis) """ net, costs, incomes = self.calc_cash_flows(impl_date, start_date, end_date) periods = pd.period_range(start=start_date, end=end_date, freq=self.freq) From 31656528c8e673d271fb6807fd3edf1686e9f0f9 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 29 May 2026 09:57:37 +0200 Subject: [PATCH 20/23] Removes double checks --- climada/entity/measures/cost_income.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index e4ae304026..358fbe5b37 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -167,12 +167,9 @@ def _prepare_custom_flows(self, df: pd.DataFrame) -> pd.DataFrame: ) df = df.copy() - if "cost" in df.columns: - df["cost"] = -df["cost"].abs() - - if "date" in df.columns: - df["date"] = pd.to_datetime(df["date"]) - df = df.set_index("date") + df["cost"] = -df["cost"].abs() + df["date"] = pd.to_datetime(df["date"]) + df = df.set_index("date") freq = self._make_offset_compat(self.freq) return df.resample(freq).sum() From d09d18f7d64c1e487b9c4969ed736091e0a2da22 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 29 May 2026 10:01:30 +0200 Subject: [PATCH 21/23] Removes method not in use --- climada/entity/measures/cost_income.py | 30 -------------------------- 1 file changed, 30 deletions(-) diff --git a/climada/entity/measures/cost_income.py b/climada/entity/measures/cost_income.py index 358fbe5b37..cb99463b38 100644 --- a/climada/entity/measures/cost_income.py +++ b/climada/entity/measures/cost_income.py @@ -261,36 +261,6 @@ def from_yaml(cls, path: str) -> "CostIncome": with open(path) as f: return cls.from_dict(yaml.safe_load(f)["cost_income"]) - @classmethod - def _freq_to_days(cls, freq: str) -> str: - """ - Convert a frequency string to the equivalent number of days. - - Parameters: - ----------- - freq : str - A frequency string (e.g., 'D' for daily, 'M' for monthly, 'Y' for yearly). - - Returns: - -------- - float - The equivalent number of days for the given frequency string. - """ - - try: - # Convert the frequency string to a DateOffset object - freq = cls._make_offset_compat(freq, start=False) - offset = pd.tseries.frequencies.to_offset(freq) - - # Calculate the number of days by applying the offset to a base date - base_date = pd.Timestamp("2000-01-01") - end_date = base_date + offset - - # Return the difference in days - return f"{(end_date - base_date).days}d" - except ValueError as exc: - raise ValueError(f"Invalid frequency string: {freq}") from exc - def _get_width_days(self) -> float: """Return the number of days in the current frequency.""" From dd9c738de40151e84c34b3bc442001d1df513c9a Mon Sep 17 00:00:00 2001 From: spjuhel Date: Fri, 29 May 2026 11:59:34 +0200 Subject: [PATCH 22/23] Adds test for custom cost incomes and cash flow computation --- .../entity/measures/test/test_cost_income.py | 54 ++++++++++++++++--- 1 file changed, 47 insertions(+), 7 deletions(-) diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index 04be3bbd10..4766d19d2f 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -104,7 +104,7 @@ def test_defaults_for_missing_keys(self): assert ci.init_cost == 0.0 assert ci.freq == "Y" - def test_with_custom_cash_flows(self): + def test_with_custom_cash_flows_only(self): d = { "freq": "Y", "custom_cash_flows": [ @@ -284,6 +284,38 @@ def test_nonzero_cost_income(self): income, [0.0, 0.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0] ) + def test_with_custom_cash_flows(self): + d = { + "freq": "Y", + "init_cost": 500, + "periodic_cost": 100, + "periodic_income": 200, + "custom_cash_flows": [ + {"date": "2021-01-01", "cost": 170, "income": 50}, + {"date": "2022-01-01", "cost": 180, "income": 50}, + {"date": "2025-01-01", "cost": 190, "income": 50}, + ], + } + ci = CostIncome.from_dict(d) + expected_net = np.array([0.0, -120.0, -630.0, 100, 100, -40]) + expected_costs = np.array([0.0, -170.0, -680.0, -100, -100, -290]) + expected_incomes = np.array( + [ + 0.0, + 50.0, + 50.0, + 200, + 200, + 250, + ] + ) + net, costs, incomes = ci.calc_cash_flows( + impl_date="2022", start_date="2020", end_date="2025" + ) + np.testing.assert_array_equal(net, expected_net) + np.testing.assert_array_equal(costs, expected_costs) + np.testing.assert_array_equal(incomes, expected_incomes) + # --------------------------------------------------------------------------- # calc_total @@ -388,9 +420,9 @@ def test_preserves_growth_rates(self): def test_merges_custom_cash_flows(self): df1 = pd.DataFrame( { - "date": ["2020-01-01", "2020-03-01"], - "cost": [100, 200], - "income": [50, 60], + "date": ["2019-11-01", "2020-01-01", "2020-03-01", "2020-05-01"], + "cost": [100, 200, 100, 50], + "income": [50, 60, 0, 0], } ) df2 = pd.DataFrame( @@ -403,9 +435,17 @@ def test_merges_custom_cash_flows(self): expected = pd.DataFrame( { - "date": ["2020-01", "2020-02", "2020-03", "2020-04"], - "cost": [-200, 0, -400, -300], - "income": [100, 0, 120, 70], + "date": [ + "2019-11", + "2019-12", + "2020-01", + "2020-02", + "2020-03", + "2020-04", + "2020-05", + ], + "cost": [-100, 0, -300, 0, -300, -300, -50], + "income": [50, 0, 110, 0, 60, 70, 0], } ) From a56dcc6da8e9004264e5a1389a8021dcc02730c5 Mon Sep 17 00:00:00 2001 From: spjuhel Date: Wed, 10 Jun 2026 09:50:52 +0200 Subject: [PATCH 23/23] removes tests for removed method --- .../entity/measures/test/test_cost_income.py | 23 ------------------- 1 file changed, 23 deletions(-) diff --git a/climada/entity/measures/test/test_cost_income.py b/climada/entity/measures/test/test_cost_income.py index 4766d19d2f..7a63d3b963 100644 --- a/climada/entity/measures/test/test_cost_income.py +++ b/climada/entity/measures/test/test_cost_income.py @@ -134,29 +134,6 @@ def test_from_yaml(self, tmp_path): assert ci.periodic_income == 300.0 -# --------------------------------------------------------------------------- -# _freq_to_days -# --------------------------------------------------------------------------- - - -class TestFreqToDays: - def test_yearly(self): - result = CostIncome._freq_to_days("Y") - assert result == "365d" - - def test_monthly(self): - result = CostIncome._freq_to_days("M") - assert result == "30d" - - def test_daily(self): - result = CostIncome._freq_to_days("D") - assert result == "1d" - - def test_invalid(self): - with pytest.raises(ValueError): - CostIncome._freq_to_days("INVALID_FREQ_XYZ") - - # --------------------------------------------------------------------------- # _get_width_days # ---------------------------------------------------------------------------