vision-agent 0.2.56__py3-none-any.whl → 0.2.58__py3-none-any.whl

vision_agent/agent/data_interpreter.py

@@ -1,475 +0,0 @@
-import json
-import logging
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, Union
-
-import pandas as pd
-from langsmith import traceable
-from rich.console import Console
-from rich.syntax import Syntax
-from tabulate import tabulate
-
-from vision_agent.agent import Agent
-from vision_agent.agent.data_interpreter_prompts import (
-    CODE,
-    CODE_SYS_MSG,
-    DEBUG,
-    DEBUG_EXAMPLE,
-    DEBUG_SYS_MSG,
-    PLAN,
-    PREV_CODE_CONTEXT,
-    PREV_CODE_CONTEXT_WITH_REFLECTION,
-    TEST,
-    USER_REQ_CONTEXT,
-    USER_REQ_SUBTASK_CONTEXT,
-    USER_REQ_SUBTASK_WM_CONTEXT,
-)
-from vision_agent.llm import LLM, OpenAILLM
-from vision_agent.tools import TOOL_DESCRIPTIONS, TOOLS_DF
-from vision_agent.utils import CodeInterpreter, CodeInterpreterFactory, Execution, Sim
-
-logging.basicConfig(level=logging.INFO)
-_LOGGER = logging.getLogger(__name__)
-_MAX_TABULATE_COL_WIDTH = 80
-_EXECUTE = CodeInterpreterFactory.get_default_instance()
-_CONSOLE = Console()
-
-
-def build_working_memory(working_memory: Mapping[str, List[str]]) -> Sim:
-    data: Mapping[str, List[str]] = {"desc": [], "doc": []}
-    for key, value in working_memory.items():
-        data["desc"].append(key)
-        data["doc"].append("\n".join(value))
-    df = pd.DataFrame(data)  # type: ignore
-    return Sim(df, sim_key="desc")
-
-
-def extract_code(code: str) -> str:
-    if "```python" in code:
-        code = code[code.find("```python") + len("```python") :]
-        code = code[: code.find("```")]
-    if code.startswith("python\n"):
-        code = code[len("python\n") :]
-    return code
-
-
-def extract_json(json_str: str) -> Dict[str, Any]:
-    try:
-        json_dict = json.loads(json_str)
-    except json.JSONDecodeError:
-        if "```json" in json_str:
-            json_str = json_str[json_str.find("```json") + len("```json") :]
-            json_str = json_str[: json_str.find("```")]
-        elif "```" in json_str:
-            json_str = json_str[json_str.find("```") + len("```") :]
-            # get the last ``` not one from an intermediate string
-            json_str = json_str[: json_str.find("}```")]
-        json_dict = json.loads(json_str)
-    return json_dict  # type: ignore
-
-
-@traceable(name="planning")
-def write_plan(
-    chat: List[Dict[str, str]],
-    plan: Optional[List[Dict[str, Any]]],
-    tool_desc: str,
-    model: LLM,
-) -> Tuple[str, List[Dict[str, Any]]]:
-    # Get last user request
-    if chat[-1]["role"] != "user":
-        raise ValueError("Last chat message must be from the user.")
-    user_requirements = chat[-1]["content"]
-
-    context = USER_REQ_CONTEXT.format(user_requirement=user_requirements)
-    prompt = PLAN.format(context=context, plan=str(plan), tool_desc=tool_desc)
-    chat[-1]["content"] = prompt
-    new_plan = extract_json(model.chat(chat))
-    return new_plan["user_req"], new_plan["plan"]
-
-
-def write_code(
-    user_req: str,
-    subtask: str,
-    working_memory: str,
-    tool_info: str,
-    code: str,
-    model: LLM,
-) -> str:
-    prompt = CODE.format(
-        context=USER_REQ_SUBTASK_WM_CONTEXT.format(
-            user_requirement=user_req, working_memory=working_memory, subtask=subtask
-        ),
-        tool_info=tool_info,
-        code=code,
-    )
-    messages = [
-        {"role": "system", "content": CODE_SYS_MSG},
-        {"role": "user", "content": prompt},
-    ]
-    code = model.chat(messages)
-    return extract_code(code)
-
-
-def write_test(
-    user_req: str, subtask: str, tool_info: str, _: str, code: str, model: LLM
-) -> str:
-    prompt = TEST.format(
-        context=USER_REQ_SUBTASK_CONTEXT.format(
-            user_requirement=user_req, subtask=subtask
-        ),
-        tool_info=tool_info,
-        code=code,
-    )
-    messages = [
-        {"role": "system", "content": CODE_SYS_MSG},
-        {"role": "user", "content": prompt},
-    ]
-    code = model.chat(messages)
-    return extract_code(code)
-
-
-def debug_code(
-    user_req: str,
-    subtask: str,
-    retrieved_ltm: str,
-    working_memory: str,
-    model: LLM,
-) -> Tuple[str, str]:
-    # Make debug model output JSON
-    if hasattr(model, "kwargs"):
-        model.kwargs["response_format"] = {"type": "json_object"}
-    prompt = DEBUG.format(
-        debug_example=DEBUG_EXAMPLE,
-        context=USER_REQ_SUBTASK_WM_CONTEXT.format(
-            user_requirement=user_req,
-            subtask=subtask,
-            working_memory=retrieved_ltm,
-        ),
-        previous_impl=working_memory,
-    )
-    messages = [
-        {"role": "system", "content": DEBUG_SYS_MSG},
-        {"role": "user", "content": prompt},
-    ]
-    code_and_ref = extract_json(model.chat(messages))
-    if hasattr(model, "kwargs"):
-        del model.kwargs["response_format"]
-    return extract_code(code_and_ref["improved_impl"]), code_and_ref["reflection"]
-
-
-def write_and_exec_code(
-    user_req: str,
-    subtask: str,
-    orig_code: str,
-    code_writer_call: Callable[..., str],
-    model: LLM,
-    tool_info: str,
-    exec: CodeInterpreter,
-    retrieved_ltm: str,
-    log_progress: Callable[[Dict[str, Any]], None],
-    max_retry: int = 3,
-    verbosity: int = 0,
-) -> Tuple[bool, str, Execution, Dict[str, List[str]]]:
-    success = False
-    counter = 0
-    reflection = ""
-
-    code = code_writer_call(
-        user_req, subtask, retrieved_ltm, tool_info, orig_code, model
-    )
-    result = exec.exec_isolation(code)
-    success = result.success
-    if verbosity == 2:
-        _CONSOLE.print(Syntax(code, "python", theme="gruvbox-dark", line_numbers=True))
-        log_progress(
-            {
-                "log": f"Code success: {success}",
-            }
-        )
-        log_progress(
-            {
-                "log": "Code:",
-                "code": code,
-            }
-        )
-        log_progress(
-            {
-                "log": "Result:",
-                "result": result.to_json(),
-            }
-        )
-        _LOGGER.info(f"\tCode success: {success}, result: {result.text(False)}")
-    working_memory: Dict[str, List[str]] = {}
-    while not success and counter < max_retry:
-        if subtask not in working_memory:
-            working_memory[subtask] = []
-
-        if reflection:
-            working_memory[subtask].append(
-                PREV_CODE_CONTEXT_WITH_REFLECTION.format(
-                    code=code, result=result, reflection=reflection
-                )
-            )
-        else:
-            working_memory[subtask].append(
-                PREV_CODE_CONTEXT.format(code=code, result=result.text())
-            )
-
-        code, reflection = debug_code(
-            user_req, subtask, retrieved_ltm, "\n".join(working_memory[subtask]), model
-        )
-        result = exec.exec_isolation(code)
-        counter += 1
-        if verbosity == 2:
-            _CONSOLE.print(
-                Syntax(code, "python", theme="gruvbox-dark", line_numbers=True)
-            )
-            log_progress(
-                {
-                    "log": "Debugging reflection:",
-                    "reflection": reflection,
-                }
-            )
-            log_progress(
-                {
-                    "log": "Result:",
-                    "result": result.to_json(),
-                }
-            )
-            _LOGGER.info(
-                f"\tDebugging reflection: {reflection}, result: {result.text(False)}"
-            )
-
-        if success:
-            working_memory[subtask].append(
-                PREV_CODE_CONTEXT_WITH_REFLECTION.format(
-                    reflection=reflection, code=code, result=result.text()
-                )
-            )
-
-    return result.success, code, result, working_memory
-
-
-@traceable(name="plan execution")
-def run_plan(
-    user_req: str,
-    plan: List[Dict[str, Any]],
-    coder: LLM,
-    exec: CodeInterpreter,
-    code: str,
-    tool_recommender: Sim,
-    log_progress: Callable[[Dict[str, Any]], None],
-    long_term_memory: Optional[Sim] = None,
-    verbosity: int = 0,
-) -> Tuple[str, str, List[Dict[str, Any]], Dict[str, List[str]]]:
-    active_plan = [e for e in plan if "success" not in e or not e["success"]]
-    current_code = code
-    current_test = ""
-    retrieved_ltm = ""
-    working_memory: Dict[str, List[str]] = {}
-
-    for task in active_plan:
-        log_progress(
-            {"log": "Going to run the following task(s) in sequence:", "task": task}
-        )
-        _LOGGER.info(
-            f"""
-{tabulate(tabular_data=[task], headers="keys", tablefmt="mixed_grid", maxcolwidths=_MAX_TABULATE_COL_WIDTH)}"""
-        )
-        tools = tool_recommender.top_k(task["instruction"], thresh=0.3)
-        tool_info = "\n".join([e["doc"] for e in tools])
-
-        if verbosity == 2:
-            log_progress({"log": f"Tools retrieved: {[e['desc'] for e in tools]}"})
-            _LOGGER.info(f"Tools retrieved: {[e['desc'] for e in tools]}")
-
-        if long_term_memory is not None:
-            retrieved_ltm = "\n".join(
-                [e["doc"] for e in long_term_memory.top_k(task["instruction"], 1)]
-            )
-
-        success, code, result, working_memory_i = write_and_exec_code(
-            user_req,
-            task["instruction"],
-            current_code,
-            write_code if task["type"] == "code" else write_test,
-            coder,
-            tool_info,
-            exec,
-            retrieved_ltm,
-            log_progress,
-            verbosity=verbosity,
-        )
-        if task["type"] == "code":
-            current_code = code
-        else:
-            current_test = code
-
-        working_memory.update(working_memory_i)
-
-        if verbosity == 1:
-            _CONSOLE.print(
-                Syntax(code, "python", theme="gruvbox-dark", line_numbers=True)
-            )
-
-        log_progress(
-            {
-                "log": f"Code success: {success}",
-            }
-        )
-        log_progress(
-            {
-                "log": "Result:",
-                "result": result.to_json(),
-            }
-        )
-        _LOGGER.info(f"\tCode success: {success} result: {result.text(False)}")
-
-        task["success"] = success
-        task["result"] = result
-        task["code"] = code
-
-        if not success:
-            break
-
-    return current_code, current_test, plan, working_memory
-
-
-class DataInterpreter(Agent):
-    """This version of Data Interpreter is an AI agentic framework geared towards
-    outputting Python code to solve vision tasks. It is inspired by MetaGPT's Data
-    Interpreter https://arxiv.org/abs/2402.18679. This version of Data Interpreter has
-    several key features to help it generate code:
-
-    - A planner to generate a plan of tasks to solve a user requirement. The planner
-    can output code tasks or test tasks, where test tasks are used to verify the code.
-    - Automatic debugging, if a task fails, the agent will attempt to debug the code
-    using the failed output to fix it.
-    - A tool recommender to recommend tools to use for a given task. LLM performance
-    on tool retrieval starts to decrease as you add more tools, tool retrieval helps
-    keep the number of tools to choose from low.
-    - Memory retrieval, the agent can remember previous iterations on tasks to help it
-    with new tasks.
-    - Dynamic replanning, the agent can ask for feedback and replan remaining tasks
-    based off of that feedback.
-    """
-
-    def __init__(
-        self,
-        timeout: int = 600,
-        tool_recommender: Optional[Sim] = None,
-        long_term_memory: Optional[Sim] = None,
-        verbosity: int = 0,
-        report_progress_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
-    ) -> None:
-        self.planner = OpenAILLM(temperature=0.0, json_mode=True)
-        self.coder = OpenAILLM(temperature=0.0)
-        self.exec = _EXECUTE
-        self.report_progress_callback = report_progress_callback
-        if tool_recommender is None:
-            self.tool_recommender = Sim(TOOLS_DF, sim_key="desc")
-        else:
-            self.tool_recommender = tool_recommender
-        self.verbosity = verbosity
-        self._working_memory: Dict[str, List[str]] = {}
-        if long_term_memory is not None:
-            if "doc" not in long_term_memory.df.columns:
-                raise ValueError("Long term memory must have a 'doc' column.")
-        self.long_term_memory = long_term_memory
-        self.max_retries = 3
-        if self.verbosity:
-            _LOGGER.setLevel(logging.INFO)
-
-    def __call__(
-        self,
-        input: Union[List[Dict[str, str]], str],
-        media: Optional[Union[str, Path]] = None,
-        plan: Optional[List[Dict[str, Any]]] = None,
-    ) -> str:
-        if isinstance(input, str):
-            input = [{"role": "user", "content": input}]
-        results = self.chat_with_workflow(input, media, plan)
-        return results["code"]  # type: ignore
-
-    @traceable
-    def chat_with_workflow(
-        self,
-        chat: List[Dict[str, str]],
-        media: Optional[Union[str, Path]] = None,
-        plan: Optional[List[Dict[str, Any]]] = None,
-    ) -> Dict[str, Any]:
-        if len(chat) == 0:
-            raise ValueError("Input cannot be empty.")
-
-        if media is not None:
-            # append file names to all user messages
-            for chat_i in chat:
-                if chat_i["role"] == "user":
-                    chat_i["content"] += f" Image name {media}"
-
-        working_code = ""
-        if plan is not None:
-            # grab the latest working code from a previous plan
-            for task in plan:
-                if "success" in task and "code" in task and task["success"]:
-                    working_code = task["code"]
-
-        user_req, plan = write_plan(chat, plan, TOOL_DESCRIPTIONS, self.planner)
-        self.log_progress(
-            {
-                "log": "Plans:",
-                "plan": plan,
-            }
-        )
-        _LOGGER.info(
-            f"""Plan:
-{tabulate(tabular_data=plan, headers="keys", tablefmt="mixed_grid", maxcolwidths=_MAX_TABULATE_COL_WIDTH)}"""
-        )
-
-        working_test = ""
-        working_memory: Dict[str, List[str]] = {}
-        success = False
-        retries = 0
-
-        while not success and retries < self.max_retries:
-            working_code, working_test, plan, working_memory_i = run_plan(
-                user_req,
-                plan,
-                self.coder,
-                self.exec,
-                working_code,
-                self.tool_recommender,
-                self.log_progress,
-                self.long_term_memory,
-                self.verbosity,
-            )
-            success = all(
-                task["success"] if "success" in task else False for task in plan
-            )
-            working_memory.update(working_memory_i)
-
-            if not success:
-                # return to user and request feedback
-                break
-
-            retries += 1
-
-        self.log_progress(
-            {
-                "log": f"The Vision Agent V2 has concluded this chat.\nSuccess: {success}",
-                "finished": True,
-            }
-        )
-
-        return {
-            "code": working_code,
-            "test": working_test,
-            "success": success,
-            "working_memory": build_working_memory(working_memory),
-            "plan": plan,
-        }
-
-    def log_progress(self, data: Dict[str, Any]) -> None:
-        if self.report_progress_callback is not None:
-            self.report_progress_callback(data)
-        pass

