kensho-kfinance 3.1.1__tar.gz → 3.2.1__tar.gz

{kensho_kfinance-3.1.1/kensho_kfinance.egg-info → kensho_kfinance-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kensho-kfinance
-Version: 3.1.1
+Version: 3.2.1
 Summary: Python CLI for kFinance
 Author-email: Luke Brown <luke.brown@kensho.com>, Michelle Keoy <michelle.keoy@kensho.com>, Keith Page <keith.page@kensho.com>, Matthew Rosen <matthew.rosen@kensho.com>, Nick Roshdieh <nick.roshdieh@kensho.com>
 Project-URL: source, https://github.com/kensho-technologies/kfinance

{kensho_kfinance-3.1.1 → kensho_kfinance-3.2.1/kensho_kfinance.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kensho-kfinance
-Version: 3.1.1
+Version: 3.2.1
 Summary: Python CLI for kFinance
 Author-email: Luke Brown <luke.brown@kensho.com>, Michelle Keoy <michelle.keoy@kensho.com>, Keith Page <keith.page@kensho.com>, Matthew Rosen <matthew.rosen@kensho.com>, Nick Roshdieh <nick.roshdieh@kensho.com>
 Project-URL: source, https://github.com/kensho-technologies/kfinance

{kensho_kfinance-3.1.1 → kensho_kfinance-3.2.1}/kfinance/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v3.2.1
+- Add Company Intelligence tools to ALL_TOOLS
+
+## v3.2.0
+- Add Company Intelligence tools
+
 ## v3.1.1
 - Update client base prompt
 

{kensho_kfinance-3.1.1 → kensho_kfinance-3.2.1}/kfinance/client/fetch.py

@@ -17,7 +17,12 @@ from kfinance.domains.business_relationships.business_relationship_models import
     RelationshipResponse,
 )
 from kfinance.domains.capitalizations.capitalization_models import Capitalizations
-from kfinance.domains.companies.company_models import IdentificationTriple, UnifiedIdTripleResponse
+from kfinance.domains.companies.company_models import (
+    CompanyDescriptions,
+    CompanyOtherNames,
+    IdentificationTriple,
+    UnifiedIdTripleResponse,
+)
 from kfinance.domains.competitors.competitor_models import CompetitorResponse, CompetitorSource
 from kfinance.domains.earnings.earning_models import EarningsCallResp
 from kfinance.domains.line_items.line_item_models import LineItemResponse
@@ -602,6 +607,18 @@ class KFinanceApiClient:
         url = f"{self.url_base}transcript/{key_dev_id}"
         return self.fetch(url)
 
+    def fetch_company_descriptions(self, company_id: int) -> CompanyDescriptions:
+        """Get the short description (summary) and long description for a company"""
+        url = f"{self.url_base}info/{company_id}/descriptions"
+        result = self.fetch(url)
+        return CompanyDescriptions.model_validate(result)
+
+    def fetch_company_other_names(self, company_id: int) -> CompanyOtherNames:
+        """Get the alternate, historical, and native names for a company"""
+        url = f"{self.url_base}info/{company_id}/names"
+        result = self.fetch(url)
+        return CompanyOtherNames.model_validate(result)
+
     def fetch_competitors(
         self, company_id: int, competitor_source: CompetitorSource
     ) -> CompetitorResponse:

{kensho_kfinance-3.1.1 → kensho_kfinance-3.2.1}/kfinance/client/meta_classes.py

@@ -13,6 +13,11 @@ from kfinance.domains.business_relationships.business_relationship_models import
     BusinessRelationshipType,
 )
 from kfinance.domains.capitalizations.capitalization_models import Capitalization
+from kfinance.domains.companies.company_models import (
+    CompanyDescriptions,
+    CompanyOtherNames,
+    NativeName,
+)
 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
@@ -27,6 +32,11 @@ logger = logging.getLogger(__name__)
 class CompanyFunctionsMetaClass:
     kfinance_api_client: KFinanceApiClient
 
