kensho-kfinance 2.0.1__py3-none-any.whl → 2.2.2__py3-none-any.whl

kfinance/kfinance.py

@@ -22,6 +22,7 @@ from .batch_request_handling import add_methods_of_singular_class_to_iterable_cl
 from .constants import (
     HistoryMetadata,
     IdentificationTriple,
+    IndustryClassification,
     LatestPeriods,
     Periodicity,
     YearAndQuarter,
@@ -233,10 +234,9 @@ class Company(CompanyFunctionsMetaClass):
         primary_security_id = self.kfinance_api_client.fetch_primary_security(self.company_id)[
             "primary_security"
         ]
-        self.primary_security = Security(
+        return Security(
             kfinance_api_client=self.kfinance_api_client, security_id=primary_security_id
         )
-        return self.primary_security
 
     @cached_property
     def securities(self) -> Securities:
@@ -246,10 +246,7 @@ class Company(CompanyFunctionsMetaClass):
         :rtype: Securities
         """
         security_ids = self.kfinance_api_client.fetch_securities(self.company_id)["securities"]
-        self.securities = Securities(
-            kfinance_api_client=self.kfinance_api_client, security_ids=security_ids
-        )
-        return self.securities
+        return Securities(kfinance_api_client=self.kfinance_api_client, security_ids=security_ids)
 
     @cached_property
     def latest_earnings_call(self) -> None:
@@ -265,11 +262,10 @@ class Company(CompanyFunctionsMetaClass):
     def info(self) -> dict:
         """Get the company info
 
-        :return: a dict with containing: name, status, type, simple industry, number of employees, founding date, webpage, address, city, zip code, state, country, & iso_country
+        :return: a dict with containing: name, status, type, simple industry, number of employees (if available), founding date, webpage, address, city, zip code, state, country, & iso_country
         :rtype: dict
         """
-        self.info = self.kfinance_api_client.fetch_info(self.company_id)
-        return self.info
+        return self.kfinance_api_client.fetch_info(self.company_id)
 
     @property
     def name(self) -> str:
@@ -308,11 +304,11 @@ class Company(CompanyFunctionsMetaClass):
         return self.info["simple_industry"]
 
     @property
-    def number_of_employees(self) -> str:
-        """Get the number of employees the company has
+    def number_of_employees(self) -> str | None:
+        """Get the number of employees the company has (if available)
 
         :return: how many employees the company has
-        :rtype: str
+        :rtype: str | None
         """
         return self.info["number_of_employees"]
 
@@ -539,6 +535,44 @@ class Ticker(DelegatedCompanyFunctionsMetaClass):
                 "Neither an identifier nor an identification triple (company id, security id, & trading item id) were passed in"
             )
 
+    @property
+    def id_triple(self) -> IdentificationTriple:
+        """Returns a unique identification triple for the Ticker object.
+
+        :return: an identification triple consisting of company_id, security_id, and trading_item_id
+        :rtype: IdentificationTriple
+        """
+
+        if self._company_id is None or self._security_id is None or self._trading_item_id is None:
+            if self._identifier is None:
+                raise RuntimeError(
+                    "Fetching the id triple of a Ticker requires an identifier "
+                    "(ticker, CUSIP, or ISIN)."
+                )
+            id_triple = self.kfinance_api_client.fetch_id_triple(
+                identifier=self._identifier, exchange_code=self.exchange_code
+            )
+            self._company_id = id_triple["company_id"]
+            self._security_id = id_triple["security_id"]
+            self._trading_item_id = id_triple["trading_item_id"]
+            assert self._company_id
+            assert self._security_id
+            assert self._trading_item_id
+
+        return IdentificationTriple(
+            company_id=self._company_id,
+            security_id=self._security_id,
+            trading_item_id=self._trading_item_id,
+        )
+
+    def __hash__(self) -> int:
+        return hash(self.id_triple)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Ticker):
+            return False
+        return self.id_triple == other.id_triple
+
     def __str__(self) -> str:
         """String representation for the ticker object"""
         str_attributes = []
@@ -557,79 +591,32 @@ class Ticker(DelegatedCompanyFunctionsMetaClass):
 
         return f"{type(self).__module__}.{type(self).__qualname__} of {', '.join(str_attributes)}"
 
