kensho-kfinance 2.8.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

kfinance/{kfinance.py → client/kfinance.py}

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 from concurrent.futures import ThreadPoolExecutor
-from copy import deepcopy
 from datetime import date, datetime, timezone
 from io import BytesIO
 import logging
@@ -18,29 +17,32 @@ from langchain_google_genai._function_utils import convert_to_genai_function_dec
 import pandas as pd
 from PIL.Image import Image, open as image_open
 
-from kfinance.batch_request_handling import add_methods_of_singular_class_to_iterable_class
-from kfinance.fetch import (
+from kfinance.client.batch_request_handling import add_methods_of_singular_class_to_iterable_class
+from kfinance.client.fetch import (
     DEFAULT_API_HOST,
     DEFAULT_API_VERSION,
     DEFAULT_OKTA_AUTH_SERVER,
     DEFAULT_OKTA_HOST,
     KFinanceApiClient,
 )
-from kfinance.meta_classes import (
+from kfinance.client.industry_models import IndustryClassification
+from kfinance.client.meta_classes import (
     CompanyFunctionsMetaClass,
     DelegatedCompanyFunctionsMetaClass,
 )
-from kfinance.models.date_and_period_models import LatestPeriods, Periodicity, YearAndQuarter
-from kfinance.models.id_models import IdentificationTriple
-from kfinance.models.industry_models import IndustryClassification
-from kfinance.models.price_models import HistoryMetadata, PriceHistory
-from kfinance.prompt import PROMPT
-from kfinance.pydantic_models import TranscriptComponent
-from kfinance.server_thread import ServerThread
+from kfinance.client.models.date_and_period_models import (
+    LatestPeriods,
+    Periodicity,
+    YearAndQuarter,
+)
+from kfinance.client.server_thread import ServerThread
+from kfinance.domains.companies.company_models import IdentificationTriple
+from kfinance.domains.earnings.earning_models import EarningsCall, TranscriptComponent
+from kfinance.domains.prices.price_models import HistoryMetadata, PriceHistory
 
 
 if TYPE_CHECKING:
-    from kfinance.tool_calling.shared_models import KfinanceTool
+    from kfinance.integrations.tool_calling.tool_calling_models import KfinanceTool
 
 logger = logging.getLogger(__name__)
 
@@ -266,6 +268,19 @@ class Earnings:
         self.key_dev_id = key_dev_id
         self._transcript: Transcript | None = None
 
+    @classmethod
+    def from_earnings_call(
+        cls, earnings_call: EarningsCall, kfinance_api_client: KFinanceApiClient
+    ) -> "Earnings":
+        """Generate an Earnings object from an EarningsCall pydantic model."""
+
+        return Earnings(
+            name=earnings_call.name,
+            datetime=earnings_call.datetime,
+            key_dev_id=earnings_call.key_dev_id,
+            kfinance_api_client=kfinance_api_client,
+        )
+
     def __str__(self) -> str:
         """String representation for the earnings object"""
         return f"{type(self).__module__}.{type(self).__qualname__} of {self.key_dev_id}"
@@ -513,24 +528,13 @@ class Company(CompanyFunctionsMetaClass):
             return self._all_earnings
 
         earnings_data = self.kfinance_api_client.fetch_earnings(self.company_id)
-        self._all_earnings = []
-
-        for earnings in earnings_data["earnings"]:
-            if "keydevid" in earnings:
-                earnings["key_dev_id"] = deepcopy(earnings["keydevid"])
-                del earnings["keydevid"]
-            earnings_datetime = datetime.fromisoformat(
-                earnings["datetime"].replace("Z", "+00:00")
-            ).replace(tzinfo=timezone.utc)
-
-            self._all_earnings.append(
-                Earnings(
-                    kfinance_api_client=self.kfinance_api_client,
-                    name=earnings["name"],
-                    datetime=earnings_datetime,
-                    key_dev_id=earnings["key_dev_id"],
-                )
+
+        self._all_earnings = [
+            Earnings.from_earnings_call(
+                earnings_call=earnings_call, kfinance_api_client=self.kfinance_api_client
             )
+            for earnings_call in earnings_data.earnings_calls
+        ]
 
         return self._all_earnings
 
@@ -641,83 +645,77 @@ class Company(CompanyFunctionsMetaClass):
         return self._mergers_for_company
 
 
-class AdvisedCompany(Company):
+class ParticipantInMerger:
     """A Company that has been involved in a transaction is a company that may have been advised."""
 
     def __init__(
-        self,
-        kfinance_api_client: KFinanceApiClient,
-        company_id: int,
-        transaction_id: int,
-        company_name: str | None = None,
+        self, kfinance_api_client: KFinanceApiClient, transaction_id: int, company: Company
     ):
         """Initialize the AdvisedCompany object
 
         :param kfinance_api_client: The KFinanceApiClient used to fetch data
         :type kfinance_api_client: KFinanceApiClient
-        :param company_id: The S&P Global CIQ Company Id
-        :type company_id: int
         :param transaction_id: The S&P Global CIP Transaction Id
         :type transaction_id: int
+        :param company: The company object
+        :type company: Company
         """
-
-        super().__init__(
-            kfinance_api_client=kfinance_api_client,
-            company_id=company_id,
-            company_name=company_name,
-        )
+        self.kfinance_api_client = kfinance_api_client
         self.transaction_id = transaction_id
+        self._company = company
 
     @property
-    def advisors(self) -> Companies | None:
+    def company(self) -> Company:
+        """Get the specific Company object."""
+        return self._company
+
+    @property
+    def advisors(self) -> list[Advisor] | None:
         """Get the companies that advised this company during the current transaction."""
         advisors = self.kfinance_api_client.fetch_advisors_for_company_in_merger(
-            transaction_id=self.transaction_id, advised_company_id=self.company_id
+            transaction_id=self.transaction_id, advised_company_id=self._company.company_id
         )["advisors"]
-        companies = [
-            AdvisorCompany(
-                kfinance_api_client=self.kfinance_api_client,
-                company_id=int(advisor["advisor_company_id"]),
-                company_name=str(advisor["advisor_company_name"]),
+        return [
+            Advisor(
                 advisor_type_name=str(advisor["advisor_type_name"]),
+                company=Company(
+                    kfinance_api_client=self.kfinance_api_client,
+                    company_id=int(advisor["advisor_company_id"]),
+                    company_name=str(advisor["advisor_company_name"]),
+                ),
             )
             for advisor in advisors
         ]
-        return Companies(kfinance_api_client=self.kfinance_api_client, companies=companies)
 
 
-class AdvisorCompany(Company):
+class Advisor:
     """A company that advised another company during a transaction."""
 
     def __init__(
         self,
-        kfinance_api_client: KFinanceApiClient,
-        company_id: int,
-        advisor_type_name: str,
-        company_name: str | None = None,
+        advisor_type_name: str | None,
+        company: Company,
     ):
         """Initialize the AdvisorCompany object
 
-        :param kfinance_api_client: The KFinanceApiClient used to fetch data
-        :type kfinance_api_client: KFinanceApiClient
-        :param company_id: The S&P Global CIQ Company Id
-        :type company_id: int
+        :param company: The company that advised
+        :type company: Company
         :param advisor_type_name: The type of the advisor company
         :type advisor_type_name: str
         """
-
-        super().__init__(
-            kfinance_api_client=kfinance_api_client,
-            company_id=company_id,
-            company_name=company_name,
-        )
         self._advisor_type_name = advisor_type_name
+        self._company = company
 
     @property
     def advisor_type_name(self) -> str | None:
         """When this company advised another during a transaction, get the advisor type name."""
         return self._advisor_type_name
 
+    @property
+    def company(self) -> Company:
+        """Get the Company object."""
+        return self._company
+
 
 class Security:
     """Security class
@@ -1253,7 +1251,11 @@ class MergerOrAcquisition:
     """An object that represents a merger or an acquisition of a company."""
 
     def __init__(
-        self, kfinance_api_client: KFinanceApiClient, transaction_id: int, merger_title: str | None
+        self,
+        kfinance_api_client: KFinanceApiClient,
+        transaction_id: int,
+        merger_title: str | None,
+        closed_date: date | None,
     ) -> None:
         """MergerOrAcqusition initializer.
 
@@ -1264,6 +1266,7 @@ class MergerOrAcquisition:
         self.kfinance_api_client = kfinance_api_client
         self.transaction_id = transaction_id
         self.merger_title = merger_title
+        self.closed_date = closed_date
         self._merger_info: dict | None = None
 
     @property
@@ -1301,36 +1304,39 @@ class MergerOrAcquisition:
         Each category is a single Company or a list of Companies.
         """
         return {
-            "target": AdvisedCompany(
+            "target": ParticipantInMerger(
                 kfinance_api_client=self.kfinance_api_client,
-                company_id=self.merger_info["participants"]["target"]["company_id"],
-                company_name=self.merger_info["participants"]["target"]["company_name"],
                 transaction_id=self.transaction_id,
+                company=Company(
+                    kfinance_api_client=self.kfinance_api_client,
+                    company_id=self.merger_info["participants"]["target"]["company_id"],
+                    company_name=self.merger_info["participants"]["target"]["company_name"],
+                ),
             ),
-            "buyers": Companies(
-                kfinance_api_client=self.kfinance_api_client,
-                companies=[
-                    AdvisedCompany(
+            "buyers": [
+                ParticipantInMerger(
+                    kfinance_api_client=self.kfinance_api_client,
+                    transaction_id=self.transaction_id,
+                    company=Company(
                         kfinance_api_client=self.kfinance_api_client,
                         company_id=company["company_id"],
                         company_name=company["company_name"],
-                        transaction_id=self.transaction_id,
-                    )
-                    for company in self.merger_info["participants"]["buyers"]
-                ],
-            ),
-            "sellers": Companies(
-                kfinance_api_client=self.kfinance_api_client,
-                companies=[
-                    AdvisedCompany(
+                    ),
+                )
+                for company in self.merger_info["participants"]["buyers"]
+            ],
+            "sellers": [
+                ParticipantInMerger(
+                    kfinance_api_client=self.kfinance_api_client,
+                    transaction_id=self.transaction_id,
+                    company=Company(
                         kfinance_api_client=self.kfinance_api_client,
                         company_id=company["company_id"],
                         company_name=company["company_name"],
-                        transaction_id=self.transaction_id,
-                    )
-                    for company in self.merger_info["participants"]["sellers"]
-                ],
-            ),
+                    ),
+                )
+                for company in self.merger_info["participants"]["sellers"]
+            ],
         }
 
     @property
@@ -1360,7 +1366,6 @@ class Companies(set):
         self,
         kfinance_api_client: KFinanceApiClient,
         company_ids: Optional[Iterable[int]] = None,
-        transaction_id: Optional[int] = None,
         companies: Optional[Iterable[Company]] = None,
     ) -> None:
         """Initialize the Companies object
@@ -1369,8 +1374,6 @@ class Companies(set):
         :type kfinance_api_client: KFinanceApiClient
         :param company_ids: An iterable of S&P CIQ Company ids
         :type company_ids: Iterable[int]
-        :param transaction_id: If the companies were party to a transaction, the S&P CIQ Transaction Id
-        :type transaction_id: Optional[int]
         :param companies: If there's already an iterable of Company objects
         :type companies: Iterable[Company]
         """
@@ -1378,23 +1381,13 @@ class Companies(set):
         if companies is not None:
             super().__init__(company for company in companies)
         elif company_ids is not None:
-            if transaction_id is not None:
-                super().__init__(
-                    AdvisedCompany(
-                        kfinance_api_client=kfinance_api_client,
-                        company_id=company_id,
-                        transaction_id=transaction_id,
-                    )
-                    for company_id in company_ids
-                )
-            else:
-                super().__init__(
-                    Company(
-                        kfinance_api_client=kfinance_api_client,
-                        company_id=company_id,
-                    )
-                    for company_id in company_ids
+            super().__init__(
+                Company(
+                    kfinance_api_client=kfinance_api_client,
+                    company_id=company_id,
                 )
+                for company_id in company_ids
+            )
 
 
 @add_methods_of_singular_class_to_iterable_class(Security)
@@ -1409,6 +1402,7 @@ class Securities(set):
         :param security_ids: An iterable of S&P CIQ Security ids
         :type security_ids: Iterable[int]
         """
+        self.kfinance_api_client = kfinance_api_client
         super().__init__(Security(kfinance_api_client, security_id) for security_id in security_ids)
 
 
@@ -1533,6 +1527,7 @@ class MergersAndAcquisitions(set):
                 kfinance_api_client=kfinance_api_client,
                 transaction_id=id_and_title["transaction_id"],
                 merger_title=id_and_title["merger_title"],
+                closed_date=id_and_title["closed_date"],
             )
             for id_and_title in ids_and_titles
         )
@@ -1551,8 +1546,6 @@ class Client:
     :type openai_tool_descriptions: list[dict]
     """
 
-    prompt = PROMPT
-
     def __init__(
         self,
         refresh_token: Optional[str] = None,
@@ -1632,9 +1625,10 @@ class Client:
     @property
     def langchain_tools(self) -> list["KfinanceTool"]:
         """Return a list of all Kfinance tools for tool calling."""
-        if self._tools is None:
-            from kfinance.tool_calling import ALL_TOOLS
 
+        from kfinance.integrations.tool_calling.all_tools import ALL_TOOLS
+
+        if self._tools is None:
             self._tools = []
             # Add tool to _tools if the user has permissions to use it.
             for tool_cls in ALL_TOOLS:

kfinance/{meta_classes.py → client/meta_classes.py}

@@ -7,14 +7,15 @@ from cachetools import LRUCache, cached
 import numpy as np
 import pandas as pd
 
-from .fetch import KFinanceApiClient
-from .models.business_relationship_models import BusinessRelationshipType
-from .models.capitalization_models import Capitalization
-from .models.competitor_models import CompetitorSource
-from .models.date_and_period_models import PeriodType
-from .models.line_item_models import LINE_ITEMS
-from .models.segment_models import SegmentType
-from .pydantic_models import RelationshipResponse
+from kfinance.client.fetch import KFinanceApiClient
+from kfinance.client.models.date_and_period_models import PeriodType
+from kfinance.domains.business_relationships.business_relationship_models import (
+    BusinessRelationshipType,
+)
+from kfinance.domains.capitalizations.capitalization_models import Capitalization
+from kfinance.domains.competitors.competitor_models import CompetitorSource
+from kfinance.domains.line_items.line_item_models import LINE_ITEMS
+from kfinance.domains.segments.segment_models import SegmentType
 
 
 if TYPE_CHECKING:
@@ -234,28 +235,16 @@ class CompanyFunctionsMetaClass:
             company_id=self.company_id,
             relationship_type=relationship_type,
         )
-        if isinstance(relationship_resp, RelationshipResponse):
-            return BusinessRelationships(
-                current=Companies(
-                    kfinance_api_client=self.kfinance_api_client,
-                    company_ids=[c.company_id for c in relationship_resp.current],
-                ),
-                previous=Companies(
-                    kfinance_api_client=self.kfinance_api_client,
-                    company_ids=[c.company_id for c in relationship_resp.previous],
-                ),
-            )
-        else:
-            return BusinessRelationships(
-                current=Companies(
-                    kfinance_api_client=self.kfinance_api_client,
-                    company_ids=relationship_resp.current,
-                ),
-                previous=Companies(
-                    kfinance_api_client=self.kfinance_api_client,
-                    company_ids=relationship_resp.previous,
-                ),
-            )
+        return BusinessRelationships(
+            current=Companies(
+                kfinance_api_client=self.kfinance_api_client,
+                company_ids=[c.company_id for c in relationship_resp.current],
+            ),
+            previous=Companies(
+                kfinance_api_client=self.kfinance_api_client,
+                company_ids=[c.company_id for c in relationship_resp.previous],
+            ),
+        )
 
     def market_cap(
         self,
@@ -329,7 +318,9 @@ class CompanyFunctionsMetaClass:
         capitalizations = self.kfinance_api_client.fetch_market_caps_tevs_and_shares_outstanding(
             company_id=self.company_id, start_date=start_date, end_date=end_date
         )
-        return capitalizations.jsonify_single_attribute(capitalization_to_extract)
+        return capitalizations.model_dump_json_single_metric(
+            capitalization_metric=capitalization_to_extract
+        )
 
     def _segments(
         self,
@@ -437,16 +428,16 @@ class CompanyFunctionsMetaClass:
 
         competitors_data = self.kfinance_api_client.fetch_competitors(
             company_id=self.company_id, competitor_source=competitor_source
-        )["competitors"]
+        )
         return Companies(
             kfinance_api_client=self.kfinance_api_client,
             companies=[
                 Company(
                     kfinance_api_client=self.kfinance_api_client,
-                    company_id=company["company_id"],
-                    company_name=company["company_name"],
+                    company_id=company.company_id,
+                    company_name=company.company_name,
                 )
-                for company in competitors_data
+                for company in competitors_data.competitors
             ],
         )
 

kfinance/{decimal_with_unit.py → client/models/decimal_with_unit.py}

@@ -5,7 +5,7 @@ from typing import Any
 from pydantic import BaseModel, Field, model_validator
 from typing_extensions import Self
 
-from kfinance.models.currency_models import ISO_CODE_TO_CURRENCY
+from kfinance.client.models.currency_models import ISO_CODE_TO_CURRENCY
 
 
 class DecimalWithUnit(BaseModel):

kfinance/{tests → client/models/tests}/test_decimal_with_unit.py

@@ -3,7 +3,7 @@ from typing import Any
 
 import pytest
 
-from kfinance.decimal_with_unit import DecimalWithUnit, Money, Shares
+from kfinance.client.models.decimal_with_unit import DecimalWithUnit, Money, Shares
 
 
 class TestDecimalWithUnit:

kfinance/{tests → client/tests}/test_batch_requests.py

@@ -9,16 +9,18 @@ import pytest
 import requests
 import requests_mock
 
-from kfinance.batch_request_handling import MAX_WORKERS_CAP
-from kfinance.decimal_with_unit import Money, Shares
-from kfinance.fetch import KFinanceApiClient
-from kfinance.kfinance import Companies, Company, Ticker, TradingItem, TradingItems
-from kfinance.models.price_models import PriceHistory, Prices
+from kfinance.client.batch_request_handling import MAX_WORKERS_CAP
+from kfinance.client.fetch import KFinanceApiClient
+from kfinance.client.kfinance import Companies, Company, Ticker, TradingItem, TradingItems
+from kfinance.client.models.decimal_with_unit import Money, Shares
+from kfinance.domains.prices.price_models import PriceHistory, Prices
 
 
 @pytest.fixture(autouse=True)
 def mock_method():
-    with patch("kfinance.fetch.KFinanceApiClient.access_token", return_value="fake_access_token"):
+    with patch(
+        "kfinance.client.fetch.KFinanceApiClient.access_token", return_value="fake_access_token"
+    ):
         yield
 
 

kfinance/{tests → client/tests}/test_client.py

@@ -2,18 +2,20 @@ from unittest.mock import Mock
 
 import pytest
 
-from kfinance.kfinance import Client
-from kfinance.models.permission_models import Permission
-from kfinance.tool_calling import (
-    GetBusinessRelationshipFromIdentifier,
-    GetEarnings,
-    GetFinancialStatementFromIdentifier,
-    GetLatest,
-    GetLatestEarnings,
-    GetNextEarnings,
-    GetTranscript,
+from kfinance.client.kfinance import Client
+from kfinance.client.permission_models import Permission
+from kfinance.domains.business_relationships.business_relationship_tools import (
+    GetBusinessRelationshipFromIdentifiers,
 )
-from kfinance.tool_calling.shared_models import KfinanceTool
+from kfinance.domains.earnings.earning_tools import (
+    GetEarningsFromIdentifiers,
+    GetLatestEarningsFromIdentifiers,
+    GetNextEarningsFromIdentifiers,
+    GetTranscriptFromKeyDevId,
+)
+from kfinance.domains.statements.statement_tools import GetFinancialStatementFromIdentifiers
+from kfinance.integrations.tool_calling.static_tools.get_latest import GetLatest
+from kfinance.integrations.tool_calling.tool_calling_models import KfinanceTool
 
 
 class TestLangchainTools:
@@ -52,19 +54,23 @@ class TestLangchainTools:
         mock_client.kfinance_api_client._user_permissions = {Permission.RelationshipPermission}  # noqa: SLF001
         tool_classes = [type(t) for t in mock_client.langchain_tools]
         # User should have access to GetBusinessRelationshipFromIdentifier
-        assert GetBusinessRelationshipFromIdentifier in tool_classes
+        assert GetBusinessRelationshipFromIdentifiers in tool_classes
         # User should have access to functions that don't require permissions
         assert GetLatest in tool_classes
         # User should not have access to functions that require statement permissions
-        assert GetFinancialStatementFromIdentifier not in tool_classes
+        assert GetFinancialStatementFromIdentifiers not in tool_classes
 
     @pytest.mark.parametrize(
         "user_permission, expected_tool",
         [
             pytest.param(
-                Permission.TranscriptsPermission, GetTranscript, id="Transcript Permissions"
+                Permission.TranscriptsPermission,
+                GetTranscriptFromKeyDevId,
+                id="Transcript Permissions",
+            ),
+            pytest.param(
+                Permission.EarningsPermission, GetEarningsFromIdentifiers, id="Earnings Permissions"
             ),
-            pytest.param(Permission.EarningsPermission, GetEarnings, id="Earnings Permissions"),
         ],
     )
     def test_permission_set_handling(
@@ -79,11 +85,11 @@ class TestLangchainTools:
         mock_client.kfinance_api_client._user_permissions = {user_permission}  # noqa: SLF001
         tool_classes = [type(t) for t in mock_client.langchain_tools]
         # User should have access to GetEarnings, GetNextEarnings, GetLatestEarnings, GetTranscript
-        assert GetEarnings in tool_classes
-        assert GetNextEarnings in tool_classes
-        assert GetLatestEarnings in tool_classes
+        assert GetEarningsFromIdentifiers in tool_classes
+        assert GetNextEarningsFromIdentifiers in tool_classes
+        assert GetLatestEarningsFromIdentifiers in tool_classes
         assert expected_tool in tool_classes
         # User should have access to functions that don't require permissions
         assert GetLatest in tool_classes
         # User should not have access to functions that require statement permissions
-        assert GetFinancialStatementFromIdentifier not in tool_classes
+        assert GetFinancialStatementFromIdentifiers not in tool_classes

kfinance/{tests → client/tests}/test_fetch.py

@@ -5,16 +5,15 @@ from pydantic import ValidationError
 import pytest
 from requests_mock import Mocker
 
-from kfinance.fetch import KFinanceApiClient
-from kfinance.kfinance import Client
-from kfinance.models.business_relationship_models import BusinessRelationshipType
-from kfinance.models.date_and_period_models import Periodicity, PeriodType
-from kfinance.pydantic_models import (
-    CompanyIdAndName,
+from kfinance.client.fetch import KFinanceApiClient
+from kfinance.client.kfinance import Client
+from kfinance.client.models.date_and_period_models import Periodicity, PeriodType
+from kfinance.conftest import SPGI_COMPANY_ID
+from kfinance.domains.business_relationships.business_relationship_models import (
+    BusinessRelationshipType,
     RelationshipResponse,
-    RelationshipResponseNoName,
 )
-from kfinance.tests.conftest import SPGI_COMPANY_ID
+from kfinance.domains.companies.company_models import CompanyIdAndName
 
 
 def build_mock_api_client() -> KFinanceApiClient:
@@ -150,7 +149,8 @@ class TestFetchItem(TestCase):
     def test_fetch_earnings(self) -> None:
         company_id = 21719
         expected_fetch_url = f"{self.kfinance_api_client.url_base}earnings/{company_id}"
-        self.kfinance_api_client.fetch_earnings(company_id=company_id)
+        with pytest.raises(ValidationError):
+            self.kfinance_api_client.fetch_earnings(company_id=company_id)
         self.kfinance_api_client.fetch.assert_called_once_with(expected_fetch_url)
 
     def test_fetch_transcript(self) -> None:
@@ -334,28 +334,10 @@ class TestMarketCap:
 
 
 class TestFetchCompaniesFromBusinessRelationship:
-    def test_old_response_format(self, requests_mock: Mocker, mock_client: Client) -> None:
-        """
-        GIVEN a business relationship request
-        WHEN the api returns a response in the old (no name) format
-        THEN the response can successfully be parsed.
-        """
-        http_resp = {"current": [883103], "previous": [472898, 8182358]}
-        expected_result = RelationshipResponseNoName(current=[883103], previous=[472898, 8182358])
-        requests_mock.get(
-            url=f"{mock_client.kfinance_api_client.url_base}relationship/{SPGI_COMPANY_ID}/{BusinessRelationshipType.supplier}",
-            json=http_resp,
-        )
-
-        resp = mock_client.kfinance_api_client.fetch_companies_from_business_relationship(
-            company_id=SPGI_COMPANY_ID, relationship_type=BusinessRelationshipType.supplier
-        )
-        assert resp == expected_result
-
-    def test_new_response_format(self, requests_mock: Mocker, mock_client: Client) -> None:
+    def test_fetch_business_relationships(self, requests_mock: Mocker, mock_client: Client) -> None:
         """
         GIVEN a business relationship request
-        WHEN the api returns a response in the new (with name) format
+        WHEN the api returns a response
         THEN the response can successfully be parsed.
         """