+    def __init__(self) -> None:
+        """Initialize the CompanyFunctionsMetaClass object"""
+        self._company_descriptions: CompanyDescriptions | None = None
+        self._company_other_names: CompanyOtherNames | None = None
+
     @property
     @abstractmethod
     def company_id(self) -> Any:
@@ -415,6 +425,51 @@ class CompanyFunctionsMetaClass:
             end_quarter=end_quarter,
         )
 
+    @property
+    def summary(self) -> str:
+        """Lazily fetch and return a company's summary"""
+        if not self._company_descriptions:
+            self._company_descriptions = self.kfinance_api_client.fetch_company_descriptions(
+                company_id=self.company_id
+            )
+        return self._company_descriptions.summary
+
+    @property
+    def description(self) -> str:
+        """Lazily fetch and return a company's description"""
+        if not self._company_descriptions:
+            self._company_descriptions = self.kfinance_api_client.fetch_company_descriptions(
+                company_id=self.company_id
+            )
+        return self._company_descriptions.description
+
+    @property
+    def alternate_names(self) -> list[str]:
+        """Lazily fetch and return a company's alternate names"""
+        if not self._company_other_names:
+            self._company_other_names = self.kfinance_api_client.fetch_company_other_names(
+                company_id=self.company_id
+            )
+        return self._company_other_names.alternate_names
+
+    @property
+    def historical_names(self) -> list[str]:
+        """Lazily fetch and return a company's historical names"""
+        if not self._company_other_names:
+            self._company_other_names = self.kfinance_api_client.fetch_company_other_names(
+                company_id=self.company_id
+            )
+        return self._company_other_names.historical_names
+
+    @property
+    def native_names(self) -> list[NativeName]:
+        """Lazily fetch and return a company's native names"""
+        if not self._company_other_names:
+            self._company_other_names = self.kfinance_api_client.fetch_company_other_names(
+                company_id=self.company_id
+            )
+        return self._company_other_names.native_names
+
     def competitors(
         self, competitor_source: CompetitorSource = CompetitorSource.all
     ) -> "Companies":

{kensho_kfinance-3.1.1/kfinance/models → kensho_kfinance-3.2.1/kfinance/client}/permission_models.py

@@ -14,3 +14,4 @@ class Permission(StrEnum):
     StatementsPermission = "StatementsPermission"
     TranscriptsPermission = "TranscriptsPermission"
     PrivateCompanyFinancialsPermission = "PrivateCompanyFinancialsPermission"
+    CompanyIntelligencePermission = "CompanyIntelligencePermission"

{kensho_kfinance-3.1.1 → kensho_kfinance-3.2.1}/kfinance/client/tests/test_fetch.py

@@ -13,7 +13,11 @@ from kfinance.domains.business_relationships.business_relationship_models import
     BusinessRelationshipType,
     RelationshipResponse,
 )
-from kfinance.domains.companies.company_models import CompanyIdAndName
+from kfinance.domains.companies.company_models import (
+    CompanyDescriptions,
+    CompanyIdAndName,
+    CompanyOtherNames,
+)
 
 
 def build_mock_api_client() -> KFinanceApiClient:
@@ -383,3 +387,75 @@ class TestFetchCompaniesFromBusinessRelationship:
             company_id=SPGI_COMPANY_ID, relationship_type=BusinessRelationshipType.supplier
         )
         assert resp == expected_result
