kensho-kfinance 2.0.1__tar.gz → 2.1.2__tar.gz

{kensho_kfinance-2.0.1/kensho_kfinance.egg-info → kensho_kfinance-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kensho-kfinance
-Version: 2.0.1
+Version: 2.1.2
 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
@@ -12,6 +12,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS.md
+Requires-Dist: cachetools<6,>=5.5
 Requires-Dist: langchain-core>=0.3.15
 Requires-Dist: langchain-google-genai<3,>=2.1.0
 Requires-Dist: numpy>=1.22.4
@@ -33,6 +34,7 @@ Requires-Dist: pytest-cov<7,>=6.0.0; extra == "dev"
 Requires-Dist: requests_mock<2,>=1.12; extra == "dev"
 Requires-Dist: ruff<1,>=0.9.4; extra == "dev"
 Requires-Dist: time_machine<3,>=2.1; extra == "dev"
+Requires-Dist: types-cachetools<6,>=5.5; extra == "dev"
 Dynamic: license-file
 
 # kFinance

{kensho_kfinance-2.0.1 → kensho_kfinance-2.1.2/kensho_kfinance.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kensho-kfinance
-Version: 2.0.1
+Version: 2.1.2
 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
@@ -12,6 +12,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS.md
+Requires-Dist: cachetools<6,>=5.5
 Requires-Dist: langchain-core>=0.3.15
 Requires-Dist: langchain-google-genai<3,>=2.1.0
 Requires-Dist: numpy>=1.22.4
@@ -33,6 +34,7 @@ Requires-Dist: pytest-cov<7,>=6.0.0; extra == "dev"
 Requires-Dist: requests_mock<2,>=1.12; extra == "dev"
 Requires-Dist: ruff<1,>=0.9.4; extra == "dev"
 Requires-Dist: time_machine<3,>=2.1; extra == "dev"
+Requires-Dist: types-cachetools<6,>=5.5; extra == "dev"
 Dynamic: license-file
 
 # kFinance

{kensho_kfinance-2.0.1 → kensho_kfinance-2.1.2}/kensho_kfinance.egg-info/SOURCES.txt

@@ -37,8 +37,11 @@ kfinance/py.typed
 kfinance/server_thread.py
 kfinance/version.py
 kfinance/tests/__init__.py
+kfinance/tests/conftest.py
 kfinance/tests/test_batch_requests.py
+kfinance/tests/test_client.py
 kfinance/tests/test_fetch.py
+kfinance/tests/test_group_objects.py
 kfinance/tests/test_objects.py
 kfinance/tests/test_tools.py
 kfinance/tool_calling/README.md

{kensho_kfinance-2.0.1 → kensho_kfinance-2.1.2}/kensho_kfinance.egg-info/requires.txt

@@ -1,3 +1,4 @@
+cachetools<6,>=5.5
 langchain-core>=0.3.15
 langchain-google-genai<3,>=2.1.0
 numpy>=1.22.4
@@ -20,3 +21,4 @@ pytest-cov<7,>=6.0.0
 requests_mock<2,>=1.12
 ruff<1,>=0.9.4
 time_machine<3,>=2.1
+types-cachetools<6,>=5.5

{kensho_kfinance-2.0.1 → kensho_kfinance-2.1.2}/kfinance/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v2.1.2
+- Allow batch executor to handle multiple requests
+
+## v2.1.1
+- Use cachetools cache
+
+## v2.1.0
+- Filter llm tools by user permissions
+
+## v2.0.2
+- Add Client.tickers() method for ticker industry filters for ISRCS and GICS
+
 ## v2.0.1
 - Fix readthedocs integration for llm tools.
 

{kensho_kfinance-2.0.1 → kensho_kfinance-2.1.2}/kfinance/batch_request_handling.py

@@ -72,19 +72,19 @@ def add_methods_of_singular_class_to_iterable_class(singular_cls: Type[T]) -> Ca
         def process_in_batch(
             method: Callable, self: IterableKfinanceClass, *args: Any, **kwargs: Any
         ) -> dict:
-            results = {}
             kfinance_api_client = self.kfinance_api_client
             with kfinance_api_client.batch_request_header(batch_size=len(self)):
-                with kfinance_api_client.thread_pool as executor:
-                    results = dict(
-                        zip(
-                            self,
-                            [
-                                process_in_thread_pool(executor, method, obj, *args, **kwargs)
-                                for obj in self
-                            ],
-                        )
+                results = dict(
+                    zip(
+                        self,
+                        [
+                            process_in_thread_pool(
+                                kfinance_api_client.thread_pool, method, obj, *args, **kwargs
+                            )
+                            for obj in self
+                        ],
                     )
+                )
 
             return results
 

{kensho_kfinance-2.0.1 → kensho_kfinance-2.1.2}/kfinance/constants.py

@@ -1,7 +1,6 @@
 from datetime import date
-from enum import Enum
 from itertools import chain
-from typing import TypedDict
+from typing import NamedTuple, TypedDict
 
 from strenum import StrEnum
 
@@ -21,13 +20,13 @@ class HistoryMetadata(TypedDict):
     first_trade_date: date
 
 
-class IdentificationTriple(TypedDict):
+class IdentificationTriple(NamedTuple):
     trading_item_id: int
     security_id: int
     company_id: int
 
 
-class Capitalization(Enum):
+class Capitalization(StrEnum):
     """The capitalization type"""
 
     market_cap = "market_cap"
@@ -35,7 +34,7 @@ class Capitalization(Enum):
     shares_outstanding = "shares_outstanding"
 
 
-class PeriodType(Enum):
+class PeriodType(StrEnum):
     """The period type"""
 
     annual = "annual"
@@ -44,7 +43,7 @@ class PeriodType(Enum):
     ytd = "ytd"
 
 
-class Periodicity(Enum):
+class Periodicity(StrEnum):
     """The frequency or interval at which the historical data points are sampled or aggregated. Periodicity is not the same as the date range. The date range specifies the time span over which the data is retrieved, while periodicity determines how the data within that date range is aggregated."""
 
     day = "day"
@@ -53,7 +52,7 @@ class Periodicity(Enum):
     year = "year"
 
 
-class StatementType(Enum):
+class StatementType(StrEnum):
     """The type of financial statement"""
 
     balance_sheet = "balance_sheet"
@@ -88,6 +87,16 @@ class BusinessRelationshipType(StrEnum):
     client_services = "client_services"
 
 
+class Permission(StrEnum):
+    EarningsPermission = "EarningsPermission"
+    GICSPermission = "GICSPermission"
+    IDPermission = "IDPermission"
+    ISCRSPermission = "ISCRSPermission"
+    PricingPermission = "PricingPermission"
+    RelationshipPermission = "RelationshipPermission"
+    StatementsPermission = "StatementsPermission"
+
+
 class YearAndQuarter(TypedDict):
     year: int
     quarter: int

{kensho_kfinance-2.0.1 → kensho_kfinance-2.1.2}/kfinance/fetch.py

@@ -1,5 +1,6 @@
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
+import logging
 from time import time
 from typing import Callable, Generator, Optional
 from uuid import uuid4
@@ -13,6 +14,7 @@ from .constants import (
     IndustryClassification,
     Periodicity,
     PeriodType,
+    Permission,
 )
 
 
@@ -23,6 +25,8 @@ try:
 except ImportError:
     kfinance_version = "dev"
 
+logger = logging.getLogger(__name__)
+
 
 DEFAULT_API_HOST: str = "https://kfinance.kensho.com"
 DEFAULT_API_VERSION: int = 1
@@ -86,6 +90,7 @@ class KFinanceApiClient:
         self.user_agent_source = "object_oriented"
         self._batch_id: str | None = None
         self._batch_size: str | None = None
+        self._user_permissions: set[Permission] | None = None
 
     @contextmanager
     def batch_request_header(self, batch_size: int) -> Generator:
@@ -127,6 +132,9 @@ class KFinanceApiClient:
                 # nosemgrep:  python.jwt.security.unverified-jwt-decode.unverified-jwt-decode
                 options={"verify_signature": False},
             ).get("exp")
+            # When the access token gets refreshed, also refresh user permissions in case they
+            # have been updated.
+            self._refresh_user_permissions()
         return self._access_token
 
     def _get_access_token_via_refresh_token(self) -> str:
@@ -169,6 +177,33 @@ class KFinanceApiClient:
         response.raise_for_status()
         return response.json().get("access_token")
 
+    @property
+    def user_permissions(self) -> set[Permission]:
+        """Return the permissions that the current user holds."""
+
+        if self._user_permissions is None:
+            self._refresh_user_permissions()
+            # _refresh_user_permissions updates self._user_permissions in place
+            assert self._user_permissions is not None
+        return self._user_permissions
+
+    def _refresh_user_permissions(self) -> None:
+        """Fetches user permissions and stores them as KfinanceApiClient._user_permissions."""
+
+        user_permission_dict = self.fetch_permissions()
+        self._user_permissions = set()
+        for permission_str in user_permission_dict["permissions"]:
+            try:
+                self._user_permissions.add(Permission[permission_str])
+            except KeyError:
+                logger.warning(
+                    "Could not resolve %s to a member of the Permission enum. "
+                    "%s may be a new type of permission that still needs to be "
+                    "added to the enum.",
+                    permission_str,
+                    permission_str,
+                )
+
     def fetch(self, url: str) -> dict:
         """Does the request and auth"""
 
@@ -191,6 +226,11 @@ class KFinanceApiClient:
         response.raise_for_status()
         return response.json()
 
+    def fetch_permissions(self) -> dict[str, list[str]]:
+        """Return the permissions of the user."""
+        url = f"{self.url_base}users/permissions"
+        return self.fetch(url)
+
     def fetch_id_triple(self, identifier: str, exchange_code: Optional[str] = None) -> dict:
         """Get the ID triple from [identifier]."""
         url = f"{self.url_base}id/{identifier}"
@@ -241,7 +281,7 @@ class KFinanceApiClient:
             f"{self.url_base}pricing/{trading_item_id}/"
             f"{start_date if start_date is not None else 'none'}/"
             f"{end_date if end_date is not None else 'none'}/"
-            f"{periodicity.value if periodicity else 'none'}/"
+            f"{periodicity if periodicity else 'none'}/"
             f"{'adjusted' if is_adjusted else 'unadjusted'}"
         )
         return self.fetch(url)
@@ -278,7 +318,7 @@ class KFinanceApiClient:
             f"{self.url_base}price_chart/{trading_item_id}/"
             f"{start_date if start_date is not None else 'none'}/"
             f"{end_date if end_date is not None else 'none'}/"
-            f"{periodicity.value if periodicity else 'none'}/"
+            f"{periodicity if periodicity else 'none'}/"
             f"{'adjusted' if is_adjusted else 'unadjusted'}"
         )
 
