lionagi 0.0.312__py3-none-any.whl → 0.2.1__py3-none-any.whl

lionagi/lions/researcher/data_source/finhub_.py

@@ -0,0 +1,191 @@
+import os
+from lionagi.libs import convert
+
+finnhub_key_scheme = "FINNHUB_API_KEY"
+
+
+class FinnHub:
+    """
+    A utility class for interacting with the FinnHub API to retrieve financial and market data.
+
+    Attributes:
+        api_key (str): The API key used for authenticating with the FinnHub API.
+
+    Methods:
+        get_client(api_key=None):
+            Returns a FinnHub API client instance for making API calls.
+
+        get_info_df(info_kind="company_news", api_key=None, **kwargs):
+            Retrieves data from the FinnHub API based on the specified 'info_kind' and returns it as a Pandas DataFrame.
+    """
+
+    api_key = os.getenv(finnhub_key_scheme)
+
+    @classmethod
+    def get_client(cls, api_key=None):
+        """
+        Creates and returns a FinnHub API client instance.
+
+        Args:
+            api_key (str): The API key used for authenticating with the FinnHub API. If not provided,
+                the class-level API key (if set) will be used.
+
+        Returns:
+            finnhub.Client: A FinnHub API client instance.
+
+        Raises:
+            ImportError: If there is an error while importing the 'finnhub' library.
+        """
+        try:
+            from lionagi.libs import SysUtil
+
+            SysUtil.check_import("finnhub")
+
+            import finnhub
+
+            return finnhub.Client(api_key=api_key or cls.api_key)
+        except Exception as e:
+            raise ImportError(f"Error occured during importing finnhub: {e}")
+
+    @classmethod
+    def get_info_df(cls, info_kind="company_news", api_key=None, **kwargs):
+        """
+        Retrieves data from the FinnHub API based on the specified 'info_kind' and returns it as a Pandas DataFrame.
+
+        Args:
+            info_kind (str): The type of information to retrieve from FinnHub. Default is "company_news".
+            api_key (str): The API key used for authenticating with the FinnHub API. If not provided,
+                the class-level API key (if set) will be used.
+            **kwargs: Additional keyword arguments to customize the API query.
+
+        Returns:
+            pandas.DataFrame: A Pandas DataFrame containing the retrieved data.
+
+        Raises:
+            ValueError: If there is an error during the API call or while converting the data to a DataFrame.
+        """
+        client = cls.get_client(api_key)
+        info_func = cls.get_finnhub_method(client, info_kind)
+        try:
+            results = info_func(**kwargs)
+            try:
+                df = convert.to_df(results)
+                return df
+            except Exception as e:
+                raise ValueError(
+                    f"Error occured during converting {info_kind} to DataFrame: {e}"
+                )
+        except Exception as e:
+            raise ValueError(
+                f"Error occured during getting {info_kind} from FinnHub: {e}"
+            )
+
+    @staticmethod
+    def get_finnhub_method(client, info_kind):
+        """
+        Returns the appropriate FinnHub API method based on the specified 'info_kind'.
+
+        Args:
+            client (finnhub.Client): The FinnHub API client instance.
+            info_kind (str): The type of information to retrieve from FinnHub.
+
+        Returns:
+            Callable or None: The corresponding FinnHub API method, or None if 'info_kind' is not recognized.
+        """
+        info_func = {
+            "aggregate_indicator": client.aggregate_indicator,
+            "company_basic_financials": client.company_basic_financials,
+            "company_earnings": client.company_earnings,
+            "company_eps_estimates": client.company_eps_estimates,
+            "company_executive": client.company_executive,
+            "company_news": client.company_news,
+            "company_peers": client.company_peers,
+            "company_profile": client.company_profile,
+            "company_profile2": client.company_profile2,
+            "company_revenue_estimates": client.company_revenue_estimates,
+            "country": client.country,
+            "crypto_exchanges": client.crypto_exchanges,
+            "crypto_symbols": client.crypto_symbols,
+            "economic_data": client.economic_data,
+            "filings": client.filings,
+            "financials": client.financials,
+            "financials_reported": client.financials_reported,
+            "forex_exchanges": client.forex_exchanges,
+            "forex_rates": client.forex_rates,
+            "forex_symbols": client.forex_symbols,
+            "fund_ownership": client.fund_ownership,
+            "general_news": client.general_news,
+            "ownership": client.ownership,
+            "ipo_calendar": client.ipo_calendar,
+            "press_releases": client.press_releases,
+            "news_sentiment": client.news_sentiment,
+            "pattern_recognition": client.pattern_recognition,
+            "price_target": client.price_target,
+            "quote": client.quote,
+            "recommendation_trends": client.recommendation_trends,
+            "stock_dividends": client.stock_dividends,
+            "stock_basic_dividends": client.stock_basic_dividends,
+            "stock_symbols": client.stock_symbols,
+            "transcripts": client.transcripts,
+            "transcripts_list": client.transcripts_list,
+            "earnings_calendar": client.earnings_calendar,
+            "covid19": client.covid19,
+            "upgrade_downgrade": client.upgrade_downgrade,
+            "economic_code": client.economic_code,
+            "calendar_economic": client.calendar_economic,
+            "support_resistance": client.support_resistance,
+            "technical_indicator": client.technical_indicator,
+            "stock_splits": client.stock_splits,
+            "forex_candles": client.forex_candles,
+            "crypto_candles": client.crypto_candles,
+            "stock_tick": client.stock_tick,
+            "stock_nbbo": client.stock_nbbo,
+            "indices_const": client.indices_const,
+            "indices_hist_const": client.indices_hist_const,
+            "etfs_profile": client.etfs_profile,
+            "etfs_holdings": client.etfs_holdings,
+            "etfs_sector_exp": client.etfs_sector_exp,
+            "etfs_country_exp": client.etfs_country_exp,
+            "international_filings": client.international_filings,
+            "sec_sentiment_analysis": client.sec_sentiment_analysis,
+            "sec_similarity_index": client.sec_similarity_index,
+            "last_bid_ask": client.last_bid_ask,
+            "fda_calendar": client.fda_calendar,
+            "symbol_lookup": client.symbol_lookup,
+            "stock_insider_transactions": client.stock_insider_transactions,
+            "mutual_fund_profile": client.mutual_fund_profile,
+            "mutual_fund_holdings": client.mutual_fund_holdings,
+            "mutual_fund_sector_exp": client.mutual_fund_sector_exp,
+            "mutual_fund_country_exp": client.mutual_fund_country_exp,
+            "stock_revenue_breakdown": client.stock_revenue_breakdown,
+            "stock_social_sentiment": client.stock_social_sentiment,
+            "stock_investment_theme": client.stock_investment_theme,
+            "stock_supply_chain": client.stock_supply_chain,
+            "company_esg_score": client.company_esg_score,
+            "company_earnings_quality_score": client.company_earnings_quality_score,
+            "crypto_profile": client.crypto_profile,
+            "company_ebitda_estimates": client.company_ebitda_estimates,
+            "company_ebit_estimates": client.company_ebit_estimates,
+            "stock_uspto_patent": client.stock_uspto_patent,
+            "stock_visa_application": client.stock_visa_application,
+            "stock_insider_sentiment": client.stock_insider_sentiment,
+            "bond_profile": client.bond_profile,
+            "bond_price": client.bond_price,
+            "stock_lobbying": client.stock_lobbying,
+            "stock_usa_spending": client.stock_usa_spending,
+            "sector_metric": client.sector_metric,
+            "mutual_fund_eet": client.mutual_fund_eet,
+            "mutual_fund_eet_pai": client.mutual_fund_eet_pai,
+            "isin_change": client.isin_change,
+            "symbol_change": client.symbol_change,
+            "institutional_profile": client.institutional_profile,
+            "institutional_portfolio": client.institutional_portfolio,
+            "institutional_ownership": client.institutional_ownership,
+            "bond_yield_curve": client.bond_yield_curve,
+            "bond_tick": client.bond_tick,
+            "congressional_trading": client.congressional_trading,
+            "price_metrics": client.price_metrics,
+            "market_holiday": client.market_holiday,
+            "market_status": client.market_status,
+        }
+        return info_func.get(info_kind, None)

