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

lionagi/libs/ln_validate.py

@@ -0,0 +1,288 @@
+"""
+This module provides functions for validating and fixing field values based on their data types.
+
+The module defines several functions for checking and fixing field values of different data types,
+including numeric, boolean, string, and enum. It also provides a dictionary `validation_funcs` that
+maps data types to their corresponding validation functions.
+"""
+
+from .ln_convert import to_str, is_same_dtype, to_list, to_dict, to_num, strip_lower
+from .ln_parse import StringMatch, ParseUtil
+
+
+def check_dict_field(x, keys: list[str] | dict, fix_=True, **kwargs):
+    if isinstance(x, dict):
+        return x
+    if fix_:
+        try:
+            x = to_str(x)
+            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__}")
+
+
+def check_action_field(x, fix_=True, **kwargs):
+    if (
+        isinstance(x, list)
+        and is_same_dtype(x, dict)
+        and all(_has_action_keys(y) for y in x)
+    ):
+        return x
+    try:
+        x = _fix_action_field(x, fix_)
+        return x
+    except Exception as e:
+        raise ValueError("Invalid action field type.") from e
+
+
+def check_number_field(x, fix_=True, **kwargs):
+    """
+    Checks if the given value is a valid numeric field.
+
+    Args:
+        x: The value to check.
+        fix_ (bool): Flag indicating whether to attempt fixing the value if it's invalid (default: True).
+        **kwargs: Additional keyword arguments for fixing the value.
+
+    Returns:
+        The original value if it's valid, or the fixed value if `fix_` is True.
+
+    Raises:
+        ValueError: If the value is not a valid numeric field and cannot be fixed.
+    """
+    if not isinstance(x, (int, float)):
+        if fix_:
+            try:
+                return _fix_number_field(x, **kwargs)
+            except Exception as e:
+                raise e
+
+        raise ValueError(
+            f"Default value for NUMERIC must be an int or float, got {type(x).__name__}"
+        )
+    return x
+
+
+def check_bool_field(x, fix_=True):
+    """
+    Checks if the given value is a valid boolean field.
+
+    Args:
+        x: The value to check.
+        fix_ (bool): Flag indicating whether to attempt fixing the value if it's invalid (default: True).
+
+    Returns:
+        The original value if it's valid, or the fixed value if `fix_` is True.
+
+    Raises:
+        ValueError: If the value is not a valid boolean field and cannot be fixed.
+    """
+    if not isinstance(x, bool):
+        if fix_:
+            try:
+                return _fix_bool_field(x)
+            except Exception as e:
+                raise e
+
+        raise ValueError(
+            f"Default value for BOOLEAN must be a bool, got {type(x).__name__}"
+        )
+    return x
+
+
+def check_str_field(x, *args, fix_=True, **kwargs):
+    """
+    Checks if the given value is a valid string field.
+
+    Args:
+        x: The value to check.
+        *args: Additional positional arguments for fixing the value.
+        fix_ (bool): Flag indicating whether to attempt fixing the value if it's invalid (default: True).
+        **kwargs: Additional keyword arguments for fixing the value.
+
+    Returns:
+        The original value if it's valid, or the fixed value if `fix_` is True.
+
+    Raises:
+        ValueError: If the value is not a valid string field and cannot be fixed.
+    """
+    if not isinstance(x, str):
+        if fix_:
+            try:
+                return _fix_str_field(x, *args, **kwargs)
+            except Exception as e:
+                raise e
+
+        raise ValueError(
+            f"Default value for STRING must be a str, got {type(x).__name__}"
+        )
+    return x
+
+
+def check_enum_field(x, choices, fix_=True, **kwargs):
+    """
+    Checks if the given value is a valid enum field.
+
+    Args:
+        x: The value to check.
+        choices: The list of valid choices for the enum field.
+        fix_ (bool): Flag indicating whether to attempt fixing the value if it's invalid (default: True).
+        **kwargs: Additional keyword arguments for fixing the value.
+
+    Returns:
+        The original value if it's valid, or the fixed value if `fix_` is True.
+
+    Raises:
+        ValueError: If the value is not a valid enum field and cannot be fixed.
+    """
+    same_dtype, dtype_ = is_same_dtype(choices, return_dtype=True)
+    if not same_dtype:
+        raise ValueError(
+            f"Field type ENUM requires all choices to be of the same type, got {choices}"
+        )
+
+    if not isinstance(x, dtype_):
+        raise ValueError(
+            f"Default value for ENUM must be an instance of the {dtype_.__name__}, got {type(x).__name__}"
+        )
+
+    if x not in choices:
+        if fix_:
+            try:
+                return _fix_enum_field(x, choices, **kwargs)
+            except Exception as e:
+                raise e
+        raise ValueError(
+            f"Default value for ENUM must be one of the {choices}, got {x}"
+        )
+
+    return x
+
+
+def _has_action_keys(dict_):
+    return list(dict_.keys()) >= ["function", "arguments"]
+
+
+def _fix_action_field(x, discard_=True):
+    corrected = []
+    if isinstance(x, str):
+        x = ParseUtil.fuzzy_parse_json(x)
+
+    try:
+        x = to_list(x)
+
+        for i in x:
+            i = to_dict(i)
+            if _has_action_keys(i):
+                corrected.append(i)
+            elif not discard_:
+                raise ValueError(f"Invalid action field: {i}")
+    except Exception as e:
+        raise ValueError(f"Invalid action field: {e}") from e
+
+    return corrected
+
+
+def _fix_number_field(x, *args, **kwargs):
+    """
+    Attempts to fix an invalid numeric field value.
+
+    Args:
+        x: The value to fix.
+        *args: Additional positional arguments for fixing the value.
+        **kwargs: Additional keyword arguments for fixing the value.
+
+    Returns:
+        The fixed numeric value.
+
+    Raises:
+        ValueError: If the value cannot be converted into a valid numeric value.
+    """
+    try:
+        x = to_num(x, *args, **kwargs)
+        if isinstance(x, (int, float)):
+            return x
+        raise ValueError(f"Failed to convert {x} into a numeric value")
+    except Exception as e:
+        raise ValueError(f"Failed to convert {x} into a numeric value") from e
+
+
+def _fix_bool_field(x):
+    """
+    Attempts to fix an invalid boolean field value.
+
+    Args:
+        x: The value to fix.
+
+    Returns:
+        The fixed boolean value.
+
+    Raises:
+        ValueError: If the value cannot be converted into a valid boolean value.
+    """
+    try:
+        x = strip_lower(to_str(x))
+        if x in ["true", "1", "correct", "yes"]:
+            return True
+
+        elif x in ["false", "0", "incorrect", "no", "none", "n/a"]:
+            return False
+
+        raise ValueError(f"Failed to convert {x} into a boolean value")
+    except Exception as e:
+        raise ValueError(f"Failed to convert {x} into a boolean value") from e
+
+
+def _fix_str_field(x):
+    """
+    Attempts to fix an invalid string field value.
+
+    Args:
+        x: The value to fix.
+
+    Returns:
+        The fixed string value.
+
+    Raises:
+        ValueError: If the value cannot be converted into a valid string value.
+    """
+    try:
+        x = to_str(x)
+        if isinstance(x, str):
+            return x
+        raise ValueError(f"Failed to convert {x} into a string value")
+    except Exception as e:
+        raise ValueError(f"Failed to convert {x} into a string value") from e
+
+
+def _fix_enum_field(x, choices, **kwargs):
+    """
+    Attempts to fix an invalid enum field value.
+
+    Args:
+        x: The value to fix.
+        choices: The list of valid choices for the enum field.
+        **kwargs: Additional keyword arguments for fixing the value.
+
+    Returns:
+        The fixed enum value.
+
+    Raises:
+        ValueError: If the value cannot be converted into a valid enum value.
+    """
+    try:
+        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
+
+
+validation_funcs = {
+    "number": check_number_field,
+    "bool": check_bool_field,
+    "str": check_str_field,
+    "enum": check_enum_field,
+    "action": check_action_field,
+    "dict": check_dict_field,
+}

