lionagi 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

lionagi/lions/coder/coder.py

@@ -0,0 +1,121 @@
+import asyncio
+from lionagi.core import Session
+
+from .base_prompts import CODER_PROMPTS
+from .util import extract_code_blocks, install_missing_dependencies, set_up_interpreter
+
+
+class Coder:
+    def __init__(
+        self, prompts=None, session=None, session_kwargs=None, required_libraries=None
+    ):
+        print("Initializing Coder...")
+        self.prompts = prompts or CODER_PROMPTS
+        self.session = session or self._create_session(session_kwargs)
+        self.required_libraries = required_libraries or ["lionagi"]
+        print("Coder initialized.")
+
+    def _create_session(self, session_kwargs=None):
+        print("Creating session...")
+        session_kwargs = session_kwargs or {}
+        session = Session(system=self.prompts["system"], **session_kwargs)
+        print("Session created.")
+        return session
+
+    async def _plan_code(self, context):
+        print("Planning code...")
+        plans = await self.session.chat(self.prompts["plan_code"], context=context)
+        print("Code planning completed.")
+        return plans
+
+    async def _write_code(self, context=None):
+        print("Writing code...")
+        code = await self.session.chat(self.prompts["write_code"], context=context)
+        print("Code writing completed.")
+        return extract_code_blocks(code)
+
+    async def _review_code(self, context=None):
+        print("Reviewing code...")
+        code = await self.session.chat(self.prompts["review_code"], context=context)
+        print("Code review completed.")
+        return code
+
+    async def _modify_code(self, context=None):
+        print("Modifying code...")
+        code = await self.session.chat(self.prompts["modify_code"], context=context)
+        print("Code modification completed.")
+        return code
+
+    async def _debug_code(self, context=None):
+        print("Debugging code...")
+        code = await self.session.chat(self.prompts["debug_code"], context=context)
+        print("Code debugging completed.")
+        return code
+
+    def _handle_execution_error(self, execution, required_libraries=None):
+        print("Handling execution error...")
+        if execution.error and execution.error.name == "ModuleNotFoundError":
+            print("ModuleNotFoundError detected. Installing missing dependencies...")
+            install_missing_dependencies(required_libraries)
+            print("Dependencies installed. Retrying execution.")
+            return "try again"
+        elif execution.error:
+            print(f"Execution error: {execution.error}")
+            return execution.error
+
+    def execute_code(self, code, **kwargs):
+        print("Executing code...")
+        interpreter = set_up_interpreter()
+        with interpreter as sandbox:
+            print("Running code in sandbox...")
+            execution = sandbox.notebook.exec_cell(code, **kwargs)
+            error = self._handle_execution_error(
+                execution, required_libraries=kwargs.get("required_libraries")
+            )
+            if error == "try again":
+                print("Retrying code execution...")
+                execution = sandbox.notebook.exec_cell(code, **kwargs)
+            print("Code execution completed.")
+            return execution
+
+
+async def main():
+    print("Starting main function...")
+    coder = Coder()
+
+    code_prompt = """
+    write a pure python function that takes a list of integers and returns the sum of all the integers in the list. write a couple tests as well
+    """
+
+    print(f"Code prompt: {code_prompt}")
+
+    print("Planning code...")
+    code_plan = await coder._plan_code(context=code_prompt)
+    print("Code plan generated.")
+
+    print("Writing code...")
+    code = await coder._write_code()
+    print("Code written.")
+
+    print("Executing code...")
+    execution_result = coder.execute_code(code)
+    print("Code execution completed.")
+
+    from IPython.display import Markdown
+
+    print("Displaying code plan...")
+    Markdown(code_plan)
+
+    print("Displaying generated code...")
+    print(code)
+
+    print("Displaying execution result...")
+    print(execution_result)
+
+    print("Main function completed.")
+
+
+if __name__ == "__main__":
+    print("Running script...")
+    asyncio.run(main())
+    print("Script execution completed.")

lionagi/lions/coder/util.py

@@ -0,0 +1,91 @@
+E2B_key_scheme = "E2B_API_KEY"
+
+
+def set_up_interpreter(interpreter_provider="e2b", key_scheme=E2B_key_scheme):
+
+    if interpreter_provider == "e2b":
+        from dotenv import load_dotenv
+
+        load_dotenv()
+
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("e2b_code_interpreter")
+
+        from e2b_code_interpreter import CodeInterpreter  # type: ignore
+        from os import getenv
+
+        return CodeInterpreter(api_key=getenv(key_scheme))
+
+    else:
+        raise ValueError("Invalid interpreter provider")
+
+
+def extract_code_blocks(code):
+    print("Extracting code blocks...")
+    code_blocks = []
+    lines = code.split("\n")
+    inside_code_block = False
+    current_block = []
+
+    for line in lines:
+        if line.startswith("```"):
+            if inside_code_block:
+                code_blocks.append("\n".join(current_block))
+                current_block = []
+                inside_code_block = False
+            else:
+                inside_code_block = True
+        elif inside_code_block:
+            current_block.append(line)
+
+    if current_block:
+        code_blocks.append("\n".join(current_block))
+
+    print(f"Extracted {len(code_blocks)} code block(s).")
+    return "\n\n".join(code_blocks)
+
+
+def install_missing_dependencies(required_libraries):
+    print("Checking for missing dependencies...")
+    missing_libraries = [
+        library for library in required_libraries if not is_library_installed(library)
+    ]
+
+    if missing_libraries:
+        print(f"Missing libraries: {', '.join(missing_libraries)}")
+        for library in missing_libraries:
+            print(f"Installing {library}...")
+            install_library(library)
+        print("Installation completed.")
+    else:
+        print("All required dependencies are already installed.")
+
+
+def is_library_installed(library):
+    try:
+        import importlib
+
+        importlib.import_module(library)
+        print(f"{library} is already installed.")
+        return True
+    except ImportError:
+        print(f"{library} is not installed.")
+        return False
+
+
+def install_library(library):
+    try:
+        import subprocess
+        import sys
+
+        subprocess.check_call([sys.executable, "-m", "pip", "install", library])
+        print(f"Successfully installed {library}.")
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while installing {library}: {str(e)}")
+        print(
+            "Please check the error message and ensure you have the necessary permissions to install packages."
+        )
+        print(
+            "You may need to run the script with administrative privileges or use a virtual environment."
+        )

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