lionagi 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

lionagi/lions/judge/rubric.py

@@ -1,34 +0,0 @@
-from pydantic import BaseModel
-
-
-class RubricItem(BaseModel):
-    name: str
-    prompt: str
-    description: str | None = None
-    weight: float | int = 1
-    metadata: dict = {}
-
-
-class Rubric(BaseModel):
-    name: str
-    description: str
-    items: dict[str, RubricItem]
-    metadata: dict = {}
-
-    @property
-    def analysis_types(self):
-        return list(self.items.keys())
-
-    @property
-    def normalized_weight(self):
-        return {
-            item.name: item.weight / self.ttl_weights
-            for item in self.items.values()
-        }
-
-    @property
-    def ttl_weights(self):
-        return sum([item.weight for item in self.items.values()])
-
-
-__all__ = ["Rubric", "RubricItem"]

lionagi/lions/judge/services/judge_code.py

@@ -1,49 +0,0 @@
-import asyncio
-
-from aiocache import cached
-
-from lionagi import Branch, iModel
-from lionagi.lions.judge.config import judge_model_config
-from lionagi.lions.judge.forms.code_analysis_form import CodeAnalysisForm
-from lionagi.lions.judge.rubric import Rubric
-
-
-@cached(ttl=3600)
-async def judge_code(
-    code_submission: str,
-    rubric: Rubric,
-    instruction: str = None,
-    context: str = None,
-    model_config: dict = None,
-    display_message: bool = True,
-    verbose: bool = True,
-    language: str = "Python",
-) -> CodeAnalysisForm:
-    branch = Branch(imodel=iModel(**(model_config or judge_model_config)))
-    form = CodeAnalysisForm(
-        code_submission=code_submission,
-        rubric=rubric,
-        instruction=instruction,
-        context=context,
-        language=language,
-    )
-    if verbose:
-        print("Evaluating code submission...")
-    form = await branch.chat(form=form)
-    if display_message:
-        print(form.display_message)
-    return form.to_dict()
-
-
-async def main():
-    from ..data.sample_codes import code1
-    from ..data.sample_rurbic import code_quality_rubric
-
-    return await judge_code(
-        code_submission=code1,
-        rubric=code_quality_rubric,
-    )
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

lionagi/lions/researcher/data_source/finhub_.py

@@ -1,192 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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.llms.openai import OpenAI
-            from llama_index.tools.google import GoogleSearchToolSpec
-            from llama_index.tools.tool_spec.load_and_search.base import (
-                LoadAndSearchToolSpec,
-            )
-
-            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

@@ -1,98 +0,0 @@
-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.agent.openai import OpenAIAgent
-        from llama_index.llms.openai import OpenAI
-        from llama_index.tools.wikipedia import WikipediaToolSpec
-
-        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

@@ -1,21 +0,0 @@
-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