-    def set_identification_triple(self) -> None:
-        """Get & set company_id, security_id, & trading_item_id for ticker with an exchange"""
-        if self._identifier is None:
-            raise RuntimeError(
-                "Ticker.set_identification_triple was called with a identifier set to None"
-            )
-        else:
-            id_triple = self.kfinance_api_client.fetch_id_triple(
-                self._identifier, self.exchange_code
-            )
-            self.company_id = id_triple["company_id"]
-            self.security_id = id_triple["security_id"]
-            self.trading_item_id = id_triple["trading_item_id"]
-
-    def set_company_id(self) -> int:
-        """Set the company id for the object
-
-        :return: the CIQ company id
-        :rtype: int
-        """
-        self.set_identification_triple()
-        return self.company_id
-
-    def set_security_id(self) -> int:
-        """Set the security id for the object
-
-        :return: the CIQ security id
-        :rtype: int
-        """
-        self.set_identification_triple()
-        return self.security_id
-
-    def set_trading_item_id(self) -> int:
-        """Set the trading item id for the object
-
-        :return: the CIQ trading item id
-        :rtype: int
-        """
-        self.set_identification_triple()
-        return self.trading_item_id
-
-    @cached_property
+    @property
     def company_id(self) -> int:
         """Get the company id for the object
 
         :return: the CIQ company id
         :rtype: int
         """
-        if self._company_id:
-            return self._company_id
-        return self.set_company_id()
+        return self.id_triple.company_id
 
-    @cached_property
+    @property
     def security_id(self) -> int:
         """Get the CIQ security id for the object
 
         :return: the CIQ security id
         :rtype: int
         """
-        if self._security_id:
-            return self._security_id
-        return self.set_security_id()
+        return self.id_triple.security_id
 
-    @cached_property
+    @property
     def trading_item_id(self) -> int:
         """Get the CIQ trading item id for the object
 
         :return: the CIQ trading item id
         :rtype: int
         """
-        if self._trading_item_id:
-            return self._trading_item_id
-        return self.set_trading_item_id()
+        return self.id_triple.trading_item_id
 
     @cached_property
     def primary_security(self) -> Security:
@@ -698,7 +685,7 @@ class Ticker(DelegatedCompanyFunctionsMetaClass):
     def info(self) -> dict:
         """Get the company info for the ticker
 
-        :return: a dict with containing: name, status, type, simple industry, number of employees, founding date, webpage, address, city, zip code, state, country, & iso_country
+        :return: a dict with containing: name, status, type, simple industry, number of employees (if available), founding date, webpage, address, city, zip code, state, country, & iso_country
         :rtype: dict
         """
         return self.company.info
@@ -740,11 +727,11 @@ class Ticker(DelegatedCompanyFunctionsMetaClass):
         return self.company.simple_industry
 
     @property
-    def number_of_employees(self) -> str:
-        """Get the number of employees the company has
+    def number_of_employees(self) -> str | None:
+        """Get the number of employees the company has (if available)
 
         :return: how many employees the company has
-        :rtype: str
+        :rtype: str | None
         """
         return self.company.number_of_employees
 
@@ -991,13 +978,33 @@ class Tickers(set):
         super().__init__(
             Ticker(
                 kfinance_api_client=kfinance_api_client,
-                company_id=id_triple["company_id"],
-                security_id=id_triple["security_id"],
-                trading_item_id=id_triple["trading_item_id"],
+                company_id=id_triple.company_id,
+                security_id=id_triple.security_id,
+                trading_item_id=id_triple.trading_item_id,
             )
             for id_triple in id_triples
         )
 
+    def intersection(self, *s: Iterable[Any]) -> Tickers:
+        """Returns the intersection of Tickers objects"""
+        for obj in s:
+            if not isinstance(obj, Tickers):
+                raise ValueError("Can only intersect Tickers object with other Tickers object.")
+
+        self_triples = {t.id_triple for t in self}
+        set_triples = []
+
+        for ticker_set in s:
+            set_triples.append({t.id_triple for t in ticker_set})
+        common_triples = self_triples.intersection(*set_triples)
+
+        return Tickers(kfinance_api_client=self.kfinance_api_client, id_triples=common_triples)
+
+    def __and__(self, other: Any) -> "Tickers":
+        if not isinstance(other, Tickers):
+            raise ValueError("Can only combine Tickers objects with other Tickers objects.")
+        return self.intersection(other)
+
     def companies(self) -> Companies:
         """Build a group of company objects from the group of tickers
 
@@ -1126,7 +1133,16 @@ class Client:
         if self._tools is None:
             from kfinance.tool_calling import ALL_TOOLS
 