vision_agent/agent/data_interpreter_prompts.py

@@ -1,186 +0,0 @@
-USER_REQ_CONTEXT = """
-## User Requirement
-{user_requirement}
-"""
-
-USER_REQ_SUBTASK_CONTEXT = """
-## User Requirement
-{user_requirement}
-
-## Current Subtask
-{subtask}
-"""
-
-USER_REQ_SUBTASK_WM_CONTEXT = """
-## User Requirement
-{user_requirement}
-
-## Current Subtask
-{subtask}
-
-## Previous Task
-{working_memory}
-"""
-
-PLAN = """
-# Context
-{context}
-
-# Current Plan
-{plan}
-
-# Tools Available
-{tool_desc}
-
-# Task:
-Based on the context and the tools you have available, write a plan of subtasks to achieve the user request that adhere to the following requirements:
-- For each subtask, you should provide instructions on what to do. Write detailed subtasks, ensure they are large enough to be meaningful, encompassing multiple lines of code.
-- You do not need to have the agent rewrite any tool functionality you already have, you should instead instruct it to utilize one or more of those tools in each subtask.
-- You can have agents either write coding tasks, to code some functionality or testing tasks to test previous functionality.
-- If a current plan exists, examine each item in the plan to determine if it was successful. If there was an item that failed, i.e. 'success': False, then you should rewrite that item and all subsequent items to ensure that the rewritten plan is successful.
-
-Output a list of jsons in the following format:
-
-```json
-{{
-    "user_req": str, # "a summarized version of the user requirement"
-    "plan":
-        [
-            {{
-                "task_id": int, # "unique identifier for a task in plan, can be an ordinal"
-                "dependent_task_ids": list[int], # "ids of tasks prerequisite to this task"
-                "instruction": str, # "what you should do in this task, one short phrase or sentence"
-                "type": str, # "the type of the task, tasks can either be 'code' for coding tasks or 'test' for testing tasks"
-            }},
-            ...
-        ]
-}}
-```
-"""
-
-
-CODE_SYS_MSG = """You are an AI Python assistant. You need to help user to achieve their goal by implementing a function. Your code will be run in a jupyter notebook environment so don't use asyncio.run. Instead, use await if you need to call an async function. Do not use 'display' for showing images, instead use matplotlib or PIL."""
-
-
-CODE = """
-# Context
-{context}
-
-# Tool Info for Current Subtask
-{tool_info}
-
-# Previous Code
-{code}
-
-# Constraints
-- Write a function that accomplishes the 'Current Subtask'. You are supplied code from a previous task under 'Previous Code', do not delete or change previous code unless it contains a bug or it is necessary to complete the 'Current Subtask'.
-- Always prioritize using pre-defined tools or code for the same functionality from 'Tool Info' when working on 'Current Subtask'. You have access to all these tools through the `from vision_agent.tools import *` import.
-- You may recieve previous trials and errors under 'Previous Task', this is code, output and reflections from previous tasks. You can use these to avoid running in to the same issues when writing your code.
-- Use the `save_json` function from `vision_agent.tools` to save your output as a json file.
-- Write clean, readable, and well-documented code.
-
-# Output
-While some concise thoughts are helpful, code is absolutely required. If possible, execute your defined functions in the code output. Output code in the following format:
-```python
-from vision_agent.tools imoprt *
-
-# your code goes here
-```
-"""
-
-
-DEBUG_SYS_MSG = """You are an AI Python assistant. You will be given your previous implementation code of a task, runtime error results, and a hint to change the implementation appropriately. Your code will be run in a jupyter notebook environment. Write your full implementation."""
-
-
-DEBUG_EXAMPLE = '''
-[previous impl]:
-```python
-def add(a: int, b: int) -> int:
-   """Given integers a and b, return the total value of a and b."""
-   return a - b
-```
-
-[previous output]
-Tests failed:
-assert add(1, 2) == 3 # output: -1
-assert add(1, 3) == 4 # output: -2
-
-[reflection on previous impl]:
-The implementation failed the test cases where the input integers are 1 and 2. The issue arises because the code does not add the two integers together, but instead subtracts the second integer from the first. To fix this issue, we should change the operator from `-` to `+` in the return statement. This will ensure that the function returns the correct output for the given input.
-
-[improved impl]:
-def add(a: int, b: int) -> int:
-   """Given integers a and b, return the total value of a and b."""
-   return a + b
-'''
-
-
-PREV_CODE_CONTEXT = """
-[previous impl]
-```python
-{code}
-```
-
-[previous output]
-{result}
-"""
-
-
-PREV_CODE_CONTEXT_WITH_REFLECTION = """
-[reflection on previous impl]
-{reflection}
-
-[new impl]
-```python
-{code}
-```
-
-[new output]
-{result}
-
-"""
-
-# don't need [previous impl] because it will come from PREV_CODE_CONTEXT or PREV_CODE_CONTEXT_WITH_REFLECTION
-DEBUG = """
-[example]
-Here is an example of debugging with reflection.
-{debug_example}
-[/example]
-
-[context]
-{context}
-
-{previous_impl}
-
-[instruction]
-Analyze your previous code and error in [context] step by step, provide me with improved method and code. Remember to follow [context] requirement. Because you are writing code in a jupyter notebook, you can run `!pip install` to install missing packages. Output a json following the format:
-```json
-{{
-    "reflection": str = "Reflection on previous implementation",
-    "improved_impl": str = "Refined code after reflection.",
-}}
-```
-"""
-
-
-TEST = """
-# Context
-{context}
-
-# Tool Info for Current Subtask
-{tool_info}
-
-# Code to Test
-{code}
-
-# Constraints
-- Write code to test the functionality of the provided code according to the 'Current Subtask'. If you cannot test the code, then write code to visualize the result by calling the code.
-- Always prioritize using pre-defined tools for the same functionality.
-- Write clean, readable, and well-documented code.
-
-# Output
-While some concise thoughts are helpful, code is absolutely required. Always output one and only one code block in your response. Output code in the following format:
-```python
-your code
-```
-"""