sbti-finance-tool 1.0.8__py3-none-any.whl → 1.1.0__py3-none-any.whl

SBTi/configs.py

@@ -162,7 +162,9 @@ class PortfolioCoverageTVPConfig(PortfolioAggregationConfig):
         "current-Companies-Taking-Action.xlsx",
     )
     # Temporary URL until the SBTi website is updated
-    CTA_FILE_URL = "https://sciencebasedtargets.org/download/target-dashboard"
+    CTA_FILE_URL = "https://sciencebasedtargets.org/resources/files/companies-excel.xlsx"  # Default to per-company
+    CTA_FILE_URL_PER_COMPANY = "https://files.sciencebasedtargets.org/production/files/companies-excel.xlsx"
+    CTA_FILE_URL_PER_TARGET = "https://sciencebasedtargets.org/resources/files/targets-excel.xlsx"
     OUTPUT_TARGET_STATUS = "sbti_target_status"
     OUTPUT_WEIGHTED_TARGET_STATUS = "weighted_sbti_target_status"
     VALUE_TARGET_NO = "No target"
@@ -181,4 +183,5 @@ class PortfolioCoverageTVPConfig(PortfolioAggregationConfig):
     COL_COMPANY_ISIN = "ISIN"
     COL_COMPANY_LEI = "LEI"
     COL_ACTION = "Action"
-    COL_TARGET = "Target"
+    COL_TARGET = "Target"
+    COL_DATE_PUBLISHED = "Date Published"

SBTi/data/sbti.py

@@ -1,110 +1,332 @@
-from typing import List, Type
+from typing import List, Type, Dict, Tuple, Optional
 import requests
 import pandas as pd
 import warnings
-
+import datetime
+import re
 
 from SBTi.configs import PortfolioCoverageTVPConfig
-from SBTi.interfaces import IDataProviderCompany
+from SBTi.interfaces import IDataProviderCompany, IDataProviderTarget, EScope, ETimeFrames
 
 
 class SBTi:
     """
     Data provider skeleton for SBTi. This class only provides the sbti_validated field for existing companies.
+    Updated to DEFAULT to per-company format for TR Testing consistency.
+    Enhanced to extract detailed target information when available.
     """
 
     def __init__(
         self, config: Type[PortfolioCoverageTVPConfig] = PortfolioCoverageTVPConfig
     ):
         self.c = config
-        # Fetch CTA file from SBTi website
-        resp = requests.get(self.c.CTA_FILE_URL)
-        # Write CTA file to disk
-        with open(self.c.FILE_TARGETS, 'wb') as output:
-            output.write(resp.content)
-            print(f'Status code from fetching the CTA file: {resp.status_code}, 200 = OK')
+        
+        # DEFAULT TO PER-COMPANY FORMAT for consistency with TR Testing baseline
+        # Override the config to ensure per-company format is used
+        original_url = self.c.CTA_FILE_URL
+        self.c.CTA_FILE_URL = "https://files.sciencebasedtargets.org/production/files/companies-excel.xlsx"
+        
+
+        fallback_err_log_statement = 'Will read older file from this package version'
+        try:
+            # Fetch CTA file from SBTi website
+            resp = requests.get(self.c.CTA_FILE_URL)
+
+            # If status code == 200 then write CTA file to disk
+            if resp.ok:
+                with open(self.c.FILE_TARGETS, 'wb') as output:
+                    output.write(resp.content)
+                    print(f'Status code from fetching the CTA file: {resp.status_code}, 200 = OK')
+            else:
+                print(f'Non-200 status code when fetching the CTA file from the SBTi website: {resp.status_code}')
+                print(fallback_err_log_statement)
+
+        except requests.exceptions.RequestException as e:
+            print(f'Exception when fetching the CTA file from the SBTi website: {e}')
+            print(fallback_err_log_statement)
+
         # Read CTA file into pandas dataframe
-        # Suppress warning about openpyxl - check if this is still needed in the released version.
+        # Suppress warning about openpyxl
         warnings.filterwarnings('ignore', category=UserWarning, module='openpyxl')
         self.targets = pd.read_excel(self.c.FILE_TARGETS)
         
