diff --git a/ITR/configs.py b/ITR/configs.py index 8f6407a9..f5c7db75 100644 --- a/ITR/configs.py +++ b/ITR/configs.py @@ -25,6 +25,7 @@ class ColumnsConfig: OWNED_EMISSIONS = "owned_emissions" COUNTRY = 'country' SECTOR = 'sector' + PRODUCTION = 'production' GHG_SCOPE12 = 'ghg_s1s2' GHG_SCOPE3 = 'ghg_s3' COMPANY_REVENUE = 'company_revenue' @@ -44,6 +45,7 @@ class ColumnsConfig: BENCHMARK_TEMP = 'benchmark_temperature' BENCHMARK_GLOBAL_BUDGET = 'benchmark_global_budget' BASE_EI = 'emission_intensity_at_base_year' + PROJECTED_PRODUCTION = 'projected_production_units' PROJECTED_EI = 'projected_intensities' PROJECTED_TARGETS = 'projected_targets' TRAJECTORY_SCORE = 'trajectory_score' diff --git a/ITR/data/base_providers.py b/ITR/data/base_providers.py index d503e591..0d03502a 100644 --- a/ITR/data/base_providers.py +++ b/ITR/data/base_providers.py @@ -2,7 +2,7 @@ from typing import List, Type from ITR.configs import ColumnsConfig, TemperatureScoreConfig from ITR.data.data_providers import CompanyDataProvider, ProductionBenchmarkDataProvider, IntensityBenchmarkDataProvider -from ITR.interfaces import ICompanyData, EScope, IProductionBenchmarkScopes, IEmissionIntensityBenchmarkScopes, \ +from ITR.interfaces import ICompanyData, PScope, IProductionBenchmarkScopes, IEmissionIntensityBenchmarkScopes, \ IBenchmark @@ -28,7 +28,7 @@ def __init__(self, self.temp_config = tempscore_config def _convert_projections_to_series(self, company: ICompanyData, feature: str, - scope: EScope = EScope.S1S2) -> pd.Series: + scope: PScope = PScope.S1S2) -> pd.Series: """ extracts the company projected intensities or targets for a given scope :param feature: PROJECTED_EI or PROJECTED_TARGETS @@ -78,15 +78,17 @@ def get_company_intensity_and_production_at_base_year(self, company_ids: List[st overrides subclass method :param: company_ids: list of company ids :return: DataFrame the following columns : - ColumnsConfig.COMPANY_ID, ColumnsConfig.GHG_S1S2, ColumnsConfig.BASE_EI, ColumnsConfig.SECTOR and - ColumnsConfig.REGION + ColumnsConfig.COMPANY_ID, ColumnsConfig.PRODUCTION, ColumnsConfig.GHG_S1S2, ColumnsConfig.BASE_EI, + ColumnsConfig.SECTOR and ColumnsConfig.REGION """ df_fundamentals = self.get_company_fundamentals(company_ids) base_year = self.temp_config.CONTROLS_CONFIG.base_year company_info = df_fundamentals.loc[ company_ids, [self.column_config.SECTOR, self.column_config.REGION, + self.column_config.PRODUCTION, self.column_config.GHG_SCOPE12]] ei_at_base = self._get_company_intensity_at_year(base_year, company_ids).rename(self.column_config.BASE_EI) + # print(f"BA: company_info.loc[] = {company_info.loc['US0185223007']}") return company_info.merge(ei_at_base, left_index=True, right_index=True) def get_company_fundamentals(self, company_ids: List[str]) -> pd.DataFrame: @@ -96,7 +98,7 @@ def get_company_fundamentals(self, company_ids: List[str]) -> pd.DataFrame: """ return pd.DataFrame.from_records( [ICompanyData.parse_obj(c).dict() for c in self.get_company_data(company_ids)], - exclude=['projected_targets', 'projected_intensities']).set_index(self.column_config.COMPANY_ID) + exclude=['projected_production_units', 'projected_targets', 'projected_intensities']).set_index(self.column_config.COMPANY_ID) def get_company_projected_intensities(self, company_ids: List[str]) -> pd.DataFrame: """ @@ -116,6 +118,15 @@ def get_company_projected_targets(self, company_ids: List[str]) -> pd.DataFrame: [self._convert_projections_to_series(c, self.column_config.PROJECTED_TARGETS) for c in self.get_company_data(company_ids)]) + def get_company_projected_production(self, company_ids: List[str]) -> pd.DataFrame: + """ + :param company_ids: A list of company IDs + :return: A pandas DataFrame with projected production per company + """ + return pd.DataFrame( + [self._convert_projections_to_series(c, self.column_config.PROJECTED_PRODUCTION) for c in + self.get_company_data(company_ids)]) + class BaseProviderProductionBenchmark(ProductionBenchmarkDataProvider): @@ -142,7 +153,7 @@ def _convert_benchmark_to_series(self, benchmark: IBenchmark) -> pd.Series: """ return pd.Series({r.year: r.value for r in benchmark.projections}, name=(benchmark.region, benchmark.sector)) - def _get_projected_production(self, scope: EScope = EScope.S1S2) -> pd.DataFrame: + def _get_projected_production(self, scope: PScope = PScope.PRODUCTION) -> pd.DataFrame: """ Converts IBenchmarkScopes into dataframe for a scope :param scope: a scope @@ -156,19 +167,19 @@ def _get_projected_production(self, scope: EScope = EScope.S1S2) -> pd.DataFrame return df_bm - def get_company_projected_production(self, ghg_scope12: pd.DataFrame) -> pd.DataFrame: + def get_company_projected_production(self, production: pd.DataFrame) -> pd.DataFrame: """ - get the projected productions for list of companies in ghg_scope12 - :param ghg_scope12: DataFrame with at least the following columns : - ColumnsConfig.COMPANY_ID,ColumnsConfig.GHG_SCOPE12, ColumnsConfig.SECTOR and ColumnsConfig.REGION + get the projected productions for list of companies (PRODUCTIONS not S1S2) + :param production: DataFrame with at least the following columns : + ColumnsConfig.COMPANY_ID,ColumnsConfig.PRODUCTION, ColumnsConfig.SECTOR and ColumnsConfig.REGION :return: DataFrame of projected productions for [base_year - base_year + 50] """ - benchmark_production_projections = self.get_benchmark_projections(ghg_scope12) + benchmark_production_projections = self.get_benchmark_projections(production) return benchmark_production_projections.add(1).cumprod(axis=1).mul( - ghg_scope12[self.column_config.GHG_SCOPE12].values, axis=0) + production[self.column_config.PRODUCTION].values, axis=0) def get_benchmark_projections(self, company_sector_region_info: pd.DataFrame, - scope: EScope = EScope.S1S2) -> pd.DataFrame: + scope: PScope = PScope.S1S2) -> pd.DataFrame: """ Overrides subclass method returns a Dataframe with production benchmarks per company_id given a region and sector. @@ -246,7 +257,7 @@ def _convert_benchmark_to_series(self, benchmark: IBenchmark) -> pd.Series: """ return pd.Series({r.year: r.value for r in benchmark.projections}, name=(benchmark.region, benchmark.sector)) - def _get_projected_intensities(self, scope: EScope = EScope.S1S2) -> pd.Series: + def _get_projected_intensities(self, scope: PScope = PScope.S1S2) -> pd.Series: """ Converts IBenchmarkScopes into dataframe for a scope :param scope: a scope @@ -261,7 +272,7 @@ def _get_projected_intensities(self, scope: EScope = EScope.S1S2) -> pd.Series: return df_bm def _get_intensity_benchmarks(self, company_sector_region_info: pd.DataFrame, - scope: EScope = EScope.S1S2) -> pd.DataFrame: + scope: PScope = PScope.S1S2) -> pd.DataFrame: """ Overrides subclass method returns a Dataframe with production benchmarks per company_id given a region and sector. diff --git a/ITR/data/data_providers.py b/ITR/data/data_providers.py index 77d6697e..1f370c96 100644 --- a/ITR/data/data_providers.py +++ b/ITR/data/data_providers.py @@ -48,8 +48,8 @@ def get_company_intensity_and_production_at_base_year(self, company_ids: List[st Get the emission intensity and the production for a list of companies at the base year. :param: company_ids: list of company ids :return: DataFrame the following columns : - ColumnsConfig.COMPANY_ID, ColumnsConfig.GHG_S1S2, ColumnsConfig.BASE_EI, ColumnsConfig.SECTOR and - ColumnsConfig.REGION + ColumnsConfig.COMPANY_ID, ColumnsConfig.PRODUCTION, ColumnsConfig.GHG_S1S2, ColumnsConfig.BASE_EI, + ColumnsConfig.SECTOR and ColumnsConfig.REGION """ raise NotImplementedError diff --git a/ITR/data/data_warehouse.py b/ITR/data/data_warehouse.py index 1210acfa..4fd29789 100644 --- a/ITR/data/data_warehouse.py +++ b/ITR/data/data_warehouse.py @@ -1,4 +1,4 @@ -from abc import ABC +from abc import ABC # _project from typing import List import pandas as pd from pydantic import ValidationError @@ -43,27 +43,40 @@ def get_preprocessed_company_data(self, company_ids: List[str]) -> List[ICompany """ company_data = self.company_data.get_company_data(company_ids) df_company_data = pd.DataFrame.from_records([c.dict() for c in company_data]) - + assert pd.Series(company_ids).isin(df_company_data.loc[:, self.column_config.COMPANY_ID]).all(), \ "some of the company ids are not included in the fundamental data" company_info_at_base_year = self.company_data.get_company_intensity_and_production_at_base_year(company_ids) + # print(f"DW: company_info_at_base_year.loc[] = {company_info_at_base_year.loc['US0185223007']}") projected_production = self.benchmark_projected_production.get_company_projected_production( - company_info_at_base_year) + company_info_at_base_year).sort_index() - df_company_data.loc[:, self.column_config.CUMULATIVE_TRAJECTORY] = self._get_cumulative_emission( + df_new = self._get_cumulative_emission( projected_emission_intensity=self.company_data.get_company_projected_intensities(company_ids), - projected_production=projected_production).to_numpy() + projected_production=projected_production) + df_new.rename(columns={"cumulative_value":self.column_config.CUMULATIVE_TRAJECTORY}, inplace=True) + df_company_data = df_company_data.merge(df_new, on='company_id', how='right') - df_company_data.loc[:, self.column_config.CUMULATIVE_TARGET] = self._get_cumulative_emission( + df_new = self._get_cumulative_emission( projected_emission_intensity=self.company_data.get_company_projected_targets(company_ids), - projected_production=projected_production).to_numpy() + projected_production=projected_production) + df_new.rename(columns={"cumulative_value":self.column_config.CUMULATIVE_TARGET}, inplace=True) + df_company_data = df_company_data.merge(df_new, on='company_id', how='right') - df_company_data.loc[:, self.column_config.CUMULATIVE_BUDGET] = self._get_cumulative_emission( + df_new = self._get_cumulative_emission( projected_emission_intensity=self.benchmarks_projected_emission_intensity.get_SDA_intensity_benchmarks( company_info_at_base_year), - projected_production=projected_production).to_numpy() - + projected_production=projected_production) + df_new.rename(columns={"cumulative_value":self.column_config.CUMULATIVE_BUDGET}, inplace=True) + df_company_data = df_company_data.merge(df_new, on='company_id', how='right') + + # 'US00130H1059', 'US0185223007', 'US0188021085' + # print(f"df_company_data.columns = {df_company_data.columns}") + # print(f"BUDG:\n{df_company_data.loc[df_company_data.index<40,['company_id',self.column_config.CUMULATIVE_BUDGET]]}\n\n") + # print(f"CIABY:\n{company_info_at_base_year.loc[df_company_data.index<40,:]}\n\n") + # print(f"""SDA:\n{self.benchmarks_projected_emission_intensity.get_SDA_intensity_benchmarks( + # company_info_at_base_year).loc[df_company_data.index<40,:]}\n\n""") df_company_data.loc[:, self.column_config.BENCHMARK_GLOBAL_BUDGET] = self.benchmarks_projected_emission_intensity.benchmark_global_budget df_company_data.loc[:, @@ -94,7 +107,7 @@ def _convert_df_to_model(self, df_company_data: pd.DataFrame) -> List[ICompanyAg model_companies.append(ICompanyAggregates.parse_obj(company_data)) except ValidationError as e: logger.warning( - "(one of) the input(s) of company %s is invalid and will be skipped" % company_data[ + "DW: (one of) the input(s) of company %s is invalid and will be skipped" % company_data[ self.column_config.COMPANY_NAME]) pass return model_companies @@ -107,6 +120,13 @@ def _get_cumulative_emission(self, projected_emission_intensity: pd.DataFrame, p :param projected_production: series of projected production series :return: weighted sum of production and emission """ - - return projected_emission_intensity.reset_index(drop=True).multiply(projected_production.reset_index( - drop=True)).sum(axis=1) + # print(f"DW: projected_emission_intensity['US0185223007'] = {projected_emission_intensity.loc['US0185223007']}") + # print(f"DW: projected_production['US0185223007'] = {projected_production.loc['US0185223007']}") + # print(projected_emission_intensity.index[0:3]) + # print(projected_emission_intensity.iloc[0:3]) + # print(projected_production.index[0:3]) + # print(projected_production.iloc[0:3]) + df = projected_emission_intensity.multiply(projected_production).sum(axis=1) + df = pd.DataFrame(data=df, index=df.index).reset_index() + df.rename(columns={'index':'company_id', 0:'cumulative_value'},inplace=True) + return df diff --git a/ITR/data/excel.py b/ITR/data/excel.py index 0e510bd0..91b6c9ce 100644 --- a/ITR/data/excel.py +++ b/ITR/data/excel.py @@ -5,7 +5,7 @@ from ITR.data.base_providers import BaseCompanyDataProvider, BaseProviderProductionBenchmark, \ BaseProviderIntensityBenchmark from ITR.configs import ColumnsConfig, TemperatureScoreConfig, SectorsConfig -from ITR.interfaces import ICompanyData, ICompanyProjection, EScope, IEmissionIntensityBenchmarkScopes, \ +from ITR.interfaces import ICompanyData, ICompanyProjection, PScope, IEmissionIntensityBenchmarkScopes, \ IProductionBenchmarkScopes, IBenchmark, IBenchmarks, IBenchmarkProjection import logging @@ -30,7 +30,7 @@ def convert_benchmark_excel_to_model(df_excel: pd.DataFrame, sheetname: str, col result.append(bm) return IBenchmarks(benchmarks=result) - +# ??? This duplicates info from class TabsConfig: FUNDAMENTAL = "fundamental_data" PROJECTED_EI = "projected_ei_in_Wh" @@ -53,7 +53,7 @@ def __init__(self, excel_path: str, column_config: Type[ColumnsConfig] = Columns production_bms = self._convert_excel_to_model(self.benchmark_excel, TabsConfig.PROJECTED_PRODUCTION, column_config.REGION, column_config.SECTOR) super().__init__( - IProductionBenchmarkScopes(S1S2=production_bms), column_config, + IProductionBenchmarkScopes(PRODUCTION=production_bms), column_config, tempscore_config) def _check_sector_data(self) -> None: @@ -65,7 +65,7 @@ def _check_sector_data(self) -> None: assert pd.Series([TabsConfig.PROJECTED_PRODUCTION, TabsConfig.PROJECTED_EI]).isin( self.benchmark_excel.keys()).all(), "some tabs are missing in the sector data excel" - def _get_projected_production(self, scope: EScope = EScope.S1S2) -> pd.DataFrame: + def _get_projected_production(self, scope: PScope = PScope.PRODUCTION) -> pd.DataFrame: """ interface from excel file and internally used DataFrame :param scope: @@ -137,9 +137,10 @@ def _convert_excel_data_to_ICompanyData(self, excel_path: str) -> List[ICompanyD df_fundamentals = df_company_data[TabsConfig.FUNDAMENTAL] company_ids = df_fundamentals[self.column_config.COMPANY_ID].unique() + df_production = self._get_projection(company_ids, df_company_data[TabsConfig.PROJECTED_PRODUCTION]) df_targets = self._get_projection(company_ids, df_company_data[TabsConfig.PROJECTED_TARGET]) df_ei = self._get_projection(company_ids, df_company_data[TabsConfig.PROJECTED_EI]) - return self._company_df_to_model(df_fundamentals, df_targets, df_ei) + return self._company_df_to_model(df_fundamentals, df_production, df_targets, df_ei) def _convert_series_to_projections(self, projections: pd.Series, convert_unit: bool = False) -> List[ ICompanyProjection]: @@ -152,12 +153,14 @@ def _convert_series_to_projections(self, projections: pd.Series, convert_unit: b projections = projections * self.ENERGY_UNIT_CONVERSION_FACTOR if convert_unit else projections return [ICompanyProjection(year=y, value=v) for y, v in projections.items()] - def _company_df_to_model(self, df_fundamentals: pd.DataFrame, df_targets: pd.DataFrame, df_ei: pd.DataFrame) -> \ + def _company_df_to_model(self, df_fundamentals: pd.DataFrame, + df_production: pd.DataFrame, df_targets: pd.DataFrame, df_ei: pd.DataFrame) -> \ List[ICompanyData]: """ transforms target Dataframe into list of IDataProviderTarget instances :param df_fundamentals: pandas Dataframe with fundamental data + :param df_production: pandas Dataframe with production :param df_targets: pandas Dataframe with targets :param df_ei: pandas Dataframe with emission intensities :return: A list containing the ICompanyData objects @@ -171,12 +174,13 @@ def _company_df_to_model(self, df_fundamentals: pd.DataFrame, df_targets: pd.Dat for company_data in companies_data_dict: try: convert_unit_of_measure = company_data[self.column_config.SECTOR] in self.CORRECTION_SECTORS - company_targets = self._convert_series_to_projections( - df_targets.loc[company_data[self.column_config.COMPANY_ID], :], convert_unit_of_measure) + company_production = self._convert_series_to_projections( + df_production.loc[company_data[self.column_config.COMPANY_ID], :], convert_unit_of_measure) company_ei = self._convert_series_to_projections( - df_ei.loc[company_data[self.column_config.COMPANY_ID], :], - convert_unit_of_measure) - + df_ei.loc[company_data[self.column_config.COMPANY_ID], :], convert_unit_of_measure) + company_targets = self._convert_series_to_projections( + df_targets.loc[company_data[self.column_config.COMPANY_ID], :], False) + company_data.update({self.column_config.PROJECTED_PRODUCTION: {'PRODUCTION': {'projections': company_production}}}) company_data.update({self.column_config.PROJECTED_TARGETS: {'S1S2': {'projections': company_targets}}}) company_data.update({self.column_config.PROJECTED_EI: {'S1S2': {'projections': company_ei}}}) @@ -184,7 +188,7 @@ def _company_df_to_model(self, df_fundamentals: pd.DataFrame, df_targets: pd.Dat except ValidationError as e: logger.warning( - "(one of) the input(s) of company %s is invalid and will be skipped" % company_data[ + "EX: (one of) the input(s) of company %s is invalid and will be skipped" % company_data[ self.column_config.COMPANY_NAME]) pass return model_companies diff --git a/ITR/interfaces.py b/ITR/interfaces.py index 875e0205..a4963e5c 100644 --- a/ITR/interfaces.py +++ b/ITR/interfaces.py @@ -79,6 +79,7 @@ def __getitem__(self, item): return getattr(self, item) class IProductionBenchmarkScopes(BaseModel): + PRODUCTION: Optional[IBenchmarks] S1S2: Optional[IBenchmarks] S3: Optional[IBenchmarks] S1S2S3: Optional[IBenchmarks] @@ -112,6 +113,7 @@ def __getitem__(self, item): class ICompanyProjectionsScopes(BaseModel): + PRODUCTION: Optional[ICompanyProjections] S1S2: Optional[ICompanyProjections] S3: Optional[ICompanyProjections] S1S2S3: Optional[ICompanyProjections] @@ -128,10 +130,12 @@ class ICompanyData(BaseModel): sector: str # TODO: make SortableEnums target_probability: float + projected_production_units: ICompanyProjectionsScopes projected_targets: ICompanyProjectionsScopes projected_intensities: ICompanyProjectionsScopes country: Optional[str] + production: Optional[float] ghg_s1s2: Optional[float] ghg_s3: Optional[float] @@ -201,19 +205,21 @@ def tcre_multiplier(self) -> float: return self.tcre / self.carbon_conversion -class EScope(SortableEnum): +class PScope(SortableEnum): S1 = "S1" S2 = "S2" S3 = "S3" S1S2 = "S1+S2" S1S2S3 = "S1+S2+S3" + PRODUCTION = "Production" @classmethod - def get_result_scopes(cls) -> List['EScope']: + def get_result_scopes(cls) -> List['PScope']: """ - Get a list of scopes that should be calculated if the user leaves it open. + Get a list of emission scopes that should be calculated if the user leaves it open. + If user doesn't ask for production scopes, don't tell them! - :return: A list of EScope objects + :return: A list of PScope objects """ return [cls.S1S2, cls.S3, cls.S1S2S3] diff --git a/ITR/portfolio_aggregation.py b/ITR/portfolio_aggregation.py index f376e787..63da82b4 100644 --- a/ITR/portfolio_aggregation.py +++ b/ITR/portfolio_aggregation.py @@ -4,7 +4,7 @@ import pandas as pd from .configs import PortfolioAggregationConfig, ColumnsConfig -from .interfaces import EScope +from .interfaces import PScope class PortfolioAggregationMethod(Enum): @@ -92,8 +92,8 @@ def _calculate_aggregate_score(self, data: pd.DataFrame, input_column: str, # Total emissions weighted temperature score (TETS) elif portfolio_aggregation_method == PortfolioAggregationMethod.TETS: - use_S1S2 = (data[self.c.COLS.SCOPE] == EScope.S1S2) | (data[self.c.COLS.SCOPE] == EScope.S1S2S3) - use_S3 = (data[self.c.COLS.SCOPE] == EScope.S3) | (data[self.c.COLS.SCOPE] == EScope.S1S2S3) + use_S1S2 = data[self.c.COLS.SCOPE].isin([PScope.S1S2,PScope.S1S2S3]) + use_S3 = data[self.c.COLS.SCOPE].isin([PScope.S3,PScope.S1S2S3]) if use_S3.any(): self._check_column(data, self.c.COLS.GHG_SCOPE3) if use_S1S2.any(): @@ -120,8 +120,8 @@ def _calculate_aggregate_score(self, data: pd.DataFrame, input_column: str, try: self._check_column(data, self.c.COLS.INVESTMENT_VALUE) self._check_column(data, value_column) - use_S1S2 = (data[self.c.COLS.SCOPE] == EScope.S1S2) | (data[self.c.COLS.SCOPE] == EScope.S1S2S3) - use_S3 = (data[self.c.COLS.SCOPE] == EScope.S3) | (data[self.c.COLS.SCOPE] == EScope.S1S2S3) + use_S1S2 = (data[self.c.COLS.SCOPE] == PScope.S1S2) | (data[self.c.COLS.SCOPE] == PScope.S1S2S3) + use_S3 = (data[self.c.COLS.SCOPE] == PScope.S3) | (data[self.c.COLS.SCOPE] == PScope.S1S2S3) if use_S1S2.any(): self._check_column(data, self.c.COLS.GHG_SCOPE12) if use_S3.any(): diff --git a/ITR/temperature_score.py b/ITR/temperature_score.py index f4962979..63f690e6 100644 --- a/ITR/temperature_score.py +++ b/ITR/temperature_score.py @@ -4,7 +4,7 @@ import numpy as np import itertools -from ITR.interfaces import EScope, ETimeFrames, Aggregation, AggregationContribution, ScoreAggregation, \ +from ITR.interfaces import PScope, ETimeFrames, Aggregation, AggregationContribution, ScoreAggregation, \ ScoreAggregationScopes, ScoreAggregations, PortfolioCompany from ITR.portfolio_aggregation import PortfolioAggregation, PortfolioAggregationMethod from ITR.configs import TemperatureScoreConfig @@ -22,7 +22,7 @@ class TemperatureScore(PortfolioAggregation): class and overwriting one of the parameters. """ - def __init__(self, time_frames: List[ETimeFrames], scopes: List[EScope], fallback_score: float = 3.2, + def __init__(self, time_frames: List[ETimeFrames], scopes: List[PScope], fallback_score: float = 3.2, aggregation_method: PortfolioAggregationMethod = PortfolioAggregationMethod.WATS, grouping: Optional[List] = None, config: Type[TemperatureScoreConfig] = TemperatureScoreConfig): super().__init__(config) @@ -76,13 +76,13 @@ def get_ghc_temperature_score(self, row: pd.Series, company_data: pd.DataFrame) Get the aggregated temperature score and a temperature result, which indicates how much of the score is based on the default score for a certain company based on the emissions of company. :param company_data: The original data, grouped by company, time frame and scope category - :param row: The row to calculate the temperature score for (if the scope of the row isn't s1s2s3, it will return the original score + :param row: The row to calculate the temperature score for (if the scope of the row isn't s1s2s3, it will return the original score) :return: The aggregated temperature score for a company """ - if row[self.c.COLS.SCOPE] != EScope.S1S2S3: + if row[self.c.COLS.SCOPE] != PScope.S1S2S3: return row[self.c.COLS.TEMPERATURE_SCORE], row[self.c.TEMPERATURE_RESULTS] - s1s2 = company_data.loc[(row[self.c.COLS.COMPANY_ID], row[self.c.COLS.TIME_FRAME], EScope.S1S2)] - s3 = company_data.loc[(row[self.c.COLS.COMPANY_ID], row[self.c.COLS.TIME_FRAME], EScope.S3)] + s1s2 = company_data.loc[(row[self.c.COLS.COMPANY_ID], row[self.c.COLS.TIME_FRAME], PScope.S1S2)] + s3 = company_data.loc[(row[self.c.COLS.COMPANY_ID], row[self.c.COLS.TIME_FRAME], PScope.S3)] try: # If the s3 emissions are less than 40 percent, we'll ignore them altogether, if not, we'll weigh them @@ -116,10 +116,10 @@ def _prepare_data(self, data: pd.DataFrame): # If scope S1S2S3 is in the list of scopes to calculate, we need to calculate the other two as well scopes = self.scopes.copy() - if EScope.S1S2S3 in self.scopes and EScope.S1S2 not in self.scopes: - scopes.append(EScope.S1S2) - if EScope.S1S2S3 in scopes and EScope.S3 not in scopes: - scopes.append(EScope.S3) + if PScope.S1S2S3 in self.scopes and PScope.S1S2 not in self.scopes: + scopes.append(PScope.S1S2) + if PScope.S1S2S3 in scopes and PScope.S3 not in scopes: + scopes.append(PScope.S3) score_combinations = pd.DataFrame(list(itertools.product(*[companies, scopes, self.time_frames])), columns=[self.c.COLS.COMPANY_ID, self.c.COLS.SCOPE, self.c.COLS.TIME_FRAME]) @@ -142,8 +142,9 @@ def _calculate_company_score(self, data): """ # Calculate the GHC company_data = data[ - [self.c.COLS.COMPANY_ID, self.c.COLS.TIME_FRAME, self.c.COLS.SCOPE, self.c.COLS.GHG_SCOPE12, - self.c.COLS.GHG_SCOPE3, self.c.COLS.TEMPERATURE_SCORE, self.c.TEMPERATURE_RESULTS] + [self.c.COLS.COMPANY_ID, self.c.COLS.TIME_FRAME, self.c.COLS.SCOPE, + self.c.COLS.PRODUCTION, self.c.COLS.GHG_SCOPE12, self.c.COLS.GHG_SCOPE3, + self.c.COLS.TEMPERATURE_SCORE, self.c.TEMPERATURE_RESULTS] ].groupby([self.c.COLS.COMPANY_ID, self.c.COLS.TIME_FRAME, self.c.COLS.SCOPE]).mean() data[self.c.COLS.TEMPERATURE_SCORE], data[self.c.TEMPERATURE_RESULTS] = zip(*data.apply( @@ -171,9 +172,15 @@ def calculate(self, data: Optional[pd.DataFrame] = None, data = self._prepare_data(data) - if EScope.S1S2S3 in self.scopes: + checks_passed = False + if PScope.S1S2S3 in self.scopes: self._check_column(data, self.c.COLS.GHG_SCOPE12) self._check_column(data, self.c.COLS.GHG_SCOPE3) + checks_passed = True + if PScope.PRODUCTION in self.scopes: + self._check_column(data, self.c.COLS.PRODUCTION) + checks_passed = True + if checks_passed: data = self._calculate_company_score(data) # We need to filter the scopes again, because we might have had to add a scope in te preparation step @@ -205,7 +212,7 @@ def _get_aggregations(self, data: pd.DataFrame, total_companies: int) -> Tuple[A data[self.c.COLS.CONTRIBUTION_RELATIVE], \ data[self.c.COLS.CONTRIBUTION] - def _get_score_aggregation(self, data: pd.DataFrame, time_frame: ETimeFrames, scope: EScope) -> \ + def _get_score_aggregation(self, data: pd.DataFrame, time_frame: ETimeFrames, scope: PScope) -> \ Optional[ScoreAggregation]: """ Get a score aggregation for a certain time frame and scope, for the data set as a whole and for the different diff --git a/ITR/utils.py b/ITR/utils.py index a0b7e3d6..94732e89 100644 --- a/ITR/utils.py +++ b/ITR/utils.py @@ -2,7 +2,7 @@ from typing import List, Optional, Tuple from .configs import ColumnsConfig, TemperatureScoreConfig -from .interfaces import PortfolioCompany, EScope, ETimeFrames, ScoreAggregations, TemperatureScoreControls +from .interfaces import PortfolioCompany, PScope, ETimeFrames, ScoreAggregations, TemperatureScoreControls from .temperature_score import TemperatureScore from .portfolio_aggregation import PortfolioAggregationMethod @@ -73,7 +73,7 @@ def get_data(data_warehouse: DataWarehouse, portfolio: List[PortfolioCompany]) - def calculate(portfolio_data: pd.DataFrame, fallback_score: float, aggregation_method: PortfolioAggregationMethod, grouping: Optional[List[str]], time_frames: List[ETimeFrames], - scopes: List[EScope], anonymize: bool, aggregate: bool = True, + scopes: List[PScope], anonymize: bool, aggregate: bool = True, controls: Optional[TemperatureScoreControls] = None) -> Tuple[pd.DataFrame, Optional[ScoreAggregations]]: """ diff --git a/examples/data/rmi-20211120-output.xlsx b/examples/data/rmi-20211120-output.xlsx new file mode 100644 index 00000000..7278b56b Binary files /dev/null and b/examples/data/rmi-20211120-output.xlsx differ diff --git a/examples/data/rmi-20211120-portfolio.csv b/examples/data/rmi-20211120-portfolio.csv new file mode 100644 index 00000000..46c7f8ce --- /dev/null +++ b/examples/data/rmi-20211120-portfolio.csv @@ -0,0 +1,36 @@ +company_name;company_lei;company_id;investment_value +AES Corp.;2NUNNB7D43COUIRE5295;US00130H1059;4351252 +Algonquin Power & Utilities Corp.;549300K5VIUTJXQL7X75;US0158577090;2228185 +ALLETE, Inc.;549300NNLSIMY6Z8OT86;US0185223007;3829481 +Alliant Energy;5493009ML300G373MZ12;US0188021085;3829481 +Ameren Corp.;XRZQ5S7HYJFPHJ78L959;US0236081024;15917812 +American Electric Power Co., Inc.;1B4S6S7G0TW5EE83BO58;US0255371017;45520637 +Avangrid, Inc.;549300OX0Q38NLSKPB49;US05351W1036;10049068 +Avista Corp.;Q0IK63NITJD6RJ47SW96;US05379B1070;2804211 +Cleco Partners LP;5493002H80P81B3HXL31;US18551QAA58;3086052 +CMS Energy;549300IA9XFBAGNIBW29;US1258961002;9153135 +Consolidated Edison, Inc.;54930033SBW53OO8T749;US2091151041;20394113 +Dominion Energy;ILUL7B6Z54MRYCF6H308;US25746U1097;33528082 +DTE Energy;549300IX8SD6XXD71I78;US2333311072;14329945 +Duke Energy Corp.;I1BZKREC126H0VB1BL91;US26441C2044;73069652 +El Paso Electric Co;OZ8GM8L4AHPKSWZMW205;US283677AZ52;2646941 +Emera Inc.;NQZVQT2P5IUF2PGA1Q48;CA2908761018;6631113 +Entergy Corp.;4XM3TW50JULSLG8BNC79;US29364G1031;29844269 +Evergy, Inc.;549300PGTHDQY6PSUI61;US30034W1062;18254954 +Eversource Energy;SJ7XXD41SQU3ZNWUJ746;US30040W1080;18962480 +FirstEnergy Corp.;549300SVYJS666PQJH88;US3379321074;27277340 +Fortis, Inc;549300MQYQ9Y065XPR71;CA3495531079;12428756 +MDU Resources Group;0T6SBMK3JTBI1JR36794;US5526901096;1207049 +National Grid plc;8R95QZMKZLJX5Q2XR704;US6362744095;12281584 +NorthWestern Corp.;3BPWMBHR1R9SHUN7J795;US6680743050;2703150 +OG&E Energy;CE5OG6JPOZMDSA0LAQ19;US6708371033;7251242 +Otter Tail Corp.;549300HHVBQRQUVKKD91;US6896481032;1264277 +Pinnacle West Capital Corp.;TWSEY0NEDUDCKS27AH81;US7234841010;12058547 +PNM Resources, Inc.;5493003JOBJGLZSDDQ28;US69349H1077;3326899 +Portland General Electric Co.;GJOUP9M7C39GLSK9R870;US7365088472;5770964 +PPL;9N3UAJSNOUXFKQLF3V18;US69351T1060;18146577 +Public Service Enterprise Group;PUSS41EMO3E6XXNV3U28;US7445731067;16912134 +Sempra Energy;PBBKGKLRK5S5C0Y4T545;US8168511090;29579515 +Southern Co.;549300FC3G3YU2FBZD92;US8425871071;50294245 +WEC Energy Group;549300IGLYTZUK3PVP70;US92939U1060;11046675 +Xcel Energy, Inc.;LGJNMI9GH8XIDG5RCM61;US98389B1008;27475073 diff --git a/examples/quick_temp_score_calculation.ipynb b/examples/quick_temp_score_calculation.ipynb index 0cb10f99..3a6ae81a 100644 --- a/examples/quick_temp_score_calculation.ipynb +++ b/examples/quick_temp_score_calculation.ipynb @@ -30,7 +30,7 @@ "cell_type": "code", "execution_count": 2, "metadata": { - "scrolled": true + "tags": [] }, "outputs": [], "source": [ @@ -39,7 +39,7 @@ "from ITR.data.data_warehouse import DataWarehouse\n", "from ITR.portfolio_aggregation import PortfolioAggregationMethod\n", "from ITR.temperature_score import TemperatureScore\n", - "from ITR.interfaces import ETimeFrames, EScope\n", + "from ITR.interfaces import ETimeFrames, PScope\n", "import pandas as pd" ] }, @@ -65,7 +65,7 @@ "\n", "if not os.path.isdir(\"data\"):\n", " os.mkdir(\"data\")\n", - "if not os.path.isfile(\"data/test_data_company.xlsx\"):\n", + "if not os.path.isfile(\"data/rmi-20211120-output.xlsx\"):\n", " urllib.request.urlretrieve(\"https://github.com/os-c/ITR/raw/main/examples/data/test_data_company.xlsx\", \"data/test_data_company.xlsx\")\n", "if not os.path.isfile(\"data/OECM_EI_and_production_benchmarks.xlsx\"):\n", " urllib.request.urlretrieve(\"https://github.com/os-c/ITR/raw/main/examples/data/OECM_EI_and_production_benchmarks.xlsx\", \"data/OECM_EI_and_production_benchmarks.xlsx\")\n", @@ -114,7 +114,7 @@ "metadata": {}, "outputs": [], "source": [ - "excel_company_data = ExcelProviderCompany(excel_path=\"data/test_data_company.xlsx\")\n", + "excel_company_data = ExcelProviderCompany(excel_path=\"data/rmi-20211120-output.xlsx\")\n", "excel_production_bm = ExcelProviderProductionBenchmark(excel_path=\"data/OECM_EI_and_production_benchmarks.xlsx\")\n", "excel_EI_bm = ExcelProviderIntensityBenchmark(excel_path=\"data/OECM_EI_and_production_benchmarks.xlsx\",benchmark_temperature=1.5,\n", " benchmark_global_budget=396, is_AFOLU_included=False)\n", @@ -137,7 +137,7 @@ "metadata": {}, "outputs": [], "source": [ - "df_portfolio = pd.read_csv(\"data/example_portfolio.csv\", encoding=\"iso-8859-1\", sep=';')" + "df_portfolio = pd.read_csv(\"data/rmi-20211120-portfolio.csv\", encoding=\"iso-8859-1\", sep=';')" ] }, { @@ -167,58 +167,65 @@ " \n", " \n", " company_name\n", + " company_lei\n", " company_id\n", - " company_isin\n", " investment_value\n", " \n", " \n", " \n", " \n", " 0\n", - " Company AG\n", - " US0079031078\n", - " US0079031078\n", - " 35000000\n", + " AES Corp.\n", + " 2NUNNB7D43COUIRE5295\n", + " US00130H1059\n", + " 4351252\n", " \n", " \n", " 1\n", - " Company AH\n", - " US00724F1012\n", - " US00724F1012\n", - " 10000000\n", + " Algonquin Power & Utilities Corp.\n", + " 549300K5VIUTJXQL7X75\n", + " US0158577090\n", + " 2228185\n", " \n", " \n", " 2\n", - " Company AI\n", - " FR0000125338\n", - " FR0000125338\n", - " 10000000\n", + " ALLETE, Inc.\n", + " 549300NNLSIMY6Z8OT86\n", + " US0185223007\n", + " 3829481\n", " \n", " \n", " 3\n", - " Company AJ\n", - " US17275R1023\n", - " US17275R1023\n", - " 10000000\n", + " Alliant Energy\n", + " 5493009ML300G373MZ12\n", + " US0188021085\n", + " 3829481\n", " \n", " \n", " 4\n", - " Company AK\n", - " CH0198251305\n", - " CH0198251305\n", - " 10000000\n", + " Ameren Corp.\n", + " XRZQ5S7HYJFPHJ78L959\n", + " US0236081024\n", + " 15917812\n", " \n", " \n", "\n", "" ], "text/plain": [ - " company_name company_id company_isin investment_value\n", - "0 Company AG US0079031078 US0079031078 35000000\n", - "1 Company AH US00724F1012 US00724F1012 10000000\n", - "2 Company AI FR0000125338 FR0000125338 10000000\n", - "3 Company AJ US17275R1023 US17275R1023 10000000\n", - "4 Company AK CH0198251305 CH0198251305 10000000" + " company_name company_lei company_id \\\n", + "0 AES Corp. 2NUNNB7D43COUIRE5295 US00130H1059 \n", + "1 Algonquin Power & Utilities Corp. 549300K5VIUTJXQL7X75 US0158577090 \n", + "2 ALLETE, Inc. 549300NNLSIMY6Z8OT86 US0185223007 \n", + "3 Alliant Energy 5493009ML300G373MZ12 US0188021085 \n", + "4 Ameren Corp. XRZQ5S7HYJFPHJ78L959 US0236081024 \n", + "\n", + " investment_value \n", + "0 4351252 \n", + "1 2228185 \n", + "2 3829481 \n", + "3 3829481 \n", + "4 15917812 " ] }, "execution_count": 7, @@ -258,11 +265,84 @@ "cell_type": "code", "execution_count": 9, "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", + "
sectorregionproductionghg_s1s2emission_intensity_at_base_year
company_id
US0185223007Electricity UtilitiesNorth America6.4909064.3830481.873292
\n", + "
" + ], + "text/plain": [ + " sector region production ghg_s1s2 \\\n", + "company_id \n", + "US0185223007 Electricity Utilities North America 6.490906 4.383048 \n", + "\n", + " emission_intensity_at_base_year \n", + "company_id \n", + "US0185223007 1.873292 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "excel_provider.company_data.get_company_intensity_and_production_at_base_year(['US0185223007'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, "outputs": [], "source": [ "temperature_score = TemperatureScore( \n", " time_frames = [ETimeFrames.LONG], \n", - " scopes=[EScope.S1S2], \n", + " scopes=[PScope.S1S2], \n", " aggregation_method=PortfolioAggregationMethod.WATS # Options for the aggregation method are WATS, TETS, AOTS, MOTS, EOTS, ECOTS, and ROTS.\n", ")\n", "amended_portfolio = temperature_score.calculate(data_warehouse=excel_provider, portfolio=companies)" @@ -272,12 +352,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For every company the tool assigns a score for all the requested timeframe and scope combinations. For now the ITR methodolgy only supportt a long timeframe in combination with a S1S2 scope" + "For every company the tool assigns a score for all the requested timeframe and scope combinations. For now the ITR methodolgy only support a long timeframe in combination with a S1S2 scope" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -310,85 +390,85 @@ " \n", " \n", " 0\n", - " Company AG\n", + " Emera Inc.\n", " LONG\n", " S1S2\n", - " 2.05\n", + " 3.56\n", " \n", " \n", " 1\n", - " Company AH\n", + " Fortis, Inc\n", " LONG\n", " S1S2\n", - " 2.22\n", + " 3.17\n", " \n", " \n", " 2\n", - " Company AI\n", + " AES Corp.\n", " LONG\n", " S1S2\n", - " 2.06\n", + " 2.56\n", " \n", " \n", " 3\n", - " Company AJ\n", + " Algonquin Power & Utilities Corp.\n", " LONG\n", " S1S2\n", - " 2.01\n", + " 3.20\n", " \n", " \n", " 4\n", - " Company AK\n", + " ALLETE, Inc.\n", " LONG\n", " S1S2\n", - " 1.93\n", + " 2.46\n", " \n", " \n", " 5\n", - " Company AL\n", + " Alliant Energy\n", " LONG\n", " S1S2\n", - " 1.78\n", + " 3.78\n", " \n", " \n", " 6\n", - " Company AM\n", + " Ameren Corp.\n", " LONG\n", " S1S2\n", - " 1.71\n", + " 6.07\n", " \n", " \n", " 7\n", - " Company AN\n", + " American Electric Power Co., Inc.\n", " LONG\n", " S1S2\n", - " 1.34\n", + " 13.47\n", " \n", " \n", " 8\n", - " Company AO\n", + " Avangrid, Inc.\n", " LONG\n", " S1S2\n", - " 2.21\n", + " 1.32\n", " \n", " \n", "\n", "" ], "text/plain": [ - " company_name time_frame scope temperature_score\n", - "0 Company AG LONG S1S2 2.05\n", - "1 Company AH LONG S1S2 2.22\n", - "2 Company AI LONG S1S2 2.06\n", - "3 Company AJ LONG S1S2 2.01\n", - "4 Company AK LONG S1S2 1.93\n", - "5 Company AL LONG S1S2 1.78\n", - "6 Company AM LONG S1S2 1.71\n", - "7 Company AN LONG S1S2 1.34\n", - "8 Company AO LONG S1S2 2.21" + " company_name time_frame scope temperature_score\n", + "0 Emera Inc. LONG S1S2 3.56\n", + "1 Fortis, Inc LONG S1S2 3.17\n", + "2 AES Corp. LONG S1S2 2.56\n", + "3 Algonquin Power & Utilities Corp. LONG S1S2 3.20\n", + "4 ALLETE, Inc. LONG S1S2 2.46\n", + "5 Alliant Energy LONG S1S2 3.78\n", + "6 Ameren Corp. LONG S1S2 6.07\n", + "7 American Electric Power Co., Inc. LONG S1S2 13.47\n", + "8 Avangrid, Inc. LONG S1S2 1.32" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -407,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -416,16 +496,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "2.242923076923077" + "10.56493695895286" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -450,9 +530,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": { - "scrolled": true + "tags": [] }, "outputs": [], "source": [ @@ -478,14 +558,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -495,169 +575,13 @@ } ], "source": [ - "analysis_parameters = ([ETimeFrames.LONG], [EScope.S1S2], grouping)\n", + "analysis_parameters = ([ETimeFrames.LONG], [PScope.S1S2], grouping)\n", "plot_grouped_heatmap(grouped_aggregations, analysis_parameters)" ] }, { - "cell_type": "code", - "execution_count": 15, + "cell_type": "raw", "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", - " \n", - " \n", - " \n", - " \n", - " \n", - "
groupcompany_namecompany_idtemperature_scorecontribution_relative
0Steel-AsiaCompany AWUS71344810813.2011.94
1Steel-AsiaCompany AJP00000000013.2011.94
2Steel-AsiaCompany FNL00000000063.2011.94
3Steel-AsiaCompany ICN00000000093.2011.94
4Steel-AsiaCompany JBR00000000103.2011.94
5Steel-AsiaCompany LBR00000000121.887.02
6Steel-AsiaCompany HCN00000000081.846.87
7Steel-AsiaCompany ESE00000000051.816.76
8Steel-AsiaCompany GCN00000000071.786.64
9Steel-AsiaCompany DSE00000000041.766.57
10Steel-AsiaCompany CIT00000000031.726.42
\n", - "
" - ], - "text/plain": [ - " group company_name company_id temperature_score \\\n", - "0 Steel-Asia Company AW US7134481081 3.20 \n", - "1 Steel-Asia Company A JP0000000001 3.20 \n", - "2 Steel-Asia Company F NL0000000006 3.20 \n", - "3 Steel-Asia Company I CN0000000009 3.20 \n", - "4 Steel-Asia Company J BR0000000010 3.20 \n", - "5 Steel-Asia Company L BR0000000012 1.88 \n", - "6 Steel-Asia Company H CN0000000008 1.84 \n", - "7 Steel-Asia Company E SE0000000005 1.81 \n", - "8 Steel-Asia Company G CN0000000007 1.78 \n", - "9 Steel-Asia Company D SE0000000004 1.76 \n", - "10 Steel-Asia Company C IT0000000003 1.72 \n", - "\n", - " contribution_relative \n", - "0 11.94 \n", - "1 11.94 \n", - "2 11.94 \n", - "3 11.94 \n", - "4 11.94 \n", - "5 7.02 \n", - "6 6.87 \n", - "7 6.76 \n", - "8 6.64 \n", - "9 6.57 \n", - "10 6.42 " - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "region = 'Asia'\n", "sector = 'Steel'\n", @@ -692,7 +616,7 @@ "outputs": [], "source": [ "time_frames = [ETimeFrames.LONG]\n", - "scopes = [EScope.S1S2]\n", + "scopes = [PScope.S1S2]\n", "grouping = ['sector']\n", "analysis_parameters = (time_frames, scopes, grouping)\n", "\n", @@ -711,7 +635,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAICCAYAAACHlRq/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxU1f3/8dcnCUtYZcvI6iiCCC4oinGpUGvd4ha1qFWrtq5drIptx6XV1hZoq9b221qxaulPba0btjqtWm2FtooVFBHZ3IKsYQ8BkpDl/P64NzqEQAJk5szyfj4e88jMvXfufc9ycz9z7rn3mnMOEREREUmtPN8BRERERHKRijARERERD1SEiYiIiHigIkxERETEAxVhIiIiIh6oCBMRERHxQEWYiOQMM3vPzMaG9+8ws0fbcN63mNmDbTU/Ecl+KsJSxMzKzOzEHFz2ZWb2Hx/LlvRkZl82s5lmtsnMVpjZ383suD2c5xQz+3FL0znnRjjnXt2TZYXLG2tmS5vMe4Jz7oo9nbeI5A4VYSKSMmZ2I3AvMAGIAIOA+4CzkrzcgmTOX0Rkd6gIS7HGliEzu8vM1pvZx2Z2ajjuAjOb2WT6G8zsr+H9DuHzPjGzcjO738wKw3G9zex5M9tgZuvM7N9mlmdmjxBs6J4LWx6+a2ZRM3NmdrmZLQlzXGNmR5rZnHAev26S46tmNj+c9kUz2ydhnAuf/344/jcWOBC4Hzg6XPaGcPrTzGyemVWa2TIzuymZ77mkBzPrDvwI+IZz7hnn3GbnXK1z7jnn3HfC7/e9ZrY8vN1rZh3C5441s6VmNt7MVoUtaJeH464CLgK+G37PnguHl5nZ98xsDrDZzAqaaRXuaGZ/Dr+Lb5nZoQl5nZntn/B4ipn92Mw6A38H+oXL22Rm/Zru3jSzM8PdnxvM7NVwfWgcV2ZmN4XrW0WYoWM4rtl1ue0/ERHxTSu2H0cBC4HewM+Ah8zMgL8CB5jZkIRpvwz8Mbz/U2AoMBLYH+gP/CAcNx5YCvQhaGG4BXDOuUuAT4AznHNdnHM/a5JjCHA+QevErcCJwAhgnJmNATCzs8P5nRPO/9/An5q8ptOBI4FDgXHAyc65+cA1wOvhsvcKp30IuNo51xU4CPhn6986yWBHAx2BqTsYfytQTPD9PhQYDdyWMH5voDvB9/5rwG/MrIdz7gHgMeBn4ffsjITnXAiUAHs55+qaWeZZwJNAT4L17Fkza7ezF+Gc2wycCiwPl9fFObc8cRozG0qwjlxPsM78jeCHUPuEycYBpwD7AocAl4XDm12Xd5ZJRDKTijA/Fjvnfuecqwf+APQFIs65LcBfCDYchMXYMOCvYZF2JXCDc26dc66SYJfOBeE8a8P57BO2LvzbtXxh0Dudc9XOuZeAzcCfnHOrnHPLCAqtw8LprgYmOufmhxuyCcDIxNYwYJJzboNz7hPgXwQb0h2pBYabWTfn3Hrn3FstvWGSFXoBa3ZQDEHQmvWj8Du4GvghcEnC+NpwfK1z7m/AJuCAFpb5K+fcEudc1Q7Gz3LOPeWcqwXuISgSi1v7gnbifCDunPtHOO+7gELgmCbZljvn1gHP8dk6szvrsohkIBVhfqxsvBMWXgBdwr9/JCzCCFrBng2n6QN0AmaFuyk2AC+EwwF+DnwAvGRmH5lZrBU5yhPuVzXzuDHTPsAvE5a7DjCCFontXhOwJeG5zTkXOA1YbGbTzOzoVmSVzLcW6G077p/VD1ic8HhxOOzT5zcp4Fr6ngEsae1451wDQQtUvx1P3mrbvJZw3kto3TqzO+uyiGQgFWHp5yWCDdVIgmKscVfkGoLCaIRzbq/w1t051wXAOVfpnBvvnNsPOAO40cy+ED53T39FLyHYfbhXwq3QOfdaK5673bKdc286584CioBngSf2MJ9khteBauDsHYxfTlDwNxoUDmuNHX3HW/ruD2y8E/a7GpCwzC0EP3wa7b0L893mtYQt2QOBZS08r6V1WUSyiIqwNBP+0n+K4NdwT+Af4fAG4HfAL8ysCMDM+pvZyeH9081s//Cf/UagPrxB0MK13x7Euh+42cxGhMvqbmZfauVzy4EBjX1hzKy9mV1kZt3D3TSNWSXLOecqCPow/sbMzjazTmbWzsxONbOfEfShus3M+phZ73Da1p7Ha3e/46PM7Jywde56oAaYEY6bDXzZzPLN7BRgTJPl9QoPNmjOE0CJmX0h7GM2Ppx3iz9cWliXRSSLqAhLT38k6CD/ZJPdL98j2E0xw8w2Ai/zWZ+YIeHjTQQtDvclnA9pIsHGbcPuHInonJtKcFDA4+Fy5xJ0TG6NfwLvASvNbE047BKgLJzXNcDFu5pJMpNz7h7gRoIO96sJWlm/SdAi+mNgJjAHeBd4KxzWGg8R9DPcYGbP7kKkvxD031pP8L08J/xxAPBtgpaoDQT91T6dr3NuAUHR+FG4zG12YTrnFhJ8r/+PoBX7DIKDY7a2ItPO1mURySKm/p4iIiIiqaeWMBEREREPVISJiIiIeKAiTERERMQDFWEiIiIiHqgIExEREfFARZiIiIiIByrCRERERDxQESYiIiLigYowEREREQ9UhIlIzgqvC/m2mT0fPh5pZjPMbLaZzTSz0eHwY81sjpm9aWb7h8P2MrMXw2s8iojsMhVhOa7pRigc9i0zW2hm74UXVtZGSLLVt4H5CY9/BvzQOTeS4ALiPwuHjwfOBW4Brg2HfR+Y4HTtNxHZTSrCZJuNkJl9HjgLOMQ5NwK4KxyljZBkFTMbAJQADyYMdkC38H53YHl4vxYoBDoBtWY2GOjvnJuWorgikoUKfAcQfxI2Qj8BbgwHXwtMcs7VADjnVoXDtRGSbHMv8F2ga8Kw64EXzewugh+px4TDJwIPAFXAJQQ/Tr6fuqgiko3UEpbbGjdCDQnDhgKfM7M3zGyamR0ZDm/cCF0P/JqgcNNGSDKSmZ0OrHLOzWoy6lrgBufcQOAG4CEA59xs51yxc+7zwH4ELWRmZn82s0fNLJLK/CKSHdQSlqMSN0JmNjZhVAHQAygGjgSeMLP9nHOzw2GY2fEkbIQIWsnGO+fKU/kaRPbAscCZZnYa0BHoZmaPAmcQ7KIHeJJtd1US9n+8DTif4MfI7UAUuA64NSXJRSRrqCUsdzVuhMqAx4ETwo3QUuAZF/gfQStZ78YnJWyE7iTYAN0OPEqwERLJCM65m51zA5xzUeAC4J/OuYsJflyMCSc7AXi/yVMvBeLOufUEu+YbwlunlAQXkayilrAc5Zy7GbgZIGwJu8k5d7GZXUOw8XnVzIYC7YE1CU/9dCNkZtoISba5EvilmRUA1cBVjSPC7/ulwEnhoHuAp4GtwIUpzikiWcB0YJskFGGnm1l74GFgJMHG5Sbn3D/D6ToBceAk51ytmX0OuC+c7kLn3CIvL0BERCQDqQgTEZGsN2vWrKKCgoIHgYNQV5xc0QDMrauru2LUqFGrWpzaA+2OFBGRrFdQUPDg3nvvfWCfPn3W5+XlqfUhBzQ0NNjq1auHr1y58kHgTN95mqNfAyIikgsO6tOnz0YVYLkjLy/P9enTp4Kg9TMtqQgTEZFckKcCLPeEn3na1jppG0xEREQkm6lPmIiI5JxoLD6qLedXNqmk6dUXmvW9731v76effrpXXl6ey8vL47777lv8n//8p/MNN9ywpmvXrg0tz2F75557bvT000+vuPzyy9fvzvPFHxVhIiIiKfDyyy93fvHFF/d699135xUWFroVK1YU1NTU2CWXXLLflVdeuW53izDJXNodKSIikgLLli1r17Nnz7rCwkIH0Ldv37pHH320x6pVq9qNGTNm6FFHHTUU4Jlnnuk2cuTIYcOHDz/w1FNP3a+ioiIP4N///nenI4888oARI0YceNxxxw1ZvHhxO5+vR/acijAREZEUOPvsszcuX768fTQaPejiiy8eFI/Hu9x2222rioqKaqdNm7bojTfeWLRixYqCCRMm9J0+ffqiefPmzT/88MO33HnnnZGamhq77rrrBv3lL3/58L333pt/6aWXrrnpppv6+35Nsme0O1JERCQFunfv3jB37tx5L7zwQtdXXnml66WXXjr4Bz/4wdLEaV599dXOH374YcfRo0cPA6itrbVRo0ZtmjNnTof333+/8IQTThgK0NDQQJ8+fWp9vA5pOyrCREREUqSgoIDTTz+98vTTT6885JBDqh555JFeieOdcxx33HEbn3vuuY8Th//vf/8r3H///atmz569ILWJJZlUhOWAaCyeB3QPb3sBHQmu91gN1IR/q4HKskklW33lFEmFaCxuQFegkGBd6BD+7UjQRWMzsAmoANaXTSrRuaWkTbzzzjsd8vLyOPjgg2sA3n777cIBAwZsXbp0afuKioq8vn37Mnbs2M3jx48fNHfu3A4HHXRQTWVlZd7HH3/c7pBDDqlet25dwcsvv9z5xBNP3FxTU2PvvvtuhyOOOKLa9+uS3aciLAtEY/F8IAoc0OS2L9CDYINjrZiVi8bia4BlwCfAR8CHwHvAzLJJJZVtHl4kCcJCazjBmbKj4W3f8O8+BAVXa9RHY/F1QDmwCJifcFtQNqlkS1vmltRp7Skl2tLGjRvzr7vuukEbN27Mz8/Pd9FotOYPf/jD4ocffrjnqaeeOqSoqKj2jTfeWDR58uSyCy64YL+tW7cawO23377skEMOqXn88cc/vO666wZVVlbm19fX27XXXluuIiyz6QLeGSgai3cEioEx4a2Y4Fd9MjUA84A3Em7vqpVA0kE0Ft8LOAo4OrwdRdDym0wOKAP+A7wCvFI2qWTpTp8h3rzzzjtlhx566BrfOST13nnnnd6HHnpo1HeO5qgIyxDRWHwocD7wRWA0wS4U31YCzwHPEmyAajznkRwSjcX3B84FzgGOpHWtvcn2AfBP4B9AvGxSSZXnPBJSEZa7VITJbonG4vsAF4S3kZ7jtKQSeAF4GnhWBZkkQzQWHwGcR1B4HeI5TksqgWeAR4B/lU0q0Yk4PVIRlrtUhEmrRWPxdsCFwNUEu1XS4df9rloDPAz8tmxSSZnnLJLhwnViHHAdQStwJloG/BH4fdmkkvm+w+QiFWG5S0WYtCgai/cgKLy+BfTzHKetNBC0jt0H/F0tAbIrorF4BLiGYL3o6zlOW3HA88DEskklr/sOk0tUhOUuFWGyQ+Eux/HAV4HOnuMk01zg+2WTSp71HUTSWzQWjwK3A18G2vtNk1TTCIqxF30HyQUqwnKXijDZTjQW7w7cSrCLJR062afKG8AtZZNK/uk7iKSXsDX4NuAb5NY68RYQK5tU8g/fQbKZirDcpSJMPhWe0+tq4A6gj980Xv0T+K6Pc/VIeonG4h0IfozcTHBeu1z1DHBj2aSSxb6DZKOmRdjUGeWj2nL+pcWRFv+X5efnjxoyZMinR8yec8456yZMmLBy9OjRB9x1111Ljj/++F0679xrr71WuGTJkvbnn39+RXPjp0+f3unhhx/uNWXKlCU7mseYMWP2f/rppz8GePDBB3vGYrHVrV3+888/3/Xuu++O/Otf//qgcdi5554bPf300ysuv/zy9T/60Y+KbrjhhjVdu3ZtSFxW79696zt16nTYli1b3i4rK2t3zTXXDHzhhRc+avp6Hnvsse7vvfde4YQJE1a2NlNz0rkI0wW8Uygai58EzAF+Q24XYAAnAG9EY/G7o7F4J99hxI9oLF4CLAR+Rm4XYBAc8Tk/GovfHp4LULJMhw4dGhYsWDCv8banxcXMmTM7xePxZs+HV1tby/HHH79lZwUYwLRp0z7o3bt3/dq1a/Mfeuihoj3J09TkyZMjmzZt+rTOaFxW4jTRaLT2hRde+Ai2fz0XXXRRxZ6+R+lORVgKRGPx7tFY/PfAiwRn8ZZAPnAj8G40Fj/BdxhJnWgs3i0aiz9M0El9H9950kghQSv5vGgsfrLnLOLBM888023kyJHDhg8ffuCpp566X0VFRR7AtGnTOh122GHDDjjggOEHH3zwgWvXrs2fOHFiv+eee67HsGHDhv/ud7/rceONN/a78MIL9zn22GOHnHPOOfs+//zzXT//+c/vD1BRUZF33nnnRYcOHTp86NChw6dMmbIXQP/+/Q9esWJFwfjx4wcsWbKkw7Bhw4ZfffXVA84+++x9H3300b0ac5155pn7PvbYY60+AfKPf/zjolWrVrUbM2bM0KOOOmpo4rISp1u4cGH7IUOGjKiurramr+dXv/pVr6985SuDAJYvX15w8sknDz7ooIMOPOiggw586aWXOgPE4/Euw4YNGz5s2LDhBx544PD169dnVF2TUWEzUTQW/yLBZX8u8xwlne0HvBKNxR8Kz3wuWSxcJ+YCl/vOksb2Bf4ejcXvicbi2XxwQk6pqanJaywYGguNxPErVqwomDBhQt/p06cvmjdv3vzDDz98y5133hmprq62iy66aPC99977ycKFC+dNmzZtYbdu3epvvvnm5Wecccb6BQsWzLvyyivXA8yZM6fTiy+++EHTC4DHYrG+3bp1q1+0aNG8RYsWzSsp2fYydHfffffSgQMH1ixYsGDe5MmTl1555ZWrp0yZ0gtg7dq1+bNmzeoybty4Znd7Nue2225bVVRUVDtt2rRFb7zxxqKWpu/YsaNr7vU0uvrqqwfeeOON5XPnzp0/derUD6+55ppomHvvX/3qV4sXLFgwb8aMGQu6dOmSUUfh69qRSRL+45wI3EBmnuvLh68CJ0Rj8XPLJpW85TuMtK1oLN4ZuIvgtBPSMiP4/zEmGotfUDap5H3fgWTPNO6O3NH4V199tfOHH37YcfTo0cMAamtrbdSoUZvmzJnTsaioqHbMmDFbAHr27LnDQuOUU07Z0KVLl+06e0+fPr3b448//lHj4z59+tQ3nSZRSUnJpuuvv36fZcuWFTz22GM9SkpK1rdr126bacys2U7lOxq+J/773/92e//99z+9PN+mTZvy169fn1dcXLzppptuGjhu3Lh1F1544frBgwdnVBGmlrAkiMbi/YD/EuxqUwG2a6LAf6OxuFpJskg0Fh8MvI4KsN1xOPBWNBa/zHcQSS7nHMcdd9zGxj5jH3744XtPPPHEYudcqwubzp07N1uEhPPYpTzjxo1b++CDD/Z89NFHe1111VXbHVlaVFRUV1FRsU1jzvr16wv69OlTt0sLagXnHDNnzpzf+N6sWrVqTo8ePRomTJiw8sEHH1xcVVWVd8wxxxz49ttvZ1R/ShVhbSwaix8BvAkc4TtLBusIPByNxSdrV0zmC/s2vQkc7DtLBusC/D4ai/8uGotrD0aWGjt27OaZM2d2mTt3bgeAysrKvDlz5nQ49NBDq8vLy9tPmzatE8D69evzamtr6datW31ix/cW5r3xnnvu+bTj/erVq/MTx3fv3r1+8+bN28zrmmuuWTN58uQIwBFHHFHddJ4HHXRQTXl5ebu33nqrI8CiRYvaL1iwoLC4uLgKoHPnzvWNfdpaY2ev57jjjtv405/+9NP8r732WiHAe++912H06NFVP/nJT1YefPDBm+fOnZtRRZhW5jYUjcXHAVMIOtfKnrsKGBmNxc8qm1SS1UfIZKtoLP5N4F6CgzBkz10B9I/G4l8qm1Sy2XeYTNaaU0q0tcY+YY2PTzjhhIr77rtvWePjfv361U2ePLnsggsu2G/r1q0GcPvtty875JBDah577LEPr7vuukHV1dV5HTt2bJg+ffqiU089tfKuu+7qO2zYsOHjx49fsbNlT5w4ccXll18+aMiQISPy8vLcLbfcsvzSSy/d0Dh+7733rh81atSmIUOGjDjhhBMqJk+evHTgwIF1gwcPrj7jjDM2NDfPwsJC9/vf//6jyy+/PFpTU5NXUFDgfvOb3yzu1atXPcCll1665tRTTx1SVFRU25p+YTt7PQ888MCSK664YtDQoUOH19fX21FHHVV5zDHHfPKzn/2s6LXXXuuWl5fnhg4dWnXeeee1ut9aOtB5wtpINBa/A/gB2v2YDB8CJ+o6lJkjGovnERRf3/KdJUvNAkrKJpWU+w6SKXSy1l1XWVmZN3z48OGzZ8+e31hYZSKdJyyLRWNxi8bivyG4zIoKsOQYDPwnGosf6DuItCwswB5GBVgyjQJmRGPxYb6DSHZ69tlnuw4dOnTElVdeuSqTC7B0p5awPRCNxQ34NfB131lyxBrgZB05mb7CAuz3wFd8Z8kR6whaid/2HSTdqSUsd6klLHupAEut3sA/o7H4Mb6DyPZUgHnRE3gpGouP8B0kAzQ0NDRob0WOCT/ztD1thYqw3RTuglQBlnrdgXg0Fj/EdxD5TFiATUEFmA+9CU52PMR3kDQ3d/Xq1d1ViOWOhoYGW716dXeCk0OnJe2O3A3RWHwCwcWGxZ8VwLFlk0o+bnFKSbpoLH4fcK3vHDmuDDimbFLJTo+Sy1WzZs0qKigoeBA4CDVA5IoGYG5dXd0Vo0aNWuU7THNUhO2iaCx+CfD/fOcQABYQbHTWtzilJE00Fv8Gwa558W8OcHzZpJKMOkxfJFepCNsF0Vj8aOBfQAffWeRTrwInlU0qqfUdJBdFY/ETgb+jcw6mk78CZ5dNKtE/d5E0pybZVorG4oOAZ1EBlm7GAr/0HSIXhX2QnkAFWLo5E4j5DiEiLVNLWCtEY/FOwGvAob6zyA6dWzap5BnfIXJFNBbvDrwBHOA7izSrnqCF+J++g4jIjqklrHV+jgqwdPdQNBbfx3eIHPJbVICls3zgT9FYvL/vICKyY2oJa0F48eEXfOeQVnmdoFNyne8g2Swai3+JYDekpL/XgDFaJ0TSk1rCdiIai/cguPyKZIajgTt9h8hm0Vh8b4JWMMkMxwA3+A4hIs1TEbZz9wH9fIeQXfLdaCx+hO8QWewBoJfvELJL7ojG4vv6DiEi21MRtgPhLpcLfOeQXZYH3BeewV3aUDQWvxw4w3cO2WWdUOulSFrShqoZ0Vi8ELjbdw7ZbUcCV/gOkU3CXfNaJzLXydFY/CLfIURkWyrCmjceGOg7hOyRidFYXLvN2s5tQA/fIWSP/ELrhEh6URHWRDQW74tOdJgNegKTfIfIBmF/om/6ziF7rA9wq+8QIvIZFWHb+zHQ2XcIaRNfi8biI3yHyAITgfa+Q0ibuCb8oSkiaUBFWIJoLH4ocJnvHNJmDP3y3yPRWHw0cL7vHNJmCoGbfYcQkYCKsG3dgt6TbDMuvMah7J6JvgNIm7tKZ9IXSQ8qOELRWDwKnOs7h7S5fILiWnZR2DJ8gu8c0uY6oBZikbSgIuwz1xNssCX7XBwW2bJrrvcdQJLma9FYXCeiFvFMRRgQjcX3Ar7mO4ckTQHBaUeklaKxeBFwoe8ckjTtgct9hxDJdSrCAlcDXXyHkKS6KBqLd/AdIoNcQ7DbSrLXFdFY3HyHEMllOV+Ehf+ErvWdQ5KuB3C27xCZIBqLt0frRC6IAl/0HUIkl+V8EQYcDezjO4SkxFd9B8gQpwF7+w4hKXGl7wAiuUxFmC7SnUtOjMbiuhxVy77kO4CkzFlh/z8R8SCni7BoLJ4PjPOdQ1ImD/iK7xDpLOw3d7rvHJIy7dD/QBFvcroIAz4PRHyHkJTSueB27iSgm+8QklIlvgOI5KpcL8J0OZbcM1K7X3bqPN8BJOXGRmPxTr5DiOSiXC/C9Asw9xhBa480EY3F2wFn+s4hKdcRXRlBxIucLcKisfiBQF/fOcSLk30HSFNHAnv5DiFe6AepiAc5W4QNj3Q/ukNBXqXvHOLFSTpJZbOO8R1AvDnNdwCRXFTgO4AvVx495GTnXKeauoZ5i9dvWv3W0nWF767YcEBVbX1339kk6YqAkcDbvoOkGRVhuWtQNBaPlk0qKfMdRCSX5GwRBhxjZvkd2+UPP6CoOwcUdecC5xq21jcs/GT95pVvL13X8Z0V64du2Vrfw3dQSYojUBHW1NG+A4hXhwNlvkOI5JKcLMKmzigfBAxoOtzM8joU5B8wpE+3A4b06caXRu7jahvc+0vWb14+e9m69rOXrx+yqaaut4fI0vYO9R0gnURj8f3QWfJz3WHAM75DiOSSnCzCCHZFtcjMrH2+DRncu+uQwb27cu6h+1Bb3/Dhsooty2YvW9/u7WXrBm+srtXpDjKTirBtaVekHOY7gEiuydUibPDuPrFdft7gaM8ug6M9u3D2wQOpq2/4ePnGqqXvLF+f9/bSdfutr9qqIy4zwyHRWNzKJpU430HShIpSUREmkmIqwvZQQX7evoN6dN53UI/OnDFiAPUNDZ+s2Fj9yZzl63l72bp912yu6d9Wy5I21Q3YF/jId5A0McR3APGuXzQWLyqbVLLKdxCRXKEirI3l5+UNGrBXp0ED9urEacP7U9/glpZXVpXNWbHBvb103aBVm6r3SdayZZcdhIqwRirCBGAYoCJMJEVUhCVZfp4N6Ne904B+3TtxyrB+NDS4Fas2V380d8WGhreWrhuwYmPVvqnKItvp5ztAurj7rFFda+oa3ttYvbVi9aaarSs2VuUvq9jSecXGql5rNtf0a3Cune+MkhLqTiGSQjlXhE2dUZ4PRH0tPy/P+u7dtbDv3l0LOXFoXxqcW7Vmc82Hc1dsqH1r6dr+yyqqUlYgii7eDjB1RnmvPLOBhe3yKWxXSKRrIQf1/ezE+c65+gbHsura+tUbqrduWlVZXbesYku7ZRVbuq6srO6zoWrr3gSXg5LMpyNkRVIo54owYCCQNr/q88yKirp0LDphyN6cMGRvGpxbs25LzQfvrayoeWvJur6fbNg8BG3gkkUbnMB2p2tJZGb5+Ub/zh0K+nfuUED/7p04bEDPT8c752rqG9zyLbV1a9dt2bplZWVVw/KKqg7LKrZ0L6+s3nvz1rqeO5m9pBetEyIplItFWB/fAXYmz6x3784de48Z3JExgyM459avr9q6aH55RfWsJesiZes2DXU5fLmpNqaWsMAebXjNrENBvu3bLb/9vt06tifas8s2451zlbX1DSs2ba1bv3ZzTfWKjVUsq9hSuHxjVY9VldX9ttY3dN6j9NKWVISJpFAuFmEdfQfYFWbWo2enDkcdu28Rx+5bhHOuYkNV7cIFqyqqZi1Z2+ejtZsOcAa1M0EAACAASURBVJDvO2eG0gYnUJjMmZtZ1/YF+V17FuTTs1MHhvTpts34BufWbK1rKN9YXVuxenN10B9tw5ZOyzdW9VZ/tJRTnzCRFFIRlmHMrHuPTu1HHx3tw9HRPjjnKjdW1y5cuHrjpllL1vX6YE3lMG20Wk1XPwi097nwPLPeHdvl9+7YLp+irh0Zsfc2/dEaGhzLq+vqV2+o2lq5alN13fKKLQXLKqq6rtxYVbShamtELcNtqpfvACK5REVYhjOzrt0L2x8xelBvRg/qjXNu86aauncXrt64cdaStT3fX105rN45rxvZNKb3JdDBd4AdMbO8fKNf5/YF/Tq3D/uj9d+mP9rWeueWb9lav3b9lprNKyurG5ZXbGnsjxbZtLVORcWu0Q84kRRSEZZlzKxz147tDj9iYC+OGNgL51zV5q11b7+/prLirSXr9lqwqmJYXYPL6vdgF+Ti9785GVuMmln7ArNot4550W4d27HP9v3RNtU2uBWbamrXr91cU7WysoplFVWFyyu29FhVWd23pr6hyw5mnatUhImkUC5uhNL2V38ymFlhlw7tDjusf08O698T51zNltr6d8orqypcjl+wp66hYaPvDGkia9cJM+vSPt+G9OzUodn+aM65tTV1DeUba2orKqtrt5LjRyJvrW8o951BJJeoCMsxZtahc/uCQ/fr1dV3lHSwxHeANJGxLWF7ysx6dWyX36tju3yKuqiBGJjrO4BILsnFDq01vgNI2qjzHSBN6H2QRvouiKRQLhZha3wHkLRR6ztAmljrO4CkDa0TIimUi0WYNjjSaJ3vAGlCP0ykkf4/iqSQijDJZct8B0gTWiek0XLfAURySS4WYfrVL41UhAW0TkgjrRMiKZRzRVhpcWQj6vcggaW+A6QJtYRJI7WEiaRQzhVhIW10BPSrH4DS4shmoMp3DkkLKsJEUihXi7CPfAeQtKAi7DOLfAeQtKAiTCSFcrUIm+c7gKQF7Y78zBzfASQtLPYdQCSXqAiTXFUJfOw7RBpRESZLS4sjq32HEMkluVqEaYMjM0uLIw2+Q6QRrRPypu8AIrkmV4uwt3wHEO/e8B0gzagIExVhIimWk0VYaXFkPeqcn+tUhCUoLY6sBFb5ziFeqQgTSbGcLMJC//MdQLxSEba9Wb4DiDcOmOk7hEiuyeUi7B++A4g3S0qLIyt8h0hDr/gOIN58UFoc2eA7hEiuyeUiLE7w609yz+u+A6Qp/TDJXSrARTzI2SKstDhSjna/5Kq/+A6Qpt4FVvoOIV5M9R1AJBflbBEWet53AEm5GvS5N6u0OOIIWoglt2wA/uU7hEguyvUiTBuc3POP8CLu0jy1EuaeeGlxpNZ3CJFclOtF2CxAHbRzy1O+A6S5l4HNvkNISmlXpIgnOV2Ehbtf9A8od9Silp6dKi2OVAFP+s4hKVMNvOA7hEiuyukiLHS/7wCSMq/oMPxWmew7gKTM30qLI2r5FPEk54uw0uLIu8B/fOeQlHjEd4BMUFocmYEuY5Qr9CNUxKOcL8JC9/kOIEm3Au1m2xVqDct+7xP0ARQRT1SEBZ4Gyn2HkKS6X0eA7ZJHUQf9bPfbsF+siHiiIgwoLY5sBR7ynUOSphrtdtkl4Wk8HvedQ5KmAnjQdwiRXKci7DP3A3W+Q0hS/L60OLLKd4gMdDdQ7zuEJMUDpcWRSt8hRHKdirBQaXFkCfplmI3qgZ/7DpGJSosj89HBDNmoBvil7xAioiKsqR+ifjDZ5rHS4sjHvkNksDuArb5DSJu6t7Q4ssx3CBFREbaN0uLISoJdMJIdNgO3+A6RyUqLI4tRf7psshqY4DuEiARUhG3v54D6D2WHCfrF3yZ+glqIs8XtunaqSPpQEdZEaXFkE8FuSclsH6FWzTYRHtRwr+8cssfmAQ/4DiEin1ER1rwHgEW+Q8geubG0OFLjO0QWmQiob11m+05pcURHu4qkERVhzSgtjtQB1wA6kWFmeqm0OKILdbeh8PqCX0PrRKaKlxZH/uY7hIhsS0XYDpQWR/4F/NZ3Dtll1cC3fYfIRlonMtYa4ArfIURkeyrCdu57aBdMprmhtDiywHeILKZ1IvNcGR75LSJpRkXYToSd9C9GZw3PFE+VFkd0OoUkCtcJ7ZbMHA+VFkee9R1CRJqnIqwFpcWR14A7feeQFpWhXS4pEe6W/LXvHNKiD9CueZG0piKsdX4MvOo7hOxQHXBBaXGkwneQHHIT8LrvELJDdcAl4QEVIpKmVIS1QnhY97notBXp6tbS4sgbvkPkktLiyFaCdWKF7yzSrG+WFkdm+A4hIjunIqyVSosj64ASYK3vLLKNP6ILdHtRWhxZAZxDcESqpI+flRZHJvsOISItUxG2C0qLIx8AZwM6CWh6eBG4rLQ4ok7inoStLZeijvrp4s9AzHcIEWkdFWG7qLQ48h/gcrTR8e1/wLmlxZFa30FyXWlx5AngVt85hP8Cl+pHiUjmUBG2G0qLI38Cvu87Rw5bAJymTsfpo7Q4MhH4ke8cOex94Cxdqksks6gI202lxZGfoELMh6XASaXFEfXNSzOlxZHbgdt958hBHwBf0DohknnMObVc74mpM8qvA+4FzHeWHLAE+GJpcWSh7yCyY1NnlN9KcFoXSb4FBAXYct9BRGTXqQhrA1NnlF8GPAjke46SzeYTtIAt9R1EWjZ1RnkMmOg7R5Z7GziltDiyyncQEdk92h3ZBkqLI1OA84GtnqNkqxnA51SAZY7S4sgk4Hp0ya9k+ScwRgWYSGZTEdZGSosjTwNnABt8Z8kyTwCfV3+XzFNaHPklcCqwzneWLPNHggNTKn0HEZE9o92RbWzqjPL9gCeBw31nyQITgNt0yH1mC9eJZ4GDfWfJcFuBG0qLI/f5DiIibUNFWBJMnVHeAfgFcK3vLBlqFcFJWP/uO4i0jakzyjsDU4DzPEfJVGXAuNLiyJu+g4hI21ERlkRTZ5RfCDwAdPGdJYP8DbhcfV2yU9hh/0dAO99ZMshzBCdhXe87iIi0LRVhSTZ1Rvkwgn5N2hWzc9XAd0qLI7/2HUSSa+qM8oOBh4EjfGdJc9XAD4C7tEteJDupCEuBqTPK2wHfITi5a0fPcdLRHODLpcWR93wHkdSYOqM8H7iBoFWs0HOcdPQi8M3werUikqVUhKXQ1Bnl+wO/AU7ynSVNrCE4w/oDpcWROt9hJPWmzigfTHCOvbGeo6SL5cD1pcWRJ30HEZHkUxHmwdQZ5WcCdwP7+87iyVbgV8CPS4sjFb7DiF9TZ5Qb8BWCVrFBnuP4Uk+wTtyuU0+I5A4VYZ5MnVHeHvg6MB4Y4DlOKj0FfK+0OPKR7yCSXsKjir8B3Az09hwnVeqBPwETSosj832HEZHUUhHmWdhf7GLgu8Awz3GSpR6YCtxTWhx53XcYSW9TZ5R3ITi9y01Akec4yVID/AH4qX6QiOQuFWFpItwlczYQA0Z7jtNW1hH09/lNaXHkE99hJLNMnVHeCbgMuBIY6TdNm9kCTCY44lEX3RbJcSrC0tDUGeXHE/SROQfo4TnO7niPoH/Lo6XFkS2+w0jmmzqjfBTwNeDLQHfPcXbHm8DvgT+VFkd0aTMRAVSEpbWw39jJwAXAWUBnv4l26mOCyzU9WVocmek7jGSnqTPKCwnOun858DmgwG+inXof+DPwuE6/IiLNURGWIcJdM6cTXCT8WGBfv4loAGYQnOE+Xlocme05j+SYqTPKuwInEPxQOQkY7DcRlcB/gWnAi6XFkbc95xGRNKciLENNnVHej6AYa7yNJLmtAh8BsxJvuoyKpJPwnGMnAUcDI4ADSe6JYNcBrwOvEhReb5UWR+qTuDwRyTIqwrJE2FJ2IEFrwP7AfkB/oF/4tzNBkZYPWJOn1xFcNLu8yW0Fwdns31I/Fsk0U2eU5xG0GI8Ib8OBvkCf8NaD5q9gUQtUEXSi30KwbnyQcHsf+KC0OLIuyS9BRLKcirAcFG6cCvisKNuka9NJLgovn9QF6EBwrcYtunqDiKSKijARERERD/J8BxARERHJRSrCRERERDxQESYiIiLigYowEREREQ9UhImIiIh4oCJMRERExAMVYSIiIiIeqAgTERER8UBFmIiIiIgHKsJEREREPFARlkHMrMzM3jWz2WY2s8m4m8zMmVnv8PGxZjbHzN40s/3DYXuZ2Ytm1vQC3iJZo7n1xMx+bmYLwnViqpntFQ7XeiIi3qgIyzyfd86NdM4d0TjAzAYCXwQ+SZhuPHAucAtwbTjs+8AEpwuGSvZrup78AzjIOXcIsAi4ORyu9UREvFERlh1+AXwXSNxo1AKFQCeg1swGA/2dc9M85BPxyjn3knOuLnw4AxgQ3td6IiLeFPgOILvEAS+ZmQMmO+ceMLMzgWXOuXea7D2ZCDwAVAGXAHcR/MIXyXbbrSdNxn8V+HN4X+uJiHijIiyzHOucW25mRcA/zGwBcCtwUtMJnXOzgWIAMzseWB7ctT8T/Pof75wrT110kZTZbj1xzk0HMLNbgTrgMdB6IiJ+mbo9ZCYzuwOoB74FbAkHDyDYiIx2zq0MpzPgReB84NfAnUAU+Jxz7tbUphZJrXA92eScu8vMLgWuAb7gnNvSZDqtJyKScuoTliHMrLOZdW28T9D69aZzrsg5F3XORYGlwOGNBVjoUiDunFtP0O+lIbx1SukLEEmBHawnc83sFOB7wJlNC7CQ1hMRSTntjswcEWBq2O+rAPijc+6FnT3BzDoRbFwad1feAzwNbAUuTF5UEW+aXU/M7AOgA8HuSYAZzrlrQOuJiPij3ZEiIiIiHmh3pIiIiIgHKsJEREREPFARJiIiIuKBijARERERD1SEiYiIiHigIkxERETEAxVhIiIiIh6oCBMRERHxQEWYiIiIiAcqwkREREQ8UBEmIiIi4oGKMBEREREPVISJiIiIeKAiTERERMQDFWEiIiIiHqgIExEREfFARZiIiIiIByrCRERERDxQESYiIiLigYowEREREQ9UhImIiIh4oCJMRERExAMVYSIiIiIeqAgTERER8UBFmIiIiIgHKsJEREREPFARJiIiIuKBijARERERD1SEiYiIiHigIkwkTZnZpoRbg5lVJTy+yHe+3WFmZWZ2ou8csuf0WYrsuQLfAUSkec65Lo33zawMuMI597K/RDtnZgXOubpMX8auSLc8kJ6ZmsqEjCKpoJYwkQxjZnlmFjOzD81srZk9YWY9w3FRM3NmdrmZLTGz9WZ2jZkdaWZzzGyDmf06YV6Xmdl/zez/zKzCzBaY2RcSxnc3s4fMbIWZLTOzH5tZfpPn/sLM1gF3mNlgM/tnmGuNmT1mZnuF0z8CDAKeC1vzvmtmY81saZPX92kLi5ndYWZPmdmjZrYRuGxnmZp5r0ab2Uwz22hm5WZ2T8K448zstfA9WWJmlyW85v9nZqvNbLGZ3WZmeTt5zR3M7C4z+yRcxv1mVhhO39vMng+Xsc7M/t04r2ayOjO7zsw+Ct+7nydOa2ZfNbP54Wf6opnt0+S53zCz94H3m5l3x/A9XBtmedPMIi19xuH4K8PlVprZPDM7vLnPMpz2TDN7L1zGq2Z2YJPP9XtmNgfYbGZqBBBxzummm25pfgPKgBPD+9cDM4ABQAdgMvCncFwUcMD9QEfgJKAaeBYoAvoDq4Ax4fSXAXXADUA74HygAugZjn82nH/n8Pn/A65u8txvEbSqFwL7A18Mc/UBpgP3Nvc6wsdjgaU7ea13ALXA2QQ/Ggt3lqmZ9+114JLwfhegOLw/CKgELgxfdy9gZDju/wF/AbqG7+ci4Gs7ec33An8FeobPeQ6YGE4/Mfws2oW3zwG2g6wO+Fc4n0Hhcq8Ix50NfAAcGC73NuC1Js/9R/jcwmbmfXWYqxOQD4wCurXiM/4SsAw4ErDw891nB5/lUGBz+Pm3A74bZm6fMP1sYGBzGXXTLRdv3gPopptuLd+aFCbzgS8kjOsbFioFfFaE9U8YvxY4P+Hx08D14f3LgOWJhUG4Eb4EiAA1iRvMsGj5V8JzP2kh99nA2829jvDxWFouwqYnjNtppmaWPx34IdC7yfCbganNTJ8fzn94wrCrgVebe81hYbIZGJww7Gjg4/D+jwgKuv1b8Rk74JSEx18HXgnv/52wEAwf5wFbEgoiB5ywk3l/FXgNOKTJ8JY+4xeBb7f0nQwffx94oknGZcDYhOm/6ntd0k23dLqpOVgk8+wDTDWzhoRh9QQb1EblCfermnncJeHxMuecS3i8GOgXLqcdsMLMGsflAUsSpk28j5kVAb8iaPHpGk6/vlWvascSl9GaTIm+RlAILTCzj4EfOueeJ2iN+bCZ6XsD7Qneg0aLCVoQm8vTh6B1aVZCHiMo5gB+TlBIvhSOf8A5N2kHWZvOu/FzgOB1/9LM7k4Yb2Guxc08t6lHCF7z4+Hu4UeBW2n5/dzR+9ScfglZcM41mNkSdvzeieQ89QkTyTxLgFOdc3sl3Do655bt5vz6W8IWmGBX2PJwOTUErUiNy+nmnBuRMG1i8QbB7jdH0OLSDbiYoFjY0fSbCYoYAMK+SH2aTJP4nNZk+uyJzr3vnLuQYDfbT4GnzKxzOJ/BzTxlDUGr4j4JwwYRtOg0l2cNQVE7IiFPdxceVOGcq3TOjXfO7QecAdyY2OeuGQObLHd5wuu+uslnXuice20HubbhnKt1zv3QOTccOAY4HfgKLb+fO3qfmlvechLet/A7NZAdv3ciOU9FmEjmuR/4SWPHbDPrY2Zn7cH8ioDrzKydmX2JoN/R35xzK4CXgLvNrJsFBwQMNrMxO5lXV2ATsMHM+gPfaTK+HNgv4fEioKOZlZhZO4K+Th12NPNdzWRmF5tZH+dcA7AhHFwPPAacaGbjzKzAzHqZ2UjnXD3wBMH72zV8j28kaDlqLk8D8DvgF2ErIGbW38xODu+fbmb7hwXJxnDZ9Tt6fcB3zKyHmQ0Evg38ORx+P3CzmY0I59s9/Kxaxcw+b2YHh0XuRoJCs74V7+eDwE1mNsoC+yccEND0s3wCKDGzL4Sf5XiCAi+xUBSRBCrCRDLPLwk6gr9kZpUEnfSP2oP5vQEMIWjV+QlwnnNubTjuKwS75+YR7FZ8iqAP2o78EDicoHN/HHimyfiJwG3h0XM3OecqCPo+PUjQYrIZWMrO7UqmU4D3zGwTwft2gXOu2jn3CXAaQaGwjqDD+KHhc74V5vgI+A/wR+DhneT5HkEH9BkWHMH5MnBAOG5I+HgTwUEC9znnXt3JvP4CzArzxIGHAJxzUwla8h4PlzEXOHUn82lqb4L3aSNBn8JpfFZY7vD9dM49SfCd+CPBgQzPEnT+h+0/y4UELZ//R/BdOgM4wzm3dRdyiuQU27YriIjkEgtOy3CFc+4431lynZk5YIhz7gPfWUQkNdQSJiIiIuKBijARERERD7Q7UkRERMQDtYSJiIiIeJBxJ2vt3bu3i0ajvmOIiIiItGjWrFlrnHNNz38IZGARFo1GmTlzpu8YIiIiIi0ys8U7GqfdkSIiIiIeqAgTERER8UBFmIiIiIgHKsJEREREPFARJiIiIuKBijARERERD1SEiYiIiHiQcecJS5VoLO47gkhOK5tU4juCiEhSqSVMRERExAMVYSIiIiIeqAgTERER8UBFmIiIiIgHKsJEREREPFARJiIiIuKBijARERERD1SEiYiIiHigIkxERETEAxVhIiIiIh6oCBMRERHxQNeOFBHxQNenFfHP9zVq1RImIiIi4oGKMBEREREPVISJiIiIeKAiTERERMQDFWEiIiIiHqgIExEREfFARZiIiIiIByrCRERERDxQESYiIiLiQdKKMDMbaGb/MrP5ZvaemX27mWnMzH5lZh+Y2RwzOzxZeURERETSSTIvW1QHjHfOvWVmXYFZZvYP59y8hGlOBYaEt6OA34Z/RURERLJa0lrCnHMrnHNvhfcrgflA/yaTnQX8PxeYAexlZn2TlUlEREQkXaSkT5iZRYHDgDeajOoPLEl4vJTtCzXM7Cozm2lmM1evXp2smCIiIiIpk/QizMy6AE8D1zvnNjYd3cxT3HYDnHvAOXeEc+6IPn36JCOmiIiISEoltQgzs3YEBdhjzrlnmplkKTAw4fEAYHkyM4mIiIikg2QeHWnAQ8B859w9O5jsr8BXwqMki4EK59yKZGUSERERSRfJPDryWOAS4F0zmx0OuwUYBOCcux/4G3Aa8AGwBbg8iXlERERE0kbSijDn3H9ovs9X4jQO+EayMoiIiIikK50xX0RERMQDFWEiIiIiHqgIExEREfFARZiIiIiIByrCRERERDxQESYiIiLigYowEREREQ9UhImIiIh40KoizMwKzeyAZIcRERERyRUtFmFmdgYwG3ghfDzSzP6a7GAiIiIi2aw1LWF3AKOBDQDOudlANHmRRERERLJfa4qwOudcRdKTiIiIiOSQ1lzAe66ZfRnIN7MhwHXAa8mNJSIiIpLdWtMS9i1gBFAD/BGoAK5PZigRERGRbLfTljAzywf+6pw7Ebg1NZFEREREst9OW8Kcc/XAFjPrnqI8IiIiIjmhNX3CqoF3zewfwObGgc6565KWSkRERCTLtaYIi4c3EREREWkjLRZhzrk/mFl7YGg4aKFzrja5sURERESyW4tFmJmNBf4AlAEGDDSzS51z05MbTURERCR7tWZ35N3ASc65hQBmNhT4EzAqmcFEREREsllrzhPWrrEAA3DOLQLaJS+SiIiISPZrTUvYTDN7CHgkfHwRMCt5kURERESyX2uKsGuBbxBcrsiA6cB9yQwlIiIiku1aU4QVAL90zt0Dn55Fv0NSU4mIiIhkudb0CXsFKEx4XAi8nJw4IiIiIrmhNUVYR+fcpsYH4f1OyYskIiIikv1aU4RtNrPDGx+Y2SigKnmRRERERLJfa/qEXQ88aWbLw8d9gfOTF0lEREQk+7XmskVvmtkw4ACCoyMXtOayRWb2MHA6sMo5d1Az48cCfwE+Dgc945z70S5kFxEREclYLe6ONLMvEfQLmwucBfw5cffkTkwBTmlhmn8750aGNxVgIiIikjNaszvy+865J83sOOBk4C7gt8BRO3uSc266mUX3OGETCxcuZOzYsdsMGzduHF//+tfZsmULp5122nbPueyyy7jssstYs2YN55133nbjr732Ws4//3yWLFnCJZdcAsDKj9Z+Or7b6FI67X8UtWuXsvbFX2/3/O7HXEBhdCRbyz9i3SsPbDd+r+MvpeOAA6leOp8N0/+w3fieX7iK9pH9qCqbTcVrj283vtfJ36RdrwFs+eANNv5v6nbje58+noJufdg8fzqVb/9tu/F9zr6Z/E7d2fTuy2x6d/sDW4u+dAd57TpS+VaczQv+vd34vb88CYCKN56h6sP/bTPOCjoQGfdDADb8909UL35nm/H5hd3oU3oLAOunTaFm2YJtxhd07U3vM24CYN3LD7B11UfbjG/Xsz+9TvkWAGtf+D9q1y3bZnz7ov3oeeJVAKx57i7qKtdsM75D/2H0GHMZAKunTqC+auM24zvucyh7HXshAOVP3I6rq9lmfOHg0XQ/6hwAVv4xRlOdh32OroeX0FBbzaon79hufJeDT6TLwSdSv6WC1c9O3G5818NOo/OBx1O3cTVrnr97u/G5/N0bO+PnvPrqqwDcddddPP/889uMLyws5O9//zsAd955J6+88sq22Xv14umnnwbg5ptv5vXXX99m/IABA3j00UcBuP7665k9e/Y244cOHcoDDwTv6VVXXcWiRYu2GT9y5EjuvfdeAC6++GKWLl26zfijjz6aiRODz/zcc89l7dq124zfUD9A3700/e6B/u/lyndv7Nifbzd+8uTJHHDAATz33HPcfff2+R555BEGDhzIn//8Z377299uN/6pp56id+/eTJkyhSlTpmw3PlFrOubXh39LgN865/4CtG/F81rjaDN7x8z+bmYjdjSRmV1lZjPNbGZtbYt7QkVERETSnjnndj6B2fPAMuBEgot2VwH/c84d2uLMg5aw53fQJ6wb0OCc22RmpxGcEHZIS/M84ogj3MyZM1uabI9FY/GkL0NEdqxsUonvCEml/zEi/qXi/4yZzXLOHdHcuNa0hI0DXgROcc5tAHoC39nTUM65jY3nH3PO/Q1oZ2a993S+IiIiIpmgNUdHbgGeSXi8Alixpws2s72BcuecM7PRBAXh2haeJiIiIpIVWtMxf7eY2Z+AsUBvM1sK3A60A3DO3Q+cB1xrZnUEuzgvcC3tGxURERHJEkkrwpxzF7Yw/tfA9oc9iIiIiOSA1vQJw8z2MbMTw/uFZtY1ubFEREREsltrTtZ6JfAUMDkcNAB4NpmhRERERLJda1rCvgEcC2wEcM69DxQlM5SIiIhItmtNEVbjnNva+MDMCgB1oBcRERHZA60pwqaZ2S1AoZl9EXgSeC65sURERESyW2uKsO8Bq4F3gauBvwG3JTOUiIiISLbb6SkqzCwPmBNeduh3qYkkIiIikv122hLmnGsA3jGzQSnKIyIiIpITWnOy1r7Ae2b2P2Bz40Dn3JlJSyUiIiKS5VpThP0w6SlEREREckxrLuA9LRVBRERERHJJi0WYmVXy2XnB2hNchHuzc65bMoOJiIiIZLPWtIRtc51IMzsbGJ20RCIiIiI5oFUX8E7knHsWOCEJWURERERyRmt2R56T8DAPOAJdtkhERERkj7Tm6MgzEu7XAWXAWUlJIyIiIpIjWlOEPeic+2/iADM7FliVnEgiIiIi2a81fcL+r5XDRERERKSVdtgSZmZHA8cAfczsxoRR3YD8ZAcTERERyWY72x3ZHugSTpN4moqNwHnJDCUiIiKS7XZYhIVnyp9mZlOcc4tTmElEREQk67WmY/4WM/s5MALo2DjQOadzhYmIiIjsptZ0zH8MWADsS3Ax7zLgzSRmEhEREcl6rSnCz6rNxgAAExtJREFUejnnHgJqnXPTnHNfBYqTnEtEREQkq7Vmd2Rt+HeFmZUAy4EByYskIiIikv1aU4T92My6A+MJzg/WDbghqalEREREstxOizAzyweGOOeeByqAz6ck1f9v786D7CrLPI5/fwYUlRkUiAQiMIKMiuLCoCzlwqIICEQEWXS0ZBRkBJXCFbCMCwqIjsoacWBYXBjcIGIYxGVccEQwA4giGBiEyCKLsoeQ5Jk/zunyGkNygb59+nZ/P1Wp7rPc7scq6/Dr933P80qSJE1wy10TVlWLgV3HqBZJkqRJo5/pyJ8lOR74T+C+kZNVNXdgVUmSJE1w/YSwrdqvH+s5V8By+4QlORXYGfhjVT1vGdcDfB7YCbgfeIvBTpIkTRYrDGFV9WjXgZ0GHA+c8TDXdwQ2av9tDpzUfpUkSZrwVtgnLMlaSU5Jcn57vHGSt67oc1X1Y+DO5dwyAzijGj8HnpJk7X4LlyRJGmb9NGs9DbgAWKc9vgY4eBR+93Tgxp7j+e25v5Fk/ySXJrn0tttuG4VfLUmS1K1+QtiaVXU2sASgqhYBi0fhd2cZ52pZN1bVyVW1WVVtNnXq1FH41ZIkSd3qJ4Tdl2QN2oCUZAuanmGP1Xxg3Z7jp9N045ckSZrw+nk78hBgNrBhkouAqcAeo/C7ZwMHJTmLZkH+XVV18yj8XEmSpHGvn7cj5yZ5BfAsminEq6vqoRV8jCRfBbYG1kwyH5gJrNz+zFnAHJr2FPNoWlTs+yj/N0iSJA2dFYawJKsA7wBeSjMl+ZMks6pqwfI+V1X7rOB6AQc+glolSZImjH6mI88A7qHZvBtgH+BM4PWDKkqSJGmi6yeEPauqXtBz/MMklw+qIEmSpMmgn7cj/7d9IxKAJJsDFw2uJEmSpImvn5GwzYE3J7mhPV4PuCrJr2iWdj1/YNVJkiRNUP2EsB0GXoUkSdIk00+Lit8neSpNY9WVes7PHWRhkiRJE1k/LSo+DrwFuJa/bCtUwLaDK0uSJGli62c6ck9gw6paOOhiJEmSJot+3o68EnjKoAuRJEmaTPoZCTuSpk3FlcCDIyerateBVSVJkjTB9RPCTgeOBn4FLBlsOZIkSZNDPyHs9qo6duCVSJIkTSL9hLBfJjkSmM1fT0faokKSJOlR6ieEvaj9ukXPOVtUSJIkPQb9NGvdZiwKkSRJmkxW2KIiyVpJTklyfnu8cZK3Dr40SZKkiaufPmGnARcA67TH1wAHD6ogSZKkyeBhQ1iSkanKNavqbNr2FFW1CFg8BrVJkiRNWMsbCftF+/W+JGvQ7huZZAvgrkEXJkmSNJEtb2F+2q+H0LSn2DDJRcBUYI9BFyZJkjSRLS+ETU1ySPv9t4A5NMHsQeCVwBUDrk2SJGnCWl4ImwKsyl9GxEY8aXDlSJIkTQ7LC2E3V9XHxqwSSZKkSWR5C/OXHgGTJEnSKFleCNtuzKqQJEmaZB42hFXVnWNZiCRJ0mTST8d8SZIkjTJDmCRJUgcGGsKS7JDk6iTzknxwGde3TnJXksvafx8eZD2SJEnjxfJaVDwmSaYAJwCvAuYDlySZXVW/WerWn1TVzoOqQ5IkaTwa5EjYS4B5VXVdVS0EzgJmDPD3SZIkDY1BhrDpwI09x/Pbc0vbMsnlSc5P8twB1iNJkjRuDGw6kmU3e62ljucC61fVvUl2As4BNvqbH5TsD+wPsN566412nZIkSWNukCNh84F1e46fDtzUe0NV3V1V97bfzwFWTrLm0j+oqk6uqs2qarOpU6cOsGRJkqSxMcgQdgmwUZJnJHk8sDcwu/eGJNOSpP3+JW09dwywJkmSpHFhYNORVbUoyUHABcAU4NSq+nWSA9rrs4A9gH9Nsgh4ANi7qpaespQkSZpwBrkmbGSKcc5S52b1fH88cPwga5AkSRqP7JgvSZLUAUOYJElSBwxhkiRJHTCESZIkdcAQJkmS1AFDmCRJUgcMYZIkSR0whEmSJHXAECZJktQBQ5gkSVIHDGGSJEkdMIRJkiR1wBAmSZLUAUOYJElSBwxhkiRJHTCESZIkdcAQJkmS1AFDmCRJUgcMYZIkSR0whEmSJHXAECZJktQBQ5gkSVIHDGGSJEkdMIRJkiR1wBAmSZLUAUOYJElSBwxhkiRJHTCESZIkdcAQJkmS1IGBhrAkOyS5Osm8JB9cxvUkOba9fkWSTQdZjyRJ0ngxsBCWZApwArAjsDGwT5KNl7ptR2Cj9t/+wEmDqkeSJGk8GeRI2EuAeVV1XVUtBM4CZix1zwzgjGr8HHhKkrUHWJMkSdK4sNIAf/Z04Mae4/nA5n3cMx24ufemJPvTjJQB3Jvk6tEtVRPQmsDtXRehRy9Hd12BtEI+Z4bcGD1n1n+4C4MMYVnGuXoU91BVJwMnj0ZRmhySXFpVm3Vdh6SJy+eMHqtBTkfOB9btOX46cNOjuEeSJGnCGWQIuwTYKMkzkjwe2BuYvdQ9s4E3t29JbgHcVVU3L/2DJEmSJpqBTUdW1aIkBwEXAFOAU6vq10kOaK/PAuYAOwHzgPuBfQdVjyYdp68lDZrPGT0mqfqbJViSJEkaMDvmS5IkdcAQJkmS1AFDmCRJUgcMYRpK7Ru3kiQNLUOYhk6STYC3JpnedS2SJqYkab/630kNjP/n0jBaB3glsFOSdbouRtLEkiRVVUl2BU5y5F2DMshti6RRNfJgrKoLkhTwZmBKktlV5U4LkkZFG8B2Aj4KvK+qFo48f7quTROLI2EaCks/AKvqu8CxwMuBXR0RkzRa2qnIbYDDgCvbEbGvJNk+yRNGpiqlx8pmrRoq7Y4LG9PssPBFYE3gIOAnwJyqmt9heZKG1NJ/6CU5FHgJsAbNzi8b0Mwe7VdVC7upUhON05EaGkkOBHYDDgU+C0ypqvcleTJwMLAoyelVtbjLOiUNl541YDvQ/JFXwKeAlwI3VdXvkvwjcBowDbihs2I1oRjCNEzWAHYF3gbcAxye5AlV9YMkDwC/N4BJeqTaALY9cCTwduB8YM2qOhygnY78JHBYVRnANGoMYRqXHmYR7DTgUuCqqtqxve+AJPdX1RljXqSkoZVkLeCJVXV9u8ZrBvAWmufM1cCsntunAwdX1fdcoK/RZAjTuNP7kEuyG/AgcBtwFLAJTRAjyb7Au2kenpLUlyRPoBlV/1GSVapqQZI7aEbBng28papuTPLPwIKqOmnkswYwjSYX5mvcSnIIsAvwbWBP4Ajgj8AJwP8B6wJvrarfdFakpKHUriV9Ik0biqOBZ9E8a3apqguTbAacDhxUVT/srlJNZIYwjRs9i2ND05D12KraPcnHgBcCM9rrU2genitV1Z+7rFnS8EjyRGDdqromyfo0i/BfTvM8mUkzOvY+YC7wXODjVTW7q3o18RnCNC4k+buquqf9fm3gduAs4CZgfWDPdspgH+Diqrquu2olDaN2y7OdgacCmwL7AGsDuwOrAx8CVqUJZStX1VWuAdMg2axVnUuyGrBvkn2T7A+cWlUPAdcBOwDvbAPYvwAfoOkRJkl9SbJBkm1oFtyvCxwI/LSqbquqK4Bzaf7w+zTwlKqaV1VXgWvANFguzFenkrwG2AL4JvA9YAHNX6gAXwYWAucm+S6wI7B3Vd3SRa2Shtb6wAPAIpq3Hu8DVk+yd1WdVVVz26nKrWl6hEljwulIdSbJzsAnaBbcf4tmKmAv4AtV9bme+7aneTBe6zSkpH4leSZNG4pfJVkduAg4tKrOaUfdNwe+BlxP88fgnKr6Y2cFa9JxJEydSDINeA/wtqq6pD39kSTnAWcnWVxVxyXZA/htVV3ZWbGShtW2wKwkm1bVZUlmAjPb58vJSZYA+wMvA95gANNYM4SpKw8CDwEL2mmAD9BsmHsrMJ+mG/7zaNaEbd9ZlZKGTpJ/AO5pg9ZKwA+SbFdVZydZCHwyyZKq+vck3wGeVlWXd1mzJidDmLryZ5pNcT9N8yr494Azgato3l76MvAH4Miqur6jGiUNpz2B/05yV1WdmGRl4PttEDsnSQHHJ1mtqr4C3NxtuZqsDGHqRNvv6wvAz2jeVjq3qh4ESLIfMLeqzuuyRknDqao+lWRN4JIkr6mqzzftB/l+km2r6twkj6N5I1LqjAvzNa4keT3wQZq+YNd2XY+k4ZBkVWDtqvpdki2Bi4ETgecBe1TVLUkOAj4LbF5Vc9vP2QdMnXEkTONC26B1L2A/YC8DmKR+tbtsrAacmOSXNPvJ7l5VByQ5jqbNzYyqOr6dmlxj5LMGMHXJkTCNC+3i/G2Bq6tqXtf1SBoO7ZvW21TVV5O8HTiWZruhI3ruORbYDnhlVd3cnnMETJ0zhEmShlbbb/DtwNnAHcBUmp6Dh1XV13ru+wRwflX9tJNCpWVwOlKSNLSq6rx2inEG8MOqOj3JLcBJSe6maYXzRpqehI46aFwxhEmShkqS6cD6VfUzgKr6Vvu24+uS0Aaxg4FDaf479zkDmMYjQ5gkaWi0i/C3A/ZLcnhV/Rigqr7RdsB/Q5Jrqmp2kkvaaze7BkzjkWvCJElDJckawG7Aa4FjqupHPdcOo9kT8nVVtbijEqW+OBImSRoqVXVHkm8CjwPe205BjgSxnwHTgCWdFSj1yRAmSRo6VXVnkq/ThK2ZSU4BbgI+A3zYqUcNA6cjJUlDoW3qfDdw/0jISvJ44NXAO2n2m/1G+8aka8A07hnCJEnjXhvAPg28t11o/7iqWtJzfWVgcVUtMYBpWDyu6wIkSVqRttP9QuCI9njJUtcfGjlnANOwMIRJksadtu8XSaYl2ag9/UHg3iRrtdfSVX3SaHBhviRp3EjyJGBRVS1M8k/Au4DFSW4ATgKeA2wPnOmIl4ada8IkSeNGkm2B1wMX0oSt/wBuAY4HfgrsAywA9qqq33dVpzQanI6UJHUuyfR2sf0PgPWBLwHnVNXFbdiaAXwNOAW4H3h6d9VKo8MQJkkaD94PPK9dC/Zz4HzgoCSrQbMQv6quq6rjgLOAQ5K4pEZDzRAmSepcVb2bpgfY6cBRVbU7cCPN6BdJNkiyV3v7bcBqwJQuapVGiyFMktSZkTcck6xaVdfTTDN+qR0ROxC4IckVwGya8AXwIPCuqnqwg5KlUePCfElSJ0aaqiZ5DbAj8P6quj/JecADwJ7t9d2BG6vqF72f67B0aVQYwiRJnUnyUuBkYL+quqjn/DnAKsCOPVsUGb40oTgdKUkaM0nWTbJVz6mtga9W1UVJprTbD1FVrwUeAjYdudEAponGN0skSWOiXef1AuDGJH9fVXcDtwPPGLmlqh5KsgVwa1Xt0lWt0lhwJEySNCbaNhPnAfOAryR5FfBdYIckrwOmJdmUpkHr6h2WKo0J14RJkgauZxH+tjTNWAPsBhwOPB6YSdOEdTrwqaqa3Vmx0hhxOlKSNHBtAHs+zSbch9CMhhVwNHB4Ve2S5KnAalV1vYvwNRkYwiRJA9EbpJJsCOxPs9bryvbcucAS4N+SHFNV3wH+BC7C1+TgmjBJ0qhLsgqwZfv9M4EXAncAayfZCaCq7gTOo+mSf2tHpUqdcU2YJGnUJZkO7AK8CtgE2ApYDLyDZsuhC6vqwvbelapqUVe1Sl1xJEySNOqq6g80fb52Ay6uqtur6k/AmcCdwC49I2IGME1KhjBJ0qjp2QvyOTSbb78JuDrJUUmmVdUNwByaqclru6tU6p7TkZKkUZVkB5qtiHatqsuSvALYGVgAzKXpgj+rHS2TJi1HwiRJoybJesBRwBur6jKAqvoR8O32lmOASwxgkiNhkqRR0NOMdX3gM1W1R3t+lapakGTldkuiaVV1i33AJEfCJEmPwcgaMODJ7debgHWSvAegDWCvAj7b7h15a3veAKZJz2atkqRHpWf069XAO5JcAswH3g3MTLIB8EPgQ8DMqlrSYbnSuON0pCTpUUvyMuBE4G3AQcATgH2BpwGHArcA/1NV5zsFKf01Q5gkqW9tE9apwBVVtSTJ62m2GroPOA7Yvap+n2RqVd3W8zkDmLQU14RJkh6J1wLHAi9qj+8HTgNOArZvA9irgXcmGVkn5howaRkMYZKkFUqyQZK9q+oE4LvAR5JsBvwI+DpweXvfy4DPAL+oqvs6K1gaAoYwSdJyJXkW8M2R46o6ArgImAk8m2YD7uuB/6JZhH9YVZ3X8+akpGVwTZgk6WEl2Zhm4f2ZVXVKkpWBTapqbpKZwAuAT1TVL5OsClBV97oGTFoxR8IkScvUBq7ZwD1tAJtCM9r1CoCq+ijNNkTHJHlxVd1bVfe21wxg0grYJ0yStExth/t9gO8kORDYCrisqj7bc88RSRZ0VqQ0xJyOlCQtV7sA/0Lgt1W1Zc/5LYAXVtWszoqThpjTkZKk5aqqS4GtgWcn2Q8gyVbAF4F5HZYmDTVHwiRJfWlHxOYAXwM2AY6uqu90W5U0vAxhkqS+JXkx8APgTVV1Ttf1SMPMECZJekSSrGobCumxc02YJOmRshO+NAocCZMkSeqAI2GSJEkdMIRJkiR1wBAmSZLUAUOYJElSBwxhkiRJHfh/2tkPV/JI0TkAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -772,133 +696,133 @@ " \n", " \n", " \n", + " 0\n", + " Duke Energy Corp.\n", + " US26441C2044\n", + " Electricity Utilities\n", + " 37.33\n", + " 30.09\n", + " 0.11\n", + " 13.11\n", + " \n", + " \n", + " 1\n", + " Southern Co.\n", + " US8425871071\n", + " Electricity Utilities\n", + " 19.98\n", + " 23.40\n", + " 0.09\n", + " 9.02\n", + " \n", + " \n", " 2\n", - " Company J\n", - " BR0000000010\n", - " Steel\n", - " 4.39\n", - " 3.20\n", - " 0.83\n", - " 3.08\n", + " American Electric Power Co., Inc.\n", + " US0255371017\n", + " Electricity Utilities\n", + " 10.41\n", + " 13.47\n", + " 0.10\n", + " 8.17\n", " \n", " \n", " 3\n", - " Company I\n", - " CN0000000009\n", - " Steel\n", - " 4.39\n", - " 3.20\n", - " 0.33\n", - " 3.08\n", + " Dominion Energy\n", + " US25746U1097\n", + " Electricity Utilities\n", + " 7.04\n", + " 12.37\n", + " 0.05\n", + " 6.01\n", " \n", " \n", " 4\n", - " Company F\n", - " NL0000000006\n", - " Steel\n", - " 4.39\n", - " 3.20\n", - " 0.11\n", - " 3.08\n", + " Evergy, Inc.\n", + " US30034W1062\n", + " Electricity Utilities\n", + " 3.68\n", + " 11.88\n", + " 0.13\n", + " 3.27\n", " \n", " \n", " 5\n", - " Company A\n", - " JP0000000001\n", - " Steel\n", - " 4.39\n", - " 3.20\n", - " 1.07\n", - " 3.08\n", + " Xcel Energy, Inc.\n", + " US98389B1008\n", + " Electricity Utilities\n", + " 3.13\n", + " 6.72\n", + " 0.09\n", + " 4.93\n", " \n", " \n", " 6\n", - " Company AW\n", - " US7134481081\n", - " Steel\n", - " 4.39\n", - " 3.20\n", - " 0.10\n", - " 3.08\n", + " PPL\n", + " US69351T1060\n", + " Electricity Utilities\n", + " 2.05\n", + " 6.65\n", + " 0.08\n", + " 3.26\n", " \n", " \n", " 7\n", - " Company M\n", - " AR0000000013\n", - " Steel\n", - " 4.39\n", - " 3.20\n", - " 1.07\n", - " 3.08\n", + " Ameren Corp.\n", + " US0236081024\n", + " Electricity Utilities\n", + " 1.64\n", + " 6.07\n", + " 0.09\n", + " 2.86\n", " \n", " \n", - " 18\n", - " Company L\n", - " BR0000000012\n", - " Steel\n", - " 2.58\n", - " 1.88\n", + " 8\n", + " Entergy Corp.\n", + " US29364G1031\n", + " Electricity Utilities\n", + " 1.62\n", + " 3.20\n", " 0.15\n", - " 3.08\n", + " 5.35\n", " \n", " \n", - " 19\n", - " Company H\n", - " CN0000000008\n", - " Steel\n", - " 2.52\n", - " 1.84\n", - " 0.18\n", - " 3.08\n", - " \n", - " \n", - " 20\n", - " Company E\n", - " SE0000000005\n", - " Steel\n", - " 2.48\n", - " 1.81\n", - " 3.39\n", - " 3.08\n", - " \n", - " \n", - " 21\n", - " Company G\n", - " CN0000000007\n", - " Steel\n", - " 2.44\n", - " 1.78\n", - " 0.05\n", - " 3.08\n", + " 9\n", + " FirstEnergy Corp.\n", + " US3379321074\n", + " Electricity Utilities\n", + " 1.49\n", + " 3.22\n", + " 0.12\n", + " 4.89\n", " \n", " \n", "\n", "" ], "text/plain": [ - " company_name company_id sector contribution temperature_score \\\n", - "2 Company J BR0000000010 Steel 4.39 3.20 \n", - "3 Company I CN0000000009 Steel 4.39 3.20 \n", - "4 Company F NL0000000006 Steel 4.39 3.20 \n", - "5 Company A JP0000000001 Steel 4.39 3.20 \n", - "6 Company AW US7134481081 Steel 4.39 3.20 \n", - "7 Company M AR0000000013 Steel 4.39 3.20 \n", - "18 Company L BR0000000012 Steel 2.58 1.88 \n", - "19 Company H CN0000000008 Steel 2.52 1.84 \n", - "20 Company E SE0000000005 Steel 2.48 1.81 \n", - "21 Company G CN0000000007 Steel 2.44 1.78 \n", + " company_name company_id sector \\\n", + "0 Duke Energy Corp. US26441C2044 Electricity Utilities \n", + "1 Southern Co. US8425871071 Electricity Utilities \n", + "2 American Electric Power Co., Inc. US0255371017 Electricity Utilities \n", + "3 Dominion Energy US25746U1097 Electricity Utilities \n", + "4 Evergy, Inc. US30034W1062 Electricity Utilities \n", + "5 Xcel Energy, Inc. US98389B1008 Electricity Utilities \n", + "6 PPL US69351T1060 Electricity Utilities \n", + "7 Ameren Corp. US0236081024 Electricity Utilities \n", + "8 Entergy Corp. US29364G1031 Electricity Utilities \n", + "9 FirstEnergy Corp. US3379321074 Electricity Utilities \n", "\n", - " ownership_percentage portfolio_percentage \n", - "2 0.83 3.08 \n", - "3 0.33 3.08 \n", - "4 0.11 3.08 \n", - "5 1.07 3.08 \n", - "6 0.10 3.08 \n", - "7 1.07 3.08 \n", - "18 0.15 3.08 \n", - "19 0.18 3.08 \n", - "20 3.39 3.08 \n", - "21 0.05 3.08 " + " contribution temperature_score ownership_percentage portfolio_percentage \n", + "0 37.33 30.09 0.11 13.11 \n", + "1 19.98 23.40 0.09 9.02 \n", + "2 10.41 13.47 0.10 8.17 \n", + "3 7.04 12.37 0.05 6.01 \n", + "4 3.68 11.88 0.13 3.27 \n", + "5 3.13 6.72 0.09 4.93 \n", + "6 2.05 6.65 0.08 3.26 \n", + "7 1.64 6.07 0.09 2.86 \n", + "8 1.62 3.20 0.15 5.35 \n", + "9 1.49 3.22 0.12 4.89 " ] }, "execution_count": 18, @@ -908,7 +832,7 @@ ], "source": [ "sector_contributions = company_contributions[['company_name', 'company_id', 'sector', 'contribution', 'temperature_score', 'ownership_percentage', 'portfolio_percentage']]\n", - "sector_contributions.loc[sector_contributions['sector'] == 'Steel'][:10].round(2)" + "sector_contributions.loc[sector_contributions['sector'] == 'Electricity Utilities'][:10].round(2)" ] }, { @@ -936,11 +860,18 @@ "data_dump_filename = 'data_dump.xlsx'\n", "amended_portfolio.set_index(['company_name', 'company_id']).to_excel(data_dump_filename)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -954,9 +885,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.8" + "version": "3.8.3" } }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +}