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

lionagi/integrations/storage/structure_excel.py

@@ -0,0 +1,285 @@
+import pandas as pd
+import json
+from pathlib import Path
+
+from lionagi.integrations.storage.storage_util import ParseNode
+from lionagi.core.executor.graph_executor import GraphExecutor
+from lionagi.core.agent.base_agent import BaseAgent
+from lionagi.core.executor.base_executor import BaseExecutor
+from lionagi.core.engine.instruction_map_engine import InstructionMapEngine
+
+
+def excel_reload(structure_name=None, structure_id=None, dir="structure_storage"):
+    """
+    Loads a structure from an Excel file into a StructureExecutor instance.
+
+    This function uses the StructureExcel class to handle the reloading process. It identifies the
+    Excel file based on the provided structure name or ID and reloads the structure from it.
+
+    Args:
+        structure_name (str, optional): The name of the structure to reload.
+        structure_id (str, optional): The unique identifier of the structure to reload.
+        dir (str): The directory path where the Excel files are stored.
+
+    Returns:
+        StructureExecutor: An instance of StructureExecutor containing the reloaded structure.
+
+    Raises:
+        ValueError: If neither structure_name nor structure_id is provided, or if multiple or no files
+                    are found matching the criteria.
+    """
+    excel_structure = StructureExcel(structure_name, structure_id, dir)
+    excel_structure.reload()
+    return excel_structure.structure
+
+
+class StructureExcel:
+    """
+    Manages the reloading of structures from Excel files.
+
+    This class handles the identification and parsing of structure data from an Excel workbook. It supports
+    loading from specifically named Excel files based on the structure name or ID.
+
+    Attributes:
+        structure (StructureExecutor): The loaded structure, ready for execution.
+        default_agent_executable (BaseExecutor): The default executor for agents within the structure.
+
+    Methods:
+        get_heads(): Retrieves the head nodes of the loaded structure.
+        parse_node(info_dict): Parses a node from the structure based on the provided dictionary.
+        get_next(node_id): Gets the next nodes connected by outgoing edges from a given node.
+        relate(parent_node, node): Relates two nodes within the structure based on the edge definitions.
+        parse(node_list, parent_node=None): Recursively parses nodes and their relationships from the structure.
+        reload(): Reloads the structure from the Excel file based on the initially provided parameters.
+    """
+
+    structure: GraphExecutor = GraphExecutor()
+    default_agent_executable: BaseExecutor = InstructionMapEngine()
+
+    def __init__(
+        self, structure_name=None, structure_id=None, file_path="structure_storage"
+    ):
+        """
+        Initializes the StructureExcel class with specified parameters.
+
+        This method sets up the paths and reads the Excel file, preparing the internal dataframes used for
+        structure parsing.
+
+        Args:
+            structure_name (str, optional): The name of the structure to reload.
+            structure_id (str, optional): The unique identifier of the structure to reload.
+            file_path (str): The base path where the Excel files are stored.
+
+        Raises:
+            ValueError: If both structure_name and structure_id are provided but do not correspond to a valid file,
+                        or if multiple or no files are found when one of the identifiers is provided.
+        """
+        self.file_path = file_path
+        if not structure_name and not structure_id:
+            raise ValueError("Please provide the structure name or id")
+        if structure_name and structure_id:
+            self.filename = f"{file_path}/{structure_name}_{structure_id}.xlsx"
+            self.file = pd.read_excel(self.filename, sheet_name=None)
+        elif structure_name and not structure_id:
+            dir_path = Path(file_path)
+            files = list(dir_path.glob(f"{structure_name}*.xlsx"))
+            filename = []
+            for file in files:
+                try:
+                    name = file.name
+                    name = name.rsplit("_", 1)[0]
+                    if name == structure_name:
+                        filename.append(file.name)
+                except:
+                    continue
+            if len(filename) > 1:
+                raise ValueError(
+                    f"Multiple files starting with the same structure name {structure_name} has found, please specify the structure id"
+                )
+            self.filename = f"{file_path}/{filename[0]}"
+            self.file = pd.read_excel(self.filename, sheet_name=None)
+        elif structure_id and not structure_name:
+            dir_path = Path(file_path)
+            files = list(dir_path.glob(f"*{structure_id}.xlsx"))
+            filename = [file.name for file in files]
+            if len(filename) > 1:
+                raise ValueError(
+                    f"Multiple files with the same structure id {structure_id} has found, please double check the stored structure"
+                )
+            self.filename = f"{file_path}/{filename[0]}"
+            self.file = pd.read_excel(self.filename, sheet_name=None)
+        self.nodes = self.file["Nodes"]
+        self.edges = self.file["Edges"]
+
+    def get_heads(self):
+        """
+        Retrieves the list of head node identifiers from the loaded structure data.
+
+        This method parses the 'StructureExecutor' sheet in the loaded Excel file to extract the list of head nodes.
+
+        Returns:
+            list: A list of identifiers for the head nodes in the structure.
+        """
+        structure_df = self.file["GraphExecutor"]
+        head_list = json.loads(structure_df["head_nodes"].iloc[0])
+        return head_list
+
+    def _reload_info_dict(self, node_id):
+        """
+        Retrieves detailed information about a specific node from the Excel file based on its identifier.
+
+        This method looks up a node's information within the loaded Excel sheets and returns a dictionary
+        containing all the relevant details.
+
+        Args:
+            node_id (str): The identifier of the node to look up.
+
+        Returns:
+            dict: A dictionary containing the properties and values for the specified node.
+        """
+        node_type = self.nodes[self.nodes["ln_id"] == node_id]["type"].iloc[0]
+        node_file = self.file[node_type]
+        row = node_file[node_file["ln_id"] == node_id].iloc[0]
+        info_dict = row.to_dict()
+        return info_dict
+
+    def parse_agent(self, info_dict):
+        """
+        Parses an agent node from the structure using the agent's specific details provided in a dictionary.
+
+        This method creates an agent instance based on the information from the dictionary, which includes
+        dynamically loading the output parser code.
+
+        Args:
+            info_dict (dict): A dictionary containing details about the agent node, including its class, structure ID,
+                              and output parser code.
+
+        Returns:
+            BaseAgent: An initialized agent object.
+        """
+        output_parser = ParseNode.convert_to_def(info_dict["output_parser"])
+
+        structure_excel = StructureExcel(
+            structure_id=info_dict["structure_id"], file_path=self.file_path
+        )
+        structure_excel.reload()
+        structure = structure_excel.structure
+        agent = BaseAgent(
+            structure=structure,
+            executable=self.default_agent_executable,
+            output_parser=output_parser,
+            ln_id=info_dict["ln_id"],
+            timestamp=info_dict["timestamp"],
+        )
+        return agent
+
+    def parse_node(self, info_dict):
+        """
+        Parses a node from its dictionary representation into a specific node type like System, Instruction, etc.
+
+        This method determines the type of node from the info dictionary and uses the appropriate parsing method
+        to create an instance of that node type.
+
+        Args:
+            info_dict (dict): A dictionary containing node data, including the node type and associated properties.
+
+        Returns:
+            Node: An instance of the node corresponding to the type specified in the info_dict.
+        """
+        if info_dict["type"] == "System":
+            return ParseNode.parse_system(info_dict)
+        elif info_dict["type"] == "Instruction":
+            return ParseNode.parse_instruction(info_dict)
+        elif info_dict["type"] == "Tool":
+            return ParseNode.parse_tool(info_dict)
+        elif info_dict["type"] == "DirectiveSelection":
+            return ParseNode.parse_directiveSelection(info_dict)
+        elif info_dict["type"] == "BaseAgent":
+            return self.parse_agent(info_dict)
+
+    def get_next(self, node_id):
+        """
+        Retrieves the list of identifiers for nodes that are directly connected via outgoing edges from the specified node.
+
+        This method searches the 'Edges' DataFrame for all entries where the specified node is a head and returns
+        a list of the tail node identifiers.
+
+        Args:
+            node_id (str): The identifier of the node whose successors are to be found.
+
+        Returns:
+            list[str]: A list of identifiers for the successor nodes.
+        """
+        return self.edges[self.edges["head"] == node_id]["tail"].to_list()
+
+    def relate(self, parent_node, node):
+        """
+        Establishes a relationship between two nodes in the structure based on the Excel data for edges.
+
+        This method looks up the edge details connecting the two nodes and applies any conditions associated
+        with the edge to the structure being rebuilt.
+
+        Args:
+            parent_node (Node): The parent node in the relationship.
+            node (Node): The child node in the relationship.
+
+        Raises:
+            ValueError: If there are issues with the edge data such as multiple undefined edges.
+        """
+        if not parent_node:
+            return
+        row = self.edges[
+            (self.edges["head"] == parent_node.ln_id)
+            & (self.edges["tail"] == node.ln_id)
+        ]
+        if len(row) > 1:
+            raise ValueError(
+                f"currently does not support handle multiple edges between two nodes, Error node: from {parent_node.ln_id} to {node.ln_id}"
+            )
+        if row["condition"].isna().any():
+            self.structure.add_edge(parent_node, node)
+        else:
+            cond = json.loads(row["condition"].iloc[0])
+            cond_cls = cond["class"]
+            cond_row = self.file["EdgesCondClass"][
+                self.file["EdgesCondClass"]["class_name"] == cond_cls
+            ]
+            cond_code = cond_row["class"].iloc[0]
+            condition = ParseNode.parse_condition(cond, cond_code)
+            self.structure.add_edge(parent_node, node, condition=condition)
+
+    def parse(self, node_list, parent_node=None):
+        """
+        Recursively parses a list of nodes and establishes their interconnections based on the Excel data.
+
+        This method processes each node ID in the list, parsing individual nodes and relating them according
+        to their connections defined in the Excel file.
+
+        Args:
+            node_list (list[str]): A list of node identifiers to be parsed.
+            parent_node (Node, optional): The parent node to which the nodes in the list are connected.
+
+        Raises:
+            ValueError: If an error occurs during parsing or relating nodes.
+        """
+        for node_id in node_list:
+            info_dict = self._reload_info_dict(node_id)
+            node = self.parse_node(info_dict)
+
+            if node.ln_id not in self.structure.internal_nodes:
+                self.structure.add_node(node)
+            self.relate(parent_node, node)
+
+            next_node_list = self.get_next(node_id)
+            self.parse(next_node_list, node)
+
+    def reload(self):
+        """
+        Reloads the entire structure from the Excel file.
+
+        This method initializes a new StructureExecutor and uses the Excel data to rebuild the entire structure,
+        starting from the head nodes and recursively parsing and connecting all nodes defined within.
+        """
+        self.structure = GraphExecutor()
+        heads = self.get_heads()
+        self.parse(heads)

