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

lionagi/integrations/storage/to_excel.py

@@ -0,0 +1,83 @@
+import pandas as pd
+from lionagi.libs import SysUtil
+
+from lionagi.integrations.storage.storage_util import output_node_list, output_edge_list
+
+
+def _output_excel(
+    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.
+
+    This helper function takes lists and dictionaries of nodes and edges, converts them into pandas DataFrames,
+    and then writes each DataFrame to a distinct sheet in an Excel workbook. This includes a separate sheet
+    for each type of node and edge, as well as edge conditions if they exist.
+
+    Args:
+        node_list (list): A list of dictionaries where each dictionary contains attributes of a single node.
+        node_dict (dict): A dictionary of lists where each key represents a node type and the value is a list of
+                          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.
+        structure_name (str): The base name for the output Excel file. The '.xlsx' extension will be added
+                        automatically if not included.
+
+    Returns:
+        None: This function does not return a value but writes data directly to an Excel workbook.
+
+    Raises:
+        ImportError: If the required 'openpyxl' library is not installed, which is necessary for pandas to write Excel files.
+    """
+    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])
+
+    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(filepath) as writer:
+        for i in tables:
+            tables[i].to_excel(writer, sheet_name=i, index=False)
+
+
+def to_excel(structure, structure_name, dir="structure_storage"):
+    """
+    Converts a structure into a series of Excel sheets within a single workbook.
+
+    This function processes the specified structure to extract detailed node and edge information,
+    including conditions if applicable. These details are then saved into separate sheets within an
+    Excel workbook for nodes, edges, and any edge conditions.
+
+    Args:
+        structure: An object representing the structure to be serialized. This should have methods
+                   to return lists of nodes and edges suitable for output.
+        structure_name (str): The base name of the output Excel file. The '.xlsx' extension will be added
+                        automatically if not included.
+
+    Returns:
+        None: This function does not return a value but outputs an Excel workbook with multiple sheets.
+    """
+    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, 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,30 +372,53 @@ 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:
-                prompt = payload["prompt"]
-                if isinstance(prompt, str):  # single prompt
+                prompt = payload["format_prompt"]
+                if isinstance(prompt, str):  # single format_prompt
                     prompt_tokens = len(encoding.encode(prompt))
                     return prompt_tokens + completion_tokens
                 elif isinstance(prompt, list):  # multiple prompts
@@ -386,7 +426,7 @@ class APIUtil:
                     return prompt_tokens + completion_tokens * len(prompt)
                 else:
                     raise TypeError(
-                        'Expecting either string or list of strings for "prompt" field in completion request'
+                        'Expecting either string or list of strings for "format_prompt" field in completion request'
                     )
         elif api_endpoint == "embeddings":
             input = payload["input"]
@@ -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
+            )

lionagi/libs/ln_convert.py

@@ -1,3 +1,19 @@
+"""
+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.
+"""
+
 import json
 import re
 from functools import singledispatch
@@ -361,6 +377,8 @@ def _(
     reset_index: bool = True,
     **kwargs,
 ) -> pd.DataFrame:
+    if not input_:
+        return pd.DataFrame()
     if not isinstance(input_[0], (pd.DataFrame, pd.Series, pd.core.generic.NDFrame)):
         if drop_kwargs is None:
             drop_kwargs = {}
@@ -400,7 +418,7 @@ def to_num(
     *,
     upper_bound: int | float | None = None,
     lower_bound: int | float | None = None,
-    num_type: Type[int | float] = int,
+    num_type: Type[int | float] = float,
     precision: int | None = None,
 ) -> int | float:
     """
@@ -423,15 +441,9 @@ def to_num(
     return _str_to_num(str_, upper_bound, lower_bound, num_type, precision)
 
 
-def to_readable_dict(input_: Any | list[Any]) -> str | list[Any]:
+def to_readable_dict(input_: Any) -> str:
     """
-    Converts a given input to a readable dictionary format, either as a string or a list of dictionaries.
-
-    Args:
-            input_ (Any | list[Any]): The input to convert to a readable dictionary format.
-
-    Returns:
-            str | list[str]: The readable dictionary format of the input.
+    Converts a given input to a readable dictionary format
     """
 
     try:

lionagi/libs/ln_func_call.py

@@ -1,3 +1,19 @@
+"""
+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 __future__ import annotations
 
 import functools
@@ -115,12 +131,12 @@ async def alcall(
     tasks = []
     if input_ is not None:
         lst = to_list(input_)
-        tasks = [AsyncUtil.handle_async_sync(func, i, **kwargs) for i in lst]
+        tasks = [call_handler(func, i, **kwargs) for i in lst]
 
     else:
-        tasks = [AsyncUtil.handle_async_sync(func, **kwargs)]
+        tasks = [call_handler(func, **kwargs)]
 
-    outs = await AsyncUtil.execute_tasks(*tasks)
+    outs = await asyncio.gather(*tasks)
     outs_ = []
     for i in outs:
         outs_.append(await i if isinstance(i, (Coroutine, asyncio.Future)) else i)
@@ -128,6 +144,11 @@ async def alcall(
     return to_list(outs_, flatten=flatten, dropna=dropna)
 
 
+async def pcall(funcs):
+    task = [call_handler(func) for func in funcs]
+    return await asyncio.gather(*task)
+
+
 async def mcall(
     input_: Any, /, func: Any, *, explode: bool = False, **kwargs
 ) -> tuple[Any]:
@@ -290,10 +311,12 @@ async def rcall(
     func: Callable,
     *args,
     retries: int = 0,
-    delay: float = 1.0,
-    backoff_factor: float = 2.0,
+    delay: float = 0.1,
+    backoff_factor: float = 2,
     default: Any = None,
     timeout: float | None = None,
+    timing: bool = False,
+    verbose: bool = True,
     **kwargs,
 ) -> Any:
     """
@@ -339,20 +362,34 @@ async def rcall(
     last_exception = None
     result = None
 
+    start = SysUtil.get_now(datetime_=False)
     for attempt in range(retries + 1) if retries == 0 else range(retries):
         try:
+            err_msg = f"Attempt {attempt + 1}/{retries}: " if retries > 0 else None
+            if timing:
+                return (
+                    await _tcall(
+                        func, *args, err_msg=err_msg, timeout=timeout, **kwargs
+                    ),
+                    SysUtil.get_now(datetime_=False) - start,
+                )
+
             return await _tcall(func, *args, timeout=timeout, **kwargs)
         except Exception as e:
             last_exception = e
             if attempt < retries:
-                await AsyncUtil.sleep(delay)
+                if verbose:
+                    print(f"Attempt {attempt + 1}/{retries} failed: {e}, retrying...")
+                await asyncio.sleep(delay)
                 delay *= backoff_factor
             else:
                 break
     if result is None and default is not None:
         return default
     elif last_exception is not None:
-        raise last_exception
+        raise RuntimeError(
+            f"Operation failed after {retries+1} attempts: {last_exception}"
+        ) from last_exception
     else:
         raise RuntimeError("rcall failed without catching an exception")
 
@@ -395,8 +432,8 @@ async def _alcall(
             [1, 4, 9]
     """
     lst = to_list(input_)
-    tasks = [AsyncUtil.handle_async_sync(func, i, **kwargs) for i in lst]
-    outs = await AsyncUtil.execute_tasks(*tasks)
+    tasks = [call_handler(func, i, **kwargs) for i in lst]
+    outs = await asyncio.gather(*tasks)
     return to_list(outs, flatten=flatten)
 
 
@@ -435,11 +472,11 @@ async def _tcall(
     """
     start_time = SysUtil.get_now(datetime_=False)
     try:
-        await AsyncUtil.sleep(delay)
+        await asyncio.sleep(delay)
         # Apply timeout to the function call
         if timeout is not None:
             coro = ""
-            if AsyncUtil.is_coroutine_func(func):
+            if is_coroutine_func(func):
                 coro = func(*args, **kwargs)
             else:
 
@@ -451,14 +488,13 @@ async def _tcall(
             result = await asyncio.wait_for(coro, timeout)
 
         else:
-            if AsyncUtil.is_coroutine_func(func):
+            if is_coroutine_func(func):
                 return await func(*args, **kwargs)
             return func(*args, **kwargs)
         duration = SysUtil.get_now(datetime_=False) - start_time
         return (result, duration) if timing else result
     except asyncio.TimeoutError as e:
-        err_msg = f"{err_msg} Error: {e}" if err_msg else f"An error occurred: {e}"
-        print(err_msg)
+        err_msg = f"{err_msg or ''}Timeout {timeout} seconds exceeded"
         if ignore_err:
             return (
                 (default, SysUtil.get_now(datetime_=False) - start_time)
@@ -466,10 +502,9 @@ async def _tcall(
                 else default
             )
         else:
-            raise e  # Re-raise the timeout exception
+            raise asyncio.TimeoutError(err_msg)  # Re-raise the timeout exception
     except Exception as e:
         err_msg = f"{err_msg} Error: {e}" if err_msg else f"An error occurred: {e}"
-        print(err_msg)
         if ignore_err:
             return (
                 (default, SysUtil.get_now(datetime_=False) - start_time)
@@ -537,7 +572,11 @@ class CallDecorator:
 
     @staticmethod
     def retry(
-        retries: int = 3, delay: float = 2.0, backoff_factor: float = 2.0
+        retries: int = 3,
+        delay: float = 2.0,
+        backoff_factor: float = 2.0,
+        default=...,
+        verbose=True,
     ) -> Callable:
         """
         Decorates an asynchronous function to automatically retry on failure,
@@ -581,6 +620,8 @@ class CallDecorator:
                     retries=retries,
                     delay=delay,
                     backoff_factor=backoff_factor,
+                    default=default,
+                    verbose=verbose,
                     **kwargs,
                 )
 
@@ -690,7 +731,7 @@ class CallDecorator:
         """
 
         def decorator(func: Callable[..., list[Any]]) -> Callable:
-            if AsyncUtil.is_coroutine_func(func):
+            if is_coroutine_func(func):
 
                 @functools.wraps(func)
                 async def async_wrapper(*args, **kwargs) -> list[Any]:
@@ -748,7 +789,7 @@ class CallDecorator:
         """
 
         def decorator(func: Callable) -> Callable:
-            if not any(AsyncUtil.is_coroutine_func(f) for f in functions):
+            if not any(is_coroutine_func(f) for f in functions):
 
                 @functools.wraps(func)
                 def sync_wrapper(*args, **kwargs):
@@ -763,7 +804,7 @@ class CallDecorator:
                     return value
 
                 return sync_wrapper
-            elif all(AsyncUtil.is_coroutine_func(f) for f in functions):
+            elif all(is_coroutine_func(f) for f in functions):
 
                 @functools.wraps(func)
                 async def async_wrapper(*args, **kwargs):
@@ -827,7 +868,7 @@ class CallDecorator:
         """
 
         def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
-            if AsyncUtil.is_coroutine_func(func):
+            if is_coroutine_func(func):
 
                 @functools.wraps(func)
                 async def async_wrapper(*args, **kwargs) -> Any:
@@ -889,7 +930,7 @@ class CallDecorator:
                 ... # will return the cached result without re-executing the function body.
         """
 
-        if AsyncUtil.is_coroutine_func(func):
+        if is_coroutine_func(func):
             # Asynchronous function handling
             @AsyncUtil.cached(ttl=ttl)
             async def cached_async(*args, **kwargs) -> Any:
@@ -993,7 +1034,7 @@ class CallDecorator:
         """
 
         def decorator(func: Callable[..., list[Any]]) -> Callable:
-            if AsyncUtil.is_coroutine_func(func):
+            if is_coroutine_func(func):
 
                 @functools.wraps(func)
                 async def async_wrapper(*args, **kwargs) -> Any:
@@ -1039,11 +1080,11 @@ class CallDecorator:
         """
 
         def decorator(func: Callable) -> Callable:
-            if not AsyncUtil.is_coroutine_func(func):
+            if not is_coroutine_func(func):
                 raise TypeError(
                     "max_concurrency decorator can only be used with async functions."
                 )
-            semaphore = AsyncUtil.semaphore(limit)
+            semaphore = asyncio.Semaphore(limit)
 
             @functools.wraps(func)
             async def wrapper(*args, **kwargs):
@@ -1089,7 +1130,7 @@ class CallDecorator:
         @functools.wraps(fn)
         def wrapper(*args, **kwargs):
             future = pool.submit(fn, *args, **kwargs)
-            return AsyncUtil.wrap_future(future)  # make it awaitable
+            return asyncio.wrap_future(future)  # make it awaitable
 
         return wrapper
 
@@ -1233,8 +1274,8 @@ async def call_handler(
     except Exception as e:
         if error_map:
             _custom_error_handler(e, error_map)
-        else:
-            logging.error(f"Error in call_handler: {e}")
+        # else:
+        #     logging.error(f"Error in call_handler: {e}")
         raise