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

lionagi/libs/special_tokens.py

@@ -0,0 +1,172 @@
+# disallowed special tokens
+
+disallowed_tokens = [
+    "▄",
+    "▅",
+    "▆",
+    "▇",
+    "█",
+    "▏",
+    "▎",
+    "▍",
+    "▌",
+    "▋",
+    "▊",
+    "▉",
+    "▔",
+    "▕",
+    "▁▁",
+    "▁▂",
+    "▁▃",
+    "▁▄",
+    "▁▅",
+    "▁▆",
+    "▁▇",
+    "▁█",
+    "▁▏",
+    "▁▎",
+    "▁▍",
+    "▁▌",
+    "▁▋",
+    "▁▊",
+    "▁▉",
+    "▁▔",
+    "▁▕",
+    "▄▄",
+    "▄▅",
+    "▄▆",
+    "▄▇",
+    "▄█",
+    "▄▏",
+    "▄▎",
+    "▄▍",
+    "▄▌",
+    "▄▋",
+    "▄▊",
+    "▄▉",
+    "▄▔",
+    "▄▕",
+    "▅▅",
+    "▅▆",
+    "▅▇",
+    "▅█",
+    "▅▏",
+    "▅▎",
+    "▅▍",
+    "▅▌",
+    "▅▋",
+    "▅▊",
+    "▅▉",
+    "▅▔",
+    "▅▕",
+    "▆▆",
+    "▆▇",
+    "▆█",
+    "▆▏",
+    "▆▎",
+    "▆▍",
+    "▆▌",
+    "▆▋",
+    "▆▊",
+    "▆▉",
+    "▆▔",
+    "▆▕",
+    "▇▇",
+    "▇█",
+    "▇▏",
+    "▇▎",
+    "▇▍",
+    "▇▌",
+    "▇▋",
+    "▇▊",
+    "▇▉",
+    "▇▔",
+    "▇▕",
+    "██",
+    "█▏",
+    "█▎",
+    "█▍",
+    "█▌",
+    "█▋",
+    "█▊",
+    "█▉",
+    "█",
+    "█▔",
+    "█▕",
+    "▏▏",
+    "▏▎",
+    "▏▍",
+    "▏▌",
+    "▏▋",
+    "▏▊",
+    "▏▉",
+    "▏",
+    "▏▔",
+    "▏▕",
+    "▎▎",
+    "▎▍",
+    "▎▌",
+    "▎▋",
+    "▎▊",
+    "▎▉",
+    "▎",
+    "▎▔",
+    "▎▕",
+    "▍▍",
+    "▍▌",
+    "▍▋",
+    "▍▊",
+    "▍▉",
+    "▍",
+    "▍▔",
+    "▍▕",
+    "▌▌",
+    "▌▋",
+    "▌▊",
+    "▌▉",
+    "▌",
+    "▌▔",
+    "▌▕",
+    "▋▋",
+    "▋▊",
+    "▋▉",
+    "▋",
+    "▋▔",
+    "▋▕",
+    "▊▊",
+    "▊▉",
+    "▊",
+    "▊▔",
+    "▊▕",
+    "▉▉",
+    "▉",
+    "▉▔",
+    "▉▕",
+    "▔▔",
+    "▔▕",
+    "▕▕",
+    "▁▁▁",
+    "▁▁▂",
+    "▁▁▃",
+    "▁▁▄",
+    "▁▁▅",
+    "▁▁▆",
+    "▁▁▇",
+    "▁▁█",
+    "▁▁▏",
+    "▁▁▎",
+    "▁▁▍",
+    "▁▁▌",
+    "▁▁▋",
+    "▁▁▊",
+    "▁▁▉",
+    "▁▁▔",
+    "▁▁▕",
+    "▁▂▂",
+    "▁▂▃",
+    "▁▂▄",
+    "▁▂▅",
+    "▁▂▆",
+    "▁▂▇",
+    "▁▂█",
+]

lionagi/libs/sys_util.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 copy
 import importlib
 import logging
@@ -245,7 +261,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."
@@ -351,6 +367,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.
@@ -388,7 +405,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)
 
@@ -396,6 +419,19 @@ class SysUtil:
 
     @staticmethod
     def list_files(dir_path: Path | str, extension: str = None) -> list[Path]:
+        """
+        Lists all files in a specified directory with an optional filter for file extensions.
+
+        Args:
+            dir_path (Path | str): The directory path where files are listed.
+            extension (str, optional): Filter files by extension. Default is None, which lists all files.
+
+        Returns:
+            list[Path]: A list of Path objects representing files in the directory.
+
+        Raises:
+            NotADirectoryError: If the provided dir_path is not a directory.
+        """
         dir_path = Path(dir_path)
         if not dir_path.is_dir():
             raise NotADirectoryError(f"{dir_path} is not a directory.")
@@ -406,6 +442,16 @@ class SysUtil:
 
     @staticmethod
     def copy_file(src: Path | str, dest: Path | str) -> None:
+        """
+        Copies a file from a source path to a destination path.
+
+        Args:
+            src (Path | str): The source file path.
+            dest (Path | str): The destination file path.
+
+        Raises:
+            FileNotFoundError: If the source file does not exist or is not a file.
+        """
         from shutil import copy2
 
         src, dest = Path(src), Path(dest)
@@ -416,6 +462,18 @@ class SysUtil:
 
     @staticmethod
     def get_size(path: Path | str) -> int:
+        """
+        Gets the size of a file or total size of files in a directory.
+
+        Args:
+            path (Path | str): The file or directory path.
+
+        Returns:
+            int: The size in bytes.
+
+        Raises:
+            FileNotFoundError: If the path does not exist.
+        """
         path = Path(path)
         if path.is_file():
             return path.stat().st_size
@@ -423,3 +481,50 @@ class SysUtil:
             return sum(f.stat().st_size for f in path.glob("**/*") if f.is_file())
         else:
             raise FileNotFoundError(f"{path} does not exist.")
+
+    @staticmethod
+    def save_to_file(
+        text,
+        directory: Path | str,
+        filename: str,
+        timestamp: bool = True,
+        dir_exist_ok: bool = True,
+        time_prefix: bool = False,
+        custom_timestamp_format: str | None = None,
+        random_hash_digits=0,
+        verbose=True,
+    ):
+        """
+        Saves text to a file within a specified directory, optionally adding a timestamp, hash, and verbose logging.
+
+        Args:
+            text (str): The text to save.
+            directory (Path | str): The directory path to save the file.
+            filename (str): The filename for the saved text.
+            timestamp (bool): If True, append a timestamp to the filename. Default is True.
+            dir_exist_ok (bool): If True, creates the directory if it does not exist. Default is True.
+            time_prefix (bool): If True, prepend the timestamp instead of appending. Default is False.
+            custom_timestamp_format (str | None): A custom format for the timestamp, if None uses default format. Default is None.
+            random_hash_digits (int): Number of random hash digits to append to filename. Default is 0.
+            verbose (bool): If True, prints the file path after saving. Default is True.
+
+        Returns:
+            bool: True if the text was successfully saved.
+        """
+        file_path = SysUtil.create_path(
+            directory=directory,
+            filename=filename,
+            timestamp=timestamp,
+            dir_exist_ok=dir_exist_ok,
+            time_prefix=time_prefix,
+            custom_timestamp_format=custom_timestamp_format,
+            random_hash_digits=random_hash_digits,
+        )
+
+        with open(file_path, "w") as file:
+            file.write(text)
+
+        if verbose:
+            print(f"Text saved to: {file_path}")
+
+        return True

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/code_form.py

@@ -0,0 +1,13 @@
+from typing import Any
+from pydantic import Field
+from lionagi.libs import ParseUtil, SysUtil
+from lionagi.core import Session
+from lionagi.core.form.action_form import ActionForm
+
+
+class CodeForm(ActionForm):
+    template_name: str = "code_form"
+    language: str = Field(
+        default="python",
+        description="The programming language of the code to be executed.",
+    )

lionagi/lions/coder/coder.py

@@ -0,0 +1,168 @@
+import asyncio
+from pathlib import Path
+
+from lionagi import logging as _logging
+from lionagi.core import Session
+from lionagi.libs import ParseUtil
+
+from .base_prompts import CODER_PROMPTS
+from .util import install_missing_dependencies, set_up_interpreter, save_code_file
+
+
+class Coder:
+
+    def __init__(
+        self,
+        prompts: dict = None,
+        session: Session = None,
+        session_kwargs: dict = None,
+        required_libraries: list = None,
+        work_dir: Path | str = None,
+    ) -> None:
+
+        self.prompts = prompts or CODER_PROMPTS
+        self.session = session or self._create_session(session_kwargs)
+        self.required_libraries = required_libraries or ["lionagi"]
+        self.work_dir = work_dir or Path.cwd() / "coder" / "code_files"
+
+    def _create_session(self, session_kwargs: dict = None) -> Session:
+        session_kwargs = session_kwargs or {}
+        return Session(system=self.prompts["system"], **session_kwargs)
+
+
+class Coder:
+    def __init__(
+        self,
+        prompts=None,
+        session=None,
+        session_kwargs=None,
+        required_libraries=None,
+        work_dir=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"]
+        self.work_dir = work_dir or Path.cwd() / "coder" / "code_files"
+        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 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)
+        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
+
+    def _save_code_file(self, code, **kwargs):
+        print("Saving code...")
+        save_code_file(code, self.work_dir, **kwargs)
+        print("Code saved.")
+
+    @staticmethod
+    def _load_code_file(file_path):
+        print("Loading code...")
+        try:
+            with open(file_path, "r") as file:
+                print("Code loaded.")
+                return file.read()
+        except FileNotFoundError:
+            _logging.error(f"File not found: {file_path}")
+            return None
+
+
+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,96 @@
+from typing import Any
+from pathlib import Path
+
+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 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."
+        )
+
+
+def save_code_file(
+    code: Any,
+    directory: Path | str = None,
+    filename: str = "code.py",
+    timestamp: bool = True,
+    dir_exist_ok: bool = True,
+    time_prefix: bool = False,
+    custom_timestamp_format: str | None = None,
+    random_hash_digits: int = 3,
+    verbose: bool = True,
+):
+
+    from lionagi.libs import SysUtil
+
+    return SysUtil.save_to_file(
+        text=code,
+        directory=directory,
+        filename=filename,
+        timestamp=timestamp,
+        dir_exist_ok=dir_exist_ok,
+        time_prefix=time_prefix,
+        custom_timestamp_format=custom_timestamp_format,
+        random_hash_digits=random_hash_digits,
+        verbose=verbose,
+    )