-            self._tools = [t(kfinance_client=self) for t in ALL_TOOLS]  # type: ignore[call-arg]
+            self._tools = []
+            # Add tool to _tools if the user has permissions to use it.
+            for tool_cls in ALL_TOOLS:
+                tool = tool_cls(kfinance_client=self)  # type: ignore[call-arg]
+                if (
+                    tool.required_permission is None
+                    or tool.required_permission in self.kfinance_api_client.user_permissions
+                ):
+                    self._tools.append(tool)
+
         return self._tools
 
     @property
@@ -1212,31 +1228,90 @@ class Client:
         state_iso_code: Optional[str] = None,
         simple_industry: Optional[str] = None,
         exchange_code: Optional[str] = None,
+        sic: Optional[str] = None,
+        naics: Optional[str] = None,
+        nace: Optional[str] = None,
+        anzsic: Optional[str] = None,
+        spcapiqetf: Optional[str] = None,
+        spratings: Optional[str] = None,
+        gics: Optional[str] = None,
     ) -> Tickers:
-        """Generate tickers object representing the collection of Tickers that meet all the supplied parameters
+        """Generate a Tickers object representing the collection of Tickers that meet all the supplied parameters.
 
-        One of country_iso_code, simple_industry, or exchange_code must be supplied. A parameter set to None is not used to filter on
+        One of country_iso_code, simple_industry, or exchange_code must be supplied, or one of sic, naics, nace, anzsic, spcapiqetf, spratings, or gics.
 
-        :param country_iso_code: The ISO 3166-1 Alpha-2 or Alpha-3 code that represent the primary country the firm is based in. It default None
+        :param country_iso_code: The ISO 3166-1 Alpha-2 or Alpha-3 code that represent the primary country the firm is based in. It defaults to None
         :type country_iso_code: str, optional
-        :param state_iso_code: The ISO 3166-2 Alpha-2 code that represents the primary subdivision of the country the firm the based in. Not all ISO 3166-2 codes are supported as S&P doesn't maintain the full list but a feature request for the full list is submitted to S&P product. Requires country_iso_code also to have a value other then None. It default None
+        :param state_iso_code: The ISO 3166-2 Alpha-2 code that represents the primary subdivision of the country the firm the based in. Not all ISO 3166-2 codes are supported as S&P doesn't maintain the full list but a feature request for the full list is submitted to S&P product. Requires country_iso_code also to have a value other then None. It defaults to None
         :type state_iso_code: str, optional
-        :param simple_industry: The S&P CIQ Simple Industry defined in ciqSimpleIndustry in XPF. It default None
+        :param simple_industry: The S&P CIQ Simple Industry defined in ciqSimpleIndustry in XPF. It defaults to None
         :type simple_industry: str, optional
-        :param exchange_code: The exchange code for the primary equity listing exchange of the firm. It default None
+        :param exchange_code: The exchange code for the primary equity listing exchange of the firm. It defaults to None
         :type exchange_code: str, optional
-        :return: A tickers object that is the group of Ticker objects meeting all the supplied parameters
+        :param sic: The SIC industry code. It defaults to None
+        :type sic: str, optional
+        :param naics: The NAICS industry code. It defaults to None
+        :type naics: str, optional
+        :param nace: The NACE industry code. It defaults to None
+        :type nace: str, optional
+        :param anzsic: The ANZSIC industry code. It defaults to None
+        :type anzsic: str, optional
+        :param spcapiqetf: The S&P CapitalIQ ETF industry code. It defaults to None
+        :type spcapiqetf: str, optional
+        :param spratings: The S&P Ratings industry code. It defaults to None
+        :type spratings: str, optional
+        :param gics: The GICS code. It defaults to None
+        :type gics: str, optional
+        :return: A Tickers object that is the intersection of Ticker objects meeting all the supplied parameters.
         :rtype: Tickers
         """
-        return Tickers(
-            kfinance_api_client=self.kfinance_api_client,
-            id_triples=self.kfinance_api_client.fetch_ticker_combined(
-                country_iso_code=country_iso_code,
-                state_iso_code=state_iso_code,
-                simple_industry=simple_industry,
-                exchange_code=exchange_code,
-            )["tickers"],
-        )
+        # Create a list to accumulate the fetched ticker sets
+        ticker_sets: list[Tickers] = []
+
+        # Map the parameters to the industry_dict, pass the values in as the key.
+        industry_dict = {
+            "sic": sic,
+            "naics": naics,
+            "nace": nace,
+            "anzsic": anzsic,
+            "spcapiqetf": spcapiqetf,
+            "spratings": spratings,
+            "gics": gics,
+        }
+
+        if any(
+            parameter is not None
+            for parameter in [country_iso_code, state_iso_code, simple_industry, exchange_code]
+        ):
+            ticker_sets.append(
+                Tickers(
+                    kfinance_api_client=self.kfinance_api_client,
+                    id_triples=self.kfinance_api_client.fetch_ticker_combined(
+                        country_iso_code=country_iso_code,
+                        state_iso_code=state_iso_code,
+                        simple_industry=simple_industry,
+                        exchange_code=exchange_code,
+                    ),
+                )
+            )
+
+        for key, value in industry_dict.items():
+            if value is not None:
+                ticker_sets.append(
+                    Tickers(
+                        kfinance_api_client=self.kfinance_api_client,
+                        id_triples=self.kfinance_api_client.fetch_ticker_from_industry_code(
+                            industry_code=value,
+                            industry_classification=IndustryClassification(key),
+                        ),
+                    )
+                )
+
+        if not ticker_sets:
+            return Tickers(kfinance_api_client=self.kfinance_api_client, id_triples=set())
+
+        common_ticker_elements = Tickers.intersection(*ticker_sets)
+        return common_ticker_elements
 
     def company(self, company_id: int) -> Company:
         """Generate the Company object from company_id