+
+
+class TestFetchCompanyDescriptions:
+    def test_fetch_company_descriptions(self, requests_mock: Mocker, mock_client: Client) -> None:
+        """
+        GIVEN a request to fetch company descriptions
+        WHEN the api returns a response
+        THEN the response can successfully be parsed into a CompanyDescriptions object.
+        """
+
+        # Truncated from actual http response
+        http_resp = {
+            "summary": "S&P Global Inc., together... [summary]",
+            "description": "S&P Global Inc. (S&P Global), together... [description]",
+        }
+
+        expected_result = CompanyDescriptions(
+            summary="S&P Global Inc., together... [summary]",
+            description="S&P Global Inc. (S&P Global), together... [description]",
+        )
+
+        requests_mock.get(
+            url=f"{mock_client.kfinance_api_client.url_base}info/{SPGI_COMPANY_ID}/descriptions",
+            json=http_resp,
+        )
+
+        resp = mock_client.kfinance_api_client.fetch_company_descriptions(
+            company_id=SPGI_COMPANY_ID
+        )
+        assert resp == expected_result
+
+
+class TestFetchCompanyOtherNames:
+    def test_fetch_company_other_names(self, requests_mock: Mocker, mock_client: Client) -> None:
+        """
+        GIVEN a request to fetch a company's other names (alternate, historical, and native)
+        WHEN the api returns a response
+        THEN the response can be successfully parsed into a CompanyOtherNames object
+        """
+        alternate_names = ["S&P Global", "S&P Global, Inc.", "S&P"]
+        historical_names = [
+            "McGraw-Hill Publishing Company, Inc.",
+            "McGraw-Hill Book Company",
+            "McGraw Hill Financial, Inc.",
+            "The McGraw-Hill Companies, Inc.",
+        ]
+        native_names = [
+            {"name": "KLab Venture Partners 株式会社", "language": "Japanese"},
+            {"name": "株式会社ANOBAKA", "language": "Japanese"},
+            {"name": "株式会社KVP", "language": "Japanese"},
+        ]
+
+        http_resp = {
+            "alternate_names": alternate_names,
+            "historical_names": historical_names,
+            "native_names": native_names,
+        }
+
+        expected_resp = CompanyOtherNames(
+            alternate_names=alternate_names,
+            historical_names=historical_names,
+            native_names=native_names,
+        )
+
+        requests_mock.get(
+            url=f"{mock_client.kfinance_api_client.url_base}info/{SPGI_COMPANY_ID}/names",
+            json=http_resp,
+        )
+
+        resp = mock_client.kfinance_api_client.fetch_company_other_names(company_id=SPGI_COMPANY_ID)
+
+        assert resp == expected_resp

{kensho_kfinance-3.1.1 → kensho_kfinance-3.2.1}/kfinance/domains/companies/company_models.py

@@ -118,3 +118,25 @@ class UnifiedIdTripleResponse(BaseModel):
                 f"{identifier} is a private company without a trading_item_id."
             )
             self.identifiers_to_id_triples.pop(identifier)
+
+
+class CompanyDescriptions(BaseModel):
+    """A company summary and description"""
+
+    summary: str
+    description: str
+
+
+class NativeName(BaseModel):
+    """A company's native name's name and language"""
+
+    name: str
+    language: str
+
+
+class CompanyOtherNames(BaseModel):
+    """A company's alternate, historical, and native names"""
+
+    alternate_names: list[str]
+    historical_names: list[str]
+    native_names: list[NativeName]

kensho_kfinance-3.2.1/kfinance/domains/companies/company_tools.py