lionagi/integrations/storage/to_excel.py

@@ -5,7 +5,12 @@ from lionagi.integrations.storage.storage_util import output_node_list, output_e
 
 
 def _output_excel(
-    node_list, node_dict, edge_list, edge_cls_list, filename="structure_storage"
+    node_list,
+    node_dict,
+    edge_list,
+    edge_cls_list,
+    structure_name,
+    dir="structure_storage",
 ):
     """
     Writes provided node and edge data into multiple sheets of a single Excel workbook.
@@ -20,7 +25,7 @@ def _output_excel(
                           node attributes for nodes of that type.
         edge_list (list): A list of dictionaries where each dictionary contains attributes of a single edge.
         edge_cls_list (list): A list of dictionaries where each dictionary contains attributes of edge conditions.
-        filename (str): The base name for the output Excel file. The '.xlsx' extension will be added
+        structure_name (str): The base name for the output Excel file. The '.xlsx' extension will be added
                         automatically if not included.
 
     Returns:
@@ -31,20 +36,31 @@ def _output_excel(
     """
     SysUtil.check_import("openpyxl")
 
+    structure_id = ""
+
     tables = {"Nodes": pd.DataFrame(node_list), "Edges": pd.DataFrame(edge_list)}
     if edge_cls_list:
         tables["EdgesCondClass"] = pd.DataFrame(edge_cls_list)
     for i in node_dict:
+        if i == "GraphExecutor":
+            structure_node = node_dict[i][0]
+            structure_node["name"] = structure_name
+            structure_id = structure_node["ln_id"]
         tables[i] = pd.DataFrame(node_dict[i])
 
-    filename = filename + ".xlsx"
+    import os
+
+    filepath = os.path.join(dir, f"{structure_name}_{structure_id}.xlsx")
+
+    if not os.path.exists(dir):
+        os.makedirs(dir)
 
-    with pd.ExcelWriter(filename) as writer:
+    with pd.ExcelWriter(filepath) as writer:
         for i in tables:
             tables[i].to_excel(writer, sheet_name=i, index=False)
 
 
-def to_excel(structure, filename="structure_storage"):
+def to_excel(structure, structure_name, dir="structure_storage"):
     """
     Converts a structure into a series of Excel sheets within a single workbook.
 
@@ -55,7 +71,7 @@ def to_excel(structure, filename="structure_storage"):
     Args:
         structure: An object representing the structure to be serialized. This should have methods
                    to return lists of nodes and edges suitable for output.
-        filename (str): The base name of the output Excel file. The '.xlsx' extension will be added
+        structure_name (str): The base name of the output Excel file. The '.xlsx' extension will be added
                         automatically if not included.
 
     Returns:
@@ -64,4 +80,4 @@ def to_excel(structure, filename="structure_storage"):
     node_list, node_dict = output_node_list(structure)
     edge_list, edge_cls_list = output_edge_list(structure)
 
-    _output_excel(node_list, node_dict, edge_list, edge_cls_list, filename)
+    _output_excel(node_list, node_dict, edge_list, edge_cls_list, structure_name, dir)

lionagi/libs/__init__.py

@@ -2,10 +2,19 @@ from lionagi.libs.sys_util import SysUtil
 from lionagi.libs.ln_async import AsyncUtil
 
 import lionagi.libs.ln_convert as convert
+from lionagi.libs.ln_convert import (
+    to_str,
+    to_list,
+    to_dict,
+    to_df,
+    to_readable_dict,
+    to_num,
+)
 import lionagi.libs.ln_dataframe as dataframe
 import lionagi.libs.ln_func_call as func_call
-from lionagi.libs.ln_func_call import CallDecorator
+from lionagi.libs.ln_func_call import lcall, CallDecorator
 import lionagi.libs.ln_nested as nested
+from lionagi.libs.ln_nested import nget, nset, ninsert
 from lionagi.libs.ln_parse import ParseUtil, StringMatch
 
 from lionagi.libs.ln_api import (
@@ -16,6 +25,10 @@ from lionagi.libs.ln_api import (
     PayloadPackage,
 )
 
+from lionagi.libs.ln_image import ImageUtil
+from lionagi.libs.ln_validate import validation_funcs
+
+
 __all__ = [
     "SysUtil",
     "convert",
@@ -31,4 +44,16 @@ __all__ = [
     "StatusTracker",
     "SimpleRateLimiter",
     "CallDecorator",
+    "validation_funcs",
+    "ImageUtil",
+    "to_str",
+    "to_list",
+    "to_dict",
+    "to_df",
+    "lcall",
+    "to_readable_dict",
+    "to_num",
+    "nget",
+    "nset",
+    "ninsert",
 ]

lionagi/libs/ln_api.py

@@ -1,8 +1,25 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
 from collections.abc import Sequence, Mapping
 
 from abc import ABC
 from dataclasses import dataclass
 
+import contextlib
 import logging
 import re
 import asyncio
@@ -11,9 +28,9 @@ import aiohttp
 from typing import Any, NoReturn, Type, Callable
 
 from lionagi.libs.ln_async import AsyncUtil
-import lionagi.libs.ln_convert as convert
-import lionagi.libs.ln_nested as nested
+from lionagi.libs.ln_convert import to_dict, strip_lower, to_str
 import lionagi.libs.ln_func_call as func_call
+from lionagi.libs.ln_nested import nget
 
 
 class APIUtil:
@@ -175,7 +192,7 @@ class APIUtil:
         """
         import hashlib
 
