kensho-kfinance 3.0.2__py3-none-any.whl → 3.1.0__py3-none-any.whl

kfinance/domains/capitalizations/capitalization_tools.py

@@ -6,14 +6,11 @@ from pydantic import BaseModel, Field
 
 from kfinance.client.batch_request_handling import Task, process_tasks_in_thread_pool_executor
 from kfinance.client.permission_models import Permission
-from kfinance.domains.capitalizations.capitalization_models import Capitalization
-from kfinance.domains.companies.company_identifiers import (
-    fetch_company_ids_from_identifiers,
-    parse_identifiers,
-)
+from kfinance.domains.capitalizations.capitalization_models import Capitalization, Capitalizations
 from kfinance.integrations.tool_calling.tool_calling_models import (
     KfinanceTool,
     ToolArgsWithIdentifiers,
+    ToolRespWithErrors,
 )
 
 
@@ -28,6 +25,10 @@ class GetCapitalizationFromIdentifiersArgs(ToolArgsWithIdentifiers):
     )
 
 
+class GetCapitalizationFromIdentifiersResp(ToolRespWithErrors):
+    results: dict[str, Capitalizations]
+
+
 class GetCapitalizationFromIdentifiers(KfinanceTool):
     name: str = "get_capitalization_from_identifiers"
     description: str = dedent("""
@@ -53,37 +54,53 @@ class GetCapitalizationFromIdentifiers(KfinanceTool):
         """Sample response:
 
         {
-            'SPGI': [
-                {'date': '2024-04-10', 'market_cap': {'unit': 'USD', 'value': '132766738270.00'}},
-                {'date': '2024-04-11', 'market_cap': {'unit': 'USD', 'value': '132416066761.00'}}
-            ]
+            'results': {
+                'SPGI': {
+                    'capitalizations': [
+                        {'date': '2024-04-10', 'market_cap': {'value': '132766738270.00', 'unit': 'USD'}},
+                        {'date': '2024-04-11', 'market_cap': {'value': '132416066761.00', 'unit': 'USD'}}
+                    ]
+                }
+            },
+            'errors': ['No identification triple found for the provided identifier: NON-EXISTENT of type: ticker']
         }
         """
         api_client = self.kfinance_client.kfinance_api_client
-        parsed_identifiers = parse_identifiers(identifiers=identifiers, api_client=api_client)
-        identifiers_to_company_ids = fetch_company_ids_from_identifiers(
-            identifiers=parsed_identifiers, api_client=api_client
-        )
+        id_triple_resp = api_client.unified_fetch_id_triples(identifiers=identifiers)
 
         tasks = [
             Task(
                 func=api_client.fetch_market_caps_tevs_and_shares_outstanding,
-                kwargs=dict(company_id=company_id, start_date=start_date, end_date=end_date),
+                kwargs=dict(
+                    company_id=id_triple.company_id, start_date=start_date, end_date=end_date
+                ),
                 result_key=identifier,
             )
-            for identifier, company_id in identifiers_to_company_ids.items()
+            for identifier, id_triple in id_triple_resp.identifiers_to_id_triples.items()
         ]
 
         capitalization_responses = process_tasks_in_thread_pool_executor(
             api_client=api_client, tasks=tasks
         )
 
-        return {
-            str(identifier): capitalization_response.model_dump_json_single_metric(
-                capitalization_metric=capitalization,
-                only_include_most_recent_value=True
-                if (len(identifiers) > 1 and start_date == end_date is None)
-                else False,
-            )
-            for identifier, capitalization_response in capitalization_responses.items()
-        }
+        for capitalization_response in capitalization_responses.values():
+            # If we return results for more than one company and the start and end dates are unset,
+            # truncate data to only return the most recent datapoint.
+            if len(capitalization_responses) > 1 and start_date is None and end_date is None:
+                capitalization_response.capitalizations = capitalization_response.capitalizations[
+                    -1:
+                ]
+            # Set capitalizations that were not requested to None.
+            # That way, they can be skipped for serialization via `exclude_none=True`
+            for daily_capitalization in capitalization_response.capitalizations:
+                if capitalization is not Capitalization.market_cap:
+                    daily_capitalization.market_cap = None
+                if capitalization is not Capitalization.tev:
+                    daily_capitalization.tev = None
+                if capitalization is not Capitalization.shares_outstanding:
+                    daily_capitalization.shares_outstanding = None
+
+        resp_model = GetCapitalizationFromIdentifiersResp(
+            results=capitalization_responses, errors=list(id_triple_resp.errors.values())
+        )
+        return resp_model.model_dump(mode="json", exclude_none=True)

kfinance/domains/capitalizations/tests/test_capitalization_tools.py

@@ -32,8 +32,8 @@ class TestGetCapitalizationFromCompanyIds:
     def test_get_capitalization_from_identifiers(self, requests_mock: Mocker, mock_client: Client):
         """
         GIVEN the GetCapitalizationFromIdentifiers tool
-        WHEN we request the SPGI market cap
-        THEN we get back the SPGI market cap
+        WHEN we request the market cap for SPGI and a non-existent company
+        THEN we get back the SPGI market cap and error for the non-existent company
         """
         requests_mock.get(
             url=f"https://kfinance.kensho.com/api/v1/market_cap/{SPGI_COMPANY_ID}/none/none",
@@ -41,15 +41,28 @@ class TestGetCapitalizationFromCompanyIds:
         )
 
         expected_response = {
-            "SPGI": [
-                {"date": "2024-04-10", "market_cap": {"unit": "USD", "value": "132766738270.00"}},
-                {"date": "2024-04-11", "market_cap": {"unit": "USD", "value": "132416066761.00"}},
-            ]
+            "results": {
+                "SPGI": {
+                    "capitalizations": [
+                        {
+                            "date": "2024-04-10",
+                            "market_cap": {"value": "132766738270.00", "unit": "USD"},
+                        },
+                        {
+                            "date": "2024-04-11",
+                            "market_cap": {"value": "132416066761.00", "unit": "USD"},
+                        },
+                    ]
+                }
+            },
+            "errors": [
+                "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
+            ],
         }
 
         tool = GetCapitalizationFromIdentifiers(kfinance_client=mock_client)
         args = GetCapitalizationFromIdentifiersArgs(
-            identifiers=["SPGI"], capitalization=Capitalization.market_cap
+            identifiers=["SPGI", "non-existent"], capitalization=Capitalization.market_cap
         )
         response = tool.run(args.model_dump(mode="json"))
         assert response == expected_response
@@ -61,12 +74,24 @@ class TestGetCapitalizationFromCompanyIds:
         THEN we only get back the most recent market cap for each company
         """
         expected_response = {
-            "C_1": [
-                {"date": "2024-04-10", "market_cap": {"unit": "USD", "value": "132766738270.00"}}
-            ],
-            "C_2": [
-                {"date": "2024-04-10", "market_cap": {"unit": "USD", "value": "132766738270.00"}}
-            ],
+            "results": {
+                "C_1": {
+                    "capitalizations": [
+                        {
+                            "date": "2024-04-11",
+                            "market_cap": {"unit": "USD", "value": "132416066761.00"},
+                        }
+                    ]
+                },
+                "C_2": {
+                    "capitalizations": [
+                        {
+                            "date": "2024-04-11",
+                            "market_cap": {"unit": "USD", "value": "132416066761.00"},
+                        }
+                    ]
+                },
+            }
         }
 
         company_ids = [1, 2]

kfinance/domains/companies/company_identifiers.py

@@ -1,175 +0,0 @@
-from dataclasses import dataclass
-from typing import Hashable, Protocol
-
-from kfinance.client.batch_request_handling import Task, process_tasks_in_thread_pool_executor
-from kfinance.client.fetch import KFinanceApiClient
-from kfinance.domains.companies.company_models import COMPANY_ID_PREFIX, IdentificationTriple
-
-
-class CompanyIdentifier(Protocol, Hashable):
-    """A CompanyIdentifier is an identifier that can be resolved to a company, security, or trading item id.
-
-    The two current identifiers are:
-    - Ticker/CUSIP/ISIN (resolve through ID triple)
-    - company id (from tools like business relationships)
-
-    These identifiers both have ways of fetching company, security, and trading
-    item ids but the paths differ, so this protocol defines the functional requirements
-    and leaves the implementation to sub classes.
-    """
-
-    api_client: KFinanceApiClient
-
-    def fetch_company_id(self) -> int:
-        """Return the company_id associated with the CompanyIdentifier."""
-
-    def fetch_security_id(self) -> int:
-        """Return the security_id associated with the CompanyIdentifier."""
-
-    def fetch_trading_item_id(self) -> int:
-        """Return the trading_item_id associated with the CompanyIdentifier."""
-
-
-@dataclass
-class Identifier(CompanyIdentifier):
-    """An identifier (ticker, CUSIP, ISIN), which can be resolved to company, security, or trading item id.
-
-    The resolution happens by fetching the id triple.
-    """
-
-    identifier: str
-    api_client: KFinanceApiClient
-    _id_triple: IdentificationTriple | None = None
-
-    def __str__(self) -> str:
-        return self.identifier
-
-    def __hash__(self) -> int:
-        return hash(self.identifier)
-
-    @property
-    def id_triple(self) -> IdentificationTriple:
-        """Return the id triple of the company."""
-        if self._id_triple is None:
-            id_triple_resp = self.api_client.fetch_id_triple(identifier=self.identifier)
-            self._id_triple = IdentificationTriple(
-                trading_item_id=id_triple_resp["trading_item_id"],
-                security_id=id_triple_resp["security_id"],
-                company_id=id_triple_resp["company_id"],
-            )
-        return self._id_triple
-
-    def fetch_company_id(self) -> int:
-        """Return the company_id associated with the Identifier."""
-        return self.id_triple.company_id
-
-    def fetch_security_id(self) -> int:
-        """Return the security_id associated with the Identifier."""
-        return self.id_triple.security_id
-
-    def fetch_trading_item_id(self) -> int:
-        """Return the trading_item_id associated with the Identifier."""
-        return self.id_triple.trading_item_id
-
-
-@dataclass
-class CompanyId(CompanyIdentifier):
-    """A company id, which can be resolved to security and trading item id.
-
-    The resolution happens by fetching the primary security and trading item id
-    associated with the company id.
-    """
-
-    company_id: int
-    api_client: KFinanceApiClient
-    _security_id: int | None = None
-    _trading_item_id: int | None = None
-
-    def __str__(self) -> str:
-        return f"{COMPANY_ID_PREFIX}{self.company_id}"
-
-    def __hash__(self) -> int:
-        return hash(self.company_id)
-
-    def fetch_company_id(self) -> int:
-        """Return the company_id."""
-        return self.company_id
-
-    def fetch_security_id(self) -> int:
-        """Return the security_id associated with the CompanyId."""
-        if self._security_id is None:
-            security_resp = self.api_client.fetch_primary_security(company_id=self.company_id)
-            self._security_id = security_resp["primary_security"]
-        return self._security_id
-
-    def fetch_trading_item_id(self) -> int:
-        """Return the trading_item_id associated with the CompanyId."""
-        if self._trading_item_id is None:
-            trading_item_resp = self.api_client.fetch_primary_trading_item(
-                security_id=self.fetch_security_id()
-            )
-            self._trading_item_id = trading_item_resp["primary_trading_item"]
-        return self._trading_item_id
-
-
-def parse_identifiers(
-    identifiers: list[str], api_client: KFinanceApiClient
-) -> list[CompanyIdentifier]:
-    """Return a list of CompanyIdentifier based on a list of string identifiers."""
-
-    parsed_identifiers: list[CompanyIdentifier] = []
-    for identifier in identifiers:
-        if identifier.startswith(COMPANY_ID_PREFIX):
-            parsed_identifiers.append(
-                CompanyId(
-                    company_id=int(identifier[len(COMPANY_ID_PREFIX) :]), api_client=api_client
-                )
-            )
-        else:
-            parsed_identifiers.append(Identifier(identifier=identifier, api_client=api_client))
-
-    return parsed_identifiers
-
-
-def fetch_company_ids_from_identifiers(
-    identifiers: list[CompanyIdentifier], api_client: KFinanceApiClient
-) -> dict[CompanyIdentifier, int]:
-    """Resolve a list of CompanyIdentifier to the corresponding company_ids."""
-
-    tasks = [
-        Task(
-            func=identifier.fetch_company_id,
-            result_key=identifier,
-        )
-        for identifier in identifiers
-    ]
-    return process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)
-
-
-def fetch_security_ids_from_identifiers(
-    identifiers: list[CompanyIdentifier], api_client: KFinanceApiClient
-) -> dict[CompanyIdentifier, int]:
-    """Resolve a list of CompanyIdentifier to the corresponding security_ids."""
-
-    tasks = [
-        Task(
-            func=identifier.fetch_security_id,
-            result_key=identifier,
-        )
-        for identifier in identifiers
-    ]
-    return process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)
-
-
-def fetch_trading_item_ids_from_identifiers(
-    identifiers: list[CompanyIdentifier], api_client: KFinanceApiClient
-) -> dict[CompanyIdentifier, int]:
-    """Resolve a list of CompanyIdentifier to the corresponding trading_item_ids."""
-    tasks = [
-        Task(
-            func=identifier.fetch_trading_item_id,
-            result_key=identifier,
-        )
-        for identifier in identifiers
-    ]
-    return process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)