kfinance/meta_classes.py

@@ -1,12 +1,13 @@
 from datetime import datetime
-from functools import cache, cached_property
+from functools import cached_property
 import logging
 from typing import TYPE_CHECKING, Any, Callable, Literal, Optional
 
+from cachetools import LRUCache, cached
 import numpy as np
 import pandas as pd
 
-from .constants import LINE_ITEMS, BusinessRelationshipType, PeriodType
+from .constants import LINE_ITEMS, BusinessRelationshipType, PeriodType, SegmentType
 from .fetch import KFinanceApiClient
 
 
@@ -46,7 +47,7 @@ class CompanyFunctionsMetaClass:
         if end_quarter and not (1 <= end_quarter <= 4):
             raise ValueError("end_qtr is out of range 1 to 4")
 
-    @cache
+    @cached(cache=LRUCache(maxsize=100))
     def statement(
         self,
         statement_type: str,
@@ -85,7 +86,7 @@ class CompanyFunctionsMetaClass:
 
     def income_statement(
         self,
-        period_type: Optional[str] = None,
+        period_type: Optional[PeriodType] = None,
         start_year: Optional[int] = None,
         end_year: Optional[int] = None,
         start_quarter: Optional[int] = None,
@@ -103,7 +104,7 @@ class CompanyFunctionsMetaClass:
 
     def income_stmt(
         self,
-        period_type: Optional[str] = None,
+        period_type: Optional[PeriodType] = None,
         start_year: Optional[int] = None,
         end_year: Optional[int] = None,
         start_quarter: Optional[int] = None,
@@ -121,7 +122,7 @@ class CompanyFunctionsMetaClass:
 
     def balance_sheet(
         self,
-        period_type: Optional[str] = None,
+        period_type: Optional[PeriodType] = None,
         start_year: Optional[int] = None,
         end_year: Optional[int] = None,
         start_quarter: Optional[int] = None,
@@ -139,7 +140,7 @@ class CompanyFunctionsMetaClass:
 
     def cash_flow(
         self,
-        period_type: Optional[str] = None,
+        period_type: Optional[PeriodType] = None,
         start_year: Optional[int] = None,
         end_year: Optional[int] = None,
         start_quarter: Optional[int] = None,
@@ -157,7 +158,7 @@ class CompanyFunctionsMetaClass:
 
     def cashflow(
         self,
-        period_type: Optional[str] = None,
+        period_type: Optional[PeriodType] = None,
         start_year: Optional[int] = None,
         end_year: Optional[int] = None,
         start_quarter: Optional[int] = None,
@@ -173,7 +174,7 @@ class CompanyFunctionsMetaClass:
             end_quarter=end_quarter,
         )
 
-    @cache
+    @cached(cache=LRUCache(maxsize=100))
     def line_item(
         self,
         line_item: str,
@@ -303,6 +304,114 @@ class CompanyFunctionsMetaClass:
         )
         return df.set_index("date")[[column_to_extract]].apply(pd.to_numeric).replace(np.nan, None)
 
+    def _segments(
+        self,
+        segment_type: SegmentType,
+        period_type: Optional[PeriodType] = None,
+        start_year: Optional[int] = None,
+        end_year: Optional[int] = None,
+        start_quarter: Optional[int] = None,
+        end_quarter: Optional[int] = None,
+    ) -> pd.DataFrame:
+        """Get the company's segments"""
+        try:
+            self.validate_inputs(
+                start_year=start_year,
+                end_year=end_year,
+                start_quarter=start_quarter,
+                end_quarter=end_quarter,
+            )
+        except ValueError:
+            return pd.DataFrame()
+
+        results = self.kfinance_api_client.fetch_segments(
+            company_id=self.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,
+        )["segments"]
+
+        period_name = (
+            "Year" if (period_type == PeriodType.annual or period_type is None) else "Period"
+        )
+
+        # flatten the nested dictionary and return as a DataFrame
+        rows = []
+        for period, segments in results.items():
+            for segment_name, line_items in segments.items():
+                for line_item, value in line_items.items():
+                    rows.append([period, segment_name, line_item, value])
+        return pd.DataFrame(
+            rows, columns=[period_name, "Segment Name", "Line Item", "Value"]
+        ).replace(np.nan, None)
+
+    def business_segments(
+        self,
+        period_type: Optional[PeriodType] = None,
+        start_year: Optional[int] = None,
+        end_year: Optional[int] = None,
+        start_quarter: Optional[int] = None,
+        end_quarter: Optional[int] = None,
+    ) -> pd.DataFrame:
+        """Retrieves the templated line of business segments for a given period_type, start_year, start_quarter, end_year and end_quarter.
+
+        :param period_type: The period_type requested for. Can be “annual”, “quarterly”, "ytd". Defaults to “annual” when start_quarter and end_quarter are None.
+        :type start_year: PeriodType, optional
+        :param start_year: The starting calendar year, defaults to None
+        :type start_year: int, optional
+        :param end_year: The ending calendar year, defaults to None
+        :type end_year: int, optional
+        :param start_quarter: The starting calendar quarter, defaults to None
+        :type start_quarter: int, optional
+        :param end_quarter: The ending calendar quarter, defaults to None
+        :type end_quarter: int, optional
+        :return: A DataFrame with `Year`/`Period`, `Segment Name`, `Line Item` and `Value` column.
+        :rtype: pd.DataFrame
+        """
+        return self._segments(
+            segment_type=SegmentType.business,
+            period_type=period_type,
+            start_year=start_year,
+            end_year=end_year,
+            start_quarter=start_quarter,
+            end_quarter=end_quarter,
+        )
+
+    def geographic_segments(
+        self,
+        period_type: Optional[PeriodType] = None,
+        start_year: Optional[int] = None,
+        end_year: Optional[int] = None,
+        start_quarter: Optional[int] = None,
+        end_quarter: Optional[int] = None,
+    ) -> pd.DataFrame:
+        """Retrieves the templated geographic segments for a given company for a given period_type, start_year, start_quarter, end_year and end_quarter.
+
+        :param period_type: The period_type requested for. Can be “annual”, “quarterly”, "ytd". Defaults to “annual” when start_quarter and end_quarter are None.
+        :type start_year: PeriodType, optional
+        :param start_year: The starting calendar year, defaults to None
+        :type start_year: int, optional
+        :param end_year: The ending calendar year, defaults to None
+        :type end_year: int, optional
+        :param start_quarter: The starting calendar quarter, defaults to None
+        :type start_quarter: int, optional
+        :param end_quarter: The ending calendar quarter, defaults to None
+        :type end_quarter: int, optional
+        :return: A DataFrame with `Year`/`Period`, `Segment Name`, `Line Item` and `Value` column.
+        :rtype: pd.DataFrame
+        """
+        return self._segments(
+            segment_type=SegmentType.geographic,
+            period_type=period_type,
+            start_year=start_year,
+            end_year=end_year,
+            start_quarter=start_quarter,
+            end_quarter=end_quarter,
+        )
+
 
 for line_item in LINE_ITEMS:
     line_item_name = line_item["name"]

kfinance/tests/conftest.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+
+import pytest
+from requests_mock import Mocker
+
+from kfinance.kfinance import Client
+
+
+SPGI_COMPANY_ID = 21719
+SPGI_SECURITY_ID = 2629107
+SPGI_TRADING_ITEM_ID = 2629108
+
+
+@pytest.fixture
+def mock_client(requests_mock: Mocker) -> Client:
+    """Create a KFinanceApiClient with a mock response for the SPGI id triple."""
+
+    client = Client(refresh_token="foo")
+    # Set access token so that the client doesn't try to fetch it.
+    client.kfinance_api_client._access_token = "foo"  # noqa: SLF001
+    client.kfinance_api_client._access_token_expiry = datetime(2100, 1, 1).timestamp()  # noqa: SLF001
+
+    # Create a mock for the SPGI id triple.
+    requests_mock.get(
+        url="https://kfinance.kensho.com/api/v1/id/SPGI",
+        json={
+            "trading_item_id": SPGI_TRADING_ITEM_ID,
+            "security_id": SPGI_SECURITY_ID,
+            "company_id": SPGI_COMPANY_ID,
+        },
+    )
+    return client

kfinance/tests/test_batch_requests.py

@@ -1,7 +1,8 @@
 from concurrent.futures import ThreadPoolExecutor
+import time
 from typing import Any, Dict
 from unittest import TestCase
-from unittest.mock import patch
+from unittest.mock import PropertyMock, patch
 
 import numpy as np
 import pandas as pd
@@ -9,6 +10,7 @@ import pytest
 import requests
 import requests_mock
 
+from kfinance.batch_request_handling import MAX_WORKERS_CAP
 from kfinance.fetch import KFinanceApiClient
 from kfinance.kfinance import Companies, Company, Ticker, TradingItems
 
@@ -34,8 +36,13 @@ class TestTradingItem(TestCase):
     def test_batch_request_property(self, m):
         """GIVEN a kfinance group object like Companies
         WHEN we batch request a property for each object in the group
-        THEN the batch request completes successfully and we get back a mapping of
-        company objects to the corresponding values."""
+        THEN the batch request completes successfully, and we get back a mapping of
+        company objects to the corresponding values.
+
+        Note: This test also checks that multiple tasks can be submitted. In the
+        first implementation, we used the threadpool context manager, which shuts down
+        the threadpool on __exit__ and prevented further tasks from getting submitted.
+        """
 
         m.get(
             "https://kfinance.kensho.com/api/v1/info/1001",
@@ -52,12 +59,13 @@ class TestTradingItem(TestCase):
             },
         )
 
-        companies = Companies(self.kfinance_api_client, [1001, 1002])
-        result = companies.city
-        id_based_result = self.company_object_keys_as_company_id(result)
+        for _ in range(3):
+            companies = Companies(self.kfinance_api_client, [1001, 1002])
+            result = companies.city
+            id_based_result = self.company_object_keys_as_company_id(result)
 
-        expected_id_based_result = {1001: "Mock City A", 1002: "Mock City B"}
-        self.assertDictEqual(id_based_result, expected_id_based_result)
+            expected_id_based_result = {1001: "Mock City A", 1002: "Mock City B"}
+            self.assertDictEqual(id_based_result, expected_id_based_result)
 
     @requests_mock.Mocker()
     def test_batch_request_cached_properties(self, m):
@@ -254,3 +262,33 @@ class TestTradingItem(TestCase):
 
         expected_id_based_result = {1001: "Mock City A"}
         self.assertDictEqual(id_based_result, expected_id_based_result)
+
+    @patch.object(Company, "info", new_callable=PropertyMock)
+    def test_batch_requests_processed_in_parallel(self, mock_value: PropertyMock):
+        """
+        WHEN a batch request gets processed
+        THEN the requests are handled in parallel not sequentially.
+        """
+
+        sleep_duration = 0.05
+
+        def mock_info_with_sleep() -> dict[str, str]:
+            """Mock an info call with a short sleep"""
+            time.sleep(sleep_duration)
+            return {"city": "Cambridge"}
+
+        mock_value.side_effect = mock_info_with_sleep
+
+        # Create tasks up to the MAX_WORKERS_CAP (max number of parallel tasks)
+        companies = Companies(
+            self.kfinance_api_client_with_thread_pool, [i for i in range(MAX_WORKERS_CAP)]
+        )
+
+        start = time.perf_counter()
+        result = companies.city
+        end = time.perf_counter()
+        assert len(result) == MAX_WORKERS_CAP
+        # Check that the requests run faster than sequential.
+        # In practice, the requests should take barely more than the `sleep_duration` but timing
+        # based tests can be flaky, especially in CI.
+        assert end - start < MAX_WORKERS_CAP * sleep_duration