lionagi/libs/sys_util.py

@@ -3,11 +3,26 @@ MIT License
 
 Copyright (c) 2023 HaiyangLi quantocean.li@gmail.com
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Permission is hereby granted, free of charge, to any person 
+obtaining a copy of this software and associated documentation 
+files (the "Software"), to deal in the Software without 
+restriction, including without limitation the rights to use, 
+copy, modify, merge, publish, distribute, sublicense, and/or 
+sell copies of the Software, and to permit persons to whom 
+the Software is furnished to do so, subject to the following 
+conditions:
+
+The above copyright notice and this permission notice shall be 
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
 """
 
 import copy
@@ -257,7 +272,7 @@ class SysUtil:
         """
         try:
             if not SysUtil.is_package_installed(package_name):
-                print("check")
+                # print("check")
                 if attempt_install:
                     logging.info(
                         f"Package {package_name} not found. Attempting to install."
@@ -363,6 +378,7 @@ class SysUtil:
         dir_exist_ok: bool = True,
         time_prefix: bool = False,
         custom_timestamp_format: str | None = None,
+        random_hash_digits=0,
     ) -> Path:
         """
         Creates a path with an optional timestamp in the specified directory.
@@ -400,7 +416,13 @@ class SysUtil:
         else:
             filename = name
 
-        full_filename = f"{filename}{ext}"
+        random_hash = (
+            "-" + SysUtil.create_id(random_hash_digits)
+            if random_hash_digits > 0
+            else ""
+        )
+
+        full_filename = f"{filename}{random_hash}{ext}"
         full_path = directory / full_filename
         full_path.parent.mkdir(parents=True, exist_ok=dir_exist_ok)
 

lionagi/lions/coder/add_feature.py

@@ -0,0 +1,20 @@
+# task1 = task1 or """
+# 1. read through the given functions, and try to understand what they do.
+# 2. if any function appear undefined in the environment, define them according to given information
+# 3. add a few test cases and check correctness
+# """
+
+# context = "codes to evaluate: "+ context
+
+# task2 = task2 or f"""
+# 1. validate correctness, and add 5-10 new functions using pure python
+# 2. improve time/space complexity while preserving usage behavior
+# 3. run to make sure correctness
+# """
+
+# task3 = task3 or f"""
+# present the full implementation and save as: {filename}.txt
+# 1. add typing and google format docstrings
+# 2. add a couple examples in the docstrings
+# 3. add unittests
+# """