kfinance/domains/companies/company_models.py

@@ -1,11 +1,16 @@
-from typing import NamedTuple
+from typing import Any
 
-from pydantic import BaseModel, field_serializer
+from pydantic import BaseModel, ConfigDict, Field, field_serializer, model_validator
 
 
 COMPANY_ID_PREFIX = "C_"
 
 
+def prefix_company_id(company_id: int) -> str:
+    """Return the company_id with the COMPANY_ID_PREFIX"""
+    return f"{COMPANY_ID_PREFIX}{company_id}"
+
+
 class CompanyIdAndName(BaseModel):
     """A company_id and name"""
 
@@ -21,7 +26,95 @@ class CompanyIdAndName(BaseModel):
         return f"{COMPANY_ID_PREFIX}{company_id}"
 
 
-class IdentificationTriple(NamedTuple):
-    trading_item_id: int
-    security_id: int
+class IdentificationTriple(BaseModel):
     company_id: int
+    security_id: int | None = Field(description="Private companies do not have a security_id.")
+    trading_item_id: int | None = Field(
+        description="Private companies do not have a trading_item_id."
+    )
+
+    # frozen to allow hashing
+    model_config = ConfigDict(frozen=True)
+
+
+class IdTripleResolutionError(BaseModel):
+    """Error returned when an identifier cannot be resolved."""
+
+    error: str
+
+
+class UnifiedIdTripleResponse(BaseModel):
+    """A response from the unified id triple endpoint (POST /ids).
+
+    For easier handling within tools, we split the api response into
+    identifiers_to_id_triples (successful resolution) and errors (resolution failed).
+    """
+
+    identifiers_to_id_triples: dict[str, IdentificationTriple] = Field(
+        description="A mapping of all identifiers that could successfully be resolved"
+        "to the corresponding identification triples."
+    )
+    errors: dict[str, str] = Field(
+        description="A mapping of all identifiers that could not be resolved or don't have "
+        "a required field like security_id with the corresponding error messages."
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def separate_successful_and_failed_resolutions(cls, data: Any) -> Any:
+        """Split response into identifiers_to_id_triples (success) and errors
+
+        Pre-processed API response:
+        {
+            'data': {
+                'SPGI': {'trading_item_id': 2629108, 'security_id': 2629107, 'company_id': 21719},
+                'non-existent': {'error': 'No identification triple found for the provided identifier: NON-EXISTENT of type: ticker'}
+            }
+        }
+
+        Post-processed API response:
+        {
+            'identifiers_to_id_triples': {
+                'SPGI': {'trading_item_id': 2629108, 'security_id': 2629107, 'company_id': 21719},
+            },
+            'errors': {
+                'non-existent': 'No identification triple found for the provided identifier: NON-EXISTENT of type: ticker'
+            }
+        }
+
+
+        """
+        output: dict[str, dict] = dict(identifiers_to_id_triples=dict(), errors=dict())
+        if isinstance(data, dict) and "data" in data:
+            for key, val in data["data"].items():
+                if "error" in val:
+                    output["errors"][key] = val["error"]
+                else:
+                    output["identifiers_to_id_triples"][key] = val
+        return output
+
+    def filter_out_companies_without_security_ids(self) -> None:
+        """Filter out companies that don't have a security_id and add an error for them."""
+
+        identifiers_to_remove = [
+            identifier
+            for identifier, id_triple in self.identifiers_to_id_triples.items()
+            if id_triple.security_id is None
+        ]
+        for identifier in identifiers_to_remove:
+            self.errors[identifier] = f"{identifier} is a private company without a security_id."
+            self.identifiers_to_id_triples.pop(identifier)
+
+    def filter_out_companies_without_trading_item_ids(self) -> None:
+        """Filter out companies that don't have a trading_item_id and add an error for them."""
+
+        identifiers_to_remove = [
+            identifier
+            for identifier, id_triple in self.identifiers_to_id_triples.items()
+            if id_triple.trading_item_id is None
+        ]
+        for identifier in identifiers_to_remove:
+            self.errors[identifier] = (
+                f"{identifier} is a private company without a trading_item_id."
+            )
+            self.identifiers_to_id_triples.pop(identifier)

kfinance/domains/companies/company_tools.py

@@ -5,16 +5,17 @@ from pydantic import BaseModel
 
 from kfinance.client.batch_request_handling import Task, process_tasks_in_thread_pool_executor
 from kfinance.client.permission_models import Permission
-from kfinance.domains.companies.company_identifiers import (
-    fetch_company_ids_from_identifiers,
-    parse_identifiers,
-)
 from kfinance.integrations.tool_calling.tool_calling_models import (
     KfinanceTool,
     ToolArgsWithIdentifiers,
+    ToolRespWithErrors,
 )
 
 
+class GetInfoFromIdentifiersResp(ToolRespWithErrors):
+    results: dict[str, dict]
+
+
 class GetInfoFromIdentifiers(KfinanceTool):
     name: str = "get_info_from_identifiers"
     description: str = dedent("""
@@ -28,39 +29,42 @@ class GetInfoFromIdentifiers(KfinanceTool):
     def _run(self, identifiers: list[str]) -> dict:
         """Sample response:
 
-        {
-            "SPGI": {
-                "name": "S&P Global Inc.",
-                "status": "Operating",
-                "type": "Public Company",
-                "simple_industry": "Capital Markets",
-                "number_of_employees": "42350.0000",
-                "founding_date": "1860-01-01",
-                "webpage": "www.spglobal.com",
-                "address": "55 Water Street",
-                "city": "New York",
-                "zip_code": "10041-0001",
-                "state": "New York",
-                "country": "United States",
-                "iso_country": "USA"
-            }
+        {   "results": {
+                "SPGI": {
+                    "name": "S&P Global Inc.",
+                    "status": "Operating",
+                    "type": "Public Company",
+                    "simple_industry": "Capital Markets",
+                    "number_of_employees": "42350.0000",
+                    "founding_date": "1860-01-01",
+                    "webpage": "www.spglobal.com",
+                    "address": "55 Water Street",
+                    "city": "New York",
+                    "zip_code": "10041-0001",
+                    "state": "New York",
+                    "country": "United States",
+                    "iso_country": "USA"
+                }
+            },
+            "errors": [['No identification triple found for the provided identifier: NON-EXISTENT of type: ticker']
         }
         """
         api_client = self.kfinance_client.kfinance_api_client
-        parsed_identifiers = parse_identifiers(identifiers=identifiers, api_client=api_client)
-        identifiers_to_company_ids = fetch_company_ids_from_identifiers(
-            identifiers=parsed_identifiers, api_client=api_client
-        )
+        id_triple_resp = api_client.unified_fetch_id_triples(identifiers=identifiers)
 
         tasks = [
             Task(
                 func=api_client.fetch_info,
-                kwargs=dict(company_id=company_id),
+                kwargs=dict(company_id=id_triple.company_id),
                 result_key=identifier,
             )
-            for identifier, company_id in identifiers_to_company_ids.items()
+            for identifier, id_triple in id_triple_resp.identifiers_to_id_triples.items()
         ]
 
-        info_responses = process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)
-
-        return {str(identifier): result for identifier, result in info_responses.items()}
+        info_responses: dict[str, dict] = process_tasks_in_thread_pool_executor(
+            api_client=api_client, tasks=tasks
+        )
+        resp_model = GetInfoFromIdentifiersResp(
+            results=info_responses, errors=list(id_triple_resp.errors.values())
+        )
+        return resp_model.model_dump(mode="json")

kfinance/domains/companies/tests/test_company_tools.py

@@ -10,17 +10,24 @@ class TestGetInfoFromIdentifiers:
     def test_get_info_from_identifiers(self, mock_client: Client, requests_mock: Mocker):
         """
         GIVEN the GetInfoFromIdentifiers tool
-        WHEN request info for SPGI
-        THEN we get back info for SPGI
+        WHEN request info for SPGI and a non-existent company
+        THEN we get back info for SPGI and an error for the non-existent company
         """
 
         info_resp = {"name": "S&P Global Inc.", "status": "Operating"}
-        expected_response = {"SPGI": info_resp}
+        expected_response = {
+            "results": {"SPGI": info_resp},
+            "errors": [
+                "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
+            ],
+        }
         requests_mock.get(
             url=f"https://kfinance.kensho.com/api/v1/info/{SPGI_COMPANY_ID}",
             json=info_resp,
         )
 
         tool = GetInfoFromIdentifiers(kfinance_client=mock_client)
-        resp = tool.run(ToolArgsWithIdentifiers(identifiers=["SPGI"]).model_dump(mode="json"))
+        resp = tool.run(
+            ToolArgsWithIdentifiers(identifiers=["SPGI", "non-existent"]).model_dump(mode="json")
+        )
         assert resp == expected_response

kfinance/domains/competitors/competitor_tools.py

@@ -1,14 +1,10 @@
 from kfinance.client.batch_request_handling import Task, process_tasks_in_thread_pool_executor
 from kfinance.client.permission_models import Permission
-from kfinance.domains.companies.company_identifiers import (
-    Identifier,
-    fetch_company_ids_from_identifiers,
-    parse_identifiers,
-)
 from kfinance.domains.competitors.competitor_models import CompetitorResponse, CompetitorSource
 from kfinance.integrations.tool_calling.tool_calling_models import (
     KfinanceTool,
     ToolArgsWithIdentifiers,
+    ToolRespWithErrors,
 )
 
 
@@ -17,6 +13,10 @@ class GetCompetitorsFromIdentifiersArgs(ToolArgsWithIdentifiers):
     competitor_source: CompetitorSource
 
 
+class GetCompetitorsFromIdentifiersResp(ToolRespWithErrors):
+    results: dict[str, CompetitorResponse]
+
+
 class GetCompetitorsFromIdentifiers(KfinanceTool):
     name: str = "get_competitors_from_identifiers"
     description: str = "Retrieves a list of company_id and company_name that are competitors for a list of companies, optionally filtered by the source of the competitor information."
@@ -31,32 +31,32 @@ class GetCompetitorsFromIdentifiers(KfinanceTool):
         """Sample response:
 
         {
-            SPGI: {
-                {'company_id': "C_35352", 'company_name': 'The Descartes Systems Group Inc.'},
-                {'company_id': "C_4003514", 'company_name': 'London Stock Exchange Group plc'}
-            }
+            "results": {
+                "SPGI": {
+                    {'company_id': "C_35352", 'company_name': 'The Descartes Systems Group Inc.'},
+                    {'company_id': "C_4003514", 'company_name': 'London Stock Exchange Group plc'}
+                }
+            },
+            'errors': ['No identification triple found for the provided identifier: NON-EXISTENT of type: ticker']
         }
         """
 
         api_client = self.kfinance_client.kfinance_api_client
-        parsed_identifiers = parse_identifiers(identifiers=identifiers, api_client=api_client)
-        identifiers_to_company_ids = fetch_company_ids_from_identifiers(
-            identifiers=parsed_identifiers, api_client=api_client
-        )
+        id_triple_resp = api_client.unified_fetch_id_triples(identifiers=identifiers)
 
         tasks = [
             Task(
                 func=api_client.fetch_competitors,
-                kwargs=dict(company_id=company_id, competitor_source=competitor_source),
+                kwargs=dict(company_id=id_triple.company_id, competitor_source=competitor_source),
                 result_key=identifier,
             )
-            for identifier, company_id in identifiers_to_company_ids.items()
+            for identifier, id_triple in id_triple_resp.identifiers_to_id_triples.items()
         ]
 
-        competitor_responses: dict[Identifier, CompetitorResponse] = (
-            process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)
+        competitor_responses: dict[str, CompetitorResponse] = process_tasks_in_thread_pool_executor(
+            api_client=api_client, tasks=tasks
         )
-        return {
-            str(identifier): competitors.model_dump(mode="json")
-            for identifier, competitors in competitor_responses.items()
-        }
+        resp_model = GetCompetitorsFromIdentifiersResp(
+            results=competitor_responses, errors=list(id_triple_resp.errors.values())
+        )
+        return resp_model.model_dump(mode="json")