-        param_str = convert.to_str(params, sort_keys=True) if params else ""
+        param_str = to_str(params, sort_keys=True) if params else ""
         return hashlib.md5((url + param_str).encode("utf-8")).hexdigest()
 
     @staticmethod
@@ -355,25 +372,48 @@ class APIUtil:
                 # Expected token calculation for the given payload and endpoint.
         """
         import tiktoken
+        from .ln_image import ImageUtil
 
+        token_encoding_name = token_encoding_name or "cl100k_base"
         encoding = tiktoken.get_encoding(token_encoding_name)
         if api_endpoint.endswith("completions"):
             max_tokens = payload.get("max_tokens", 15)
             n = payload.get("n", 1)
             completion_tokens = n * max_tokens
-
-            # chat completions
             if api_endpoint.startswith("chat/"):
                 num_tokens = 0
+
                 for message in payload["messages"]:
                     num_tokens += 4  # every message follows <im_start>{role/name}\n{content}<im_end>\n
-                    for key, value in message.items():
-                        num_tokens += len(encoding.encode(value))
-                        if key == "name":  # if there's a name, the role is omitted
-                            num_tokens -= (
-                                1
-                                # role is always required and always 1 token
-                            )
+
+                    _content = message.get("content")
+                    if isinstance(_content, str):
+                        num_tokens += len(encoding.encode(_content))
+
+                    elif isinstance(_content, list):
+                        for item in _content:
+                            if isinstance(item, dict):
+                                if "text" in item:
+                                    num_tokens += len(
+                                        encoding.encode(to_str(item["text"]))
+                                    )
+                                elif "image_url" in item:
+                                    a: str = item["image_url"]["url"]
+                                    if "data:image/jpeg;base64," in a:
+                                        a = a.split("data:image/jpeg;base64,")[
+                                            1
+                                        ].strip()
+                                    num_tokens += ImageUtil.calculate_image_token_usage_from_base64(
+                                        a, item.get("detail", "low")
+                                    )
+                                    num_tokens += (
+                                        20  # for every image we add 20 tokens buffer
+                                    )
+                            elif isinstance(item, str):
+                                num_tokens += len(encoding.encode(item))
+                            else:
+                                num_tokens += len(encoding.encode(str(item)))
+
                 num_tokens += 2  # every reply is primed with <im_start>assistant
                 return num_tokens + completion_tokens
             else:
@@ -412,7 +452,7 @@ class APIUtil:
             payload[key] = config[key]
 
         for key in optional_:
-            if bool(config[key]) and convert.strip_lower(config[key]) != "none":
+            if bool(config[key]) and strip_lower(config[key]) != "none":
                 payload[key] = config[key]
 
         return payload
@@ -527,6 +567,7 @@ class BaseRateLimiter(ABC):
         max_attempts: int = 3,
         method: str = "post",
         payload: Mapping[str, any] = None,
+        required_tokens: int = None,
         **kwargs,
     ) -> Mapping[str, any] | None:
         """