lionagi/lions/coder/base_prompts.py

@@ -0,0 +1,22 @@
+GUIDANCE_RESPONSE = """
+...
+"""
+
+PLAN_PROMPT = "..."
+WRITE_PROMPT = "..."
+REVIEW_PROMPT = "..."
+MODIFY_PROMPT = """
+...
+"""
+DEBUG_PROMPT = """
+...
+"""
+
+CODER_PROMPTS = {
+    "system": GUIDANCE_RESPONSE,
+    "plan_code": PLAN_PROMPT,
+    "write_code": WRITE_PROMPT,
+    "review_code": REVIEW_PROMPT,
+    "modify_code": MODIFY_PROMPT,
+    "debug_code": DEBUG_PROMPT,
+}

lionagi/lions/coder/coder.py

@@ -0,0 +1,121 @@
+import asyncio
+from lionagi.core import Session
+
+from .base_prompts import CODER_PROMPTS
+from .util import extract_code_blocks, install_missing_dependencies, set_up_interpreter
+
+
+class Coder:
+    def __init__(
+        self, prompts=None, session=None, session_kwargs=None, required_libraries=None
+    ):
+        print("Initializing Coder...")
+        self.prompts = prompts or CODER_PROMPTS
+        self.session = session or self._create_session(session_kwargs)
+        self.required_libraries = required_libraries or ["lionagi"]
+        print("Coder initialized.")
+
+    def _create_session(self, session_kwargs=None):
+        print("Creating session...")
+        session_kwargs = session_kwargs or {}
+        session = Session(system=self.prompts["system"], **session_kwargs)
+        print("Session created.")
+        return session
+
+    async def _plan_code(self, context):
+        print("Planning code...")
+        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)
+        print("Code writing completed.")
+        return 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)
+        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)
+        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)
+        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...")
+            install_missing_dependencies(required_libraries)
+            print("Dependencies installed. Retrying execution.")
+            return "try again"
+        elif execution.error:
+            print(f"Execution error: {execution.error}")
+            return execution.error
+
+    def execute_code(self, code, **kwargs):
+        print("Executing code...")
+        interpreter = set_up_interpreter()
+        with interpreter as sandbox:
+            print("Running code in sandbox...")
+            execution = sandbox.notebook.exec_cell(code, **kwargs)
+            error = self._handle_execution_error(
+                execution, required_libraries=kwargs.get("required_libraries")
+            )
+            if error == "try again":
+                print("Retrying code execution...")
+                execution = sandbox.notebook.exec_cell(code, **kwargs)
+            print("Code execution completed.")
+            return execution
+
+
+async def main():
+    print("Starting main function...")
+    coder = Coder()
+
+    code_prompt = """
+    write a pure python function that takes a list of integers and returns the sum of all the integers in the list. write a couple tests as well
+    """
+
+    print(f"Code prompt: {code_prompt}")
+
+    print("Planning code...")
+    code_plan = await coder._plan_code(context=code_prompt)
+    print("Code plan generated.")
+
+    print("Writing code...")
+    code = await coder._write_code()
+    print("Code written.")
+
+    print("Executing code...")
+    execution_result = coder.execute_code(code)
+    print("Code execution completed.")
+
+    from IPython.display import Markdown
+
+    print("Displaying code plan...")
+    Markdown(code_plan)
+
+    print("Displaying generated code...")
+    print(code)
+
+    print("Displaying execution result...")
+    print(execution_result)
+
+    print("Main function completed.")
+
+
+if __name__ == "__main__":
+    print("Running script...")
+    asyncio.run(main())
+    print("Script execution completed.")

