lionagi 0.0.208__py3-none-any.whl → 0.0.210__py3-none-any.whl

lionagi/utils/core_utils.py

@@ -0,0 +1,338 @@
+import pandas as pd
+import json
+from datetime import datetime
+from typing import Union, Optional
+
+from .sys_util import strip_lower, to_df, as_dict
+from .nested_util import nget
+
+
+class CoreUtil:
+
+    @staticmethod
+    def validate_messages(messages):
+        """
+        Validates the structure and content of a DataFrame containing conversation messages.
+
+        Args:
+            messages (pd.DataFrame): The DataFrame containing conversation messages to validate.
+
+        Returns:
+            bool: True if the DataFrame is valid, raises a ValueError otherwise.
+
+        Raises:
+            ValueError: If the DataFrame has unmatched columns, contains null values, has an unsupported role, or
+                        if the content cannot be parsed as a JSON string.
+        """
+        if list(messages.columns) != ['node_id', 'role', 'sender', 'timestamp', 'content']:
+            raise ValueError('Invalid messages dataframe. Unmatched columns.')
+        if messages.isnull().values.any():
+            raise ValueError('Invalid messages dataframe. Cannot have null.')
+        if not all(role in ['system', 'user', 'assistant'] for role in messages['role'].unique()):
+            raise ValueError('Invalid messages dataframe. Cannot have role other than ["system", "user", "assistant"].')
+        for cont in messages['content']:
+            if cont.startswith('Sender'):
+                cont = cont.split(':', 1)[1]
+            try:
+                json.loads(cont)
+            except:
+                raise ValueError('Invalid messages dataframe. Content expect json string.')
+        return True
+
+    @staticmethod
+    def sign_message(messages, sender: str):
+        """
+        Prefixes each message in the DataFrame with 'Sender <sender>:' to indicate the message's origin.
+
+        Args:
+            messages (pd.DataFrame): The DataFrame containing conversation messages to sign.
+            sender (str): The name or identifier of the sender to prefix the messages with.
+
+        Returns:
+            pd.DataFrame: The DataFrame with updated messages signed by the specified sender.
+
+        Raises:
+            ValueError: If the sender is None or equivalent to the string 'none'.
+        """
+        if sender is None or strip_lower(sender) == 'none':
+            raise ValueError("sender cannot be None")
+        df = messages.copy()
+
+        for i in df.index:
+            if not df.loc[i, 'content'].startswith('Sender'):
+                df.loc[i, 'content'] = f"Sender {sender}: {df.loc[i, 'content']}"
+            else:
+                content = df.loc[i, 'content'].split(':', 1)[1]
+                df.loc[i, 'content'] = f"Sender {sender}: {content}"
+                
+        return to_df(df)
+
+    @staticmethod
+    def search_keywords(
+        messages, 
+        keywords: Union[str, list],
+        case_sensitive: bool = False, reset_index=False, dropna=False
+    ):
+        """
+        Searches for keywords in the 'content' column of a DataFrame and returns matching rows.
+
+        Args:
+            messages (pd.DataFrame): The DataFrame to search within.
+            keywords (Union[str, List[str]]): Keyword(s) to search for. If a list, combines keywords with an OR condition.
+            case_sensitive (bool, optional): Whether the search should be case-sensitive. Defaults to False.
+            reset_index (bool, optional): Whether to reset the index of the resulting DataFrame. Defaults to False.
+            dropna (bool, optional): Whether to drop rows with NA values in the 'content' column. Defaults to False.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing rows where the 'content' column matches the search criteria.
+        """
+        out = ''
+        if isinstance(keywords, list):
+            keywords = '|'.join(keywords)
+        if not case_sensitive:
+            out = messages[
+                messages["content"].str.contains(keywords, case=False)
+            ]        
+        out = messages[messages["content"].str.contains(keywords)]
+        if reset_index or dropna:
+            out = to_df(out, reset_index=reset_index)
+        return out
+
+    @staticmethod
+    def filter_messages_by(
+        messages,
+        role: Optional[str] = None, 
+        sender: Optional[str] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        content_keywords: Optional[Union[str, list]] = None,
+        case_sensitive: bool = False
+    ) -> pd.DataFrame:
+        """
+        Filters messages in a DataFrame based on specified criteria such as role, sender, time range, and keywords.
+
+        Args:
+            messages (pd.DataFrame): The DataFrame of messages to filter.
+            role (Optional[str]): The role to filter messages by (e.g., 'user', 'assistant').
+            sender (Optional[str]): The sender to filter messages by.
+            start_time (Optional[datetime]): The start time for filtering messages.
+            end_time (Optional[datetime]): The end time for filtering messages.
+            content_keywords (Optional[Union[str, list]]): Keywords to filter messages by content.
+            case_sensitive (bool): Determines if the keyword search should be case-sensitive.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing messages that match the filter criteria.
+
+        Raises:
+            ValueError: If an error occurs during the filtering process.
+        """
+
+        try:
+            outs = messages.copy()
+            
+            if content_keywords:
+                outs = CoreUtil.search_keywords(content_keywords, case_sensitive)
+            
+            outs = outs[outs['role'] == role] if role else outs
+            outs = outs[outs['sender'] == sender] if sender else outs
+            outs = outs[outs['timestamp'] > start_time] if start_time else outs
+            outs = outs[outs['timestamp'] < end_time] if end_time else outs
+        
+            return to_df(outs)
+        
+        except Exception as e:
+            raise ValueError(f"Error in filtering messages: {e}")
+
+    @staticmethod
+    def replace_keyword(
+        df,
+        keyword: str, 
+        replacement: str, 
+        col='content',
+        case_sensitive: bool = False
+    ) -> None:
+        """
+        Replaces occurrences of a keyword within a specified column of a DataFrame with a given replacement.
+
+        Args:
+            df (pd.DataFrame): The DataFrame to operate on.
+            keyword (str): The keyword to search for and replace.
+            replacement (str): The string to replace the keyword with.
+            col (str): The column to search for the keyword in.
+            case_sensitive (bool): If True, the search and replacement are case-sensitive.
+
+        Returns:
+            None: This function modifies the DataFrame in place.
+        """
+        if not case_sensitive:
+            df[col] = df[col].str.replace(
+                keyword, replacement, case=False
+            )
+        else:
+            df[col] = df[col].str.replace(
+                keyword, replacement
+            )
+
+    @staticmethod
+    def remove_message(df, node_id: str) -> bool:
+        """
+        Removes a message from the DataFrame based on its node_id.
+
+        Args:
+            df (pd.DataFrame): The DataFrame from which the message should be removed.
+            node_id (str): The node_id of the message to be removed.
+
+        Returns:
+            bool: True if the message was successfully removed, False otherwise.
+        """
+        initial_length = len(df)
+        df = df[df["node_id"] != node_id]
+        
+        return len(df) < initial_length
+
+    @staticmethod
+    def update_row(
+        df, node_id = None, col = "node_id", value = None
+    ) -> bool:
+        """
+        Updates the value of a specified column for a row identified by node_id in a DataFrame.
+
+        Args:
+            df (pd.DataFrame): The DataFrame to update.
+            node_id (Optional[str]): The node_id of the row to be updated.
+            col (str): The column to update.
+            value (Any): The new value to be assigned to the column.
+
+        Returns:
+            bool: True if the update was successful, False otherwise.
+        """
+        index = df.index[df[col] == node_id].tolist()
+        if index:
+            df.at[index[0], col] = value
+            return True
+        return False
+
+    @staticmethod
+    def remove_last_n_rows(df, steps: int) -> None:
+        """
+        Removes the last 'n' rows from a DataFrame.
+
+        Args:
+            df (pd.DataFrame): The DataFrame from which rows will be removed.
+            steps (int): The number of rows to remove.
+
+        Returns:
+            pd.DataFrame: The DataFrame after the last 'n' rows have been removed.
+
+        Raises:
+            ValueError: If 'steps' is less than 0 or greater than the number of rows in the DataFrame.
+        """
+        if steps < 0 or steps > len(df):
+            raise ValueError("Steps must be a non-negative integer less than or equal to the number of messages.")
+        df = to_df(df[:-steps])
+
+    @staticmethod
+    def get_rows(
+        df, 
+        sender: Optional[str] = None, 
+        role: Optional[str] = None, 
+        n: int = 1, 
+        sign_ = False, 
+        from_="front",
+    ) -> pd.DataFrame:
+        """
+        Retrieves rows from a DataFrame based on specified sender, role, and quantity, optionally signing them.
+
+        Args:
+            df (pd.DataFrame): The DataFrame to retrieve rows from.
+            sender (Optional[str]): The sender based on which to filter rows.
+            role (Optional[str]): The role based on which to filter rows.
+            n (int): The number of rows to retrieve.
+            sign_ (bool): Whether to sign the retrieved rows.
+            from_ (str): Direction to retrieve rows ('front' for the first rows, 'last' for the last rows).
+
+        Returns:
+            pd.DataFrame: A DataFrame containing the retrieved rows.
+        """
+
+        if from_ == "last":
+            if sender is None and role is None:
+                outs = df.iloc[-n:]
+            elif sender and role:
+                outs = df[(df['sender'] == sender) & (df['role'] == role)].iloc[-n:]
+            elif sender:
+                outs = df[df['sender'] == sender].iloc[-n:]
+            else:
+                outs = df[df['role'] == role].iloc[-n:]
+                
+        elif from_ == "front":
+            if sender is None and role is None:
+                outs = df.iloc[:n]
+            elif sender and role:
+                outs = df[(df['sender'] == sender) & (df['role'] == role)].iloc[:n]
+            elif sender:
+                outs = df[df['sender'] == sender].iloc[:n]
+            else:
+                outs = df[df['role'] == role].iloc[:n]
+
+        return CoreUtil.sign_message(outs, sender) if sign_ else outs
+
+    @staticmethod
+    def extend(df1: pd.DataFrame, df2: pd.DataFrame, **kwargs) -> pd.DataFrame:
+        """
+        Extends a DataFrame with another DataFrame, optionally removing duplicates based on specified criteria.
+
+        Args:
+            df1 (pd.DataFrame): The original DataFrame to be extended.
+            df2 (pd.DataFrame): The DataFrame containing new rows to add to df1.
+            **kwargs: Additional keyword arguments for pandas.DataFrame.drop_duplicates().
+
+        Returns:
+            pd.DataFrame: The extended DataFrame after adding rows from df2 and removing duplicates.
+
+        Raises:
+            ValueError: If an error occurs during the extension process.
+        """
+        CoreUtil.validate_messages(df2)
+        try:
+            if len(df2.dropna(how='all')) > 0 and len(df1.dropna(how='all')) > 0:
+                df = to_df([df1, df2])
+                df.drop_duplicates(
+                    inplace=True, subset=['node_id'], keep='first', **kwargs
+                )
+                return to_df(df)
+        except Exception as e:
+            raise ValueError(f"Error in extending messages: {e}")
+
+    @staticmethod
+    def to_markdown_string(df):
+        answers = []
+        for _, i in df.iterrows():
+            content = as_dict(i.content)
+            
+            if i.role == "assistant":
+                try:
+                    a = nget(content, ['action_response', 'func'])
+                    b = nget(content, ['action_response', 'arguments'])
+                    c = nget(content, ['action_response', 'output'])
+                    if a is not None:
+                        answers.append(f"Function: {a}")
+                        answers.append(f"Arguments: {b}")
+                        answers.append(f"Output: {c}")
+                    else:
+                        answers.append(nget(content, ['response']))
+                except:
+                    pass
+            elif i.role == "user":
+                try:
+                    answers.append(nget(content, ['instruction']))
+                except:
+                    pass
+            else:
+                try:
+                    answers.append(nget(content, ['system_info']))
+                except:
+                    pass
+        
+        out_ = "\n".join(answers)
+        return out_

