A programming framework for agentic AI
Add function and code execution (#34)
Jack Gerrits2dc7af87efb0
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.ymlindex df6236d68..5f781d060 100644--- a/.github/workflows/checks.yml+++ b/.github/workflows/checks.yml@@ -55,14 +55,15 @@ jobs:runs-on: ubuntu-lateststrategy:matrix:- python-version: ["pypy3.10", "3.10", "3.11", "3.12"]+ # "pypy3.10" disabled until better example than polars used in tests+ python-version: ["3.10", "3.11", "3.12"]steps:- uses: actions/checkout@v4- uses: actions/setup-python@v5with:python-version: ${{ matrix.python-version }}- run: pip install ".[dev]"- - run: pytest+ - run: pytest -n autodocs:runs-on: ubuntu-latestdiff --git a/pyproject.toml b/pyproject.tomlindex 0ae9b954c..e79ae9535 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -13,11 +13,26 @@ classifiers = ["License :: OSI Approved :: MIT License","Operating System :: OS Independent",]-dependencies = ["openai>=1.3", "pillow", "aiohttp", "typing-extensions"]+dependencies = [+ "openai>=1.3",+ "pillow",+ "aiohttp",+ "typing-extensions",+ "pydantic>=1.10,<3",+][project.optional-dependencies]-dev = ["ruff==0.4.6", "pyright", "mypy", "pytest", "pytest-asyncio", "types-Pillow"]-docs = [ "sphinx", "furo", "sphinxcontrib-apidoc"]+dev = [+ "ruff==0.4.6",+ "pyright",+ "mypy",+ "pytest",+ "pytest-asyncio",+ "pytest-xdist",+ "types-Pillow",+ "polars",+]+docs = ["sphinx", "furo", "sphinxcontrib-apidoc"][tool.setuptools.package-data]agnext = ["py.typed"]@@ -30,9 +45,13 @@ target-version = "py310"include = ["src/**", "examples/**"][tool.ruff.lint]-select = ["E", "F", "W", "B", "Q", "I"]+select = ["E", "F", "W", "B", "Q", "I", "ASYNC"]ignore = ["F401", "E501"]+[tool.ruff.lint.flake8-tidy-imports]+[tool.ruff.lint.flake8-tidy-imports.banned-api]+"unittest".msg = "Use `pytest` instead."+[tool.mypy]files = ["src", "examples", "tests"]diff --git a/src/agnext/agent_components/code_executor/__init__.py b/src/agnext/agent_components/code_executor/__init__.pynew file mode 100644index 000000000..5df725747--- /dev/null+++ b/src/agnext/agent_components/code_executor/__init__.py@@ -0,0 +1,14 @@+from ._base import CodeBlock, CodeExecutor, CodeExtractor, CodeResult+from ._impl.command_line_code_result import CommandLineCodeResult+from ._impl.local_commandline_code_executor import LocalCommandLineCodeExecutor+from ._impl.markdown_code_extractor import MarkdownCodeExtractor++__all__ = [+ "LocalCommandLineCodeExecutor",+ "MarkdownCodeExtractor",+ "CommandLineCodeResult",+ "CodeBlock",+ "CodeResult",+ "CodeExecutor",+ "CodeExtractor",+]diff --git a/src/agnext/agent_components/code_executor/_base.py b/src/agnext/agent_components/code_executor/_base.pynew file mode 100644index 000000000..46fabb3f3--- /dev/null+++ b/src/agnext/agent_components/code_executor/_base.py@@ -0,0 +1,66 @@+# File based from: https://github.com/microsoft/autogen/blob/main/autogen/coding/base.py+# Credit to original authors++from __future__ import annotations++from dataclasses import dataclass+from typing import List, Protocol, runtime_checkable+++@dataclass+class CodeBlock:+ """A code block extracted fromm an agent message."""++ code: str+ language: str+++@dataclass+class CodeResult:+ """Result of a code execution."""++ exit_code: int+ output: str+++class CodeExtractor(Protocol):+ """Extracts code blocks from a message."""++ # TODO support text or multimodal message directly+ def extract_code_blocks(self, message: str) -> List[CodeBlock]:+ """Extract code blocks from a message.++ Args:+ message (str): The message to extract code blocks from.++ Returns:+ List[CodeBlock]: The extracted code blocks.+ """+ ...+++@runtime_checkable+class CodeExecutor(Protocol):+ """Executes code blocks and returns the result."""++ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult:+ """Execute code blocks and return the result.++ This method should be implemented by the code executor.++ Args:+ code_blocks (List[CodeBlock]): The code blocks to execute.++ Returns:+ CodeResult: The result of the code execution.+ """+ ...++ def restart(self) -> None:+ """Restart the code executor.++ This method should be implemented by the code executor.++ This method is called when the agent is reset.+ """+ ...diff --git a/src/agnext/agent_components/code_executor/_impl/__init__.py b/src/agnext/agent_components/code_executor/_impl/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/src/agnext/agent_components/code_executor/_impl/command_line_code_result.py b/src/agnext/agent_components/code_executor/_impl/command_line_code_result.pynew file mode 100644index 000000000..cafc73f14--- /dev/null+++ b/src/agnext/agent_components/code_executor/_impl/command_line_code_result.py@@ -0,0 +1,11 @@+from dataclasses import dataclass+from typing import Optional++from .._base import CodeResult+++@dataclass+class CommandLineCodeResult(CodeResult):+ """A code result class for command line code executor."""++ code_file: Optional[str]diff --git a/src/agnext/agent_components/code_executor/_impl/local_commandline_code_executor.py b/src/agnext/agent_components/code_executor/_impl/local_commandline_code_executor.pynew file mode 100644index 000000000..927395732--- /dev/null+++ b/src/agnext/agent_components/code_executor/_impl/local_commandline_code_executor.py@@ -0,0 +1,272 @@+# File based from: https://github.com/microsoft/autogen/blob/main/autogen/coding/local_commandline_code_executor.py+# Credit to original authors++import logging+import re+import subprocess+import sys+import warnings+from hashlib import md5+from pathlib import Path+from string import Template+from typing import Any, Callable, ClassVar, List, Sequence, Union++from typing_extensions import ParamSpec++from ...func_with_reqs import (+ FunctionWithRequirements,+ FunctionWithRequirementsStr,+ build_python_functions_file,+ to_stub,+)+from .._base import CodeBlock, CodeExecutor, CodeExtractor+from .command_line_code_result import CommandLineCodeResult+from .markdown_code_extractor import MarkdownCodeExtractor+from .utils import PYTHON_VARIANTS, get_file_name_from_content, lang_to_cmd, silence_pip # type: ignore++__all__ = ("LocalCommandLineCodeExecutor",)++A = ParamSpec("A")+++class LocalCommandLineCodeExecutor(CodeExecutor):+ SUPPORTED_LANGUAGES: ClassVar[List[str]] = ["bash", "shell", "sh", "pwsh", "powershell", "ps1", "python"]+ FUNCTION_PROMPT_TEMPLATE: ClassVar[+ str+ ] = """You have access to the following user defined functions. They can be accessed from the module called `$module_name` by their function names.++For example, if there was a function called `foo` you could import it by writing `from $module_name import foo`++$functions"""++ def __init__(+ self,+ timeout: int = 60,+ work_dir: Union[Path, str] = Path("."),+ functions: Sequence[+ Union[FunctionWithRequirements[Any, A], Callable[..., Any], FunctionWithRequirementsStr]+ ] = [],+ functions_module: str = "functions",+ ):+ """(Experimental) A code executor class that executes code through a local command line+ environment.++ **This will execute LLM generated code on the local machine.**++ Each code block is saved as a file and executed in a separate process in+ the working directory, and a unique file is generated and saved in the+ working directory for each code block.+ The code blocks are executed in the order they are received.+ Command line code is sanitized using regular expression match against a list of dangerous commands in order to prevent self-destructive+ commands from being executed which may potentially affect the users environment.+ Currently the only supported languages is Python and shell scripts.+ For Python code, use the language "python" for the code block.+ For shell scripts, use the language "bash", "shell", or "sh" for the code+ block.++ Args:+ timeout (int): The timeout for code execution. Default is 60.+ work_dir (str): The working directory for the code execution. If None,+ a default working directory will be used. The default working+ directory is the current directory ".".+ functions (List[Union[FunctionWithRequirements[Any, A], Callable[..., Any]]]): A list of functions that are available to the code executor. Default is an empty list.+ """++ if timeout < 1:+ raise ValueError("Timeout must be greater than or equal to 1.")++ if isinstance(work_dir, str):+ work_dir = Path(work_dir)++ if not functions_module.isidentifier():+ raise ValueError("Module name must be a valid Python identifier")++ self._functions_module = functions_module++ work_dir.mkdir(exist_ok=True)++ self._timeout = timeout+ self._work_dir: Path = work_dir++ self._functions = functions+ # Setup could take some time so we intentionally wait for the first code block to do it.+ if len(functions) > 0:+ self._setup_functions_complete = False+ else:+ self._setup_functions_complete = True++ def format_functions_for_prompt(self, prompt_template: str = FUNCTION_PROMPT_TEMPLATE) -> str:+ """(Experimental) Format the functions for a prompt.++ The template includes two variables:+ - `$module_name`: The module name.+ - `$functions`: The functions formatted as stubs with two newlines between each function.++ Args:+ prompt_template (str): The prompt template. Default is the class default.++ Returns:+ str: The formatted prompt.+ """++ template = Template(prompt_template)+ return template.substitute(+ module_name=self._functions_module,+ functions="\n\n".join([to_stub(func) for func in self._functions]),+ )++ @property+ def functions_module(self) -> str:+ """(Experimental) The module name for the functions."""+ return self._functions_module++ @property+ def functions(self) -> List[str]:+ raise NotImplementedError++ @property+ def timeout(self) -> int:+ """(Experimental) The timeout for code execution."""+ return self._timeout++ @property+ def work_dir(self) -> Path:+ """(Experimental) The working directory for the code execution."""+ return self._work_dir++ @property+ def code_extractor(self) -> CodeExtractor:+ """(Experimental) Export a code extractor that can be used by an agent."""+ return MarkdownCodeExtractor()++ @staticmethod+ def sanitize_command(lang: str, code: str) -> None:+ """+ Sanitize the code block to prevent dangerous commands.+ This approach acknowledges that while Docker or similar+ containerization/sandboxing technologies provide a robust layer of security,+ not all users may have Docker installed or may choose not to use it.+ Therefore, having a baseline level of protection helps mitigate risks for users who,+ either out of choice or necessity, run code outside of a sandboxed environment.+ """+ dangerous_patterns = [+ (r"\brm\s+-rf\b", "Use of 'rm -rf' command is not allowed."),+ (r"\bmv\b.*?\s+/dev/null", "Moving files to /dev/null is not allowed."),+ (r"\bdd\b", "Use of 'dd' command is not allowed."),+ (r">\s*/dev/sd[a-z][1-9]?", "Overwriting disk blocks directly is not allowed."),+ (r":\(\)\{\s*:\|\:&\s*\};:", "Fork bombs are not allowed."),+ ]+ if lang in ["bash", "shell", "sh"]:+ for pattern, message in dangerous_patterns:+ if re.search(pattern, code):+ raise ValueError(f"Potentially dangerous command detected: {message}")++ def _setup_functions(self) -> None:+ func_file_content = build_python_functions_file(self._functions)+ func_file = self._work_dir / f"{self._functions_module}.py"+ func_file.write_text(func_file_content)++ # Collect requirements+ lists_of_packages = [x.python_packages for x in self._functions if isinstance(x, FunctionWithRequirements)]+ flattened_packages = [item for sublist in lists_of_packages for item in sublist]+ required_packages = list(set(flattened_packages))+ if len(required_packages) > 0:+ logging.info("Ensuring packages are installed in executor.")++ cmd = [sys.executable, "-m", "pip", "install"]+ cmd.extend(required_packages)++ try:+ result = subprocess.run(+ cmd, cwd=self._work_dir, capture_output=True, text=True, timeout=float(self._timeout)+ )+ except subprocess.TimeoutExpired as e:+ raise ValueError("Pip install timed out") from e++ if result.returncode != 0:+ raise ValueError(f"Pip install failed. {result.stdout}, {result.stderr}")++ # Attempt to load the function file to check for syntax errors, imports etc.+ exec_result = self._execute_code_dont_check_setup([CodeBlock(code=func_file_content, language="python")])++ if exec_result.exit_code != 0:+ raise ValueError(f"Functions failed to load: {exec_result.output}")++ self._setup_functions_complete = True++ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CommandLineCodeResult:+ """(Experimental) Execute the code blocks and return the result.++ Args:+ code_blocks (List[CodeBlock]): The code blocks to execute.++ Returns:+ CommandLineCodeResult: The result of the code execution."""++ if not self._setup_functions_complete:+ self._setup_functions()++ return self._execute_code_dont_check_setup(code_blocks)++ def _execute_code_dont_check_setup(self, code_blocks: List[CodeBlock]) -> CommandLineCodeResult:+ logs_all: str = ""+ file_names: List[Path] = []+ exitcode = 0+ for code_block in code_blocks:+ lang, code = code_block.language, code_block.code+ lang = lang.lower()++ LocalCommandLineCodeExecutor.sanitize_command(lang, code)+ code = silence_pip(code, lang)++ if lang in PYTHON_VARIANTS:+ lang = "python"++ if lang not in self.SUPPORTED_LANGUAGES:+ # In case the language is not supported, we return an error message.+ exitcode = 1+ logs_all += "\n" + f"unknown language {lang}"+ break++ try:+ # Check if there is a filename comment+ filename = get_file_name_from_content(code, self._work_dir)+ except ValueError:+ return CommandLineCodeResult(exit_code=1, output="Filename is not in the workspace", code_file=None)++ if filename is None:+ # create a file with an automatically generated name+ code_hash = md5(code.encode()).hexdigest()+ filename = f"tmp_code_{code_hash}.{'py' if lang.startswith('python') else lang}"++ written_file = (self._work_dir / filename).resolve()+ with written_file.open("w", encoding="utf-8") as f:+ f.write(code)+ file_names.append(written_file)++ program = sys.executable if lang.startswith("python") else lang_to_cmd(lang)+ cmd = [program, str(written_file.absolute())]++ try:+ result = subprocess.run(+ cmd, cwd=self._work_dir, capture_output=True, text=True, timeout=float(self._timeout)+ )+ except subprocess.TimeoutExpired:+ logs_all += "\n Timeout"+ # Same exit code as the timeout command on linux.+ exitcode = 124+ break++ logs_all += result.stderr+ logs_all += result.stdout+ exitcode = result.returncode++ if exitcode != 0:+ break++ code_file = str(file_names[0]) if len(file_names) > 0 else None+ return CommandLineCodeResult(exit_code=exitcode, output=logs_all, code_file=code_file)++ def restart(self) -> None:+ """(Experimental) Restart the code executor."""+ warnings.warn("Restarting local command line code executor is not supported. No action is taken.", stacklevel=2)diff --git a/src/agnext/agent_components/code_executor/_impl/markdown_code_extractor.py b/src/agnext/agent_components/code_executor/_impl/markdown_code_extractor.pynew file mode 100644index 000000000..18239ecd6--- /dev/null+++ b/src/agnext/agent_components/code_executor/_impl/markdown_code_extractor.py@@ -0,0 +1,37 @@+# File based from: https://github.com/microsoft/autogen/blob/main/autogen/coding/markdown_code_extractor.py+# Credit to original authors++import re+from typing import List++from .._base import CodeBlock, CodeExtractor+from .utils import CODE_BLOCK_PATTERN, infer_lang++__all__ = ("MarkdownCodeExtractor",)+++class MarkdownCodeExtractor(CodeExtractor):+ """(Experimental) A class that extracts code blocks from a message using Markdown syntax."""++ def extract_code_blocks(self, message: str) -> List[CodeBlock]:+ """(Experimental) Extract code blocks from a message. If no code blocks are found,+ return an empty list.++ Args:+ message (str): The message to extract code blocks from.++ Returns:+ List[CodeBlock]: The extracted code blocks or an empty list.+ """++ match = re.findall(CODE_BLOCK_PATTERN, message, flags=re.DOTALL)+ if not match:+ return []+ code_blocks: List[CodeBlock] = []+ for lang, code in match:+ if lang == "":+ lang = infer_lang(code)+ if lang == "unknown":+ lang = ""+ code_blocks.append(CodeBlock(code=code, language=lang))+ return code_blocksdiff --git a/src/agnext/agent_components/code_executor/_impl/utils.py b/src/agnext/agent_components/code_executor/_impl/utils.pynew file mode 100644index 000000000..3fc39054a--- /dev/null+++ b/src/agnext/agent_components/code_executor/_impl/utils.py@@ -0,0 +1,88 @@+# File based from: https://github.com/microsoft/autogen/blob/main/autogen/coding/utils.py+# Credit to original authors++# Will return the filename relative to the workspace path+import re+from pathlib import Path+from typing import Optional+++# Raises ValueError if the file is not in the workspace+def get_file_name_from_content(code: str, workspace_path: Path) -> Optional[str]:+ first_line = code.split("\n")[0]+ # TODO - support other languages+ if first_line.startswith("# filename:"):+ filename = first_line.split(":")[1].strip()++ # Handle relative paths in the filename+ path = Path(filename)+ if not path.is_absolute():+ path = workspace_path / path+ path = path.resolve()+ # Throws an error if the file is not in the workspace+ relative = path.relative_to(workspace_path.resolve())+ return str(relative)++ return None+++def silence_pip(code: str, lang: str) -> str:+ """Apply -qqq flag to pip install commands."""+ if lang == "python":+ regex = r"^! ?pip install"+ elif lang in ["bash", "shell", "sh", "pwsh", "powershell", "ps1"]:+ regex = r"^pip install"+ else:+ return code++ # Find lines that start with pip install and make sure "-qqq" flag is added.+ lines = code.split("\n")+ for i, line in enumerate(lines):+ # use regex to find lines that start with pip install.+ match = re.search(regex, line)+ if match is not None:+ if "-qqq" not in line:+ lines[i] = line.replace(match.group(0), match.group(0) + " -qqq")+ return "\n".join(lines)+++PYTHON_VARIANTS = ["python", "Python", "py"]+++def lang_to_cmd(lang: str) -> str:+ if lang in PYTHON_VARIANTS:+ return "python"+ if lang.startswith("python") or lang in ["bash", "sh"]:+ return lang+ if lang in ["shell"]:+ return "sh"+ else:+ raise ValueError(f"Unsupported language: {lang}")+++# Regular expression for finding a code block+# ```[ \t]*(\w+)?[ \t]*\r?\n(.*?)[ \t]*\r?\n``` Matches multi-line code blocks.+# The [ \t]* matches the potential spaces before language name.+# The (\w+)? matches the language, where the ? indicates it is optional.+# The [ \t]* matches the potential spaces (not newlines) after language name.+# The \r?\n makes sure there is a linebreak after ```.+# The (.*?) matches the code itself (non-greedy).+# The \r?\n makes sure there is a linebreak before ```.+# The [ \t]* matches the potential spaces before closing ``` (the spec allows indentation).+CODE_BLOCK_PATTERN = r"```[ \t]*(\w+)?[ \t]*\r?\n(.*?)\r?\n[ \t]*```"+++def infer_lang(code: str) -> str:+ """infer the language for the code.+ TODO: make it robust.+ """+ if code.startswith("python ") or code.startswith("pip") or code.startswith("python3 "):+ return "sh"++ # check if code is a valid python code+ try:+ compile(code, "test", "exec")+ return "python"+ except SyntaxError:+ # not a valid python code+ return "unknown"diff --git a/src/agnext/agent_components/func_with_reqs.py b/src/agnext/agent_components/func_with_reqs.pynew file mode 100644index 000000000..1ef01cedd--- /dev/null+++ b/src/agnext/agent_components/func_with_reqs.py@@ -0,0 +1,200 @@+# File based from: https://github.com/microsoft/autogen/blob/main/autogen/coding/func_with_reqs.py+# Credit to original authors++from __future__ import annotations++import functools+import inspect+from dataclasses import dataclass, field+from importlib.abc import SourceLoader+from importlib.util import module_from_spec, spec_from_loader+from textwrap import dedent, indent+from typing import Any, Callable, Generic, List, Sequence, Set, TypeVar, Union++from typing_extensions import ParamSpec++T = TypeVar("T")+P = ParamSpec("P")+++def _to_code(func: Union[FunctionWithRequirements[T, P], Callable[P, T], FunctionWithRequirementsStr]) -> str:+ if isinstance(func, FunctionWithRequirementsStr):+ return func.func++ code = inspect.getsource(func)+ # Strip the decorator+ if code.startswith("@"):+ code = code[code.index("\n") + 1 :]+ return code+++@dataclass+class Alias:+ name: str+ alias: str+++@dataclass+class ImportFromModule:+ module: str+ imports: List[Union[str, Alias]]+++Import = Union[str, ImportFromModule, Alias]+++def _import_to_str(im: Import) -> str:+ if isinstance(im, str):+ return f"import {im}"+ elif isinstance(im, Alias):+ return f"import {im.name} as {im.alias}"+ else:++ def to_str(i: Union[str, Alias]) -> str:+ if isinstance(i, str):+ return i+ else:+ return f"{i.name} as {i.alias}"++ imports = ", ".join(map(to_str, im.imports))+ return f"from {im.module} import {imports}"+++class _StringLoader(SourceLoader):+ def __init__(self, data: str):+ self.data = data++ def get_source(self, fullname: str) -> str:+ return self.data++ def get_data(self, path: str) -> bytes:+ return self.data.encode("utf-8")++ def get_filename(self, fullname: str) -> str:+ return "<not a real path>/" + fullname + ".py"+++@dataclass+class FunctionWithRequirementsStr:+ func: str+ compiled_func: Callable[..., Any]+ _func_name: str+ python_packages: Sequence[str] = field(default_factory=list)+ global_imports: Sequence[Import] = field(default_factory=list)++ def __init__(self, func: str, python_packages: Sequence[str] = [], global_imports: Sequence[Import] = []):+ self.func = func+ self.python_packages = python_packages+ self.global_imports = global_imports++ module_name = "func_module"+ loader = _StringLoader(func)+ spec = spec_from_loader(module_name, loader)+ if spec is None:+ raise ValueError("Could not create spec")+ module = module_from_spec(spec)+ if spec.loader is None:+ raise ValueError("Could not create loader")++ try:+ spec.loader.exec_module(module)+ except Exception as e:+ raise ValueError(f"Could not compile function: {e}") from e++ functions = inspect.getmembers(module, inspect.isfunction)+ if len(functions) != 1:+ raise ValueError("The string must contain exactly one function")++ self._func_name, self.compiled_func = functions[0]++ def __call__(self, *args: Any, **kwargs: Any) -> None:+ raise NotImplementedError("String based function with requirement objects are not directly callable")+++@dataclass+class FunctionWithRequirements(Generic[T, P]):+ func: Callable[P, T]+ python_packages: Sequence[str] = field(default_factory=list)+ global_imports: Sequence[Import] = field(default_factory=list)++ @classmethod+ def from_callable(+ cls, func: Callable[P, T], python_packages: Sequence[str] = [], global_imports: Sequence[Import] = []+ ) -> FunctionWithRequirements[T, P]:+ return cls(python_packages=python_packages, global_imports=global_imports, func=func)++ @staticmethod+ def from_str(+ func: str, python_packages: Sequence[str] = [], global_imports: Sequence[Import] = []+ ) -> FunctionWithRequirementsStr:+ return FunctionWithRequirementsStr(func=func, python_packages=python_packages, global_imports=global_imports)++ # Type this based on F+ def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:+ return self.func(*args, **kwargs)+++def with_requirements(+ python_packages: Sequence[str] = [], global_imports: Sequence[Import] = []+) -> Callable[[Callable[P, T]], FunctionWithRequirements[T, P]]:+ """Decorate a function with package and import requirements++ Args:+ python_packages (List[str], optional): Packages required to function. Can include version info.. Defaults to [].+ global_imports (List[Import], optional): Required imports. Defaults to [].++ Returns:+ Callable[[Callable[P, T]], FunctionWithRequirements[T, P]]: The decorated function+ """++ def wrapper(func: Callable[P, T]) -> FunctionWithRequirements[T, P]:+ func_with_reqs = FunctionWithRequirements(+ python_packages=python_packages, global_imports=global_imports, func=func+ )++ functools.update_wrapper(func_with_reqs, func)+ return func_with_reqs++ return wrapper+++def build_python_functions_file(+ funcs: Sequence[Union[FunctionWithRequirements[Any, P], Callable[..., Any], FunctionWithRequirementsStr]],+) -> str:+ # First collect all global imports+ global_imports: Set[Import] = set()+ for func in funcs:+ if isinstance(func, (FunctionWithRequirements, FunctionWithRequirementsStr)):+ global_imports.update(func.global_imports)++ content = "\n".join(map(_import_to_str, global_imports)) + "\n\n"++ for func in funcs:+ content += _to_code(func) + "\n\n"++ return content+++def to_stub(func: Union[Callable[..., Any], FunctionWithRequirementsStr]) -> str:+ """Generate a stub for a function as a string++ Args:+ func (Callable[..., Any]): The function to generate a stub for++ Returns:+ str: The stub for the function+ """+ if isinstance(func, FunctionWithRequirementsStr):+ return to_stub(func.compiled_func)++ content = f"def {func.__name__}{inspect.signature(func)}:\n"+ docstring = func.__doc__++ if docstring:+ docstring = dedent(docstring)+ docstring = '"""' + docstring + '"""'+ docstring = indent(docstring, " ")+ content += docstring + "\n"++ content += " ..."+ return contentdiff --git a/src/agnext/agent_components/function_executor/__init__.py b/src/agnext/agent_components/function_executor/__init__.pynew file mode 100644index 000000000..7c3a41bd8--- /dev/null+++ b/src/agnext/agent_components/function_executor/__init__.py@@ -0,0 +1,4 @@+from ._base import FunctionExecutor, FunctionInfo, into_function_definition+from ._impl.in_process_function_executor import InProcessFunctionExecutor++__all__ = ["FunctionExecutor", "FunctionInfo", "into_function_definition", "InProcessFunctionExecutor"]diff --git a/src/agnext/agent_components/function_executor/_base.py b/src/agnext/agent_components/function_executor/_base.pynew file mode 100644index 000000000..afad5d6b7--- /dev/null+++ b/src/agnext/agent_components/function_executor/_base.py@@ -0,0 +1,36 @@+from collections.abc import Sequence+from typing import Any, Callable, Dict, Protocol, TypedDict, Union, runtime_checkable++from typing_extensions import NotRequired, Required++from ..function_utils import get_function_schema+from ..types import FunctionDefinition+++@runtime_checkable+class FunctionExecutor(Protocol):+ async def execute_function(self, function_name: str, arguments: Dict[str, Any]) -> str: ...++ @property+ def functions(self) -> Sequence[str]: ...+++class FunctionInfo(TypedDict):+ func: Required[Callable[..., Any]]+ name: NotRequired[str]+ description: NotRequired[str]+++def into_function_definition(+ func_info: Union[FunctionInfo, FunctionDefinition, Callable[..., Any]],+) -> FunctionDefinition:+ if isinstance(func_info, FunctionDefinition):+ return func_info+ elif isinstance(func_info, dict):+ name = func_info.get("name", func_info["func"].__name__)+ description = func_info.get("description", "")+ parameters = get_function_schema(func_info["func"], description="", name="")["function"]["parameters"]+ return FunctionDefinition(name=name, description=description, parameters=parameters)+ else:+ parameters = get_function_schema(func_info, description="", name="")["function"]["parameters"]+ return FunctionDefinition(name=func_info.__name__, description="", parameters=parameters)diff --git a/src/agnext/agent_components/function_executor/_impl/__init__.py b/src/agnext/agent_components/function_executor/_impl/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/src/agnext/agent_components/function_executor/_impl/in_process_function_executor.py b/src/agnext/agent_components/function_executor/_impl/in_process_function_executor.pynew file mode 100644index 000000000..7fddbf601--- /dev/null+++ b/src/agnext/agent_components/function_executor/_impl/in_process_function_executor.py@@ -0,0 +1,40 @@+import asyncio+import functools+from collections.abc import Sequence+from typing import Any, Callable, Union++from .._base import FunctionExecutor, FunctionInfo+++class InProcessFunctionExecutor(FunctionExecutor):+ def __init__(+ self,+ functions: Sequence[Union[Callable[..., Any], FunctionInfo]] = [],+ ) -> None:+ def _name(func: Union[Callable[..., Any], FunctionInfo]) -> str:+ if isinstance(func, dict):+ return func.get("name", func["func"].__name__)+ else:+ return func.__name__++ def _func(func: Union[Callable[..., Any], FunctionInfo]) -> Any:+ if isinstance(func, dict):+ return func.get("func")+ else:+ return func++ self._functions = dict([(_name(x), _func(x)) for x in functions])++ async def execute_function(self, function_name: str, arguments: dict[str, Any]) -> str:+ if function_name in self._functions:+ function = self._functions[function_name]+ if asyncio.iscoroutinefunction(function):+ return str(function(**arguments))+ else:+ return await asyncio.get_event_loop().run_in_executor(None, functools.partial(function, **arguments))++ raise ValueError(f"Function {function_name} not found")++ @property+ def functions(self) -> Sequence[str]:+ return list(self._functions.keys())diff --git a/src/agnext/agent_components/function_utils.py b/src/agnext/agent_components/function_utils.pynew file mode 100644index 000000000..a6e1c7dc0--- /dev/null+++ b/src/agnext/agent_components/function_utils.py@@ -0,0 +1,284 @@+# File based from: https://github.com/microsoft/autogen/blob/main/autogen/function_utils.py+# Credit to original authors++import inspect+from logging import getLogger+from typing import Any, Callable, Dict, ForwardRef, List, Optional, Set, Tuple, Type, TypeVar, Union++from pydantic import BaseModel, Field+from typing_extensions import Annotated, Literal++from .pydantic_compat import evaluate_forwardref, model_dump, type2schema++logger = getLogger(__name__)++T = TypeVar("T")+++def get_typed_annotation(annotation: Any, globalns: Dict[str, Any]) -> Any:+ """Get the type annotation of a parameter.++ Args:+ annotation: The annotation of the parameter+ globalns: The global namespace of the function++ Returns:+ The type annotation of the parameter+ """+ if isinstance(annotation, str):+ annotation = ForwardRef(annotation)+ annotation = evaluate_forwardref(annotation, globalns, globalns)+ return annotation+++def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:+ """Get the signature of a function with type annotations.++ Args:+ call: The function to get the signature for++ Returns:+ The signature of the function with type annotations+ """+ signature = inspect.signature(call)+ globalns = getattr(call, "__globals__", {})+ typed_params = [+ inspect.Parameter(+ name=param.name,+ kind=param.kind,+ default=param.default,+ annotation=get_typed_annotation(param.annotation, globalns),+ )+ for param in signature.parameters.values()+ ]+ typed_signature = inspect.Signature(typed_params)+ return typed_signature+++def get_typed_return_annotation(call: Callable[..., Any]) -> Any:+ """Get the return annotation of a function.++ Args:+ call: The function to get the return annotation for++ Returns:+ The return annotation of the function+ """+ signature = inspect.signature(call)+ annotation = signature.return_annotation++ if annotation is inspect.Signature.empty:+ return None++ globalns = getattr(call, "__globals__", {})+ return get_typed_annotation(annotation, globalns)+++def get_param_annotations(typed_signature: inspect.Signature) -> Dict[str, Union[Annotated[Type[Any], str], Type[Any]]]:+ """Get the type annotations of the parameters of a function++ Args:+ typed_signature: The signature of the function with type annotations++ Returns:+ A dictionary of the type annotations of the parameters of the function+ """+ return {+ k: v.annotation for k, v in typed_signature.parameters.items() if v.annotation is not inspect.Signature.empty+ }+++class Parameters(BaseModel):+ """Parameters of a function as defined by the OpenAI API"""++ type: Literal["object"] = "object"+ properties: Dict[str, Dict[str, Any]]+ required: List[str]+++class Function(BaseModel):+ """A function as defined by the OpenAI API"""++ description: Annotated[str, Field(description="Description of the function")]+ name: Annotated[str, Field(description="Name of the function")]+ parameters: Annotated[Parameters, Field(description="Parameters of the function")]+++class ToolFunction(BaseModel):+ """A function under tool as defined by the OpenAI API."""++ type: Literal["function"] = "function"+ function: Annotated[Function, Field(description="Function under tool")]+++def get_parameter_json_schema(k: str, v: Any, default_values: Dict[str, Any]) -> Dict[str, Any]:+ """Get a JSON schema for a parameter as defined by the OpenAI API++ Args:+ k: The name of the parameter+ v: The type of the parameter+ default_values: The default values of the parameters of the function++ Returns:+ A Pydanitc model for the parameter+ """++ def type2description(k: str, v: Union[Annotated[Type[Any], str], Type[Any]]) -> str:+ # handles Annotated+ if hasattr(v, "__metadata__"):+ retval = v.__metadata__[0]+ if isinstance(retval, str):+ return retval+ else:+ raise ValueError(f"Invalid description {retval} for parameter {k}, should be a string.")+ else:+ return k++ schema = type2schema(v)+ if k in default_values:+ dv = default_values[k]+ schema["default"] = dv++ schema["description"] = type2description(k, v)++ return schema+++def get_required_params(typed_signature: inspect.Signature) -> List[str]:+ """Get the required parameters of a function++ Args:+ signature: The signature of the function as returned by inspect.signature++ Returns:+ A list of the required parameters of the function+ """+ return [k for k, v in typed_signature.parameters.items() if v.default == inspect.Signature.empty]+++def get_default_values(typed_signature: inspect.Signature) -> Dict[str, Any]:+ """Get default values of parameters of a function++ Args:+ signature: The signature of the function as returned by inspect.signature++ Returns:+ A dictionary of the default values of the parameters of the function+ """+ return {k: v.default for k, v in typed_signature.parameters.items() if v.default != inspect.Signature.empty}+++def get_parameters(+ required: List[str],+ param_annotations: Dict[str, Union[Annotated[Type[Any], str], Type[Any]]],+ default_values: Dict[str, Any],+) -> Parameters:+ """Get the parameters of a function as defined by the OpenAI API++ Args:+ required: The required parameters of the function+ hints: The type hints of the function as returned by typing.get_type_hints++ Returns:+ A Pydantic model for the parameters of the function+ """+ return Parameters(+ properties={+ k: get_parameter_json_schema(k, v, default_values)+ for k, v in param_annotations.items()+ if v is not inspect.Signature.empty+ },+ required=required,+ )+++def get_missing_annotations(typed_signature: inspect.Signature, required: List[str]) -> Tuple[Set[str], Set[str]]:+ """Get the missing annotations of a function++ Ignores the parameters with default values as they are not required to be annotated, but logs a warning.+ Args:+ typed_signature: The signature of the function with type annotations+ required: The required parameters of the function++ Returns:+ A set of the missing annotations of the function+ """+ all_missing = {k for k, v in typed_signature.parameters.items() if v.annotation is inspect.Signature.empty}+ missing = all_missing.intersection(set(required))+ unannotated_with_default = all_missing.difference(missing)+ return missing, unannotated_with_default+++def get_function_schema(f: Callable[..., Any], *, name: Optional[str] = None, description: str) -> Dict[str, Any]:+ """Get a JSON schema for a function as defined by the OpenAI API++ Args:+ f: The function to get the JSON schema for+ name: The name of the function+ description: The description of the function++ Returns:+ A JSON schema for the function++ Raises:+ TypeError: If the function is not annotated++ Examples:++ .. code-block:: python++ def f(a: Annotated[str, "Parameter a"], b: int = 2, c: Annotated[float, "Parameter c"] = 0.1) -> None:+ pass++ get_function_schema(f, description="function f")++ # {'type': 'function',+ # 'function': {'description': 'function f',+ # 'name': 'f',+ # 'parameters': {'type': 'object',+ # 'properties': {'a': {'type': 'str', 'description': 'Parameter a'},+ # 'b': {'type': 'int', 'description': 'b'},+ # 'c': {'type': 'float', 'description': 'Parameter c'}},+ # 'required': ['a']}}}++ """+ typed_signature = get_typed_signature(f)+ required = get_required_params(typed_signature)+ default_values = get_default_values(typed_signature)+ param_annotations = get_param_annotations(typed_signature)+ return_annotation = get_typed_return_annotation(f)+ missing, unannotated_with_default = get_missing_annotations(typed_signature, required)++ if return_annotation is None:+ logger.warning(+ f"The return type of the function '{f.__name__}' is not annotated. Although annotating it is "+ + "optional, the function should return either a string, a subclass of 'pydantic.BaseModel'."+ )++ if unannotated_with_default != set():+ unannotated_with_default_s = [f"'{k}'" for k in sorted(unannotated_with_default)]+ logger.warning(+ f"The following parameters of the function '{f.__name__}' with default values are not annotated: "+ + f"{', '.join(unannotated_with_default_s)}."+ )++ if missing != set():+ missing_s = [f"'{k}'" for k in sorted(missing)]+ raise TypeError(+ f"All parameters of the function '{f.__name__}' without default values must be annotated. "+ + f"The annotations are missing for the following parameters: {', '.join(missing_s)}"+ )++ fname = name if name else f.__name__++ parameters = get_parameters(required, param_annotations, default_values=default_values)++ function = ToolFunction(+ function=Function(+ description=description,+ name=fname,+ parameters=parameters,+ )+ )++ return model_dump(function)diff --git a/src/agnext/agent_components/pydantic_compat.py b/src/agnext/agent_components/pydantic_compat.pynew file mode 100644index 000000000..d554d83d2--- /dev/null+++ b/src/agnext/agent_components/pydantic_compat.py@@ -0,0 +1,63 @@+# File based from: https://github.com/microsoft/autogen/blob/main/autogen/_pydantic.py+# Credit to original authors+++from typing import Any, Dict, Tuple, Type, Union, get_args++from pydantic import BaseModel+from pydantic.version import VERSION as PYDANTIC_VERSION+from typing_extensions import get_origin++__all__ = ("model_dump", "type2schema", "evaluate_forwardref")++PYDANTIC_V1 = PYDANTIC_VERSION.startswith("1.")+++def evaluate_forwardref(+ value: Any, globalns: dict[str, Any] | None = None, localns: dict[str, Any] | None = None+) -> Any:+ if PYDANTIC_V1:+ from pydantic.typing import evaluate_forwardref as evaluate_forwardref_internal++ return evaluate_forwardref_internal(value, globalns, localns)+ else:+ from pydantic._internal._typing_extra import eval_type_lenient++ return eval_type_lenient(value, globalns, localns)+++def type2schema(t: Type[Any] | None) -> Dict[str, Any]:+ if PYDANTIC_V1:+ from pydantic import schema_of # type: ignore++ if t is None:+ return {"type": "null"}+ elif get_origin(t) is Union:+ return {"anyOf": [type2schema(tt) for tt in get_args(t)]}+ elif get_origin(t) in [Tuple, tuple]:+ prefixItems = [type2schema(tt) for tt in get_args(t)]+ return {+ "maxItems": len(prefixItems),+ "minItems": len(prefixItems),+ "prefixItems": prefixItems,+ "type": "array",+ }++ d = schema_of(t) # type: ignore+ if "title" in d:+ d.pop("title")+ if "description" in d:+ d.pop("description")++ return d+ else:+ from pydantic import TypeAdapter++ return TypeAdapter(t).json_schema()+++def model_dump(model: BaseModel) -> Dict[str, Any]:+ if PYDANTIC_V1:+ return model.dict() # type: ignore+ else:+ return model.model_dump()diff --git a/test.sh b/test.shindex 636d66382..9236c93ff 100755--- a/test.sh+++ b/test.sh@@ -20,4 +20,4 @@ pyrightecho "--- Running mypy ---"mypyecho "--- Running pytest ---"-pytest\ No newline at end of file+pytest -n auto\ No newline at end of filediff --git a/tests/execution/test_commandline_code_executor.py b/tests/execution/test_commandline_code_executor.pynew file mode 100644index 000000000..2df31d6e7--- /dev/null+++ b/tests/execution/test_commandline_code_executor.py@@ -0,0 +1,105 @@+# File based from: https://github.com/microsoft/autogen/blob/main/test/coding/test_commandline_code_executor.py+# Credit to original authors++import sys+import tempfile+from pathlib import Path++import pytest++from agnext.agent_components.code_executor import LocalCommandLineCodeExecutor, CodeBlock++UNIX_SHELLS = ["bash", "sh", "shell"]+WINDOWS_SHELLS = ["ps1", "pwsh", "powershell"]+PYTHON_VARIANTS = ["python", "Python", "py"]+++def test_execute_code() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir)+++ # Test single code block.+ code_blocks = [CodeBlock(code="import sys; print('hello world!')", language="python")]+ code_result = executor.execute_code_blocks(code_blocks)+ assert code_result.exit_code == 0 and "hello world!" in code_result.output and code_result.code_file is not None++ # Test multiple code blocks.+ code_blocks = [+ CodeBlock(code="import sys; print('hello world!')", language="python"),+ CodeBlock(code="a = 100 + 100; print(a)", language="python"),+ ]+ code_result = executor.execute_code_blocks(code_blocks)+ assert (+ code_result.exit_code == 0+ and "hello world!" in code_result.output+ and "200" in code_result.output+ and code_result.code_file is not None+ )++ # Test bash script.+ if sys.platform not in ["win32"]:+ code_blocks = [CodeBlock(code="echo 'hello world!'", language="bash")]+ code_result = executor.execute_code_blocks(code_blocks)+ assert code_result.exit_code == 0 and "hello world!" in code_result.output and code_result.code_file is not None++ # Test running code.+ file_lines = ["import sys", "print('hello world!')", "a = 100 + 100", "print(a)"]+ code_blocks = [CodeBlock(code="\n".join(file_lines), language="python")]+ code_result = executor.execute_code_blocks(code_blocks)+ assert (+ code_result.exit_code == 0+ and "hello world!" in code_result.output+ and "200" in code_result.output+ and code_result.code_file is not None+ )++ # Check saved code file.+ with open(code_result.code_file) as f:+ code_lines = f.readlines()+ for file_line, code_line in zip(file_lines, code_lines):+ assert file_line.strip() == code_line.strip()+++def test_commandline_code_executor_timeout() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ executor = LocalCommandLineCodeExecutor(timeout=1, work_dir=temp_dir)+ code_blocks = [CodeBlock(code="import time; time.sleep(10); print('hello world!')", language="python")]+ code_result = executor.execute_code_blocks(code_blocks)+ assert code_result.exit_code and "Timeout" in code_result.output+++def test_local_commandline_code_executor_restart() -> None:+ executor = LocalCommandLineCodeExecutor()+ with pytest.warns(UserWarning, match=r".*No action is taken."):+ executor.restart()+++++def test_invalid_relative_path() -> None:+ executor = LocalCommandLineCodeExecutor()+ code = """# filename: /tmp/test.py++print("hello world")+"""+ result = executor.execute_code_blocks([CodeBlock(code=code, language="python")])+ assert result.exit_code == 1 and "Filename is not in the workspace" in result.output+++def test_valid_relative_path() -> None:+ with tempfile.TemporaryDirectory() as temp_dir_str:+ temp_dir = Path(temp_dir_str)+ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir)+ code = """# filename: test.py++print("hello world")+"""+ result = executor.execute_code_blocks([CodeBlock(code=code, language="python")])+ assert result.exit_code == 0+ assert "hello world" in result.output+ assert result.code_file is not None+ assert "test.py" in result.code_file+ assert (temp_dir / Path("test.py")).resolve() == Path(result.code_file).resolve()+ assert (temp_dir / Path("test.py")).exists()+diff --git a/tests/execution/test_markdown_code_extractor.py b/tests/execution/test_markdown_code_extractor.pynew file mode 100644index 000000000..13894b3b5--- /dev/null+++ b/tests/execution/test_markdown_code_extractor.py@@ -0,0 +1,118 @@+# File based from: https://github.com/microsoft/autogen/blob/main/test/coding/test_markdown_code_extractor.py+# Credit to original authors++from agnext.agent_components.code_executor import MarkdownCodeExtractor++_message_1 = """+Example:+```+print("hello extract code")+```+"""++_message_2 = """Example:+```python+def scrape(url):+ import requests+ from bs4 import BeautifulSoup+ response = requests.get(url)+ soup = BeautifulSoup(response.text, "html.parser")+ title = soup.find("title").text+ text = soup.find("div", {"id": "bodyContent"}).text+ return title, text+```+Test:+```python+url = "https://en.wikipedia.org/wiki/Web_scraping"+title, text = scrape(url)+print(f"Title: {title}")+print(f"Text: {text}")+```+"""++_message_3 = """+Example:+ ```python+ def scrape(url):+ import requests+ from bs4 import BeautifulSoup+ response = requests.get(url)+ soup = BeautifulSoup(response.text, "html.parser")+ title = soup.find("title").text+ text = soup.find("div", {"id": "bodyContent"}).text+ return title, text+ ```+"""++_message_4 = """+Example:+``` python+def scrape(url):+ import requests+ from bs4 import BeautifulSoup+ response = requests.get(url)+ soup = BeautifulSoup(response.text, "html.parser")+ title = soup.find("title").text+ text = soup.find("div", {"id": "bodyContent"}).text+ return title, text+```+""".replace(+ "\n", "\r\n"+)++_message_5 = """+Test bash script:+```bash+echo 'hello world!'+```+"""++_message_6 = """+Test some C# code, expecting ""+```+using System;+using System.Collections.Generic;+using System.Linq;+using System.Text;++namespace ConsoleApplication1+{+ class Program+ {+ static void Main(string[] args)+ {+ Console.WriteLine("Hello World");+ }+ }+}+```+"""++_message_7 = """+Test some message that has no code block.+"""+++def test_extract_code() -> None:+ extractor = MarkdownCodeExtractor()++ code_blocks = extractor.extract_code_blocks(_message_1)+ assert len(code_blocks) == 1 and code_blocks[0].language == "python"++ code_blocks = extractor.extract_code_blocks(_message_2)+ assert len(code_blocks) == 2 and code_blocks[0].language == "python" and code_blocks[1].language == "python"++ code_blocks = extractor.extract_code_blocks(_message_3)+ assert len(code_blocks) == 1 and code_blocks[0].language == "python"++ code_blocks = extractor.extract_code_blocks(_message_4)+ assert len(code_blocks) == 1 and code_blocks[0].language == "python"++ code_blocks = extractor.extract_code_blocks(_message_5)+ assert len(code_blocks) == 1 and code_blocks[0].language == "bash"++ code_blocks = extractor.extract_code_blocks(_message_6)+ assert len(code_blocks) == 1 and code_blocks[0].language == ""++ code_blocks = extractor.extract_code_blocks(_message_7)+ assert len(code_blocks) == 0diff --git a/tests/execution/test_user_defined_functions.py b/tests/execution/test_user_defined_functions.pynew file mode 100644index 000000000..382ecca2c--- /dev/null+++ b/tests/execution/test_user_defined_functions.py@@ -0,0 +1,199 @@+# File based from: https://github.com/microsoft/autogen/blob/main/test/coding/test_user_defined_functions.py+# Credit to original authors++import tempfile++import pytest++from agnext.agent_components.code_executor import LocalCommandLineCodeExecutor, CodeBlock+from agnext.agent_components.func_with_reqs import FunctionWithRequirements, with_requirements++import polars++def add_two_numbers(a: int, b: int) -> int:+ """Add two numbers together."""+ return a + b+++@with_requirements(python_packages=["polars"], global_imports=["polars"])+def load_data() -> polars.DataFrame:+ """Load some sample data.++ Returns:+ polars.DataFrame: A DataFrame with the following columns: name(str), location(str), age(int)+ """+ data = {+ "name": ["John", "Anna", "Peter", "Linda"],+ "location": ["New York", "Paris", "Berlin", "London"],+ "age": [24, 13, 53, 33],+ }+ return polars.DataFrame(data)+++@with_requirements(global_imports=["NOT_A_REAL_PACKAGE"])+def function_incorrect_import() -> "polars.DataFrame":+ return polars.DataFrame()+++@with_requirements(python_packages=["NOT_A_REAL_PACKAGE"])+def function_incorrect_dep() -> "polars.DataFrame":+ return polars.DataFrame()+++def function_missing_reqs() -> "polars.DataFrame":+ return polars.DataFrame()+++def test_can_load_function_with_reqs() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, functions=[load_data])+ code = f"""from {executor.functions_module} import load_data+import polars++# Get first row's name+data = load_data()+print(data['name'][0])"""++ result = executor.execute_code_blocks(+ code_blocks=[+ CodeBlock(language="python", code=code),+ ]+ )+ assert result.output == "John\n"+ assert result.exit_code == 0+++def test_can_load_function() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, functions=[add_two_numbers])+ code = f"""from {executor.functions_module} import add_two_numbers+print(add_two_numbers(1, 2))"""++ result = executor.execute_code_blocks(+ code_blocks=[+ CodeBlock(language="python", code=code),+ ]+ )+ assert result.output == "3\n"+ assert result.exit_code == 0+++def test_fails_for_function_incorrect_import() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, functions=[function_incorrect_import])+ code = f"""from {executor.functions_module} import function_incorrect_import+function_incorrect_import()"""++ with pytest.raises(ValueError):+ executor.execute_code_blocks(+ code_blocks=[+ CodeBlock(language="python", code=code),+ ]+ )+++def test_fails_for_function_incorrect_dep() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, functions=[function_incorrect_dep])+ code = f"""from {executor.functions_module} import function_incorrect_dep+function_incorrect_dep()"""++ with pytest.raises(ValueError):+ executor.execute_code_blocks(+ code_blocks=[+ CodeBlock(language="python", code=code),+ ]+ )++++def test_formatted_prompt() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, functions=[add_two_numbers])++ result = executor.format_functions_for_prompt()+ assert (+ '''def add_two_numbers(a: int, b: int) -> int:+ """Add two numbers together."""+'''+ in result+ )+++def test_formatted_prompt_str_func() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ func = FunctionWithRequirements.from_str(+ '''+def add_two_numbers(a: int, b: int) -> int:+ """Add two numbers together."""+ return a + b+'''+ )+ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, functions=[func])++ result = executor.format_functions_for_prompt()+ assert (+ '''def add_two_numbers(a: int, b: int) -> int:+ """Add two numbers together."""+'''+ in result+ )++++def test_can_load_str_function_with_reqs() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ func = FunctionWithRequirements.from_str(+ '''+def add_two_numbers(a: int, b: int) -> int:+ """Add two numbers together."""+ return a + b+'''+ )++ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, functions=[func])+ code = f"""from {executor.functions_module} import add_two_numbers+print(add_two_numbers(1, 2))"""++ result = executor.execute_code_blocks(+ code_blocks=[+ CodeBlock(language="python", code=code),+ ]+ )+ assert result.output == "3\n"+ assert result.exit_code == 0+++def test_cant_load_broken_str_function_with_reqs() -> None:++ with pytest.raises(ValueError):+ _ = FunctionWithRequirements.from_str(+ '''+invaliddef add_two_numbers(a: int, b: int) -> int:+ """Add two numbers together."""+ return a + b+'''+ )+++def test_cant_run_broken_str_function_with_reqs() -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ func = FunctionWithRequirements.from_str(+ '''+def add_two_numbers(a: int, b: int) -> int:+ """Add two numbers together."""+ return a + b+'''+ )++ executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, functions=[func])+ code = f"""from {executor.functions_module} import add_two_numbers+print(add_two_numbers(object(), False))"""++ result = executor.execute_code_blocks(+ code_blocks=[+ CodeBlock(language="python", code=code),+ ]+ )+ assert "TypeError: unsupported operand type(s) for +:" in result.output+ assert result.exit_code == 1