@@ -306,7 +346,7 @@ class KFinanceApiClient:
         """Get a specified financial statement for a specified duration."""
         url = (
             f"{self.url_base}statements/{company_id}/{statement_type}/"
-            f"{period_type.value if period_type else 'none'}/"
+            f"{period_type if period_type else 'none'}/"
             f"{start_year if start_year is not None else 'none'}/"
             f"{end_year if end_year is not None else 'none'}/"
             f"{start_quarter if start_quarter is not None else 'none'}/"
@@ -327,7 +367,7 @@ class KFinanceApiClient:
         """Get a specified financial line item for a specified duration."""
         url = (
             f"{self.url_base}line_item/{company_id}/{line_item}/"
-            f"{period_type.value if period_type else 'none'}/"
+            f"{period_type if period_type else 'none'}/"
             f"{start_year if start_year is not None else 'none'}/"
             f"{end_year if end_year is not None else 'none'}/"
             f"{start_quarter if start_quarter is not None else 'none'}/"
@@ -358,10 +398,12 @@ class KFinanceApiClient:
         self,
         country_iso_code: str,
         state_iso_code: Optional[str] = None,
-    ) -> dict[str, list[IdentificationTriple]]:
+    ) -> list[IdentificationTriple]:
         """Fetch ticker geography groups"""
