`SBTi.temperature_score`

Module Contents

Classes

`ScenarioType`	A scenario defines which scenario should be run.
`EngagementType`	An engagement type defines how the companies will be engaged.
`Scenario`	A scenario defines the action the portfolio holder will take to improve its temperature score.
`TemperatureScore`	This class is provides a temperature score based on the climate goals.

class SBTi.temperature_score.ScenarioType

Bases: enum.Enum

A scenario defines which scenario should be run.

TARGETS = 1

APPROVED_TARGETS = 2

HIGHEST_CONTRIBUTORS = 3

HIGHEST_CONTRIBUTORS_APPROVED = 4

static from_int(value) → Optional[ScenarioType]

class SBTi.temperature_score.EngagementType

Bases: enum.Enum

An engagement type defines how the companies will be engaged.

SET_TARGETS = 1

SET_SBTI_TARGETS = 2

static from_int(value) → EngagementType

Convert an integer to an engagement type.

Parameters: value – The value to convert
Returns

static from_string(value: Optional[str]) → EngagementType

Convert a string to an engagement type.

Parameters: value – The value to convert
Returns

class SBTi.temperature_score.Scenario

A scenario defines the action the portfolio holder will take to improve its temperature score.

scenario_type :Optional[ScenarioType]

engagement_type :EngagementType

get_score_cap(self) → float

get_fallback_score(self, fallback_score: float) → float

static from_dict(scenario_values: dict) → Optional[Scenario]

Convert a dictionary to a scenario. The dictionary should have the following keys:

number: The scenario type as an integer
engagement_type: The engagement type as a string

Parameters: scenario_values – The dictionary to convert
Returns: A scenario object matching the input values or None, if no scenario could be matched

static from_interface(scenario_values: Optional[SBTi.interfaces.ScenarioInterface]) → Optional[Scenario]

Convert a scenario interface to a scenario.

Parameters: scenario_values – The interface model instance to convert
Returns: A scenario object matching the input values or None, if no scenario could be matched

class SBTi.temperature_score.TemperatureScore(time_frames: List[SBTi.interfaces.ETimeFrames], scopes: List[SBTi.interfaces.EScope], fallback_score: float = 3.2, model: int = 4, scenario: Optional[Scenario] = None, aggregation_method: SBTi.portfolio_aggregation.PortfolioAggregationMethod = PortfolioAggregationMethod.WATS, grouping: Optional[List] = None, config: Type[SBTi.configs.TemperatureScoreConfig] = TemperatureScoreConfig)

Bases: SBTi.portfolio_aggregation.PortfolioAggregation

This class is provides a temperature score based on the climate goals.

Parameters

fallback_score – The temp score if a company is not found
model – The regression model to use
config – A class defining the constants that are used throughout this class. This parameter is only required if you’d like to overwrite a constant. This can be done by extending the TemperatureScoreConfig class and overwriting one of the parameters.

get_target_mapping(self, target: pandas.Series) → Optional[str]

Map the target onto an SR15 target (None if not available).

Parameters: target – The target as a row of a dataframe
Returns: The mapped SR15 target

get_annual_reduction_rate(self, target: pandas.Series) → Optional[float]

Get the annual reduction rate (or None if not available).

Parameters: target – The target as a row of a dataframe
Returns: The annual reduction

get_regression(self, target: pandas.Series) → Tuple[Optional[float], Optional[float]]

Get the regression parameter and intercept from the model’s output.

Parameters: target – The target as a row of a dataframe
Returns: The regression parameter and intercept

_merge_regression(self, data: pandas.DataFrame)

Merge the data with the regression parameters from the SBTi model.

Parameters: data – The data to merge
Returns: The data set, amended with the regression parameters

get_score(self, target: pandas.Series) → Tuple[float, float]

Get the temperature score for a certain target based on the annual reduction rate and the regression parameters.

Parameters: target – The target as a row of a data frame
Returns: The temperature score

get_ghc_temperature_score(self, row: pandas.Series, company_data: pandas.DataFrame) → Tuple[float, float]

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.

Parameters

company_data – The original data, grouped by company, time frame and scope category
row – The row to calculate the temperature score for (if the scope of the row isn’t s1s2s3, it will return the original score

Returns

The aggregated temperature score for a company

get_default_score(self, target: pandas.Series) → int

Get the temperature score for a certain target based on the annual reduction rate and the regression parameters.

Parameters: target – The target as a row of a dataframe
Returns: The temperature score

_prepare_data(self, data: pandas.DataFrame)

Prepare the data such that it can be used to calculate the temperature score.

Parameters: data – The original data set as a pandas data frame
Returns: The extended data frame

_calculate_company_score(self, data)

Calculate the combined s1s2s3 scores for all companies.

Parameters: data – The original data set as a pandas data frame
Returns: The data frame, with an updated s1s2s3 temperature score

calculate(self, data: Optional[pandas.DataFrame] = None, data_providers: Optional[List[TemperatureScore.calculate.data]] = None, portfolio: Optional[List[SBTi.interfaces.PortfolioCompany]] = None)

Calculate the temperature for a dataframe of company data. The columns in the data frame should be a combination of IDataProviderTarget and IDataProviderCompany.

Parameters

data – The data set (or None if the data should be retrieved)
data_providers – A list of DataProvider instances. Optional, only required if data is empty.
portfolio – A list of PortfolioCompany models. Optional, only required if data is empty.

Returns

A data frame containing all relevant information for the targets and companies

_get_aggregations(self, data: pandas.DataFrame, total_companies: int) → Tuple[SBTi.interfaces.Aggregation, pandas.Series, pandas.Series]

Get the aggregated score over a certain data set. Also calculate the (relative) contribution of each company

Parameters: data – A data set, containing one row per company
Returns: An aggregated score and the relative and absolute contribution of each company

_get_score_aggregation(self, data: pandas.DataFrame, time_frame: SBTi.interfaces.ETimeFrames, scope: SBTi.interfaces.EScope) → Optional[SBTi.interfaces.ScoreAggregation]

Get a score aggregation for a certain time frame and scope, for the data set as a whole and for the different groupings.

Parameters

data – The whole data set
time_frame – A time frame
scope – A scope

Returns

A score aggregation, containing the aggregations for the whole data set and each individual group

aggregate_scores(self, data: pandas.DataFrame) → SBTi.interfaces.ScoreAggregations

Aggregate scores to create a portfolio score per time_frame (short, mid, long).

Parameters: data – The results of the calculate method
Returns: A weighted temperature score for the portfolio

cap_scores(self, scores: pandas.DataFrame) → pandas.DataFrame

Cap the temperature scores in the input data frame to a certain value, based on the scenario that’s being used. This can either be for the whole data set, or only for the top X contributors.

Parameters: scores – The data set with the temperature scores
Returns: The input data frame, with capped scores

anonymize_data_dump(self, scores: pandas.DataFrame) → pandas.DataFrame

Anonymize the scores by deleting the company IDs, ISIN and renaming the companies.

Parameters: scores – The data set with the temperature scores
Returns: The input data frame, anonymized

SBTi.temperature_score

Module Contents

Classes

`SBTi.temperature_score`