@@ -0,0 +1,198 @@
+from textwrap import dedent
+from typing import Type
+
+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_models import CompanyDescriptions, CompanyOtherNames
+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("""
+        Get the information associated with a list of identifiers. Info includes company name, status, type, simple industry, number of employees (if available), founding date, webpage, HQ address, HQ city, HQ zip code, HQ state, HQ country, and HQ country iso code.
+
+        - When possible, pass multiple identifiers in a single call rather than making multiple calls.
+    """).strip()
+    args_schema: Type[BaseModel] = ToolArgsWithIdentifiers
+    accepted_permissions: set[Permission] | None = None
+
+    def _run(self, identifiers: list[str]) -> dict:
+        """Sample response:
+
+        {   "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
+        id_triple_resp = api_client.unified_fetch_id_triples(identifiers=identifiers)
+
+        tasks = [
+            Task(
+                func=api_client.fetch_info,
+                kwargs=dict(company_id=id_triple.company_id),
+                result_key=identifier,
+            )
+            for identifier, id_triple in id_triple_resp.identifiers_to_id_triples.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")
+
+
+class GetCompanyOtherNamesFromIdentifiersResp(ToolRespWithErrors):
+    results: dict[str, CompanyOtherNames]
+
+
+class GetCompanyOtherNamesFromIdentifiers(KfinanceTool):
+    name: str = "get_company_other_names_from_identifiers"
+    description: str = dedent("""
+        Given a list of identifiers, fetch the alternate, historical, and native names associated with each identifier. Alternate names are additional names a company might go by (for example, Hewlett-Packard Company also goes by the name HP). Historical names are previous names for the company if it has changed over time. Native names are primary non-Latin character native names for global companies, including languages such as Arabic, Russian, Greek, Japanese, etc. This also includes limited history on native name changes.
+
+        - When possible, pass multiple identifiers in a single call rather than making multiple calls.
+    """).strip()
+    args_schema: Type[BaseModel] = ToolArgsWithIdentifiers
+    accepted_permissions: set[Permission] | None = {Permission.CompanyIntelligencePermission}
+
+    def _run(
+        self,
+        identifiers: list[str],
+    ) -> dict:
+        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_company_other_names,
+                kwargs=dict(company_id=id_triple.company_id),
+                result_key=identifier,
+            )
+            for identifier, id_triple in id_triple_resp.identifiers_to_id_triples.items()
+        ]
+        info_responses: dict[str, CompanyOtherNames] = process_tasks_in_thread_pool_executor(
+            api_client=api_client, tasks=tasks
+        )
+        resp_model = GetCompanyOtherNamesFromIdentifiersResp(
+            results=info_responses, errors=list(id_triple_resp.errors.values())
+        )
+        return resp_model.model_dump(mode="json")
+
+
+class GetCompanySummaryFromIdentifiersResp(ToolRespWithErrors):
+    results: dict[str, str]
+
+
+class GetCompanySummaryFromIdentifiers(KfinanceTool):
+    name: str = "get_company_summary_from_identifiers"
+    description: str = dedent("""
+        Get one paragraph summary/short descriptions of companies, including information about the company's primary business, products and services offered and their applications, business segment details, client/customer groups served, geographic markets served, distribution channels, strategic alliances/partnerships, founded/incorporated year, latest former name, and headquarters and additional offices."
+
+        - When possible, pass multiple identifiers in a single call rather than making multiple calls.
+    """).strip()
+    args_schema: Type[BaseModel] = ToolArgsWithIdentifiers
+    accepted_permissions: set[Permission] | None = {Permission.CompanyIntelligencePermission}
+
+    def _run(
+        self,
+        identifiers: list[str],
+    ) -> dict:
+        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_company_descriptions,
+                kwargs=dict(company_id=id_triple.company_id),
+                result_key=identifier,
+            )
+            for identifier, id_triple in id_triple_resp.identifiers_to_id_triples.items()
+        ]
+        company_description_responses: dict[str, CompanyDescriptions] = (
+            process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)
+        )
+
+        # Extract only the summary field
+        summary_results = {
+            identifier: descriptions.summary
+            for identifier, descriptions in company_description_responses.items()
+        }
+
+        resp_model = GetCompanySummaryFromIdentifiersResp(
+            results=summary_results, errors=list(id_triple_resp.errors.values())
+        )
+        return resp_model.model_dump(mode="json")
+
+
+class GetCompanyDescriptionFromIdentifiersResp(ToolRespWithErrors):
+    results: dict[str, str]
+
+
+class GetCompanyDescriptionFromIdentifiers(KfinanceTool):
+    name: str = "get_company_description_from_identifiers"
+    description: str = dedent("""
+        Get detailed descriptions of companies, broken down into sections, which may include information about the company's Primary business, Segments (including Products and Services for each), Competition, Significant events, and History. Within the text, four spaces represent a new paragraph. Note that the description is divided into sections with headers, where each section has a new paragraph (four spaces) before and after the section header.
+
+        - When possible, pass multiple identifiers in a single call rather than making multiple calls.
+    """).strip()
+    args_schema: Type[BaseModel] = ToolArgsWithIdentifiers
+    accepted_permissions: set[Permission] | None = {Permission.CompanyIntelligencePermission}
+
+    def _run(
+        self,
+        identifiers: list[str],
+    ) -> dict:
+        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_company_descriptions,
+                kwargs=dict(company_id=id_triple.company_id),
+                result_key=identifier,
+            )
+            for identifier, id_triple in id_triple_resp.identifiers_to_id_triples.items()
+        ]
+        company_description_responses: dict[str, CompanyDescriptions] = (
+            process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)
+        )
+
+        # Extract only the description field
+        description_results = {
+            identifier: descriptions.description
+            for identifier, descriptions in company_description_responses.items()
+        }
+
+        resp_model = GetCompanyDescriptionFromIdentifiersResp(
+            results=description_results, errors=list(id_triple_resp.errors.values())
+        )
+        return resp_model.model_dump(mode="json")

kensho_kfinance-3.2.1/kfinance/domains/companies/tests/test_company_tools.py

@@ -0,0 +1,125 @@
+from requests_mock import Mocker
+
+from kfinance.client.kfinance import Client
+from kfinance.conftest import SPGI_COMPANY_ID
+from kfinance.domains.companies.company_tools import (
+    GetCompanyDescriptionFromIdentifiers,
+    GetCompanyOtherNamesFromIdentifiers,
+    GetCompanySummaryFromIdentifiers,
+    GetInfoFromIdentifiers,
+)
+from kfinance.integrations.tool_calling.tool_calling_models import ToolArgsWithIdentifiers
+
+
+class TestGetInfoFromIdentifiers:
+    def test_get_info_from_identifiers(self, mock_client: Client, requests_mock: Mocker):
+        """
+        GIVEN the GetInfoFromIdentifiers tool
+        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 = {
+            "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", "non-existent"]).model_dump(mode="json")
+        )
+        assert resp == expected_response
+
+
+class TestGetCompanyDescriptions:
+    description = "S&P Global Inc. (S&P Global), together... [description]"
+    summary = "S&P Global Inc., together... [summary]"
+    descriptions_data = {
+        "summary": summary,
+        "description": description,
+    }
+
+    def test_get_company_summary_from_identifier(self, mock_client: Client, requests_mock: Mocker):
+        """
+        GIVEN the GetCompanySummaryFromIdentifier tool
+        WHEN we request the company summary (short description) for SPGI
+        THEN we get back SPGI company's summary (short description)
+        """
+        requests_mock.get(
+            url=f"https://kfinance.kensho.com/api/v1/info/{SPGI_COMPANY_ID}/descriptions",
+            # truncated from the original API response
+            json=self.descriptions_data,
+        )
+
+        tool = GetCompanySummaryFromIdentifiers(kfinance_client=mock_client)
+        args = ToolArgsWithIdentifiers(identifiers=["SPGI"])
+        response = tool.run(args.model_dump(mode="json"))
+        expected_response = {"results": {"SPGI": self.summary}}
+        assert response == expected_response
+
+    def test_get_company_description_from_identifier(
+        self, mock_client: Client, requests_mock: Mocker
+    ):
+        """
+        GIVEN the GetCompanyDescriptionFromIdentifier tool
+        WHEN we request the company description for SPGI
+        THEN we get back SPGI company's description
+        """
+        requests_mock.get(
+            url=f"https://kfinance.kensho.com/api/v1/info/{SPGI_COMPANY_ID}/descriptions",
+            # truncated from the original API response
+            json=self.descriptions_data,
+        )
+
+        tool = GetCompanyDescriptionFromIdentifiers(kfinance_client=mock_client)
+        args = ToolArgsWithIdentifiers(identifiers=["SPGI"])
+        response = tool.run(args.model_dump(mode="json"))
+        expected_response = {"results": {"SPGI": self.description}}
+        assert response == expected_response
+
+
+class TestGetCompanyOtherNames:
+    alternate_names = ["S&P Global", "S&P Global, Inc.", "S&P"]
+    historical_names = [
+        "McGraw-Hill Publishing Company, Inc.",
+        "McGraw-Hill Book Company",
+        "McGraw Hill Financial, Inc.",
+        "The McGraw-Hill Companies, Inc.",
+    ]
+    native_names = [
+        {"name": "KLab Venture Partners 株式会社", "language": "Japanese"},
+        {"name": "株式会社ANOBAKA", "language": "Japanese"},
+        {"name": "株式会社KVP", "language": "Japanese"},
+    ]
+
+    company_other_names_info = {
+        "alternate_names": alternate_names,
+        "historical_names": historical_names,
+        "native_names": native_names,
+    }
+
+    def test_get_company_other_names_from_identifier(
+        self, mock_client: Client, requests_mock: Mocker
+    ):
+        """
+        GIVEN the GetCompanyOtherNamesFromIdentifier tool
+        WHEN we request the other names for SPGI
+        THEN we get back SPGI's other names
+        """
+        requests_mock.get(
+            url=f"https://kfinance.kensho.com/api/v1/info/{SPGI_COMPANY_ID}/names",
+            json=self.company_other_names_info,
+        )
+
+        tool = GetCompanyOtherNamesFromIdentifiers(kfinance_client=mock_client)
+        args = ToolArgsWithIdentifiers(identifiers=["SPGI"])
+        response = tool.run(args.model_dump(mode="json"))
+        expected_response = {"results": {"SPGI": self.company_other_names_info}}
+        assert response == expected_response

