kensho-kfinance 3.2.4__py3-none-any.whl → 4.0.0__py3-none-any.whl

kfinance/domains/mergers_and_acquisitions/tests/test_merger_and_acquisition_tools.py

@@ -8,13 +8,18 @@ from kfinance.client.tests.test_objects import (
     ordered,
 )
 from kfinance.conftest import SPGI_COMPANY_ID
-from kfinance.domains.companies.company_models import COMPANY_ID_PREFIX
+from kfinance.domains.mergers_and_acquisitions.merger_and_acquisition_models import (
+    AdvisorResp,
+    MergerInfo,
+)
 from kfinance.domains.mergers_and_acquisitions.merger_and_acquisition_tools import (
     GetAdvisorsForCompanyInTransactionFromIdentifier,
     GetAdvisorsForCompanyInTransactionFromIdentifierArgs,
+    GetAdvisorsForCompanyInTransactionFromIdentifierResp,
     GetMergerInfoFromTransactionId,
     GetMergerInfoFromTransactionIdArgs,
     GetMergersFromIdentifiers,
+    GetMergersFromIdentifiersResp,
 )
 from kfinance.integrations.tool_calling.tool_calling_models import ToolArgsWithIdentifiers
 
@@ -27,12 +32,14 @@ class TestGetMergersFromIdentifiers:
         THEN we get back the SPGI mergers and an error for the non-existent company"""
 
         merger_data = MERGERS_RESP.model_dump(mode="json")
-        expected_response = {
-            "results": {"SPGI": merger_data},
-            "errors": [
-                "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
-            ],
-        }
+        expected_response = GetMergersFromIdentifiersResp.model_validate(
+            {
+                "results": {"SPGI": merger_data},
+                "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/mergers/{SPGI_COMPANY_ID}", json=merger_data
         )
@@ -51,13 +58,21 @@ class TestGetCompaniesAdvisingCompanyInTransactionFromIdentifier:
             "advisor_company_name": "Kensho Technologies, Inc.",
             "advisor_type_name": "Professional Mongo Enjoyer",
         }
-        api_response = {"advisors": [deepcopy(advisor_data)]}
-        expected_response = {"results": [deepcopy(advisor_data)]}
-        expected_response["results"][0]["advisor_company_id"] = f"{COMPANY_ID_PREFIX}251994106"
+        expected_response = GetAdvisorsForCompanyInTransactionFromIdentifierResp(
+            results=[
+                AdvisorResp(
+                    advisor_company_id=251994106,
+                    advisor_company_name="Kensho Technologies, Inc.",
+                    advisor_type_name="Professional Mongo Enjoyer",
+                )
+            ],
+            errors=[],
+        )
+
         transaction_id = 554979212
         requests_mock.get(
             url=f"https://kfinance.kensho.com/api/v1/merger/info/{transaction_id}/advisors/{SPGI_COMPANY_ID}",
-            json=api_response,
+            json={"advisors": [deepcopy(advisor_data)]},
         )
         tool = GetAdvisorsForCompanyInTransactionFromIdentifier(kfinance_client=mock_client)
         args = GetAdvisorsForCompanyInTransactionFromIdentifierArgs(
@@ -67,14 +82,14 @@ class TestGetCompaniesAdvisingCompanyInTransactionFromIdentifier:
         assert response == expected_response
 
     def test_get_companies_advising_company_in_transaction_from_bad_identifier(
-        self, requests_mock: Mocker, mock_client: Client
+        self, mock_client: Client
     ):
-        expected_response = {
-            "results": [],
-            "errors": [
+        expected_response = GetAdvisorsForCompanyInTransactionFromIdentifierResp(
+            results=[],
+            errors=[
                 "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
             ],
-        }
+        )
         transaction_id = 554979212
         tool = GetAdvisorsForCompanyInTransactionFromIdentifier(kfinance_client=mock_client)
         args = GetAdvisorsForCompanyInTransactionFromIdentifierArgs(
@@ -86,30 +101,11 @@ class TestGetCompaniesAdvisingCompanyInTransactionFromIdentifier:
 
 class TestGetMergerInfoFromTransactionId:
     def test_get_merger_info_from_transaction_id(self, requests_mock: Mocker, mock_client: Client):
-        response_base = {
-            "timeline": [
-                {"status": "Announced", "date": "2000-09-12"},
-                {"status": "Closed", "date": "2000-09-12"},
-            ],
-            "participants": {},
-            "consideration": {
-                "currency_name": "US Dollar",
-                "current_calculated_gross_total_transaction_value": "51609375.000000",
-                "current_calculated_implied_equity_value": "51609375.000000",
-                "current_calculated_implied_enterprise_value": "51609375.000000",
-                "details": [
-                    {
-                        "scenario": "Stock Lump Sum",
-                        "subtype": "Common Equity",
-                        "cash_or_cash_equivalent_per_target_share_unit": None,
-                        "number_of_target_shares_sought": "1000000.000000",
-                        "current_calculated_gross_value_of_consideration": "51609375.000000",
-                    }
-                ],
-            },
-        }
-
-        participants_api_response = {
+        timeline_resp = [
+            {"status": "Announced", "date": "2000-09-12"},
+            {"status": "Closed", "date": "2000-09-12"},
+        ]
+        participants_resp = {
             "target": {"company_id": 31696, "company_name": "MongoMusic, Inc."},
             "buyers": [{"company_id": 21835, "company_name": "Microsoft Corporation"}],
             "sellers": [
@@ -117,33 +113,39 @@ class TestGetMergerInfoFromTransactionId:
                 {"company_id": 20087, "company_name": "Draper Richards, L.P."},
             ],
         }
-        api_response = deepcopy(response_base)
-        api_response["participants"] = participants_api_response
 
-        # Returned company IDs should be prefixed
-        expected_participants_tool_response = {
-            "target": {
-                "company_id": f"{COMPANY_ID_PREFIX}31696",
-                "company_name": "MongoMusic, Inc.",
-            },
-            "buyers": [
-                {"company_id": f"{COMPANY_ID_PREFIX}21835", "company_name": "Microsoft Corporation"}
-            ],
-            "sellers": [
-                {"company_id": f"{COMPANY_ID_PREFIX}18805", "company_name": "Angel Investors L.P."},
+        consideration_resp = {
+            "currency_name": "US Dollar",
+            "current_calculated_gross_total_transaction_value": "51609375.000000",
+            "current_calculated_implied_equity_value": "51609375.000000",
+            "current_calculated_implied_enterprise_value": "51609375.000000",
+            "details": [
                 {
-                    "company_id": f"{COMPANY_ID_PREFIX}20087",
-                    "company_name": "Draper Richards, L.P.",
-                },
+                    "scenario": "Stock Lump Sum",
+                    "subtype": "Common Equity",
+                    "cash_or_cash_equivalent_per_target_share_unit": None,
+                    "number_of_target_shares_sought": "1000000.000000",
+                    "current_calculated_gross_value_of_consideration": "51609375.000000",
+                }
             ],
         }
-        expected_response = deepcopy(response_base)
-        expected_response["participants"] = expected_participants_tool_response
+
+        expected_response = MergerInfo.model_validate(
+            {
+                "timeline": timeline_resp,
+                "participants": participants_resp,
+                "consideration": consideration_resp,
+            }
+        )
 
         transaction_id = 517414
         requests_mock.get(
             url=f"https://kfinance.kensho.com/api/v1/merger/info/{transaction_id}",
-            json=api_response,
+            json={
+                "timeline": timeline_resp,
+                "participants": participants_resp,
+                "consideration": consideration_resp,
+            },
         )
         tool = GetMergerInfoFromTransactionId(kfinance_client=mock_client)
         args = GetMergerInfoFromTransactionIdArgs(transaction_id=transaction_id)

kfinance/domains/prices/price_models.py

@@ -15,11 +15,11 @@ class Prices(BaseModel):
     """
 
     date: str