+        # Detect and convert column format if needed
+        self.targets = self._ensure_compatible_format(self.targets)
+        
+        print(f"CTA format: {getattr(self, 'format_type', 'unknown')} | Companies: {len(self.targets)}")
+
+    def _detect_format(self, df):
+        """
+        Detect the format of the CTA file:
+        - 'old': Original format with Title Case columns
+        - 'new_company': New per-company format (one row per company) - PREFERRED
+        - 'new_target': New per-target format (multiple rows per company)
+        """
+        # Check for key columns to determine format
+        if 'Company Name' in df.columns:
+            return 'old'
+        elif 'company_name' in df.columns:
+            # Distinguish between per-company and per-target formats
+            if 'near_term_status' in df.columns:
+                return 'new_company'  # PREFERRED FORMAT
+            elif 'target_wording' in df.columns or 'row_entry_id' in df.columns:
+                return 'new_target'
+            else:
+                # Default to per-company if we can't determine
+                return 'new_company'
+        else:
+            raise ValueError("Unrecognized CTA file format")
     
+    def _ensure_compatible_format(self, df):
+        """
+        Convert CTA file to the format expected by the configs
+        OPTIMIZED FOR PER-COMPANY FORMAT
+        """
+        format_type = self._detect_format(df)
+        
+        if format_type in ['new_target', 'new_company']:
+            # Map new format columns to old format for backward compatibility
+            column_mapping = {
+                'company_name': self.c.COL_COMPANY_NAME,
+                'isin': self.c.COL_COMPANY_ISIN,
+                'lei': self.c.COL_COMPANY_LEI,
+                'action': self.c.COL_ACTION,
+                'target': self.c.COL_TARGET,
+                'date_published': self.c.COL_DATE_PUBLISHED
+            }
+            
+            # Handle different format types
+            if format_type == 'new_company':
+                # Map near_term_status to create synthetic Action and Target columns
+                if 'near_term_status' in df.columns:
+                    df['action'] = df['near_term_status'].apply(
+                        lambda x: 'Target' if x == 'Targets set' else 'Commitment'
+                    )
+                    df['target'] = df['near_term_status'].apply(
+                        lambda x: 'Near-term' if x == 'Targets set' else None
+                    )
+            
+            # Only rename columns that exist
+            rename_dict = {}
+            for new_col, old_col in column_mapping.items():
+                if new_col in df.columns:
+                    rename_dict[new_col] = old_col
+            
+            df = df.rename(columns=rename_dict)
+            
+            # Store format type for later use
+            self.format_type = format_type
+            
+            # Keep additional columns for potential future use
+            if 'sbti_id' in df.columns:
+                df['SBTI_ID'] = df['sbti_id']
+            if 'target_classification_short' in df.columns:
+                df['Target Classification'] = df['target_classification_short']
+            if 'scope' in df.columns:
+                df['Scope'] = df['scope']
+            if 'base_year' in df.columns:
+                df['Base Year'] = df['base_year']
+            if 'target_year' in df.columns:
+                df['Target Year'] = df['target_year']
+        else:
+            self.format_type = 'old'
+        
+        return df
+
     def filter_cta_file(self, targets):
         """
-        Filter the CTA file to create a datafram that has on row per company 
+        Filter the CTA file to create a dataframe that has one row per company
         with the columns "Action" and "Target".
         If Action = Target then only keep the rows where Target = Near-term.
+        
+        Handles all three formats: old, new per-company, and new per-target.
         """
 
         # Create a new dataframe with only the columns "Action" and "Target"
         # and the columns that are needed for identifying the company