{kensho_kfinance-3.1.1 → kensho_kfinance-3.2.1}/kfinance/integrations/tool_calling/all_tools.py

@@ -2,7 +2,12 @@ from kfinance.domains.business_relationships.business_relationship_tools import
     GetBusinessRelationshipFromIdentifiers,
 )
 from kfinance.domains.capitalizations.capitalization_tools import GetCapitalizationFromIdentifiers
-from kfinance.domains.companies.company_tools import GetInfoFromIdentifiers
+from kfinance.domains.companies.company_tools import (
+    GetCompanyDescriptionFromIdentifiers,
+    GetCompanyOtherNamesFromIdentifiers,
+    GetCompanySummaryFromIdentifiers,
+    GetInfoFromIdentifiers,
+)
 from kfinance.domains.competitors.competitor_tools import GetCompetitorsFromIdentifiers
 from kfinance.domains.cusip_and_isin.cusip_and_isin_tools import (
     GetCusipFromIdentifiers,
@@ -34,6 +39,9 @@ ALL_TOOLS: list[type[KfinanceTool]] = [
     GetCapitalizationFromIdentifiers,
     # Companies
     GetInfoFromIdentifiers,
+    GetCompanyOtherNamesFromIdentifiers,
+    GetCompanySummaryFromIdentifiers,
+    GetCompanyDescriptionFromIdentifiers,
     # Competitors
     GetCompetitorsFromIdentifiers,
     # Cusip and Isin

{kensho_kfinance-3.1.1 → kensho_kfinance-3.2.1}/kfinance/version.py

@@ -1,14 +1,7 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -16,19 +9,13 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
-    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
 
-__version__ = version = '3.1.1'
-__version_tuple__ = version_tuple = (3, 1, 1)
-
-__commit_id__ = commit_id = 'g8208e6a64'
+__version__ = version = '3.2.1'
+__version_tuple__ = version_tuple = (3, 2, 1)