-        return self.fetch_geography_groups(
-            country_iso_code=country_iso_code, state_iso_code=state_iso_code, fetch_ticker=True
+        return self._tickers_response_to_id_triple(
+            self.fetch_geography_groups(
+                country_iso_code=country_iso_code, state_iso_code=state_iso_code, fetch_ticker=True
+            )
         )
 
     def fetch_company_geography_groups(
@@ -381,13 +423,13 @@ class KFinanceApiClient:
         url = f"{self.url_base}{'ticker_groups' if fetch_ticker else 'trading_item_groups'}/exchange/{exchange_code}"
         return self.fetch(url)
 
-    def fetch_ticker_exchange_groups(
-        self, exchange_code: str
-    ) -> dict[str, list[IdentificationTriple]]:
+    def fetch_ticker_exchange_groups(self, exchange_code: str) -> list[IdentificationTriple]:
         """Fetch ticker exchange groups"""
-        return self.fetch_exchange_groups(
-            exchange_code=exchange_code,
-            fetch_ticker=True,
+        return self._tickers_response_to_id_triple(
+            self.fetch_exchange_groups(
+                exchange_code=exchange_code,
+                fetch_ticker=True,
+            )
         )
 
     def fetch_trading_item_exchange_groups(self, exchange_code: str) -> dict[str, list[int]]:
@@ -397,13 +439,32 @@ class KFinanceApiClient:
             fetch_ticker=False,
         )
 
+    @staticmethod
+    def _tickers_response_to_id_triple(
+        tickers_response: dict[str, list[dict]],
+    ) -> list[IdentificationTriple]:
+        """For fetch ticker cases with a dict[str, list[dict]] response, return a list[IdentificationTriple].
+
+        For example, with a given fetch tickers response:
+        {"tickers" : [{"trading_item_id": 1, "security_id": 1, "company_id": 1}, {"trading_item_id": 2,"security_id": 2,"company_id": 2}]},
+        return [[1, 1, 1], [2, 2, 2]].
+        """
+        return [
+            IdentificationTriple(
+                trading_item_id=ticker["trading_item_id"],
+                security_id=ticker["security_id"],
+                company_id=ticker["company_id"],
+            )
+            for ticker in tickers_response["tickers"]
+        ]
+
     def fetch_ticker_combined(
         self,
         country_iso_code: Optional[str] = None,
         state_iso_code: Optional[str] = None,
         simple_industry: Optional[str] = None,
         exchange_code: Optional[str] = None,
-    ) -> dict[str, list[IdentificationTriple]]:
+    ) -> list[IdentificationTriple]:
         """Fetch tickers using combined filters route"""
         if (
             country_iso_code is None
@@ -414,11 +475,11 @@ class KFinanceApiClient:
             raise RuntimeError("Invalid parameters: No parameters provided or all set to none")
         elif country_iso_code is None and state_iso_code is not None:
             raise RuntimeError(
-                "Invalid parameters: state_iso_code must be provided with a country_iso_code value"
+                "Invalid parameters: country_iso_code must be provided with a state_iso_code value"
             )
         else:
             url = f"{self.url_base}ticker_groups/filters/geo/{str(country_iso_code).lower()}/{str(state_iso_code).lower()}/simple/{str(simple_industry).lower()}/exchange/{str(exchange_code).lower()}"
-            return self.fetch(url)
+            return self._tickers_response_to_id_triple(self.fetch(url))
 
     def fetch_companies_from_business_relationship(
         self, company_id: int, relationship_type: BusinessRelationshipType
@@ -443,22 +504,11 @@ class KFinanceApiClient:
         url = f"{self.url_base}relationship/{company_id}/{relationship_type}"
         return self.fetch(url)
 
-    def fetch_from_industry_code(
-        self,
-        industry_code: str,
-        industry_classification: IndustryClassification,
-        fetch_ticker: bool = True,
-    ) -> dict[str, list]:
-        """Fetches a list of companies or identification triples that are classified in the given industry_code and industry_classification."""
-
-        url = f"{self.url_base}{'ticker_groups' if fetch_ticker else 'company_groups'}/industry/{industry_classification}/{industry_code}"
-        return self.fetch(url)
-
     def fetch_ticker_from_industry_code(
         self,
         industry_code: str,
         industry_classification: IndustryClassification,
-    ) -> dict[str, list[IdentificationTriple]]:
+    ) -> list[IdentificationTriple]:
         """Fetches a list of identification triples that are classified in the given industry_code and industry_classification.
 
         Returns a dictionary of shape {"tickers": List[{“company_id”: <company_id>, “security_id”: <security_id>, “trading_item_id”: <trading_item_id>}]}.
@@ -466,14 +516,11 @@ class KFinanceApiClient:
         :type industry_code: str
         :param industry_classification: The type of industry_classification to filter on.
         :type industry_classification: IndustryClassification
-        :return: A dictionary containing the list of identification triple [company_id, security_id, trading_item_id] that are classified in the given industry_code and industry_classification.
-        :rtype: dict[str, list[IdentificationTriple]]
+        :return: A list of identification triples [company_id, security_id, trading_item_id] that are classified in the given industry_code and industry_classification.
+        :rtype: list[IdentificationTriple]
         """
-        return self.fetch_from_industry_code(
-            industry_code=industry_code,
-            industry_classification=industry_classification,
-            fetch_ticker=True,
-        )
+        url = f"{self.url_base}ticker_groups/industry/{industry_classification}/{industry_code}"
+        return self._tickers_response_to_id_triple(self.fetch(url))
 
     def fetch_company_from_industry_code(
         self,
@@ -490,8 +537,5 @@ class KFinanceApiClient:
         :return: A dictionary containing the list of companies that are classified in the given industry_code and industry_classification.
         :rtype: dict[str, list[int]]
         """
-        return self.fetch_from_industry_code(
-            industry_code=industry_code,
-            industry_classification=industry_classification,
-            fetch_ticker=False,
-        )
+        url = f"{self.url_base}company_groups/industry/{industry_classification}/{industry_code}"
+        return self.fetch(url)

{kensho_kfinance-2.0.1 → kensho_kfinance-2.1.2}/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:
@@ -268,8 +265,7 @@ class Company(CompanyFunctionsMetaClass):
         :return: a dict with containing: name, status, type, simple industry, number of employees, 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:
@@ -539,6 +535,23 @@ 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 identifier triple for the Ticker object."""
+        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 = []
@@ -991,13 +1004,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 +1159,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 +1254,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