lionagi/lions/researcher/data_source/google_.py

@@ -0,0 +1,199 @@
+import os
+
+google_key_scheme = "GOOGLE_API_KEY"
+google_engine_scheme = "GOOGLE_CSE_ID"
+
+google_api_key = os.getenv(google_key_scheme)
+google_engine = os.getenv(google_engine_scheme)
+
+
+class GoogleSearch:
+    """
+    A utility class for performing Google searches and retrieving search results.
+
+    Attributes:
+        api_key (str): The Google API key used for search (can be set via environment variable).
+        search_engine (str): The Google Custom Search Engine ID (can be set via environment variable).
+
+    Methods:
+        create_agent_engine(api_key=None, search_engine=None, verbose=False):
+            Create an OpenAIAgent for Google search operations.
+
+        url_get_content(url: str):
+            Retrieve and parse the content from a given URL.
+
+        search(title: str = None, url: str = None):
+            Perform a Google search for a given title or URL and retrieve relevant content.
+    """
+
+    api_key = google_api_key
+    search_engine = google_engine
+    search_url = """
+        https://www.googleapis.com/customsearch/v1?key={key}&cx={engine}&q={query}&start={start}
+        """
+
+    @classmethod
+    def create_agent(cls, api_key=None, search_engine=None, verbose=False):
+        """
+        Create an OpenAIAgent for Google search operations.
+
+        Args:
+            api_key (str, optional): The Google API key for search. Defaults to None (uses class attribute).
+            search_engine (str, optional): The Google Custom Search Engine ID. Defaults to None (uses class attribute).
+            verbose (bool, optional): Whether to enable verbose mode for the agent. Defaults to False.
+
+        Returns:
+            OpenAIAgent: An instance of the OpenAIAgent for performing Google searches.
+
+        Raises:
+            ImportError: If there is an issue during the agent creation.
+        """
+        try:
+            from lionagi.libs import SysUtil
+
+            SysUtil.check_import(package_name="llama_index", pip_name="llama-index")
+
+            SysUtil.check_import(
+                package_name="llama_index",
+                module_name="agent.openai",
+                import_name="OpenAIAgent",
+                pip_name="llama-index-agent-openai",
+            )
+
+            SysUtil.check_import(
+                package_name="llama_index",
+                module_name="tools.google",
+                import_name="GoogleSearchToolSpec",
+                pip_name="llama-index-tools-google",
+            )
+
+            from llama_index.agent import OpenAIAgent
+            from llama_index.tools.tool_spec.load_and_search.base import (
+                LoadAndSearchToolSpec,
+            )
+            from llama_index.tools.google import GoogleSearchToolSpec
+            from llama_index.llms.openai import OpenAI
+
+            llm = OpenAI(model="gpt-4-turbo", temperature=0.1)
+
+            api_key = api_key if api_key else cls.api_key
+            search_engine = search_engine if search_engine else cls.search_engine
+            google_spec = GoogleSearchToolSpec(key=api_key, engine=search_engine)
+
+            # Wrap the google search tool as it returns large payloads
+            tools = LoadAndSearchToolSpec.from_defaults(
+                google_spec.to_tool_list()[0],
+            ).to_tool_list()
+
+            # Create the Agent with our tools
+            agent = OpenAIAgent.from_tools(tools, verbose=verbose, llm=llm)
+            return agent
+
+        except Exception as e:
+            raise ImportError(f"Error in importing OpenAIAgent from llama_index: {e}")
+
+
+# responses_google = []
+# async def query_google(query: str):
+#     """
+#     Search Google and retrieve a natural language answer to a given query.
+
+#     Args:
+#         query (str): The search query to find an answer for.
+
+#     Returns:
+#         str: A natural language answer obtained from Google search results.
+
+#     Raises:
+#         Exception: If there is an issue with making the request or parsing the response.
+#     """
+#     google_agent = GoogleSearch.create_agent()
+#     response = await google_agent.achat(query)
+#     responses_google.append(response)
+#     return str(response.response)
+
+
+# @staticmethod
+# def search(title: str = None, url: str = None):
+#     """
+#     Perform a Google search for a given title or URL and retrieve relevant content.
+
+#     Args:
+#         title (str, optional): The title or query for the Google search. Defaults to None.
+#         url (str, optional): The URL to retrieve content from. Defaults to None.
+
+#     Returns:
+#         str: The retrieved information from the Google search or URL, or an error message if no results are found.
+
+#     Raises:
+#         ValueError: If there is an issue during the search or content retrieval.
+#     """
+#     if not title and not url:
+#         raise 'No search input.'
+#     from ..utils.url_util import get_url_content
+
+#     if url:
+#         return get_url_content(url)
+#     else:
+#         from googlesearch import search
+#         search_result = search(title)
+
+#         for url in search_result:
+#             try:
+#                 return get_url_content(url)
+
+#             except:
+#                 continue
+#         return 'No matched or valid source'
+
+
+# get fields of a google search item
+# @classmethod
+# def _get_search_item_field(cls, item: Dict[str, Any]) -> Dict[str, str]:
+#     try:
+#         long_description = item["pagemap"]["metatags"][0]["og:description"]
+#     except KeyError:
+#         long_description = "N/A"
+#     url = item.get("link")
+#
+#     return {
+#         "title": item.get("title"),
+#         "snippet": item.get("snippet"),
+#         "url": item.get("link"),
+#         "long_description": long_description,
+#         "content": get_url_content(url)
+#     }
+#
+# @classmethod
+# def _format_search_url(cls, url, api_key, search_engine, query, start):
+#     url = url or cls.search_url
+#     url = url.format(
+#         key=api_key or cls.api_key,
+#         engine=search_engine or cls.search_engine,
+#         query=query,
+#         start=start
+#     )
+#     return url
+#
+# @classmethod
+# def search(
+#     cls,
+#     query: str =None,
+#     search_url = None,
+#     api_key = None,
+#     search_engine=None,
+#     start: int = 1,
+#     timeout: tuple = (0.5, 0.5),
+#     content=True,
+#     num=5
+#     ):
+#     url = cls._format_search_url(
+#         url = search_url, query=query, api_key=api_key,
+#         search_engine=search_engine, start=start
+#         )
+#     response = get_url_response(url, timeout=timeout)
+#     response_dict = response.json()
+#     items = response_dict.get('items')[:num]
+#     if content:
+#         items = lcall(items, cls._get_search_item_field, dropna=True)
+#     return items

