lionagi 0.2.11__py3-none-any.whl → 0.3.1__py3-none-any.whl

lionagi/libs/ln_nested.py

@@ -1,12 +1,15 @@
 from collections import defaultdict
+from collections.abc import Callable, Generator
 from itertools import chain
-from typing import Any, Callable, Generator
+from typing import Any
 
 import lionagi.libs.ln_convert as convert
 from lionagi.libs.sys_util import SysUtil
 
 
-def nset(nested_structure: dict | list, indices: list[int | str], value: Any) -> None:
+def nset(
+    nested_structure: dict | list, indices: list[int | str], value: Any
+) -> None:
     """
     sets a value within a nested structure at the specified path defined by indices.
 
@@ -34,7 +37,9 @@ def nset(nested_structure: dict | list, indices: list[int | str], value: Any) ->
             >>> assert data == [0, [1, 99], 3]
     """
     if not indices:
-        raise ValueError("Indices list is empty, cannot determine target container")
+        raise ValueError(
+            "Indices list is empty, cannot determine target container"
+        )
 
     _indices = convert.to_list(indices)
     target_container = _get_target_container(nested_structure, _indices[:-1])
@@ -86,7 +91,9 @@ def nget(
     """
 
     try:
-        target_container = _get_target_container(nested_structure, indices[:-1])
+        target_container = _get_target_container(
+            nested_structure, indices[:-1]
+        )
         last_index = indices[-1]
 
         if (
@@ -96,17 +103,24 @@ def nget(
         ):
 
             return target_container[last_index]
-        elif isinstance(target_container, dict) and last_index in target_container:
+        elif (
+            isinstance(target_container, dict)
+            and last_index in target_container
+        ):
             return target_container[last_index]
         elif default is not ...:
             return default
         else:
-            raise LookupError("Target not found and no default value provided.")
+            raise LookupError(
+                "Target not found and no default value provided."
+            )
     except (IndexError, KeyError, TypeError):
         if default is not ...:
             return default
         else:
-            raise LookupError("Target not found and no default value provided.")
+            raise LookupError(
+                "Target not found and no default value provided."
+            )
 
 
 # nested merge
@@ -212,7 +226,9 @@ def flatten(
     """
     if inplace:
         if not isinstance(nested_structure, dict):
-            raise ValueError("Object must be a dictionary when 'inplace' is True.")
+            raise ValueError(
+                "Object must be a dictionary when 'inplace' is True."
+            )
         _dynamic_flatten_in_place(
             nested_structure,
             parent_key=parent_key,
@@ -278,7 +294,13 @@ def unflatten(
         if not unflattened and all(isinstance(part, int) for part in parts):
             unflattened = []
 
-        ninsert(unflattened, indices=parts, value=value, sep=sep, max_depth=max_depth)
+        ninsert(
+            unflattened,
+            indices=parts,
+            value=value,
+            sep=sep,
+            max_depth=max_depth,
+        )
 
     if isinstance(unflattened, dict) and all(
         isinstance(k, int) for k in unflattened.keys()
@@ -321,7 +343,9 @@ def nfilter(
     elif isinstance(nested_structure, list):
         return _filter_list(nested_structure, condition)
     else:
-        raise TypeError("The nested_structure must be either a dict or a list.")
+        raise TypeError(
+            "The nested_structure must be either a dict or a list."
+        )
 
 
 def ninsert(
@@ -373,7 +397,9 @@ def ninsert(
                 nested_structure[part], (dict, list)
             ):
                 next_part = indices[i + 1]
-                nested_structure[part] = [] if isinstance(next_part, int) else {}
+                nested_structure[part] = (
+                    [] if isinstance(next_part, int) else {}
+                )
         elif part not in nested_structure:
             next_part = indices[i + 1]
             nested_structure[part] = [] if isinstance(next_part, int) else {}
@@ -434,11 +460,20 @@ def get_flattened_keys(
     if not inplace:
         return convert.to_list(
             flatten(
-                nested_structure, sep=sep, max_depth=max_depth, dict_only=dict_only
+                nested_structure,
+                sep=sep,
+                max_depth=max_depth,
+                dict_only=dict_only,
             ).keys()
         )
     obj_copy = SysUtil.create_copy(nested_structure, num=1)
-    flatten(obj_copy, sep=sep, max_depth=max_depth, inplace=True, dict_only=dict_only)
+    flatten(
+        obj_copy,
+        sep=sep,
+        max_depth=max_depth,
+        inplace=True,
+        dict_only=dict_only,
+    )
     return convert.to_list(obj_copy.keys())
 
 
@@ -484,7 +519,9 @@ def _dynamic_flatten_in_place(
         for k, v in items:
             new_key = f"{parent_key}{sep}{k}" if parent_key else k
 
-            if isinstance(v, dict) and (max_depth is None or current_depth < max_depth):
+            if isinstance(v, dict) and (
+                max_depth is None or current_depth < max_depth
+            ):
                 _dynamic_flatten_in_place(
                     v,
                     parent_key=new_key,
@@ -744,7 +781,9 @@ def _filter_dict(
     return {k: v for k, v in dictionary.items() if condition((k, v))}
 
 
-def _filter_list(lst: list[Any], condition: Callable[[Any], bool]) -> list[Any]:
+def _filter_list(
+    lst: list[Any], condition: Callable[[Any], bool]
+) -> list[Any]:
     """
     Filters elements in a list based on a specified condition.
 
@@ -777,5 +816,7 @@ def _get_target_container(
             else:
                 raise KeyError("Key not found in dictionary")
         else:
-            raise TypeError("Current element is neither a list nor a dictionary")
+            raise TypeError(
+                "Current element is neither a list nor a dictionary"
+            )
     return current_element

lionagi/libs/ln_parse.py

@@ -63,7 +63,9 @@ class ParseUtil:
                 open_brackets.append(brackets[char])
             elif char in brackets.values():
                 if not open_brackets or open_brackets[-1] != char:
-                    raise ValueError("Mismatched or extra closing bracket found.")
+                    raise ValueError(
+                        "Mismatched or extra closing bracket found."
+                    )
                 open_brackets.pop()
 
         return str_to_parse + "".join(reversed(open_brackets))
@@ -94,7 +96,9 @@ class ParseUtil:
         def replacement(match):
             char = match.group(0)
             _char_map = char_map or md_json_char_map
-            return _char_map.get(char, char)  # Default to the char itself if not in map
+            return _char_map.get(
+                char, char
+            )  # Default to the char itself if not in map
 
         # Match any of the special characters to be escaped.
         return re.sub(r'[\n\r\t"]', replacement, value)
@@ -149,7 +153,9 @@ class ParseUtil:
             )
         if not match:
             str_to_parse = str_to_parse.strip()
-            if str_to_parse.startswith("```json\n") and str_to_parse.endswith("\n```"):
+            if str_to_parse.startswith("```json\n") and str_to_parse.endswith(
+                "\n```"
+            ):
                 str_to_parse = str_to_parse[8:-4].strip()
 
         parser = parser or ParseUtil.fuzzy_parse_json
@@ -209,11 +215,15 @@ class ParseUtil:
                 {'key': 'value'}
         """
         json_obj = ParseUtil.extract_json_block(
-            str_to_parse, language="json", parser=parser or ParseUtil.fuzzy_parse_json
+            str_to_parse,
+            language="json",
+            parser=parser or ParseUtil.fuzzy_parse_json,
         )
 
         if expected_keys:
-            if missing_keys := [key for key in expected_keys if key not in json_obj]:
+            if missing_keys := [
+                key for key in expected_keys if key not in json_obj
+            ]:
                 raise ValueError(
                     f"Missing expected keys in JSON object: {', '.join(missing_keys)}"
                 )
@@ -276,7 +286,9 @@ class ParseUtil:
             elif lines[i].startswith(" "):
                 param_desc = lines[i].split(":", 1)
                 if len(param_desc) == 1:
-                    params_description[current_param] += f" {param_desc[0].strip()}"
+                    params_description[
+                        current_param
+                    ] += f" {param_desc[0].strip()}"
                     continue
                 param, desc = param_desc
                 param = param.split("(")[0].strip()
@@ -443,9 +455,13 @@ class ParseUtil:
         func_name = func.__name__
 
         if not func_description:
-            func_description, _ = ParseUtil._extract_docstring_details(func, style)
+            func_description, _ = ParseUtil._extract_docstring_details(
+                func, style
+            )
         if not params_description:
-            _, params_description = ParseUtil._extract_docstring_details(func, style)
+            _, params_description = ParseUtil._extract_docstring_details(
+                func, style
+            )
 
         # Extracting parameters with typing hints
         sig = inspect.signature(func)
@@ -459,7 +475,9 @@ class ParseUtil:
             # Default type to string and update if type hint is available
             param_type = "string"
             if param.annotation is not inspect.Parameter.empty:
-                param_type = ParseUtil._python_to_json_type(param.annotation.__name__)
+                param_type = ParseUtil._python_to_json_type(
+                    param.annotation.__name__
+                )
 
             # Extract parameter description from docstring, if available
             param_description = params_description.get(
@@ -546,7 +564,9 @@ class StringMatch:
 
         transpositions //= 2
         return (
-            matches / s_len + matches / t_len + (matches - transpositions) / matches
+            matches / s_len
+            + matches / t_len
+            + (matches - transpositions) / matches
         ) / 3.0
 
     @staticmethod
@@ -639,7 +659,9 @@ class StringMatch:
                 used_keys.add(k)
             else:
                 # Calculate Jaro-Winkler similarity scores for each potential match
-                scores = np.array([score_func(k, field) for field in fields_set])
+                scores = np.array(
+                    [score_func(k, field) for field in fields_set]
+                )
                 # Find the index of the highest score
                 max_score_index = np.argmax(scores)
                 # Select the best match based on the highest score
@@ -697,19 +719,25 @@ class StringMatch:
 
                     except Exception:
                         # if still failed we try to extract the json block using re and parse it again
-                        match = re.search(r"```json\n({.*?})\n```", out_, re.DOTALL)
+                        match = re.search(
+                            r"```json\n({.*?})\n```", out_, re.DOTALL
+                        )
                         if match:
                             out_ = match.group(1)
                             try:
                                 out_ = ParseUtil.fuzzy_parse_json(out_)
-                                return StringMatch.correct_dict_keys(keys, out_)
+                                return StringMatch.correct_dict_keys(
+                                    keys, out_
+                                )
 
                             except:
                                 try:
                                     out_ = ParseUtil.fuzzy_parse_json(
                                         out_.replace("'", '"')
                                     )
-                                    return StringMatch.correct_dict_keys(keys, out_)
+                                    return StringMatch.correct_dict_keys(
+                                        keys, out_
+                                    )
                                 except:
                                     pass
 
@@ -717,4 +745,6 @@ class StringMatch:
             try:
                 return StringMatch.correct_dict_keys(keys, out_)
             except Exception as e:
-                raise ValueError(f"Failed to force_validate_dict for input: {x}") from e
+                raise ValueError(
+                    f"Failed to force_validate_dict for input: {x}"
+                ) from e

lionagi/libs/ln_queue.py

@@ -3,7 +3,8 @@ A class that manages asynchronous task processing with controlled concurrency.
 """
 
 import asyncio
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from lionagi.libs import func_call
 
@@ -69,7 +70,9 @@ class AsyncQueue:
         """
         return self._stop_event.is_set()
 
-    async def process_requests(self, func: Callable, retry_kwargs: dict = {}) -> None:
+    async def process_requests(
+        self, func: Callable, retry_kwargs: dict = {}
+    ) -> None:
         """
         Processes tasks from the queue using the provided function with retries.
 
@@ -85,7 +88,9 @@ class AsyncQueue:
         tasks = set()
         while not self.stopped():
             if len(tasks) >= self.max_concurrent_tasks:
-                _, done = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+                _, done = await asyncio.wait(
+                    tasks, return_when=asyncio.FIRST_COMPLETED
+                )
                 tasks.difference_update(done)
 
             async with self.semaphore:

lionagi/libs/ln_tokenize.py

@@ -20,11 +20,16 @@ class TokenizeUtil:
 
         if encoding_model:
             try:
-                encoding_name = tiktoken.encoding_name_for_model(encoding_model)
+                encoding_name = tiktoken.encoding_name_for_model(
+                    encoding_model
+                )
             except:
                 encoding_name = encoding_name or "cl100k_base"
 
-        if not encoding_name or encoding_name in tiktoken.list_encoding_names():
+        if (
+            not encoding_name
+            or encoding_name in tiktoken.list_encoding_names()
+        ):
             encoding_name = encoding_name or "cl100k_base"
             encoding = tiktoken.get_encoding(encoding_name)
 
@@ -88,9 +93,13 @@ class TokenizeUtil:
                 chunks.append(text[start_idx:end_idx])
 
             if len(text) - chunk_size * (n_chunks - 1) > threshold:
-                chunks.append(text[chunk_size * (n_chunks - 1) - overlap_size :])
+                chunks.append(
+                    text[chunk_size * (n_chunks - 1) - overlap_size :]
+                )
             else:
-                chunks[-1] += text[chunk_size * (n_chunks - 1) + overlap_size :]
+                chunks[-1] += text[
+                    chunk_size * (n_chunks - 1) + overlap_size :
+                ]
 
             return chunks
 
@@ -157,10 +166,14 @@ class TokenizeUtil:
                 chunks.append(tokens[start_idx:end_idx])
 
             if len(tokens) - chunk_size * (n_chunks - 1) > threshold:
-                chunks.append(tokens[chunk_size * (n_chunks - 1) - overlap_size :])
+                chunks.append(
+                    tokens[chunk_size * (n_chunks - 1) - overlap_size :]
+                )
             else:
                 chunks[-1] += tokens[-residue:]
 
             return (
-                [" ".join(chunk) for chunk in chunks] if not return_tokens else chunks
+                [" ".join(chunk) for chunk in chunks]
+                if not return_tokens
+                else chunks
             )

lionagi/libs/ln_validate.py

@@ -6,7 +6,14 @@ including numeric, boolean, string, and enum. It also provides a dictionary `val
 maps data types to their corresponding validation functions.
 """
 
-from .ln_convert import is_same_dtype, strip_lower, to_dict, to_list, to_num, to_str
+from .ln_convert import (
+    is_same_dtype,
+    strip_lower,
+    to_dict,
+    to_list,
+    to_num,
+    to_str,
+)
 from .ln_parse import ParseUtil, StringMatch
 
 
@@ -19,7 +26,9 @@ def check_dict_field(x, keys: list[str] | dict, fix_=True, **kwargs):
             return StringMatch.force_validate_dict(x, keys=keys, **kwargs)
         except Exception as e:
             raise ValueError("Invalid dict field type.") from e
-    raise ValueError(f"Default value for DICT must be a dict, got {type(x).__name__}")
+    raise ValueError(
+        f"Default value for DICT must be a dict, got {type(x).__name__}"
+    )
 
 
 def check_action_field(x, fix_=True, **kwargs):
@@ -275,7 +284,9 @@ def _fix_enum_field(x, choices, **kwargs):
         x = to_str(x)
         return StringMatch.choose_most_similar(x, choices, **kwargs)
     except Exception as e:
-        raise ValueError(f"Failed to convert {x} into one of the choices") from e
+        raise ValueError(
+            f"Failed to convert {x} into one of the choices"
+        ) from e
 
 
 validation_funcs = {

lionagi/libs/sys_util.py

@@ -48,7 +48,9 @@ class SysUtil:
         return datetime.now(**config_)
 
     @staticmethod
-    def change_dict_key(dict_: dict[Any, Any], old_key: str, new_key: str) -> None:
+    def change_dict_key(
+        dict_: dict[Any, Any], old_key: str, new_key: str
+    ) -> None:
         """Safely changes a key in a dictionary if the old key exists.
 
         Args:
@@ -122,7 +124,9 @@ class SysUtil:
         return sha256(current_time + random_bytes).hexdigest()[:n]
 
     @staticmethod
-    def get_bins(input_: list[str], upper: int | None = 2000) -> list[list[int]]:
+    def get_bins(
+        input_: list[str], upper: int | None = 2000
+    ) -> list[list[int]]:
         """Organizes indices of strings into bins based on a cumulative upper limit.
 
         Args:
@@ -157,7 +161,11 @@ class SysUtil:
                 str: A string identifying the CPU architecture ('apple_silicon' or 'other_cpu').
         """
         arch: str = platform.machine().lower()
-        return "apple_silicon" if "arm" in arch or "aarch64" in arch else "other_cpu"
+        return (
+            "apple_silicon"
+            if "arm" in arch or "aarch64" in arch
+            else "other_cpu"
+        )
 
     @staticmethod
     def install_import(
@@ -195,7 +203,9 @@ class SysUtil:
             print(
                 f"Module {full_import_path} or attribute {import_name} not found. Installing {pip_name}..."
             )
-            subprocess.check_call([sys.executable, "-m", "pip", "install", pip_name])
+            subprocess.check_call(
+                [sys.executable, "-m", "pip", "install", pip_name]
+            )
 
             # Retry the import after installation
             if import_name:
@@ -254,18 +264,25 @@ class SysUtil:
                         package_name, module_name, import_name, pip_name
                     )
                 else:
-                    logging.info(f"Package {package_name} not found. {error_message}")
+                    logging.info(
+                        f"Package {package_name} not found. {error_message}"
+                    )
                     raise ImportError(
                         f"Package {package_name} not found. {error_message}"
                     )
         except ImportError as e:  # More specific exception handling
             logging.error(f"Failed to import {package_name}. Error: {e}")
-            raise ValueError(f"Failed to import {package_name}. Error: {e}") from e
+            raise ValueError(
+                f"Failed to import {package_name}. Error: {e}"
+            ) from e
 
     @staticmethod
     def list_installed_packages() -> list:
         """list all installed packages using importlib.metadata."""
-        return [dist.metadata["Name"] for dist in importlib.metadata.distributions()]
+        return [
+            dist.metadata["Name"]
+            for dist in importlib.metadata.distributions()
+        ]
 
     @staticmethod
     def uninstall_package(package_name: str) -> None:
@@ -283,7 +300,14 @@ class SysUtil:
         """Update a specified package."""
         try:
             subprocess.check_call(
-                [sys.executable, "-m", "pip", "install", "--upgrade", package_name]
+                [
+                    sys.executable,
+                    "-m",
+                    "pip",
+                    "install",
+                    "--upgrade",
+                    package_name,
+                ]
             )
             print(f"Successfully updated {package_name}.")
         except subprocess.CalledProcessError as e:
@@ -291,7 +315,9 @@ class SysUtil:
 
     @staticmethod
     def clear_dir(
-        dir_path: Path | str, recursive: bool = False, exclude: list[str] = None
+        dir_path: Path | str,
+        recursive: bool = False,
+        exclude: list[str] = None,
     ) -> None:
         """
         Clears all files (and, if recursive, directories) in the specified directory,
@@ -376,7 +402,9 @@ class SysUtil:
                 "Invalid filename. Ensure it doesn't contain illegal characters and has a valid extension."
             )
 
-        name, ext = filename.rsplit(".", 1) if "." in filename else (filename, "")
+        name, ext = (
+            filename.rsplit(".", 1) if "." in filename else (filename, "")
+        )
         ext = f".{ext}" if ext else ""
 
         timestamp_str = ""
@@ -384,7 +412,9 @@ class SysUtil:
             timestamp_format = custom_timestamp_format or "%Y%m%d%H%M%S"
             timestamp_str = datetime.now().strftime(timestamp_format)
             filename = (
-                f"{timestamp_str}_{name}" if time_prefix else f"{name}_{timestamp_str}"
+                f"{timestamp_str}_{name}"
+                if time_prefix
+                else f"{name}_{timestamp_str}"
             )
         else:
             filename = name
@@ -462,7 +492,9 @@ class SysUtil:
         if path.is_file():
             return path.stat().st_size
         elif path.is_dir():
-            return sum(f.stat().st_size for f in path.glob("**/*") if f.is_file())
+            return sum(
+                f.stat().st_size for f in path.glob("**/*") if f.is_file()
+            )
         else:
             raise FileNotFoundError(f"{path} does not exist.")
 

lionagi/lions/coder/coder.py

@@ -6,7 +6,11 @@ from lionagi.core import Session
 from lionagi.libs import ParseUtil
 
 from .base_prompts import CODER_PROMPTS
-from .util import install_missing_dependencies, save_code_file, set_up_interpreter
+from .util import (
+    install_missing_dependencies,
+    save_code_file,
+    set_up_interpreter,
+)
 
 
 class Coder:
@@ -55,38 +59,50 @@ class Coder:
 
     async def _plan_code(self, context):
         print("Planning code...")
-        plans = await self.session.chat(self.prompts["plan_code"], context=context)
+        plans = await self.session.chat(
+            self.prompts["plan_code"], context=context
+        )
         print("Code planning completed.")
         return plans
 
     async def _write_code(self, context=None):
         print("Writing code...")
-        code = await self.session.chat(self.prompts["write_code"], context=context)
+        code = await self.session.chat(
+            self.prompts["write_code"], context=context
+        )
         print("Code writing completed.")
         return ParseUtil.extract_code_blocks(code)
 
     async def _review_code(self, context=None):
         print("Reviewing code...")
-        code = await self.session.chat(self.prompts["review_code"], context=context)
+        code = await self.session.chat(
+            self.prompts["review_code"], context=context
+        )
         print("Code review completed.")
         return code
 
     async def _modify_code(self, context=None):
         print("Modifying code...")
-        code = await self.session.chat(self.prompts["modify_code"], context=context)
+        code = await self.session.chat(
+            self.prompts["modify_code"], context=context
+        )
         print("Code modification completed.")
         return code
 
     async def _debug_code(self, context=None):
         print("Debugging code...")
-        code = await self.session.chat(self.prompts["debug_code"], context=context)
+        code = await self.session.chat(
+            self.prompts["debug_code"], context=context
+        )
         print("Code debugging completed.")
         return code
 
     def _handle_execution_error(self, execution, required_libraries=None):
         print("Handling execution error...")
         if execution.error and execution.error.name == "ModuleNotFoundError":
-            print("ModuleNotFoundError detected. Installing missing dependencies...")
+            print(
+                "ModuleNotFoundError detected. Installing missing dependencies..."
+            )
             install_missing_dependencies(required_libraries)
             print("Dependencies installed. Retrying execution.")
             return "try again"
@@ -118,7 +134,7 @@ class Coder:
     def _load_code_file(file_path):
         print("Loading code...")
         try:
-            with open(file_path, "r") as file:
+            with open(file_path) as file:
                 print("Code loaded.")
                 return file.read()
         except FileNotFoundError:

lionagi/lions/coder/util.py

@@ -28,7 +28,9 @@ def set_up_interpreter(interpreter_provider="e2b", key_scheme=E2B_key_scheme):
 def install_missing_dependencies(required_libraries):
     print("Checking for missing dependencies...")
     missing_libraries = [
-        library for library in required_libraries if not is_library_installed(library)
+        library
+        for library in required_libraries
+        if not is_library_installed(library)
     ]
 
     if missing_libraries:
@@ -58,7 +60,9 @@ def install_library(library):
         import subprocess
         import sys
 
-        subprocess.check_call([sys.executable, "-m", "pip", "install", library])
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", library]
+        )
         print(f"Successfully installed {library}.")
     except subprocess.CalledProcessError as e:
         print(f"Error occurred while installing {library}: {str(e)}")