lionagi/utils/sys_util.py

@@ -11,7 +11,7 @@ import json
 import logging
 
 import pandas as pd
-from typing import Any, List, Dict, Union
+from typing import Any, List, Dict
 
 
 def as_dict(input_: Any) -> Dict[Any, Any]:
@@ -136,8 +136,8 @@ def create_path(
         name, ext = filename, ''
     os.makedirs(dir, exist_ok=dir_exist_ok)
     timestamp_str = get_timestamp() if timestamp else ''
-    filename = f"{timestamp_str}_{name}" if time_prefix else f"{name}_{timestamp_str}"
-    return f"{dir}{filename}.{ext}" if ext else f"{dir}{filename}"
+    filename = f"{timestamp_str}{name}" if time_prefix else f"{name}{timestamp_str}"
+    return f"{dir}{filename}.{ext}" if ext != '' else f"{dir}{filename}"
 
 def get_bins(input: List[str], upper: int) -> List[List[int]]:
     """

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.0.208"
+__version__ = "0.0.210"

{lionagi-0.0.208.dist-info → lionagi-0.0.210.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.208
+Version: 0.0.210
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>
@@ -234,42 +234,30 @@ Requires-Dist: pandas >=2.1.0
 **Towards Automated General Intelligence**
 
 
-LionAGI is a cutting-edge **intelligent agent framework**. It integrates data manipulation with advanced machine learning tools, such as Large Language Models (i.e. OpenAI's GPT). 
-- Designed for data-centric, production-level projects,
-- dramatically lowers the barrier in creating intelligent, automated systems
-- that can understand and interact meaningfully with large volumes of data. 
+LionAGI is an **intelligent agent framework** tailored for **big data analysis** with advanced **machine learning** tools. Designed for data-centric, production-level projects. Lionagi allows flexible and rapid design of agentic workflow, customed for your own data. Lionagi `agents` can manage and direct other agents, can also use multiple different tools in parallel.
+  
+<img width="1002" alt="image" src="https://github.com/lion-agi/lionagi/assets/122793010/3fd75c2a-a9e9-4ab4-8ae9-f9cd71c69aec">
 
-Install LionAGI with pip:
 
-```bash
-pip install lionagi
-```
-Download the `.env_template` file, input your appropriate `API_KEY`, save the file, rename as `.env` and put in your project's root directory. 
-by default we use `OPENAI_API_KEY`.
+#### Integrate any Advanced Model into your existing workflow.
 
+<img width="1100" alt="Screenshot 2024-02-14 at 8 54 01 AM" src="https://github.com/lion-agi/lionagi/assets/122793010/cfbc403c-cece-49e7-bc3a-015e035d3607">
 
 
-### Features
-- Robust and scalable. Create a production ready LLM application **in hours**, with more than 100 models
-- Efficient and verstile data operations for reading, chunking, binning, writing, storing data with support for `langchain` and `llamaindex`
-- Built-in support for **chain/graph-of-thoughts, ReAct, Concurrent parallel function calling** 
-- Unified interface with any LLM provider, API or local
-  - Fast and **concurrent** API call with **configurable rate limit**
-  - (Work In Progress) support for models both API and local
----
-LionAGI is designed to be `asynchronous` only, please check python official documentation on how `async` work: [here](https://docs.python.org/3/library/asyncio.html)
 
 
-**Notice**: 
-* calling API with maximum throughput over large set of data with advanced models i.e. gpt-4 can get **EXPENSIVE IN JUST SECONDS**,
-* please know what you are doing, and check the usage on OpenAI regularly
-* default rate limits are set to be **tier 1** of OpenAI model `gpt-4-1104-preview`, please check the [OpenAI usage limit documentation](https://platform.openai.com/docs/guides/rate-limits?context=tier-free) you can modify token rate parameters to fit different use cases.
-* if you would like to build from source, please download the [latest release](https://github.com/lion-agi/lionagi/releases),  **main is under development and will be changed without notice**
+### Install LionAGI with pip:
+
+```bash
+pip install lionagi
+```
+Download the `.env_template` file, input your appropriate `API_KEY`, save the file, rename as `.env` and put in your project's root directory. 
+by default we use `OPENAI_API_KEY`.
 
 
 ### Quick Start
 
-The following example shows how to use LionAGI's `Session` object to interact with `gpt-4` model:
+The following example shows how to use LionAGI's `Session` object to interact with `gpt-4-turbo` model:
 
 ```python
 
@@ -285,7 +273,7 @@ import lionagi as li
 
 calculator = li.Session(system=system)
 result = await calculator.chat(
-  instruction=instruction, context=context, model="gpt-4-1106-preview"
+  instruction=instruction, context=context, model="gpt-4-turbo-preview"
 )
 
 print(f"Calculation Result: {result}")
@@ -303,7 +291,7 @@ import lionagi as li
 async def main():
     calculator = li.Session(system=system)
     result = await calculator.chat(
-      instruction=instruction, context=context, model="gpt-4-1106-preview"
+      instruction=instruction, context=context, model="gpt-4-turbo-preview"
     )
     print(f"Calculation Result: {result}")
 
@@ -311,7 +299,18 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
-Visit our notebooks for our examples. 
+Visit our notebooks for examples. 
+
+LionAGI is designed to be `asynchronous` only, please check python official documentation on how `async` work: [here](https://docs.python.org/3/library/asyncio.html)
+
+---
+
+**Notice**: 
+* calling API with maximum throughput over large set of data with advanced models i.e. gpt-4 can get **EXPENSIVE IN JUST SECONDS**,
+* please know what you are doing, and check the usage on OpenAI regularly
+* default rate limits are set to be 1,000 requests, 100,000 tokens per miniute, please check the [OpenAI usage limit documentation](https://platform.openai.com/docs/guides/rate-limits?context=tier-free) you can modify token rate parameters to fit different use cases.
+* if you would like to build from source, please download the [latest release](https://github.com/lion-agi/lionagi/releases),  **main is under development and will be changed without notice**
+
 
 ### Community
 

lionagi-0.0.210.dist-info/RECORD

@@ -0,0 +1,56 @@
+lionagi/__init__.py,sha256=txn3JAAymtQVhlS15wiE85kW2o5gjCr8ikDNze9QYlY,921
+lionagi/version.py,sha256=9Haj1irMyv2cKsU0AXTI7BLba6Cbi6TUK35nkUCvjeg,23
+lionagi/api_service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/api_service/base_endpoint.py,sha256=kbGp4vRFlBkkP21YE0_ZRh7EQDt69IojDfST_fogYOY,2461
+lionagi/api_service/base_rate_limiter.py,sha256=_9i1n6IvIR8C90zTT3u9XrVbaltz1aAbKAlqp9i6zjM,5216
+lionagi/api_service/base_service.py,sha256=Vd_FoEa6BKxid5Z8KX3tRRuJtCJvlMBNO2VlBddWVtQ,6254
+lionagi/api_service/chat_completion.py,sha256=IZsdky14jL221FPMNbKF0JWEC_TUVGB-FEB-2z8xYfA,134
+lionagi/api_service/embeddings.py,sha256=VO7I3SvCEmfBCeyWw09nt_VK9qkaauQncaf9O2-PrRc,130
+lionagi/api_service/payload_package.py,sha256=t_LYHyz6gvncQhkpdkkdLACYnO06dLQ2PMESGuf91Yw,1550
+lionagi/api_service/status_tracker.py,sha256=Sg5kUXgrq4mArWuMVw4l7OIZtySkGzVVZmdPiPS792U,1101
+lionagi/configs/__init__.py,sha256=QOd4Rs7vjIpNWvIocxWQeU-q-MPRC-AOxh-gM-eBJ2o,142
+lionagi/configs/oai_configs.py,sha256=Q2ESc5QiMprnRc_w7SeMlaTYUWl_Y4SEzZSE4iOkz4Q,2646
+lionagi/configs/openrouter_configs.py,sha256=IBQHqb8mo4Jb3kYAm_7NOHSKRPwSdGbPpDJoiwHxLYw,1269
+lionagi/core/__init__.py,sha256=qoWWDKV5d-3LMP-GBzMtE-cW0X3q5zaGwGCwijp3y7o,98
+lionagi/core/branch.py,sha256=t5C8fJD4g0evlNnitH1bq2wsIFcgOlvmvqrUVETSsIY,50425
+lionagi/core/branch_manager.py,sha256=zA_dECz9XYKLk7kK6zDWfHLs1ttRGYDfyCj4B7XKDqo,4903
+lionagi/core/flow.py,sha256=8IRcRTSrwCIuLTni33PGYb4PeuR5bjuqr1_YnDh8PFc,16764
+lionagi/core/instruction_set.py,sha256=-hMg6UDXmxG1oYqTXWhona5gDZbNcQxaK06iMuHJr6I,13694
+lionagi/core/messages.py,sha256=I91WqZPW-8kgG4xQ2w6DxJ55V5H2ivgGWO777_y0O9M,6533
+lionagi/core/session.py,sha256=Oj9BapZ4FODadRvvJNzbzsT77WnaiB9x4_K7bJoQC1k,36166
+lionagi/schema/__init__.py,sha256=3D30R38-bxegsdfIYZMOIGHCwhZ4HBYx9E3PPd5weUY,137
+lionagi/schema/base_schema.py,sha256=xB8vfclShpRdCf7aJxFcZoDJQZL4QB6n57a_OcDV48A,26579
+lionagi/services/__init__.py,sha256=zU5sxmSI9-Jtp_WsI-Zsb6hmT8y5zF9YtJ7XikAjnbs,60
+lionagi/services/base_service.py,sha256=FnmljjPaNX6tqEy1P2HS_i4k3ZMRi2B074DA0SiFAP0,17354
+lionagi/services/mistralai.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/mlx_service.py,sha256=1AF_RcV4KQmpxC67n2E0zRbssSlsTFmdnojydUXdJn4,1285
+lionagi/services/oai.py,sha256=-xWE8zc_o9eYcyV-NW8GfURMafObcufbJrHIb13V6Yg,4055
+lionagi/services/ollama.py,sha256=I2GvWtWA9WMyq_bhLe2JQlrkP_mAeqm2Bhf8ItOpEzQ,1190
+lionagi/services/services.py,sha256=TwjAizQCTFCv_I8XZbTvpcryJPGt4vQAGYkGdZqJST0,5077
+lionagi/services/transformers.py,sha256=nGfQbcECKzA1biHe4i9l01aKCMgULKFQ4LZyqjtvSXk,2934
+lionagi/structures/__init__.py,sha256=wMPekT2vbWwUkJ5aW5o-lzJC9Fzhta6RHDiFPTNUm_0,120
+lionagi/structures/graph.py,sha256=N_jIsDn9zQt7vr_KurfjRNg1VO81CMFze64lJa6ZjWU,7790
+lionagi/structures/relationship.py,sha256=XBYNCNmkpTLSXfE8f41I7yEUfaqlPOhajmosYVzgiw8,6061
+lionagi/structures/structure.py,sha256=NJOnesHBJ24snSzsSt_Nrx20eElKymJ4WdlRRaG9zDc,3497
+lionagi/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/tests/test_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/tests/test_utils/test_api_util.py,sha256=7Zyc0J1glZrIWI1HrTRSRhzw8jaUW1L2vVLFAlUhI4g,9721
+lionagi/tests/test_utils/test_call_util.py,sha256=7xmfFaWvniMQfaOyfwasA2enJQVuSlcAwc8gUyAR_7k,26277
+lionagi/tests/test_utils/test_io_util.py,sha256=cFZCT6EikVeuXB13w-UbtO3YceCHBO5RlNXxGICqg_U,11002
+lionagi/tests/test_utils/test_nested_util.py,sha256=Z1boHufhjZryw51qW2lABOnnyJ1snAFp26KKzzzD8Bs,12612
+lionagi/tests/test_utils/test_sys_util.py,sha256=TDCkzll-JLa6NuBbN_-ay5Rw9KTa_HcSHHAq62RVwGI,13545
+lionagi/tools/__init__.py,sha256=ZEck-ReP5Co05nAA2gUXTpKoDN2QZqrL7DvU9Z09gqg,69
+lionagi/tools/tool_manager.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/tools/tool_util.py,sha256=FeWWD8hIqPxgT7xC3yZmbPkbgatm7Ozlt1rlfN7LG_U,9255
+lionagi/utils/__init__.py,sha256=HymzWXPhVa2xqijEOVUT2rK14JoQBSnHzmjocqQgfD0,820
+lionagi/utils/api_util.py,sha256=lEsDmnDts7fPUZPNcMI7n1M4Bsx0nOHY6e6EY_xloOI,17610
+lionagi/utils/call_util.py,sha256=nqrqUjRtTAaOSnRoEyLy5j6B7Pauv-MgzApOv9xrVkc,33187
+lionagi/utils/core_utils.py,sha256=56vGEUU1idDZIt6b1YOj7-hH4kNRYJFfvTQqEj3IW50,13120
+lionagi/utils/io_util.py,sha256=xoVsq8sP5JGsosuC80Kad3GkGjm8Qm0OLYyTw-U5ru8,6455
+lionagi/utils/nested_util.py,sha256=67j-ySQtuMGxtjnC-Ty2mwQgqp2g1gZhXRy1MulUu1U,26656
+lionagi/utils/sys_util.py,sha256=DtcIRoGkOPYaXM9iuMSR8FNdEKX3Sjoym348SA3kZ8A,15884
+lionagi-0.0.210.dist-info/LICENSE,sha256=TBnSyG8fs_tMRtK805GzA1cIyExleKyzoN_kuVxT9IY,11358
+lionagi-0.0.210.dist-info/METADATA,sha256=k0Ar_7HbWS0ufwFMfsK4ujVKucfW4xFI3IXpEc7TZIo,17691
+lionagi-0.0.210.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+lionagi-0.0.210.dist-info/top_level.txt,sha256=szvch_d2jE1Lu9ZIKsl26Ll6BGfYfbOgt5lm-UpFSo4,8
+lionagi-0.0.210.dist-info/RECORD,,

lionagi/_services/anthropic.py

@@ -1,79 +0,0 @@
-from os import getenv
-from .base_service import BaseService, PayloadCreation
-
-class AnthropicService(BaseService):
-    """
-    A service to interact with Anthropic's API endpoints.
-
-    Attributes:
-        base_url (str): The base URL for the Anthropic API.
-        available_endpoints (list): A list of available API endpoints.
-        schema (dict): The schema configuration for the API.
-        key_scheme (str): The environment variable name for Anthropic API key.
-        token_encoding_name (str): The default token encoding scheme.
-
-    Examples:
-        >>> service = AnthropicService(api_key="your_api_key")
-        >>> asyncio.run(service.serve("Hello, world!", "chat/completions"))
-        (payload, completion)
-    """
-
-    base_url = "https://api.anthropic.com/v1/"
-    available_endpoints = ['chat/completions']
-    schema = {}        # TODO
-    key_scheme = "ANTHROPIC_API_KEY"
-    token_encoding_name = "cl100k_base"
-
-    def __init__(self, api_key = None, key_scheme = None,schema = None, token_encoding_name: str = "cl100k_base", **kwargs):
-        key_scheme = key_scheme or self.key_scheme            
-        super().__init__(
-            api_key = api_key or getenv(key_scheme),
-            schema = schema or self.schema,
-            token_encoding_name=token_encoding_name, 
-            **kwargs
-        )
-        self.active_endpoint = []
-
-    async def serve(self, input_, endpoint="chat/completions", method="post", **kwargs):
-        """
-        Serves the input using the specified endpoint and method.
-
-        Args:
-            input_: The input text to be processed.
-            endpoint: The API endpoint to use for processing.
-            method: The HTTP method to use for the request.
-            **kwargs: Additional keyword arguments to pass to the payload creation.
-
-        Returns:
-            A tuple containing the payload and the completion response from the API.
-        """
-        if endpoint not in self.active_endpoint:
-            await self. init_endpoint(endpoint)
-        if endpoint == "chat/completions":
-            return await self.serve_chat(input_, **kwargs)
-        else:
-            return ValueError(f'{endpoint} is currently not supported')
-    
-    async def serve_chat(self, messages, **kwargs):
-        """
-        Serves the chat completion request with the given messages.
-
-        Args:
-            messages: The messages to be included in the chat completion.
-            **kwargs: Additional keyword arguments for payload creation.
-
-        Returns:
-            A tuple containing the payload and the completion response from the API.
-        """
-        if "chat/completions" not in self.active_endpoint:
-            await self. init_endpoint("chat/completions")
-            self.active_endpoint.append("chat/completions")
-        payload = PayloadCreation.chat_completion(
-            messages, self.endpoints["chat/completions"].config, self.schema["chat/completions"], **kwargs)
-
-        try:
-            completion = await self.call_api(payload, "chat/completions", "post")
-            return payload, completion
-        except Exception as e:
-            self.status_tracker.num_tasks_failed += 1
-            raise e

lionagi/_services/azure.py

@@ -1 +0,0 @@
-# TODO

lionagi/_services/litellm.py

@@ -1,33 +0,0 @@
-from ..utils.sys_util import install_import, is_package_installed
-from .base_service import BaseService
-
-
-class LiteLLMService(BaseService):
-    def __init__(self, model: str = None, **kwargs):
-        super().__init__()
-
-        try: 
-            if not is_package_installed('litellm'):
-                install_import(
-                    package_name='litellm',
-                    import_name='acompletion'
-                )
-            from litellm import acompletion 
-            self.acompletion = acompletion
-        except:
-            raise ImportError(f'Unable to import required module from ollama. Please make sure that ollama is installed.')
-        
-        self.model = model
-        self.kwargs = kwargs
-
-    async def serve_chat(self, messages, **kwargs):
-        payload = {'messages': messages}
-        kwargs = {**self.kwargs, **kwargs}
-
-        try:
-            completion = await self.acompletion(model=self.model, messages=messages, **kwargs)
-            return payload, completion
-        except Exception as e:
-            self.status_tracker.num_tasks_failed += 1
-            raise e
-