lionagi/lions/coder/util.py

@@ -0,0 +1,91 @@
+E2B_key_scheme = "E2B_API_KEY"
+
+
+def set_up_interpreter(interpreter_provider="e2b", key_scheme=E2B_key_scheme):
+
+    if interpreter_provider == "e2b":
+        from dotenv import load_dotenv
+
+        load_dotenv()
+
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("e2b_code_interpreter")
+
+        from e2b_code_interpreter import CodeInterpreter  # type: ignore
+        from os import getenv
+
+        return CodeInterpreter(api_key=getenv(key_scheme))
+
+    else:
+        raise ValueError("Invalid interpreter provider")
+
+
+def extract_code_blocks(code):
+    print("Extracting code blocks...")
+    code_blocks = []
+    lines = code.split("\n")
+    inside_code_block = False
+    current_block = []
+
+    for line in lines:
+        if line.startswith("```"):
+            if inside_code_block:
+                code_blocks.append("\n".join(current_block))
+                current_block = []
+                inside_code_block = False
+            else:
+                inside_code_block = True
+        elif inside_code_block:
+            current_block.append(line)
+
+    if current_block:
+        code_blocks.append("\n".join(current_block))
+
+    print(f"Extracted {len(code_blocks)} code block(s).")
+    return "\n\n".join(code_blocks)
+
+
+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)
+    ]
+
+    if missing_libraries:
+        print(f"Missing libraries: {', '.join(missing_libraries)}")
+        for library in missing_libraries:
+            print(f"Installing {library}...")
+            install_library(library)
+        print("Installation completed.")
+    else:
+        print("All required dependencies are already installed.")
+
+
+def is_library_installed(library):
+    try:
+        import importlib
+
+        importlib.import_module(library)
+        print(f"{library} is already installed.")
+        return True
+    except ImportError:
+        print(f"{library} is not installed.")
+        return False
+
+
+def install_library(library):
+    try:
+        import subprocess
+        import sys
+
+        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)}")
+        print(
+            "Please check the error message and ensure you have the necessary permissions to install packages."
+        )
+        print(
+            "You may need to run the script with administrative privileges or use a virtual environment."
+        )