sbti-finance-tool 1.0.9__tar.gz → 1.1.0__tar.gz

{sbti-finance-tool-1.0.9 → sbti_finance_tool-1.1.0}/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.9 → sbti_finance_tool-1.1.0}/PKG-INFO

@@ -1,11 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: sbti-finance-tool
-Version: 1.0.9
+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
@@ -15,10 +15,13 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+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: Programming Language :: Python :: 3.9
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Requires-Dist: cleo (>=2.0.1,<3.0.0)
@@ -35,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
 
@@ -114,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.9 → sbti_finance_tool-1.1.0}/README.md

@@ -1,6 +1,6 @@
 > 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
 
@@ -79,6 +79,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.9 → sbti_finance_tool-1.1.0}/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_finance_tool-1.1.0/SBTi/data/sbti.py

@@ -0,0 +1,332 @@
+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, 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
+        
+        # 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
+        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 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
+        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_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_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]:
+        """
+        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 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, (None, None))
+            
+            # Skip if no identifiers
+            if not isin and not lei:
+                continue
+                
+            # Check lei and length of lei to avoid zeros 
+            if lei and not lei.lower() == 'nan' and len(str(lei)) > 3:
+                targets = self.targets[
+                    self.targets[self.c.COL_COMPANY_LEI] == lei
+                ]
+                # 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 = 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-finance-tool-1.0.9 → sbti_finance_tool-1.1.0}/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.9 → sbti_finance_tool-1.1.0}/pyproject.toml

@@ -1,8 +1,8 @@
 [tool.poetry]
 name = "sbti-finance-tool"
-version = "1.0.9"
+version = "1.1.0"
 description = "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.'"
-authors = ["sbti <finance@sciencebasedtargets.org>"]
+authors = ["sbti <financialinstitutions@sciencebasedtargets.org>"]
 license = "MIT"
 readme = "README.md"
 classifiers = [

sbti-finance-tool-1.0.9/SBTi/data/sbti.py

@@ -1,115 +0,0 @@
-from typing import List, Type
-import requests
-import pandas as pd
-import warnings
-
-
-from SBTi.configs import PortfolioCoverageTVPConfig
-from SBTi.interfaces import IDataProviderCompany
-
-
-class SBTi:
-    """
-    Data provider skeleton for SBTi. This class only provides the sbti_validated field for existing companies.
-    """
-
-    def __init__(
-        self, config: Type[PortfolioCoverageTVPConfig] = PortfolioCoverageTVPConfig
-    ):
-        self.c = config
-        # 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.status_code == 200:
-            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')
-                # Read CTA file into pandas dataframe
-                # Suppress warning about openpyxl - check if this is still needed in the released version.
-        else:
-            print('Could not fetch the CTA file from the SBTi website')
-            print('Will read older file from this package version')
-            
-        warnings.filterwarnings('ignore', category=UserWarning, module='openpyxl')
-        self.targets = pd.read_excel(self.c.FILE_TARGETS)
-        
-    
-    def filter_cta_file(self, targets):
-        """
-        Filter the CTA file to create a datafram that has on row per company 
-        with the columns "Action" and "Target".
-        If Action = Target then only keep the rows where Target = Near-term.
-        """
-
-        # 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
-            ]
-        ]
-        
-        # 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)
-  
-        return df_nt_targets
-    
-    def get_sbti_targets(
-        self, companies: List[IDataProviderCompany], id_map: dict
-    ) -> 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.
-        
-        :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
-        self.targets = self.filter_cta_file(self.targets)
-
-        for company in companies:
-            isin, lei = id_map.get(company.company_id)
-            # Check lei and length of lei to avoid zeros 
-            if not lei.lower() == 'nan' and len(lei) > 3:
-                targets = self.targets[
-                    self.targets[self.c.COL_COMPANY_LEI] == lei
-                ]
-            elif not isin.lower() == 'nan':
-                targets = self.targets[
-                    self.targets[self.c.COL_COMPANY_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
-
-   

sbti-finance-tool-1.0.9/setup.py

@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['SBTi', 'SBTi.data']
-
-package_data = \
-{'': ['*'], 'SBTi': ['inputs/*']}
-
-install_requires = \
-['cleo>=2.0.1,<3.0.0',
- 'openpyxl==3.1.2',
- 'pandas==1.5.3',
- 'pydantic==1.10.7',
- 'requests==2.31.0',
- 'six==1.16.0',
- 'xlrd==2.0.1']
-
-setup_kwargs = {
-    'name': 'sbti-finance-tool',
-    'version': '1.0.9',
-    'description': "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.'",
-    'long_description': "> Visit https://sciencebasedtargets.github.io/SBTi-finance-tool/ for the full documentation\n\n> If you have any additional questions or comments send a mail to: finance@sciencebasedtargets.org\n\n# SBTi Temperature Alignment tool\n\nThis package helps companies and financial institutions to assess the temperature alignment of current\ntargets, commitments, and investment and lending portfolios, and to use this information to develop\ntargets for official validation by the SBTi.\n\nThis tool can be used either as a standalone Python package, a REST API or as a simple webapp which provides a simple skin on the API.\nSo, the SBTi toolkit caters for three types of usage:\n\n- Users can integrate the Python package in their codebase\n- The tool can be included as a Microservice (containerised REST API) in any IT infrastructure (in the cloud or on premise)\n- As an webapp, exposing the functionality with a simple user interface.\n\nTo following diagram provides an overview of the different parts of the toolkit:\n\n    +-------------------------------------------------+\n    |   UI     : Simple user interface on top of API  |\n    |   Install: via dockerhub                        |\n    |            docker.io/sbti/ui:latest             |\n    |                                                 |\n    | +-----------------------------------------+     |\n    | | REST API: Dockerized FastAPI/NGINX      |     |\n    | | Source : github.com/OFBDABV/SBTi_api    |     |\n    | | Install: via source or dockerhub        |     |\n    | |          docker.io/sbti/sbti/api:latest |     |\n    | |                                         |     |\n    | | +---------------------------------+     |     |\n    | | |                                 |     |     |\n    | | |Core   : Python Module           |     |     |\n    | | |Source : github.com/ScienceBasedTargets/     |\n    | | |               SBTi-finance-tool |     |     |\n    | | |Install: via source or PyPi      |     |     |\n    | | |                                 |     |     |\n    | | +---------------------------------+     |     |\n    | +-----------------------------------------+     |\n    +-------------------------------------------------+\n\nAs shown above the API is dependent on the Python Repo, in the same way the UI requires the API backend. These dependencies are scripted in the Docker files.\n\n> This repository only contains the Python module. If you'd like to use the REST API, please refer to [this repository](https://github.com/ScienceBasedTargets/SBTi-finance-tool-api) or the same repository on [Dockerhub](https://docker.io/sbti/sbti/api:latest).\n\n## Structure\n\nThe folder structure for this project is as follows:\n\n    .\n    ├── .github                 # Github specific files (Github Actions workflows)\n    ├── app                     # FastAPI app files for the API endpoints\n    ├── docs                    # Documentation files (Sphinx)\n    ├── config                  # Config files for the Docker container\n    ├── SBTi                    # The main Python package for the temperature alignment tool\n    └── test                    # Automated unit tests for the SBTi package (Nose2 tests)\n\n## Installation\n\nThe SBTi package may be installed using PIP. If you'd like to install it locally use the following command. For testing or production please see the deployment section for further instructions\n\n```bash\npip install -e .\n```\n\nFor installing the latest stable release in PyPi run:\n\n```bash\npip install sbti-finance-tool\n```\n\n## Development\n\nTo set up the local dev environment with all dependencies, [install poetry](https://python-poetry.org/docs/#osx--linux--bashonwindows-install-instructions) and run\n\n```bash\npoetry install\n```\n\nThis will create a virtual environment inside the project folder under `.venv`.\n\n### Testing\n\nEach class should be unit tested. The unit tests are written using the Nose2 framework.\nThe setup.py script should have already installed Nose2, so now you may run the tests as follows:\n\n```bash\nnose2 -v\n```\n\n### Publish to PyPi\n\nThe package should be published to PyPi when any changes to main are merged.\n\nUpdate package\n\n1. bump version in `pyproject.toml` based on semantic versioning principles\n2. run `poetry build`\n3. run `poetry publish`\n4. check whether package has been successfully uploaded\n\n**Initial Setup**\n\n- Create account on [PyPi](https://pypi.org/)\n",
-    'author': 'sbti',
-    'author_email': 'finance@sciencebasedtargets.org',
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': None,
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.9,<4.0',
-}
-
-
-setup(**setup_kwargs)