-        targets = targets[
-            [
-                self.c.COL_COMPANY_NAME, 
-                self.c.COL_COMPANY_ISIN, 
-                self.c.COL_COMPANY_LEI, 
-                self.c.COL_ACTION, 
-                self.c.COL_TARGET
-            ]
+        required_cols = [
+            self.c.COL_COMPANY_NAME, 
+            self.c.COL_COMPANY_ISIN, 
+            self.c.COL_COMPANY_LEI, 
+            self.c.COL_ACTION, 
+            self.c.COL_TARGET
         ]
         
+        # Only select columns that exist
+        existing_cols = [col for col in required_cols if col in targets.columns]
+        targets_filtered = targets[existing_cols].copy()
+        
         # Keep rows where Action = Target and Target = Near-term 
-        df_nt_targets = targets[
-            (targets[self.c.COL_ACTION] == self.c.VALUE_ACTION_TARGET) & 
-            (targets[self.c.COL_TARGET] == self.c.VALUE_TARGET_SET)]
-        
-        # Drop duplicates in the dataframe by waterfall. 
-        # Do company name last due to risk of misspelled names
-        # First drop duplicates on LEI, then on ISIN, then on company name
-        df_nt_targets = pd.concat([
-            df_nt_targets[~df_nt_targets[self.c.COL_COMPANY_LEI].isnull()].drop_duplicates(
-                subset=self.c.COL_COMPANY_LEI, keep='first'
-            ), 
-            df_nt_targets[df_nt_targets[self.c.COL_COMPANY_LEI].isnull()]
-        ])
-        
-        df_nt_targets = pd.concat([
-            df_nt_targets[~df_nt_targets[self.c.COL_COMPANY_ISIN].isnull()].drop_duplicates(
-                subset=self.c.COL_COMPANY_ISIN, keep='first'
-            ),
-            df_nt_targets[df_nt_targets[self.c.COL_COMPANY_ISIN].isnull()]
-        ])
-
-        df_nt_targets.drop_duplicates(subset=self.c.COL_COMPANY_NAME, inplace=True)
-  
+        df_nt_targets = targets_filtered[
+            (targets_filtered[self.c.COL_ACTION] == self.c.VALUE_ACTION_TARGET) & 
+            (targets_filtered[self.c.COL_TARGET] == self.c.VALUE_TARGET_SET)]
+        
+        # For per-target format, we need to deduplicate at company level
+        # since there can be multiple target rows per company
+        if hasattr(self, 'format_type') and self.format_type == 'new_target':
+            print("Processing per-target format - deduplicating companies...")
+        
+        # Drop duplicates in the dataframe by waterfall approach
+        # LEI first, then ISIN, then company name
+        identifier_cols = [self.c.COL_COMPANY_LEI, self.c.COL_COMPANY_ISIN, self.c.COL_COMPANY_NAME]
+        
+        for identifier_col in identifier_cols:
+            if identifier_col in df_nt_targets.columns:
+                # Drop duplicates based on this identifier, keeping first occurrence
+                before_count = len(df_nt_targets)
+                df_nt_targets = df_nt_targets.drop_duplicates(subset=[identifier_col], keep='first')
+                after_count = len(df_nt_targets)
+                if before_count != after_count and hasattr(self, 'format_type') and self.format_type == 'new_target':
+                    print(f"   Deduplicated {before_count - after_count} entries using {identifier_col}")
+        
         return df_nt_targets
-    
-    def get_sbti_targets(
-        self, companies: List[IDataProviderCompany], id_map: dict
+
+    def get_company_targets(self, company_name: str = None, isin: str = None, lei: str = None):
+        """
+        Get all targets for a specific company.
+        Only works with per-target format.
+        
+        :param company_name: Company name to search for
+        :param isin: ISIN to search for
+        :param lei: LEI to search for
+        :return: DataFrame with all targets for the company
+        """
+        if hasattr(self, 'format_type') and self.format_type == 'new_target':
+            if lei:
+                return self.targets[self.targets['lei'] == lei]
+            elif isin:
+                return self.targets[self.targets['isin'] == isin]
+            elif company_name:
+                return self.targets[self.targets[self.c.COL_COMPANY_NAME] == company_name]
+        return pd.DataFrame()  # Empty dataframe if not per-target format
+
+    def get_companies(
+        self, companies: List[IDataProviderCompany], id_map: Dict[str, Tuple[str, str]]
     ) -> List[IDataProviderCompany]:
         """
-        Check for each company if they have an SBTi validated target, first using the company LEI, 
-        if available, and then using the ISIN.
+        Get company data from SBTi database and add sbti_validated field.
         
         :param companies: A list of IDataProviderCompany instances
         :param id_map: A map from company id to a tuple of (ISIN, LEI)
         :return: A list of IDataProviderCompany instances, supplemented with the SBTi information
         """
-        # Filter out information about targets
+        # Filter targets for validation check
+        filtered_targets = self.filter_cta_file(self.targets)
+        
+        # Track matching statistics for debugging
+        matched_lei = matched_isin = matched_name = 0
+
+        for company in companies:
+            isin, lei = id_map.get(company.company_id, (None, None))
+            
+            # Skip if no identifiers
+            if not isin and not lei and not company.company_name:
+                continue
+                
+            # Check lei and length of lei to avoid zeros 
+            if lei and not lei.lower() == 'nan' and len(str(lei)) > 3:
+                targets = filtered_targets[
+                    filtered_targets[self.c.COL_COMPANY_LEI] == lei
+                ]
+                if len(targets) > 0:
+                    company.sbti_validated = True
+                    matched_lei += 1
+                    continue
+                    
+            if isin and not isin.lower() == 'nan':
+                targets = filtered_targets[
+                    filtered_targets[self.c.COL_COMPANY_ISIN] == isin
+                ]
+                if len(targets) > 0:
+                    company.sbti_validated = True
+                    matched_isin += 1
+                    continue
+                    
+            # Try company name matching as fallback
+            if company.company_name:
+                targets = filtered_targets[
+                    filtered_targets[self.c.COL_COMPANY_NAME].str.lower() == company.company_name.lower()
+                ]
+                if len(targets) > 0:
+                    company.sbti_validated = True
+                    matched_name += 1
+                    continue
+            
+            # No match found
+            company.sbti_validated = False
+
+        total_matched = matched_lei + matched_isin + matched_name
+        print(f"SBTi matches: {total_matched}/{len(companies)} (LEI: {matched_lei}, ISIN: {matched_isin}, Name: {matched_name})")
+        
+        return companies
+
+    def get_sbti_targets(
+        self, companies: List[IDataProviderCompany], id_map: Dict[str, Tuple[str, str]]
+    ) -> Tuple[List[IDataProviderCompany], Dict[str, List[IDataProviderTarget]]]:
+        """
+        Enhanced version that returns both validation status AND target details when available.
+        
+        :param companies: A list of IDataProviderCompany instances
+        :param id_map: A map from company id to a tuple of (ISIN, LEI)
+        :return: A tuple of:
+            - List of IDataProviderCompany instances, supplemented with the SBTi information
+            - Dictionary mapping company_id to list of IDataProviderTarget instances
+        """
+        # Store original unfiltered targets for detailed extraction
+        original_targets = self.targets.copy()
+        
+        # Filter out information about targets for validation check
         self.targets = self.filter_cta_file(self.targets)
+        
+        # Dictionary to store detailed target data
+        sbti_target_data = {}
 
         for company in companies:
-            isin, lei = id_map.get(company.company_id)
+            isin, lei = id_map.get(company.company_id, (None, None))
+            
+            # Skip if no identifiers
+            if not isin and not lei:
+                continue
+                
             # Check lei and length of lei to avoid zeros 
-            if not lei.lower() == 'nan' and len(lei) > 3:
+            if lei and not lei.lower() == 'nan' and len(str(lei)) > 3:
                 targets = self.targets[
                     self.targets[self.c.COL_COMPANY_LEI] == lei
                 ]
-            elif not isin.lower() == 'nan':
+                # Get all targets for detailed extraction
+                if hasattr(self, 'format_type') and self.format_type == 'new_target':
+                    all_company_targets = original_targets[
+                        original_targets[self.c.COL_COMPANY_LEI if self.c.COL_COMPANY_LEI in original_targets.columns else 'lei'] == lei
+                    ]
+            elif isin and not isin.lower() == 'nan':
                 targets = self.targets[
                     self.targets[self.c.COL_COMPANY_ISIN] == isin
                 ]
+                # Get all targets for detailed extraction
+                if hasattr(self, 'format_type') and self.format_type == 'new_target':
+                    all_company_targets = original_targets[
+                        original_targets[self.c.COL_COMPANY_ISIN if self.c.COL_COMPANY_ISIN in original_targets.columns else 'isin'] == isin
+                    ]
             else:
                 continue
+                
             if len(targets) > 0:
-                company.sbti_validated = (
-                    self.c.VALUE_TARGET_SET in targets[self.c.COL_TARGET].values
-                )
-        return companies
+                company.sbti_validated = True
+                
+                # Extract detailed target information if available
+                if hasattr(self, 'format_type') and self.format_type == 'new_target' and len(all_company_targets) > 0:
+                    targets_list = []
+                    for _, target_row in all_company_targets.iterrows():
+                        target_data = {
+                            'company_id': company.company_id,
+                            'target_type': target_row.get('target_classification_short', 'Unknown'),
+                            'scope': target_row.get('scope', 'Unknown'),
+                            'base_year': target_row.get('base_year'),
+                            'target_year': target_row.get('target_year'),
+                        }
+                        targets_list.append(target_data)
+                    sbti_target_data[company.company_id] = targets_list
+            else:
+                company.sbti_validated = False
 
-   
+        return companies, sbti_target_data

SBTi/utils.py

@@ -164,24 +164,6 @@ def _make_id_map(df_portfolio: pd.DataFrame) -> dict:
     }
 
 
-# def _make_isin_map(df_portfolio: pd.DataFrame) -> dict:
-#     """
-#     Create a mapping from company_id to ISIN (required for the SBTi matching).
-
-#     :param df_portfolio: The complete portfolio
-#     :return: A mapping from company_id to ISIN
-#     """
-#     return {
-#         company_id: company[ColumnsConfig.COMPANY_ISIN]
-#         for company_id, company in df_portfolio[
-#             [ColumnsConfig.COMPANY_ID, ColumnsConfig.COMPANY_ISIN]
-#         ]
-#         .set_index(ColumnsConfig.COMPANY_ID)
-#         .to_dict(orient="index")
-#         .items()
-#     }
-
-
 def dataframe_to_portfolio(df_portfolio: pd.DataFrame) -> List[PortfolioCompany]:
     """
     Convert a data frame to a list of portfolio company objects.
@@ -199,28 +181,77 @@ def dataframe_to_portfolio(df_portfolio: pd.DataFrame) -> List[PortfolioCompany]
     ]
 
 
+def merge_target_data(
+    provider_targets: List[IDataProviderTarget], 
+    sbti_targets: Dict[str, List[IDataProviderTarget]]
+) -> List[IDataProviderTarget]:
+    """
+    Merge targets from data providers with SBTi targets, preferring SBTi data for validated companies.
+    
+    :param provider_targets: List of targets from data providers
+    :param sbti_targets: Dictionary mapping company_id to list of SBTi targets
+    :return: Merged list of targets
+    """
+    # Create lookup of provider targets by company
+    provider_by_company = {}
+    for target in provider_targets:
+        if target.company_id not in provider_by_company:
+            provider_by_company[target.company_id] = []
+        provider_by_company[target.company_id].append(target)
+    
+    # Replace with SBTi targets where available
+    for company_id, sbti_company_targets in sbti_targets.items():
+        if sbti_company_targets:  # Only replace if we have valid SBTi targets
+            provider_by_company[company_id] = sbti_company_targets
+            logging.getLogger(__name__).info(
+                f"Using {len(sbti_company_targets)} SBTi targets for company {company_id}"
+            )
+    
+    # Flatten back to list
+    merged_targets = []
+    for company_targets in provider_by_company.values():
+        merged_targets.extend(company_targets)
+    
+    return merged_targets
+
+
 def get_data(
     data_providers: List[data.DataProvider], portfolio: List[PortfolioCompany]
 ) -> pd.DataFrame:
     """
     Get the required data from the data provider(s), validate the targets and return a 9-box grid for each company.
+    Enhanced to use SBTi authoritative target data when available.
 
     :param data_providers: A list of DataProvider instances
     :param portfolio: A list of PortfolioCompany models
     :return: A data frame containing the relevant company-target data
     """
+    logger = logging.getLogger(__name__)
+    
     df_portfolio = pd.DataFrame.from_records(
         [_flatten_user_fields(c) for c in portfolio]
     )
     company_data = get_company_data(data_providers, df_portfolio["company_id"].tolist())
     target_data = get_targets(data_providers, df_portfolio["company_id"].tolist())
 
+    # Supplement the company data with the SBTi target status and get detailed targets
+    sbti = SBTi()
+    company_data, sbti_targets = sbti.get_sbti_targets(company_data, _make_id_map(df_portfolio))
+    
+    # Log information about SBTi targets found
+    if sbti_targets:
+        logger.info(f"Found SBTi targets for {len(sbti_targets)} companies")
+        for company_id, targets in sbti_targets.items():
+            logger.info(f"Company {company_id}: {len(targets)} SBTi targets")
+    
+    # Merge SBTi targets with provider targets
+    if sbti_targets:
+        target_data = merge_target_data(target_data, sbti_targets)
+        logger.info(f"Total targets after merging: {len(target_data)}")
+    
     if len(target_data) == 0:
         raise ValueError("No targets found")
 
-    # Supplement the company data with the SBTi target status
-    company_data = SBTi().get_sbti_targets(company_data, _make_id_map(df_portfolio))
-
     # Prepare the data
     portfolio_data = TargetProtocol().process(target_data, company_data)
     portfolio_data = pd.merge(
@@ -280,4 +311,4 @@ def calculate(
     if anonymize:
         scores = ts.anonymize_data_dump(scores)
 
-    return scores, aggregations
+    return scores, aggregations

{sbti_finance_tool-1.0.8.dist-info → sbti_finance_tool-1.1.0.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
          
-         Copyright (c) 2020 World Resources Institute
+         Copyright (c) 2025 World Resources Institute; Science Based Targets initiative
          
          Permission is hereby granted, free of charge, to any person obtaining a copy
          of this software and associated documentation files (the "Software"), to deal

{sbti_finance_tool-1.0.8.dist-info → sbti_finance_tool-1.1.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: sbti-finance-tool
-Version: 1.0.8
+Version: 1.1.0
 Summary: This package helps companies and financial institutions to assess the temperature alignment of current targets, commitments, and investment and lending portfolios, and to use this information to develop targets for official validation by the SBTi.'
 License: MIT
 Keywords: Climate,SBTi,Finance
 Author: sbti
-Author-email: finance@sciencebasedtargets.org
+Author-email: financialinstitutions@sciencebasedtargets.org
 Requires-Python: >=3.9,<4.0
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -18,7 +18,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Topic :: Scientific/Engineering
@@ -27,7 +28,7 @@ Requires-Dist: cleo (>=2.0.1,<3.0.0)
 Requires-Dist: openpyxl (==3.1.2)
 Requires-Dist: pandas (==1.5.3)
 Requires-Dist: pydantic (==1.10.7)
-Requires-Dist: requests (==2.29.0)
+Requires-Dist: requests (==2.31.0)
 Requires-Dist: six (==1.16.0)
 Requires-Dist: xlrd (==2.0.1)
 Project-URL: Bug Tracker, https://github.com/ScienceBasedTargets/SBTi-finance-tool/issues
@@ -37,7 +38,7 @@ Description-Content-Type: text/markdown
 
 > Visit https://sciencebasedtargets.github.io/SBTi-finance-tool/ for the full documentation
 
-> If you have any additional questions or comments send a mail to: finance@sciencebasedtargets.org
+> If you have any additional questions or comments send a mail to: financialinstitutions@sciencebasedtargets.org
 
 # SBTi Temperature Alignment tool
 
@@ -103,7 +104,7 @@ pip install -e .
 For installing the latest stable release in PyPi run:
 
 ```bash
-pip install sbti
+pip install sbti-finance-tool
 ```
 
 ## Development
@@ -116,6 +117,15 @@ poetry install
 
 This will create a virtual environment inside the project folder under `.venv`.
 
+### SBTi Companies Taking Action (CTA) Data
+
+The tool supports multiple formats of the SBTi CTA file:
+- **Per-company format** (default, recommended): One row per company with aggregated target status
+- **Per-target format**: Multiple rows per company with detailed target information
+- **Legacy format**: Original Title Case column format
+
+The tool automatically detects and handles all formats, defaulting to the per-company format for consistency.
+
 ### Testing
 
 Each class should be unit tested. The unit tests are written using the Nose2 framework.

{sbti_finance_tool-1.0.8.dist-info → sbti_finance_tool-1.1.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 SBTi/.DS_Store,sha256=W31j55Akn120dS6ubbWGqo8fdXI3MJozXV18EMNoiSw,6148
 SBTi/__init__.py,sha256=K3V0UVvqCRkD7CIClEMjiSegTGpVW1NUGNrG0vWT8VM,327
-SBTi/configs.py,sha256=ZOr809l716jLWaamvtS-mqwK4zbtOGbPiwg-1Pr8Wgw,6782
+SBTi/configs.py,sha256=ajIxuub2SxQxOG6FdQ7fjcHsrxZRr6I09KO2PDCklUo,7069
 SBTi/data/__init__.py,sha256=sOp_BV-nwBZIS4TfseXWxI8RZ3so4tvTphbxRw235VI,320
 SBTi/data/bloomberg.py,sha256=nTf3JVIgQe-IEUw0yJ6aoBBeSpCDBg2xaU0KjZVQdbo,2852
 SBTi/data/cdp.py,sha256=7q30fs9DfCNeKkB6rxtmE5qqRfNIihvd4ZaOURyGHmI,1995
@@ -9,10 +9,10 @@ SBTi/data/data_provider.py,sha256=EaMLz1vqFZoip0--Cwb_Qaeivxs1BPQRPbjrXTxlomI,18
 SBTi/data/excel.py,sha256=WYzT6ZobQY8AgcSyXKZFgG9qAcAV7ZEafZQfOLEFIJQ,3364
 SBTi/data/iss.py,sha256=sIHwRwV6QGXV-ePkIO_hX8Z2iUOtNZagW2UTPdQ7omU,1995
 SBTi/data/msci.py,sha256=A7mmUdaeX1z5ywuR7ZApJHMfxov6EpxlharSB8hXgLw,1997
-SBTi/data/sbti.py,sha256=ZdlswavdH89I2ekWo1jDz6CFlyIz_EM-WyFzXNuIABM,4306
+SBTi/data/sbti.py,sha256=HukaCKZoF685nzc_uL5U4MiC9-6nhKIgazddjM8GoLk,14919
 SBTi/data/trucost.py,sha256=H8ugebVUWgmtKTQ3x3l5drs_F3XzGqiiNugiYVu612s,2003
 SBTi/data/urgentem.py,sha256=eMnVRcCQQUBeERugClmgwvDMMi0bNqfSqblRV0bBBng,1854
-SBTi/inputs/current-Companies-Taking-Action-191.xlsx,sha256=bbpf5yaDoiPXvDkPcueSA1cDiKPkW9mGQmQy8Ik1cGE,525783
+SBTi/inputs/current-Companies-Taking-Action.xlsx,sha256=_Q1F1lktsmOrjRNJYbreyUI00_EWtx08nuTZOlVN1E4,1662705
 SBTi/inputs/regression_model_summary.xlsx,sha256=LSWCWq0Uy13tT-FWVmVEOwogs-NwdfqLSwlthFtr2MA,182447
 SBTi/inputs/sr15_mapping.xlsx,sha256=XhCue18kkVwgYDLsx04i5HB6cfJMa5UCW76Z74JsuzA,9922
 SBTi/interfaces.py,sha256=EJbTwiBnNhTqVt8aXs8HH9OB_T_24aSKAypLCC8gPGM,4331
@@ -20,8 +20,8 @@ SBTi/portfolio_aggregation.py,sha256=a9AfWsS8DA5G76Yrkm68TgX5z1XfVnSD7bG19cEMRjA
 SBTi/portfolio_coverage_tvp.py,sha256=q9v0VEs-4kFusHpXypNtoFPPThC4xng8GiUgyWaFnVA,1731
 SBTi/target_validation.py,sha256=UA4nFOjudjmeq8pwLJbYJ1x8Rz0KvDH2ZkytF_doHEU,16148
 SBTi/temperature_score.py,sha256=QqYAUCNp8gO43owcpTzxgKs_XpujI_XECKeMvee2CCg,27801
-SBTi/utils.py,sha256=qiYbuR2Worg7JRs_livnqf92TNGzGLW7xx-PvwEifuo,10182
-sbti_finance_tool-1.0.8.dist-info/LICENSE,sha256=NKw6I_eIAxDVIhtSsfeMBnECHTVf5UAGGIdAvFDqdnE,1261
-sbti_finance_tool-1.0.8.dist-info/METADATA,sha256=VErLnSuRty1YNDpohpFt9aGuhCtoE-JaLa8_4d5xHZM,6125
-sbti_finance_tool-1.0.8.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-sbti_finance_tool-1.0.8.dist-info/RECORD,,
+SBTi/utils.py,sha256=TBt5eW_wilxFfQkEC6vmM9z-JswyXTB4zO8cqa2BHSc,11639
+sbti_finance_tool-1.1.0.dist-info/LICENSE,sha256=UEETGN9GWX7lUA5-u4T2r60VSpzCg5W8L1aRhg_NbsM,1295
+sbti_finance_tool-1.1.0.dist-info/METADATA,sha256=qmLmT370KXXzcz9GSXDvJdUvDejwFj_7Tn1QildAy18,6672
+sbti_finance_tool-1.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+sbti_finance_tool-1.1.0.dist-info/RECORD,,

{sbti_finance_tool-1.0.8.dist-info → sbti_finance_tool-1.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.5.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any