-    open: Money
-    high: Money
-    low: Money
-    close: Money
-    volume: Shares
+    open: Money | None
+    high: Money | None
+    low: Money | None
+    close: Money | None  # For Consistency with other OHLC dtype
+    volume: Shares | None
 
 
 class PriceHistory(BaseModel):
@@ -58,7 +58,8 @@ class PriceHistory(BaseModel):
             currency = data["currency"]
             for capitalization in data["prices"]:
                 for key in ["open", "high", "low", "close"]:
-                    capitalization[key] = dict(unit=currency, value=capitalization[key])
+                    if capitalization[key] is not None:
+                        capitalization[key] = dict(unit=currency, value=capitalization[key])
         return data
 
 

kfinance/domains/prices/price_tools.py

@@ -17,10 +17,12 @@ from kfinance.integrations.tool_calling.tool_calling_models import (
 
 class GetPricesFromIdentifiersArgs(ToolArgsWithIdentifiers):
     start_date: date | None = Field(
-        description="The start date for historical price retrieval", default=None
+        description="The start date for historical price retrieval. Use null for latest values. For annual queries (e.g., 'prices in 2020'), use January 1st of the year.",
+        default=None,
     )
     end_date: date | None = Field(
-        description="The end date for historical price retrieval", default=None
+        description="The end date for historical price retrieval. Use null for latest values. For annual queries (e.g., 'prices in 2020'), use December 31st of the year.",
+        default=None,
     )
     # no description because the description for enum fields comes from the enum docstring.
     periodicity: Periodicity = Field(default=Periodicity.day)
@@ -40,15 +42,19 @@ class GetPricesFromIdentifiers(KfinanceTool):
         Get the historical open, high, low, and close prices, and volume of a group of identifiers between inclusive start_date and inclusive end date.
 
         - When possible, pass multiple identifiers in a single call rather than making multiple calls.
-        - When requesting the most recent values, leave start_date and end_date empty.
+        - When requesting the most recent values, leave start_date and end_date null.
+        - For annual queries (e.g., "prices in 2020"), use the full year range from January 1st to December 31st.
+        - If requesting prices for long periods of time (e.g., multiple years), consider using a coarser periodicity (e.g., weekly or monthly) to reduce the amount of data returned.
 
-        Example:
+        Examples:
         Query: "What are the prices of Facebook and Google?"
-        Do:
-            get_prices_from_identifiers(identifiers=["META", "GOOGL"])
-        Don't:
-            get_prices_from_identifiers(trading_item_ids=["META"])
-            get_prices_from_identifiers(trading_item_ids=["GOOGL"])
+        Function: get_prices_from_identifiers(identifiers=["Facebook", "Google"], start_date=null, end_date=null)
+
+        Query: "Get prices for META and GOOGL"
+        Function: get_prices_from_identifiers(identifiers=["META", "GOOGL"], start_date=null, end_date=null)
+
+        Query: "How did Meta's stock perform in 2020?"
+        Function: get_prices_from_identifiers(identifiers=["Meta"], start_date="2020-01-01", end_date="2020-12-31", periodicity="day")
     """).strip()
     args_schema: Type[BaseModel] = GetPricesFromIdentifiersArgs
     accepted_permissions: set[Permission] | None = {Permission.PricingPermission}
@@ -60,7 +66,7 @@ class GetPricesFromIdentifiers(KfinanceTool):
         end_date: date | None = None,
         periodicity: Periodicity = Periodicity.day,
         adjusted: bool = True,
-    ) -> dict:
+    ) -> GetPricesFromIdentifiersResp:
         """Sample Response:
 
         {
@@ -116,10 +122,9 @@ class GetPricesFromIdentifiers(KfinanceTool):
             for price_response in price_responses.values():
                 price_response.prices = price_response.prices[-1:]
 
-        output_model = GetPricesFromIdentifiersResp(
+        return GetPricesFromIdentifiersResp(
             results=price_responses, errors=list(id_triple_resp.errors.values())
         )
-        return output_model.model_dump(mode="json")
 
 
 class GetHistoryMetadataFromIdentifiersResp(ToolRespWithErrors):
@@ -132,11 +137,16 @@ class GetHistoryMetadataFromIdentifiers(KfinanceTool):
         Get the history metadata associated with a list of identifiers. History metadata includes currency, symbol, exchange name, instrument type, and first trade date.
 
         - When possible, pass multiple identifiers in a single call rather than making multiple calls.
+
+        Examples:
+        Query: "What exchange does Starbucks trade on?"
+        Function: get_history_metadata_from_identifiers(identifiers=["Starbucks"])
+
     """).strip()
     args_schema: Type[BaseModel] = ToolArgsWithIdentifiers
     accepted_permissions: set[Permission] | None = None
 
-    def _run(self, identifiers: list[str]) -> dict:
+    def _run(self, identifiers: list[str]) -> GetHistoryMetadataFromIdentifiersResp:
         """Sample response:
 
         {
@@ -169,8 +179,6 @@ class GetHistoryMetadataFromIdentifiers(KfinanceTool):
         history_metadata_responses: dict[str, HistoryMetadataResp] = (
             process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)
         )
-        output_model = GetHistoryMetadataFromIdentifiersResp(
+        return GetHistoryMetadataFromIdentifiersResp(
             results=history_metadata_responses, errors=list(id_triple_resp.errors.values())
         )
-
-        return output_model.model_dump(mode="json")

kfinance/domains/prices/tests/test_price_tools.py

@@ -5,8 +5,10 @@ from kfinance.conftest import SPGI_TRADING_ITEM_ID
 from kfinance.domains.companies.company_models import COMPANY_ID_PREFIX
 from kfinance.domains.prices.price_tools import (
     GetHistoryMetadataFromIdentifiers,
+    GetHistoryMetadataFromIdentifiersResp,
     GetPricesFromIdentifiers,
     GetPricesFromIdentifiersArgs,
+    GetPricesFromIdentifiersResp,
 )
 from kfinance.integrations.tool_calling.tool_calling_models import ToolArgsWithIdentifiers
 
@@ -27,12 +29,14 @@ class TestGetHistoryMetadataFromIdentifiers:
             "instrument_type": "Equity",
             "symbol": "SPGI",
         }
-        expected_resp = {
-            "results": {"SPGI": metadata_resp},
-            "errors": [
-                "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
-            ],
-        }
+        expected_resp = GetHistoryMetadataFromIdentifiersResp.model_validate(
+            {
+                "results": {"SPGI": metadata_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/pricing/{SPGI_TRADING_ITEM_ID}/metadata",
@@ -80,33 +84,35 @@ class TestGetPricesFromIdentifiers:
             url=f"https://kfinance.kensho.com/api/v1/pricing/{SPGI_TRADING_ITEM_ID}/none/none/day/adjusted",
             json=self.prices_resp,
         )
-        expected_response = {
-            "results": {
-                "SPGI": {
-                    "prices": [
-                        {
-                            "date": "2024-04-11",
-                            "open": {"value": "424.26", "unit": "USD"},
-                            "high": {"value": "425.99", "unit": "USD"},
-                            "low": {"value": "422.04", "unit": "USD"},
-                            "close": {"value": "422.92", "unit": "USD"},
-                            "volume": {"value": "1129158", "unit": "Shares"},
-                        },
-                        {
-                            "date": "2024-04-12",
-                            "open": {"value": "419.23", "unit": "USD"},
-                            "high": {"value": "421.94", "unit": "USD"},
-                            "low": {"value": "416.45", "unit": "USD"},
-                            "close": {"value": "417.81", "unit": "USD"},
-                            "volume": {"value": "1182229", "unit": "Shares"},
-                        },
-                    ]
-                }
-            },
-            "errors": [
-                "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
-            ],
-        }
+        expected_response = GetPricesFromIdentifiersResp.model_validate(
+            {
+                "results": {
+                    "SPGI": {
+                        "prices": [
+                            {
+                                "date": "2024-04-11",
+                                "open": {"value": "424.26", "unit": "USD"},
+                                "high": {"value": "425.99", "unit": "USD"},
+                                "low": {"value": "422.04", "unit": "USD"},
+                                "close": {"value": "422.92", "unit": "USD"},
+                                "volume": {"value": "1129158", "unit": "Shares"},
+                            },
+                            {
+                                "date": "2024-04-12",
+                                "open": {"value": "419.23", "unit": "USD"},
+                                "high": {"value": "421.94", "unit": "USD"},
+                                "low": {"value": "416.45", "unit": "USD"},
+                                "close": {"value": "417.81", "unit": "USD"},
+                                "volume": {"value": "1182229", "unit": "Shares"},
+                            },
+                        ]
+                    }
+                },
+                "errors": [
+                    "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
+                ],
+            }
+        )
 
         tool = GetPricesFromIdentifiers(kfinance_client=mock_client)
         response = tool.run(
@@ -142,12 +148,14 @@ class TestGetPricesFromIdentifiers:
                 }
             ]
         }
-        expected_response = {
-            "results": {
-                "C_1": expected_single_company_response,
-                "C_2": expected_single_company_response,
-            },
-        }
+        expected_response = GetPricesFromIdentifiersResp.model_validate(
+            {
+                "results": {
+                    "C_1": expected_single_company_response,
+                    "C_2": expected_single_company_response,
+                },
+            }
+        )
         tool = GetPricesFromIdentifiers(kfinance_client=mock_client)
         response = tool.run(
             GetPricesFromIdentifiersArgs(

kfinance/domains/segments/segment_models.py

@@ -1,8 +1,10 @@
-from typing import Any
+from datetime import date
 
 from pydantic import BaseModel
 from strenum import StrEnum
 
+from kfinance.domains.line_items.line_item_models import BasePeriodsResp, LineItem
+
 
 class SegmentType(StrEnum):
     """The type of segment"""
@@ -11,5 +13,17 @@ class SegmentType(StrEnum):
     geographic = "geographic"
 
 
-class SegmentsResp(BaseModel):
-    segments: dict[str, Any]
+class Segment(BaseModel):
+    name: str
+    line_items: list[LineItem]
+
+
+class SegmentPeriodData(BaseModel):
+    period_end_date: date
+    num_months: int
+    segments: list[Segment]
+
+
+class SegmentsResp(BasePeriodsResp):
+    currency: str | None
+    periods: dict[str, SegmentPeriodData]  # period -> segment and period data

kfinance/domains/segments/segment_tools.py

@@ -1,10 +1,11 @@
+from textwrap import dedent
 from typing import Literal, Type
 
 from pydantic import BaseModel, Field
 
-from kfinance.client.batch_request_handling import Task, process_tasks_in_thread_pool_executor
-from kfinance.client.models.date_and_period_models import PeriodType
+from kfinance.client.models.date_and_period_models import NumPeriods, NumPeriodsBack, PeriodType
 from kfinance.client.permission_models import Permission
+from kfinance.domains.line_items.line_item_models import CalendarType
 from kfinance.domains.segments.segment_models import SegmentsResp, SegmentType
 from kfinance.integrations.tool_calling.tool_calling_models import (
     KfinanceTool,
@@ -22,15 +23,42 @@ class GetSegmentsFromIdentifiersArgs(ToolArgsWithIdentifiers):
     end_year: int | None = Field(default=None, description="The ending year for the data range")
     start_quarter: ValidQuarter | None = Field(default=None, description="Starting quarter")
     end_quarter: ValidQuarter | None = Field(default=None, description="Ending quarter")
+    calendar_type: CalendarType | None = Field(
+        default=None, description="Fiscal year or calendar year"
+    )
+    num_periods: NumPeriods | None = Field(
+        default=None, description="The number of periods to retrieve data for (1-99)"
+    )
+    num_periods_back: NumPeriodsBack | None = Field(
+        default=None,
+        description="The end period of the data range expressed as number of periods back relative to the present period (0-99)",
+    )
 
 
 class GetSegmentsFromIdentifiersResp(ToolRespWithErrors):
-    results: dict[str, SegmentsResp]
+    results: dict[str, SegmentsResp]  # identifier -> response
 
 
 class GetSegmentsFromIdentifiers(KfinanceTool):
     name: str = "get_segments_from_identifiers"
-    description: str = "Get the templated segments associated with a list of identifiers."
+    description: str = dedent("""
+        Get the templated business or geographic segments associated with a list of identifiers.
+
+        - When possible, pass multiple identifiers in a single call rather than making multiple calls.
+        - The tool accepts an optional calendar_type argument, which can either be 'calendar' or 'fiscal'. If 'calendar' is chosen, then start_year and end_year will filter on calendar year, and the output returned will be in calendar years. If 'fiscal' is chosen (which is the default), then start_year and end_year will filter on fiscal year, and the output returned will be in fiscal years.
+        - To fetch the most recent segment data, leave start_year, start_quarter, end_year, end_quarter, num_periods, and num_periods_back as None.
+        - To filter by time, use either absolute (start_year, end_year, start_quarter, end_quarter) for specific dates like "in 2023" or "Q2 2021", OR relative (num_periods, num_periods_back) for phrases like "last 3 quarters" or "past five years"—but not both.
+
+        Examples:
+        Query: "What are the business segments for AT&T?"
+        Function: get_segments_from_identifiers(identifiers=["AT&T"], segment_type="business")
+
+        Query: "Get geographic segments for PFE and JNJ"
+        Function: get_segments_from_identifiers(identifiers=["PFE", "JNJ"], segment_type="geographic")
+
+        Query: "What are the ltm business segments for S&P for the last three calendar quarters but one?"
+        Function: get_segments_from_identifiers(segment_type="business", period_type="ltm", calendar_type="calendar", num_periods=3, num_periods_back=1, identifiers=["SPGI"])
+    """).strip()
     args_schema: Type[BaseModel] = GetSegmentsFromIdentifiersArgs
     accepted_permissions: set[Permission] | None = {Permission.SegmentsPermission}
 
@@ -43,50 +71,83 @@ class GetSegmentsFromIdentifiers(KfinanceTool):
         end_year: int | None = None,
         start_quarter: Literal[1, 2, 3, 4] | None = None,
         end_quarter: Literal[1, 2, 3, 4] | None = None,
-    ) -> dict:
-        """Sample Response:
+        calendar_type: CalendarType | None = None,
+        num_periods: int | None = None,
+        num_periods_back: int | None = None,
+    ) -> GetSegmentsFromIdentifiersResp:
+        """Sample response:
 
         {
             'results': {
                 'SPGI': {
-                    'segments': {
-                        '2021': {
-                            'Commodity Insights': {'CAPEX': -2000000.0, 'D&A': 12000000.0},
-                            'Unallocated Assets Held for Sale': {'Total Assets': 321000000.0}
+                    'currency': 'USD',
+                    'periods': {
+                        'CY2021': {
+                            'period_end_date': '2021-12-31',
+                            'num_months': 12,
+                            'segments': [
+                                {
+                                    'name': 'Commodity Insights',
+                                    'line_items': [
+                                        {
+                                            'name': 'CAPEX',
+                                            'value': -2000000.0,
+                                            'sources': [
+                                                {
+                                                    'type': 'doc-viewer segment',
+                                                    'url': 'https://www.capitaliq.spglobal.com/...'
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            'name': 'D&A',
+                                            'value': 12000000.0
+                                        }
+                                    ]
+                                },
+                                {
+                                    'name': 'Unallocated Assets Held for Sale',
+                                    'line_items': [
+                                        {
+                                            'name': 'Total Assets',
+                                            'value': 321000000.0
+                                        }
+                                    ]
+                                }
+                            ]
                         }
                     }
                 }
             },
             'errors': ['No identification triple found for the provided identifier: NON-EXISTENT of type: ticker']
         }
-
-
         """
 
         api_client = self.kfinance_client.kfinance_api_client
-        id_triple_resp = api_client.unified_fetch_id_triples(identifiers=identifiers)
-
-        tasks = [
-            Task(
-                func=api_client.fetch_segments,
-                kwargs=dict(
-                    company_id=id_triple.company_id,
-                    segment_type=segment_type,
-                    period_type=period_type,
-                    start_year=start_year,
-                    end_year=end_year,
-                    start_quarter=start_quarter,
-                    end_quarter=end_quarter,
-                ),
-                result_key=identifier,
-            )
-            for identifier, id_triple in id_triple_resp.identifiers_to_id_triples.items()
-        ]
-
-        segments_responses: dict[str, SegmentsResp] = process_tasks_in_thread_pool_executor(
-            api_client=api_client, tasks=tasks
+
+        # First resolve identifiers to company IDs
+        ids_response = api_client.unified_fetch_id_triples(identifiers)
+
+        # Call the simplified fetch_segments API with company IDs
+        response = api_client.fetch_segments(
+            company_ids=ids_response.company_ids,
+            segment_type=segment_type,
+            period_type=period_type,
+            start_year=start_year,
+            end_year=end_year,
+            start_quarter=start_quarter,
+            end_quarter=end_quarter,
+            calendar_type=calendar_type,
+            num_periods=num_periods,
+            num_periods_back=num_periods_back,
         )
 
+        identifier_to_results = {}
+        for company_id_str, segments_resp in response.results.items():
+            company_id = int(company_id_str)
+            original_identifier = ids_response.get_identifier_from_company_id(company_id)
+            identifier_to_results[original_identifier] = segments_resp
+
         # If no date and multiple companies, only return the most recent value.
         # By default, we return 5 years of data, which can be too much when
         # returning data for many companies.
@@ -95,14 +156,13 @@ class GetSegmentsFromIdentifiers(KfinanceTool):
             and end_year is None
             and start_quarter is None
             and end_quarter is None
-            and len(segments_responses) > 1
+            and num_periods is None
+            and num_periods_back is None
+            and len(identifier_to_results) > 1
         ):
-            for segments_response in segments_responses.values():
-                most_recent_year = max(segments_response.segments.keys())
-                most_recent_year_data = segments_response.segments[most_recent_year]
-                segments_response.segments = {most_recent_year: most_recent_year_data}
+            for segments_response in identifier_to_results.values():
+                segments_response.remove_all_periods_other_than_the_most_recent_one()
 
-        output_model = GetSegmentsFromIdentifiersResp(
-            results=segments_responses, errors=list(id_triple_resp.errors.values())
-        )
-        return output_model.model_dump(mode="json")
+        all_errors = list(ids_response.errors.values()) + list(response.errors.values())
+
+        return GetSegmentsFromIdentifiersResp(results=identifier_to_results, errors=all_errors)