@@ -552,9 +593,11 @@ class BaseRateLimiter(ABC):
             ):  # Minimum token count
                 await AsyncUtil.sleep(1)  # Wait for capacity
                 continue
-            required_tokens = APIUtil.calculate_num_token(
-                payload, endpoint, self.token_encoding_name, **kwargs
-            )
+
+            if not required_tokens:
+                required_tokens = APIUtil.calculate_num_token(
+                    payload, endpoint, self.token_encoding_name, **kwargs
+                )
 
             if await self.request_permission(required_tokens):
                 request_headers = {"Authorization": f"Bearer {api_key}"}
@@ -748,7 +791,7 @@ class BaseService:
                     )
 
                 if ep not in self.endpoints:
-                    endpoint_config = nested.nget(self.schema, [ep, "config"])
+                    endpoint_config = nget(self.schema, [ep, "config"])
                     self.schema.get(ep, {})
                     if isinstance(ep, EndPoint):
                         self.endpoints[ep.endpoint] = ep
@@ -792,7 +835,7 @@ class BaseService:
 
         else:
             for ep in self.available_endpoints:
-                endpoint_config = nested.nget(self.schema, [ep, "config"])
+                endpoint_config = nget(self.schema, [ep, "config"])
                 self.schema.get(ep, {})
                 if ep not in self.endpoints:
                     self.endpoints[ep] = EndPoint(
@@ -806,7 +849,7 @@ class BaseService:
                 if not self.endpoints[ep]._has_initialized:
                     await self.endpoints[ep].init_rate_limiter()
 
-    async def call_api(self, payload, endpoint, method, **kwargs):
+    async def call_api(self, payload, endpoint, method, required_tokens=None, **kwargs):
         """
         Calls the specified API endpoint with the given payload and method.
 
@@ -831,12 +874,24 @@ class BaseService:
                 api_key=self.api_key,
                 method=method,
                 payload=payload,
+                required_tokens=required_tokens,
                 **kwargs,
             )
 
 
 class PayloadPackage:
 
+    @classmethod
+    def embeddings(cls, embed_str, llmconfig, schema, **kwargs):
+        return APIUtil.create_payload(
+            input_=embed_str,
+            config=llmconfig,
+            required_=schema["required"],
+            optional_=schema["optional"],
+            input_key="input",
+            **kwargs,
+        )
+
     @classmethod
     def chat_completion(cls, messages, llmconfig, schema, **kwargs):
         """
@@ -874,7 +929,7 @@ class PayloadPackage:
         Returns:
                 The constructed payload.
         """
-        return APIUtil._create_payload(
+        return APIUtil.create_payload(
             input_=training_file,
             config=llmconfig,
             required_=schema["required"],

lionagi/libs/ln_context.py

@@ -0,0 +1,37 @@
+import os
+import sys
+from contextlib import asynccontextmanager
+
+# import builtins
+# import traceback
+
+# original_print = builtins.print
+
+
+# def new_print(*args, **kwargs):
+#     # Get the last frame in the stack
+#     frame = traceback.extract_stack(limit=2)[0]
+#     # Insert the filename and line number
+#     original_print(f"Called from {frame.filename}:{frame.lineno}")
+#     # Call the original print
+#     original_print(*args, **kwargs)
+
+
+# Replace the built-in print with the new print
+# builtins.print = new_print
+
+
+@asynccontextmanager
+async def async_suppress_print():
+    """
+    An asynchronous context manager that redirects stdout to /dev/null to suppress print output.
+    """
+    original_stdout = sys.stdout  # Save the reference to the original standard output
+    with open(os.devnull, "w") as devnull:
+        sys.stdout = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = (
+                original_stdout  # Restore standard output to the original value
+            )