kensho-kfinance 2.4.2__py3-none-any.whl → 2.6.1__py3-none-any.whl

kfinance/tests/test_tools.py

@@ -1,16 +1,27 @@
+import contextlib
+from contextlib import nullcontext as does_not_raise
 from datetime import date, datetime
 
 from langchain_core.utils.function_calling import convert_to_openai_tool
+from pydantic import BaseModel, ValidationError
+import pytest
 from pytest import raises
 from requests_mock import Mocker
 import time_machine
 
-from kfinance.constants import BusinessRelationshipType, Capitalization, SegmentType, StatementType
+from kfinance.constants import (
+    BusinessRelationshipType,
+    Capitalization,
+    CompetitorSource,
+    SegmentType,
+    StatementType,
+)
 from kfinance.kfinance import Client, NoEarningsDataError
 from kfinance.tests.conftest import SPGI_COMPANY_ID, SPGI_SECURITY_ID, SPGI_TRADING_ITEM_ID
+from kfinance.tests.test_objects import MOCK_COMPANY_DB, MOCK_MERGERS_DB, ordered
 from kfinance.tool_calling import (
+    GetCompetitorsFromIdentifier,
     GetEarnings,
-    GetEarningsCallDatetimesFromIdentifier,
     GetFinancialLineItemFromIdentifier,
     GetFinancialStatementFromIdentifier,
     GetHistoryMetadataFromIdentifier,
@@ -24,6 +35,10 @@ from kfinance.tool_calling import (
     GetTranscript,
     ResolveIdentifier,
 )
+from kfinance.tool_calling.get_advisors_for_company_in_transaction_from_identifier import (
+    GetAdvisorsForCompanyInTransactionFromIdentifier,
+    GetAdvisorsForCompanyInTransactionFromIdentifierArgs,
+)
 from kfinance.tool_calling.get_business_relationship_from_identifier import (
     GetBusinessRelationshipFromIdentifier,
     GetBusinessRelationshipFromIdentifierArgs,
@@ -32,6 +47,9 @@ from kfinance.tool_calling.get_capitalization_from_identifier import (
     GetCapitalizationFromIdentifier,
     GetCapitalizationFromIdentifierArgs,
 )
+from kfinance.tool_calling.get_competitors_from_identifier import (
+    GetCompetitorsFromIdentifierArgs,
+)
 from kfinance.tool_calling.get_cusip_from_ticker import GetCusipFromTicker, GetCusipFromTickerArgs
 from kfinance.tool_calling.get_financial_line_item_from_identifier import (
     GetFinancialLineItemFromIdentifierArgs,
@@ -41,6 +59,11 @@ from kfinance.tool_calling.get_financial_statement_from_identifier import (
 )
 from kfinance.tool_calling.get_isin_from_ticker import GetIsinFromTickerArgs
 from kfinance.tool_calling.get_latest import GetLatestArgs
+from kfinance.tool_calling.get_merger_info_from_transaction_id import (
+    GetMergerInfoFromTransactionId,
+    GetMergerInfoFromTransactionIdArgs,
+)
+from kfinance.tool_calling.get_mergers_from_identifier import GetMergersFromIdentifier
 from kfinance.tool_calling.get_n_quarters_ago import GetNQuartersAgoArgs
 from kfinance.tool_calling.get_prices_from_identifier import GetPricesFromIdentifierArgs
 from kfinance.tool_calling.get_segments_from_identifier import (
@@ -48,7 +71,60 @@ from kfinance.tool_calling.get_segments_from_identifier import (
     GetSegmentsFromIdentifierArgs,
 )
 from kfinance.tool_calling.get_transcript import GetTranscriptArgs
-from kfinance.tool_calling.shared_models import ToolArgsWithIdentifier
+from kfinance.tool_calling.shared_models import ToolArgsWithIdentifier, ValidQuarter
+
+
+class TestGetCompaniesAdvisingCompanyInTransactionFromIdentifier:
+    def test_get_companies_advising_company_in_transaction_from_identifier(
+        self, requests_mock: Mocker, mock_client: Client
+    ):
+        expected_response = {
+            "advisors": [
+                {
+                    "advisor_company_id": 251994106,
+                    "advisor_company_name": "Kensho Technologies, Inc.",
+                    "advisor_type_name": "Professional Mongo Enjoyer",
+                }
+            ]
+        }
+        transaction_id = 517414
+        requests_mock.get(
+            url=f"https://kfinance.kensho.com/api/v1/merger/info/{transaction_id}/advisors/21835",
+            json=expected_response,
+        )
+        tool = GetAdvisorsForCompanyInTransactionFromIdentifier(kfinance_client=mock_client)
+        args = GetAdvisorsForCompanyInTransactionFromIdentifierArgs(
+            identifier="MSFT", transaction_id=transaction_id
+        )
+        response = tool.run(args.model_dump(mode="json"))
+        assert response == expected_response["advisors"]
+
+
+class TestGetMergerInfoFromTransactionId:
+    def test_get_merger_info_from_transaction_id(self, requests_mock: Mocker, mock_client: Client):
+        expected_response = MOCK_MERGERS_DB["517414"]
+        transaction_id = 517414
+        requests_mock.get(
+            url=f"https://kfinance.kensho.com/api/v1/merger/info/{transaction_id}",
+            json=expected_response,
+        )
+        tool = GetMergerInfoFromTransactionId(kfinance_client=mock_client)
+        args = GetMergerInfoFromTransactionIdArgs(transaction_id=transaction_id)
+        response = tool.run(args.model_dump(mode="json"))
+        assert ordered(response) == ordered(expected_response)
+
+
+class TestGetMergersFromIdentifier:
+    def test_get_mergers_from_identifier(self, requests_mock: Mocker, mock_client: Client):
+        expected_response = MOCK_COMPANY_DB["21835"]["mergers"]
+        company_id = 21835
+        requests_mock.get(
+            url=f"https://kfinance.kensho.com/api/v1/mergers/{company_id}", json=expected_response
+        )
+        tool = GetMergersFromIdentifier(kfinance_client=mock_client)
+        args = ToolArgsWithIdentifier(identifier="MSFT")
+        response = tool.run(args.model_dump(mode="json"))
+        assert ordered(response) == ordered(expected_response)
 
 
 class TestGetBusinessRelationshipFromIdentifier:
@@ -133,27 +209,6 @@ class TestGetCusipFromTicker:
         assert resp == spgi_cusip
 
 
-class TestGetEarningsCallDatetimesFromTicker:
-    def test_get_earnings_call_datetimes_from_ticker(
-        self, requests_mock: Mocker, mock_client: Client
-    ):
-        """
-        GIVEN the GetEarningsCallDatetimesFromIdentifier tool
-        WHEN we request earnings call datetimes for SPGI
-        THEN we get back the expected SPGI earnings call datetimes
-        """
-
-        requests_mock.get(
-            url=f"https://kfinance.kensho.com/api/v1/earnings/{SPGI_COMPANY_ID}/dates",
-            json={"earnings": ["2025-04-29T12:30:00", "2025-02-11T13:30:00"]},
-        )
-        expected_response = '["2025-04-29T12:30:00+00:00", "2025-02-11T13:30:00+00:00"]'
-
-        tool = GetEarningsCallDatetimesFromIdentifier(kfinance_client=mock_client)
-        response = tool.run(ToolArgsWithIdentifier(identifier="SPGI").model_dump(mode="json"))
-        assert response == expected_response
-
-
 class TestGetFinancialLineItemFromIdentifier:
     def test_get_financial_line_item_from_identifier(
         self, mock_client: Client, requests_mock: Mocker
@@ -638,3 +693,60 @@ class TestGetTranscript:
         tool = GetTranscript(kfinance_client=mock_client)
         response = tool.run(GetTranscriptArgs(key_dev_id=12345).model_dump(mode="json"))
         assert response == expected_response
+
+
+class TestGetCompetitorsFromIdentifier:
+    def test_get_competitors_from_identifier(self, mock_client: Client, requests_mock: Mocker):
+        """
+        GIVEN the GetCompetitorsFromIdentifier tool
+        WHEN we request the SPGI competitors that are named by competitors
+        THEN we get back the SPGI competitors that are named by competitors
+        """
+        expected_competitors_response = {
+            "companies": [
+                {"company_id": 35352, "company_name": "The Descartes Systems Group Inc."},
+                {"company_id": 4003514, "company_name": "London Stock Exchange Group plc"},
+            ]
+        }
+        requests_mock.get(
+            url=f"https://kfinance.kensho.com/api/v1/competitors/{SPGI_COMPANY_ID}/named_by_competitor",
+            # truncated from the original API response
+            json=expected_competitors_response,
+        )
+
+        tool = GetCompetitorsFromIdentifier(kfinance_client=mock_client)
+        args = GetCompetitorsFromIdentifierArgs(
+            identifier="SPGI", competitor_source=CompetitorSource.named_by_competitor
+        )
+        response = tool.run(args.model_dump(mode="json"))
+        assert response == expected_competitors_response
+
+
+class TestValidQuarter:
+    class QuarterModel(BaseModel):
+        quarter: ValidQuarter | None
+
+    @pytest.mark.parametrize(
+        "input_quarter, expectation, expected_quarter",
+        [
+            pytest.param(1, does_not_raise(), 1, id="int input works"),
+            pytest.param("1", does_not_raise(), 1, id="str input works"),
+            pytest.param(None, does_not_raise(), None, id="None input works"),
+            pytest.param(5, pytest.raises(ValidationError), None, id="invalid int raises"),
+            pytest.param("5", pytest.raises(ValidationError), None, id="invalid str raises"),
+        ],
+    )
+    def test_valid_quarter(
+        self,
+        input_quarter: int | str | None,
+        expectation: contextlib.AbstractContextManager,
+        expected_quarter: int | None,
+    ) -> None:
+        """
+        GIVEN a model that uses `ValidQuarter`
+        WHEN we deserialize with int, str, or None
+        THEN valid str get coerced to int. Invalid values raise.
+        """
+        with expectation:
+            res = self.QuarterModel.model_validate(dict(quarter=input_quarter))
+            assert res.quarter == expected_quarter

kfinance/tool_calling/__init__.py

@@ -4,11 +4,9 @@ from kfinance.tool_calling.get_business_relationship_from_identifier import (
     GetBusinessRelationshipFromIdentifier,
 )
 from kfinance.tool_calling.get_capitalization_from_identifier import GetCapitalizationFromIdentifier
+from kfinance.tool_calling.get_competitors_from_identifier import GetCompetitorsFromIdentifier
 from kfinance.tool_calling.get_cusip_from_ticker import GetCusipFromTicker
 from kfinance.tool_calling.get_earnings import GetEarnings
-from kfinance.tool_calling.get_earnings_call_datetimes_from_identifier import (
-    GetEarningsCallDatetimesFromIdentifier,
-)
 from kfinance.tool_calling.get_financial_line_item_from_identifier import (
     GetFinancialLineItemFromIdentifier,
 )
@@ -39,7 +37,6 @@ ALL_TOOLS: list[Type[KfinanceTool]] = [
     GetIsinFromTicker,
     GetCusipFromTicker,
     GetInfoFromIdentifier,
-    GetEarningsCallDatetimesFromIdentifier,
     GetEarnings,
     GetLatestEarnings,
     GetNextEarnings,
@@ -52,4 +49,5 @@ ALL_TOOLS: list[Type[KfinanceTool]] = [
     GetBusinessRelationshipFromIdentifier,
     ResolveIdentifier,
     GetSegmentsFromIdentifier,
+    GetCompetitorsFromIdentifier,
 ]

kfinance/tool_calling/get_advisors_for_company_in_transaction_from_identifier.py

@@ -0,0 +1,39 @@
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from kfinance.constants import Permission
+from kfinance.kfinance import AdvisedCompany
+from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier
+
+
+class GetAdvisorsForCompanyInTransactionFromIdentifierArgs(ToolArgsWithIdentifier):
+    transaction_id: int | None = Field(description="The ID of the merger.", default=None)
+
+
+class GetAdvisorsForCompanyInTransactionFromIdentifier(KfinanceTool):
+    name: str = "get_advisors_for_company_in_transaction_from_identifier"
+    description: str = 'Get the companies advising a company in a given transaction. For example, "Who advised S&P Global during their purchase of Kensho?"'
+    args_schema: Type[BaseModel] = GetAdvisorsForCompanyInTransactionFromIdentifierArgs
+    required_permission: Permission | None = Permission.MergersPermission
+
+    def _run(self, identifier: str, transaction_id: int) -> list:
+        ticker = self.kfinance_client.ticker(identifier)
+        advised_company = AdvisedCompany(
+            kfinance_api_client=ticker.kfinance_api_client,
+            company_id=ticker.company.company_id,
+            transaction_id=transaction_id,
+        )
+        advisors = advised_company.advisors
+
+        if advisors:
+            return [
+                {
+                    "advisor_company_id": advisor.company_id,
+                    "advisor_company_name": advisor.name,
+                    "advisor_type_name": advisor.advisor_type_name,
+                }
+                for advisor in advisors
+            ]
+        else:
+            return []

kfinance/tool_calling/get_competitors_from_identifier.py

@@ -0,0 +1,24 @@
+from kfinance.constants import CompetitorSource, Permission
+from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier
+
+
+class GetCompetitorsFromIdentifierArgs(ToolArgsWithIdentifier):
+    # no description because the description for enum fields comes from the enum docstring.
+    competitor_source: CompetitorSource
+
+
+class GetCompetitorsFromIdentifier(KfinanceTool):
+    name: str = "get_competitors_from_identifier"
+    description: str = "Retrieves a list of competitors for a given company, optionally filtered by the source of the competitor information."
+    args_schema = GetCompetitorsFromIdentifierArgs
+    required_permission: Permission | None = Permission.CompetitorsPermission
+
+    def _run(
+        self,
+        identifier: str,
+        competitor_source: CompetitorSource,
+    ) -> dict:
+        ticker = self.kfinance_client.ticker(identifier)
+        return self.kfinance_client.kfinance_api_client.fetch_competitors(
+            company_id=ticker.company_id, competitor_source=competitor_source
+        )

kfinance/tool_calling/get_financial_line_item_from_identifier.py

@@ -3,7 +3,7 @@ from typing import Literal, Type
 from pydantic import BaseModel, Field
 
 from kfinance.constants import LINE_ITEM_NAMES_AND_ALIASES, PeriodType, Permission
-from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier
+from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier, ValidQuarter
 
 
 class GetFinancialLineItemFromIdentifierArgs(ToolArgsWithIdentifier):
@@ -16,8 +16,8 @@ class GetFinancialLineItemFromIdentifierArgs(ToolArgsWithIdentifier):
     period_type: PeriodType | None = Field(default=None, description="The period type")
     start_year: int | None = Field(default=None, description="The starting year for the data range")
     end_year: int | None = Field(default=None, description="The ending year for the data range")
-    start_quarter: Literal[1, 2, 3, 4] | None = Field(default=None, description="Starting quarter")
-    end_quarter: Literal[1, 2, 3, 4] | None = Field(default=None, description="Ending quarter")
+    start_quarter: ValidQuarter | None = Field(default=None, description="Starting quarter")
+    end_quarter: ValidQuarter | None = Field(default=None, description="Ending quarter")
 
 
 class GetFinancialLineItemFromIdentifier(KfinanceTool):

kfinance/tool_calling/get_financial_statement_from_identifier.py

@@ -3,7 +3,7 @@ from typing import Literal, Type
 from pydantic import BaseModel, Field
 
 from kfinance.constants import PeriodType, Permission, StatementType
-from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier
+from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier, ValidQuarter
 
 
 class GetFinancialStatementFromIdentifierArgs(ToolArgsWithIdentifier):
@@ -12,8 +12,8 @@ class GetFinancialStatementFromIdentifierArgs(ToolArgsWithIdentifier):
     period_type: PeriodType | None = Field(default=None, description="The period type")
     start_year: int | None = Field(default=None, description="The starting year for the data range")
     end_year: int | None = Field(default=None, description="The ending year for the data range")
-    start_quarter: Literal[1, 2, 3, 4] | None = Field(default=None, description="Starting quarter")
-    end_quarter: Literal[1, 2, 3, 4] | None = Field(default=None, description="Ending quarter")
+    start_quarter: ValidQuarter | None = Field(default=None, description="Starting quarter")
+    end_quarter: ValidQuarter | None = Field(default=None, description="Ending quarter")
 
 
 class GetFinancialStatementFromIdentifier(KfinanceTool):

kfinance/tool_calling/get_merger_info_from_transaction_id.py

@@ -0,0 +1,62 @@
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from kfinance.constants import Permission
+from kfinance.kfinance import MergerOrAcquisition
+from kfinance.tool_calling.shared_models import KfinanceTool
+
+
+class GetMergerInfoFromTransactionIdArgs(BaseModel):
+    transaction_id: int | None = Field(description="The ID of the merger.", default=None)
+
+
+class GetMergerInfoFromTransactionId(KfinanceTool):
+    name: str = "get_merger_info_from_transaction_id"
+    description: str = 'Get the timeline, the participants, and the consideration of the merger or acquisition from the given transaction ID. For example, "How much was Ben & Jerrys purchased for?" or "What was the price per share for LinkedIn?" or "When did S&P purchase Kensho?"'
+    args_schema: Type[BaseModel] = GetMergerInfoFromTransactionIdArgs
+    required_permission: Permission | None = Permission.MergersPermission
+
+    def _run(self, transaction_id: int) -> dict:
+        merger_or_acquisition = MergerOrAcquisition(
+            kfinance_api_client=self.kfinance_client.kfinance_api_client,
+            transaction_id=transaction_id,
+            merger_title=None,
+        )
+        merger_timeline = merger_or_acquisition.get_timeline
+        merger_participants = merger_or_acquisition.get_participants
+        merger_consideration = merger_or_acquisition.get_consideration
+
+        return {
+            "timeline": [
+                {"status": timeline["status"], "date": timeline["date"].strftime("%Y-%m-%d")}
+                for timeline in merger_timeline.to_dict(orient="records")
+            ],
+            "participants": {
+                "target": {
+                    "company_id": merger_participants["target"].company_id,
+                    "company_name": merger_participants["target"].name,
+                },
+                "buyers": [
+                    {"company_id": buyer.company_id, "company_name": buyer.name}
+                    for buyer in merger_participants["buyers"]
+                ],
+                "sellers": [
+                    {"company_id": seller.company_id, "company_name": seller.name}
+                    for seller in merger_participants["sellers"]
+                ],
+            },
+            "consideration": {
+                "currency_name": merger_consideration["currency_name"],
+                "current_calculated_gross_total_transaction_value": merger_consideration[
+                    "current_calculated_gross_total_transaction_value"
+                ],
+                "current_calculated_implied_equity_value": merger_consideration[
+                    "current_calculated_implied_equity_value"
+                ],
+                "current_calculated_implied_enterprise_value": merger_consideration[
+                    "current_calculated_implied_enterprise_value"
+                ],
+                "details": merger_consideration["details"].to_dict(orient="records"),
+            },
+        }

kfinance/tool_calling/get_mergers_from_identifier.py

@@ -0,0 +1,41 @@
+from typing import Type
+
+from pydantic import BaseModel
+
+from kfinance.constants import Permission
+from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier
+
+
+class GetMergersFromIdentifier(KfinanceTool):
+    name: str = "get_mergers_from_identifier"
+    description: str = 'Get the transaction IDs that involve the given identifier. For example, "Which companies did Microsoft purchase?" or "Which company bought Ben & Jerrys?"'
+    args_schema: Type[BaseModel] = ToolArgsWithIdentifier
+    required_permission: Permission | None = Permission.MergersPermission
+
+    def _run(self, identifier: str) -> dict:
+        ticker = self.kfinance_client.ticker(identifier)
+        mergers_and_acquisitions = ticker.company.mergers_and_acquisitions
+
+        return {
+            "target": [
+                {
+                    "transaction_id": merger_or_acquisition.transaction_id,
+                    "merger_title": merger_or_acquisition.merger_title,
+                }
+                for merger_or_acquisition in mergers_and_acquisitions["target"]
+            ],
+            "buyer": [
+                {
+                    "transaction_id": merger_or_acquisition.transaction_id,
+                    "merger_title": merger_or_acquisition.merger_title,
+                }
+                for merger_or_acquisition in mergers_and_acquisitions["buyer"]
+            ],
+            "seller": [
+                {
+                    "transaction_id": merger_or_acquisition.transaction_id,
+                    "merger_title": merger_or_acquisition.merger_title,
+                }
+                for merger_or_acquisition in mergers_and_acquisitions["seller"]
+            ],
+        }

kfinance/tool_calling/get_segments_from_identifier.py

@@ -3,7 +3,7 @@ from typing import Literal, Type
 from pydantic import BaseModel, Field
 
 from kfinance.constants import PeriodType, Permission, SegmentType
-from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier
+from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier, ValidQuarter
 
 
 class GetSegmentsFromIdentifierArgs(ToolArgsWithIdentifier):
@@ -12,8 +12,8 @@ class GetSegmentsFromIdentifierArgs(ToolArgsWithIdentifier):
     period_type: PeriodType | None = Field(default=None, description="The period type")
     start_year: int | None = Field(default=None, description="The starting year for the data range")
     end_year: int | None = Field(default=None, description="The ending year for the data range")
-    start_quarter: Literal[1, 2, 3, 4] | None = Field(default=None, description="Starting quarter")
-    end_quarter: Literal[1, 2, 3, 4] | None = Field(default=None, description="Ending quarter")
+    start_quarter: ValidQuarter | None = Field(default=None, description="Starting quarter")
+    end_quarter: ValidQuarter | None = Field(default=None, description="Ending quarter")
 
 
 class GetSegmentsFromIdentifier(KfinanceTool):

kfinance/tool_calling/shared_models.py

@@ -1,7 +1,7 @@
-from typing import Any, Type
+from typing import Annotated, Any, Literal, Type
 
 from langchain_core.tools import BaseTool
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field
 
 from kfinance.constants import Permission
 from kfinance.kfinance import Client
@@ -53,3 +53,18 @@ class ToolArgsWithIdentifier(BaseModel):
     identifier: str = Field(
         description="The identifier, which can be a ticker symbol, ISIN, or CUSIP"
     )
+
+
+def convert_str_to_int(v: Any) -> Any:
+    """Convert strings to integers if possible."""
+    if isinstance(v, str) and v.isdigit():
+        return int(v)
+    return v
+
+
+# Valid Quarter is a literal type, which converts strings to int before
+# validating them.
+# Claude seems to often pass strings to int literals, which raise a
+# ValidationError during deserialization unless they have been converted
+# to int.
+ValidQuarter = Annotated[Literal[1, 2, 3, 4], BeforeValidator(convert_str_to_int)]

kfinance/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.4.2'
-__version_tuple__ = version_tuple = (2, 4, 2)
+__version__ = version = '2.6.1'
+__version_tuple__ = version_tuple = (2, 6, 1)

kfinance/tests/test_mcp.py

@@ -1,16 +0,0 @@
-from typing import Type
-
-import pytest
-
-from kfinance.kfinance import Client
-from kfinance.mcp import build_doc_string
-from kfinance.tool_calling import ALL_TOOLS
-from kfinance.tool_calling.shared_models import KfinanceTool
-
-
-class TestDocStringBuilding:
-    @pytest.mark.parametrize("tool_class", ALL_TOOLS)
-    def test_build_doc_string(self, mock_client: Client, tool_class: Type[KfinanceTool]):
-        """This test build the docstring for each tool. A success is considered if no exception is raised"""
-        tool = tool_class(kfinance_client=mock_client)
-        build_doc_string(tool)

kfinance/tool_calling/get_earnings_call_datetimes_from_identifier.py

@@ -1,19 +0,0 @@
-import json
-from typing import Type
-
-from pydantic import BaseModel
-
-from kfinance.constants import Permission
-from kfinance.tool_calling.shared_models import KfinanceTool, ToolArgsWithIdentifier
-
-
-class GetEarningsCallDatetimesFromIdentifier(KfinanceTool):
-    name: str = "get_earnings_call_datetimes_from_identifier"
-    description: str = "Get earnings call datetimes associated with an identifier."
-    args_schema: Type[BaseModel] = ToolArgsWithIdentifier
-    required_permission: Permission | None = Permission.EarningsPermission
-
-    def _run(self, identifier: str) -> str:
-        ticker = self.kfinance_client.ticker(identifier)
-        earnings_call_datetimes = ticker.earnings_call_datetimes
-        return json.dumps([dt.isoformat() for dt in earnings_call_datetimes])