lionagi 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/lions/coder/add_feature.py

@@ -1,20 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-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

@@ -1,15 +0,0 @@
-from typing import Any
-
-from pydantic import Field
-
-from lionagi.core import Session
-from lionagi.core.form.action_form import ActionForm
-from lionagi.libs import ParseUtil, SysUtil
-
-
-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

@@ -1,184 +0,0 @@
-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,
-    save_code_file,
-    set_up_interpreter,
-)
-
-
-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) 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

@@ -1,101 +0,0 @@
-from pathlib import Path
-from typing import Any
-
-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 os import getenv
-
-        from e2b_code_interpreter import CodeInterpreter  # type: ignore
-
-        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,
-    )

lionagi/lions/judge/config.py

@@ -1,8 +0,0 @@
-judge_model_config = {
-    "model": "gpt-4o-mini",
-    "temperature": 0.1,
-    "api_key_schema": "OPENAI_API_KEY",
-    "max_tokens": 1000,
-    "costs": (0.15, 0.6),
-    "top_p": 0.9,
-}