lionagi/lions/researcher/data_source/wiki_.py

@@ -0,0 +1,96 @@
+class WikipediaSearch:
+    """
+    A utility class for searching and retrieving information from Wikipedia.
+    Methods:
+        query(query: str, lang: str = 'en'):
+            Search for a query on Wikipedia and retrieve relevant information.
+    """
+
+    # @staticmethod
+    def create_agent(verbose=False):
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import(package_name="llama_index", pip_name="llama-index")
+
+        SysUtil.check_import(
+            package_name="llama_index",
+            module_name="agent.openai",
+            import_name="OpenAIAgent",
+            pip_name="llama-index-agent-openai",
+        )
+
+        SysUtil.check_import(
+            package_name="llama_index",
+            module_name="tools.wikipedia",
+            import_name="WikipediaToolSpec",
+            pip_name="llama-index-tools-wikipedia",
+        )
+
+        from llama_index.tools.wikipedia import WikipediaToolSpec
+        from llama_index.agent.openai import OpenAIAgent
+        from llama_index.llms.openai import OpenAI
+
+        llm = OpenAI(model="gpt-4-turbo", temperature=0.1)
+
+        tool_spec = WikipediaToolSpec()
+
+        agent = OpenAIAgent.from_tools(
+            tool_spec.to_tool_list(), verbose=verbose, llm=llm
+        )
+        return agent
+
+
+# responses_wiki = []
+# async def query_wiki(query: str):
+#     """
+#     Search Wikipedia and retrieve a natural language answer to a given query.
+
+#     Args:
+#         query (str): The search query to find an answer for.
+
+#     Returns:
+#         str: A natural language answer obtained from Google search results.
+
+#     Raises:
+#         Exception: If there is an issue with making the request or parsing the response.
+#     """
+#     wiki_agent = WikipediaSearch.create_agent()
+#     response = await wiki_agent.achat(query)
+#     responses_wiki.append(response)
+#     return str(response.response)
+
+
+# @staticmethod
+# def query(query: str, lang: str = 'en'):
+#     """
+#     Search for a query on Wikipedia and retrieve relevant information.
+
+#     Args:
+#         query (str): The query to search for on Wikipedia.
+#         lang (str, optional): The language for the Wikipedia search. Default is 'en' (English).
+
+#     Returns:
+#         str: The retrieved information from Wikipedia or an error message if no results are found.
+
+#     Raises:
+#         WikipediaException: If there is an issue during the Wikipedia search or content retrieval.
+#     """
+#     import lionagi.lions.searcher.wikipedia as wikipedia
+#     from llama_index import Document, VectorStoreIndex
+
+#     wikipedia.set_lang(lang)
+
+#     res = wikipedia.search(query, results=1)
+#     if len(res) == 0:
+#         return "No search results."
+#     try:
+#         wikipedia_page = wikipedia.page(res[0], auto_suggest=False)
+#     except wikipedia.PageError:
+#         return f"Unable to load page {res[0]}."
+#     content = wikipedia_page.content
+
+#     documents = [Document(text=content)]
+#     index = VectorStoreIndex.from_documents(documents)
+#     query_engine = index.as_query_engine()
+#     response = query_engine.query(query)
+#     return response.response

lionagi/lions/researcher/data_source/yfinance_.py

@@ -0,0 +1,21 @@
+def get_stock_prices(symbol, **kwargs):
+    """
+    Fetch historical stock prices for a given symbol using Yahoo Finance.
+    Args:
+        symbol (str): The stock symbol to retrieve data for, e.g., 'AAPL' for Apple Inc.
+        **kwargs: Additional keyword arguments to customize the query, such as 'start', 'end', 'period', etc.
+    Returns:
+        pandas.DataFrame: A DataFrame containing historical stock price data for the specified symbol.
+    Note:
+        - The 'symbol' parameter should be a valid stock symbol recognized by Yahoo Finance.
+        - You can customize the query further by providing keyword arguments, such as 'start' and 'end' to specify a date range.
+        - For a full list of available keyword arguments, refer to the Yahoo Finance API documentation.
+    """
+    from lionagi.libs import SysUtil
+
+    SysUtil.check_import("yfinance")
+    from yfinance import Ticker
+
+    stock = Ticker(symbol)
+    hist = stock.history(**kwargs)
+    return hist