From be7541474bcf7ea9fd15c6288dd37b961111cd39 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Wed, 24 Jan 2024 02:03:44 -0800 Subject: [PATCH 01/52] code executor --- autogen/agentchat/conversable_agent.py | 79 ++++++++++++--- autogen/coding/__init__.py | 0 autogen/coding/base.py | 81 +++++++++++++++ autogen/coding/commandline_code_executor.py | 74 ++++++++++++++ autogen/coding/factory.py | 23 +++++ autogen/coding/ipython_code_executor.py | 103 ++++++++++++++++++++ 6 files changed, 349 insertions(+), 11 deletions(-) create mode 100644 autogen/coding/__init__.py create mode 100644 autogen/coding/base.py create mode 100644 autogen/coding/commandline_code_executor.py create mode 100644 autogen/coding/factory.py create mode 100644 autogen/coding/ipython_code_executor.py diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 70783376452..4f8b9d33f81 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -7,6 +7,10 @@ import re from collections import defaultdict from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional, Tuple, Type, TypeVar, Union +import warnings +from autogen.coding.base import CodeBlock + +from autogen.coding.factory import CodeExecutorFactory from .. import OpenAIWrapper from ..cache.cache import Cache @@ -166,7 +170,17 @@ def __init__( self.reply_at_receive = defaultdict(bool) self.register_reply([Agent, None], ConversableAgent.generate_oai_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_oai_reply, ignore_async_in_sync_chat=True) - self.register_reply([Agent, None], ConversableAgent.generate_code_execution_reply) + + if self._code_execution_config is not None and self._code_execution_config is not False: + # Register code execution reply functions with a code executor. + code_executor = CodeExecutorFactory.create(self._code_execution_config) + self.register_reply( + [Agent, None], + ConversableAgent.generate_code_execution_reply, + config=code_executor, + reset_config=code_executor.reset, + ) + self.register_reply([Agent, None], ConversableAgent.generate_tool_calls_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_tool_calls_reply, ignore_async_in_sync_chat=True) self.register_reply([Agent, None], ConversableAgent.generate_function_call_reply) @@ -837,9 +851,20 @@ def generate_code_execution_reply( code_execution_config = config if config is not None else self._code_execution_config if code_execution_config is False: return False, None + if isinstance(code_execution_config, dict): + warnings.warn( + "Usage of dictionary config in generate_code_execution_reply will be deprecated. " + "Please pass a CodeExecutor object instead when registering generate_code_execution_reply.", + DeprecationWarning, + ) + # For backward compatibility, convert the dictionary config to a CodeExecutor object. + code_executor = CodeExecutorFactory.create(code_execution_config) + else: + # Use the provided code executor. + code_executor = code_execution_config if messages is None: messages = self._oai_messages[sender] - last_n_messages = code_execution_config.pop("last_n_messages", "auto") + last_n_messages = code_executor.code_execution_config.get("last_n_messages", "auto") if not (isinstance(last_n_messages, (int, float)) and last_n_messages >= 0) and last_n_messages != "auto": raise ValueError("last_n_messages must be either a non-negative integer, or the string 'auto'.") @@ -870,13 +895,9 @@ def generate_code_execution_reply( # found code blocks, execute code and push "last_n_messages" back exitcode, logs = self.execute_code_blocks(code_blocks) - code_execution_config["last_n_messages"] = last_n_messages exitcode2str = "execution succeeded" if exitcode == 0 else "execution failed" return True, f"exitcode: {exitcode} ({exitcode2str})\nCode output: {logs}" - # no code blocks are found, push last_n_messages back and return. - code_execution_config["last_n_messages"] = last_n_messages - return False, None def generate_function_call_reply( @@ -1381,6 +1402,8 @@ def get_human_input(self, prompt: str) -> str: """Get human input. Override this method to customize the way to get human input. + To customize code execution, register a `generate_code_execution_reply`. + with a custom code executor created by `autogen.coding.CodeExecutorFactory`. Args: prompt (str): prompt for the human input. @@ -1405,10 +1428,11 @@ async def a_get_human_input(self, prompt: str) -> str: reply = input(prompt) return reply - def run_code(self, code, **kwargs): - """Run the code and return the result. + def run_code(self, code: str, **kwargs): + """(Deprecated) Run the code and return the result. + + NOTE: overidding this method in the future may result in undefined behavior. - Override this function to modify the way to run the code. Args: code (str): the code to be executed. **kwargs: other keyword arguments. @@ -1419,10 +1443,43 @@ def run_code(self, code, **kwargs): logs (str): the logs of the code execution. image (str or None): the docker image used for the code execution. """ - return execute_code(code, **kwargs) + # Find the config for the code executor. + code_executor = None + found_reply_func = False + for reply_func_tuple in self._reply_func_list: + if reply_func_tuple["reply_func"] == self.generate_code_execution_reply: + found_reply_func = True + code_executor = reply_func_tuple["config"]["code_executor"] + break + if found_reply_func is False or self._code_execution_config is False: + # This is the case when this code is running in a subclass that is + # not registered with a generate_code_execution_reply method or + # no code execution config is specified. + warnings.warn("Calling run_code directly will be deprecated in the future.") + # Just run the code with the default code executor. + code_executor = CodeExecutorFactory.create(kwargs) + elif code_executor is None: + # This is the case when this code is running in a subclass that is + # registered with a generate_code_execution_reply method, but the + # code executor is not specified in the config. + warnings.warn( + "Calling run_code directly or without specifying a code executor " + "when registering generate_code_execution_reply will be deprecated in the future." + ) + # For backward compatibility, we create a code executor on the fly. + code_executor = CodeExecutorFactory.create(self._code_execution_config) + # Run the code with the specified code executor. + language = kwargs.get("lang", "python") + code_result = code_executor.execute_code(CodeBlock(code=code, language=language), **kwargs) + return (code_result.exit_code, code_result.output, code_result.docker_image_name) def execute_code_blocks(self, code_blocks): - """Execute the code blocks and return the result.""" + """(Deprecated) Execute the code blocks and return the result. + + NOTE: Overriding this method in the future may result in undefined behavior. + To customize code execution, register a `generate_code_execution_reply`. + with a custom code executor created by `autogen.coding.CodeExecutorFactory`. + """ logs_all = "" for i, code_block in enumerate(code_blocks): lang, code = code_block diff --git a/autogen/coding/__init__.py b/autogen/coding/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/autogen/coding/base.py b/autogen/coding/base.py new file mode 100644 index 00000000000..82f5db5ff18 --- /dev/null +++ b/autogen/coding/base.py @@ -0,0 +1,81 @@ +from __future__ import annotations +from typing import Dict, Optional, Protocol, Tuple + +from pydantic import BaseModel + + +class CodeBlock(BaseModel): + """A class that represents a code block.""" + + """The code to execute.""" + code: str + + """The language of the code.""" + language: str + + +class CodeResult(BaseModel): + """A class that represents the result of a code execution.""" + + """The exit code of the code execution.""" + exit_code: int + + """The output of the code execution.""" + output: str + + """The docker image name used for the code execution.""" + docker_image_name: Optional[str] + + +class CodeExecutor(Protocol): + class UserCapability(Protocol): + """An AgentCapability class that gives agent ability use this code executor.""" + + def add_to_agent(self, agent): + ... # pragma: no cover + + @property + def user_capability(self) -> CodeExecutor.UserCapability: + """Capability to use this code executor. + + The exported capability can be added to an agent to allow it to use this + code executor: + + ```python + code_executor = CodeExecutor() + agent = Agent() + code_executor.user_capability.add_to_agent(agent) + ``` + + A typical implementation is to update the system message of the agent with + instructions for how to use this code executor. + """ + ... # pragma: no cover + + @property + def code_execution_config(self) -> Dict: + """Return the code execution config.""" + ... # pragma: no cover + + def execute_code(self, code: CodeBlock, **kwargs) -> CodeResult: + """Execute code and return the result. + + This method should be implemented by the code executor. + + Args: + code (CodeBlock): The code to execute. + **kwargs: Other arguments. + + Returns: + CodeResult: The result of the code execution. + """ + ... # pragma: no cover + + def reset(self) -> None: + """Reset the code executor. + + This method should be implemented by the code executor. + + This method is called when the agent is reset. + """ + ... diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py new file mode 100644 index 00000000000..62b0cf54fef --- /dev/null +++ b/autogen/coding/commandline_code_executor.py @@ -0,0 +1,74 @@ +from __future__ import annotations +from typing import Dict, Tuple + +from autogen.coding.base import CodeBlock, CodeResult + +try: + from termcolor import colored +except ImportError: + + def colored(x, *args, **kwargs): + return x + + +from autogen.code_utils import execute_code + + +class CommandlineCodeExecutor: + """A code executor class that executes code through command line without persisting + any state in memory between executions. + + Each execution is independent of each other. By default, it uses docker to + execute code. It can be configured to execute code locally without docker + but it's not recommended. + """ + + class UserCapability: + """An AgentCapability class that gives agent ability use a command line + code executor.""" + + DEFAULT_SYSTEM_MESSAGE_UPDATE = """ +You have been given coding capability to solve tasks using Python code. +In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. + 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself. + 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. +Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill. +When using code, you must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. +If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. +""" + + def add_to_agent(self, agent): + """Add this capability to an agent.""" + agent.update_system_message(agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE) + + def __init__(self, code_execution_config: Dict): + self._code_execution_config = code_execution_config.copy() + + @property + def user_capability(self) -> CommandlineCodeExecutor.UserCapability: + """Export a user capability that can be added to an agent.""" + return CommandlineCodeExecutor.UserCapability() + + @property + def code_execution_config(self) -> Dict: + """Return the code execution config.""" + return self._code_execution_config + + def execute_code(self, code_block: CodeBlock, **kwargs) -> CodeResult: + """Execute code and return the result.""" + args = self._code_execution_config.copy() + args.update(kwargs) + # Remove arguments not in execute_code. + for key in list(args.keys()): + if key not in execute_code.__code__.co_varnames: + args.pop(key) + args.pop("lang") + exit_code, output, docker_image_name = execute_code(code_block.code, lang=code_block.language, **args) + if docker_image_name is not None: + self._code_execution_config["image"] = docker_image_name + return CodeResult(exit_code=exit_code, output=output, docker_image_name=docker_image_name) + + def reset(self) -> None: + """Reset the code executor.""" + # Reset the image to None so that the next execution will use a new image. + self._code_execution_config["image"] = None diff --git a/autogen/coding/factory.py b/autogen/coding/factory.py new file mode 100644 index 00000000000..2390bd420a1 --- /dev/null +++ b/autogen/coding/factory.py @@ -0,0 +1,23 @@ +from typing import Dict + +from autogen.coding.base import CodeExecutor + + +class CodeExecutorFactory: + """A factory class for creating code executors.""" + + @staticmethod + def create(code_execution_config: Dict) -> CodeExecutor: + """Get a code executor based on the code execution config.""" + backend = code_execution_config.get("backend", "commandline") + if backend == "ipython": + from autogen.coding.ipython_code_executor import IPythonCodeExecutor + + return IPythonCodeExecutor(code_execution_config) + elif backend == "commandline": + # Default to command line code executor. + from autogen.coding.commandline_code_executor import CommandlineCodeExecutor + + return CommandlineCodeExecutor(code_execution_config) + else: + raise ValueError(f"Unknown code executor backend {backend}") diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py new file mode 100644 index 00000000000..49b3b269431 --- /dev/null +++ b/autogen/coding/ipython_code_executor.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from queue import Empty +from typing import Dict, Tuple +import warnings + +from autogen.coding.base import CodeBlock, CodeResult + +try: + from termcolor import colored +except ImportError: + + def colored(x, *args, **kwargs): + return x + + +from nbformat.v4 import new_output +from jupyter_client import KernelManager + + +class IPythonCodeExecutor: + """A code executor class that executes code statefully using IPython kernel. + + Each execution is stateful and can access variables created from previous + executions in the same session. + """ + + class UserCapability: + """An AgentCapability class that gives agent ability use a stateful + code executor.""" + + DEFAULT_SYSTEM_MESSAGE_UPDATE = """You have been given coding capability +to solve tasks using Python code in a stateful IPython kernel. +When you write Python code, put the code in a block with the language set to Python. +For example: +```python +x = 3 +print(x) +``` +The code will be executed in a IPython kernel, and the output will be returned to you. +You can use variables created earlier in the subsequent code blocks. +""" + + def add_to_agent(self, agent): + """Add this capability to an agent.""" + agent.update_system_message(agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE) + + def __init__(self, code_execution_config: Dict): + self._code_execution_config = code_execution_config.copy() + self._kernel_manager = KernelManager(kernel_name="python3") + self._kernel_client = self._kernel_manager.client() + self._kernel_client.start_channels() + self._timeout = self._code_execution_config.get("timeout", 60) + + @property + def user_capability(self) -> IPythonCodeExecutor.UserCapability: + """Export a user capability that can be added to an agent.""" + return IPythonCodeExecutor.UserCapability() + + @property + def code_execution_config(self) -> Dict: + """Return the code execution config.""" + return self._code_execution_config + + def execute_code(self, code_block: CodeBlock, **kwargs) -> CodeResult: + self._kernel_client.execute(code_block.code, store_history=True) + outputs = [] + while True: + try: + msg = self.kernel_client.get_iopub_msg(timeout=self._timeout) + msg_type = msg["msg_type"] + content = msg["content"] + if msg_type in ["execute_result", "display_data"]: + # Check if the output is an image + if "image/png" in content["data"]: + # Replace image with a note + note = "Image output has been replaced with this note." + outputs.append(new_output(msg_type, data={"text/plain": note})) + else: + outputs.append(new_output(msg_type, data=content["data"])) + elif msg_type == "stream": + outputs.append(new_output(msg_type, name=content["name"], text=content["text"])) + elif msg_type == "error": + return CodeResult( + exit_code=1, + output=f"ERROR: {content['ename']}: {content['evalue']}\n{content['traceback']}", + docker_image_name=None, + ) + if msg_type == "status" and content["execution_state"] == "idle": + break + # handle time outs. + except Empty: + return CodeResult( + exit_code=1, + output=f"ERROR: Timeout waiting for output from code block: {code_block.code}", + docker_image_name=None, + ) + # We return the full output. + return CodeResult(exit_code=0, output="".join([str(output) for output in outputs]), docker_image_name=None) + + def reset(self) -> None: + """Restart a new session.""" + self._kernel_client.stop_channels() + self._kernel_client.start_channels() From 36fb1be5c9998d79b1e0a50e9603e1ff6657208a Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Wed, 24 Jan 2024 20:24:55 -0800 Subject: [PATCH 02/52] test --- autogen/coding/commandline_code_executor.py | 8 +++++--- autogen/coding/factory.py | 4 ++-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py index 62b0cf54fef..2f14546a4a4 100644 --- a/autogen/coding/commandline_code_executor.py +++ b/autogen/coding/commandline_code_executor.py @@ -62,13 +62,15 @@ def execute_code(self, code_block: CodeBlock, **kwargs) -> CodeResult: for key in list(args.keys()): if key not in execute_code.__code__.co_varnames: args.pop(key) - args.pop("lang") + # Remove lang argument as we are getting it from code_block. + args.pop("lang", None) + # Execute code and obtain a docker image name if created. exit_code, output, docker_image_name = execute_code(code_block.code, lang=code_block.language, **args) if docker_image_name is not None: - self._code_execution_config["image"] = docker_image_name + self._code_execution_config["use_docker"] = docker_image_name return CodeResult(exit_code=exit_code, output=output, docker_image_name=docker_image_name) def reset(self) -> None: """Reset the code executor.""" # Reset the image to None so that the next execution will use a new image. - self._code_execution_config["image"] = None + self._code_execution_config["use_docker"] = None diff --git a/autogen/coding/factory.py b/autogen/coding/factory.py index 2390bd420a1..0317435fa7e 100644 --- a/autogen/coding/factory.py +++ b/autogen/coding/factory.py @@ -9,12 +9,12 @@ class CodeExecutorFactory: @staticmethod def create(code_execution_config: Dict) -> CodeExecutor: """Get a code executor based on the code execution config.""" - backend = code_execution_config.get("backend", "commandline") + backend = code_execution_config.get("backend") if backend == "ipython": from autogen.coding.ipython_code_executor import IPythonCodeExecutor return IPythonCodeExecutor(code_execution_config) - elif backend == "commandline": + elif backend == "commandline" or backend is None: # Default to command line code executor. from autogen.coding.commandline_code_executor import CommandlineCodeExecutor From 93d0fc64b89c25ee7c1697514340351e1c14c6f0 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Wed, 24 Jan 2024 22:22:26 -0800 Subject: [PATCH 03/52] revert to main conversable agent --- autogen/agentchat/conversable_agent.py | 79 ++++---------------------- 1 file changed, 11 insertions(+), 68 deletions(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 4f8b9d33f81..70783376452 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -7,10 +7,6 @@ import re from collections import defaultdict from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional, Tuple, Type, TypeVar, Union -import warnings -from autogen.coding.base import CodeBlock - -from autogen.coding.factory import CodeExecutorFactory from .. import OpenAIWrapper from ..cache.cache import Cache @@ -170,17 +166,7 @@ def __init__( self.reply_at_receive = defaultdict(bool) self.register_reply([Agent, None], ConversableAgent.generate_oai_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_oai_reply, ignore_async_in_sync_chat=True) - - if self._code_execution_config is not None and self._code_execution_config is not False: - # Register code execution reply functions with a code executor. - code_executor = CodeExecutorFactory.create(self._code_execution_config) - self.register_reply( - [Agent, None], - ConversableAgent.generate_code_execution_reply, - config=code_executor, - reset_config=code_executor.reset, - ) - + self.register_reply([Agent, None], ConversableAgent.generate_code_execution_reply) self.register_reply([Agent, None], ConversableAgent.generate_tool_calls_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_tool_calls_reply, ignore_async_in_sync_chat=True) self.register_reply([Agent, None], ConversableAgent.generate_function_call_reply) @@ -851,20 +837,9 @@ def generate_code_execution_reply( code_execution_config = config if config is not None else self._code_execution_config if code_execution_config is False: return False, None - if isinstance(code_execution_config, dict): - warnings.warn( - "Usage of dictionary config in generate_code_execution_reply will be deprecated. " - "Please pass a CodeExecutor object instead when registering generate_code_execution_reply.", - DeprecationWarning, - ) - # For backward compatibility, convert the dictionary config to a CodeExecutor object. - code_executor = CodeExecutorFactory.create(code_execution_config) - else: - # Use the provided code executor. - code_executor = code_execution_config if messages is None: messages = self._oai_messages[sender] - last_n_messages = code_executor.code_execution_config.get("last_n_messages", "auto") + last_n_messages = code_execution_config.pop("last_n_messages", "auto") if not (isinstance(last_n_messages, (int, float)) and last_n_messages >= 0) and last_n_messages != "auto": raise ValueError("last_n_messages must be either a non-negative integer, or the string 'auto'.") @@ -895,9 +870,13 @@ def generate_code_execution_reply( # found code blocks, execute code and push "last_n_messages" back exitcode, logs = self.execute_code_blocks(code_blocks) + code_execution_config["last_n_messages"] = last_n_messages exitcode2str = "execution succeeded" if exitcode == 0 else "execution failed" return True, f"exitcode: {exitcode} ({exitcode2str})\nCode output: {logs}" + # no code blocks are found, push last_n_messages back and return. + code_execution_config["last_n_messages"] = last_n_messages + return False, None def generate_function_call_reply( @@ -1402,8 +1381,6 @@ def get_human_input(self, prompt: str) -> str: """Get human input. Override this method to customize the way to get human input. - To customize code execution, register a `generate_code_execution_reply`. - with a custom code executor created by `autogen.coding.CodeExecutorFactory`. Args: prompt (str): prompt for the human input. @@ -1428,11 +1405,10 @@ async def a_get_human_input(self, prompt: str) -> str: reply = input(prompt) return reply - def run_code(self, code: str, **kwargs): - """(Deprecated) Run the code and return the result. - - NOTE: overidding this method in the future may result in undefined behavior. + def run_code(self, code, **kwargs): + """Run the code and return the result. + Override this function to modify the way to run the code. Args: code (str): the code to be executed. **kwargs: other keyword arguments. @@ -1443,43 +1419,10 @@ def run_code(self, code: str, **kwargs): logs (str): the logs of the code execution. image (str or None): the docker image used for the code execution. """ - # Find the config for the code executor. - code_executor = None - found_reply_func = False - for reply_func_tuple in self._reply_func_list: - if reply_func_tuple["reply_func"] == self.generate_code_execution_reply: - found_reply_func = True - code_executor = reply_func_tuple["config"]["code_executor"] - break - if found_reply_func is False or self._code_execution_config is False: - # This is the case when this code is running in a subclass that is - # not registered with a generate_code_execution_reply method or - # no code execution config is specified. - warnings.warn("Calling run_code directly will be deprecated in the future.") - # Just run the code with the default code executor. - code_executor = CodeExecutorFactory.create(kwargs) - elif code_executor is None: - # This is the case when this code is running in a subclass that is - # registered with a generate_code_execution_reply method, but the - # code executor is not specified in the config. - warnings.warn( - "Calling run_code directly or without specifying a code executor " - "when registering generate_code_execution_reply will be deprecated in the future." - ) - # For backward compatibility, we create a code executor on the fly. - code_executor = CodeExecutorFactory.create(self._code_execution_config) - # Run the code with the specified code executor. - language = kwargs.get("lang", "python") - code_result = code_executor.execute_code(CodeBlock(code=code, language=language), **kwargs) - return (code_result.exit_code, code_result.output, code_result.docker_image_name) + return execute_code(code, **kwargs) def execute_code_blocks(self, code_blocks): - """(Deprecated) Execute the code blocks and return the result. - - NOTE: Overriding this method in the future may result in undefined behavior. - To customize code execution, register a `generate_code_execution_reply`. - with a custom code executor created by `autogen.coding.CodeExecutorFactory`. - """ + """Execute the code blocks and return the result.""" logs_all = "" for i, code_block in enumerate(code_blocks): lang, code = code_block From 71d3cfa5d164ac13ee2761bc28ba5ebd869bd9c4 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Thu, 25 Jan 2024 14:24:23 -0800 Subject: [PATCH 04/52] prepare for pr --- autogen/agentchat/conversable_agent.py | 77 ++++- autogen/coding/base.py | 26 +- autogen/coding/commandline_code_executor.py | 114 ++++++-- autogen/coding/factory.py | 13 +- autogen/coding/ipython_code_executor.py | 94 ++++--- test/coding/test_commandline_code_executor.py | 263 ++++++++++++++++++ 6 files changed, 500 insertions(+), 87 deletions(-) create mode 100644 test/coding/test_commandline_code_executor.py diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 70783376452..386a7c930a0 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -7,6 +7,10 @@ import re from collections import defaultdict from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional, Tuple, Type, TypeVar, Union +import warnings +from autogen.coding.base import CodeExecutor + +from autogen.coding.factory import CodeExecutorFactory from .. import OpenAIWrapper from ..cache.cache import Cache @@ -166,7 +170,25 @@ def __init__( self.reply_at_receive = defaultdict(bool) self.register_reply([Agent, None], ConversableAgent.generate_oai_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_oai_reply, ignore_async_in_sync_chat=True) - self.register_reply([Agent, None], ConversableAgent.generate_code_execution_reply) + + # Do not register code executor if code execution is disabled. + if self._code_execution_config is not False: + if self._code_execution_config is True or ( + isinstance(self._code_execution_config, dict) and self._code_execution_config.get("executor") is None + ): + # Legacy code executor using code_utils. + warnings.warn( + "Using legacy code executor. Please use the new code executor " + "by setting 'executor' in code_execution_config. " + "For example: code_execution_config={'executor': 'commandline'}. " + "The legacy code executor will be removed in the future.", + DeprecationWarning, + ) + self.register_reply([Agent, None], ConversableAgent.generate_code_execution_reply) + else: + self._code_executor = CodeExecutorFactory.create(self._code_execution_config) + self.register_reply([Agent, None], ConversableAgent._generate_code_execution_reply_using_executor) + self.register_reply([Agent, None], ConversableAgent.generate_tool_calls_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_tool_calls_reply, ignore_async_in_sync_chat=True) self.register_reply([Agent, None], ConversableAgent.generate_function_call_reply) @@ -827,13 +849,64 @@ async def a_generate_oai_reply( None, functools.partial(self.generate_oai_reply, messages=messages, sender=sender, config=config) ) + def _generate_code_execution_reply_using_executor( + self, + messages: Optional[List[Dict]] = None, + sender: Optional[Agent] = None, + config: Optional[Union[Dict, Literal[False]]] = None, + ): + """Generate a reply using code executor.""" + code_execution_config = config if config is not None else self._code_execution_config + if code_execution_config is False: + return False, None + if messages is None: + messages = self._oai_messages[sender] + last_n_messages = code_execution_config.get("last_n_messages", "auto") + + if not (isinstance(last_n_messages, (int, float)) and last_n_messages >= 0) and last_n_messages != "auto": + raise ValueError("last_n_messages must be either a non-negative integer, or the string 'auto'.") + + messages_to_scan = last_n_messages + if last_n_messages == "auto": + # Find when the agent last spoke + messages_to_scan = 0 + for i in range(len(messages)): + message = messages[-(i + 1)] + if "role" not in message: + break + elif message["role"] != "user": + break + else: + messages_to_scan += 1 + + # iterate through the last n messages in reverse + # if code blocks are found, execute the code blocks and return the output + # if no code blocks are found, continue + for i in range(min(len(messages), messages_to_scan)): + message = messages[-(i + 1)] + if not message["content"]: + continue + code_blocks = self._code_executor.extract_code_blocks(message["content"]) + if len(code_blocks) == 1 and code_blocks[0].language == UNKNOWN: + continue + + # found code blocks, execute code and push "last_n_messages" back + code_result = self._code_executor.execute_code_blocks(code_blocks) + exitcode2str = "execution succeeded" if code_result.exit_code == 0 else "execution failed" + return True, f"exitcode: {code_result.exit_code} ({exitcode2str})\nCode output: {code_result.output}" + + return False, None + def generate_code_execution_reply( self, messages: Optional[List[Dict]] = None, sender: Optional[Agent] = None, config: Optional[Union[Dict, Literal[False]]] = None, ): - """Generate a reply using code execution.""" + """(Deprecated) Generate a reply using code execution. + + NOTE: this function uses the legacy code utils and will be removed in the future. + """ code_execution_config = config if config is not None else self._code_execution_config if code_execution_config is False: return False, None diff --git a/autogen/coding/base.py b/autogen/coding/base.py index 82f5db5ff18..c0f33d85ba5 100644 --- a/autogen/coding/base.py +++ b/autogen/coding/base.py @@ -1,5 +1,5 @@ from __future__ import annotations -from typing import Dict, Optional, Protocol, Tuple +from typing import Dict, List, Optional, Protocol, Tuple, runtime_checkable from pydantic import BaseModel @@ -23,9 +23,6 @@ class CodeResult(BaseModel): """The output of the code execution.""" output: str - """The docker image name used for the code execution.""" - docker_image_name: Optional[str] - class CodeExecutor(Protocol): class UserCapability(Protocol): @@ -52,19 +49,26 @@ def user_capability(self) -> CodeExecutor.UserCapability: """ ... # pragma: no cover - @property - def code_execution_config(self) -> Dict: - """Return the code execution config.""" + def extract_code_blocks(self, message: str) -> List[CodeBlock]: + """Extract code blocks from a message. + + This method should be implemented by the code executor. + + Args: + message (str): The message to extract code blocks from. + + Returns: + List[CodeBlock]: The extracted code blocks. + """ ... # pragma: no cover - def execute_code(self, code: CodeBlock, **kwargs) -> CodeResult: - """Execute code and return 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 (CodeBlock): The code to execute. - **kwargs: Other arguments. + code_blocks (List[CodeBlock]): The code blocks to execute. Returns: CodeResult: The result of the code execution. diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py index 2f14546a4a4..40799f815a8 100644 --- a/autogen/coding/commandline_code_executor.py +++ b/autogen/coding/commandline_code_executor.py @@ -1,5 +1,8 @@ from __future__ import annotations -from typing import Dict, Tuple +from typing import Dict, List, Optional, Tuple, Union +import warnings + +from pydantic import BaseModel, Field from autogen.coding.base import CodeBlock, CodeResult @@ -11,10 +14,10 @@ def colored(x, *args, **kwargs): return x -from autogen.code_utils import execute_code +from autogen.code_utils import DEFAULT_TIMEOUT, WORKING_DIR, execute_code, extract_code, infer_lang -class CommandlineCodeExecutor: +class CommandlineCodeExecutor(BaseModel): """A code executor class that executes code through command line without persisting any state in memory between executions. @@ -41,36 +44,95 @@ def add_to_agent(self, agent): """Add this capability to an agent.""" agent.update_system_message(agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE) - def __init__(self, code_execution_config: Dict): - self._code_execution_config = code_execution_config.copy() + timeout: Optional[int] = Field(default=DEFAULT_TIMEOUT, ge=1) + filename: Optional[str] = None + work_dir: Optional[str] = Field(default=WORKING_DIR) + use_docker: Optional[Union[List[str], str, bool]] = None + docker_image_name: Optional[str] = None + + def _get_use_docker_for_code_utils(self): + if self.use_docker is False: + return False + if self.docker_image_name is not None: + # Docker image name is set, use it. + return self.docker_image_name + # Docker image name has not being set, use the default. + return self.use_docker @property def user_capability(self) -> CommandlineCodeExecutor.UserCapability: """Export a user capability that can be added to an agent.""" return CommandlineCodeExecutor.UserCapability() - @property - def code_execution_config(self) -> Dict: - """Return the code execution config.""" - return self._code_execution_config - - def execute_code(self, code_block: CodeBlock, **kwargs) -> CodeResult: - """Execute code and return the result.""" - args = self._code_execution_config.copy() - args.update(kwargs) - # Remove arguments not in execute_code. - for key in list(args.keys()): - if key not in execute_code.__code__.co_varnames: - args.pop(key) - # Remove lang argument as we are getting it from code_block. - args.pop("lang", None) - # Execute code and obtain a docker image name if created. - exit_code, output, docker_image_name = execute_code(code_block.code, lang=code_block.language, **args) - if docker_image_name is not None: - self._code_execution_config["use_docker"] = docker_image_name - return CodeResult(exit_code=exit_code, output=output, docker_image_name=docker_image_name) + def extract_code_blocks(self, message: str) -> List[CodeBlock]: + """Extract code blocks from a message. + + This method should be implemented by the code executor. + + Args: + message: The message to extract code blocks from. + + Returns: + A list of code blocks. + """ + code_blocks = [] + for lang, code in extract_code(message): + if not lang: + lang = infer_lang(code) + code_blocks.append(CodeBlock(code=code, language=lang)) + return code_blocks + + def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: + """Execute the code blocks and return the result.""" + logs_all = "" + for i, code_block in enumerate(code_blocks): + lang, code = code_block.language, code_block.code + print( + colored( + f"\n>>>>>>>> EXECUTING CODE BLOCK {i} (inferred language is {lang})...", + "red", + ), + flush=True, + ) + if lang in ["bash", "shell", "sh"]: + exitcode, logs, image = execute_code( + code=code, + lang=lang, + timeout=self.timeout, + work_dir=self.work_dir, + filename=self.filename, + use_docker=self._get_use_docker_for_code_utils(), + ) + elif lang in ["python", "Python"]: + if code.startswith("# filename: "): + filename = code[11 : code.find("\n")].strip() + else: + filename = None + exitcode, logs, image = execute_code( + code, + lang="python", + filename=filename, + timeout=self.timeout, + work_dir=self.work_dir, + use_docker=self._get_use_docker_for_code_utils(), + ) + else: + # In case the language is not supported, we return an error message. + exitcode, logs, image = ( + 1, + f"unknown language {lang}", + None, + ) + # raise NotImplementedError + if image is not None: + # Update the image to use for the next execution. + self.docker_image_name = image + logs_all += "\n" + logs + if exitcode != 0: + break + return CodeResult(exit_code=exitcode, output=logs_all) def reset(self) -> None: """Reset the code executor.""" # Reset the image to None so that the next execution will use a new image. - self._code_execution_config["use_docker"] = None + self.docker_image_name = None diff --git a/autogen/coding/factory.py b/autogen/coding/factory.py index 0317435fa7e..d6af9abb427 100644 --- a/autogen/coding/factory.py +++ b/autogen/coding/factory.py @@ -9,15 +9,14 @@ class CodeExecutorFactory: @staticmethod def create(code_execution_config: Dict) -> CodeExecutor: """Get a code executor based on the code execution config.""" - backend = code_execution_config.get("backend") - if backend == "ipython": + executor_name = code_execution_config.get("executor") + if executor_name == "ipython": from autogen.coding.ipython_code_executor import IPythonCodeExecutor - return IPythonCodeExecutor(code_execution_config) - elif backend == "commandline" or backend is None: - # Default to command line code executor. + return IPythonCodeExecutor(**code_execution_config.get("ipython", {})) + elif executor_name == "commandline": from autogen.coding.commandline_code_executor import CommandlineCodeExecutor - return CommandlineCodeExecutor(code_execution_config) + return CommandlineCodeExecutor(**code_execution_config.get("commandline", {})) else: - raise ValueError(f"Unknown code executor backend {backend}") + raise ValueError(f"Unknown code executor {executor_name}") diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index 49b3b269431..91e916988d3 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -1,7 +1,9 @@ from __future__ import annotations from queue import Empty -from typing import Dict, Tuple -import warnings +from typing import List + +from pydantic import BaseModel, Field +from autogen.code_utils import DEFAULT_TIMEOUT, extract_code from autogen.coding.base import CodeBlock, CodeResult @@ -17,7 +19,7 @@ def colored(x, *args, **kwargs): from jupyter_client import KernelManager -class IPythonCodeExecutor: +class IPythonCodeExecutor(BaseModel): """A code executor class that executes code statefully using IPython kernel. Each execution is stateful and can access variables created from previous @@ -44,58 +46,68 @@ def add_to_agent(self, agent): """Add this capability to an agent.""" agent.update_system_message(agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE) - def __init__(self, code_execution_config: Dict): - self._code_execution_config = code_execution_config.copy() - self._kernel_manager = KernelManager(kernel_name="python3") + timeout: int = Field(default=DEFAULT_TIMEOUT, ge=1) + + def __init__(self, **kwargs): + super().__init__(**kwargs) + self._kernel_manager = KernelManager() self._kernel_client = self._kernel_manager.client() self._kernel_client.start_channels() - self._timeout = self._code_execution_config.get("timeout", 60) + self._timeout = self.timeout @property def user_capability(self) -> IPythonCodeExecutor.UserCapability: """Export a user capability that can be added to an agent.""" return IPythonCodeExecutor.UserCapability() - @property - def code_execution_config(self) -> Dict: - """Return the code execution config.""" - return self._code_execution_config + def extract_code_blocks(self, message: str) -> List[CodeBlock]: + """Extract IPython code blocks from a message. + + Args: + message (str): The message to extract code blocks from. + + Returns: + List[CodeBlock]: The extracted code blocks. + """ + code_blocks = [] + for lang, code in extract_code(message): + code_blocks.append(CodeBlock(code=code, language=lang)) + return code_blocks - def execute_code(self, code_block: CodeBlock, **kwargs) -> CodeResult: - self._kernel_client.execute(code_block.code, store_history=True) + def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: outputs = [] - while True: - try: - msg = self.kernel_client.get_iopub_msg(timeout=self._timeout) - msg_type = msg["msg_type"] - content = msg["content"] - if msg_type in ["execute_result", "display_data"]: - # Check if the output is an image - if "image/png" in content["data"]: - # Replace image with a note - note = "Image output has been replaced with this note." - outputs.append(new_output(msg_type, data={"text/plain": note})) - else: - outputs.append(new_output(msg_type, data=content["data"])) - elif msg_type == "stream": - outputs.append(new_output(msg_type, name=content["name"], text=content["text"])) - elif msg_type == "error": + for code_block in code_blocks: + self._kernel_client.execute(code_block.code, store_history=True) + while True: + try: + msg = self.kernel_client.get_iopub_msg(timeout=self._timeout) + msg_type = msg["msg_type"] + content = msg["content"] + if msg_type in ["execute_result", "display_data"]: + # Check if the output is an image + if "image/png" in content["data"]: + # Replace image with a note + note = "Image output has been replaced with this note." + outputs.append(new_output(msg_type, data={"text/plain": note})) + else: + outputs.append(new_output(msg_type, data=content["data"])) + elif msg_type == "stream": + outputs.append(new_output(msg_type, name=content["name"], text=content["text"])) + elif msg_type == "error": + return CodeResult( + exit_code=1, + output=f"ERROR: {content['ename']}: {content['evalue']}\n{content['traceback']}", + ) + if msg_type == "status" and content["execution_state"] == "idle": + break + # handle time outs. + except Empty: return CodeResult( exit_code=1, - output=f"ERROR: {content['ename']}: {content['evalue']}\n{content['traceback']}", - docker_image_name=None, + output=f"ERROR: Timeout waiting for output from code block: {code_block.code}", ) - if msg_type == "status" and content["execution_state"] == "idle": - break - # handle time outs. - except Empty: - return CodeResult( - exit_code=1, - output=f"ERROR: Timeout waiting for output from code block: {code_block.code}", - docker_image_name=None, - ) # We return the full output. - return CodeResult(exit_code=0, output="".join([str(output) for output in outputs]), docker_image_name=None) + return CodeResult(exit_code=0, output="".join([str(output) for output in outputs])) def reset(self) -> None: """Restart a new session.""" diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py new file mode 100644 index 00000000000..ac83feb4608 --- /dev/null +++ b/test/coding/test_commandline_code_executor.py @@ -0,0 +1,263 @@ +import sys +from typing import Dict +import pytest +from autogen.agentchat.agent import Agent +from autogen.agentchat.conversable_agent import ConversableAgent +from autogen.code_utils import WIN32, in_docker_container, is_docker_running +from autogen.coding.base import CodeBlock +from autogen.coding.commandline_code_executor import CommandlineCodeExecutor +from autogen.oai.openai_utils import config_list_from_json +from conftest import skip_openai # noqa: E402 + +try: + from openai import OpenAI +except ImportError: + skip_openai_tests = True +else: + skip_openai_tests = False or skip_openai + +_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 unknown. +``` +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"); + } + } +} +""" + + +def test_extract_code(): + executor = CommandlineCodeExecutor() + + code_blocks = executor.extract_code_blocks(_message_1) + assert len(code_blocks) == 1 and code_blocks[0].language == "python" + + code_blocks = executor.extract_code_blocks(_message_2) + assert len(code_blocks) == 2 and code_blocks[0].language == "python" and code_blocks[1].language == "python" + + code_blocks = executor.extract_code_blocks(_message_3) + assert len(code_blocks) == 1 and code_blocks[0].language == "python" + + code_blocks = executor.extract_code_blocks(_message_4) + assert len(code_blocks) == 1 and code_blocks[0].language == "python" + + code_blocks = executor.extract_code_blocks(_message_5) + assert len(code_blocks) == 1 and code_blocks[0].language == "bash" + + code_blocks = executor.extract_code_blocks(_message_6) + assert len(code_blocks) == 1 and code_blocks[0].language == "unknown" + + +@pytest.mark.skipif( + sys.platform in ["win32"] or (not is_docker_running() and not in_docker_container()), + reason="docker is not running", +) +def test_execute_code_docker(): + _test_execute_code({"use_docker": True}) + + +@pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") +def test_execute_code_local(): + _test_execute_code({"use_docker": False}) + + +def _test_execute_code(config: Dict): + executor = CommandlineCodeExecutor(**config) + + # 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 + # Check if the docker image is set. + if config["use_docker"] is not False: + assert isinstance(executor.docker_image_name, str) and len(executor.docker_image_name) > 0 + + # 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 + + # Test bash script. + 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 + + # Test running code and saving code to a file. + file_lines = ["# filename: test_file_name.py", "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 + + # Test checking and reading saved file. + code_blocks = [ + CodeBlock(code="import os; print(os.path.exists('test_file_name.py'))", language="python"), + CodeBlock(code="with open('test_file_name.py') as f: print(f.readlines())", language="python"), + ] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and "True" in code_result.output + for line in file_lines: + assert line in code_result.output + + # Test timeout. + executor = CommandlineCodeExecutor(**config, timeout=1) + 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 or WIN32 + + +@pytest.mark.skipif(skip_openai_tests, reason="openai not installed OR requested to skip") +def test_conversable_agent_capability(): + KEY_LOC = "notebook" + OAI_CONFIG_LIST = "OAI_CONFIG_LIST" + config_list = config_list_from_json( + OAI_CONFIG_LIST, + file_location=KEY_LOC, + filter_dict={ + "model": { + "gpt-3.5-turbo", + "gpt-35-turbo", + }, + }, + ) + llm_config = {"config_list": config_list} + agent = ConversableAgent( + "coding_agent", + llm_config=llm_config, + ) + executor = CommandlineCodeExecutor(use_docker=False) + executor.user_capability.add_to_agent(agent) + + # Test updated system prompt. + assert executor.user_capability.DEFAULT_SYSTEM_MESSAGE_UPDATE in agent.system_message + + # Test code generation. + reply = agent.generate_reply( + [{"role": "user", "content": "write a python script to print 'hello world' to the console"}], + sender=Agent("user"), + ) + + # Test code extraction. + code_blocks = executor.extract_code_blocks(reply) + assert len(code_blocks) == 1 and code_blocks[0].language == "python" + + # Test code execution. + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and "hello world" in code_result.output.lower() + + +@pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") +def test_coversable_agent_code_execution_no_docker(): + _test_conversable_agent_code_execution({"use_docker": False}) + + +@pytest.mark.skipif( + sys.platform in ["win32"] or (not is_docker_running() and not in_docker_container()), + reason="docker is not running", +) +def test_conversable_agent_code_execution_docker(): + _test_conversable_agent_code_execution({"use_docker": True}) + + +def _test_conversable_agent_code_execution(config): + agent = ConversableAgent( + "user_proxy", + code_execution_config={ + "executor": "commandline", + "commandline": config, + }, + ) + + reply = agent.generate_reply( + [{"role": "user", "content": _message_1}], + sender=Agent("user"), + ) + assert "hello extract code" in reply + if config["use_docker"] is not False: + # Check if the docker image is set. + assert ( + isinstance(agent._code_executor.docker_image_name, str) and len(agent._code_executor.docker_image_name) > 0 + ) + + +def test_conversable_agent_warning_legacy_code_executor(): + # Test warning message. + with pytest.warns(DeprecationWarning, match="legacy code executor"): + ConversableAgent("user_proxy", code_execution_config=True) From fc3d70acf5ea0e3cf1d151075628f9aa41386a84 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 00:12:06 -0800 Subject: [PATCH 05/52] kernel --- autogen/coding/ipython_code_executor.py | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index 91e916988d3..1b10e283848 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -15,7 +15,6 @@ def colored(x, *args, **kwargs): return x -from nbformat.v4 import new_output from jupyter_client import KernelManager @@ -51,6 +50,7 @@ def add_to_agent(self, agent): def __init__(self, **kwargs): super().__init__(**kwargs) self._kernel_manager = KernelManager() + self._kernel_manager.start_kernel() self._kernel_client = self._kernel_manager.client() self._kernel_client.start_channels() self._timeout = self.timeout @@ -75,25 +75,22 @@ def extract_code_blocks(self, message: str) -> List[CodeBlock]: return code_blocks def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: + self._kernel_client.wait_for_ready(timeout=self._timeout) outputs = [] for code_block in code_blocks: self._kernel_client.execute(code_block.code, store_history=True) while True: try: - msg = self.kernel_client.get_iopub_msg(timeout=self._timeout) + msg = self._kernel_client.get_iopub_msg(timeout=self._timeout) msg_type = msg["msg_type"] content = msg["content"] if msg_type in ["execute_result", "display_data"]: - # Check if the output is an image - if "image/png" in content["data"]: - # Replace image with a note - note = "Image output has been replaced with this note." - outputs.append(new_output(msg_type, data={"text/plain": note})) - else: - outputs.append(new_output(msg_type, data=content["data"])) + outputs.append(content["data"]) elif msg_type == "stream": - outputs.append(new_output(msg_type, name=content["name"], text=content["text"])) + # Output is a text. + outputs.append(content["text"]) elif msg_type == "error": + # Output is an error. return CodeResult( exit_code=1, output=f"ERROR: {content['ename']}: {content['evalue']}\n{content['traceback']}", @@ -106,6 +103,8 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: exit_code=1, output=f"ERROR: Timeout waiting for output from code block: {code_block.code}", ) + except Exception as e: + return CodeResult(exit_code=1, output=f"ERROR: {e}") # We return the full output. return CodeResult(exit_code=0, output="".join([str(output) for output in outputs])) From be4b34cf72846f13b523d5eb728822076c8b8ac3 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 00:27:54 -0800 Subject: [PATCH 06/52] run open ai tests only when it's out of draft status --- .github/workflows/contrib-openai.yml | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml index f173055d7f9..ce1aa61aade 100644 --- a/.github/workflows/contrib-openai.yml +++ b/.github/workflows/contrib-openai.yml @@ -5,17 +5,14 @@ name: OpenAI4ContribTests on: pull_request_target: - branches: ['main'] + types: [ready_for_review] + branches: ["main"] paths: - - 'autogen/**' - - 'test/agentchat/contrib/**' - - '.github/workflows/contrib-openai.yml' - - 'setup.py' + - "autogen/**" + - "test/agentchat/contrib/**" + - ".github/workflows/contrib-openai.yml" + - "setup.py" permissions: {} - # actions: read - # checks: read - # contents: read - # deployments: read jobs: RetrieveChatTest: strategy: @@ -183,8 +180,8 @@ jobs: AgentBuilder: strategy: matrix: - os: [ ubuntu-latest ] - python-version: [ "3.11" ] + os: [ubuntu-latest] + python-version: ["3.11"] runs-on: ${{ matrix.os }} environment: openai1 steps: From d42a08628eb475f62c9ddcec392f39d543f660c2 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 00:37:38 -0800 Subject: [PATCH 07/52] update workflow file --- .github/workflows/contrib-openai.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml index ce1aa61aade..1656494adaa 100644 --- a/.github/workflows/contrib-openai.yml +++ b/.github/workflows/contrib-openai.yml @@ -5,7 +5,8 @@ name: OpenAI4ContribTests on: pull_request_target: - types: [ready_for_review] + types: + - ready_for_review branches: ["main"] paths: - "autogen/**" From 5e069c0c10bd65d2a3bbe738ea4a1bb939cab261 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 01:26:42 -0800 Subject: [PATCH 08/52] revert workflow changes --- .github/workflows/contrib-openai.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml index 1656494adaa..6611b75e3b9 100644 --- a/.github/workflows/contrib-openai.yml +++ b/.github/workflows/contrib-openai.yml @@ -5,8 +5,6 @@ name: OpenAI4ContribTests on: pull_request_target: - types: - - ready_for_review branches: ["main"] paths: - "autogen/**" From 907bc8a3b337b852526eb75048ba9a9c0d631ef0 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 17:43:08 -0800 Subject: [PATCH 09/52] ipython executor --- autogen/agentchat/conversable_agent.py | 7 +- autogen/coding/base.py | 38 +- autogen/coding/commandline_code_executor.py | 32 +- autogen/coding/ipython_code_executor.py | 55 +- autogen/coding/markdown_code_extractor.py | 32 + ...at_auto_feedback_from_code_execution.ipynb | 709 ++++++++---------- setup.py | 1 + test/coding/test_commandline_code_executor.py | 117 +-- test/coding/test_ipython_code_executor.py | 128 ++++ test/coding/test_markdown_code_extractor.py | 115 +++ 10 files changed, 670 insertions(+), 564 deletions(-) create mode 100644 autogen/coding/markdown_code_extractor.py create mode 100644 test/coding/test_ipython_code_executor.py create mode 100644 test/coding/test_markdown_code_extractor.py diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 386a7c930a0..2ed7cd40f9f 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -886,11 +886,10 @@ def _generate_code_execution_reply_using_executor( message = messages[-(i + 1)] if not message["content"]: continue - code_blocks = self._code_executor.extract_code_blocks(message["content"]) - if len(code_blocks) == 1 and code_blocks[0].language == UNKNOWN: + code_blocks = self._code_executor.code_extractor.extract_code_blocks(message["content"]) + if len(code_blocks) == 0: continue - - # found code blocks, execute code and push "last_n_messages" back + # found code blocks, execute code. code_result = self._code_executor.execute_code_blocks(code_blocks) exitcode2str = "execution succeeded" if code_result.exit_code == 0 else "execution failed" return True, f"exitcode: {code_result.exit_code} ({exitcode2str})\nCode output: {code_result.output}" diff --git a/autogen/coding/base.py b/autogen/coding/base.py index c0f33d85ba5..253c3591c34 100644 --- a/autogen/coding/base.py +++ b/autogen/coding/base.py @@ -1,5 +1,4 @@ -from __future__ import annotations -from typing import Dict, List, Optional, Protocol, Tuple, runtime_checkable +from typing import List, Protocol from pydantic import BaseModel @@ -24,7 +23,24 @@ class CodeResult(BaseModel): output: str +class CodeExtractor(Protocol): + """A code extractor class that extracts code blocks from a message.""" + + 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. + """ + ... # pragma: no cover + + class CodeExecutor(Protocol): + """A code executor class that executes code blocks and returns the result.""" + class UserCapability(Protocol): """An AgentCapability class that gives agent ability use this code executor.""" @@ -32,7 +48,7 @@ def add_to_agent(self, agent): ... # pragma: no cover @property - def user_capability(self) -> CodeExecutor.UserCapability: + def user_capability(self) -> "CodeExecutor.UserCapability": """Capability to use this code executor. The exported capability can be added to an agent to allow it to use this @@ -49,17 +65,9 @@ def user_capability(self) -> CodeExecutor.UserCapability: """ ... # pragma: no cover - def extract_code_blocks(self, message: str) -> List[CodeBlock]: - """Extract code blocks from a message. - - This method should be implemented by the code executor. - - Args: - message (str): The message to extract code blocks from. - - Returns: - List[CodeBlock]: The extracted code blocks. - """ + @property + def code_extractor(self) -> CodeExtractor: + """The code extractor used by this code executor.""" ... # pragma: no cover def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: @@ -82,4 +90,4 @@ def reset(self) -> None: This method is called when the agent is reset. """ - ... + ... # pragma: no cover diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py index 40799f815a8..76293402d8a 100644 --- a/autogen/coding/commandline_code_executor.py +++ b/autogen/coding/commandline_code_executor.py @@ -1,10 +1,9 @@ -from __future__ import annotations -from typing import Dict, List, Optional, Tuple, Union -import warnings +from typing import List, Optional, Union from pydantic import BaseModel, Field -from autogen.coding.base import CodeBlock, CodeResult +from autogen.coding.base import CodeBlock, CodeExtractor, CodeResult +from autogen.coding.markdown_code_extractor import MarkdownCodeExtractor try: from termcolor import colored @@ -14,7 +13,7 @@ def colored(x, *args, **kwargs): return x -from autogen.code_utils import DEFAULT_TIMEOUT, WORKING_DIR, execute_code, extract_code, infer_lang +from autogen.code_utils import DEFAULT_TIMEOUT, WORKING_DIR, execute_code class CommandlineCodeExecutor(BaseModel): @@ -60,27 +59,14 @@ def _get_use_docker_for_code_utils(self): return self.use_docker @property - def user_capability(self) -> CommandlineCodeExecutor.UserCapability: + def user_capability(self) -> "CommandlineCodeExecutor.UserCapability": """Export a user capability that can be added to an agent.""" return CommandlineCodeExecutor.UserCapability() - def extract_code_blocks(self, message: str) -> List[CodeBlock]: - """Extract code blocks from a message. - - This method should be implemented by the code executor. - - Args: - message: The message to extract code blocks from. - - Returns: - A list of code blocks. - """ - code_blocks = [] - for lang, code in extract_code(message): - if not lang: - lang = infer_lang(code) - code_blocks.append(CodeBlock(code=code, language=lang)) - return code_blocks + @property + def code_extractor(self) -> CodeExtractor: + """Export a code extractor that can be used by an agent.""" + return MarkdownCodeExtractor() def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: """Execute the code blocks and return the result.""" diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index 1b10e283848..c6bad818b16 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -1,21 +1,12 @@ -from __future__ import annotations +import json from queue import Empty from typing import List -from pydantic import BaseModel, Field -from autogen.code_utils import DEFAULT_TIMEOUT, extract_code - -from autogen.coding.base import CodeBlock, CodeResult - -try: - from termcolor import colored -except ImportError: - - def colored(x, *args, **kwargs): - return x - - from jupyter_client import KernelManager +from pydantic import BaseModel, Field +from autogen.code_utils import DEFAULT_TIMEOUT +from autogen.coding.base import CodeBlock, CodeExtractor, CodeResult +from autogen.coding.markdown_code_extractor import MarkdownCodeExtractor class IPythonCodeExecutor(BaseModel): @@ -31,14 +22,20 @@ class UserCapability: DEFAULT_SYSTEM_MESSAGE_UPDATE = """You have been given coding capability to solve tasks using Python code in a stateful IPython kernel. -When you write Python code, put the code in a block with the language set to Python. +When you write Python code, put the code in a markdown code block with the language set to Python. For example: ```python x = 3 +``` +You can use the variable `x` in subsequent code blocks. +```python print(x) ``` -The code will be executed in a IPython kernel, and the output will be returned to you. -You can use variables created earlier in the subsequent code blocks. +The output may be text, a table, or an image. +When you suggest code, always write incrementally rather than all at once. +For example, if you want to import a library, do it in a separate code block. +If you want to define a function or a class, do it in a separate code block. +Leverage the statefulness of the kernel to avoid repeating code. """ def add_to_agent(self, agent): @@ -56,23 +53,14 @@ def __init__(self, **kwargs): self._timeout = self.timeout @property - def user_capability(self) -> IPythonCodeExecutor.UserCapability: + def user_capability(self) -> "IPythonCodeExecutor.UserCapability": """Export a user capability that can be added to an agent.""" return IPythonCodeExecutor.UserCapability() - def extract_code_blocks(self, message: str) -> List[CodeBlock]: - """Extract IPython code blocks from a message. - - Args: - message (str): The message to extract code blocks from. - - Returns: - List[CodeBlock]: The extracted code blocks. - """ - code_blocks = [] - for lang, code in extract_code(message): - code_blocks.append(CodeBlock(code=code, language=lang)) - return code_blocks + @property + def code_extractor(self) -> CodeExtractor: + """Export a code extractor that can be used by an agent.""" + return MarkdownCodeExtractor() def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: self._kernel_client.wait_for_ready(timeout=self._timeout) @@ -85,7 +73,8 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: msg_type = msg["msg_type"] content = msg["content"] if msg_type in ["execute_result", "display_data"]: - outputs.append(content["data"]) + # Output is data. + outputs.append(json.dumps(content["data"])) elif msg_type == "stream": # Output is a text. outputs.append(content["text"]) @@ -103,8 +92,6 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: exit_code=1, output=f"ERROR: Timeout waiting for output from code block: {code_block.code}", ) - except Exception as e: - return CodeResult(exit_code=1, output=f"ERROR: {e}") # We return the full output. return CodeResult(exit_code=0, output="".join([str(output) for output in outputs])) diff --git a/autogen/coding/markdown_code_extractor.py b/autogen/coding/markdown_code_extractor.py new file mode 100644 index 00000000000..86560dfb4d6 --- /dev/null +++ b/autogen/coding/markdown_code_extractor.py @@ -0,0 +1,32 @@ +import re +from typing import List +from autogen.code_utils import CODE_BLOCK_PATTERN, UNKNOWN, content_str, infer_lang +from autogen.coding.base import CodeBlock + + +class MarkdownCodeExtractor: + """A class that extracts code blocks from a message using Markdown syntax.""" + + def extract_code_blocks(self, message: str) -> List[CodeBlock]: + """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. + """ + + text = content_str(message) + match = re.findall(CODE_BLOCK_PATTERN, text, flags=re.DOTALL) + if not match: + return [] + code_blocks = [] + 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_blocks diff --git a/notebook/agentchat_auto_feedback_from_code_execution.ipynb b/notebook/agentchat_auto_feedback_from_code_execution.ipynb index 061078afda2..655d95239ff 100644 --- a/notebook/agentchat_auto_feedback_from_code_execution.ipynb +++ b/notebook/agentchat_auto_feedback_from_code_execution.ipynb @@ -60,13 +60,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "from typing import Dict, Union\n", - "\n", - "from IPython import get_ipython\n", + "from IPython import display\n", "from IPython.display import Image\n", "\n", "import autogen\n", @@ -125,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -139,117 +137,89 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "First, let's find out today's date. Then, we will fetch the stock prices for META (Facebook) and TESLA and calculate the year-to-date gain for both.\n", + "First, let's get the current date using Python. \n", "\n", - "Step 1: Get today's date\n", "```python\n", + "# python code\n", "from datetime import date\n", + "\n", + "# Get today's date\n", "today = date.today()\n", + "\n", "print(\"Today's date:\", today)\n", "```\n", "\n", - "Step 2: Fetch stock prices for META and TESLA\n", - "We will use the `yfinance` library to fetch the stock prices. If you don't have it installed, please install it using the following command:\n", + "Next, we need to fetch the stock prices for META (Facebook) and TESLA for the current year. We can use the `yfinance` library in Python to fetch this data. If `yfinance` is not installed, it can be installed using pip: `pip install yfinance`.\n", "\n", - "```sh\n", - "pip install yfinance\n", - "```\n", + "Here is the Python code to fetch the stock prices and calculate the year-to-date gain:\n", "\n", - "Step 3: Calculate the year-to-date gain for META and TESLA\n", "```python\n", + "# python code\n", "import yfinance as yf\n", "from datetime import datetime\n", "\n", - "def get_ytd_gain(ticker):\n", - " stock = yf.Ticker(ticker)\n", - " start_date = datetime(today.year, 1, 1)\n", - " end_date = today\n", - " historical_data = stock.history(start=start_date, end=end_date)\n", - " start_price = historical_data.iloc[0]['Close']\n", - " end_price = historical_data.iloc[-1]['Close']\n", - " ytd_gain = (end_price - start_price) / start_price * 100\n", - " return ytd_gain\n", - "\n", - "meta_ytd_gain = get_ytd_gain(\"FB\")\n", - "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n", - "\n", - "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n", - "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n", + "# Get the current year\n", + "current_year = datetime.now().year\n", + "\n", + "# Download stock data from the start of the year to today\n", + "meta_data = yf.download('FB', start=f'{current_year}-01-01', end=today)\n", + "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=today)\n", + "\n", + "# Calculate the year-to-date gain for each stock\n", + "meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", + "tesla_ytd_gain = ((tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]) * 100\n", + "\n", + "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain}%\")\n", + "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain}%\")\n", "```\n", "\n", - "Please execute the code blocks in the order mentioned above.\n", + "This code will print the year-to-date gain for both META (Facebook) and TESLA. The gain is calculated as the percentage increase in the closing price from the first trading day of the year to the most recent trading day.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is sh)...\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 2 (inferred language is python)...\u001b[0m\n", + ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 1 (execution failed)\n", "Code output: \n", - "Today's date: 2023-08-29\n", - "\n", - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n", - "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", - "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", - "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", - "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", - "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", - "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", - "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", - "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n", - "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", - "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", - "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", - "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", - "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", - "Requirement already satisfied: python-dateutil>=2.7.3 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", + "Today's date: 2024-01-26\n", "\n", "Traceback (most recent call last):\n", - " File \"\", line 14, in \n", - " meta_ytd_gain = get_ytd_gain(\"FB\")\n", - " File \"\", line 6, in get_ytd_gain\n", - " start_date = datetime(today.year, 1, 1)\n", + " File \"\", line 9, in \n", + " meta_data = yf.download('FB', start=f'{current_year}-01-01', end=today)\n", + " ^^^^^\n", "NameError: name 'today' is not defined\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Apologies for the error. It seems I forgot to include the `today` variable in the last code block. Here's the corrected code:\n", + "I apologize for the oversight. The 'today' variable was defined in the first code block but not in the second one. Let's correct this by defining 'today' in the second code block as well. Here's the corrected code:\n", "\n", "```python\n", + "# python code\n", "import yfinance as yf\n", "from datetime import datetime, date\n", "\n", + "# Get the current year and today's date\n", + "current_year = datetime.now().year\n", "today = date.today()\n", "\n", - "def get_ytd_gain(ticker):\n", - " stock = yf.Ticker(ticker)\n", - " start_date = datetime(today.year, 1, 1)\n", - " end_date = today\n", - " historical_data = stock.history(start=start_date, end=end_date)\n", - " start_price = historical_data.iloc[0]['Close']\n", - " end_price = historical_data.iloc[-1]['Close']\n", - " ytd_gain = (end_price - start_price) / start_price * 100\n", - " return ytd_gain\n", - "\n", - "meta_ytd_gain = get_ytd_gain(\"FB\")\n", - "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n", - "\n", - "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n", - "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n", + "# Download stock data from the start of the year to today\n", + "meta_data = yf.download('FB', start=f'{current_year}-01-01', end=today)\n", + "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=today)\n", + "\n", + "# Calculate the year-to-date gain for each stock\n", + "meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", + "tesla_ytd_gain = ((tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]) * 100\n", + "\n", + "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain}%\")\n", + "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain}%\")\n", "```\n", "\n", - "Please execute this code block to get the year-to-date gain for META and TESLA.\n", + "This code will print the year-to-date gain for both META (Facebook) and TESLA. The gain is calculated as the percentage increase in the closing price from the first trading day of the year to the most recent trading day.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -258,50 +228,52 @@ "\n", "exitcode: 1 (execution failed)\n", "Code output: \n", - "FB: No timezone found, symbol may be delisted\n", + "\n", + "[*********************100%%**********************] 1 of 1 completed\n", + "\n", + "1 Failed download:\n", + "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n", + "\n", + "[*********************100%%**********************] 1 of 1 completed\n", + ":14: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", "Traceback (most recent call last):\n", - " File \"\", line 16, in \n", - " meta_ytd_gain = get_ytd_gain(\"FB\")\n", - " File \"\", line 11, in get_ytd_gain\n", - " start_price = historical_data.iloc[0]['Close']\n", - " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 931, in __getitem__\n", - " return self._getitem_axis(maybe_callable, axis=axis)\n", - " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1566, in _getitem_axis\n", - " self._validate_integer(key, axis)\n", - " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1500, in _validate_integer\n", - " raise IndexError(\"single positional indexer is out-of-bounds\")\n", - "IndexError: single positional indexer is out-of-bounds\n", + " File \"\", line 14, in \n", + " meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", + " ~~~~~~~~~~~~~~~~~~^^^^\n", + " File \"/Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages/pandas/core/series.py\", line 1037, in __getitem__\n", + " return self._values[key]\n", + " ~~~~~~~~~~~~^^^^^\n", + "IndexError: index -1 is out of bounds for axis 0 with size 0\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "I apologize for the error. It seems that the \"FB\" ticker symbol is not working as expected. Facebook has changed its parent company name to Meta Platforms, Inc., and its ticker symbol has been changed to \"META\". Let's update the code to use the new ticker symbol:\n", + "I apologize for the confusion. The ticker symbol for Meta Platforms (formerly Facebook) has changed from 'FB' to 'META'. Let's correct this in the code:\n", "\n", "```python\n", + "# python code\n", "import yfinance as yf\n", "from datetime import datetime, date\n", "\n", + "# Get the current year and today's date\n", + "current_year = datetime.now().year\n", "today = date.today()\n", "\n", - "def get_ytd_gain(ticker):\n", - " stock = yf.Ticker(ticker)\n", - " start_date = datetime(today.year, 1, 1)\n", - " end_date = today\n", - " historical_data = stock.history(start=start_date, end=end_date)\n", - " start_price = historical_data.iloc[0]['Close']\n", - " end_price = historical_data.iloc[-1]['Close']\n", - " ytd_gain = (end_price - start_price) / start_price * 100\n", - " return ytd_gain\n", - "\n", - "meta_ytd_gain = get_ytd_gain(\"META\")\n", - "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n", - "\n", - "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n", - "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n", + "# Download stock data from the start of the year to today\n", + "meta_data = yf.download('META', start=f'{current_year}-01-01', end=today)\n", + "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=today)\n", + "\n", + "# Calculate the year-to-date gain for each stock\n", + "meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", + "tesla_ytd_gain = ((tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]) * 100\n", + "\n", + "print(f\"Year-to-date gain for META (Meta Platforms): {meta_ytd_gain}%\")\n", + "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain}%\")\n", "```\n", "\n", - "Please execute this updated code block to get the year-to-date gain for META and TESLA.\n", + "This code will print the year-to-date gain for both META (Meta Platforms) and TESLA. The gain is calculated as the percentage increase in the closing price from the first trading day of the year to the most recent trading day.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -310,19 +282,18 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Year-to-date gain for META (Facebook): 132.69%\n", - "Year-to-date gain for TESLA: 120.93%\n", + "Year-to-date gain for META (Meta Platforms): 13.540669084819019%\n", + "Year-to-date gain for TESLA: -26.48337242213101%\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Great! The code executed successfully. Here are the year-to-date gains for META (Facebook) and TESLA:\n", + "Great! The code has successfully calculated the year-to-date gain for both META (Meta Platforms) and TESLA. \n", "\n", - "- Year-to-date gain for META (Facebook): 132.69%\n", - "- Year-to-date gain for TESLA: 120.93%\n", + "As of today's date (January 26, 2024), the year-to-date gain for META (Meta Platforms) is approximately 13.54%, and the year-to-date gain for TESLA is approximately -26.48%. This means that META (Meta Platforms) has increased in value since the start of the year, while TESLA has decreased in value.\n", "\n", - "Please note that these values are based on the stock market data at the time of execution and may change as the market fluctuates.\n", + "Please note that these values are based on the closing prices of the stocks and can vary with the market's performance.\n", "\n", "TERMINATE\n", "\n", @@ -335,7 +306,6 @@ "assistant = autogen.AssistantAgent(\n", " name=\"assistant\",\n", " llm_config={\n", - " \"cache_seed\": 42, # seed for caching and reproducibility\n", " \"config_list\": config_list, # a list of OpenAI API configurations\n", " \"temperature\": 0, # temperature for sampling\n", " }, # configuration for autogen's enhanced inference API which is compatible with OpenAI API\n", @@ -347,15 +317,20 @@ " max_consecutive_auto_reply=10,\n", " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", " code_execution_config={\n", - " \"work_dir\": \"coding\",\n", - " \"use_docker\": False, # Please set use_docker=True if docker is available to run the generated code. Using docker is safer than running the generated code directly.\n", + " \"executor\": \"commandline\",\n", + " \"commandline\": {\"work_dir\": \"coding\", \"user_docker\": False},\n", + " # Please set use_docker=True if docker is available to run the generated code. Using docker is safer than running the generated code directly.\n", " },\n", ")\n", - "# the assistant receives a message from the user_proxy, which contains the task description\n", - "user_proxy.initiate_chat(\n", - " assistant,\n", - " message=\"\"\"What date is today? Compare the year-to-date gain for META and TESLA.\"\"\",\n", - ")" + "\n", + "# We use a local cache for reproducible results.\n", + "with autogen.Cache.disk() as cache:\n", + " # the assistant receives a message from the user_proxy, which contains the task description\n", + " user_proxy.initiate_chat(\n", + " assistant,\n", + " message=\"\"\"What date is today? Compare the year-to-date gain for META and TESLA.\"\"\",\n", + " cache=cache,\n", + " )" ] }, { @@ -378,7 +353,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -392,87 +367,100 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "To plot the chart and save it as an image, we will use the `matplotlib` library. If you don't have it installed, please install it using the following command:\n", + "Sure, we can use the matplotlib library in Python to plot the stock price changes for META and TESLA. If matplotlib is not installed, it can be installed using pip: `pip install matplotlib`.\n", + "\n", + "Here is the Python code to plot the stock prices and save the plot to a file:\n", + "\n", + "```python\n", + "# python code\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot the closing prices of META and TESLA\n", + "plt.figure(figsize=(14,7))\n", + "plt.plot(meta_data['Close'], label='META')\n", + "plt.plot(tesla_data['Close'], label='TESLA')\n", + "\n", + "# Add title and labels\n", + "plt.title('Stock Price Change YTD for META and TESLA')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Price (USD)')\n", "\n", - "```sh\n", - "pip install matplotlib\n", + "# Add legend\n", + "plt.legend()\n", + "\n", + "# Save the plot to a file\n", + "plt.savefig('stock_price_ytd.png')\n", "```\n", "\n", - "Now, let's plot the chart of the stock price change YTD for META and TESLA and save it to a file named \"stock_price_ytd.png\":\n", + "This code will create a line plot of the closing prices for META and TESLA from the start of the year to today's date. The plot will be saved to a file named 'stock_price_ytd.png'.\n", "\n", - "```python\n", - "# filename: plot_stock_price_ytd.py\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 1 (execution failed)\n", + "Code output: \n", + "Traceback (most recent call last):\n", + " File \"\", line 6, in \n", + " plt.plot(meta_data['Close'], label='META')\n", + " ^^^^^^^^^\n", + "NameError: name 'meta_data' is not defined\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I apologize for the oversight. The 'meta_data' and 'tesla_data' variables were defined in the previous code block but not in this one. Let's correct this by fetching the stock data again in this code block. Here's the corrected code:\n", "\n", + "```python\n", + "# python code\n", "import yfinance as yf\n", "import matplotlib.pyplot as plt\n", "from datetime import datetime, date\n", "\n", + "# Get the current year and today's date\n", + "current_year = datetime.now().year\n", "today = date.today()\n", "\n", - "def get_stock_data(ticker):\n", - " stock = yf.Ticker(ticker)\n", - " start_date = datetime(today.year, 1, 1)\n", - " end_date = today\n", - " historical_data = stock.history(start=start_date, end=end_date)\n", - " return historical_data\n", + "# Download stock data from the start of the year to today\n", + "meta_data = yf.download('META', start=f'{current_year}-01-01', end=today)\n", + "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=today)\n", "\n", - "meta_data = get_stock_data(\"META\")\n", - "tesla_data = get_stock_data(\"TSLA\")\n", + "# Plot the closing prices of META and TESLA\n", + "plt.figure(figsize=(14,7))\n", + "plt.plot(meta_data['Close'], label='META')\n", + "plt.plot(tesla_data['Close'], label='TESLA')\n", "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(meta_data.index, meta_data['Close'], label='META (Facebook)')\n", - "plt.plot(tesla_data.index, tesla_data['Close'], label='TESLA')\n", - "plt.xlabel('Date')\n", - "plt.ylabel('Stock Price')\n", + "# Add title and labels\n", "plt.title('Stock Price Change YTD for META and TESLA')\n", - "plt.legend()\n", - "plt.savefig('stock_price_ytd.png')\n", - "plt.show()\n", - "```\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Price (USD)')\n", "\n", - "Please save the above code in a file named \"plot_stock_price_ytd.py\" and execute it using the following command:\n", + "# Add legend\n", + "plt.legend()\n", "\n", - "```sh\n", - "python plot_stock_price_ytd.py\n", + "# Save the plot to a file\n", + "plt.savefig('stock_price_ytd.png')\n", "```\n", "\n", - "This will create a chart of the stock price change YTD for META and TESLA and save it as \"stock_price_ytd.png\" in the same directory where the script is located.\n", + "This code will create a line plot of the closing prices for META and TESLA from the start of the year to today's date. The plot will be saved to a file named 'stock_price_ytd.png'.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 2 (inferred language is sh)...\u001b[0m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: matplotlib in /home/vscode/.local/lib/python3.9/site-packages (3.7.2)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (4.41.1)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.4.4)\n", - "Requirement already satisfied: cycler>=0.10 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n", - "Requirement already satisfied: pillow>=6.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (10.0.0)\n", - "Requirement already satisfied: importlib-resources>=3.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (6.0.0)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n", - "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n", - "Requirement already satisfied: packaging>=20.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (23.1)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.1.0)\n", - "Requirement already satisfied: numpy>=1.20 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.25.1)\n", - "Requirement already satisfied: zipp>=3.1.0 in /home/vscode/.local/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib) (3.16.2)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", - "\n", - "Figure(1200x600)\n", - "\n", - "Figure(1200x600)\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Great! The code executed successfully, and the chart of the stock price change YTD for META and TESLA has been saved as \"stock_price_ytd.png\" in the same directory where the script is located. You can now view the chart by opening the \"stock_price_ytd.png\" file.\n", + "Great! The code has successfully created a line plot of the closing prices for META (Meta Platforms) and TESLA from the start of the year to today's date. The plot has been saved to a file named 'stock_price_ytd.png'. You can open this file to view the plot.\n", + "\n", + "Please note that the plot shows the changes in the closing prices of the stocks and can help visualize their performance over the year to date.\n", "\n", "TERMINATE\n", "\n", @@ -498,24 +486,23 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABXgAAAK8CAYAAABV1dcbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACU1UlEQVR4nOzdeXhTZf7+8TtNm3RNCl2BUvat7CJCwQUVQQd3cYFRwX0BZ3Tm51dRx11xHGdEZlSckXEDxEHRcR1EBFRABRWUVaksZSmlhe5rkvP7I21oaIGmlKanfb+uK1eT5zw553NCOeLdp59jMQzDEAAAAAAAAADAdEKCXQAAAAAAAAAAoGEIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAAAAAAADApAh4AQAAAAAAAMCkCHgBAAAAAAAAwKQIeAEAQIu0bNkyWSwWvf3220E5/quvviqLxaLt27cH5fj1MWrUKPXr1y/YZbRaRUVFuvHGG5WcnCyLxaI777wz2CXhMBaLRQ8//HCwywAAADgqAl4AANBofvrpJ40fP16dOnVSeHi4OnTooHPOOUd///vf/eY9+eSTeu+994JTZD1s375dFovF97BarUpNTdUll1yitWvXBru8YyooKNAjjzyigQMHKjo6WhEREerXr5/uuece7dmzJ9jlNYnKykr1799f3bp1U2lpaa3t27dvV2RkpC6//HK/P+ujPZYtW1breyMsLEzx8fEaMWKE7rvvPu3cubPeNT755JN69dVXddttt+mNN97QNddc05gfQS2dO3eWxWLR6NGj69z+r3/9y3dea9as8Y0//PDDR/1csrKyNGrUqHp9hjXD0k2bNslisSg8PFx5eXkn9NxPlEDPu/rPoK7Hueee67fvr776Suedd546dOig8PBwpaam6oILLtC8efP85lksFk2dOrXeNb/wwguyWCwaNmzYcZ8/AABoHkKDXQAAAGgZVq5cqTPPPFOpqam66aablJycrMzMTH399dd67rnndMcdd/jmPvnkkxo/frwuvvji4BVcDxMmTNBvfvMbud1ubdq0SS+++KI++eQTff311xo0aNBR33vNNdfoqquukt1ub5piq/z6668aPXq0du7cqcsvv1w333yzbDabfvzxR82ePVvvvvuufv755yatKRjCwsL0z3/+UyNHjtRjjz2mJ5980m/71KlTZbPZNHPmTF100UV+215//XUtXrxYb7zxht94nz59fGFx9feGx+PRwYMHtXr1as2YMUPPPfecZs+erauuuuqYNX7++ecaPny4HnrooeM82/oLDw/X0qVLlZWVpeTkZL9tc+fOVXh4uMrKyup874svvqjo6Oha47Gxsbr//vt14403+sZWr16tmTNn6r777lOfPn184wMGDPA9nzNnjpKTk3Xw4EG9/fbbfu83i4ac96BBg/THP/6x1r7at2/ve75gwQJdeeWVGjRokH7/+9+rTZs22rZtm7744gv961//0sSJExtc89y5c9W5c2d9++232rp1q7p3797gfQEAgOaBgBcAADSKJ554Qk6nU6tXr1ZsbKzftuzs7OAUdZxOOukkXX311b7XI0eO1IUXXqgXX3xRL730Up3vKS4uVlRUlKxWq6xWa1OVKklyuVy69NJLtW/fPi1btkynnnqq3/YnnnhCf/7zn5u0pmBKT0/XrbfeqmeeeUa//e1v1bdvX0nSO++8o48++kgvvPCC2rVr5/dnLElff/21Fi9eXGtckq/lxuHfG5K0Y8cOjRkzRpMmTVKfPn00cODAo9aXnZ2ttLS04zhDfy6XSx6PRzab7YhzRo4cqdWrV+utt97S73//e9/4rl279OWXX+qSSy7RO++8U+d7x48fr/j4+Dq3nXPOOX6vw8PDNXPmTJ1zzjkaNWpUrfmGYWjevHmaOHGitm3bprlz55oy4A30vCWpQ4cOdX5v1fTwww8rLS1NX3/9da0/z+O5nm7btk0rV67UwoULdcstt2ju3LlN+gMGAABwYtCiAQAANIqMjAz17du3VrgrSYmJib7nFotFxcXFeu2113y/mjx58mTf9h9++EHnnXeeHA6HoqOjdfbZZ+vrr7+utc+8vDzddddd6ty5s+x2u1JSUnTttdcqJyfniDWWl5fr/PPPl9Pp1MqVKwM+x7POOkuSNySRDvXZXb58uW6//XYlJiYqJSXFb9vhPXg/+eQTnXHGGYqJiZHD4dDQoUNr/cr1N998o3PPPVdOp1ORkZE644wztGLFimPW984772jdunW6//77a4W7kuRwOPTEE0/UGt+4caPOPPNMRUZGqkOHDnr66af9tldUVOjBBx/UkCFD5HQ6FRUVpdNOO01Lly71m1fdvuCZZ57RP//5T3Xr1k12u11Dhw7V6tWrax13wYIFSktLU3h4uPr166d3331XkydPVufOnf3meTwezZgxQ3379lV4eLiSkpJ0yy236ODBg8f8TKZPn674+HjdeuutMgxDRUVFuvPOO33hb2Pq1KmTXn31VVVUVNT6DGuq7g+9bds2ffTRR76/B9XfK9nZ2brhhhuUlJSk8PBwDRw4UK+99prfPmp+1jNmzPB91hs3bjxqjeHh4br00ktrfc+9+eabatOmjcaOHduwkw/QihUrtH37dl111VW66qqr9MUXX2jXrl31eu+PP/6oyZMnq2vXrgoPD1dycrKuv/565ebm+s2rbi2xdetWTZ48WbGxsXI6nbruuutUUlLiN7e8vFx33XWXEhISFBMTowsvvLDe9ZwIGRkZGjp0aJ1hfc3raaDmzp2rNm3aaNy4cRo/frzmzp17PGUCAIBmghW8AACgUXTq1EmrVq3S+vXrj3rjrjfeeEM33nijTjnlFN18882SpG7dukmSNmzYoNNOO00Oh0P/93//p7CwML300ksaNWqUli9f7usZWVRUpNNOO02bNm3S9ddfr5NOOkk5OTl6//33tWvXrjpXGZaWluqiiy7SmjVr9Nlnn2no0KEBn2NGRoYkKS4uzm/89ttvV0JCgh588EEVFxcf8f2vvvqqrr/+evXt21fTpk1TbGysfvjhB/3vf//z/cr1559/rvPOO09DhgzRQw89pJCQEL3yyis666yz9OWXX+qUU0454v7ff/99SQqol+vBgwd17rnn6tJLL9UVV1yht99+W/fcc4/69++v8847T5K3p+/LL7+sCRMm6KabblJhYaFmz56tsWPH6ttvv63VrmLevHkqLCzULbfcIovFoqefflqXXnqpfv31V4WFhUmSPvroI1155ZXq37+/pk+froMHD+qGG25Qhw4datV4yy236NVXX9V1112n3/3ud9q2bZv+8Y9/6IcfftCKFSt8+6yL0+nUzJkzdfnll+vll1/Wxo0btW/fPn3yySeyWCz1/pzqKz09Xd26ddPixYuPOKdPnz564403dNdddyklJcX36/oJCQkqLS3VqFGjtHXrVk2dOlVdunTRggULNHnyZOXl5fmtupWkV155RWVlZbr55ptlt9vVtm3bY9Y4ceJEjRkzRhkZGb6/e/PmzdP48eOP+lkeOHCg1lhoaGidP9Q5lrlz56pbt24aOnSo+vXrp8jISL355pu6++67j/nexYsX69dff9V1112n5ORkbdiwQf/85z+1YcMGff3117X+XK+44gp16dJF06dP1/fff6+XX35ZiYmJfqvZb7zxRs2ZM0cTJ07UiBEj9Pnnn2vcuHEBn1d9VFZW1vmDqKioKEVEREjyXk+XLFmiXbt2+X5o1Bjmzp2rSy+9VDabTRMmTNCLL76o1atXN+h6CAAAmhEDAACgEXz66aeG1Wo1rFarkZ6ebvzf//2fsWjRIqOioqLW3KioKGPSpEm1xi+++GLDZrMZGRkZvrE9e/YYMTExxumnn+4be/DBBw1JxsKFC2vtw+PxGIZhGEuXLjUkGQsWLDAKCwuNM844w4iPjzd++OGHY57Ltm3bDEnGI488Yuzfv9/Iysoyli1bZgwePNiQZLzzzjuGYRjGK6+8YkgyTj31VMPlcvnto3rbtm3bDMMwjLy8PCMmJsYYNmyYUVpaWmfNHo/H6NGjhzF27FjfmGEYRklJidGlSxfjnHPOOWrdgwcPNpxO5zHPr9oZZ5xhSDJef/1131h5ebmRnJxsXHbZZb4xl8tllJeX+7334MGDRlJSknH99df7xqo/t7i4OOPAgQO+8f/+97+GJOODDz7wjfXv399ISUkxCgsLfWPLli0zJBmdOnXyjX355ZeGJGPu3Ll+x//f//5X5/iRnH/++YbT6TSsVqsxbdq0o86dMmWKcaR/Jlef41/+8pcjvv+iiy4yJBn5+flHPU6nTp2McePG+Y3NmDHDkGTMmTPHN1ZRUWGkp6cb0dHRRkFBgV8dDofDyM7OPupxDj+ey+UykpOTjccee8wwDMPYuHGjIclYvny57/t29erVvvc99NBDhqQ6H7169arzWAsWLDAkGUuXLq21raKiwoiLizPuv/9+39jEiRONgQMH1us8SkpKao29+eabhiTjiy++qFV3ze9RwzCMSy65xIiLi/O9Xrt2rSHJuP322/3mTZw40ZBkPPTQQ/WqyzCOft6G4f0zONJnOX36dN+82bNnG5IMm81mnHnmmcaf/vQn48svvzTcbnetfUoypkyZcsza1qxZY0gyFi9ebBiG93qTkpJi/P73v6/3+QEAgOaJFg0AAKBRnHPOOVq1apUuvPBCrVu3Tk8//bTGjh2rDh06+FaWHo3b7dann36qiy++WF27dvWNt2vXThMnTtRXX32lgoICSd5WBAMHDtQll1xSaz+Hr97Lz8/XmDFjtHnzZi1btuyYN0er6aGHHlJCQoKSk5M1atQoZWRk6M9//rMuvfRSv3k33XTTMfvtLl68WIWFhbr33nsVHh5eZ81r167VL7/8ookTJyo3N1c5OTnKyclRcXGxzj77bH3xxRfyeDxHPEZBQYFiYmLqfX6SFB0d7dcP1Gaz6ZRTTtGvv/7qG7Narb5fFfd4PDpw4IBcLpdOPvlkff/997X2eeWVV6pNmza+16eddpok+fa5Z88e/fTTT7r22mv9btp1xhlnqH///n77WrBggZxOp8455xzf55GTk6MhQ4YoOjq6VpuII3n++edVUVGhjh076k9/+lO93tNQ1edUWFgY8Hs//vhjJScna8KECb6xsLAw/e53v1NRUZGWL1/uN/+yyy5TQkJCQMewWq264oor9Oabb0ryrurs2LGj78/pSN555x0tXrzY7/HKK68EdGzJ26YkNzfX7xwnTJigdevWacOGDcd8f/UqV0kqKytTTk6Ohg8fLkl1fj8e3orjtNNOU25uru968vHHH0uSfve73/nNu/POO+t3QgEaNmxYrc9x8eLFfp/H9ddfr//9738aNWqUvvrqKz322GM67bTT1KNHjwa1l5G8f85JSUk688wzJXmvO1deeaXmz58vt9vdKOcGAACCgxYNAACg0QwdOlQLFy5URUWF1q1bp3fffVfPPvusxo8fr7Vr1x71hlL79+9XSUmJevXqVWtbnz595PF4lJmZqb59+yojI0OXXXZZvWq68847VVZWph9++MF3k636uvnmm3X55ZcrJCREsbGx6tu3r+x2e615Xbp0Oea+qts7HK19xS+//CJJmjRp0hHn5Ofn+4WnNTkcDr9gtj5SUlJqheJt2rTRjz/+6Df22muv6a9//as2b96syspK33hd556amlprf5J8PXN37NghSerevXut93bv3t0vpPvll1+Un59/xL6j9b3hVGpqqhITE9W3b1+/gPBEKCoqkqSAw3bJ+9n06NFDISH+6zD69Onj215Tfb736jJx4kTNnDlT69at07x583TVVVcds2XF6aeffsSbrAVizpw56tKli+x2u7Zu3SrJ26YlMjJSc+fO1ZNPPnnU9x84cECPPPKI5s+fX+vPPz8/v9b8o30/OhwO7dixQyEhIb52FdXquhY1hvj4eI0ePfqY88aOHauxY8eqpKRE3333nd566y3NmjVL559/vjZv3hxQL16326358+frzDPP9PUQl7xh81//+lctWbJEY8aMadD5AACA4CPgBQAAjc5ms2no0KEaOnSoevbsqeuuu04LFiwIyt3aL7roIs2fP19PPfWUXn/99VrB2dH06NGjXkFMYwWG1atz//KXvxxxpXHNFa+H6927t3744QdlZmaqY8eO9TrmkVYeG4bhez5nzhxNnjxZF198se6++24lJibKarVq+vTpvuA60H3Wl8fjUWJi4hFvBhXo6tWmsH79eiUmJsrhcJzwYzX0e2/YsGHq1q2b7rzzTm3bts3XA/pEKygo0AcffKCysjL16NGj1vZ58+bpiSeeOGrYfMUVV2jlypW6++67NWjQIEVHR8vj8ejcc8+tc4V7Y34/BkNkZKROO+00nXbaaYqPj9cjjzyiTz755Kg/CDrc559/rr1792r+/PmaP39+re1z584l4AUAwMQIeAEAwAl18sknS5L27t3rG6srvElISFBkZKS2bNlSa9vmzZsVEhLiCy27deum9evX1+v4F198scaMGaPJkycrJiZGL774YkNO47hVrw5cv359nStXa85xOBz1CpYPd8EFF+jNN9/UnDlzNG3atIYXe5i3335bXbt21cKFC/3+7Boa2Hfq1EmSfKs3azp8rFu3bvrss880cuTIE77ytjGsWrVKGRkZfm0vAtGpUyf9+OOP8ng8fj+M2Lx5s297Y5kwYYIef/xx9enTJ6DWJcdj4cKFKisr04svvlhrNfCWLVv0wAMPaMWKFTr11FPrfP/Bgwe1ZMkSPfLII3rwwQd949Wr3xuiU6dO8ng8ysjI8Fu1W9e1KNjqup7Wx9y5c5WYmKjnn3++1raFCxfq3Xff1axZs0zxdwwAANRGD14AANAoli5dWueKuOr+ljWDk6ioKOXl5fnNs1qtGjNmjP773/9q+/btvvF9+/Zp3rx5OvXUU30rIi+77DJfC4jD1VXDtddeq5kzZ2rWrFm65557GnJ6x23MmDGKiYnR9OnTVVZW5retuuYhQ4aoW7dueuaZZ3y/5l/T/v37j3qM8ePHq3///nriiSe0atWqWtsLCwt1//33B1x79QrImp/tN998U+cx6qN9+/bq16+fXn/9db/zXL58uX766Se/uVdccYXcbrcee+yxWvtxuVy1vo+CaceOHZo8ebJsNpvuvvvuBu3jN7/5jbKysvTWW2/5xlwul/7+978rOjpaZ5xxRmOVqxtvvFEPPfSQ/vrXvzbaPo9lzpw56tq1q2699VaNHz/e7/H//t//U3R09BFXa0t1fy9K0owZMxpc03nnnSdJmjlzZqPt83gtWbKkzvG6rqfHUlpaqoULF+r888+v9ZmPHz9eU6dOVWFhYb16pQMAgOaJFbwAAKBR3HHHHSopKdEll1yi3r17q6KiQitXrtRbb72lzp0767rrrvPNHTJkiD777DP97W9/U/v27dWlSxcNGzZMjz/+uBYvXqxTTz1Vt99+u0JDQ/XSSy+pvLxcTz/9tO/9d999t95++21dfvnluv766zVkyBAdOHBA77//vmbNmqWBAwfWqm/q1KkqKCjQ/fffL6fTqfvuu69JPpdqDodDzz77rG688UYNHTpUEydOVJs2bbRu3TqVlJTotddeU0hIiF5++WWdd9556tu3r6677jp16NBBu3fv1tKlS+VwOPTBBx8c8RhhYWFauHChRo8erdNPP11XXHGFRo4cqbCwMG3YsEHz5s1TmzZt9MQTTwRU+/nnn6+FCxfqkksu0bhx47Rt2zbNmjVLaWlpdQbR9fHkk0/qoosu0siRI3Xdddfp4MGD+sc//qF+/fr57fOMM87QLbfcounTp2vt2rUaM2aMwsLC9Msvv2jBggV67rnnNH78+AbVcDy+//57zZkzRx6PR3l5eVq9erXeeecdWSwWvfHGGxowYECD9nvzzTfrpZde0uTJk/Xdd9+pc+fOevvtt7VixQrNmDGjQX19j6RTp056+OGH6z3/7bffrrNFyDnnnKOkpKRjvn/Pnj1aunRprZuZVbPb7Ro7dqwWLFigmTNnKiwsrNYch8Oh008/XU8//bQqKyvVoUMHffrpp359ZQM1aNAgTZgwQS+88ILy8/M1YsQILVmypM4V5o1h9+7dmjNnTq3x6OhoXXzxxZK8rWW6dOmiCy64QN26dVNxcbE+++wzffDBBxo6dKguuOACv/euWbNGjz/+eK19jho1Srt371ZhYaEuvPDCOusZPny4EhISNHfuXF155ZXHf4IAAKDJEfACAIBG8cwzz2jBggX6+OOP9c9//lMVFRVKTU3V7bffrgceeECxsbG+uX/72990880364EHHlBpaakmTZqkYcOGqW/fvvryyy81bdo0TZ8+XR6PR8OGDdOcOXM0bNgw3/ujo6P15Zdf6qGHHtK7776r1157TYmJiTr77LOVkpJyxBrvu+8+5efn+0LeKVOmnMiPpJYbbrhBiYmJeuqpp/TYY48pLCxMvXv31l133eWbM2rUKK1atUqPPfaY/vGPf6ioqEjJyckaNmyYbrnllmMeo3v37lq7dq2effZZvfvuu3rvvffk8XjUvXt33XjjjUcM145m8uTJysrK0ksvvaRFixYpLS1Nc+bM0YIFC7Rs2bKA9ycdaifx8MMP695771WPHj306quv6rXXXtOGDRv85s6aNUtDhgzRSy+9pPvuu0+hoaHq3Lmzrr76ao0cObJBxz9eb775pt58802FhobK4XCoR48euvPOO3XrrbfWuqlXICIiIrRs2TLde++9eu2111RQUKBevXrplVde0eTJkxvvBBrgtttuq3N86dKl9Qp458+fL4/HUyucrOmCCy7QO++8o08++eSIgeS8efN0xx136Pnnn5dhGBozZow++eQTtW/fvn4nUod///vfvpDzvffe01lnnaWPPvqo3r2sA7F27Vpdc801tcY7derkC3hffvll/fe//9V//vMf7dmzR4ZhqGvXrrr//vt1zz33KDTU/3/jvvnmG33zzTe19vnYY4/p22+/VXh4uM4555w66wkJCdG4ceM0d+5c5ebmKi4u7vhPEgAANCmLYZa7CwAAAKDFGzRokBISErR48eJglwIAAACYAj14AQAA0OQqKyvlcrn8xpYtW6Z169Zp1KhRwSkKAAAAMCFW8AIAAKDJbd++XaNHj9bVV1+t9u3ba/PmzZo1a5acTqfWr1/Pr4kDAAAA9UQPXgAAADS5Nm3aaMiQIXr55Ze1f/9+RUVFady4cXrqqacIdwEAAIAAsIIXAAAAAAAAAEyKHrwAAAAAAAAAYFIEvAAAAAAAAABgUvTghSl5PB7t2bNHMTExslgswS4HAAAAAACgURiGocLCQrVv314hIazNxLER8MKU9uzZo44dOwa7DAAAAAAAgBMiMzNTKSkpwS4DJkDAC1OKiYmR5L3YORyOIFcDAAAAAADQOAoKCtSxY0df9gEcCwEvTKm6LYPD4SDgBQAAAAAALQ4tKVFfNPIAAAAAAAAAAJMi4MVxeeqpp2SxWHTnnXf6xsrKyjRlyhTFxcUpOjpal112mfbt2+f3vp07d2rcuHGKjIxUYmKi7r77brlcriauHgAAAAAAADA3Al402OrVq/XSSy9pwIABfuN33XWXPvjgAy1YsEDLly/Xnj17dOmll/q2u91ujRs3ThUVFVq5cqVee+01vfrqq3rwwQeb+hQAAAAAAAAAU7MYhmEEuwiYT1FRkU466SS98MILevzxxzVo0CDNmDFD+fn5SkhI0Lx58zR+/HhJ0ubNm9WnTx+tWrVKw4cP1yeffKLzzz9fe/bsUVJSkiRp1qxZuueee7R//37ZbLZjHr+goEBOp1P5+flH7cHrdrtVWVnZOCeNIwoLC5PVag12GQAAAAAAmF59Mw+gGjdZQ4NMmTJF48aN0+jRo/X444/7xr/77jtVVlZq9OjRvrHevXsrNTXVF/CuWrVK/fv394W7kjR27Fjddttt2rBhgwYPHnzc9RmGoaysLOXl5R33vlA/sbGxSk5Opgk8AAAAAABAEyLgRcDmz5+v77//XqtXr661LSsrSzabTbGxsX7jSUlJysrK8s2pGe5Wb6/eVpfy8nKVl5f7XhcUFBy1xupwNzExUZGRkYSOJ5BhGCopKVF2drYkqV27dkGuCAAAAAAAoPUg4EVAMjMz9fvf/16LFy9WeHh4kx13+vTpeuSRR+o11+12+8LduLi4E1wZJCkiIkKSlJ2drcTERNo1AAAAAAAANBFusoaAfPfdd8rOztZJJ52k0NBQhYaGavny5Zo5c6ZCQ0OVlJSkioqKWq0R9u3bp+TkZElScnKy9u3bV2t79ba6TJs2Tfn5+b5HZmbmEWus7rkbGRnZ0NNEA1R/3vQ8BgAAAAAAaDoEvAjI2WefrZ9++klr1671PU4++WT99re/9T0PCwvTkiVLfO/ZsmWLdu7cqfT0dElSenq6fvrpJ9+v9EvS4sWL5XA4lJaWVudx7Xa7HA6H3+NYaMvQtPi8AQAAAAAAmh4tGhCQmJgY9evXz28sKipKcXFxvvEbbrhBf/jDH9S2bVs5HA7dcccdSk9P1/DhwyVJY8aMUVpamq655ho9/fTTysrK0gMPPKApU6bIbrc3+TkBAAAAAAAAZkXAi0b37LPPKiQkRJdddpnKy8s1duxYvfDCC77tVqtVH374oW677Talp6crKipKkyZN0qOPPhrEqgEAAAAAAADzoUUDjtuyZcs0Y8YM3+vw8HA9//zzOnDggIqLi7Vw4cJavXU7deqkjz/+WCUlJdq/f7+eeeYZhYby84bJkyfLYrHo1ltvrbVtypQpslgsmjx5st/cwx/nnnuuli1bVue2mo9ly5ZJknbt2iWbzVZrZTYAAAAAAACaPxI1oJnp2LGj5s+fr2effVYRERGSpLKyMs2bN0+pqal+c88991y98sorfmN2u11RUVHau3evb+z3v/+9CgoK/Oa2bdtWkvTqq6/qiiuu0BdffKFvvvlGw4YNO1GnBgAAAAAAgEZGwAs0MyeddJIyMjK0cOFC/fa3v5UkLVy4UKmpqerSpYvfXLvdXmt1dLWa4xERESovL6811zAMvfLKK3rhhReUkpKi2bNnE/ACAAAAAACYCAEvWgXDMFRa6W7y40aEWWWxWAJ+3/XXX69XXnnFF/D++9//1nXXXedrq9BYli5dqpKSEo0ePVodOnTQiBEj9OyzzyoqKqpRjwMAAAAAAIATg4AXrUJppVtpDy5q8uNufHSsIm2B/zW7+uqrNW3aNO3YsUOStGLFCs2fP79WwPvhhx8qOjrab+y+++7TfffdV6/jzJ49W1dddZWsVqv69eunrl27asGCBb4+vwAAAAAAAGjeCHiBZighIUHjxo3Tq6++KsMwNG7cOMXHx9ead+aZZ+rFF1/0G6vurXsseXl5Wrhwob766ivf2NVXX63Zs2cT8AIAAAAAAJgEAS9ahYgwqzY+OjYox22o66+/XlOnTpUkPf/883XOiYqKUvfu3Ru0/3nz5qmsrMyv565hGPJ4PPr555/Vs2fPBu0XAAAAAAAATYeAF62CxWJpUKuEYDr33HNVUVEhi8WisWMbP5yePXu2/vjHP9ZarXv77bfr3//+t5566qlGPyYAAAAAAAAal7kSL6AVsVqt2rRpk+95XcrLy5WVleU3FhoaWmc7h5rWrl2r77//XnPnzlXv3r39tk2YMEGPPvqoHn/8cYWGcokAAAAAAABozkhvgGbM4XAcdfv//vc/tWvXzm+sV69e2rx581HfN3v2bKWlpdUKdyXpkksu0dSpU/Xxxx/rwgsvDLxoAAAAAACaiMvt0d78Mu08UKKdB0q0I7dEqW0jNXFYarBLA5qMxTAMI9hFAIEqKCiQ0+lUfn5+rRC0rKxM27ZtU5cuXRQeHh6kClsfPncAAAAAwIlQVO7SztwS7TxQ7AtxqwPd3QdL5fL4R1undo/XnBuHHWFvzd/RMg+gLqzgBQAAAAAAQNB4PIb2FZZpZ26JdhwoUWaN1biZB0qUW1xx1PfbrCFKaRuh1LaR6tQ2Uv06OJuocqB5IOAFAAAAAADACVVW6fauuq2x+tYb4hYr82CpKlyeo76/TWSYUuOifCFuattIpcZ5vyY5wmUNsTTRmQDNDwEvAAAAAAAAjothGMopqqgKbou1M7dUOw4UK7NqJW52YflR328NsahDbIQ6xUWqY40Qt2NVkOsID2uiMwHMh4AXAAAAAAAAx1Th8mjXwRorcA9rqVBS4T7q+2PsoUqNi/SFuN7VuN5Vue1jwxVqDWmiMwFaFgJeAAAAAAAA1LIzt0RLNu/Tsi37tTW7SHvyS2UYR55vsUjtnRHqWN0PNy7KbzVubGSYLBZaKQCNjYAXAAAAAAAAcrk9+n5nnpZs3qclm7K1Nbuo1pyIMKtf/9uaLRU6tImQPdQahMqB1o2AFwAAAAAAoJXKL63U8p/36/NN+7Ts5/3KK6n0bbOGWHRK57Y6u0+iBnWMVWpcpBKi7azCBZoZAl4AAAAAAIBW5Nf9Rfp8c7Y+27RPq7cflNtzqO9CbGSYzuyVqLN6J+r0nglyRnBzM6C5I+AFAAAAAABowSrdHq3efkCfb8rWks3Z2pZT7Le9R2K0zuqTqNF9kjS4Yyw3OwNMhoAXaAaO9estDz30kCZPnqwuXbrUuX3VqlUaPny43G63/vKXv+jVV1/Vjh07FBERoR49euimm27SjTfeKEmaPHmy8vLy9N577x31mLt27VLXrl3Vs2dPrV+/vkHnBQAAAAAIjoPFFVr+8359tmmflv+8X4VlLt+2MKtFw7vG6aze3pW6neKiglgpgONFwAs0A3v37vU9f+utt/Tggw9qy5YtvrHo6Gjl5ORIkj777DP17dvX7/1xcXGSpEceeUQvvfSS/vGPf+jkk09WQUGB1qxZo4MHDwZc06uvvqorrrhCX3zxhb755hsNGzasIacGAAAAAGgChmFoa3aRlmzO1pJN+/TdjoOq0XlBbaNsOrNXokb3SdSpPeIVE07rBaClIOAFmoHk5GTfc6fTKYvF4jcmyRfwxsXF1dpW7f3339ftt9+uyy+/3Dc2cODAgOsxDEOvvPKKXnjhBaWkpGj27NkEvAAAAADQzFS4PPp22wF9tmmfPt+crZ0HSvy2906O0dl9EnV2nyQNTImVNYSbowEtEQEv0IIkJyfr888/1+23366EhIQG72fp0qUqKSnR6NGj1aFDB40YMULPPvusoqL4tR0AAAAACKaconIt27JfSzbt05e/5Kio/FDrBZs1ROnd4jS6T6LO7J2olDaRQawUQFMh4EXrYBhSZcmx5zW2sEjpGP11AzVixAiFhPg3vC8qKpIk/e1vf9P48eOVnJysvn37asSIEbrooot03nnnBXSM2bNn66qrrpLValW/fv3UtWtXLViwQJMnT26s0wAAAAAA1INhGNqcVajPq1ov/JCZJ6NG64WEGLvO6pWos/skamT3eEXZiXqA1oa/9WgdKkukJ9s3/XHv2yPZGnfV61tvvaU+ffrUuS0tLU3r16/Xd999pxUrVuiLL77QBRdcoMmTJ+vll1+u1/7z8vK0cOFCffXVV76xq6++WrNnzybgBQAAAIAmUFbp1te/5mrJpmx9vjlbu/NK/bb3be/Q2X2SdHbvRPXv4FQIrReAVo2AFzCZjh07qnv37kfcHhISoqFDh2ro0KG68847NWfOHF1zzTW6//771aVLl2Puf968eSorK/PruWsYhjwej37++Wf17NmzUc4DAAAAAHBIdkGZlm7J1mebsvXVLzkqrXT7ttlDQ3Rq93id3SdJZ/VOVLIzPIiVAmhuCHjROoRFelfTBuO4QZaWliZJKi4urtf82bNn649//GOt1bq33367/v3vf+upp55q7BIBAAAAoNUxDEMb9hRUrdLdp3W78v22JzvCdVafRI3uk6j0rvGKsFmDVCmA5o6AF62DxdLorRKCJTc3V1lZWX5jsbGxCg8P1/jx4zVy5EiNGDFCycnJ2rZtm6ZNm6aePXuqd+/evvn5+flau3at3z7i4uKUm5ur77//XnPnzvWbL0kTJkzQo48+qscff1yhoVw6AAAAAKC+Kt0e/bq/WJv2Fmjj3gJt2lugDXsKdKC4wm/ewI6xOrt3os7qnai+7R2yNPI9XQC0TKQ0gMmMHj261tibb76pq666SmPHjtWbb76p6dOnKz8/X8nJyTrrrLP08MMP+4Wyy5Yt0+DBg/32ccMNNygiIkJpaWm1wl1JuuSSSzR16lR9/PHHuvDCCxv/xAAAAACgBcgvrdTmGkHuxr0F+nlfkSpcnlpzI21Wndo9XqP7JGlU7wQlxtB6AUDgLIZR896LgDkUFBTI6XQqPz9fDofDb1tZWZm2bdumLl26KDyc/zg2FT53AAAAAK2JYRjadbBUG/YU+K3M3XWwtM750fZQ9WkXo7R2DvVp51Bae4d6JcfIHkrrBfg7WuYB1IUVvAAAAAAAAEdRVunWz/sKvUHungJt2ut9XljuqnN+h9gIpbWvCnKrHiltIhQSQssFAI2PgBcAAAAAYGqGYWj19oN689ud+ubXXFmtFtlDrbJZQ2QPC5E9NMT7OrSO52He13bftrq31/ne0BDZw7zHCbNa6JfaQuwvLPetxq0OdH/NKZbbU/sXoG3WEPVMjlaf5EOrcvskO+SMDAtC5QBaKwJeAAAAAIApHSiu0MLvd+nNb3cqY39xUGuxWFR3AOwXFtcOne11hMX1DaUPPw4hc2Bcbo+25RRro6+9QqE27ilQTlF5nfPbRtmq2ivEKK29Q2ntnOqaEKUwa0gTVw4A/gh4AQAAAACmYRiGVv2aq/nfZup/67NU4fbeuCrSZtUFA9rrokHtFW6zqrzSowq3R+WVbpW7PCp3eVTh8qjcVfW60qMKt1vllXVsq3Nu7X1VH9tbl1RW6VFZZe0baTWl6sDXVh0eHyEMth8lLLbVnBMWIpv1KPs6LJS2WUOaZchcWFapzVmFVe0VvIHulqxClddx4zOLReoSH+XXXiGtvUOJMfZmeW4AQMALAAAAAGj2corK9c53uzR/daa25Rxarduvg0MTTknVhQPbKya8aX8t3uMxvMFvdRh8rLC4XqHzkfdV4TrsWG7vWE3V+5Xq7g3bFGx1BMm2qjDYfsQVynUFy1XvOUprDF+wXOO9OUXlvj65G/fma9PeQu08UFJnrZE2q3onx/j1y+2VHKNIG3EJAPPgioUWyzBq90fCicPnDQAAgMbm8RhamZGrN7/dqU83ZqnS7f03Z5TNqosGd9CEoanqn+IMWn0hIRaFh1gVHmaVFJyeqzVD5jrD4Mo6wuHDQudyl3/wfPjc8hr7qqj52nXodU0VVfsoDGLIXJd2zvCqFgsOX6DbqW0kNz4DYHoEvGhxwsK8/7AqKSlRREREkKtpPUpKvD8Rr/78AQAAgIbKLizTgjW79NbqTL+VlwM7xmrC0I66YGB7Rdn531np8JA5OAzj8JD5CGHxYSuUvaHy0VcoH2n74cepGTKHhljUPTG6qk+uwxfqtomyBe0zAoATif8iosWxWq2KjY1Vdna2JCkyMpI+SSeQYRgqKSlRdna2YmNjZbUG7x+WAAAAMC+Px9CXW3P05jc79dmmfXJ5vKt1Y+yhunhwB111Skf1bR+81bo4MovFUtUeIbghc6XbUJnLrfCqdg4A0FoQ8KJFSk5OliRfyIsTLzY21ve5AwAAAPWVlV+mBWsyNX91pnbnlfrGT0qN1YRTUjVuQDv6oeKYLBaLbKEWgl0ArRL/lUSLZLFY1K5dOyUmJqqysjLY5bR4YWFhrNwFAABAvbk9hpb/nK1532Rq6ZZsuatW6zrCQ3XpSSmacEqqeiXHBLlKAADMgYAXLZrVaiV4BAAAAJqJPXmlemt1phasydSe/DLf+Cmd2+qqUzrqN/3bBbWXLAAAZkTACwAAAAA4YVxujz7fnK35qzO1bEu2qhbrKjYyTJedlKIJp3RU90RW6wIA0FAEvAAAAACARpd5oET/WZOp/6zJ1L6Cct/48K5tNeGUVI3tm8xqXQAAGgEBLwAAAACgUVS6PVqyaZ/mfZupL3/ZL6NqtW7bKJsuH5KiK4d2VNeE6OAWCQBAC0PACwAAAAA4LjtyizV/daYWrNmlnKJDq3VP7R6vCaek6py0JNlCQ4JYIQAALRcBLwAAAAAgYBUujz7dmKX532bqq605vvH4aLsuPzlFVw3tqE5xUUGsEACA1oGAFwAAAABQb7/uL9JbqzP19ne7lFtcIUmyWKTTeiRo4ikddXafJIVZWa0LAEBTIeAFAAAAABxVWaVbizZk6c1vd+rrXw/4xhNj7LpyaEddcXJHdWwbGcQKAQBovQh4AQAAAAB1yjxQojlf79B/1mTqYEmlJCnEIo3qlagJp6TqzF4JCmW1LgAAQUXACwAAAADw8XgMfbk1R6+v3K7Pt2TLMLzj7ZzhuuLkjrpiaEd1iI0IbpEAAMCHgBcAAAAAoPzSSr3z3S698fUObcsp9o2f1iNe16Z31lm9E2UNsQSxQgAAUBcCXgAAAByVYRhyeQxumgS0UJuzCvT6qh169/vdKq10S5Ji7KG6bEiKrknvpG4J0UGuEAAAHA0BLwAAAGrJPFCilRk5WrE1VyszcpVTVK7YyDAlxtiVEGNXYky4EmLsSoi2K9FR82u4HBGhslhY5Qc0Z5VujxZv3KfXVm7XN9sO3TStZ1K0rk3vrEsGd1CUnf9dBADADPgvNgAAAJRbVK6VGbm+UHfngZJac/JKKpVXUqmf9xUddV+20BAlRFcHwYcFwjXG4qPtsoWyKhhoStmFZZr/babmfbNTWQVlkiRriEVj0pJ0bXpnDe/alh/QAABgMgS8AAAArVBRuUvfbsvViq25WrE1R5uzCv22W0MsGpji1Mju8RrRLV49kqJ1oLhC+wvLlV1Y5v1aUK79RYe+7i8sV35ppSpcHu3OK9XuvNJj1tEmMswvAK4Of/3D4HA5wlkVDDSUYRj6fmeeXl+1XR//tFeVbu9d0+KjbZpwSqomDktVOyc3TQMAwKwIeAEAAFqBcpdbP+zM08qtOVqRkat1mXlyeQy/Ob2TY6oC3Tid0qWtYsLD/LbHR9vVMynmqMcpq3Qrp6hc2YXlVWGw96v3UeY35vIYOlhSqYP1WBVsDw05FPzWaAfh1x6ialUwvYIBr7JKt95ft0evr9qu9bsLfOODU2M1Kb2zzuufLHuoNYgVAgCAxkDACwAA0AK5PYY27Mmv6qGbo9XbD6is0uM3J7VtpEZ2j9OIbvFK7xan+Gj7cR83PMyqlDaRSmkTedR5Ho+h/NLKGkFwWa1AuHqsoMylcpdHuw6WatfBY68Kbhtl8+sN7L8i+FCrCFYFo6XKPFCiOV/v0FtrMpVXUinJ2zrlooHtdW16Z/VPcQa5QgAA0JgIeAEAAFoAwzCUsb+4qodujr7+9YDySyv95sRH2zSiW7wv1O3Y9ugh7IkUEmJRmyib2kTZ1Cv52KuC9xce1g6ioKxWe4jqVcEHiit0oLhCW/YVHnW/1auCE+sIgGv2Do6LtrEqGM2ex2Poq605en3Vdi3ZnC2jaoF+h9gIXZPeSVec3FFto2zBLRIAAJwQBLwAAAAmtTe/1LtCd2uOVmbk+m6YVC3aHqrhXdtWhbrx6pkUbcoVq+FhVnVsG3nMQNrjMZRXWulb+VtzRXB2VYuI6teFDVgVfHh/YO8q4XC/FhExdlYFo2kVlFXq7TW79MbXO7Qtp9g3flqPeF2b3lln9U6UNYTvSQAAWjICXgAAAJPIK6nQqoxcrcjI0cqtufq1RpgjeX8Fe0hqG+8K3e7xGtDBqdBWtPI0JMSitlE2tY2yqXfy0edWrwrOrtEbuHYgXK6cIv9VwYffjO5w4WEhh8LfOm4cVz0WH21rVX82aHxbsgr1+qrteveH3SqpcEuSYuyhumxIiq5J76RuCdFBrhAAADQVAl4AAIBmqqTCpdXbD1bdGC1HG/YU+H7tWpJCLFL/Dk6N6B6vkd3idXLnNgoP44ZJ9RHIquCDJRWH2kHU7BNcVK7sqlYR+wvKVVjuUlmlR5kHSpV54Oirgi0WqW2krc7+wP6BsF3RrApGlUq3R4s37tNrK7frm20HfOM9k6J1bXpnXTK4g6Ls/C8eAACtDf/1BwAALcbSLdla+P1uhVikSJtVEWGh3q82qyKrHhG2UEX5xqq2h1VvD1V4WEjQwrRKt0drM/O0cqt3le4POw+q0m34zemeGK2R3bwrdId3jZMzIiwotbYWISEWxUXbFRdtP+aq4NKK6l7B/jeMq9knOLuwTDlFFXJ7DOUWVyi3nquCfTeHq3HzuOq2EAnR4Up02BUXxarglmp/Ybnmf7tTc7/Z6WvFYg2xaExakq5N76zhXdvyQwAAAFoxAl4AAGB6pRVuPfnxJr3x9Y7j3pfFIl/gG2GzKsoW6guIqwNj/9A49FBAbA9VZFjN7f4Bc0SY1S+E8XgMbcoq8AW632474PtV62rtneHeFbpVN0ZLcoQf9znixIiwWZUaF6nUuGOvCj5QUuG/Grgq/K0ey6nuFVy1KnjngRLtPFBy1P1aLFJclE3x0Ue6YdyhlcGsCm7+DMPQ9zvz9Pqq7fr4p72+H/bER9s04ZRUTRyWqnbOiCBXCQAAmgMCXgAAYGrrd+fr9/N/UMZ+bz/aq4enqnNclEor3CqpdHu/VrhUUuF9XlzhqhrzPkorvdvLKj2SJMOQb9uJcCgMtqqozKWDJZV+29tEhmlEt3ild4vTyO7x6hwXSRDXwoSEWBQfbVd8tF192h19bkmFSzmFFX7hr18gXNU6IqeoXB5DyimqUE7RsVcFR4RZ62wHcXgw3JZVwU2urNKt99ft0eurtmv97gLf+ODUWE1K76zz+ifLHkorFgAAcAgBLwAAMCW3x9C/vvxVf/10iyrdhhJj7PrrFQN1Wo+EBu3P4zFUWllHAFwVEHuDYLeKy11HDI9LaryuKzyWpNJK73hu1f3RIm1WndKlrUZ2i9eI7nHqk+xQCHe8R5VIW6hS40KPuSrYXXUjuMN7A9dsD1H9KCr3fj8Hsio44fD+wH6tIsJ9q4LRcJkHSjTn6x16a02m8qp+8GMLDdFFA9vr2vTO6p/iDHKFAACgueJfYQAAwHT25JXqD/9Zq69/9d5k6Ny+yZp+aX+1ibI1eJ8hIRZF2UNPyA2KqsPjmquISyrcCg2xqE87h2yhrJDE8bGGWHwrcY+lpMJ11PYQ1WOHrwretPfo+420WesOf6P9VwnHRdtl5YcYkrzXhq+25uj1Vdu1ZHO27yaKHWIjdE16J11xcke1PY7rGgAAaB0IeAEAgKl8sG6P7n/3JxWUuRRps+rhC/rq8pNTmnUbgxMZHgOBirSFqlNcqDrFRR11XvWq4Orw9/AAuGYwXFy1an1Hbol25B59VXCIRWobdXhbiJoh8KHVws3974zL7VFx1cr+kgqXisrdKil3qajcpeIKl4rLvduKy12+eUXl3h/wFJW7tPtgqXbnlfr2d1qPeF2b3lln9U4kBAcAAPXWvP/FBAAAUKWwrFIP/XeDFv6wW5I0sGOsZlw5SF3ijx5SAWiYQFYFF5e7arSHKNf+Qv8WEdVfc32rgr0rhOuzKriu8DfhsFYRcVH1WxVc4fLUCllrhrPFvmC2RjhbI6itfl/183KX55jHPJZoe6jGD0nRNemd1C0h+rj3BwAAWh8CXgAA0Oyt2X5Ad/1nrTIPlCrEIk09s7vuOLuHwrj5E9AsVK9Q73yMH7i4PYZyi+teDXx4q4jqXtbbc0u0vR6rguOivYFvfIxdhmH4wtvicrcvtK10G4152j5h1qpV+rZQRdmtR3geqmi7VZG2UEVXfV7R4aEa0qkN/YsBAMBx4V8SAACg2ap0e/T3Jb/oH0u3ymNIKW0iNOPKQTq5c9tglwagAawhFiXGhCsxJlx9jzG3uNx1zD7B2YXlyi32rgquHtMxVgVLkj00pCqUtvrC19oBrH8YG2Wz+uZVvy/aHqpIu1X2UGujfD4AAAANQcALAACape05xbrzrbVam5knSbr0pA565MK+igkPC25hAJpElD1UXeyhx2zD4nJ7qnoFl/vaRIRW9b2Otocq0matEdJ6A1lW/wMAgJaEgBcAADQrhmHoP2sy9cgHG1VS4ZYjPFRPXNJfFwxsH+zSADRDodYQJTrClegID3YpAAAAQUHACwAAmo2DxRWatvAn/W9DliRpeNe2+tsVg9Q+NiLIlQEAAABA80TACwAAmoWvfsnRHxes1b6CcoVZLfrjmF666bSusoZYgl0aAAAAADRbBLwAACCoyird+suiLZr91TZJUteEKM28arD6dXAGuTIAAAAAaP4IeAEAQNBsySrU7+f/oM1ZhZKkq4en6v7fpCnCxh3pAQAAAKA+CHgBAECT83gMvbpyu57632ZVuDyKi7Lp6fEDdHafpGCXBgAAAACmQsALAACaVHZBmf7f2z/qi5/3S5LO7JWgp8cPVEKMPciVAQAAAID5EPACAIAm8+mGLN278CcdKK6QPTRE94/ro2uGd5LFwo3UAAAAAKAhCHgBAMAJV1Lh0mMfbtSb32ZKktLaOfTcVYPUIykmyJUBAAAAgLkR8AIAgBNqXWae7nxrrbblFMtikW4+rav+MKan7KHcSA0AAAAAjhcBLwAAOCHcHkOzlmfo2cU/y+UxlOwI19+uHKgR3eKDXRoAAAAAtBgEvAAAoNHtOliiP7y1Tt9uPyBJGte/nZ64pJ9iI21BrgwAAAAAWhYCXgAA0Kje+2G3/vTeehWWuxRls+qRi/rpspM6cCM1AAAAADgBCHgBAECjyC+t1J/eW6/31+2RJJ2UGqsZVw5WalxkkCsDAAAAgJaLgBcAABy3b37N1R/+s06780plDbHojrO6a+qZ3RVqDQl2aQAAAADQohHwAgCABqtweTTjs5/14vIMGYaU2jZSM64apJNS2wS7NAAAAABoFQh4AQBAg2TsL9Kd89fqp935kqTLh6TooQv7KtrOPy8AAAAAoKnwf2AAADQxwzB0oLhC+wrKZQ8LkTMiTM6IMIWZpJ2BYRia9+1OPf7hJpVWuuWMCNNTl/bXef3bBbs0AAAAAGh1CHgBAGhkbo+h7MIy7T5Yqt15pdp10PvYnVeq3QdLtCevTKWV7lrvi7RZfWGvo+prbNVXZ0SYnJH+22o+mioczi0q1z3v/KTPNu2TJI3sHqdnLh+ods6IJjk+AAAAAMAfAS8AAAEqd7m1N6+sKrAt1a6qr7vzSrQ7r1R788rk8hjH3E9clE0Vbo8Ky1ySpJIKt0oq3NqbXxZwTVFV4XBd4W/NcPjwhyOAcHjZlmzd/faP2l9YLps1RHeP7aUbTu2ikBBLwPUCAAAAABoHAS8AAIcpLnfVEd56V9/uOliq/UXlMo6R31pDLGrnDFeH2Ah1aBOhlKqvHWIj1aFNhNo5wxUeZpXkXfFbUFqp/CM86tqWV+IdLyz3hsPFFW4VV7i1p5HC4djDAuEt+wo15+udkqQeidF67qrBSmvvCPhYAAAAAIDGRcALAGhVDMNQXklljdYJJb4wd3ee95FXUnnM/dhDQ6oC2wilVH2tGeAmxdgVWs+VsdYQi9pE2dQmyhbw+biqVgAfKxzOK6k93pBwePKIzrr3vN6+cBoAAAAAEFwEvACAFsXjMZRdWK7deSU1+t76fy2pqN3/9nAx4aFV4W3kYQGu92tclE0WS/BbE4RaQ05YOJxfWqn8qmDY5TF09fBUjeqVeALOAgAAAADQUAS8AABTqXB5lJVfpl15JbWC210HS7U3v1SV7mP3v42Pth/WOqFGiNsmQo7wsCY4m+A6nnAYAAAAANA8EPACAJqVkgpXHb1vD33dV1hWr/63yY4a/W8PW4HbPjaCFgMAAAAAgBaBgBcA0GQMw1B+aeURWyfszivVgeKKY+7HFhpS98rbqq/JjvB6978FAAAAAMDMCHgBAI3G4zGUU1Tut/p210H/VgrF9el/aw/1C2wPrcSNVIfYCMVHN4/+twAAAAAABBsBLwCg3irdVf1v/Vbelvie78krU4Xbc8z9xEfb/MPb2Ah1qApvO7SJkDOi5fe/BQAAAACgMRDwAgB8SivcvlYJvvC2RpibVVAmzzH634ZY5O1/67cCN9IvzI2w0f8WAAAAAIDGQMALAK1Ifmml9wZmB0tq9b7dfbBUufXpf2sNUftYb4CbUjO4rfqa7AxXGP1vAQAAAABoEgS8ANBCGIah/UXltW9cVuNrYbnrmPuJtofW6n3r64EbG6H4aLtCQuh/CwAAAABAc0DACwAm4XJ7lFVQViu43VVjFW6F69j9b9tG2XytElLaHB7gRsoREcoNzAAAAAAAMAkCXgBoJsoq3Udcebs7z9v/1n2MBriW6v63dazATWkTofaxEYq0cekHAAAAAKCl4P/yAaCJVbg8+mHnQa3MyNXW7CLtqgpxc4rKj/neMKtF7WMP3aysQ5sIpbSJ9AW49L8FAAAAAKB1IeBFQF588UW9+OKL2r59uySpb9++evDBB3XeeedJkkaNGqXly5f7veeWW27RrFmzfK937typ2267TUuXLlV0dLQmTZqk6dOnKzSUb0e0TB6PoY17C7Ria45WZORq9bYDKq101zk3ymY9bOVtpN8K3AT63wIAAAAAgBpI1BCQlJQUPfXUU+rRo4cMw9Brr72miy66SD/88IP69u0rSbrpppv06KOP+t4TGRnpe+52uzVu3DglJydr5cqV2rt3r6699lqFhYXpySefbPLzAU4EwzC0PbdEK7bmaGVGjlZl5OpgSaXfnPhom9K7xWtgilMpbSK9vXBjIxQbGUb/WwAAAAAAUG8WwzCO3tAROIa2bdvqL3/5i2644QaNGjVKgwYN0owZM+qc+8knn+j888/Xnj17lJSUJEmaNWuW7rnnHu3fv182m61exywoKJDT6VR+fr4cDkdjnQrQYNkFZVqRkaMVW3O1cmuO9uSX+W2PtodqWJe2GtE9XiO7x6lXUgxBLgAAAACgFjIPBIoVvGgwt9utBQsWqLi4WOnp6b7xuXPnas6cOUpOTtYFF1ygP/3pT75VvKtWrVL//v194a4kjR07Vrfddps2bNigwYMHN/l5AA2RX1qpb37N1cqMXK3YmqNfsov8ttusIRqcGquR3eM1snu8BqQ46Y0LAAAAAAAaHQEvAvbTTz8pPT1dZWVlio6O1rvvvqu0tDRJ0sSJE9WpUye1b99eP/74o+655x5t2bJFCxculCRlZWX5hbuSfK+zsrKOeMzy8nKVlx+6AVVBQUFjnxZwVGWVbn2346Cvj+5Pu/LkqfH7DxaL1K+9UyO6x2lkt3gN7dxWETZr8AoGAAAAAACtAgEvAtarVy+tXbtW+fn5evvttzVp0iQtX75caWlpuvnmm33z+vfvr3bt2unss89WRkaGunXr1uBjTp8+XY888khjlA/Ui9tj6Kfd+d5Ad2uO1uw4qAqXx29O14QojezmbbkwvGucYiPr12IEAAAAAACgsRDwImA2m03du3eXJA0ZMkSrV6/Wc889p5deeqnW3GHDhkmStm7dqm7duik5OVnffvut35x9+/ZJkpKTk494zGnTpukPf/iD73VBQYE6dux43OcCVDMMQ1uzi3wrdL/+NVeFZS6/OUkOu0Z2i/f10W3njAhStQAAAAAAAF4EvDhuHo/Hr31CTWvXrpUktWvXTpKUnp6uJ554QtnZ2UpMTJQkLV68WA6Hw9fmoS52u112u71xC0ertzuvVCu25mjl1hytzMhVdqH/97EjPFTp3eI0snu8RnSLV7eEKG6MBgAAAAAAmhUCXgRk2rRpOu+885SamqrCwkLNmzdPy5Yt06JFi5SRkaF58+bpN7/5jeLi4vTjjz/qrrvu0umnn64BAwZIksaMGaO0tDRdc801evrpp5WVlaUHHnhAU6ZMIcDFCXewuEKrfvXeFG1lRq625RT7bbeHhmho57ZVN0aLU9/2TllDCHQBAAAAAEDzRcCLgGRnZ+vaa6/V3r175XQ6NWDAAC1atEjnnHOOMjMz9dlnn2nGjBkqLi5Wx44dddlll+mBBx7wvd9qterDDz/UbbfdpvT0dEVFRWnSpEl69NFHg3hWaKlKKlz6dtsBrczwhrob9xbIqHFjNGuIRQNSnFVtF+J0UmobhYdxYzQAAAAAAGAeFsOoGXcA5lBQUCCn06n8/Hw5HI5gl4NmwOX2aE9embblFmvtzjytyMjRDzsPqtLtf4nrlRSjEd3jNLJbvIZ1bauY8LAgVQwAAAAAQG1kHggUK3gBmIbbY2hPXqm25xZre06xtuWUeJ/nFivzQEmtMFeSOsRG6NTu3hW6I7rFKyGGViAAAAAAAKDlIOAFguR/67O0v6hcSTF2JTrClRhjV0KMXWHWkGCXFlQej6E9+aXakVuibTneIHd7brG25RQr80CpKtyeI77XFhqiznGR6pkUoxHdvH10U9tGcmM0AAAAAADQYhHwAkEy79ud+uLn/X5jFovUNtKmhBi7kqpC30SHXYkx4Upy2JUQc2jMHmreXrEej6GsgjLvKtzcYr8wd8eBElW4jhLiWkOUGhepznFR6hIfqc7xUeoSF6VO8VFq5whXCDdFAwAAAAAArQgBLxAkw7q0lT00RNkFZcouLNf+wnK5PIZyiyuUW1yhzVmFR31/bGSYEquC4IQYbwhc/dobCnvHImzBCYINw9C+gnJvcOtrqeANc7fnFqv8KCFumNWi1LbeELdzfJQvxO0cH6l2zghZCXEBAAAAAAAkEfACQTPlzO5+rz0eQwdLKrSvoFzZhYdC330FZcquGttX4B2rcHuUV1KpvJJK/byv6KjHiQkPPRT81mgH4ftatS3KHvjlwDAMZReW12ijUOJ7vj23WGWVRw5xQ0OqQtz4KHWKi1SX+KiqVblRah9LiAsAAAAAAFAfBLxAMxESYlFctF1x0Xal6ch3yTQMQ/mllcr2C3+rQuEa4fC+gjKVVXpUWOZSYZlLGfuLj3r8KJtViVWrgZMOC38TY+yyhlh8q2+rw9wducUqqXAfcZ/WEIs6tonwrsKtCm+rw9wOsREKbeX9hgEAAAAAAI4XAS9gMhaLRbGRNsVG2tQzKeaI8wzDUGG561Do6/fVGwDvL/Q+Lyp3qbjCrW1VbRQCEWKRUtpU98KN9LVU6BwXpZQ2Ea3+pnEAAAAAAAAnEgEv0EJZLBY5wsPkCA9T98Too84tLnd5VwEXlNUKf6tbQ1S4POoUd6gvbpf4yKoQN1K2UEJcAAAAAACAYCDgBaAoe6i62EPVJT4q2KUAAAAAAAAgACy7AwAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMKDXYBaBrbtm3Tl19+qR07dqikpEQJCQkaPHiw0tPTFR4eHuzyAAAAAAAAADQAAW8LN3fuXD333HNas2aNkpKS1L59e0VEROjAgQPKyMhQeHi4fvvb3+qee+5Rp06dgl0uAAAAAAAAgAAQ8LZggwcPls1m0+TJk/XOO++oY8eOftvLy8u1atUqzZ8/XyeffLJeeOEFXX755UGqFgAAAAAAAECgLIZhGMEuAifGokWLNHbs2HrNzc3N1fbt2zVkyJATXFXjKCgokNPpVH5+vhwOR7DLAQAAAAAAaBRkHggUK3hbsPqGu5IUFxenuLi4E1gNAAAAAAAAgMYWEuwC0DTy8/P19ttv65lnntFf//pXLVy4UAUFBQHv58UXX9SAAQPkcDjkcDiUnp6uTz75xLe9rKxMU6ZMUVxcnKKjo3XZZZdp3759fvvYuXOnxo0bp8jISCUmJuruu++Wy+U67nMEAAAAAAAAWhtW8LYCc+bM0dSpU2sFuk6nU7NmzdKVV15Z732lpKToqaeeUo8ePWQYhl577TVddNFF+uGHH9S3b1/ddddd+uijj7RgwQI5nU5NnTpVl156qVasWCFJcrvdGjdunJKTk7Vy5Urt3btX1157rcLCwvTkk0826nkDAAAAAAAALR09eFu477//XsOGDdNvf/tb3XXXXerdu7cMw9DGjRs1Y8YMzZ8/X6tXr9bAgQMbfIy2bdvqL3/5i8aPH6+EhATNmzdP48ePlyRt3rxZffr00apVqzR8+HB98sknOv/887Vnzx4lJSVJkmbNmqV77rlH+/fvl81mq9cx6UcDAAAAAABaIjIPBIoWDS3c3//+d1188cV69dVXNXDgQNntdoWHh+ukk07S66+/rgsvvFDPPfdcg/btdrs1f/58FRcXKz09Xd99950qKys1evRo35zevXsrNTVVq1atkiStWrVK/fv394W7krdXcEFBgTZs2HDEY5WXl6ugoMDvAQAAAAAAALR2BLwt3IoVK3TLLbcccfutt96qr776KqB9/vTTT4qOjpbdbtett96qd999V2lpacrKypLNZlNsbKzf/KSkJGVlZUmSsrKy/MLd6u3V245k+vTpcjqdvkfHjh0DqhkAAAAAAABoiQh4W7g9e/aoZ8+eR9zes2dP7d69O6B99urVS2vXrtU333yj2267TZMmTdLGjRuPt9SjmjZtmvLz832PzMzME3o8AAAAAAAAwAy4yVoLV1JSovDw8CNut9vtKisrC2ifNptN3bt3lyQNGTJEq1ev1nPPPacrr7xSFRUVysvL81vFu2/fPiUnJ0uSkpOT9e233/rtb9++fb5tR6vTbrcHVCcAAAAAAADQ0hHwtgKLFi2S0+msc1teXt5x79/j8ai8vFxDhgxRWFiYlixZossuu0yStGXLFu3cuVPp6emSpPT0dD3xxBPKzs5WYmKiJGnx4sVyOBxKS0s77loAAAAAAACA1oSAtxWYNGnSUbdbLJZ672vatGk677zzlJqaqsLCQs2bN0/Lli3zhcg33HCD/vCHP6ht27ZyOBy64447lJ6eruHDh0uSxowZo7S0NF1zzTV6+umnlZWVpQceeEBTpkxhhS4AAAAAAAAQIALeFs7j8TTq/rKzs3Xttddq7969cjqdGjBggBYtWqRzzjlHkvTss88qJCREl112mcrLyzV27Fi98MILvvdbrVZ9+OGHuu2225Senq6oqChNmjRJjz76aKPWCQAAAAAAALQGFsMwjGAXAQSqoKBATqdT+fn5cjgcwS4HAAAAAACgUZB5IFAhwS4AJ9bPP/9c66ZmS5Ys0ZlnnqlTTjlFTz75ZJAqAwAAAAAAAHC8CHhbuHvuuUcffvih7/W2bdt0wQUXyGazKT09XdOnT9eMGTOCVyAAAAAAAACABqMHbwu3Zs0a/d///Z/v9dy5c9WzZ08tWrRIkjRgwAD9/e9/15133hmkCgEAAAAAAAA0FCt4W7icnBylpKT4Xi9dulQXXHCB7/WoUaO0ffv2IFQGAAAAAAAA4HgR8LZwbdu21d69eyVJHo9Ha9as0fDhw33bKyoqxH32AAAAAAAAAHMi4G3hRo0apccee0yZmZmaMWOGPB6PRo0a5du+ceNGde7cOWj1AQAAAAAAAGg4evC2cE888YTOOeccderUSVarVTNnzlRUVJRv+xtvvKGzzjoriBUCAAAAAAAAaCiLwe/nt3gul0sbNmxQQkKC2rdv77dt3bp1SklJUVxcXJCqa5iCggI5nU7l5+fL4XAEuxwAAAAAAIBGQeaBQLGCtxUIDQ3VwIED69x2pHEAAAAAAAAAzR8Bbwt36aWX1jnudDrVs2dP3XjjjUpISGjiqgAAAAAAAAA0Bm6y1sI5nc46H3l5efrXv/6lXr16af369cEuEwAAAAAAAEAD0IO3FfN4PLrpppuUnZ2tDz74INjlBIR+NAAAAAAAoCUi80CgWMHbioWEhOh3v/udvvvuu2CXAgAAAAAAAKABCHhbuaioKJWUlAS7DAAAAAAAAAANQMDbyi1evFg9e/YMdhkAAAAAAAAAGiA02AXgxHr//ffrHM/Pz9d3332nl19+WS+//HITVwUAAAAAAACgMRDwtnAXX3xxneMxMTHq1auXXn75ZV111VVNWxQAAAAAAACARkHA28J5PJ5glwAAAAAAAADgBKEHLwAAAAAAAACYFAFvCzZ//vx6z83MzNSKFStOYDUAAAAAAAAAGhsBbwv24osvqk+fPnr66ae1adOmWtvz8/P18ccfa+LEiTrppJOUm5sbhCoBAAAAAAAANBQ9eFuw5cuX6/3339ff//53TZs2TVFRUUpKSlJ4eLgOHjyorKwsxcfHa/LkyVq/fr2SkpKCXTIAAAAAAACAAFgMwzCCXQROvJycHH311VfasWOHSktLFR8fr8GDB2vw4MEKCTHfQu6CggI5nU7l5+fL4XAEuxwAAAAAAIBGQeaBQLGCt5WIj4/XxRdfHOwyAAAAAAAAADQi8y3dBAAAAAAAAABIIuAFAAAAAAAAANMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuBtZSoqKrRlyxa5XK5glwIAAAAAAADgOBHwthIlJSW64YYbFBkZqb59+2rnzp2SpDvuuENPPfVUkKsDAAAAAAAA0BAEvK3EtGnTtG7dOi1btkzh4eG+8dGjR+utt94KYmUAAAAAAAAAGio02AWgabz33nt66623NHz4cFksFt943759lZGREcTKAAAAAAAAADQUK3hbif379ysxMbHWeHFxsV/gCwAAAAAAAMA8CHhbiZNPPlkfffSR73V1qPvyyy8rPT09WGUBAAAAAAAAOA60aGglnnzySZ133nnauHGjXC6XnnvuOW3cuFErV67U8uXLg10eAAAAAAAAgAZgBW8rceqpp2rt2rVyuVzq37+/Pv30UyUmJmrVqlUaMmRIsMsDAAAAAAAA0AAWwzCMYBcBBKqgoEBOp1P5+flyOBzBLgcAAAAAAKBRkHkgUKzgbSU+/vhjLVq0qNb4okWL9MknnwShIgAAAAAAAADHi4C3lbj33nvldrtrjRuGoXvvvTcIFQEAAAAAAAA4XgS8rcQvv/yitLS0WuO9e/fW1q1bg1ARAAAAAAAAgONFwNtKOJ1O/frrr7XGt27dqqioqCBUBAAAAAAAAOB4EfC2EhdddJHuvPNOZWRk+Ma2bt2qP/7xj7rwwguDWBkAAAAAAACAhiLgbSWefvppRUVFqXfv3urSpYu6dOmiPn36KC4uTs8880ywywMAAAAAAADQAKHBLgBNw+l0auXKlVq8eLHWrVuniIgIDRgwQKeffnqwSwMAAAAAAADQQBbDMIxgFwEEqqCgQE6nU/n5+XI4HMEuBwAAAAAAoFGQeSBQrOBtwWbOnKmbb75Z4eHhmjlz5lHn/u53v2uiqgAAAAAAAAA0FlbwtmBdunTRmjVrFBcXpy5duhxxnsVi0a+//tqElR0/fpoFAAAAAABaIjIPBIoVvC3Ytm3b6nwOAAAAAAAAoGUICXYBOPEqKyvVrVs3bdq0KdilAAAAAAAAAGhEBLytQFhYmMrKyoJdBgAAAAAAAIBGRsDbSkyZMkV//vOf5XK5gl0KAAAAAAAAgEZCD95WYvXq1VqyZIk+/fRT9e/fX1FRUX7bFy5cGKTKAAAAAAAAADQUAW8rERsbq8suuyzYZQAAAAAAAABoRAS8rcQrr7wS7BIAAAAAAAAANDJ68LZwHo9Hf/7znzVy5EgNHTpU9957r0pLS4NdFgAAAAAAAIBGQMDbwj3xxBO67777FB0drQ4dOui5557TlClTgl0WAAAAAAAAgEZAwNvCvf7663rhhRe0aNEivffee/rggw80d+5ceTyeYJcGAAAAAAAA4DgR8LZwO3fu1G9+8xvf69GjR8tisWjPnj1BrAoAAAAAAABAYyDgbeFcLpfCw8P9xsLCwlRZWRmkigAAAAAAAAA0ltBgF4ATyzAMTZ48WXa73TdWVlamW2+9VVFRUb6xhQsXBqM8AAAAAAAAAMeBgLeFmzRpUq2xq6++OgiVAAAAAAAAAGhsBLwt3CuvvBLsEgAAAAAAAACcIPTgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuAFAAAAAAAAAJMi4AUAAAAAAAAAkyLgBQAAAAAAAACTIuBFQKZPn66hQ4cqJiZGiYmJuvjii7Vlyxa/OaNGjZLFYvF73HrrrX5zdu7cqXHjxikyMlKJiYm6++675XK5mvJUAAAAAAAAANMLDXYBMJfly5drypQpGjp0qFwul+677z6NGTNGGzduVFRUlG/eTTfdpEcffdT3OjIy0vfc7XZr3LhxSk5O1sqVK7V3715de+21CgsL05NPPtmk5wMAAAAAAACYmcUwDCPYRcC89u/fr8TERC1fvlynn366JO8K3kGDBmnGjBl1vueTTz7R+eefrz179igpKUmSNGvWLN1zzz3av3+/bDbbMY9bUFAgp9Op/Px8ORyORjsfAAAAAACAYCLzQKBo0YDjkp+fL0lq27at3/jcuXMVHx+vfv36adq0aSopKfFtW7Vqlfr37+8LdyVp7NixKigo0IYNG5qmcAAAAAAAAKAFoEUDGszj8ejOO+/UyJEj1a9fP9/4xIkT1alTJ7Vv314//vij7rnnHm3ZskULFy6UJGVlZfmFu5J8r7Oysuo8Vnl5ucrLy32vCwoKGvt0AAAAAAAAANMh4EWDTZkyRevXr9dXX33lN37zzTf7nvfv31/t2rXT2WefrYyMDHXr1q1Bx5o+fboeeeSR46oXAAAAAAAAaGlo0YAGmTp1qj788EMtXbpUKSkpR507bNgwSdLWrVslScnJydq3b5/fnOrXycnJde5j2rRpys/P9z0yMzOP9xSCj/bXAAAAAAAAOE4EvAiIYRiaOnWq3n33XX3++efq0qXLMd+zdu1aSVK7du0kSenp6frpp5+UnZ3tm7N48WI5HA6lpaXVuQ+73S6Hw+H3ML0f3pDmXSVlbwp2JQAAAAAAADApWjQgIFOmTNG8efP03//+VzExMb6euU6nUxEREcrIyNC8efP0m9/8RnFxcfrxxx9111136fTTT9eAAQMkSWPGjFFaWpquueYaPf3008rKytIDDzygKVOmyG63B/P0mo7HLS3/i5S/U/plkTRoojTqPsnZIdiVAQAAAAAAwEQshsHviaP+LBZLneOvvPKKJk+erMzMTF199dVav369iouL1bFjR11yySV64IEH/Fbd7tixQ7fddpuWLVumqKgoTZo0SU899ZRCQ+v3M4eCggI5nU7l5+ebdzVvzi/SkkekTR94X4eGS8NulU69S4qIDWppAAAAAAAgOFpE5oEmRcALU2pRF7vM1dLiB6WdK72vw2Ol0/+fNPQmKSw8qKUBAAAAAICm1aIyDzQJevACwdZxqHTdx9KEt6SEPlJZnvTpA9I/TpbWvult5wAAAAAAAADUgYAXaA4sFqnXudJtK6SLnpccHaT8TOm9W6VZp0m/LJZYbA8AAAAAAIDDEPACzUmIVRp8tXTHd9LoRyS7U8reIM0dL712gbT7u2BXCAAAAAAAgGaEgBdojsIipFPvlH6/Vhpxh2S1S9u/lP51lvSfSVJuRrArBAAAAAAAQDNAwAs0Z5FtpTGPe1f0DpwoySJtfE96/hTpoz9KRdnBrhAAAAAAAABBRMALmEFsR+mSF6Vbv5J6jJE8Lmn1y9Jzg6Sl06XywmBXCAAAAAAAgCAg4AXMJLmf9NsF0qQPpfYnSZXF0vKnpJmDpW//Jbkrg10hAAAAAAAAmhABL2BGXU6TbvpcuvxVqW1XqXi/9PH/87ZuWL9QMoxgVwgAAAAAAIAmQMALmJXFIvW9RJryrTTur1JUonTgV+nt67w3Y9v2RbArBAAAAAAAwAlGwAuYnTVMGnqj9LsfpFH3SbZoac/30msXSHPGS1nrg10hAAAAAAAAThACXqClsEdLo+7xBr1Db5JCQqWti6VZp0rv3irl7Qx2hQAAAAAAAGhkBLxASxOdKI17xtu6oe8lkgxp3ZvS34dIi+6XSg4Eu0IAAAAAAAA0EgJeoKWK6+a9CdtNn0udT5PcFdKqf0jPDZK+elaqLA12hQAAAAAAADhOBLxAS9dhiDTpA+m370hJ/aTyfOmzh6WZJ0nfvyF53MGuEAAAAAAAAA1EwAu0BhaL1GO0dMuX0iUvSc6OUuEe6f2p0osjpC2fSIYR7CqB1sMwpPIiqWg/f/cAAAAAAMfFYhj8nyXMp6CgQE6nU/n5+XI4HMEux3wqy6TVL0tfPiOVHvSOpY6QznlE6nhKcGsDmjNXuVReKJUXVH0tqvpaKFUUHnru21Y1r6LIf1tFkWR4vPuMaS/1HCv1Ok/qcroUFhHccwQAAAAQVGQeCBQBL0yJi10jKc2TVsyQvn5RcpV5x3qfL41+WIrvEcTCgEbkdlWFr4eHrEcIY+sKZKsfnsoTW2tohNT1DG/g2/NcydH+xB4PAAAAQLND5oFAEfDClLjYNbL83dKy6dLaud5VhRardNI10qhpUkxysKtDa2QYUkVxw1bHHr5StrKk8euzRXsf9piqR7Rkd3if+40f9rDVmGeP8bZP2b5C+vkT6edFUn6m/3GSB3iD3l7nSu0GSyF0VgIAAABaOjIPBIqAF6bExe4Eyd4sLXlE2vKx93VYpDT8dmnk76VwPmccg2EcamFQa3Vs4bED2cPH1cj/ebLaa4SxMQ0IZKMPjYVYG7c2yfv5ZW/09sT+eZG0a7X8PoOoRKnnGG/g2/VMbz0AAAAAWhwyDwSKgBemxMXuBNuxSlr8oLTrW+/ryDhp6I1SVIIUavcGZaG2qq92/7HQcMlqqz0WEupdrYjmx9fCoI5A9lirY33BbdGJaWFgsR5ldexhq2FtNYPbmvMc3m2htsat7UQrzpF+Wexd3bv1c++fUTWrTep8mjfs7TlWatMpeHUCAAAAaFRkHggUAS9MiYtdEzAMafNH0mcPS7m/NMIOLTVC3+pQ2Fbja/iRQ2O/8LiucNlWx77DvONW22HPazxCrOYNnT0eqbL4sL6yDQhkywslV2nj11erhUFdK2Nj6g5kbTXmhUWY98+oMbkqpJ0rpS3/8wa+B7f7b09MO9S3N2XoiVlhDAAAAKBJkHkgUAS8MCUudk3I7ZLWzZO2fem9EZurXHKXewOn6q+usrrHDHewqz8GS+0QONR2hGC4rpD4SNvDDgXPdc4J84bRVpt3xWsgYWzNbSeshcHResoeHsYetorWHn3iWhjAyzCknF+kn//nfez82v/vWkRbqccYb+Db/Wwp3Bm8WgEAAAAEjMwDgSLghSlxsTMJj7tGIFz1cFccZayiRohcn7GKQ/s5fMztqvpaIbkrq75WBPsTaXyHtzBoSE9Zs7YwgFfJASnjc2/v3q2LpbL8Q9tCQqVOI6paOZwrxXULXp0AAAAA6oXMA4Ei4IUpcbFDgxiG5HEdCntdFYee+0LgGmGwu67tNZ67yuse93090vaq565ybwB3zDYGRwhkaWGAw7ldUuY3h1b35vzsvz2ux6FWDqnDvavJAQAAADQrZB4IFAEvTImLHQDUQ26G9Mun3rB3+wr/m+DZnd4WDr3Ok7qPliLbBq9OAAAAAD5kHggUAS9MiYsdAASorMDbyuHnRdIvi6SS3EPbLCFSx2GHWjkk9GJlOAAAABAkZB4IFAEvTImLHQAcB49b2v1dVSuHRdK+9f7bYzt5V/b2HCt1Gum9aSAAAACAJkHmgUAR8MKUuNgBQCPK2+kNen9eJG37wts/upotWup2ptRjjOTo4H9Dv3CHFBYlhYQEr3YAAACghSHzQKAIeGFKXOwA4AQpL5K2LT+0urdo3zHeYKnjJoGOup+HH2G8+saBBMUAAAAAmQcCFhrsAgAAQDNij5Z6j/M+PB5p71pv0LtjhVSW5+3lW14olRdIHpckw/u8vOD4j207LCiuMxA+Rnhsi5ZCrMdfCwAAAACYBAEvAACoW0iI1OEk7+NwhiG5yg+FveXVwW+NR1l+7bHyQqm8xnhZgeSp9O6zotD7KDzOuiPaSL1+Iw24Uup8GiuDAQAAALRotGiAKfHrCgDQgrjKq1YG1xES1xUe11xFXHOeu6L2vh0dpAFXSAOukhJ7N/25AQAAAAEi80CgCHhhSlzsAAC1VK8o3r9F+uk/0vp3vauFq7UbKA2cIPUbL0UnBK9OAAAA4CjIPBAoAl6YEhc7AMAxVZZ5bxa3br60dXFVz2BJFqvU/Wxp4FXeVg5hEcGtEwAAAKiBzAOBIuCFKXGxAwAEpDhHWr9QWvemtOf7Q+N2h5R2oXdlb+oI+vUCAAAg6Mg8ECgCXpgSFzsAQIPt/1n6cb7043+k/MxD485Ub7/egVdJ8T2CVx8AAABaNTIPBIqAF6bExQ4AcNw8HmnnSu+q3g3/lSoKD21rf1JVv97LpKi44NUIAACAVofMA4Ei4IUpcbEDADSqylJpy8dV/XqXSIbbOx4SKnU/x7uqt+e5Ulh4cOsEAABAi0fmgUAR8MKUuNgBAE6Yomxp/Tvelb171x0atzulvhdX9esdLlksQSsRAAAALReZBwJFwAtT4mIHAGgS2ZsP9est2H1oPLaTNOBK78reuG7Bqw8AAAAtDpkHAkXAC1PiYgcAaFIet7T9K28Lh03vSxVFh7alDPUGvX0vlSLbBq9GAAAAtAhkHggUAS9MiYsdACBoKoqlzR97Wzj8ulQyPN7xkDCp51hv2NtjjBRqD26dAAAAMCUyDwSKgBemxMUOANAsFGZJP73tXdm776dD4+GxUr9Lvf16U4bSrxcAAAD1RuaBQBHwwpS42AEAmp19G7xB74//kYqyDo237ert1zvgSqltl+DVBwAAAFMg80CgCHhhSlzsAADNlsctbVsurXvL26+3suTQto7DpYFXSn0vkSLaBK9GAAAANFtkHggUAS9MiYsdAMAUyoukzR9W9etdLqnqn11Wm9TzXGnQRG+/3hBrUMsEAABA80HmgUAR8MKUuNgBAEynYI/00wJvG4fsjYfG23SR0qd4w15bVPDqAwAAQLNA5oFAEfDClLjYAQBMyzCkrJ+8Qe/auVJZnnc8oo009EbplJul6MSglggAAIDgIfNAoAh4YUpc7AAALUJFsfTDXOnr56WD271jVpv3hmzpU6XE3kEtDwAAAE2PzAOBIuCFKXGxAwC0KB63t1fvyr9Lu1YfGu8xVhoxVep8mmSxBK8+AAAANBkyDwSKgBemxMUOANBi7fxGWjlT2vyRfDdlazdQGvE7Ke0iyRoW1PIAAABwYpF5IFAEvDAlLnYAgBYvN0Na9by0dp7kKvWOOTtKw26VTrpWCue/fwAAAC0RmQcCRcALU+JiBwBoNYpzpTWzpW9ekkpyvGN2hzRksjfsdXYIankAAABoXGQeCBQBL0yJix0AoNWpLJN+fEta9Q8p52fvWEio1O8y7w3Z2g0Ibn0AAABoFGQeCBQBL0yJix0AoNXyeKRfPvXekG3HV4fGu46S0u+Qup/NDdkAAABMjMwDgSLghSlxsQMAQNLu770reje8Jxlu71himndFb//xUqg9qOUBAAAgcGQeCBQBL0yJix0AADUc3CF9M0v6/nWposg7Fp0sDbtFOvk6KaJNcOsDAABAvZF5IFAEvDAlLnYAANShNE/67lVv2Fu41zsWFiWddI00/DapTecgFgcAAID6IPNAoAh4YUpc7AAAOApXhbRhobdP77713jFLiNTnQmnE76SUIcGtDwAAAEdE5oFAEfDClLjYAQBQD4Yh/bpUWvkPKWPJofHUEdKIO6Se50ohIcGrDwAAALWQeSBQBLwwJS52AAAEKGu9tOp56acFkqfSOxbXXUqfIg2cIIVFBLc+AAAASCLzQOAIeGFKXOwAAGiggr3Sty9Jq/8tled7xyLjpKE3SafcJEXFB7c+AACAVo7MA4Ei4IUpcbEDAOA4lRdKP8yRvn5BytvpHQsN967mTZ8ixfcIbn1o+QxDMjySxy15XJJR9dXjOex1XWNu78PvtevQ/uK6S3HdJIsl2GcJAEDAyDwQKAJemBIXOwAAGonbJW1633tDtj3fVw1apF7nefv0pqYTkjWUL8B01RFCug4LNt2HXtc1dsTws645dYWf9ZlTR2111nuk+o9yTkc6xxMpKlFKHe79Hu6ULiX1l6yhJ/aYAAA0AjIPBIqAF6bExQ4AgEZmGNKOldKqf0hbPj403mGIlD5V6nNh7XDMMI4cHDZ64BhAQHrU49QnID3WatF6rig90QFmSxcS6n1YrFXPrVWP6rHDX4d6bxpoeKT9WyR3hf/+bNFSylCp0whv8NvhZMkWGZxzAwDgKMg8ECgCXpgSFzsAAE6g/T9LXz8vrX1Tcpd7x8IiJUuIfxhqeIJbp5lZQo4SXNYYO+LrI80J9e7b73WN/R9zzhHqODxEPeacetZ2xFpCju/zrSyT9vwg7Vwp7fxa2vnNoZ7T1UJCpXaDvKt7U6sekW2P77gAADQCMg8EioAXpsTFDgCAJlC0X1r9srT6X1JJbmDv9QsV6xsoHv6eY8w5PHCsTwjZaAFpQ+uv2gdtL5qWxy1lb5J2rvKuVN+5SircW3teQu+qtg5Vq3xjU/mzAgA0OTIPBIqAF6bExQ4AgCbkKpfyMr2haX0DUkIxNGeGIeXt8K7u3VG1yjdnS+15jg5Vq3uHe1s7JPQ5/tXFAAAcA5kHAkXAC1PiYgcAAIBGVZxT1c5hlfexd523HUlN4U6p4/BDgW/7wVKoPTj1AgBaLDIPBIqAF6bExQ4AAAAnVEWxtGtNVei7UspcLVUW+8+x2r03Iqzu49vxFG8IDADAcSDzQKAIeGFKXOwAAADQpNwuKevHQyt8d6ySSnIOm2SRkvr537jN0S4o5QIAzIvMA4Ei4IUpcbEDAABAUBmGlJvhXd1b3cv34Lba89p0PnTTtk4jpLju9KgGABwVmQcCRcALU+JiBwAAgGanMOvQ6t6dq6R96yXD4z8nMt4b9qame1f6JvWXQm3BqRcA0CyReSBQBLwwJS52AAAAaPbKCqRd31YFvl9Lu9dIrjL/OVablJgmtR8ktRvk/ZqYxs3bAKAVI/NAoAh4YUpc7AAAAGA6rnJp7zpvO4edq6TMb6TSg7XnhYRJSWmHAt92g6SkvoS+ANBKkHkgUAS8MCUudgAAADA9w5Dydkh71kp71x76eqTQN7HPYSt9+0ph4U1YMACgKZB5IFAEvDAlLnYAAABokQxDytvpH/juWSuVHqg9NyTUG/r6rfTtR+gLACZH5oFAEfDClLjYAQAAoNUwDCk/s/ZK35Lc2nMt1tqhb3I/KSyiCQsGABwPMg8EioAXpsTFDgAAAK2aYUj5u2qv9C3JqT3XYpUSevu3d0jqJ9kim7BgAEB9kXkgUAS8MCUudgAAAMBhDEMq2F17pW/x/tpzLVYpoddhK337E/oCQDNA5oFAEfDClLjYAQAAAPVgGFLBntorfYuza8+1hEjxvfxX+ib3l2xRJ75Gj8v7cFdWPXdLnsoa465Dzz2VVdsPn1+1zTCkcIdkd0rh1Q+HFGo/secBAI2EzAOBIuCFKXGxAwAAAI5Dwd7aoW9RVu15lhApvqeU1FcKCasRsroOC2VrBKw1A9f6BLaGu2nOOTT8UOBrd/iHv+E1wuDDg+Hq52GRksXSNLUCaNXIPBAoAl78//buPEqL+swX+LeBplkbhGFVRHQiGhd0cjOOOmqiRk3UwfUmmSjCxJsRIRO9MYsTEjVzE4zGNY5Xs4jeMy4TjcboRCdGFjXgJBJOBFQ0i8uERWNkk63prvvHCy0ttDTY3W+/9udzTp2urqr3V0/pc/p0fbv4VUXyww4AAFrZqqVbT++wakn56unSbdtL1+qkS9dN31dv+tr1rX1FkaxflaxfmaxbUfraGqq6Ng2Ctwx/mwuFtwyTa2qTLl1apxbgPU3mwY7qVu4CAAAA6AD6Dk1Gn1BaNlu1rBT0vrao9PRqs6Hrlt9vGcC+QyDbtXqLz3TdYt+m71vradmG+k1h76bAd3Pou3m9yfYVW2zfYl9RX1rW/rm07JSqpKZvM08Rvz0wfvu+Tdu6dW+d/yYAvKd4gpeK5K9ZAABAuyiKZMObzYTCy9+2/e2B8ab1jetap5bqXtuZXmIbwfCW26t7mmYCKoDMgx3lCV4AAABoTlVVUtOntNQO37kxNq5v2ZPCzT1dvGFVaZy6NaVlW/Mlt0SX6pY9LdzcXMXd+5pmAqADEvACAABAW+pWk/QZVFp2RuM0Ey0Jhd+2bN5XNJRedLfmT6Vlp1SVgt6at4fBzQXGW673L+3rKoYAaG1+sgIAAEBH1qVr0nOX0rIziiLZsHrHQ+HGIHl5Ur8hSfHW9hU7eS3VvVvwFHFzL7Drl1T32MkTt4OG+qS+rhSkN2xM6jeW1us3fd+wcYv9m46t7vHW/9uaWlNoADtFwAsAAADvZVWbXvBW0zfpt+vOjVG3bgdD4bdt37B60zhvlpZVi3eujq7dt/+0cNfum4LU+uYD1vpN329z/xZfG499W2i7rQA37/IVR1VbBPlbLr0GbHv7lsGwqTOgUxPwAgAAAO+sukdp6TN45z5fv3HrgHh7ofC65W9tX7+yNM1E/YbkzddKSyWo6pp0rS7Nf9y1W9KlW9P1unXJ2jeSjWuTon7nptCo6tJM+Pu2YLjX24PhfoJheI8Q8AIAAABtq2u30pOovQbs3OcbGkpPATcbCm8RHNfXlcLTzcFql26bAtW3rXfd9H3jsVuGr9v6XHUzx77DeC2dcqFubbJ2ebL2z6XAd8tlzdu3bXFc3ZpS8L3m9dKyI6q6lOZGbskTw70GJMMOKk0XAnQ4Al4AAACgY+vSZdM0DLVJv93KXU3rq+5ZWmqH7djn6taVnnTeZhC8rbB409e6N0vB8No/l5aW2O2vk/EPll4aCHQoAl4AAACASlTdI6kemvQdumOf27h+05PAzQXBb9v2+m+T//5l8vNLkxOmtsWVAO+CgBcAAACgM+lWk/QdUlpaYtHDyZ0fT568MdnzQ8nex7dpecCOMZs2AAAAAM0bfUJyyMTS+o8nJisXl7ceoAkBLwAAAADv7COXJUMPLL3M7d7PJA315a4I2ETACwAAAMA761aTnDEtqe6dvPh48vjV5a4I2ETACwAAAMD2/cVfJideVVqfOTV5+cny1gMkEfACAAAA0FIHfTI58ONJUZ/86Nxk7Rvlrgg6PQEvAAAAAC134lXJgD2TFa8kP/lsUhTlrgg6NQEvAAAAAC1X0zc545akS3Xy7APJUz8od0XQqQl4AQAAANgxww9OPnJZaf3hf06WLSxvPdCJCXgBAAAA2HF/c37yvuOS+vXJ3ROSDWvKXRF0SgJeAAAAAHZcVVVyyv9N+gxN/rQoefjL5a4IOiUBLwAAAAA7p/dfJKd9N0lV8uvbkgX3lrsi6HQEvAAAAADsvD2PSo7436X1Bz6XvPFiWcuBzkbAyw6ZOnVqPvjBD6Zv374ZPHhwTjnllCxatKjJMevWrcukSZMycODA9OnTJ6effnqWLVvW5JiXX345J554Ynr16pXBgwfnC1/4QjZu3NielwIAAAC0lg9dnIw4JFm/Mrnn00l9Xbkrgk5DwMsOmTVrViZNmpQnn3wyjzzySOrq6nLcccflzTffbDzmwgsvzAMPPJC77747s2bNyuLFi3Paaac17q+vr8+JJ56YDRs2ZPbs2bntttty66235mtf+1o5LgkAAAB4t7pWJ6d/P+nRL/njU8mMb5S7Iug0qoqiKMpdBJXrtddey+DBgzNr1qwceeSRWbFiRQYNGpQ77rgjZ5xxRpLkueeey7777ps5c+bkb/7mb/LQQw/lpJNOyuLFizNkyJAkyU033ZQvfelLee2119K9e/ftnnflypXp169fVqxYkdra2ja9RgAAAKCFnrk/+eG4JFXJ2fcle3243BVVHJkHO8oTvLwrK1asSJIMGDAgSTJ37tzU1dXl2GOPbTxmn332ye677545c+YkSebMmZMDDjigMdxNkuOPPz4rV67MwoULt3me9evXZ+XKlU0WAAAAoIN5/9jkAxOSFMl9/5isfrXcFcF7noCXndbQ0JALLrgghx9+ePbff/8kydKlS9O9e/f079+/ybFDhgzJ0qVLG4/ZMtzdvH/zvm2ZOnVq+vXr17iMGDGila8GAAAAaBUnTE0G7ZusXpbcd17S0FDuiuA9TcDLTps0aVIWLFiQu+66q83PdfHFF2fFihWNyyuvvNLm5wQAAAB2QnXP5MxpSbeeye8eTebcUO6K4D1NwMtOmTx5ch588MHMmDEju+22W+P2oUOHZsOGDVm+fHmT45ctW5ahQ4c2HrNs2bKt9m/ety01NTWpra1tsgAAAAAd1OB9S0/yJsmjlyV/nFveeuA9TMDLDimKIpMnT859992X6dOnZ9SoUU32f+ADH0h1dXUeffTRxm2LFi3Kyy+/nEMPPTRJcuihh2b+/Pl59dW35uF55JFHUltbm/e///3tcyEAAABA2/rA+OT9pyQNG5N7/iFZ53060BaqiqIoyl0EleP888/PHXfckfvvvz+jR49u3N6vX7/07NkzSTJx4sT89Kc/za233pra2tp89rOfTZLMnj07SVJfX5+DDjoow4cPzxVXXJGlS5fm7LPPzrnnnptvfvObLarDGyUBAACgAqxdntx0RLLi5WT/M5LTv59UVZW7qg5N5sGOEvCyQ6qa+SE8bdq0jB8/Pkmybt26fP7zn8+dd96Z9evX5/jjj8+NN97YZPqFl156KRMnTszMmTPTu3fvnHPOObn88svTrVu3FtXhhx0AAABUiFd+mdxyQlLUJ2P/NTn4rHJX1KHJPNhRAl4qkh92AAAAUEEevyp59OtJda/kM7OSQXuXu6IOS+bBjjIHLwAAAABt6/ALk1FHJXVrSvPx1q0rd0XwniHgBQAAAKBtdemSnPbdpNdfJMvmJ498rdwVwXuGgBcAAACAttd3aHLqTaX1X96cPPfT8tYD7xECXgAAAADax/s+khw6ubR+//nJij+Wtx54DxDwAgAAANB+jrkkGXZQsvaN5N7/lTTUl7siqGgCXgAAAADaT7fuyRm3JN37JC/9InnsynJXBBVNwAsAAABA+xq4V3LSNaX1Wd9KXvxFeeuBCibgBQAAAKD9Hfg/kzF/nxQNpaka1vy53BVBRRLwAgAAAFAeH7syGfiXyco/JvdPSoqi3BVBxRHwAgAAAFAeNX1K8/F27Z4s+mnyy++VuyKoOAJeAAAAAMpn2JjkI/9SWv/ZlGTp/PLWAxVGwAsAAABAeR3yj8neH03q1yd3T0g2vFnuiqBiCHgBAAAAKK+qqmTsvyZ9hyWvv5A89MVyVwQVQ8ALAAAAQPn1Hpic9r0kVcm8f0vm31PuiqAiCHgBAAAA6BhGHZEctenp3QcuSP78+7KWA5VAwAsAAABAx3HkF5PdD0s2rEru+XSycUO5K4IOTcALAAAAQMfRtVty+veSHv2Txb9Opv9LuSuCDk3ACwAAAEDH0m+30kvXkmT29clvf17eeqADE/ACAAAA0PHse1LywXNL6/edl6xaVt56oIMS8AIAAADQMR33jWTI/smbryX3fSZpaCh3RdDhCHgBAAAA6JiqeyRn3JJU90p+PzOZfV25K4IOR8ALAAAAQMc1aHTy0W+V1qf/n+S/nypvPdDBCHgBAAAA6NgOPjvZ77SkYWNyz4Rk7fJyVwQdhoAXAAAAgI6tqio5+dqk/8hk+cvJgxckRVHuqqBDEPACAAAA0PH16Feaj7dLt2Thfcmv/1+5K4IOQcALAAAAQGXY7X8kR3+1tP7Ql5JXnytvPdABCHgBAAAAqByH/VOy19HJxrXJPf+Q1K0td0VQVgJeAAAAACpHly7JKTclvQclry5Mfjal3BVBWQl4AQAAAKgsfYckp95cWv/V95NnflLeeqCMBLwAAAAAVJ6/PCY5/HOl9Z9MTpa/Ut56oEwEvAAAAABUpqO/muz6gWTdiuRH5yb1G8tdEbQ7AS8AAAAAlalrdXL6D5Ka2uSVJ5NZ3yp3RdDuBLwAAAAAVK4Bo5KTrimtP3Zl8ofHy1sPtDMBLwAAAACV7YAzkoPPSlIkPz4/qa8rd0XQbrqVuwAAAAAAeNc+ekWy+tXkqC+Vpm6ATkLACwAAAEDl6947+dTd5a4C2p0pGgAAAAAAKpSAFwAAAACgQgl4AQAAAAAqlIAXAAAAAKBCCXgBAAAAACqUgBcAAAAAoEIJeAEAAAAAKpSAFwAAAACgQgl4AQAAAAAqlIAXAAAAAKBCCXgBAAAAACqUgBcAAAAAoEIJeAEAAAAAKpSAFwAAAACgQgl4AQAAAAAqlIAXAAAAAKBCCXgBAAAAACqUgBcAAAAAoEIJeAEAAAAAKpSAFwAAAACgQgl4AQAAAAAqVLdyFwA7oyiKJMnKlSvLXAkAAABA69mcdWzOPmB7BLxUpFWrViVJRowYUeZKAAAAAFrfqlWr0q9fv3KXQQWoKvw5gArU0NCQxYsXp2/fvqmqqmrcvnLlyowYMSKvvPJKamtry1ghbJ9+pZLoVyqFXqWS6FcqhV6lkrwX+rUoiqxatSrDhw9Ply5mV2X7PMFLRerSpUt22223ZvfX1tZW7A9yOh/9SiXRr1QKvUol0a9UCr1KJan0fvXkLjvCnwEAAAAAACqUgBcAAAAAoEIJeHlPqampySWXXJKamppylwLbpV+pJPqVSqFXqST6lUqhV6kk+pXOyEvWAAAAAAAqlCd4AQAAAAAqlIAXAAAAAKBCCXgBAAAAACqUgBcAAAAAoEIJeNkpU6dOzQc/+MH07ds3gwcPzimnnJJFixY1OWbdunWZNGlSBg4cmD59+uT000/PsmXLGvf/5je/ySc/+cmMGDEiPXv2zL777pvrrruu2XP+4he/SLdu3XLQQQdtt76iKPK1r30tw4YNS8+ePXPsscfmhRdeaHLMN77xjRx22GHp1atX+vfv3+Jrf/rpp3PEEUekR48eGTFiRK644oom+xcuXJjTTz89e+yxR6qqqnLttde2eGzahn5tvl9vvfXWVFVVNVl69OjR4vFpffq1+X6tq6vL17/+9ey1117p0aNHxowZk4cffrjF49O6Omuvrlu3LuPHj88BBxyQbt265ZRTTtnqmCeeeCKHH354Bg4cmJ49e2afffbJNddc06LxaRv6tfl+HT9+/Fa/C1RVVWW//fZr0TloXZ21V2fOnJmxY8dm2LBh6d27dw466KDcfvvtTY5xn9Xx6Nfm+9V9Fu1NwMtOmTVrViZNmpQnn3wyjzzySOrq6nLcccflzTffbDzmwgsvzAMPPJC77747s2bNyuLFi3Paaac17p87d24GDx6cf/u3f8vChQvzla98JRdffHFuuOGGrc63fPnyjBs3Lsccc0yL6rviiity/fXX56abbsp//dd/pXfv3jn++OOzbt26xmM2bNiQM888MxMnTmzxda9cuTLHHXdcRo4cmblz5+bKK6/MpZdemu9+97uNx6xZsyZ77rlnLr/88gwdOrTFY9N29Gvz/ZoktbW1WbJkSePy0ksvtfgctD792ny/TpkyJTfffHO+853v5Jlnnsl5552XU089NfPmzWvxeWg9nbVX6+vr07Nnz/zTP/1Tjj322G0e07t370yePDmPPfZYnn322UyZMiVTpkzZ6ucv7Ue/Nt+v1113XZPfA1555ZUMGDAgZ555ZovPQ+vprL06e/bsHHjggfnRj36Up59+OhMmTMi4cePy4IMPNh7jPqvj0a/N92viPot2VkArePXVV4skxaxZs4qiKIrly5cX1dXVxd133914zLPPPlskKebMmdPsOOeff37x4Q9/eKvtH//4x4spU6YUl1xySTFmzJh3rKWhoaEYOnRoceWVVzZuW758eVFTU1PceeedWx0/bdq0ol+/ftu5wpIbb7yx2GWXXYr169c3bvvSl75UjB49epvHjxw5srjmmmtaNDbtR7++1a87Mh7loV/f6tdhw4YVN9xwQ5PPnXbaacWnPvWpFp2DttVZenVL55xzTjF27NgWHXvqqacWZ5111g6fg7ahX5t33333FVVVVcWLL764w+eg9XXGXt3sYx/7WDFhwoRt7nOf1THp17f61X0W7c0TvLSKFStWJEkGDBiQpPRXuLq6uiZPCuyzzz7ZfffdM2fOnHccZ/MYm02bNi2///3vc8kll7Solj/84Q9ZunRpk3P369cvhxxyyDueuyXmzJmTI488Mt27d2/cdvzxx2fRokV544033tXYtB/92rRfV69enZEjR2bEiBEZO3ZsFi5c+K7OS+vSr2/16/r167f6p209e/bME0888a7OTevoLL26M+bNm5fZs2fnqKOOavdzs236tXk/+MEPcuyxx2bkyJHtfm621pl7dVs107Hp16Y1u8+iPXUrdwFUvoaGhlxwwQU5/PDDs//++ydJli5dmu7du281h82QIUOydOnSbY4ze/bs/Pu//3v+4z/+o3HbCy+8kC9/+ct5/PHH061by9p18/hDhgxp8blbaunSpRk1atRW427et8suu7yr8Wl7+rVpv44ePTq33HJLDjzwwKxYsSLf/va3c9hhh2XhwoXZbbfd3tX5eff0a9N+Pf7443P11VfnyCOPzF577ZVHH3009957b+rr69/VuXn3OlOv7ojddtstr732WjZu3JhLL7005557brudm+bp1+YtXrw4Dz30UO644452PS/b1pl79Yc//GF+9atf5eabb27VcWk7+rVpv7rPor15gpd3bdKkSVmwYEHuuuuunR5jwYIFGTt2bC655JIcd9xxSUpzhv393/99Lrvssuy9997b/Nztt9+ePn36NC6PP/74Ttfwdvvtt1/juB/96EdbbVzKS782deihh2bcuHE56KCDctRRR+Xee+/NoEGD/DLdQejXpq677rq8733vyz777JPu3btn8uTJmTBhQrp08etMuenVbXv88cfz1FNP5aabbsq1116bO++8s9VqY+fp1+bddttt6d+//zZfxkb766y9OmPGjEyYMCHf+973vOyvgujXpv3qPov25gle3pXJkyfnwQcfzGOPPdbkr1BDhw7Nhg0bsnz58iZ/rVu2bNlWE+I/88wzOeaYY/KZz3wmU6ZMady+atWqPPXUU5k3b14mT56cpPRXwaIo0q1bt/zsZz/L3/3d3+WQQw5p/Myuu+6aJUuWNJ5r2LBhTc7dkjdtbvbTn/40dXV1SUr/BHjzdW35xs/N427eR8emX7ffr9XV1Tn44IPz29/+tsXnpm3o1637ddCgQfnxj3+cdevW5fXXX8/w4cPz5S9/OXvuuWeLz03r62y9uiM2P5V+wAEHZNmyZbn00kvzyU9+cofHofXo1+YVRZFbbrklZ599dpPpciiPztqrs2bNysknn5xrrrkm48aNa/GYlJd+3X6/us+izZVv+l8qWUNDQzFp0qRi+PDhxfPPP7/V/s2Tqd9zzz2N25577rmtJlNfsGBBMXjw4OILX/jCVmPU19cX8+fPb7JMnDixGD16dDF//vxi9erVzdY2dOjQ4tvf/nbjthUrVrTqS4A2bNjQuO3iiy/2krUOTr+2rF+Loig2btxYjB49urjwwgtbdA5an35teb9u2LCh2GuvvYqLL764ReegdXXWXt3Sjrxk7bLLLitGjhy5w+egdejX7ffrjBkziiTF/Pnzd3hsWk9n7tUZM2YUvXv33uqFqtviPqtj0K8t69eicJ9F2xPwslMmTpxY9OvXr5g5c2axZMmSxmXNmjWNx5x33nnF7rvvXkyfPr146qmnikMPPbQ49NBDG/fPnz+/GDRoUHHWWWc1GePVV19t9rwteVtmURTF5ZdfXvTv37+4//77i6effroYO3ZsMWrUqGLt2rWNx7z00kvFvHnzissuu6zo06dPMW/evGLevHnFqlWrmh13+fLlxZAhQ4qzzz67WLBgQXHXXXcVvXr1Km6++ebGY9avX9841rBhw4qLLrqomDdvXvHCCy9st27ahn5tvl8vu+yy4j//8z+L3/3ud8XcuXOLT3ziE0WPHj2KhQsXbrdu2oZ+bb5fn3zyyeJHP/pR8bvf/a547LHHiqOPProYNWpU8cYbb2y3blpfZ+3VoiiKhQsXFvPmzStOPvnk4kMf+lDj5za74YYbip/85CfF888/Xzz//PPF97///aJv377FV77yle3WTdvQr83362ZnnXVWccghh2y3VtpWZ+3V6dOnF7169SouvvjiJjW//vrrjce4z+p49Gvz/eo+i/Ym4GWnJNnmMm3atMZj1q5dW5x//vnFLrvsUvTq1as49dRTiyVLljTuv+SSS7Y5xjs93dLSH+QNDQ3FV7/61WLIkCFFTU1NccwxxxSLFi1qcsw555yzzfPPmDHjHcf+zW9+U/zt3/5tUVNTU+y6667F5Zdf3mT/H/7wh22Oe9RRR223btqGfm2+Xy+44IJi9913L7p3714MGTKk+NjHPlb8+te/3m7NtB392ny/zpw5s9h3332LmpqaYuDAgcXZZ59d/PGPf9xuzbSNztyrI0eO3ObnNrv++uuL/fbbr+jVq1dRW1tbHHzwwcWNN95Y1NfXb7du2oZ+bb5fi6L0R7aePXsW3/3ud7dbK22rs/Zqc5/Z8h7KfVbHo1+b70X3WbS3qqIoigAAAAAAUHG8dhoAAAAAoEIJeAEAAAAAKpSAFwAAAACgQgl4AQAAAAAqlIAXAAAAAKBCCXgBAAAAACqUgBcAAAAAoEIJeAEAAAAAKpSAFwCATmH8+PGpqqpKVVVVqqurM2TIkHzkIx/JLbfckoaGhhaPc+utt6Z///5tVygAAOwAAS8AAJ3GCSeckCVLluTFF1/MQw89lA9/+MP53Oc+l5NOOikbN24sd3kAALDDBLwAAHQaNTU1GTp0aHbdddf81V/9Vf75n/85999/fx566KHceuutSZKrr746BxxwQHr37p0RI0bk/PPPz+rVq5MkM2fOzIQJE7JixYrGp4EvvfTSJMn69etz0UUXZdddd03v3r1zyCGHZObMmeW5UAAAOg0BLwAAndrRRx+dMWPG5N57702SdOnSJddff30WLlyY2267LdOnT88Xv/jFJMlhhx2Wa6+9NrW1tVmyZEmWLFmSiy66KEkyefLkzJkzJ3fddVeefvrpnHnmmTnhhBPywgsvlO3aAAB476sqiqIodxEAANDWxo8fn+XLl+fHP/7xVvs+8YlP5Omnn84zzzyz1b577rkn5513Xv70pz8lKc3Be8EFF2T58uWNx7z88svZc8898/LLL2f48OGN24899tj89V//db75zW+2+vUAAECSdCt3AQAAUG5FUaSqqipJ8vOf/zxTp07Nc889l5UrV2bjxo1Zt25d1qxZk169em3z8/Pnz099fX323nvvJtvXr1+fgQMHtnn9AAB0XgJeAAA6vWeffTajRo3Kiy++mJNOOikTJ07MN77xjQwYMCBPPPFEPv3pT2fDhg3NBryrV69O165dM3fu3HTt2rXJvj59+rTHJQAA0EkJeAEA6NSmT5+e+fPn58ILL8zcuXPT0NCQq666Kl26lF5X8cMf/rDJ8d27d099fX2TbQcffHDq6+vz6quv5ogjjmi32gEAQMALAECnsX79+ixdujT19fVZtmxZHn744UydOjUnnXRSxo0blwULFqSuri7f+c53cvLJJ+cXv/hFbrrppiZj7LHHHlm9enUeffTRjBkzJr169cree++dT33qUxk3blyuuuqqHHzwwXnttdfy6KOP5sADD8yJJ55YpisGAOC9rku5CwAAgPby8MMPZ9iwYdljjz1ywgknZMaMGbn++utz//33p2vXrhkzZkyuvvrqfOtb38r++++f22+/PVOnTm0yxmGHHZbzzjsvH//4xzNo0KBcccUVSZJp06Zl3Lhx+fznP5/Ro0fnlFNOya9+9avsvvvu5bhUAAA6iaqiKIpyFwEAAAAAwI7zBC8AAAAAQIUS8AIAAAAAVCgBLwAAAABAhRLwAgAAAABUKAEvAAAAAECFEvACAAAAAFQoAS8AAAAAQIUS8AIAAAAAVCgBLwAAAABAhRLwAgAAAABUKAEvAAAAAECFEvACAAAAAFQoAS8AAAAAQIUS8AIAAAAAVCgBLwAAAABAhRLwAgAAAABUKAEvAAAAAECFEvACAAAAAFQoAS8AAAAAQIUS8AIAAAAAVCgBLwAAAABAhRLwAgAAAABUKAEvAAAAAECFEvACAAAAAFQoAS8AAAAAQIUS8AIAAAAAVCgBLwAAAABAhRLwAgAAAABUKAEvAAAAAECFEvACAAAAAFQoAS8AAAAAQIUS8AIAAAAAVCgBLwAAAABAhRLwAgAAAABUKAEvAAAAAECFEvACAAAAAFSo/w9h2oCH/PBcWwAAAABJRU5ErkJggg==", "text/plain": [ "" ] }, - "execution_count": 5, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "try:\n", - " Image(filename=\"coding/stock_price_ytd.png\")\n", + " display(Image(filename=\"coding/stock_price_ytd.png\"))\n", "except FileNotFoundError:\n", " print(\"Image not found. Please check the file name and modify if necessary.\")" ] @@ -527,273 +514,235 @@ "source": [ "## Use a Different Code Execution Environment\n", "\n", - "The code execution happened in a separate process, so the plot is not directly displayed in the notebook. Is it possible to change the code execution environment into IPython?\n", + "In the previous example, code execution happened in a separate process in a command line environment,\n", + "which is not interactive and tends to waste a lot of LLM tokens on editing code script. \n", "\n", - "Yes! In the following we demonstrate how to extend the `UserProxyAgent` to use a different code execution environment." + "In this example, we switch the execution environment to an IPython kernel which is interactive\n", + "and stateful." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "0.00s - Debugger warning: It seems that frozen modules are being used, which may\n", + "0.00s - make the debugger miss breakpoints. Please pass -Xfrozen_modules=off\n", + "0.00s - to python to disable frozen modules.\n", + "0.00s - Note: Debugging will proceed. Set PYDEVD_DISABLE_FILE_VALIDATION=1 to disable this validation.\n" + ] + } + ], "source": [ - "class IPythonUserProxyAgent(autogen.UserProxyAgent):\n", - " def __init__(self, name: str, **kwargs):\n", - " super().__init__(name, **kwargs)\n", - " self._ipython = get_ipython()\n", - "\n", - " def generate_init_message(self, *args, **kwargs) -> Union[str, Dict]:\n", - " return (\n", - " super().generate_init_message(*args, **kwargs)\n", - " + \"\"\"\n", - "If you suggest code, the code will be executed in IPython.\"\"\"\n", - " )\n", - "\n", - " def run_code(self, code, **kwargs):\n", - " result = self._ipython.run_cell(\"%%capture --no-display cap\\n\" + code)\n", - " log = self._ipython.ev(\"cap.stdout\")\n", - " log += self._ipython.ev(\"cap.stderr\")\n", - " if result.result is not None:\n", - " log += str(result.result)\n", - " exitcode = 0 if result.success else 1\n", - " if result.error_before_exec is not None:\n", - " log += f\"\\n{result.error_before_exec}\"\n", - " exitcode = 1\n", - " if result.error_in_exec is not None:\n", - " log += f\"\\n{result.error_in_exec}\"\n", - " exitcode = 1\n", - " return exitcode, log, None" + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"user_proxy\",\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=10,\n", + " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", + " code_execution_config={\"executor\": \"ipython\"}, # use IPython to execute the generated code\n", + ")" ] }, { - "attachments": {}, - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 3, "metadata": {}, + "outputs": [], "source": [ - "The implementation overrides three functions in `UserProxyAgent`:\n", - "* constructor. We get the ipython instance as the code execution environment.\n", - "* `generate_init_message`. We generate a modified initial message to send to the assistant agent, by adding the info that the execution will be performed in IPython.\n", - "* `run_code`. We execute the code with the ipython instance.\n", - "\n", - "With the new `IPythonUserProxyAgent`, we are able to run the code within the current notebook environment and display the plot directly." + "assistant = autogen.ConversableAgent(\n", + " name=\"assistant\",\n", + " system_message=\"You are a helpful AI assistant.\",\n", + " llm_config={\n", + " \"config_list\": config_list,\n", + " \"temperature\": 0,\n", + " },\n", + ")\n", + "user_proxy._code_executor.user_capability.add_to_agent(assistant)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "Plot a chart of META and TESLA stock price gain YTD\n", - "If you suggest code, the code will be executed in IPython.\n", + "Plot a chart of META and TESLA stock price gain YTD.\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "First, we need to install the necessary libraries to fetch stock data and plot the chart. Please execute the following code to install the required libraries:\n", + "To plot the chart of META (Facebook) and TESLA stock price gain YTD, we will use the `yfinance` library in Python. This library allows us to download stock data from Yahoo Finance.\n", "\n", - "```python\n", - "!pip install yfinance matplotlib\n", - "```\n", + "First, let's install the `yfinance` library. If it's already installed, this step will simply ensure that it's up to date. We'll also import the necessary libraries for this task.\n", "\n", - "After installing the libraries, execute the following code to fetch the stock data and plot the chart:\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "```python\n", - "import yfinance as yf\n", - "import matplotlib.pyplot as plt\n", - "import datetime\n", "\n", - "# Get the current date\n", - "today = datetime.date.today()\n", "\n", - "# Calculate the start date for YTD\n", - "start_date = datetime.date(today.year, 1, 1)\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "# Fetch stock data for META (Facebook) and TESLA\n", - "meta = yf.download('FB', start=start_date, end=today)\n", - "tesla = yf.download('TSLA', start=start_date, end=today)\n", + "```python\n", + "!pip install yfinance --upgrade --no-cache-dir\n", + "import yfinance as yf\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from datetime import datetime\n", + "```\n", + "Now, let's download the data for META and TESLA. We'll get the data from the start of the year to today. We'll then calculate the percentage change in the closing price for each stock. This will give us the stock price gain YTD.\n", "\n", - "# Calculate the percentage gain for each stock\n", - "meta['Gain'] = (meta['Close'] / meta['Close'][0]) * 100\n", - "tesla['Gain'] = (tesla['Close'] / tesla['Close'][0]) * 100\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "# Plot the chart\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(meta.index, meta['Gain'], label='META (Facebook)')\n", - "plt.plot(tesla.index, tesla['Gain'], label='TESLA')\n", - "plt.xlabel('Date')\n", - "plt.ylabel('Percentage Gain YTD')\n", - "plt.title('META (Facebook) vs TESLA Stock Price Gain YTD')\n", - "plt.legend()\n", - "plt.grid()\n", - "plt.show()\n", - "```\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: Requirement already satisfied: yfinance in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (0.2.35)\n", + "Collecting yfinance\n", + " Downloading yfinance-0.2.36-py2.py3-none-any.whl.metadata (11 kB)\n", + "Requirement already satisfied: pandas>=1.3.0 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (2.1.4)\n", + "Requirement already satisfied: numpy>=1.16.5 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (1.26.2)\n", + "Requirement already satisfied: requests>=2.31 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (2.31.0)\n", + "Requirement already satisfied: multitasking>=0.0.7 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (0.0.11)\n", + "Requirement already satisfied: lxml>=4.9.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (5.0.1)\n", + "Requirement already satisfied: appdirs>=1.4.4 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (1.4.4)\n", + "Requirement already satisfied: pytz>=2022.5 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (2023.3.post1)\n", + "Requirement already satisfied: frozendict>=2.3.4 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (2.4.0)\n", + "Requirement already satisfied: peewee>=3.16.2 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (3.17.0)\n", + "Requirement already satisfied: beautifulsoup4>=4.11.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (4.12.2)\n", + "Requirement already satisfied: html5lib>=1.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (1.1)\n", + "Requirement already satisfied: soupsieve>1.2 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.5)\n", + "Requirement already satisfied: six>=1.9 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", + "Requirement already satisfied: webencodings in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", + "Requirement already satisfied: tzdata>=2022.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from pandas>=1.3.0->yfinance) (2023.4)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from requests>=2.31->yfinance) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from requests>=2.31->yfinance) (3.6)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from requests>=2.31->yfinance) (2.1.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from requests>=2.31->yfinance) (2023.11.17)\n", + "Downloading yfinance-0.2.36-py2.py3-none-any.whl (72 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m72.4/72.4 kB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: yfinance\n", + " Attempting uninstall: yfinance\n", + " Found existing installation: yfinance 0.2.35\n", + " Uninstalling yfinance-0.2.35:\n", + " Successfully uninstalled yfinance-0.2.35\n", + "Successfully installed yfinance-0.2.36\n", "\n", - "This code will fetch the stock data for META (Facebook) and TESLA from the start of the year to the current date, calculate the percentage gain, and plot the chart.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n" - ] - }, - { - "ename": "IndexError", - "evalue": "index 0 is out of bounds for axis 0 with size 0", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[7], line 16\u001b[0m\n\u001b[1;32m 13\u001b[0m tesla \u001b[39m=\u001b[39m yf\u001b[39m.\u001b[39mdownload(\u001b[39m'\u001b[39m\u001b[39mTSLA\u001b[39m\u001b[39m'\u001b[39m, start\u001b[39m=\u001b[39mstart_date, end\u001b[39m=\u001b[39mtoday)\n\u001b[1;32m 15\u001b[0m \u001b[39m# Calculate the percentage gain for each stock\u001b[39;00m\n\u001b[0;32m---> 16\u001b[0m meta[\u001b[39m'\u001b[39m\u001b[39mGain\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m (meta[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m/\u001b[39m meta[\u001b[39m'\u001b[39;49m\u001b[39mClose\u001b[39;49m\u001b[39m'\u001b[39;49m][\u001b[39m0\u001b[39;49m]) \u001b[39m*\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 17\u001b[0m tesla[\u001b[39m'\u001b[39m\u001b[39mGain\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m (tesla[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m/\u001b[39m tesla[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m][\u001b[39m0\u001b[39m]) \u001b[39m*\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 19\u001b[0m \u001b[39m# Plot the chart\u001b[39;00m\n", - "File \u001b[0;32m~/.local/lib/python3.9/site-packages/pandas/core/series.py:939\u001b[0m, in \u001b[0;36mSeries.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 936\u001b[0m key \u001b[39m=\u001b[39m unpack_1tuple(key)\n\u001b[1;32m 938\u001b[0m \u001b[39mif\u001b[39;00m is_integer(key) \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mindex\u001b[39m.\u001b[39m_should_fallback_to_positional():\n\u001b[0;32m--> 939\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_values[key]\n\u001b[1;32m 941\u001b[0m \u001b[39melif\u001b[39;00m key_is_scalar:\n\u001b[1;32m 942\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_value(key)\n", - "\u001b[0;31mIndexError\u001b[0m: index 0 is out of bounds for axis 0 with size 0" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n", - "Requirement already satisfied: matplotlib in /home/vscode/.local/lib/python3.9/site-packages (3.7.2)\n", - "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", - "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", - "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", - "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n", - "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", - "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", - "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", - "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", - "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", - "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.4.4)\n", - "Requirement already satisfied: importlib-resources>=3.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (6.0.0)\n", - "Requirement already satisfied: pillow>=6.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (10.0.0)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (4.41.1)\n", - "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n", - "Requirement already satisfied: packaging>=20.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (23.1)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.1.0)\n", - "Requirement already satisfied: cycler>=0.10 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n", - "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", - "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", - "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", - "Requirement already satisfied: zipp>=3.1.0 in /home/vscode/.local/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib) (3.16.2)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", - "\n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", - "\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "1 Failed download:\n", - "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n", + "```python\n", + "# Define the ticker symbol\n", + "tickerSymbols = ['META', 'TSLA']\n", "\n", + "# Get data from the start of this year to today\n", + "start_date = datetime(datetime.today().year, 1, 1)\n", + "end_date = datetime.today()\n", "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", + "# Get the data\n", + "data = yf.download(tickerSymbols, start=start_date, end=end_date)\n", "\n", - "It seems that there was an issue with fetching the stock data for META (Facebook) using the ticker symbol 'FB'. The stock symbol for META has been changed to 'META' recently. Let's update the code to use the new symbol and try again:\n", + "# Calculate the percentage change\n", + "data['META Change'] = data['Adj Close']['META'].pct_change()\n", + "data['TESLA Change'] = data['Adj Close']['TSLA'].pct_change()\n", "\n", - "```python\n", - "import yfinance as yf\n", - "import matplotlib.pyplot as plt\n", - "import datetime\n", + "# Drop the missing values\n", + "data = data.dropna()\n", "\n", - "# Get the current date\n", - "today = datetime.date.today()\n", + "data.head()\n", + "```\n", + "Now, let's plot the data. We'll plot the percentage change in the closing price for each stock. This will give us the stock price gain YTD.\n", "\n", - "# Calculate the start date for YTD\n", - "start_date = datetime.date(today.year, 1, 1)\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "# Fetch stock data for META (Facebook) and TESLA\n", - "meta = yf.download('META', start=start_date, end=today)\n", - "tesla = yf.download('TSLA', start=start_date, end=today)\n", + "exitcode: 0 (execution succeeded)\n", + "[*********************100%%**********************] 2 of 2 completed\n", + "{\"text/plain\": \"Price Adj Close Close High \\\\\\nTicker META TSLA META TSLA META \\nDate \\n2024-01-03 344.470001 238.449997 344.470001 238.449997 347.950012 \\n2024-01-04 347.119995 237.929993 347.119995 237.929993 348.149994 \\n2024-01-05 351.950012 237.490005 351.950012 237.490005 353.500000 \\n2024-01-08 358.660004 240.449997 358.660004 240.449997 358.980011 \\n2024-01-09 357.429993 234.960007 357.429993 234.960007 360.640015 \\n\\nPrice Low Open \\\\\\nTicker TSLA META TSLA META TSLA \\nDate \\n2024-01-03 245.679993 343.179993 236.320007 344.980011 244.979996 \\n2024-01-04 242.699997 343.399994 237.729996 344.500000 239.250000 \\n2024-01-05 240.119995 346.260010 234.899994 346.989990 236.860001 \\n2024-01-08 241.250000 352.049988 235.300003 354.700012 236.139999 \\n2024-01-09 238.960007 355.359985 232.039993 356.399994 238.110001 \\n\\nPrice Volume META Change TESLA Change \\nTicker META TSLA \\nDate \\n2024-01-03 15451100 121082600 -0.005256 -0.040134 \\n2024-01-04 12099900 102629300 0.007693 -0.002181 \\n2024-01-05 13920700 92379400 0.013915 -0.001849 \\n2024-01-08 13890200 85166600 0.019065 0.012464 \\n2024-01-09 13463900 96705700 -0.003429 -0.022832 \", \"text/html\": \"
\\n\\n\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n
PriceAdj CloseCloseHighLowOpenVolumeMETA ChangeTESLA Change
TickerMETATSLAMETATSLAMETATSLAMETATSLAMETATSLAMETATSLA
Date
2024-01-03344.470001238.449997344.470001238.449997347.950012245.679993343.179993236.320007344.980011244.97999615451100121082600-0.005256-0.040134
2024-01-04347.119995237.929993347.119995237.929993348.149994242.699997343.399994237.729996344.500000239.250000120999001026293000.007693-0.002181
2024-01-05351.950012237.490005351.950012237.490005353.500000240.119995346.260010234.899994346.989990236.86000113920700923794000.013915-0.001849
2024-01-08358.660004240.449997358.660004240.449997358.980011241.250000352.049988235.300003354.700012236.13999913890200851666000.0190650.012464
2024-01-09357.429993234.960007357.429993234.960007360.640015238.960007355.359985232.039993356.399994238.1100011346390096705700-0.003429-0.022832
\\n
\"}\n", "\n", - "# Calculate the percentage gain for each stock\n", - "meta['Gain'] = (meta['Close'] / meta['Close'][0]) * 100\n", - "tesla['Gain'] = (tesla['Close'] / tesla['Close'][0]) * 100\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "# Plot the chart\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(meta.index, meta['Gain'], label='META (Facebook)')\n", - "plt.plot(tesla.index, tesla['Gain'], label='TESLA')\n", + "```python\n", + "# Plot the data\n", + "plt.figure(figsize=(14,7))\n", + "plt.plot(data.index, data['META Change'].cumsum(), label='META')\n", + "plt.plot(data.index, data['TESLA Change'].cumsum(), label='TESLA')\n", "plt.xlabel('Date')\n", - "plt.ylabel('Percentage Gain YTD')\n", - "plt.title('META (Facebook) vs TESLA Stock Price Gain YTD')\n", + "plt.ylabel('Cumulative Returns')\n", + "plt.title('META vs TESLA Stock Price Gain YTD')\n", "plt.legend()\n", - "plt.grid()\n", + "plt.grid(True)\n", "plt.show()\n", "```\n", + "This will plot the cumulative returns of META and TESLA stocks from the start of the year to today. The y-axis represents the cumulative returns, and the x-axis represents the date. The blue line represents META, and the orange line represents TESLA.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "Please execute the updated code to fetch the stock data and plot the chart.\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: {\"text/plain\": \"
\", \"image/png\": \"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\"}\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n" + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n" ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", - "\n", - "I'm glad the code executed successfully. You should now see a chart comparing the YTD percentage gain of META (Facebook) and TESLA stocks. If you have any further questions or need assistance with another task, feel free to ask.\n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" + "ename": "BadRequestError", + "evalue": "Error code: 400 - {'error': {'message': \"This model's maximum context length is 8192 tokens. However, your messages resulted in 41067 tokens. Please reduce the length of the messages.\", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mBadRequestError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[4], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m autogen\u001b[38;5;241m.\u001b[39mCache\u001b[38;5;241m.\u001b[39mdisk() \u001b[38;5;28;01mas\u001b[39;00m cache:\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# the assistant receives a message from the user, which contains the task description\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43muser_proxy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minitiate_chat\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43massistant\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[38;5;124;43mPlot a chart of META and TESLA stock price gain YTD.\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:720\u001b[0m, in \u001b[0;36mConversableAgent.initiate_chat\u001b[0;34m(self, recipient, clear_history, silent, cache, **context)\u001b[0m\n\u001b[1;32m 718\u001b[0m agent\u001b[38;5;241m.\u001b[39mclient_cache \u001b[38;5;241m=\u001b[39m cache\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_prepare_chat(recipient, clear_history)\n\u001b[0;32m--> 720\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_init_message\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrecipient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 721\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m agent \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;28mself\u001b[39m, recipient]:\n\u001b[1;32m 722\u001b[0m agent\u001b[38;5;241m.\u001b[39mclient_cache \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39mprevious_cache\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", + " \u001b[0;31m[... skipping similar frames: ConversableAgent.send at line 463 (6 times), ConversableAgent.receive at line 623 (5 times)]\u001b[0m\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:621\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 619\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m request_reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m request_reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreply_at_receive[sender] \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m:\n\u001b[1;32m 620\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m--> 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_reply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchat_messages\u001b[49m\u001b[43m[\u001b[49m\u001b[43msender\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msender\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 623\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msend(reply, sender, silent\u001b[38;5;241m=\u001b[39msilent)\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:1356\u001b[0m, in \u001b[0;36mConversableAgent.generate_reply\u001b[0;34m(self, messages, sender, exclude)\u001b[0m\n\u001b[1;32m 1354\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 1355\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_match_trigger(reply_func_tuple[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrigger\u001b[39m\u001b[38;5;124m\"\u001b[39m], sender):\n\u001b[0;32m-> 1356\u001b[0m final, reply \u001b[38;5;241m=\u001b[39m \u001b[43mreply_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreply_func_tuple\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mconfig\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1357\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m final:\n\u001b[1;32m 1358\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m reply\n", + "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:821\u001b[0m, in \u001b[0;36mConversableAgent.generate_oai_reply\u001b[0;34m(self, messages, sender, config)\u001b[0m\n\u001b[1;32m 818\u001b[0m all_messages\u001b[38;5;241m.\u001b[39mappend(message)\n\u001b[1;32m 820\u001b[0m \u001b[38;5;66;03m# TODO: #1143 handle token limit exceeded error\u001b[39;00m\n\u001b[0;32m--> 821\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mclient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 822\u001b[0m \u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmessages\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpop\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcontext\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 823\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_oai_system_message\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mall_messages\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 824\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclient_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 825\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 827\u001b[0m extracted_response \u001b[38;5;241m=\u001b[39m client\u001b[38;5;241m.\u001b[39mextract_text_or_completion_object(response)[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 829\u001b[0m \u001b[38;5;66;03m# ensure function and tool calls will be accepted when sent back to the LLM\u001b[39;00m\n", + "File \u001b[0;32m~/autogen/autogen/oai/client.py:283\u001b[0m, in \u001b[0;36mOpenAIWrapper.create\u001b[0;34m(self, **config)\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m \u001b[38;5;66;03m# filter is not passed; try the next config\u001b[39;00m\n\u001b[1;32m 282\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 283\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_completions_create\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 284\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m APIError \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[1;32m 285\u001b[0m error_code \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(err, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcode\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n", + "File \u001b[0;32m~/autogen/autogen/oai/client.py:548\u001b[0m, in \u001b[0;36mOpenAIWrapper._completions_create\u001b[0;34m(self, client, params)\u001b[0m\n\u001b[1;32m 546\u001b[0m params \u001b[38;5;241m=\u001b[39m params\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[1;32m 547\u001b[0m params[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstream\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m--> 548\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mcompletions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 550\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response\n", + "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_utils/_utils.py:272\u001b[0m, in \u001b[0;36mrequired_args..inner..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 270\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMissing required argument: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mquote(missing[\u001b[38;5;241m0\u001b[39m])\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(msg)\n\u001b[0;32m--> 272\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/resources/chat/completions.py:645\u001b[0m, in \u001b[0;36mCompletions.create\u001b[0;34m(self, messages, model, frequency_penalty, function_call, functions, logit_bias, logprobs, max_tokens, n, presence_penalty, response_format, seed, stop, stream, temperature, tool_choice, tools, top_logprobs, top_p, user, extra_headers, extra_query, extra_body, timeout)\u001b[0m\n\u001b[1;32m 596\u001b[0m \u001b[38;5;129m@required_args\u001b[39m([\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmessages\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel\u001b[39m\u001b[38;5;124m\"\u001b[39m], [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmessages\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstream\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m 597\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate\u001b[39m(\n\u001b[1;32m 598\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 643\u001b[0m timeout: \u001b[38;5;28mfloat\u001b[39m \u001b[38;5;241m|\u001b[39m httpx\u001b[38;5;241m.\u001b[39mTimeout \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m|\u001b[39m NotGiven \u001b[38;5;241m=\u001b[39m NOT_GIVEN,\n\u001b[1;32m 644\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ChatCompletion \u001b[38;5;241m|\u001b[39m Stream[ChatCompletionChunk]:\n\u001b[0;32m--> 645\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_post\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 646\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/chat/completions\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 647\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmaybe_transform\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 648\u001b[0m \u001b[43m \u001b[49m\u001b[43m{\u001b[49m\n\u001b[1;32m 649\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmessages\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 650\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmodel\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 651\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfrequency_penalty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfrequency_penalty\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 652\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunction_call\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunction_call\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 653\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunctions\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunctions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 654\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlogit_bias\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogit_bias\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 655\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlogprobs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogprobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 656\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmax_tokens\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 657\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mn\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 658\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpresence_penalty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mpresence_penalty\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 659\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mresponse_format\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mresponse_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 660\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mseed\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mseed\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 661\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstop\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 662\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstream\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 663\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtemperature\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtemperature\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 664\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtool_choice\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtool_choice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 665\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtools\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtools\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 666\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtop_logprobs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtop_logprobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 667\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtop_p\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtop_p\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 668\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43muser\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43muser\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 669\u001b[0m \u001b[43m \u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 670\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompletion_create_params\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mCompletionCreateParams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 671\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 672\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmake_request_options\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 673\u001b[0m \u001b[43m \u001b[49m\u001b[43mextra_headers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_headers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_query\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_query\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_body\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_body\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\n\u001b[1;32m 674\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 675\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mChatCompletion\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 676\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 677\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mStream\u001b[49m\u001b[43m[\u001b[49m\u001b[43mChatCompletionChunk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 678\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:1088\u001b[0m, in \u001b[0;36mSyncAPIClient.post\u001b[0;34m(self, path, cast_to, body, options, files, stream, stream_cls)\u001b[0m\n\u001b[1;32m 1074\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpost\u001b[39m(\n\u001b[1;32m 1075\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 1076\u001b[0m path: \u001b[38;5;28mstr\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1083\u001b[0m stream_cls: \u001b[38;5;28mtype\u001b[39m[_StreamT] \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 1084\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResponseT \u001b[38;5;241m|\u001b[39m _StreamT:\n\u001b[1;32m 1085\u001b[0m opts \u001b[38;5;241m=\u001b[39m FinalRequestOptions\u001b[38;5;241m.\u001b[39mconstruct(\n\u001b[1;32m 1086\u001b[0m method\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpost\u001b[39m\u001b[38;5;124m\"\u001b[39m, url\u001b[38;5;241m=\u001b[39mpath, json_data\u001b[38;5;241m=\u001b[39mbody, files\u001b[38;5;241m=\u001b[39mto_httpx_files(files), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions\n\u001b[1;32m 1087\u001b[0m )\n\u001b[0;32m-> 1088\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cast(ResponseT, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mopts\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m)\u001b[49m)\n", + "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:853\u001b[0m, in \u001b[0;36mSyncAPIClient.request\u001b[0;34m(self, cast_to, options, remaining_retries, stream, stream_cls)\u001b[0m\n\u001b[1;32m 844\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrequest\u001b[39m(\n\u001b[1;32m 845\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 846\u001b[0m cast_to: Type[ResponseT],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 851\u001b[0m stream_cls: \u001b[38;5;28mtype\u001b[39m[_StreamT] \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 852\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResponseT \u001b[38;5;241m|\u001b[39m _StreamT:\n\u001b[0;32m--> 853\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 854\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 855\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 856\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 857\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 858\u001b[0m \u001b[43m \u001b[49m\u001b[43mremaining_retries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mremaining_retries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 859\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:930\u001b[0m, in \u001b[0;36mSyncAPIClient._request\u001b[0;34m(self, cast_to, options, remaining_retries, stream, stream_cls)\u001b[0m\n\u001b[1;32m 927\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mis_closed:\n\u001b[1;32m 928\u001b[0m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mread()\n\u001b[0;32m--> 930\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_status_error_from_response(err\u001b[38;5;241m.\u001b[39mresponse) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 932\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_process_response(\n\u001b[1;32m 933\u001b[0m cast_to\u001b[38;5;241m=\u001b[39mcast_to,\n\u001b[1;32m 934\u001b[0m options\u001b[38;5;241m=\u001b[39moptions,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 937\u001b[0m stream_cls\u001b[38;5;241m=\u001b[39mstream_cls,\n\u001b[1;32m 938\u001b[0m )\n", + "\u001b[0;31mBadRequestError\u001b[0m: Error code: 400 - {'error': {'message': \"This model's maximum context length is 8192 tokens. However, your messages resulted in 41067 tokens. Please reduce the length of the messages.\", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}" ] } ], "source": [ - "ipy_user = IPythonUserProxyAgent(\n", - " \"ipython_user_proxy\",\n", - " human_input_mode=\"NEVER\",\n", - " max_consecutive_auto_reply=10,\n", - " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\")\n", - " or x.get(\"content\", \"\").rstrip().endswith('\"TERMINATE\".'),\n", - ")\n", - "# the assistant receives a message from the user, which contains the task description\n", - "ipy_user.initiate_chat(\n", - " assistant,\n", - " message=\"\"\"Plot a chart of META and TESLA stock price gain YTD\"\"\",\n", - ")" + "with autogen.Cache.disk() as cache:\n", + " # the assistant receives a message from the user, which contains the task description\n", + " user_proxy.initiate_chat(\n", + " assistant,\n", + " message=\"\"\"Plot a chart of META and TESLA stock price gain YTD.\"\"\",\n", + " )" ] } ], @@ -813,7 +762,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.5" }, "vscode": { "interpreter": { diff --git a/setup.py b/setup.py index 5d5402e13bf..65fb9369a8a 100644 --- a/setup.py +++ b/setup.py @@ -22,6 +22,7 @@ "tiktoken", "pydantic>=1.10,<3", # could be both V1 and V2 "docker", + "jupyter-client", ] setuptools.setup( diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index ac83feb4608..6fe635234dc 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -16,112 +16,6 @@ else: skip_openai_tests = False or skip_openai -_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 unknown. -``` -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"); - } - } -} -""" - - -def test_extract_code(): - executor = CommandlineCodeExecutor() - - code_blocks = executor.extract_code_blocks(_message_1) - assert len(code_blocks) == 1 and code_blocks[0].language == "python" - - code_blocks = executor.extract_code_blocks(_message_2) - assert len(code_blocks) == 2 and code_blocks[0].language == "python" and code_blocks[1].language == "python" - - code_blocks = executor.extract_code_blocks(_message_3) - assert len(code_blocks) == 1 and code_blocks[0].language == "python" - - code_blocks = executor.extract_code_blocks(_message_4) - assert len(code_blocks) == 1 and code_blocks[0].language == "python" - - code_blocks = executor.extract_code_blocks(_message_5) - assert len(code_blocks) == 1 and code_blocks[0].language == "bash" - - code_blocks = executor.extract_code_blocks(_message_6) - assert len(code_blocks) == 1 and code_blocks[0].language == "unknown" - @pytest.mark.skipif( sys.platform in ["win32"] or (not is_docker_running() and not in_docker_container()), @@ -215,7 +109,7 @@ def test_conversable_agent_capability(): ) # Test code extraction. - code_blocks = executor.extract_code_blocks(reply) + code_blocks = executor.code_extractor.extract_code_blocks(reply) assert len(code_blocks) == 1 and code_blocks[0].language == "python" # Test code execution. @@ -245,8 +139,15 @@ def _test_conversable_agent_code_execution(config): }, ) + message = """ + Example: + ```python + print("hello extract code") + ``` + """ + reply = agent.generate_reply( - [{"role": "user", "content": _message_1}], + [{"role": "user", "content": message}], sender=Agent("user"), ) assert "hello extract code" in reply diff --git a/test/coding/test_ipython_code_executor.py b/test/coding/test_ipython_code_executor.py new file mode 100644 index 00000000000..5cc0b78904c --- /dev/null +++ b/test/coding/test_ipython_code_executor.py @@ -0,0 +1,128 @@ +import os +import tempfile +import pytest +from autogen.agentchat.agent import Agent +from autogen.agentchat.conversable_agent import ConversableAgent +from autogen.coding.base import CodeBlock +from autogen.coding.ipython_code_executor import IPythonCodeExecutor +from autogen.oai.openai_utils import config_list_from_json +from conftest import skip_openai # noqa: E402 + +try: + from openai import OpenAI +except ImportError: + skip_openai_tests = True +else: + skip_openai_tests = False or skip_openai + + +def test_execute_code_single_code_block(): + executor = IPythonCodeExecutor() + code_blocks = [CodeBlock(code="import sys\nprint('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 + + +def test_execute_code_multiple_code_blocks(): + executor = IPythonCodeExecutor() + code_blocks = [ + CodeBlock(code="import sys\na = 123 + 123\n", language="python"), + CodeBlock(code="print(a)", language="python"), + ] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and "246" in code_result.output + + msg = """ +def test_function(a, b): + return a + b +""" + code_blocks = [ + CodeBlock(code=msg, language="python"), + CodeBlock(code="test_function(431, 423)", language="python"), + ] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and "854" in code_result.output + + +def test_execute_code_bash_script(): + executor = IPythonCodeExecutor() + # Test bash script. + 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 + + +def test_saving_to_file(): + executor = IPythonCodeExecutor() + with tempfile.TemporaryDirectory() as tmpdirname: + code = f""" +with open('{tmpdirname}/test_file_name', 'w') as f: + f.write('test saving file') +""" + code_blocks = [CodeBlock(code=code, language="python")] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and os.path.exists(f"{tmpdirname}/test_file_name") + + +def test_timeout(): + executor = IPythonCodeExecutor(timeout=1) + 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 + + +@pytest.mark.skipif(skip_openai_tests, reason="openai not installed OR requested to skip") +def test_conversable_agent_capability(): + KEY_LOC = "notebook" + OAI_CONFIG_LIST = "OAI_CONFIG_LIST" + config_list = config_list_from_json( + OAI_CONFIG_LIST, + file_location=KEY_LOC, + filter_dict={ + "model": { + "gpt-3.5-turbo", + "gpt-35-turbo", + }, + }, + ) + llm_config = {"config_list": config_list} + agent = ConversableAgent( + "coding_agent", + llm_config=llm_config, + ) + executor = IPythonCodeExecutor() + executor.user_capability.add_to_agent(agent) + + # Test updated system prompt. + assert executor.user_capability.DEFAULT_SYSTEM_MESSAGE_UPDATE in agent.system_message + + # Test code generation. + reply = agent.generate_reply( + [{"role": "user", "content": "print 'hello world' to the console"}], + sender=Agent("user"), + ) + + # Test code extraction. + code_blocks = executor.code_extractor.extract_code_blocks(reply) + assert len(code_blocks) == 1 and code_blocks[0].language == "python" + + # Test code execution. + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and "hello world" in code_result.output.lower() + + +def test_conversable_agent_code_execution(): + agent = ConversableAgent("user_proxy", code_execution_config={"executor": "ipython"}) + msg = """ +Run this code: +```python +def test_function(a, b): + return a * b +``` +And then this: +```python +print(test_function(123, 4)) +``` +""" + reply = agent.generate_reply([{"role": "user", "content": msg}], sender=Agent("user")) + assert "492" in reply diff --git a/test/coding/test_markdown_code_extractor.py b/test/coding/test_markdown_code_extractor.py new file mode 100644 index 00000000000..9df908f52cc --- /dev/null +++ b/test/coding/test_markdown_code_extractor.py @@ -0,0 +1,115 @@ +from autogen.coding.markdown_code_extractor 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(): + 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) == 0 From 4a68901dc5b696e982f4ead9ccf35b3f4a714a8a Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 20:38:22 -0800 Subject: [PATCH 10/52] check kernel installed; fix tests --- .github/workflows/build.yml | 6 ++++-- .github/workflows/contrib-openai.yml | 1 + autogen/coding/ipython_code_executor.py | 9 +++++++++ setup.py | 1 + test/coding/test_commandline_code_executor.py | 1 + test/coding/test_ipython_code_executor.py | 2 +- 6 files changed, 17 insertions(+), 3 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index e7c0e1aa7c2..a3509019d86 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -19,8 +19,9 @@ on: concurrency: group: ${{ github.workflow }}-${{ github.ref }}-${{ github.head_ref }} cancel-in-progress: ${{ github.ref != 'refs/heads/main' }} -permissions: {} - # actions: read +permissions: + {} + # actions: read # checks: read # contents: read # deployments: read @@ -44,6 +45,7 @@ jobs: pip install -e . python -c "import autogen" pip install pytest mock + python -m ipykernel install --user --name python3 - name: Set AUTOGEN_USE_DOCKER based on OS shell: bash run: | diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml index 6611b75e3b9..4019d82e7d7 100644 --- a/.github/workflows/contrib-openai.yml +++ b/.github/workflows/contrib-openai.yml @@ -37,6 +37,7 @@ jobs: pip install -e . python -c "import autogen" pip install coverage pytest-asyncio + python -m ipykernel install --user --name python3 - name: Install packages for test when needed run: | pip install docker diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index c6bad818b16..3135f70f55f 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -3,6 +3,7 @@ from typing import List from jupyter_client import KernelManager +from jupyter_client.kernelspec import NoSuchKernel, KernelSpecManager from pydantic import BaseModel, Field from autogen.code_utils import DEFAULT_TIMEOUT from autogen.coding.base import CodeBlock, CodeExtractor, CodeResult @@ -43,9 +44,17 @@ def add_to_agent(self, agent): agent.update_system_message(agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE) timeout: int = Field(default=DEFAULT_TIMEOUT, ge=1) + kernel: str = "python3" def __init__(self, **kwargs): super().__init__(**kwargs) + # Check if the kernel is installed. + if self.kernel not in KernelSpecManager().find_kernel_specs(): + raise ValueError( + f"Kernel {self.kernel} is not installed. " + "Please first install it with " + f"`python -m ipykernel install --user --name {self.kernel}`." + ) self._kernel_manager = KernelManager() self._kernel_manager.start_kernel() self._kernel_client = self._kernel_manager.client() diff --git a/setup.py b/setup.py index 65fb9369a8a..bd14824a9e0 100644 --- a/setup.py +++ b/setup.py @@ -23,6 +23,7 @@ "pydantic>=1.10,<3", # could be both V1 and V2 "docker", "jupyter-client", + "ipykernel", ] setuptools.setup( diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index 6fe635234dc..0c3292ff78e 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -137,6 +137,7 @@ def _test_conversable_agent_code_execution(config): "executor": "commandline", "commandline": config, }, + llm_config=False, ) message = """ diff --git a/test/coding/test_ipython_code_executor.py b/test/coding/test_ipython_code_executor.py index 5cc0b78904c..f2f941df2f4 100644 --- a/test/coding/test_ipython_code_executor.py +++ b/test/coding/test_ipython_code_executor.py @@ -112,7 +112,7 @@ def test_conversable_agent_capability(): def test_conversable_agent_code_execution(): - agent = ConversableAgent("user_proxy", code_execution_config={"executor": "ipython"}) + agent = ConversableAgent("user_proxy", llm_config=False, code_execution_config={"executor": "ipython"}) msg = """ Run this code: ```python From c2eac9479503927064b914adc2dacb3f07f10c10 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 20:47:25 -0800 Subject: [PATCH 11/52] fix tests --- test/coding/test_commandline_code_executor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index 0c3292ff78e..0a85721c9f1 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -162,4 +162,4 @@ def _test_conversable_agent_code_execution(config): def test_conversable_agent_warning_legacy_code_executor(): # Test warning message. with pytest.warns(DeprecationWarning, match="legacy code executor"): - ConversableAgent("user_proxy", code_execution_config=True) + ConversableAgent("user_proxy", llm_config=False, code_execution_config=True) From 3e96f01bc0f96a6bcc9c337a144fcb839ab2acba Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 20:54:55 -0800 Subject: [PATCH 12/52] fix tests --- autogen/coding/ipython_code_executor.py | 2 +- test/coding/test_ipython_code_executor.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index 3135f70f55f..81873d7bd92 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -72,7 +72,7 @@ def code_extractor(self) -> CodeExtractor: return MarkdownCodeExtractor() def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: - self._kernel_client.wait_for_ready(timeout=self._timeout) + self._kernel_client.wait_for_ready() outputs = [] for code_block in code_blocks: self._kernel_client.execute(code_block.code, store_history=True) diff --git a/test/coding/test_ipython_code_executor.py b/test/coding/test_ipython_code_executor.py index f2f941df2f4..f998f24a3bd 100644 --- a/test/coding/test_ipython_code_executor.py +++ b/test/coding/test_ipython_code_executor.py @@ -56,12 +56,12 @@ def test_saving_to_file(): executor = IPythonCodeExecutor() with tempfile.TemporaryDirectory() as tmpdirname: code = f""" -with open('{tmpdirname}/test_file_name', 'w') as f: +with open('{os.path.join(tmpdirname, "test_file_name")}', 'w') as f: f.write('test saving file') """ code_blocks = [CodeBlock(code=code, language="python")] code_result = executor.execute_code_blocks(code_blocks) - assert code_result.exit_code == 0 and os.path.exists(f"{tmpdirname}/test_file_name") + assert code_result.exit_code == 0 and os.path.exists(os.path.join(tmpdirname, "test_file_name")) def test_timeout(): From 57ee0b62eb26d0f45191916a513182a62cbe379e Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 26 Jan 2024 21:28:45 -0800 Subject: [PATCH 13/52] update system prompt --- autogen/coding/ipython_code_executor.py | 8 +- ...at_auto_feedback_from_code_execution.ipynb | 188 +++++++++++------- 2 files changed, 125 insertions(+), 71 deletions(-) diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index 81873d7bd92..3e91c54faa4 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -32,10 +32,12 @@ class UserCapability: ```python print(x) ``` -The output may be text, a table, or an image. -When you suggest code, always write incrementally rather than all at once. -For example, if you want to import a library, do it in a separate code block. +Each output may be text, a table, or an image. +If you want to create an image (e.g., a plot), always make sure to minimize image size. +When you suggest code, always do it incrementally rather than all at once: +If you want to import a library, do it in a separate code block. If you want to define a function or a class, do it in a separate code block. +If you want to run a function that produces output, do it in a separate code block. Leverage the statefulness of the kernel to avoid repeating code. """ diff --git a/notebook/agentchat_auto_feedback_from_code_execution.ipynb b/notebook/agentchat_auto_feedback_from_code_execution.ipynb index 655d95239ff..02e9755112a 100644 --- a/notebook/agentchat_auto_feedback_from_code_execution.ipynb +++ b/notebook/agentchat_auto_feedback_from_code_execution.ipynb @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -523,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -549,7 +549,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -566,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -582,9 +582,14 @@ ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "To plot the chart of META (Facebook) and TESLA stock price gain YTD, we will use the `yfinance` library in Python. This library allows us to download stock data from Yahoo Finance.\n", + "To plot the chart of META (Facebook) and TESLA stock price gain YTD, we will need to:\n", + "\n", + "1. Import the necessary libraries (pandas, yfinance, and matplotlib).\n", + "2. Download the stock data for META and TESLA using yfinance.\n", + "3. Calculate the YTD gain for each stock.\n", + "4. Plot the YTD gain for each stock.\n", "\n", - "First, let's install the `yfinance` library. If it's already installed, this step will simply ensure that it's up to date. We'll also import the necessary libraries for this task.\n", + "Let's start by importing the necessary libraries.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", @@ -597,49 +602,66 @@ "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", "```python\n", - "!pip install yfinance --upgrade --no-cache-dir\n", + "import pandas as pd\n", "import yfinance as yf\n", "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", + "```\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "Now that we have imported the necessary libraries, let's download the stock data for META and TESLA. We will download the data for the current year. We will use the `yf.download()` function from the yfinance library to download the data. The function takes the ticker symbol of the stock as an argument. The ticker symbol for META is 'FB' and for TESLA is 'TSLA'. We will also specify the start date as the first day of the current year.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "```python\n", "from datetime import datetime\n", + "\n", + "# Get the current year\n", + "current_year = datetime.now().year\n", + "\n", + "# Download the stock data for META and TESLA\n", + "meta_data = yf.download('FB', start=f'{current_year}-01-01')\n", + "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01')\n", "```\n", - "Now, let's download the data for META and TESLA. We'll get the data from the start of the year to today. We'll then calculate the percentage change in the closing price for each stock. This will give us the stock price gain YTD.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", - "Code output: Requirement already satisfied: yfinance in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (0.2.35)\n", - "Collecting yfinance\n", - " Downloading yfinance-0.2.36-py2.py3-none-any.whl.metadata (11 kB)\n", - "Requirement already satisfied: pandas>=1.3.0 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (2.1.4)\n", - "Requirement already satisfied: numpy>=1.16.5 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (1.26.2)\n", - "Requirement already satisfied: requests>=2.31 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (2.31.0)\n", - "Requirement already satisfied: multitasking>=0.0.7 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (0.0.11)\n", - "Requirement already satisfied: lxml>=4.9.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (5.0.1)\n", - "Requirement already satisfied: appdirs>=1.4.4 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (1.4.4)\n", - "Requirement already satisfied: pytz>=2022.5 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (2023.3.post1)\n", - "Requirement already satisfied: frozendict>=2.3.4 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (2.4.0)\n", - "Requirement already satisfied: peewee>=3.16.2 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (3.17.0)\n", - "Requirement already satisfied: beautifulsoup4>=4.11.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (4.12.2)\n", - "Requirement already satisfied: html5lib>=1.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from yfinance) (1.1)\n", - "Requirement already satisfied: soupsieve>1.2 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.5)\n", - "Requirement already satisfied: six>=1.9 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", - "Requirement already satisfied: webencodings in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", - "Requirement already satisfied: tzdata>=2022.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from pandas>=1.3.0->yfinance) (2023.4)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from requests>=2.31->yfinance) (3.3.2)\n", - "Requirement already satisfied: idna<4,>=2.5 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from requests>=2.31->yfinance) (3.6)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from requests>=2.31->yfinance) (2.1.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages (from requests>=2.31->yfinance) (2023.11.17)\n", - "Downloading yfinance-0.2.36-py2.py3-none-any.whl (72 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m72.4/72.4 kB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hInstalling collected packages: yfinance\n", - " Attempting uninstall: yfinance\n", - " Found existing installation: yfinance 0.2.35\n", - " Uninstalling yfinance-0.2.35:\n", - " Successfully uninstalled yfinance-0.2.35\n", - "Successfully installed yfinance-0.2.36\n", + "[*********************100%%**********************] 1 of 1 completed\n", + "\n", + "1 Failed download:\n", + "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n", + "[*********************100%%**********************] 1 of 1 completed\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "It seems like there was an issue with downloading the data for META (Facebook). The ticker symbol 'FB' is not working, which might be due to the recent name change of the company to Meta Platforms Inc. The new ticker symbol for Meta Platforms Inc. is 'META'. Let's try downloading the data again using the new ticker symbol.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", "\n", "\n", "--------------------------------------------------------------------------------\n", @@ -648,33 +670,57 @@ "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", "```python\n", - "# Define the ticker symbol\n", - "tickerSymbols = ['META', 'TSLA']\n", + "# Download the stock data for META\n", + "meta_data = yf.download('META', start=f'{current_year}-01-01')\n", + "```\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "[*********************100%%**********************] 1 of 1 completed\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "Great, we have successfully downloaded the stock data for META and TESLA. Now, let's calculate the Year-to-Date (YTD) gain for each stock. The YTD gain is calculated as the percentage change in the stock price from the first day of the year to the current day. We will use the 'Adj Close' price for the calculation as it accounts for any corporate actions such as dividends, stock splits, etc. We will use the `pct_change()` function from pandas to calculate the percentage change.\n", "\n", - "# Get data from the start of this year to today\n", - "start_date = datetime(datetime.today().year, 1, 1)\n", - "end_date = datetime.today()\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "# Get the data\n", - "data = yf.download(tickerSymbols, start=start_date, end=end_date)\n", "\n", - "# Calculate the percentage change\n", - "data['META Change'] = data['Adj Close']['META'].pct_change()\n", - "data['TESLA Change'] = data['Adj Close']['TSLA'].pct_change()\n", "\n", - "# Drop the missing values\n", - "data = data.dropna()\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "data.head()\n", + "```python\n", + "# Calculate the YTD gain for META and TESLA\n", + "meta_data['YTD Gain'] = meta_data['Adj Close'].pct_change().cumsum()\n", + "tesla_data['YTD Gain'] = tesla_data['Adj Close'].pct_change().cumsum()\n", "```\n", - "Now, let's plot the data. We'll plot the percentage change in the closing price for each stock. This will give us the stock price gain YTD.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", - "[*********************100%%**********************] 2 of 2 completed\n", - "{\"text/plain\": \"Price Adj Close Close High \\\\\\nTicker META TSLA META TSLA META \\nDate \\n2024-01-03 344.470001 238.449997 344.470001 238.449997 347.950012 \\n2024-01-04 347.119995 237.929993 347.119995 237.929993 348.149994 \\n2024-01-05 351.950012 237.490005 351.950012 237.490005 353.500000 \\n2024-01-08 358.660004 240.449997 358.660004 240.449997 358.980011 \\n2024-01-09 357.429993 234.960007 357.429993 234.960007 360.640015 \\n\\nPrice Low Open \\\\\\nTicker TSLA META TSLA META TSLA \\nDate \\n2024-01-03 245.679993 343.179993 236.320007 344.980011 244.979996 \\n2024-01-04 242.699997 343.399994 237.729996 344.500000 239.250000 \\n2024-01-05 240.119995 346.260010 234.899994 346.989990 236.860001 \\n2024-01-08 241.250000 352.049988 235.300003 354.700012 236.139999 \\n2024-01-09 238.960007 355.359985 232.039993 356.399994 238.110001 \\n\\nPrice Volume META Change TESLA Change \\nTicker META TSLA \\nDate \\n2024-01-03 15451100 121082600 -0.005256 -0.040134 \\n2024-01-04 12099900 102629300 0.007693 -0.002181 \\n2024-01-05 13920700 92379400 0.013915 -0.001849 \\n2024-01-08 13890200 85166600 0.019065 0.012464 \\n2024-01-09 13463900 96705700 -0.003429 -0.022832 \", \"text/html\": \"
\\n\\n\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n
PriceAdj CloseCloseHighLowOpenVolumeMETA ChangeTESLA Change
TickerMETATSLAMETATSLAMETATSLAMETATSLAMETATSLAMETATSLA
Date
2024-01-03344.470001238.449997344.470001238.449997347.950012245.679993343.179993236.320007344.980011244.97999615451100121082600-0.005256-0.040134
2024-01-04347.119995237.929993347.119995237.929993348.149994242.699997343.399994237.729996344.500000239.250000120999001026293000.007693-0.002181
2024-01-05351.950012237.490005351.950012237.490005353.500000240.119995346.260010234.899994346.989990236.86000113920700923794000.013915-0.001849
2024-01-08358.660004240.449997358.660004240.449997358.980011241.250000352.049988235.300003354.700012236.13999913890200851666000.0190650.012464
2024-01-09357.429993234.960007357.429993234.960007360.640015238.960007355.359985232.039993356.399994238.1100011346390096705700-0.003429-0.022832
\\n
\"}\n", + "Code output: \n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "Now that we have calculated the YTD gain for each stock, let's plot the YTD gain. We will use the `plot()` function from matplotlib to create the plot. We will plot the YTD gain for META and TESLA on the same plot for comparison. We will also add labels and a title to the plot for better readability.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -682,24 +728,30 @@ "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", "```python\n", - "# Plot the data\n", + "# Create a new figure\n", "plt.figure(figsize=(14,7))\n", - "plt.plot(data.index, data['META Change'].cumsum(), label='META')\n", - "plt.plot(data.index, data['TESLA Change'].cumsum(), label='TESLA')\n", + "\n", + "# Plot the YTD gain for META\n", + "plt.plot(meta_data.index, meta_data['YTD Gain'], label='META')\n", + "\n", + "# Plot the YTD gain for TESLA\n", + "plt.plot(tesla_data.index, tesla_data['YTD Gain'], label='TESLA')\n", + "\n", + "# Add labels and a title\n", "plt.xlabel('Date')\n", - "plt.ylabel('Cumulative Returns')\n", - "plt.title('META vs TESLA Stock Price Gain YTD')\n", + "plt.ylabel('YTD Gain')\n", + "plt.title('META vs TESLA YTD Gain')\n", "plt.legend()\n", - "plt.grid(True)\n", + "\n", + "# Display the plot\n", "plt.show()\n", "```\n", - "This will plot the cumulative returns of META and TESLA stocks from the start of the year to today. The y-axis represents the cumulative returns, and the x-axis represents the date. The blue line represents META, and the orange line represents TESLA.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", - "Code output: {\"text/plain\": \"
\", \"image/png\": \"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\"}\n", + "Code output: {\"text/plain\": \"
\", \"image/png\": \"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\"}\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -708,18 +760,18 @@ }, { "ename": "BadRequestError", - "evalue": "Error code: 400 - {'error': {'message': \"This model's maximum context length is 8192 tokens. However, your messages resulted in 41067 tokens. Please reduce the length of the messages.\", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}", + "evalue": "Error code: 400 - {'error': {'message': \"This model's maximum context length is 8192 tokens. However, your messages resulted in 32968 tokens. Please reduce the length of the messages.\", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mBadRequestError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[4], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m autogen\u001b[38;5;241m.\u001b[39mCache\u001b[38;5;241m.\u001b[39mdisk() \u001b[38;5;28;01mas\u001b[39;00m cache:\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# the assistant receives a message from the user, which contains the task description\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43muser_proxy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minitiate_chat\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43massistant\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[38;5;124;43mPlot a chart of META and TESLA stock price gain YTD.\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[5], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m autogen\u001b[38;5;241m.\u001b[39mCache\u001b[38;5;241m.\u001b[39mdisk() \u001b[38;5;28;01mas\u001b[39;00m cache:\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# the assistant receives a message from the user, which contains the task description\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43muser_proxy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minitiate_chat\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43massistant\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[38;5;124;43mPlot a chart of META and TESLA stock price gain YTD.\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:720\u001b[0m, in \u001b[0;36mConversableAgent.initiate_chat\u001b[0;34m(self, recipient, clear_history, silent, cache, **context)\u001b[0m\n\u001b[1;32m 718\u001b[0m agent\u001b[38;5;241m.\u001b[39mclient_cache \u001b[38;5;241m=\u001b[39m cache\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_prepare_chat(recipient, clear_history)\n\u001b[0;32m--> 720\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_init_message\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrecipient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 721\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m agent \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;28mself\u001b[39m, recipient]:\n\u001b[1;32m 722\u001b[0m agent\u001b[38;5;241m.\u001b[39mclient_cache \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39mprevious_cache\n", "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", - " \u001b[0;31m[... skipping similar frames: ConversableAgent.send at line 463 (6 times), ConversableAgent.receive at line 623 (5 times)]\u001b[0m\n", + " \u001b[0;31m[... skipping similar frames: ConversableAgent.send at line 463 (18 times), ConversableAgent.receive at line 623 (17 times)]\u001b[0m\n", "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:621\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 619\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m request_reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m request_reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreply_at_receive[sender] \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m:\n\u001b[1;32m 620\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m--> 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_reply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchat_messages\u001b[49m\u001b[43m[\u001b[49m\u001b[43msender\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msender\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 623\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msend(reply, sender, silent\u001b[38;5;241m=\u001b[39msilent)\n", @@ -732,7 +784,7 @@ "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:1088\u001b[0m, in \u001b[0;36mSyncAPIClient.post\u001b[0;34m(self, path, cast_to, body, options, files, stream, stream_cls)\u001b[0m\n\u001b[1;32m 1074\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpost\u001b[39m(\n\u001b[1;32m 1075\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 1076\u001b[0m path: \u001b[38;5;28mstr\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1083\u001b[0m stream_cls: \u001b[38;5;28mtype\u001b[39m[_StreamT] \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 1084\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResponseT \u001b[38;5;241m|\u001b[39m _StreamT:\n\u001b[1;32m 1085\u001b[0m opts \u001b[38;5;241m=\u001b[39m FinalRequestOptions\u001b[38;5;241m.\u001b[39mconstruct(\n\u001b[1;32m 1086\u001b[0m method\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpost\u001b[39m\u001b[38;5;124m\"\u001b[39m, url\u001b[38;5;241m=\u001b[39mpath, json_data\u001b[38;5;241m=\u001b[39mbody, files\u001b[38;5;241m=\u001b[39mto_httpx_files(files), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions\n\u001b[1;32m 1087\u001b[0m )\n\u001b[0;32m-> 1088\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cast(ResponseT, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mopts\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m)\u001b[49m)\n", "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:853\u001b[0m, in \u001b[0;36mSyncAPIClient.request\u001b[0;34m(self, cast_to, options, remaining_retries, stream, stream_cls)\u001b[0m\n\u001b[1;32m 844\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrequest\u001b[39m(\n\u001b[1;32m 845\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 846\u001b[0m cast_to: Type[ResponseT],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 851\u001b[0m stream_cls: \u001b[38;5;28mtype\u001b[39m[_StreamT] \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 852\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResponseT \u001b[38;5;241m|\u001b[39m _StreamT:\n\u001b[0;32m--> 853\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 854\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 855\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 856\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 857\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 858\u001b[0m \u001b[43m \u001b[49m\u001b[43mremaining_retries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mremaining_retries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 859\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:930\u001b[0m, in \u001b[0;36mSyncAPIClient._request\u001b[0;34m(self, cast_to, options, remaining_retries, stream, stream_cls)\u001b[0m\n\u001b[1;32m 927\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mis_closed:\n\u001b[1;32m 928\u001b[0m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mread()\n\u001b[0;32m--> 930\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_status_error_from_response(err\u001b[38;5;241m.\u001b[39mresponse) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 932\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_process_response(\n\u001b[1;32m 933\u001b[0m cast_to\u001b[38;5;241m=\u001b[39mcast_to,\n\u001b[1;32m 934\u001b[0m options\u001b[38;5;241m=\u001b[39moptions,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 937\u001b[0m stream_cls\u001b[38;5;241m=\u001b[39mstream_cls,\n\u001b[1;32m 938\u001b[0m )\n", - "\u001b[0;31mBadRequestError\u001b[0m: Error code: 400 - {'error': {'message': \"This model's maximum context length is 8192 tokens. However, your messages resulted in 41067 tokens. Please reduce the length of the messages.\", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}" + "\u001b[0;31mBadRequestError\u001b[0m: Error code: 400 - {'error': {'message': \"This model's maximum context length is 8192 tokens. However, your messages resulted in 32968 tokens. Please reduce the length of the messages.\", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}" ] } ], From b74d369e3783ef9258a69fa320cb7e0342b6eed1 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sat, 27 Jan 2024 00:36:08 -0800 Subject: [PATCH 14/52] Update notebook, more tests --- autogen/agentchat/conversable_agent.py | 7 ++ autogen/coding/base.py | 4 +- autogen/coding/commandline_code_executor.py | 8 +- autogen/coding/ipython_code_executor.py | 91 +++++++++++++++---- test/coding/test_commandline_code_executor.py | 7 ++ test/coding/test_ipython_code_executor.py | 25 +++++ 6 files changed, 120 insertions(+), 22 deletions(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 2ed7cd40f9f..c87c530f051 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -204,6 +204,13 @@ def __init__( # New hookable methods should be added to this list as required to support new agent capabilities. self.hook_lists = {self.process_last_message: []} # This is currently the only hookable method. + @property + def code_executor(self) -> CodeExecutor | None: + """The code executor used by this agent. None if code execution is disabled.""" + if not hasattr(self, "_code_executor"): + return None + return self._code_executor + def register_reply( self, trigger: Union[Type[Agent], str, Agent, Callable[[Agent], bool], List], diff --git a/autogen/coding/base.py b/autogen/coding/base.py index 253c3591c34..dc3051b039d 100644 --- a/autogen/coding/base.py +++ b/autogen/coding/base.py @@ -83,8 +83,8 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: """ ... # pragma: no cover - def reset(self) -> None: - """Reset the code executor. + def restart(self) -> None: + """Restart the code executor. This method should be implemented by the code executor. diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py index 76293402d8a..b57d4c9f5b1 100644 --- a/autogen/coding/commandline_code_executor.py +++ b/autogen/coding/commandline_code_executor.py @@ -1,4 +1,5 @@ from typing import List, Optional, Union +import warnings from pydantic import BaseModel, Field @@ -118,7 +119,6 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: break return CodeResult(exit_code=exitcode, output=logs_all) - def reset(self) -> None: - """Reset the code executor.""" - # Reset the image to None so that the next execution will use a new image. - self.docker_image_name = None + def restart(self) -> None: + """Restart the code executor.""" + warnings.warn("Restarting command line code executor is not supported. No action is taken.") diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index 3e91c54faa4..fcf991f4d1c 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -1,6 +1,10 @@ +import base64 import json +import os from queue import Empty +import re from typing import List +import uuid from jupyter_client import KernelManager from jupyter_client.kernelspec import NoSuchKernel, KernelSpecManager @@ -21,8 +25,10 @@ class UserCapability: """An AgentCapability class that gives agent ability use a stateful code executor.""" - DEFAULT_SYSTEM_MESSAGE_UPDATE = """You have been given coding capability -to solve tasks using Python code in a stateful IPython kernel. + DEFAULT_SYSTEM_MESSAGE_UPDATE = """# IPython Coding Capability +You have been given coding capability to solve tasks using Python code in a stateful IPython kernel. +You are responsible for writing the code, and the user is responsible for executing the code. + When you write Python code, put the code in a markdown code block with the language set to Python. For example: ```python @@ -32,21 +38,25 @@ class UserCapability: ```python print(x) ``` -Each output may be text, a table, or an image. -If you want to create an image (e.g., a plot), always make sure to minimize image size. -When you suggest code, always do it incrementally rather than all at once: -If you want to import a library, do it in a separate code block. -If you want to define a function or a class, do it in a separate code block. -If you want to run a function that produces output, do it in a separate code block. -Leverage the statefulness of the kernel to avoid repeating code. + +Write code incrementally and leverage the statefulness of the kernel to avoid repeating code. +Import libraries in a separate code block. +Define a function or a class in a separate code block. +Run code that produces output in a separate code block. +Run code that involves expensive operations like download, upload, and call external APIs in a separate code block. + +When your code produces an output, the output will be returned to you. +Because you have limited conversation memory, if your code creates an image, +the output will be a path to the image instead of the image itself. """ def add_to_agent(self, agent): """Add this capability to an agent.""" agent.update_system_message(agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE) - timeout: int = Field(default=DEFAULT_TIMEOUT, ge=1) - kernel: str = "python3" + timeout: int = Field(default=DEFAULT_TIMEOUT, ge=1, description="The timeout for code execution.") + kernel: str = Field(default="python3", description="The kernel to use.") + output_dir: str = Field(default=".", description="The directory to save output files.") def __init__(self, **kwargs): super().__init__(**kwargs) @@ -77,15 +87,29 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: self._kernel_client.wait_for_ready() outputs = [] for code_block in code_blocks: - self._kernel_client.execute(code_block.code, store_history=True) + code = self._process_code(code_block.code) + self._kernel_client.execute(code, store_history=True) while True: try: msg = self._kernel_client.get_iopub_msg(timeout=self._timeout) msg_type = msg["msg_type"] content = msg["content"] if msg_type in ["execute_result", "display_data"]: - # Output is data. - outputs.append(json.dumps(content["data"])) + for data_type, data in content["data"].items(): + if data_type == "text/plain": + # Output is a text. + outputs.append(data) + elif data_type.startswith("image/"): + # Output is an image. + path = self._save_image(data) + outputs.append(f"Image data saved to {path}") + elif data_type == "text/html": + # Output is an html. + path = self._save_html(data) + outputs.append(f"HTML data saved to {path}") + else: + # Output raw data. + outputs.append(json.dumps(data)) elif msg_type == "stream": # Output is a text. outputs.append(content["text"]) @@ -104,9 +128,44 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: output=f"ERROR: Timeout waiting for output from code block: {code_block.code}", ) # We return the full output. - return CodeResult(exit_code=0, output="".join([str(output) for output in outputs])) + return CodeResult(exit_code=0, output="\n".join([str(output) for output in outputs])) - def reset(self) -> None: + def restart(self) -> None: """Restart a new session.""" self._kernel_client.stop_channels() + self._kernel_manager.shutdown_kernel() + self._kernel_manager = KernelManager(kernel_name=self.kernel) + self._kernel_manager.start_kernel() + self._kernel_client = self._kernel_manager.client() self._kernel_client.start_channels() + + def _save_image(self, image_data_base64: str) -> str: + """Save image data to a file.""" + image_data = base64.b64decode(image_data_base64) + # Randomly generate a filename. + filename = f"{uuid.uuid4().hex}.png" + path = os.path.join(self.output_dir, filename) + with open(path, "wb") as f: + f.write(image_data) + return os.path.abspath(path) + + def _save_html(self, html_data: str) -> str: + """Save html data to a file.""" + # Randomly generate a filename. + filename = f"{uuid.uuid4().hex}.html" + path = os.path.join(self.output_dir, filename) + with open(path, "w") as f: + f.write(html_data) + return os.path.abspath(path) + + def _process_code(self, code: str) -> str: + """Process code before execution.""" + # 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` or `!pip install`. + match = re.search(r"^! ?pip install", 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) diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index 0a85721c9f1..98a158c32e2 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -77,6 +77,13 @@ def _test_execute_code(config: Dict): assert code_result.exit_code and "Timeout" in code_result.output or WIN32 +def test_restart(): + executor = CommandlineCodeExecutor(use_docker=True) + # Check warning. + with pytest.warns(UserWarning, match="Restarting command line code executor is not supported. No action is taken."): + executor.restart() + + @pytest.mark.skipif(skip_openai_tests, reason="openai not installed OR requested to skip") def test_conversable_agent_capability(): KEY_LOC = "notebook" diff --git a/test/coding/test_ipython_code_executor.py b/test/coding/test_ipython_code_executor.py index f998f24a3bd..35c4690a18a 100644 --- a/test/coding/test_ipython_code_executor.py +++ b/test/coding/test_ipython_code_executor.py @@ -1,5 +1,6 @@ import os import tempfile +import uuid import pytest from autogen.agentchat.agent import Agent from autogen.agentchat.conversable_agent import ConversableAgent @@ -71,6 +72,30 @@ def test_timeout(): assert code_result.exit_code and "Timeout" in code_result.output +def test_silent_pip_install(): + executor = IPythonCodeExecutor() + code_blocks = [CodeBlock(code="!pip install matplotlib numpy", language="python")] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and code_result.output.strip() == "" + + none_existing_package = uuid.uuid4().hex + code_blocks = [CodeBlock(code=f"!pip install matplotlib_{none_existing_package}", language="python")] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and "ERROR: " in code_result.output + + +def test_restart(): + executor = IPythonCodeExecutor() + code_blocks = [CodeBlock(code="x = 123", language="python")] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and code_result.output.strip() == "" + + executor.restart() + code_blocks = [CodeBlock(code="print(x)", language="python")] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code and "NameError" in code_result.output + + @pytest.mark.skipif(skip_openai_tests, reason="openai not installed OR requested to skip") def test_conversable_agent_capability(): KEY_LOC = "notebook" From c4dc779f8c97574bf14450b1546057e5d6cc9e29 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sat, 27 Jan 2024 00:38:07 -0800 Subject: [PATCH 15/52] notebook --- ...at_auto_feedback_from_code_execution.ipynb | 322 ++++++++++-------- 1 file changed, 182 insertions(+), 140 deletions(-) diff --git a/notebook/agentchat_auto_feedback_from_code_execution.ipynb b/notebook/agentchat_auto_feedback_from_code_execution.ipynb index 02e9755112a..349eece6a7f 100644 --- a/notebook/agentchat_auto_feedback_from_code_execution.ipynb +++ b/notebook/agentchat_auto_feedback_from_code_execution.ipynb @@ -60,11 +60,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "from IPython import display\n", "from IPython.display import Image\n", "\n", "import autogen\n", @@ -502,7 +501,7 @@ ], "source": [ "try:\n", - " display(Image(filename=\"coding/stock_price_ytd.png\"))\n", + " Image(filename=\"coding/stock_price_ytd.png\")\n", "except FileNotFoundError:\n", " print(\"Image not found. Please check the file name and modify if necessary.\")" ] @@ -512,7 +511,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Use a Different Code Execution Environment\n", + "## Use IPython Code Execution Environment\n", "\n", "In the previous example, code execution happened in a separate process in a command line environment,\n", "which is not interactive and tends to waste a lot of LLM tokens on editing code script. \n", @@ -523,7 +522,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -540,7 +539,7 @@ "source": [ "user_proxy = autogen.UserProxyAgent(\n", " name=\"user_proxy\",\n", - " human_input_mode=\"NEVER\",\n", + " human_input_mode=\"ALWAYS\",\n", " max_consecutive_auto_reply=10,\n", " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", " code_execution_config={\"executor\": \"ipython\"}, # use IPython to execute the generated code\n", @@ -549,7 +548,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -560,8 +559,33 @@ " \"config_list\": config_list,\n", " \"temperature\": 0,\n", " },\n", - ")\n", - "user_proxy._code_executor.user_capability.add_to_agent(assistant)" + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are using a generic `ConversableAgent` as the `AssistantAgent`'s system\n", + "message is not compatible with IPython kernel.\n", + "To \"teach\" the generic `ConversableAgent` to understand how to use IPython kernel,\n", + "we need to add to it a \"user capability\" exported by the code executor." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "user_proxy.code_executor.user_capability.add_to_agent(assistant)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start the conversation with cache enabled." ] }, { @@ -582,48 +606,23 @@ ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "To plot the chart of META (Facebook) and TESLA stock price gain YTD, we will need to:\n", - "\n", - "1. Import the necessary libraries (pandas, yfinance, and matplotlib).\n", - "2. Download the stock data for META and TESLA using yfinance.\n", - "3. Calculate the YTD gain for each stock.\n", - "4. Plot the YTD gain for each stock.\n", - "\n", - "Let's start by importing the necessary libraries.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "Sure, I can help with that. We will use the `yfinance` library to download the stock data. If it's not already installed, you can install it using pip:\n", "\n", "```python\n", - "import pandas as pd\n", - "import yfinance as yf\n", - "import matplotlib.pyplot as plt\n", + "!pip install yfinance\n", "```\n", "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", + "After installing `yfinance`, we can proceed to download the stock data for META (Facebook) and TESLA. Let's start by importing the necessary libraries and downloading the data.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "Now that we have imported the necessary libraries, let's download the stock data for META and TESLA. We will download the data for the current year. We will use the `yf.download()` function from the yfinance library to download the data. The function takes the ticker symbol of the stock as an argument. The ticker symbol for META is 'FB' and for TESLA is 'TSLA'. We will also specify the start date as the first day of the current year.\n", - "\n", - "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -631,160 +630,143 @@ "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", "```python\n", - "from datetime import datetime\n", + "import yfinance as yf\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", "\n", - "# Get the current year\n", - "current_year = datetime.now().year\n", + "# Download historical data as dataframe\n", + "meta_data = yf.download('FB', start='2022-01-01', end=pd.to_datetime('today').strftime('%Y-%m-%d'))\n", + "tesla_data = yf.download('TSLA', start='2022-01-01', end=pd.to_datetime('today').strftime('%Y-%m-%d'))\n", "\n", - "# Download the stock data for META and TESLA\n", - "meta_data = yf.download('FB', start=f'{current_year}-01-01')\n", - "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01')\n", + "meta_data.head(), tesla_data.head()\n", "```\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "[*********************100%%**********************] 1 of 1 completed\n", - "\n", - "1 Failed download:\n", - "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n", - "[*********************100%%**********************] 1 of 1 completed\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "It seems like there was an issue with downloading the data for META (Facebook). The ticker symbol 'FB' is not working, which might be due to the recent name change of the company to Meta Platforms Inc. The new ticker symbol for Meta Platforms Inc. is 'META'. Let's try downloading the data again using the new ticker symbol.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "```python\n", - "# Download the stock data for META\n", - "meta_data = yf.download('META', start=f'{current_year}-01-01')\n", - "```\n", - "\n", - "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "[*********************100%%**********************] 1 of 1 completed\n", "\n", "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "1 Failed download:\n", "\n", - "Great, we have successfully downloaded the stock data for META and TESLA. Now, let's calculate the Year-to-Date (YTD) gain for each stock. The YTD gain is calculated as the percentage change in the stock price from the first day of the year to the current day. We will use the 'Adj Close' price for the calculation as it accounts for any corporate actions such as dividends, stock splits, etc. We will use the `pct_change()` function from pandas to calculate the percentage change.\n", + "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n", "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "[*********************100%%**********************] 1 of 1 completed\n", "\n", "\n", + "(Empty DataFrame\n", + " Columns: [Open, High, Low, Close, Adj Close, Volume]\n", + " Index: [],\n", + " Open High Low Close Adj Close \\\n", + " Date \n", + " 2022-01-03 382.583344 400.356659 378.679993 399.926666 399.926666 \n", + " 2022-01-04 396.516663 402.666656 374.350006 383.196655 383.196655 \n", + " 2022-01-05 382.216675 390.113342 360.336670 362.706665 362.706665 \n", + " 2022-01-06 359.000000 362.666656 340.166656 354.899994 354.899994 \n", + " 2022-01-07 360.123322 360.309998 336.666656 342.320007 342.320007 \n", + " \n", + " Volume \n", + " Date \n", + " 2022-01-03 103931400 \n", + " 2022-01-04 100248300 \n", + " 2022-01-05 80119800 \n", + " 2022-01-06 90336600 \n", + " 2022-01-07 84164700 )\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", + "It seems like there was an issue with downloading the data for Facebook (now Meta Platforms Inc.). The ticker symbol for Meta Platforms Inc. has changed from 'FB' to 'META'. Let's try downloading the data again using the correct ticker symbol.\n", + "\n", "```python\n", - "# Calculate the YTD gain for META and TESLA\n", - "meta_data['YTD Gain'] = meta_data['Adj Close'].pct_change().cumsum()\n", - "tesla_data['YTD Gain'] = tesla_data['Adj Close'].pct_change().cumsum()\n", + "# Download historical data as dataframe\n", + "meta_data = yf.download('META', start='2022-01-01', end=pd.to_datetime('today').strftime('%Y-%m-%d'))\n", + "\n", + "meta_data.head()\n", "```\n", "\n", "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "[*********************100%%**********************] 1 of 1 completed\n", "\n", - "Now that we have calculated the YTD gain for each stock, let's plot the YTD gain. We will use the `plot()` function from matplotlib to create the plot. We will plot the YTD gain for META and TESLA on the same plot for comparison. We will also add labels and a title to the plot for better readability.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", + " Open High Low Close Adj Close \\\n", + "Date \n", + "2022-01-03 338.299988 341.079987 337.190002 338.540009 338.540009 \n", + "2022-01-04 339.950012 343.089996 331.869995 336.529999 336.529999 \n", + "2022-01-05 333.019989 335.760010 323.839996 324.170013 324.170013 \n", + "2022-01-06 322.820007 339.170013 322.720001 332.459991 332.459991 \n", + "2022-01-07 332.739990 337.000000 328.880005 331.790009 331.790009 \n", "\n", + " Volume \n", + "Date \n", + "2022-01-03 14537900 \n", + "2022-01-04 15998000 \n", + "2022-01-05 20564500 \n", + "2022-01-06 27962800 \n", + "2022-01-07 14722000 \n", + "HTML data saved to /Users/ekzhu/autogen/notebook/95e8fc6fa80d4f30884382f11a50c52a.html\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "```python\n", - "# Create a new figure\n", - "plt.figure(figsize=(14,7))\n", + "Great, we have successfully downloaded the data for both META and TESLA. Now, let's calculate the Year-to-Date (YTD) returns for both stocks and plot them.\n", "\n", - "# Plot the YTD gain for META\n", - "plt.plot(meta_data.index, meta_data['YTD Gain'], label='META')\n", + "The YTD return is calculated as the percentage change in price from the start of the year to the current date.\n", "\n", - "# Plot the YTD gain for TESLA\n", - "plt.plot(tesla_data.index, tesla_data['YTD Gain'], label='TESLA')\n", + "```python\n", + "# Calculate YTD returns\n", + "meta_data['YTD'] = meta_data['Adj Close'].pct_change().cumsum()\n", + "tesla_data['YTD'] = tesla_data['Adj Close'].pct_change().cumsum()\n", "\n", - "# Add labels and a title\n", + "# Plot YTD returns\n", + "plt.figure(figsize=(14,7))\n", + "plt.plot(meta_data.index, meta_data['YTD'], label='META')\n", + "plt.plot(tesla_data.index, tesla_data['YTD'], label='TESLA')\n", "plt.xlabel('Date')\n", - "plt.ylabel('YTD Gain')\n", - "plt.title('META vs TESLA YTD Gain')\n", + "plt.ylabel('YTD Return')\n", + "plt.title('YTD Return of META and TESLA')\n", "plt.legend()\n", - "\n", - "# Display the plot\n", + "plt.grid(True)\n", "plt.show()\n", "```\n", "\n", "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", - "Code output: {\"text/plain\": \"
\", \"image/png\": \"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\"}\n", + "Code output:
\n", + "Image data saved to /Users/ekzhu/autogen/notebook/18778f8594ab45df9a35a48a1dd8d0a2.png\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n" - ] - }, - { - "ename": "BadRequestError", - "evalue": "Error code: 400 - {'error': {'message': \"This model's maximum context length is 8192 tokens. However, your messages resulted in 32968 tokens. Please reduce the length of the messages.\", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mBadRequestError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[5], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m autogen\u001b[38;5;241m.\u001b[39mCache\u001b[38;5;241m.\u001b[39mdisk() \u001b[38;5;28;01mas\u001b[39;00m cache:\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# the assistant receives a message from the user, which contains the task description\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43muser_proxy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minitiate_chat\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43massistant\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[38;5;124;43mPlot a chart of META and TESLA stock price gain YTD.\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:720\u001b[0m, in \u001b[0;36mConversableAgent.initiate_chat\u001b[0;34m(self, recipient, clear_history, silent, cache, **context)\u001b[0m\n\u001b[1;32m 718\u001b[0m agent\u001b[38;5;241m.\u001b[39mclient_cache \u001b[38;5;241m=\u001b[39m cache\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_prepare_chat(recipient, clear_history)\n\u001b[0;32m--> 720\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_init_message\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrecipient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 721\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m agent \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;28mself\u001b[39m, recipient]:\n\u001b[1;32m 722\u001b[0m agent\u001b[38;5;241m.\u001b[39mclient_cache \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39mprevious_cache\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", - " \u001b[0;31m[... skipping similar frames: ConversableAgent.send at line 463 (18 times), ConversableAgent.receive at line 623 (17 times)]\u001b[0m\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:623\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgenerate_reply(messages\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchat_messages[sender], sender\u001b[38;5;241m=\u001b[39msender)\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:463\u001b[0m, in \u001b[0;36mConversableAgent.send\u001b[0;34m(self, message, recipient, request_reply, silent)\u001b[0m\n\u001b[1;32m 461\u001b[0m valid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_append_oai_message(message, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124massistant\u001b[39m\u001b[38;5;124m\"\u001b[39m, recipient)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m valid:\n\u001b[0;32m--> 463\u001b[0m \u001b[43mrecipient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreceive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequest_reply\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 466\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt be converted into a valid ChatCompletion message. Either content or function_call must be provided.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 467\u001b[0m )\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:621\u001b[0m, in \u001b[0;36mConversableAgent.receive\u001b[0;34m(self, message, sender, request_reply, silent)\u001b[0m\n\u001b[1;32m 619\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m request_reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m request_reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreply_at_receive[sender] \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m:\n\u001b[1;32m 620\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m--> 621\u001b[0m reply \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_reply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchat_messages\u001b[49m\u001b[43m[\u001b[49m\u001b[43msender\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msender\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m reply \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 623\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msend(reply, sender, silent\u001b[38;5;241m=\u001b[39msilent)\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:1356\u001b[0m, in \u001b[0;36mConversableAgent.generate_reply\u001b[0;34m(self, messages, sender, exclude)\u001b[0m\n\u001b[1;32m 1354\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 1355\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_match_trigger(reply_func_tuple[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrigger\u001b[39m\u001b[38;5;124m\"\u001b[39m], sender):\n\u001b[0;32m-> 1356\u001b[0m final, reply \u001b[38;5;241m=\u001b[39m \u001b[43mreply_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msender\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msender\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreply_func_tuple\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mconfig\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1357\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m final:\n\u001b[1;32m 1358\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m reply\n", - "File \u001b[0;32m~/autogen/autogen/agentchat/conversable_agent.py:821\u001b[0m, in \u001b[0;36mConversableAgent.generate_oai_reply\u001b[0;34m(self, messages, sender, config)\u001b[0m\n\u001b[1;32m 818\u001b[0m all_messages\u001b[38;5;241m.\u001b[39mappend(message)\n\u001b[1;32m 820\u001b[0m \u001b[38;5;66;03m# TODO: #1143 handle token limit exceeded error\u001b[39;00m\n\u001b[0;32m--> 821\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mclient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 822\u001b[0m \u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmessages\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpop\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcontext\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 823\u001b[0m \u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_oai_system_message\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mall_messages\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 824\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclient_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 825\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 827\u001b[0m extracted_response \u001b[38;5;241m=\u001b[39m client\u001b[38;5;241m.\u001b[39mextract_text_or_completion_object(response)[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 829\u001b[0m \u001b[38;5;66;03m# ensure function and tool calls will be accepted when sent back to the LLM\u001b[39;00m\n", - "File \u001b[0;32m~/autogen/autogen/oai/client.py:283\u001b[0m, in \u001b[0;36mOpenAIWrapper.create\u001b[0;34m(self, **config)\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m \u001b[38;5;66;03m# filter is not passed; try the next config\u001b[39;00m\n\u001b[1;32m 282\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 283\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_completions_create\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 284\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m APIError \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[1;32m 285\u001b[0m error_code \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(err, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcode\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n", - "File \u001b[0;32m~/autogen/autogen/oai/client.py:548\u001b[0m, in \u001b[0;36mOpenAIWrapper._completions_create\u001b[0;34m(self, client, params)\u001b[0m\n\u001b[1;32m 546\u001b[0m params \u001b[38;5;241m=\u001b[39m params\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[1;32m 547\u001b[0m params[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstream\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m--> 548\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mcompletions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 550\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response\n", - "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_utils/_utils.py:272\u001b[0m, in \u001b[0;36mrequired_args..inner..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 270\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMissing required argument: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mquote(missing[\u001b[38;5;241m0\u001b[39m])\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(msg)\n\u001b[0;32m--> 272\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/resources/chat/completions.py:645\u001b[0m, in \u001b[0;36mCompletions.create\u001b[0;34m(self, messages, model, frequency_penalty, function_call, functions, logit_bias, logprobs, max_tokens, n, presence_penalty, response_format, seed, stop, stream, temperature, tool_choice, tools, top_logprobs, top_p, user, extra_headers, extra_query, extra_body, timeout)\u001b[0m\n\u001b[1;32m 596\u001b[0m \u001b[38;5;129m@required_args\u001b[39m([\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmessages\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel\u001b[39m\u001b[38;5;124m\"\u001b[39m], [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmessages\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstream\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m 597\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate\u001b[39m(\n\u001b[1;32m 598\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 643\u001b[0m timeout: \u001b[38;5;28mfloat\u001b[39m \u001b[38;5;241m|\u001b[39m httpx\u001b[38;5;241m.\u001b[39mTimeout \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m|\u001b[39m NotGiven \u001b[38;5;241m=\u001b[39m NOT_GIVEN,\n\u001b[1;32m 644\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ChatCompletion \u001b[38;5;241m|\u001b[39m Stream[ChatCompletionChunk]:\n\u001b[0;32m--> 645\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_post\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 646\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/chat/completions\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 647\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmaybe_transform\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 648\u001b[0m \u001b[43m \u001b[49m\u001b[43m{\u001b[49m\n\u001b[1;32m 649\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmessages\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 650\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmodel\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 651\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfrequency_penalty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfrequency_penalty\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 652\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunction_call\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunction_call\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 653\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunctions\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunctions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 654\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlogit_bias\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogit_bias\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 655\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlogprobs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogprobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 656\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmax_tokens\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 657\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mn\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 658\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpresence_penalty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mpresence_penalty\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 659\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mresponse_format\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mresponse_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 660\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mseed\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mseed\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 661\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstop\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mstop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 662\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstream\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 663\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtemperature\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtemperature\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 664\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtool_choice\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtool_choice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 665\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtools\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtools\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 666\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtop_logprobs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtop_logprobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 667\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtop_p\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtop_p\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 668\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43muser\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43muser\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 669\u001b[0m \u001b[43m \u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 670\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompletion_create_params\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mCompletionCreateParams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 671\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 672\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmake_request_options\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 673\u001b[0m \u001b[43m \u001b[49m\u001b[43mextra_headers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_headers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_query\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_query\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_body\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_body\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\n\u001b[1;32m 674\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 675\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mChatCompletion\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 676\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 677\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mStream\u001b[49m\u001b[43m[\u001b[49m\u001b[43mChatCompletionChunk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 678\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:1088\u001b[0m, in \u001b[0;36mSyncAPIClient.post\u001b[0;34m(self, path, cast_to, body, options, files, stream, stream_cls)\u001b[0m\n\u001b[1;32m 1074\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpost\u001b[39m(\n\u001b[1;32m 1075\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 1076\u001b[0m path: \u001b[38;5;28mstr\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1083\u001b[0m stream_cls: \u001b[38;5;28mtype\u001b[39m[_StreamT] \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 1084\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResponseT \u001b[38;5;241m|\u001b[39m _StreamT:\n\u001b[1;32m 1085\u001b[0m opts \u001b[38;5;241m=\u001b[39m FinalRequestOptions\u001b[38;5;241m.\u001b[39mconstruct(\n\u001b[1;32m 1086\u001b[0m method\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpost\u001b[39m\u001b[38;5;124m\"\u001b[39m, url\u001b[38;5;241m=\u001b[39mpath, json_data\u001b[38;5;241m=\u001b[39mbody, files\u001b[38;5;241m=\u001b[39mto_httpx_files(files), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions\n\u001b[1;32m 1087\u001b[0m )\n\u001b[0;32m-> 1088\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cast(ResponseT, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mopts\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m)\u001b[49m)\n", - "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:853\u001b[0m, in \u001b[0;36mSyncAPIClient.request\u001b[0;34m(self, cast_to, options, remaining_retries, stream, stream_cls)\u001b[0m\n\u001b[1;32m 844\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrequest\u001b[39m(\n\u001b[1;32m 845\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 846\u001b[0m cast_to: Type[ResponseT],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 851\u001b[0m stream_cls: \u001b[38;5;28mtype\u001b[39m[_StreamT] \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 852\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResponseT \u001b[38;5;241m|\u001b[39m _StreamT:\n\u001b[0;32m--> 853\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 854\u001b[0m \u001b[43m \u001b[49m\u001b[43mcast_to\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcast_to\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 855\u001b[0m \u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 856\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 857\u001b[0m \u001b[43m \u001b[49m\u001b[43mstream_cls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream_cls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 858\u001b[0m \u001b[43m \u001b[49m\u001b[43mremaining_retries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mremaining_retries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 859\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/autogen/lib/python3.11/site-packages/openai/_base_client.py:930\u001b[0m, in \u001b[0;36mSyncAPIClient._request\u001b[0;34m(self, cast_to, options, remaining_retries, stream, stream_cls)\u001b[0m\n\u001b[1;32m 927\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mis_closed:\n\u001b[1;32m 928\u001b[0m err\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mread()\n\u001b[0;32m--> 930\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_status_error_from_response(err\u001b[38;5;241m.\u001b[39mresponse) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 932\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_process_response(\n\u001b[1;32m 933\u001b[0m cast_to\u001b[38;5;241m=\u001b[39mcast_to,\n\u001b[1;32m 934\u001b[0m options\u001b[38;5;241m=\u001b[39moptions,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 937\u001b[0m stream_cls\u001b[38;5;241m=\u001b[39mstream_cls,\n\u001b[1;32m 938\u001b[0m )\n", - "\u001b[0;31mBadRequestError\u001b[0m: Error code: 400 - {'error': {'message': \"This model's maximum context length is 8192 tokens. However, your messages resulted in 32968 tokens. Please reduce the length of the messages.\", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}" + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "Here is the Year-to-Date (YTD) return chart for META and TESLA. The chart shows the cumulative percentage change in the adjusted closing price of each stock from the start of the year to the current date.\n", + "\n", + "![YTD Return of META and TESLA](sandbox:/Users/ekzhu/autogen/notebook/18778f8594ab45df9a35a48a1dd8d0a2.png)\n", + "\n", + "--------------------------------------------------------------------------------\n" ] } ], @@ -796,6 +778,66 @@ " message=\"\"\"Plot a chart of META and TESLA stock price gain YTD.\"\"\",\n", " )" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By using the IPython kernel as the execution environment, the code is generated\n", + "and executed incrementally rather than in a single script. This is more efficient\n", + "and can save a lot of LLM tokens on going back and forth between editing and executing.\n", + "\n", + "Let's display the generated figure." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI8AAAJwCAYAAAAA4UH0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5wTdf7H8VeS7R3YRl96FUEQREUEBBXsvSvnWc56cnp3ev4sp57lrHfWs3EqomI/C4p0AUHpvfftwPaWTeb3x6Rstpdsfz8fDx5JJjOTb3aWzeQzn8/nazEMw0BERERERERERKQS1uYegIiIiIiIiIiItFwKHomIiIiIiIiISJUUPBIRERERERERkSopeCQiIiIiIiIiIlVS8EhERERERERERKqk4JGIiIiIiIiIiFRJwSMREREREREREamSgkciIiIiIiIiIlIlBY9ERERERERERKRKCh6JiIiI+MHOnTuZMmUK0dHRWCwWvvzyy+YeUpuxaNEiLBYLixYtau6hiIiItEsKHomIiLQwZ599Nh06dCAtLa3Cc9nZ2XTu3JmEhAQsFkuN/2bOnAngsywgIICOHTsycuRI7r77brZs2VLrsSUlJfnsKzw8nNGjR/Pee+/V+/2++uqrnnG2Ztdffz0bN27kiSee4P3332fUqFGVrrdv3z7Pz+/xxx+vdJ2rr74ai8VCRESEz/LTTz+9ymM9cOBAgFr9XpQPxLz66qtYLBbGjBnjnx9GM6jL+y57DCr799RTT3n263Q6ee+99xgzZgwdO3YkMjKS/v37c9111/HLL7941nMHuD799NNaj/myyy7DYrHwl7/8xa8/CxEREX8LaO4BiIiIiK9XX32VoUOHcs899/Dhhx/6PPfAAw+QmZnJgw8+SJ8+fTzLv/vuO2bPns0LL7xAbGysZ/nJJ5/suT958mSuu+46DMMgOzub9evX89///pdXX32Vp59+mhkzZtRqfMOHD+dPf/oTACkpKbz11ltcf/31FBcXc9NNN9Xr/cbGxnLDDTfUeduWorCwkBUrVvC3v/2NO+64o1bbhISEMHv2bB588EGf5fn5+Xz11VeEhIRUul23bt148sknKyyPjo4G4P333/dZ/t577zFv3rwKywcNGuS5P2vWLJKSkli1ahW7du2ib9++tXoPLUld3ndhYSEAV155JVOnTq2wrxEjRnju33XXXbzyyiucf/75XH311QQEBLB9+3a+//57evfuzUknnVSv8ebk5PC///2PpKQkZs+ezVNPPYXFYqnXvkRERBqdISIiIi3O008/bQDGDz/84Fm2atUqw2q1Gn/+858rrP/Pf/7TAIy9e/dWuj/AuP322yssz8zMNMaOHWsAxrffflvjuHr27GlMmzbNZ1l6eroRERFhDBo0qMbtKzNkyBBj/Pjx9dq2Kk6n0ygoKPDrPquzf/9+AzD++c9/1rju3r17DcC46KKLDMBYt26dz/OzZs0yAgMDjXPPPdcIDw/3eW78+PHGkCFD6jS222+/3ajulG/Pnj0GYHz++edGXFyc8cgjj9Rp/01h4cKFBmAsXLiw1ttU977dx6Cm45WammpYLBbjpptuqvCc0+k00tLSKoxxzpw5tRrfO++8YwQGBhoLFiwwAGPRokW12k5ERKQ5qGxNRESkBZoxYwbDhg3jtttuo6ioCIfDwa233krPnj15+OGH/fY6nTp14qOPPiIgIIAnnniiXvuIi4tj4MCB7N6922e50+nkxRdfZMiQIYSEhJCQkMAtt9zCsWPHPOskJSWxefNmFi9e7CkZOv300wF45JFHKs3EmDlzJhaLhX379vns55xzzuGHH35g1KhRhIaG8sYbb3hKiT755BOeeOIJunXrRkhICJMmTWLXrl21en9r167l7LPPJioqioiICCZNmuRTrvTII4/Qs2dPAO677z4sFgtJSUk17nfs2LH06tWrQnbZrFmzOOuss+jYsWOtxtdQs2bNokOHDkybNo1LLrmEWbNm1Xrbr776imnTptGlSxeCg4Pp06cPjz32GA6Hw2e9008/naFDh7JlyxYmTJhAWFgYXbt25Zlnnqmwz0OHDnHBBRcQHh5OfHw899xzD8XFxQ1+n/Wxd+9eDMPglFNOqfCcxWIhPj6+3vueNWsWkydPZsKECQwaNKhOP3cREZGmprI1ERGRFiggIID//Oc/nHzyyTz22GPEx8ezZs0a5s6dS1hYmF9fq0ePHowfP56FCxeSk5NDVFRUnbYvLS3l0KFDdOjQwWf5LbfcwsyZM5k+fTp33XUXe/fu5eWXX2bt2rUsW7aMwMBAXnzxRe68804iIiL429/+BkBCQkK93sf27du58sorueWWW7jpppsYMGCA57mnnnoKq9XKvffeS3Z2Ns888wxXX301K1eurHafmzdvZty4cURFRfHnP/+ZwMBA3njjDU4//XQWL17MmDFjuOiii4iJieGee+7xlEGV71VUlSuvvJIPPvjAU7KUmZnJjz/+yPvvv8/cuXMr3cbhcJCZmVlheWhoKOHh4bV63bJmzZrFRRddRFBQEFdeeSWvvfYav/76KyeeeGKN286cOZOIiAhmzJhBREQECxYs4KGHHiInJ4d//vOfPuseO3aMs846i4suuojLLruMTz/9lL/85S8cd9xxnH322YBZ/jdp0iQOHDjAXXfdRZcuXXj//fdZsGBBnd9XbRQUFFT6s4yJiSEgIMATFJwzZw6XXnqp3/7vJScns3DhQv773/8C5u/BCy+8wMsvv0xQUJBfXkNERMSvmjv1SURERKp2xx13GIGBgUZERIRx5ZVXVrlefcvW3O6++24DMNavX1/teHr27GlMmTLFyMjIMDIyMoyNGzca1157bYX9L1261ACMWbNm+Ww/d+7cCsurKlt7+OGHKy07evfddyu81549exqAMXfuXJ913aVEgwYNMoqLiz3LX3rpJQMwNm7cWO37veCCC4ygoCBj9+7dnmXJyclGZGSkcdppp3mW1bYMqvy6mzZtMgBj6dKlhmEYxiuvvGJEREQY+fn5xvXXX19p2RpQ6b9bbrml0terrnzrt99+MwBj3rx5hmGYpVjdunUz7r777hrfh2EYlZYG3nLLLUZYWJhRVFRUYdzvvfeeZ1lxcbGRmJhoXHzxxZ5lL774ogEYn3zyiWdZfn6+0bdv30YpW6vq34oVKzzrXnfddQZgdOjQwbjwwguNZ5991ti6dWuFfdalbO3ZZ581QkNDjZycHMMwDGPHjh0GYHzxxRe1fn8iIiJNSWVrIiIiLdgTTzxBp06dsFqtvPDCC432Ou5Mmdzc3BrX/fHHH4mLiyMuLo7jjjuO999/n+nTp/tkmsyZM4fo6GgmT55MZmam59/IkSOJiIhg4cKFfn8PvXr14swzz6z0uenTp/tkdIwbNw6APXv2VLk/h8PBjz/+yAUXXEDv3r09yzt37sxVV13Fzz//TE5OToPGPGTIEIYNG8bs2bMB+PDDDzn//POrzXBJSkpi3rx5Ff798Y9/rPPrz5o1i4SEBCZMmACYpViXX345H330UYXSs8qEhoZ67ufm5pKZmcm4ceMoKChg27ZtPutGRERwzTXXeB4HBQUxevRon2Pw3Xff0blzZy655BLPsrCwMG6++eY6v7fauPnmmyv9WQ4ePNizzrvvvsvLL79Mr169+OKLL7j33nsZNGgQkyZN4vDhw/V63VmzZjFt2jQiIyMB6NevHyNHjlTpmoiItFgqWxMREWnBoqKiGDBgAJmZmfUu56qNvLw8AM+X2eqMGTOGxx9/HIfDwaZNm3j88cc5duyYT3Bm586dZGdnV9kTJj093T8DL6NXr15VPtejRw+fx+4Su7L9l8rLyMigoKDAp/zNbdCgQTidTg4ePMiQIUPqOWLTVVddxXPPPcc999zD8uXLeeCBB6pdPzw8nDPOOKNBrwlmcOyjjz5iwoQJ7N2717N8zJgxPPfcc8yfP58pU6ZUu4/Nmzfz4IMPsmDBggqBtOzsbJ/H3bp1q9DDqkOHDmzYsMHzeP/+/fTt27fCepUdA3/o169fjT9Lq9XK7bffzu23386RI0dYtmwZr7/+Ot9//z1XXHEFS5curdNrbt26lbVr13Ldddf59N06/fTTeeWVV+pVOioiItLYFDwSERERNm3ahM1mqzYA4xYbG+v5wn3mmWcycOBAzjnnHF566SVmzJgBmM2y4+Pjq8ykiIuLq/F1qpq2vKqMmLJZMOXZbLZKlxuGUeM4GtuVV17J/fffz0033USnTp1qDNj4y4IFC0hJSeGjjz7io48+qvD8rFmzqh1LVlYW48ePJyoqir///e/06dOHkJAQ1qxZw1/+8hecTqfP+i35GNRWp06dOO+88zjvvPM8fa/279/v6Y1UGx988AEA99xzD/fcc0+F5z/77DOmT5/utzGLiIj4g4JHIiIi7dyBAwdYvHgxY8eOrVXmUXnTpk1j/Pjx/OMf/+CWW24hPDycPn368NNPP3HKKadUG9SBqoNE7uygrKwsYmJiPMv3799f5zHWR1xcHGFhYWzfvr3Cc9u2bcNqtdK9e/cGv06PHj045ZRTWLRoEX/4wx8ICGia07NZs2YRHx/PK6+8UuG5zz//nC+++ILXX3+9yuO3aNEijhw5wueff85pp53mWV42i6muevbsyaZNmzAMw+f3orJj0NxGjRrF4sWLSUlJqXXwyDAMPvzwQyZMmMBtt91W4fnHHnuMWbNmKXgkIiItjnoeiYiItGNHjx7lyiuvxOFweGY7q4+//OUvHDlyhDfffBOAyy67DIfDwWOPPVZh3dLSUrKysjyPw8PDfR679enTB4AlS5Z4luXn53tmqGpsNpuNKVOm8NVXX7Fv3z7P8rS0ND788ENOPfVUv5UXPf744zz88MPceeedftlfTQoLC/n8888555xzuOSSSyr8u+OOO8jNzeXrr7+uch/uTKKymUMlJSW8+uqr9R7X1KlTSU5O5tNPP/UsKygo4D//+U+999kQqampbNmypcLykpIS5s+fj9VqpW/fvrXe37Jly9i3bx/Tp0+v9Od++eWXs3DhQpKTk/35NkRERBpMmUciIiLtxI4dO/jggw8wDIOcnBzWr1/PnDlzyMvL4/nnn+ess86q977PPvtshg4dyvPPP8/tt9/O+PHjueWWW3jyySdZt24dU6ZMITAwkJ07dzJnzhxeeuklT1PkkSNH8tprr/H444/Tt29f4uPjmThxIlOmTKFHjx7ceOON3HfffdhsNt555x3i4uI4cOCAv34s1Xr88ceZN28ep556KrfddhsBAQG88cYbFBcX88wzz/jtdcaPH8/48eNrtW52dran9Km8sg2pq/P111+Tm5vLeeedV+nzJ510EnFxccyaNYvLL7+80nVOPvlkOnTowPXXX89dd92FxWLh/fffb1AZ2k033cTLL7/Mddddx+rVq+ncuTPvv/9+tQ3EG2LNmjWV/iz79OnD2LFjOXToEKNHj2bixIlMmjSJxMRE0tPTmT17NuvXr+ePf/wjsbGxPtt+9tlnFZqFA1x//fXMmjULm83GtGnTKh3Peeedx9/+9jc++ugjTwmoiIhIS6DgkYiISDvhnknKarUSFRVFr169uP7667n55pt9Zpeqr3vvvZcbbriBWbNmccMNN/D6668zcuRI3njjDR544AECAgJISkrimmuu4ZRTTvFs99BDD7F//36eeeYZcnNzGT9+PBMnTiQwMJAvvviC2267jf/7v/8jMTGRP/7xj3To0KHJynqGDBnC0qVLuf/++3nyySdxOp2MGTOGDz74gDFjxjTJGMo7dOgQ1157baXP1TZ4NGvWLEJCQpg8eXKlz1utVqZNm8asWbM4cuQInTp1qrBOp06d+Oabb/jTn/7Egw8+SIcOHbjmmmuYNGlSlbPe1SQsLIz58+dz55138u9//5uwsDCuvvpqzj777AYFN6sye/Zsz0x3ZV1//fWMHTuWAQMG8OKLL/Ldd9/x6quvkpaWRkhICEOHDuXNN9/kxhtvrLBtZf2jwAwQzpkzh5NPPpmOHTtWus7QoUPp1asXH3zwgYJHIiLSoliM1tSlUEREREREREREmpR6HomIiIiIiIiISJUUPBIRERERERERkSopeCQiIiIiIiIiIlVS8EhERERERERERKqk4JGIiIiIiIiIiFRJwSMREREREREREalSQHMPoKVzOp0kJycTGRmJxWJp7uGIiIiIiIiIiPiFYRjk5ubSpUsXrNaq84sUPKpBcnIy3bt3b+5hiIiIiIiIiIg0ioMHD9KtW7cqn1fwqAaRkZGA+YOMiopq5tHUjt1u58cff2TKlCkEBgY293DET3Rc2zYd37ZNx7ft0zFum3Rc2y4d27ZPx7jt0zH2j5ycHLp37+6JfVRFwaMauEvVoqKiWlXwKCwsjKioKP0nakN0XNs2Hd+2Tce37dMxbpt0XNsuHdu2T8e47dMx9q+a2vSoYbaIiIiIiIiIiFRJwSMREREREREREamSgkciIiIiIiIiIlIl9TzyA8MwKC0txeFwNPdQALP2MyAggKKiohYzJn8JDAzEZrM19zBERERERERE2g0FjxqopKSElJQUCgoKmnsoHoZhkJiYyMGDB2tsetXaWCwWunXrRkRERHMPRURERERERKRdUPCoAZxOJ3v37sVms9GlSxeCgoJaRLDG6XSSl5dHREQEVmvbqUw0DIOMjAwOHTpEv379lIEkIiIiIiIi0gQUPGqAkpISnE4n3bt3JywsrLmH4+F0OikpKSEkJKRNBY8A4uLi2LdvH3a7XcEjERERERERkSbQtiILzaStBWhaspaQ2SUiIiIiIiLSnijqISIiIiIiIiIiVVLwSEREREREREREqqTgkYiIiIiIiIiIVEnBo3bqhhtuwGKxcOutt1Z47vbbb8disXDDDTf4rFv+31lnncWiRYsqfa7sv0WLFgFw6NAhgoKCGDp0aBO+UxERERERERFpCM221o51796djz76iBdeeIHQ0FAAioqK+PDDD+nRo4fPumeddRbvvvuuz7Lg4GDCw8NJSUnxLLv77rvJycnxWbdjx44AzJw5k8suu4wlS5awcuVKxowZ01hvTURERERERET8RMEjPzIMg0K7o1leOzTQVueZyE444QR2797N559/ztVXXw3A559/To8ePejVq5fPusHBwSQmJla6n7LLQ0NDKS4urrCuYRi8++67vPrqq3Tr1o23335bwSMRERERERGRVkDBIz8qtDsY/NAPzfLaW/5+JmFBdT+cv/vd73j33Xc9waN33nmH6dOne0rN/GXhwoUUFBRwxhln0LVrV04++WReeOEFwsPD/fo6IiIiIiIiIuJf6nnUzl1zzTX8/PPP7N+/n/3797Ns2TKuueaaCut98803RERE+Pz7xz/+UevXefvtt7niiiuw2WwMHTqU3r17M2fOHH++FRERERERERFpBMo88qPQQBtb/n5ms712fcTFxTFt2jRmzpyJYRhMmzaN2NjYCutNmDCB1157zWeZu5dRTbKysvj888/5+eefPcuuueYa3n77bU9TbhERERERERFpmRQ88iOLxVKv0rHm9rvf/Y477rgDgFdeeaXSdcLDw+nbt2+99v/hhx9SVFTk0+PIMAycTic7duygf//+9dqviIiIiIiIiDQ+la0JZ511FiUlJdjtds480/+ZU2+//TZ/+tOfWLduneff+vXrGTduHO+8847fX09ERERERERE/Kf1pcmI39lsNrZu3eq5X5ni4mJSU1N9lgUEBFRa4lbWunXrWLNmDbNmzWLgwIE+z1155ZX8/e9/5/HHHycgQL+KIiIiIiIi0noUlJQSEmDDaq3bzOetkTKPBICoqCiioqKqfH7u3Ll07tzZ59+pp55a437ffvttBg8eXCFwBHDhhReSnp7Od99916Cxi4iIiIiIiDQVp9Pgi7WHmPjsYj5fe7i5h9MklO7RTs2cObPa57/88kufdWtav6r9/vvf/65y3cTERBwOR632KyIiIiIiItIS3DtnvSdoNHvVAS4+oSsWS9vOPlLwSERERERERESkFr7ZkMznaw9js1qYMbk/N57aq80HjkDBIxERERERERGRGhXZHTz01WYAbp/Ql9sn1G9G8tZIPY9ERERERERERGqwbFcmR/NL6Bwdwh3tKHAECh6JiIiIiIiIiNRo/rZ0ACYPTiAooH2FU9rXuxURERERERERqSPDMFiw1QweTRwY38yjaXoKHomIiIiIiIiIVGNzcg6pOUWEBto4qXen5h5Ok1PwSERERERERETEpbjUwabD2RTZHZ5lH/96EIDT+scSEmhrrqE1G822JiIiIiIiIiLi8vy8HbyxeA8RwQFMGZzA6QPj+fg3M3g0/ZRezTy65qHgkYiIiIiIiIiIy+LtGQDkFZfy+drDfL72MAAn9IhhTK+OzTm0ZqOyNRERERERERERIL+4lB1puQC8ce1Ibjg5ibjIYGxWC/dOGYDFYmnmETYPBY/aGYvFUu2/Rx55hH379lX5/C+//AKAw+HgqaeeYuDAgYSGhtKxY0fGjBnDW2+95XmtG264gQsuuKDGMR06dIigoCCGDh3aWG9bREREREREpEabDmfjNCAxKoQzhyTyyHlD+OX+Sax7aDIn941t7uE1m1YXPHrllVdISkoiJCSEMWPGsGrVqlpt99FHH2GxWGoVzGjLUlJSPP9efPFFoqKifJbde++9nnV/+uknn+dSUlIYOXIkAI8++igvvPACjz32GFu2bGHhwoXcfPPNZGVl1XlMM2fO5LLLLiMnJ4eVK1f6662KiIiIiIiI1MmGQ9kAHN892rPMZrUQGRLYXENqEVpVz6OPP/6YGTNm8PrrrzNmzBhefPFFzjzzTLZv3058fHyV2+3bt497772XcePGNe4ADQPsBY37GlUJDINapM8lJiZ67kdHR2OxWHyWAWRmZgLQqVOnCs+5ff3119x2221ceumlnmXHH398nYdtGAbvvvsur776Kt26dePtt99mzJgxdd6PiIiIiIiISEOtO5QFwPHdY5p1HC1NqwoePf/889x0001Mnz4dgNdff51vv/2Wd955h7/+9a+VbuNwOLj66qt59NFHWbp0aY2ZMcXFxRQXF3se5+TkAGC327Hb7T7r2u12DMPA6XTidDqhJB/rU90a8A7rz/nXQxAUDpgBGfet0+msehvXc+XXKbu8qu0TEhJYsGABt956K3FxcZWuYxhGjWNYsGABBQUFTJw4kc6dO3Pqqafy3HPPER4eXuWYDcPAbrdjs7Wv6RHdv3/lfw+lbdDxbdt0fNs+HeO2Sce17dKxbft0jNu+xjrG6w8cA2BIYkS7+P2p7XtsNcGjkpISVq9ezf333+9ZZrVaOeOMM1ixYkWV2/39738nPj6eG2+8kaVLl9b4Ok8++SSPPvpoheU//vgjYWFhPssCAgJITEwkLy+PkpISsBcQU/u35Fc5ubkQ6PBZlpubW+02RUVFGIbhCZC55eXlAXDqqaditfpWNh46dAgwy9ZuuOEGunTpwsCBAxk9ejRTp05l8uTJnnXtdjulpaUV9l/WG2+8wYUXXkh+fj49evSgZ8+evP/++1x11VWVrl9SUkJhYSFLliyhtLS02vfXVs2bN6+5hyCNSMe3bdPxbft0jNsmHde2S8e27dMxbvvqeoyXp1nYcszCpb2dRAf5Ppdnh0NZZpgkZfNKvtvur1G2XAUFtaueajXBo8zMTBwOBwkJCT7LExIS2LZtW6Xb/Pzzz7z99tusW7eu1q9z//33M2PGDM/jnJwcunfvzpQpU4iKivJZt6ioiIMHDxIREUFISAgYkWYGUDOIKlO2ZhgGubm5REZGVtsJPiQkBIvFUuF9RUREADB79mwGDRrk+zqudUePHs2mTZtYvXo1y5cvZ8mSJVx55ZVcf/31vPnmmwAEBgYSEBBQYf9uWVlZfPPNNyxZssSzznXXXcfs2bO59dZbK92mqKiI0NBQTjvtNPNn3o7Y7XbmzZvH5MmTCQxs3/W2bZGOb9um49v26Ri3TTqubZeObdunY9z21ecYF5c6+dtTi8grLsV+KIoPf3+iTy+jRTsy4Le19I4N5+LzTmmsobco1SV7lNVqgkd1lZuby7XXXsubb75JbGztO6IHBwcTHBxcYXlgYGCFX0iHw4HFYsFqtXozdGyRDRq3P7jLxNxjq4r7ufLruB/37NmT/v37V7v9mDFjGDNmDPfccw8ffPAB1157LQ8++CC9evXyzNBW1Rg++ugjioqKGDt2rGeZu8xt165dlb621WrFYrFUejzai/b83tsDHd+2Tce37dMxbpt0XNsuHdu2T8e47avLMV66O428YrOCZVtaHn/4cD3//d1oQgLNliibks0qnOHdY9rN701t32ermW0tNjYWm81GWlqaz/K0tLRKmzrv3r2bffv2ce655xIQEEBAQADvvfceX3/9NQEBAezevbupht5uDB48GID8/Pxarf/222/zpz/9iXXr1nn+rV+/nnHjxvHOO+805lBFRERERESknSiyO5jz20FeXWjGAU7rH0dkcAAr9x7ljx+tw+E0+wavV7PsKrWazKOgoCBGjhzJ/PnzueCCCwAzw2b+/PnccccdFdYfOHAgGzdu9Fn24IMPkpuby0svvUT37t2bYtit2pEjR0hNTfVZFhMTQ0hICJdccgmnnHIKJ598MomJiezdu5f777+f/v37M3DgQM/62dnZFcoGO3XqxJEjR1izZg2zZs3yWR/gyiuv5O9//zuPP/44AQGt5ldUREREREREWqA5qw/xf19u8jy+7fQ+GAZc/84q5m5O5f++2sQTFwxl/cEsQMGjyrSqb+YzZszg+uuvZ9SoUYwePZoXX3yR/Px8z+xr1113HV27duXJJ58kJCSEoUOH+mwfExMDUGG5VO6MM86osGz27NlcccUVnHnmmcyePZsnn3yS7OxsEhMTmThxIo888ohPwGfRokWMGDHCZx833ngjoaGhDB48uELgCODCCy/kjjvu4LvvvuO8887z/xsTERERERGRdmNPRp7nflKnME5M6ojNauGlK4Zz24dr+HDlAYpKHBwrsBNoszCoc/O3o2lpWlXw6PLLLycjI4OHHnqI1NRUhg8fzty5cz1NtA8cOFBtjx/xdcMNN3DDDTdUWJ6UlIRhGNVue9NNN3HTTTdVu87MmTOZOXNmnceVmJiIw+GoeUURERERERGRGqRkFQHwu1N6cduEPtis5sRSZx/XmcfOH8qDX27i87WHATipdyeCA2zNNtaWqlUFjwDuuOOOSsvUwMxyqU59AhkiIiIiIiIi0nolZxcCMLZPJ2IjfCfIuuaknmQX2nlp/k7OP74Lfz27YnWMtMLgkYiIiIiIiIhIbSVnmcGjLjEhlT5/+4S+/GF8H6yujCSpSDVeIiIiIiIiItImFdkdZOaVANA1JrTK9RQ4qp6CRyIiIiIiIiLSJqVkm/2OwoJsRIcGNvNoWi8Fj/ygpubS4j/6WYuIiIiIiEhteUvWQrFYlF1UXwoeNUBgoBm1LCgoaOaRtB8lJWa6oc2m7vciIiIiIiJSvcOu4FHn6Mr7HUntqGF2A9hsNmJiYkhPTwcgLCysRUQynU4nJSUlFBUVYbW2nfig0+kkIyODsLAwAgL0qysiIiIiIiJVS88pYvPhbKD6fkdSM30Db6DExEQATwCpJTAMg8LCQkJD215antVqpUePHm3ufYmIiIiIiIivzLxi3l+xn42Hs7l7Uj+O7x5T6233ZeZz7r9/Jre4FDDL1qT+FDxqIIvFQufOnYmPj8dutzf3cACw2+0sWbKE0047zVNa11YEBQW1qWwqERERERERqcjhNLjmrZVsS80FoLjUwazfn1SrbZ1Og/s+Xe8JHIHK1hpKwSM/sdlsLaYPj81mo7S0lJCQkDYXPBIREREREZG279uNKZ7AEcCK3UdIzykiPqrmINC7y/fx675jhAfZuHJ0D9YfymLCwPjGHG6bp+CRiIiIiIiIiDQ5wzBwGmCzmm1JSh1OtqTksGrvUd5dtg+AP03uz4Lt6aw9kMU3G1L43am9qt3nnow8/vnDNgAemDaIq8f0bNT30F4oeCQiIiIiIiIiTe7VRbv55w/bmTgwHrvDyZr9x8gvcXiej40I4vpTkogMCWDtgSw++e0g15zUk6CAyluZOJwG9326gSK7k1P7xnLV6B5N9VbaPDWPEREREREREZEm5XQa/Hf5PgAWbEtn6c5M8kscRIUEMGlgPH89eyBf33EqUSGBnHt8FyKDA9iWmss/vtta5T7fXbaX1fuPEREcwNOXDNNES36kzCMRERERERERaVIbDmeTnlsMwK3j+9AlJoQTkzoyICESq9U36NMpIpjnLx/OTe/9xszl+xjWLZpzj0vwWaegpJTn5+0A4G/TBtFVs6v5lYJHIiIiIiIiItIksgvtzPh4HfO3pQMwbVhn/nr2wBq3mzw4gbsm9uVfC3Zx/+cb6d3JNzi0dGcmBSUOunUI5YoTuzfK2Nszla2JiIiIiIiISJP4ZkOyJ3AEMGVwQjVr+7r7jP6cPiCO4lInd8xeR77d+9xPW9IAM8ikcjX/U/BIRERERERERJrE8t1HPPejQgI4fUB8rbe1WS28dPkIenQM41BWEe/ttOJwGjicBgtcAanJg2ofjJLaU/BIRERERERERBqdYRj84goevXXdKOb/6XSiQwPrtI/osEDeuHYkIYFWtmVbeWn+LlbuPcKR/BKiQgI4sVfHxhh6u6fgkYiIiIiIiIg0uh1peRzJLyE00MZp/eOIiwyu134GdY7iifOHAPDakr3cN2cDAOcc34VAm8IcjUE/VRERERERERFpdCt2ZwIwKqkDQQENC0ecd3xnxnd2AnA4q5DQQBt3T+rX4DFK5RQ8EhEREREREZFG978NKQCc0jfWL/s7v4eT0UkdALhlfG8SokL8sl+pKKC5ByAiIiIiIiIibdu6g1ms3n+MQJuFi0Z09cs+bVZ469oTWHs4l3F+CkhJ5ZR5JCIiIiIiItKGOZ0G2YX2mldsRG//vBeAc4/vQrwfM4RCg2yM7x+H1Wrx2z6lIgWPRERERERERNqwv3+zhRMem8ec3w42y+snZxXy3UazZO3GU3s1yxikYRQ8EhEREREREWlj0nOKmPHJOuZuSuGzNYdwOA3++vlGFm5Pb/KxvLdiPw6nwUm9OzKkS3STv740nIJHIiIiIiIiIm1IfnEpv/vvr3y+5jC3f7iW3KJSABxOg9tnrWHDoSyf9Z+ft4OLX1tOTpH/S9sKSkqZveoAAL87RVlHrZWCRyIiIiIiIiJtRKnDyZ2z17LpcA5gBowALh/VnXH9YikocXDt26tYtisTgOxCO68t2sXq/cdYtD3D7+P5bPUhsgvt9OwUxqRBCX7fvzQNBY9EREREREREWqGtKTmk5xZ5HhuGwaP/28KCbekEB1i5ekwPz3PThnXmtWtGMqJHDNmFdq57ZxUzl+3lpy1p2B1mgGndgSy/js/pNHhn2T4App+chE1NrVutgOYegIiIiIiIiIjUzZ6MPM7598/ERQSz/K8TsVotvLV0L+//sh+LBV66YjgTBsaz8XA2TsPgpN6dCAqwMvumk3jg8418vvYwj/xvC5Eh3rDA+nLlbPWxLzOf7zalMCgxilKnwd7MfCJDArh0VPcG71uaj4JHIiIiIiIiIq3Mst1HcDgNUnOK+G5TCkt2ZPDJb4cA+NvUQZw1tDMAX91+ChaLN+MnJNDGc5cdz6DOUTz5/VZPPySATYezsTucBNrqV6Q0b0saN7//G4YBVgtEhgQCcNXoHoQHK/zQmqlsTURERERERKSV2Z6a47l/x4drPYGjW8f34cZTvY2pywaOyi676bTevHPDiXQIC2RMr45EhQRQXOpke2purV5/T0Ye76/YR0mp07NsyY4MDAOiQwNxGmY/pYGJkdw1qV9936a0EAr9iYiIiIiIiLQy7obYbjFhgbx9/ShG9uxY632cPiCelQ+cQaDNwnXvrGLpzkzWHcxiaNfoGrd98MtNLN99hIzcYmZMGQDAnsw8AB6YOpB1B7PYeDib164eqayjNkCZRyIiIiIiIiKtSKnDydYUM3g0MDGSxKgQZt90Up0CR25BAVYsFgsjenQAYOXeozVuY3c4Wb3/GABvLNnD4axCAHan5wPQLyGSJy8axjd3jqN7x7A6j0laHgWPRERERERERFqRXRl5FJc6iQgO4Lu7xrHi/okM6hzVoH2O6xcLwM87M3A4jWrX3ZKcQ7GrXK241Mkzc7eRV1xKao4581uf2IgGjUVaHuWOiYiIiIiIiLRghmHw675j7DuST0ZuMWtcWT+Du0RhtVbsaVQfI7rHEBkSwLECOxsPZzO8e0yV67qzjnrHhrP3SD5frUtmZE8zcyk2IojosEC/jElaDgWPRERERERERFqwL9YeZsYn6yssH+UK2PhDgM3KKX1imbs5lSU7MqoPHh0wg0cXndCV/UcKmLP6EE98uxWA3nHKOmqLFDwSERERERERacF+c2X69I2PYET3GBKiQujaIZTzju/i19cZPyCOuZtT+XFLKndO7FvpTG0Aa13jOaFnBy4b1Z1vN6ZQUOIAoI+CR22SgkciIiIiIiLS7v17/k6+35TKu9NPJCEqpLmH42NnWi4Ad0zoywUjujba60waFE9IoJVNh3P4en0y5w+v+FpH80tIzjZ7Gx3fLYbw4ABuO70Pz/64A4A+ceGNNj5pPmqYLSIiIiIiIu2a02nw9rK9bEnJ4YNf9jf3cHwYhsGOtDwA+iU0blZPfGQId0zoC8Dj327laH5JhXX2Zppj6RoTSniwmY/y+3G96RoTCsCQLtGNOkZpHgoeiYiIiIiISLu2JzOPrAI7AJ+uPlTjbGNNKSOvmOxCO1ZL05SE3XRab3rHhpORW8yt76+muNTh8/yejHwAesV6M4xCAm18dPNJvHLVCZzUu2Ojj1GanoJHIiIiIiIi0q79tu+Y535KdhHLdmVWWGfJjgw+XX2oKYcFwC5X1lGPjmGEBNoa/fWCA2y8ce1IIoMDWLXvKA98vgnD8AbT9maawaOk2DCf7bp3DGPasM5V9kmS1k3BIxERERERkWa04VAWyVmFzT2Mds099XyQzfyKPHdzqs/zaTlFXPfOKu6ds97Tf6ip7HC9Xt/4yCZ7zX4Jkbx89QlYLfDZmkO8vniP5zl38KhXrBpjtycKHomIiIiIiDST5KxCLnx1Oee9vIxsV9mUND138GjKkAQA9mTk+Tz/1lJv8GT9oeymGxiwM71p+h2VN75/HI+cNwSAp+duY+6mFMAbPOodq8bY7YmCRyIiIiIiIs1kT0Y+DqdBZl4xz/64vbmH0y6l5RSxxxUQufiEbgDsyyzwPH8kr5hZKw94Hm863DTBo+JSB8/+sJ05rlK5AQlNl3nkdt3YJK4f2xOAP368jg2Hsth3pGLPI2n7FDwSERERERFpJum5RZ77H6zcz0ZXVssrC3fx50/Xt6jGzW3V52sOA3BCjxhG9IgBIDWniIKSUgCe/H4bBSXeptGbkxs/eJSZV8yFryzn5YW7KCl1clr/OM4+LrHRX7cy/3fOYE7rH0eR3cl5Ly+jyO4kwGqhW4fQZhmPNA8Fj0RERERERJpJRm6x575hwINfbSI1u4h//rCdT347xLqDx6rZWhrKMAw+/tXMKrrixB7EhAURExYImNlHK3Yf4dPVh7BY4JmLhwGwOTmn0YN6ryzcxZaUHDqEBfLa1Sfw3+knEhzQ+M2yKxNgs/LyVSPoF+8tm0uICiHApnBCe6KjLSIiIiIi0kzSXcGjC0d0JSI4gPUHs7j9wzWe593Tokvj+GLtYfYdKSA8yMa0YZ0BSOpklmPtTM/lb19uBOCq0T24eGQ3QgNtFJQ4PH1/GkN2oZ1Pfj0IwItXjODs45p/BrOokEBm/X4MkwebPaHG9unUrOORphfQ3AMQERERERFpr9zBoyFdohjaNZrHvtniad4MsCs9r6pNpQGK7A7+8d1W3luxH4BLR3UnPNj8etw7Npx1B7N4+vttJGcXERsRzJ/PGojNamFwlyhW7z/GpsPZ9I33bwNru8PJb/uO8cHK/eSXOOifEMFp/WL9+hoNER8VwpvXjWJPRh7dOoQ193CkiSl4JCIiIiIi0kwyXD2P4iKDmXZcZ+b8dpBtqd6p4BU88r+dabncOXut5+d807he3HfmQM/zSa5G0MnZ5rH5v3MGER1qlrIN7x7D6v3HWLozkwtGdPXLePZk5PHCTztZvD2dnKJSz/I/nN6n2TOOKtM7rmlnfZOWQWVrIiIiIiIizcSdeRQfafaQefyCoQTZrARYzaDBziqCRw6ngWGomXZd7cvM57yXl7EtNZfYiCBmTj+Rv00bTFCA96txUplZxMb1i+W847t4HrvLtn7amobd4fTZd6nDibMevZD+/s0W/rc+mZyiUjqGB3HxCd1454ZRXDiiW533JdJYlHkkIiIiIiLSTDJyXMGjqGAARiV1ZOlfJmB3ODn16YUcPFZAYYmD0CBvs+SsghIuem05YUE2vrztFDUuroOF29MptDsYmBjJezeOJj4ypMI6AxIiAQgKsPLY+UN9sn9OTOpIp/AgjuSX8MueI4zrFweYjc8vf2MFNquF928cQ2J0xf1WJjOvmKU7MwGYOf1ExvWLw2ZtedlGIq3ur8wrr7xCUlISISEhjBkzhlWrVlW57ptvvsm4cePo0KEDHTp04Iwzzqh2fRERERERkYbKKbKTXWivcb3CEge5xWaZUlxksGd5QlQI3TqE0TE8CMOA3Rm+2UcPf72ZPRn5bDqcw8q9R/07+Dbu8LFCAE7tG1tp4AhgQGIkz1w8jJnTT/TJQgKwWS1MGWJmH83dlAqA02kw45N17MnMZ2d6Hte+vZL84tIK+y0rv7iU695ZxbinF+JwGhzfLZrTB8QrcCQtVqsKHn388cfMmDGDhx9+mDVr1nD88cdz5plnkp6eXun6ixYt4sorr2ThwoWsWLGC7t27M2XKFA4fPtzEIxcRERERkfbA7nBy9otLmfTcYgpLHNWum+EqWQsJtBIZXLEoxN2Qee3BLM+y7zam8NW6ZM/j/61PLr+ZVOOQK3jUtUNotetddmJ3Tu5TebPqs4aas7L9sDkNh9PgP0v3sHRnJiGBVmIjgtiZnsfC7ZV/R3VbvvsIS3ZkUGg3f0fOH+6f/kkijaVVBY+ef/55brrpJqZPn87gwYN5/fXXCQsL45133ql0/VmzZnHbbbcxfPhwBg4cyFtvvYXT6WT+/PlNPHIREREREWkPVuw+wuGsQjLzitl/tPrp3NNdzbLjI0MqbYx8YlIHAB79ejNfr08mI7eYB7/cBJiZMwDfb0qlpNRZYdvWwDAM3l22l1VNmD11OMsVPIqpPnhUnbG9OxEZEkBmXjFv/7yHZ3/YDsAj5w7hFNdxSckqqn4cxwo892Mjgji3TF8lkZao1fQ8KikpYfXq1dx///2eZVarlTPOOIMVK1bUah8FBQXY7XY6duxY5TrFxcUUFxd7Hufk5ABgt9ux22tOPW0J3ONsLeOV2tFxbdt0fNs2Hd+2T8e4bdJxbbsaemxX7j3KlpRcbhjbo0LQ55v13iqHlGMF9OlUdZAi+ZgZXIqLCKp0LLeOS2JfZj7fbkzlb19sZHi3aI7mlzAwIYLXrjqeic8vJSOvhJ93pDGuBU3pXlur9x/j0f9toWfHMH6651S/7ruqY3zIFbRJiAys9/G3AJMGxPHl+hT+8d02AKYNTeSi4YnsTDO/P6ZkFVS7/4OuwOK1Y7pz96S+RIdY9bemjvQ32j9q+/OzGK2kRX9ycjJdu3Zl+fLljB071rP8z3/+M4sXL2blypU17uO2227jhx9+YPPmzYSEVF7f+sgjj/Doo49WWP7hhx8SFhZW/zcgIiIiIiKtnsOAh36zkVdq4eaBDoZ08H6dcjjhwdU2CkrNgNLVfRyMjq/669aSFAuf7bNxfEcnvxtQefaQ04BnN9g4XGDu02Yx+NNxDrqGw3s7razOtDKtu4Mp3VrF1zofC5MtfLnfhhWD505y0Njtfood8OdVZv7EkyeWEtaAVIoNRy28vd1sYt4p2OC+YQ5CA7zv6YROTq7vX3VG2Lvbraw7auWiJAfjO7e+YydtR0FBAVdddRXZ2dlERUVVuV6ryTxqqKeeeoqPPvqIRYsWVRk4Arj//vuZMWOG53FOTo6nV1J1P8iWxG63M2/ePCZPnkxgYGBzD0f8RMe1bdPxbdt0fNs+HeO2Sce17WrIsf1lz1HyfvkNgLyonkydOtjz3BtL9lJQutPzuHPvgUw9rVeV+9o2byfs28uwfj2ZOnVQletF98/kd++tAeDuSf24aXxvAA4t3cvqH3dCdFemTh1Wp/fREiz4dCPsT8GJhVHjJpIYVbsZymqjsmO8Kz0PVi0nIjiAS86b0qD9T7Q7+PzZJeQVl/KfG8YwrFs0AMbGVL7cvwFbZCemTj2xyu3fPvALkMPkk0dyxqD4Bo2lvdLfaP9wV1vVpNUEj2JjY7HZbKSlpfksT0tLIzExsdptn332WZ566il++uknhg2r/o9qcHAwwcHBFZYHBga2ul/I1jhmqZmOa9um49u26fi2fTrGbZOOa9tVn2M7b1uG5/6i7ZkEXBjAviMFvLV0D7NWHgAgIjiAvOJSMvPt1e4/M98sF0mMCat2vQmDErnt9D5kF9q5bUI/Amxm69ohXWMA2JGe12p+Rw8dKyA8KIAO4UFsScn1LE/PK6V7J/++B8OArCInnUMDsFgspOaZP+9uHUIb/PMKDAzkq9tPpcTh9DQ2B+ja0ZydLSO3uNrXSM42eyL1iI1oNceupdLf6Iap7c+u1TTMDgoKYuTIkT7Nrt3Nr8uWsZX3zDPP8NhjjzF37lxGjRrVFEMVEREREZE2yOk0PNOzgxkAuPqtlUx8bpEncHTb6X24d0p/wNsQuyoZeWav1biIihevy7JYLPz5rIE8ceFxnsARwKDOZmXEnsx8iuzVz+zWEhw4UsDk55dw5Zu/UFBSyu6MPM9zya5G1v70vwNWTn5mMd+7jtnhYw1vll1Wj05hPoEjgIRIM3sqNaeIqjrEFNkdZOaVANAtRq1RpHVoNZlHADNmzOD6669n1KhRjB49mhdffJH8/HymT58OwHXXXUfXrl158sknAXj66ad56KGH+PDDD0lKSiI11fyjERERQURERJWvIyIiIiIiUt6ujDzSc4sJC7IxokcMy3YdYfnuIwBMHBjP70/txcl9Y/l+YwoAaTnF1e2OdNfzcVHVB4+qEh8ZTExYIFkFdnal5zG0a3S99tNUPvr1AIV2B9tSc5m/NR1nmdhKSrZv8MgwDHKLS4kKqV9Gyc60PBYmm02UfticyqerD7FgWzoAXTv4J3hUmXjXsSyyO8kpKiU6tOL4D7mCWBHBAUSFtqqv5NKOtarf1Msvv5yMjAweeughUlNTGT58OHPnziUhIQGAAwcOYLV6I/GvvfYaJSUlXHLJJT77efjhh3nkkUeacugiIiIiItLKuTNXkjqFc+fEfqRkFzG2dyemn9LLJwPFHUCoKfMoPdcMHsVH1i94ZLFYGJgYyS97jvL8vB3MmNzfE0AqdTj505z1bEvJ5ZNbxhId1rxlPXaHkzmrD3kev79iv8/zyeWmtn9q7jbeWLyHWb8fwyl9a55JrsjuoLDEQYfwIAzD4PHvt+HEDB7N25JGQYk3M8tfmUeVCQm0ER0aSHahnfScogrBo4NHC5iz+qBnHOVn6xNpqVpV8Ajgjjvu4I477qj0uUWLFvk83rdvX+MPSERERERE2oVkV3ZMl5hQTurdiQV/Or3S9eJdpUtpOcUYhlFpgMDhNDia78o8qmfwCGBgYhS/7DnKgm3p/LbvKKv+dgYhgTYe+2YLX61LBszMm8tO7F7v1/CHhdvSycj1ZmKt2ncUgMSoEFJzijhcpmzt4NEC3li8B4B3ft5bq+DRHz5Yzcq9R/nmzlPZlZ7H8t1HsVkMnFh8AkdjenXk7KGd/fW2KpUQFUx2oZ20nGL6JUR6lmfmFXPuyz+TVWD2XmrMDCgRf2s1PY9ERERERESak7svT5eY6mcFcweDSkqd5BSWVrrOkbxinAZYLdApvP7BoymDEzz3c4pKWbYrk/8u38d/y2T2/LglrbJNm9RHv5rZNj07+fb4ucU1c5z7Z1vqcPLMD9s9z+87kl/jvovsDpbszKSgxMFHvx7k8W+3AjChi0HfuHDPen+bOoiPbxlLj06N22coIcodPPTNpvr7/7Z4AkcAHcODGnUcIv6k4JGIiIiIiEgtpLhKqzpHV58xEhJoI8ZVJpZWRemau2QtNiIYm7X+pUsn941l06Nnct3YngA8P28Hj/5vMwAXn9ANgJ93ZVBY0nwNtVOyC1m03ew39Pfzh3qWj07qyEm9O7nWKWL57kym/etn/rc+2bPO7ox8MvOq7x21JSUHh6uB0ptL93DgaAHxkcFM7upkRPcYz3qn9Y/z11uqlifzrMyxX7gtna/XJ2O1wOWjuhMaaOPsodXPGi7Skih4JCIiIiIiUguHa5l5BN4+RulVNM1290NqSMmaW0RwAGe5AhGbk3NwGnDpyG48e+kwusaEUmR38vOuzAa/Tn3N+e0QTsMsGTutXyyxrtnlLhnVjS6u/kNH80u46s2VbE/LJSYskH9eMowBrpKv31wlbmA20l655wi//++vnP3SUvZl5rPxUHaZ583b+6b0I8QGw13Bo4SoYPonNM2kSYnR5vtLyzaPcX5xKQ9+uQmAG0/txdOXDGPTo2cyaVBClfsQaWlaXc8jERERERGR5pDiCgZ0qUXD5YSoEHak5ZGaU3nmUUYDm2WXNzqpIx3CAjlWYGdMr448ceFxWCwWJg6M5/1f9rNi9xEmD27cYIXTafDxbwcpdRpcNboHNqvFXOYqWbtidHcsFguPXzCU3/Yd5fzhXQiyWYkMDiC3uBSrBa45qSczJvcnJiyIDYey2Z6Wy6q9x5g8OJEfN6fy+pI9rD+Y5XnNGZ+so2cnszTNagGnASN6xHDesM7MTV7H1KEJrNh7jCmDE5qsObW7bM39+/Lsj9s5nFVItw6h3DO5P0CDss1EmoOCRyIiIiIiIjVwOg1Ss91lazVnHrln9DpwtKDS590ZSe4Sp4YKsFl59PyhLN6ewYPTBhEUYBaZDOkSBcDO9Fy/vE5VjuQVc88n61myIwOAHzalcu+ZA8gutHM4q5CokABPo+qzhiZ6MqUA7prUj7UHj3HnxH4M6hzlWT6md0fe/2U/S3Zm4PzGYObyfQAEBVi5cHhXvtuYwpoDWaw5kAXAQ+cMZkd6Hrec1hurKzgTHhzAv68c0ajvvTx3WWNKdhFrDxzzjPsfFx5HWJC+gkvrpN9cERERERGRGmTmF1PicGK1eDNLqtMnziyR2p2RV+nz7p5H/ihbczvv+C6cd3wXn2Xu2b52pDU8eLQjLZeO4UGesjO3lXuOcNdHa0nLKSYk0Axa/bwr06dU7qITuhESaKt0vzed1rvS5af1jyPQZmFXeh77Ms3G2beM783vT+1NXGQwJ/XpyD0fr/esP/W4ztzgOjZ2u73SfTYFd3AxJbuQZ+ZuxzDgohFdm6znkkhjUPBIRERERESkBu5m2fGRIQTaam4d2yfeLKXanV558MhTthblv+BRZfq5+vyk5RSTXWgnOjSwXvs5cKSAqS8tpWN4ECvun+QpSXt10S6en7cDpwF94sJ59eqRWC3w6qLdfLshhRKHE4DLT+xe59eMCgnk1L6xLNyeQanToH9CBH89a6Cn/OzCEd3ILSrloa820ycunPhaBPWagrusMTOvhMKSLABuHl95gEyktVDwSEREREREpAbuqeQ716JZNngzj/Zm5uNwGhV63KTkuINRjRs8igoJJDEqhNScInam5TIqqWO99vPb/qOUOg3Sc4uZtyWVqJBAXl64i+W7jwDmzG6PXTDEU5b1wuXDuXtSP/41fyfdOoT6lKPVxVlDE1m43SyFu2Rktwp9i64bm8SYXp3oEFa/oFhj6BAWSEiglSK7k/wSBxYLJLn6Mom0VgoeiYiIiIiI1MA701rNzbIBunUII8hmpbjUSXJWId07hnmeyy6ws+mwOUNYfYMqddEvIYLUnCJ2pOXVO3jkLhsDuPWDNZ77IYFWHjt/KJeOqphZlBQbzvOXD6/X67lNHpzIQ19txgAuGN610nUGJEY26DX8zWKx0CU6lD2un1mX6NAqS/ZEWgsFj0RERERERGqwwpVhM7iWwR6b1UJSbBg70vLYlZHnEzxatCMdh6sMq2cTZKT0T4hk6c7MGvseFdnNLJnggIqBjl3lejcFBVi5dGQ3fndqL0+WVWPoGB7EJ7eMxYAWU5ZWG51jQjzBo16xyjqS1k/BIxERERERkWoUljg8zZ8nDYqv9XZ94iLYkZbHnox8JgzwLv9xSxoAZwxK8Os4q9Lf1feouhnXiuwOprywhLAgG9/dNc4zW5nb7nQzEDJtWGdiQgO5dXwfn4BYYzq+e0yTvI4/uWdcAwWPpG1Q8EhERERERKQay3dnUlzqpGtMKAMSal8i5c7I2ZqS41lWXOpgsauHzxmDmyZ41DfeHPPejPwq19mWmsuBowWAWaJXNjBU6nCy15VF89ezBjZZ0Kg16xLtzZJKUvBI2oCapwkQERERERFp4/Zl5nPq0wt4ZeGuCs99vykVgIkD4ys0bK7Ocd2iAfh09SHu/3wjBSWlfLshhbziUhKjQhjeLcYvY69Jz05msCclp4jiUkel62xJ9ga4ymcoHTxWSInDSUigla617PnU3nUu83PqreCRtAEKHomIiIiISLv3yW8HOXSskBd/2sFBVwYOwBuLd/Pp6kMAnD00sU77nDwogZtPM6don73qAOf862dPcOrasT0rlIY1lk7hQYQF2TAMOHi0sNJ1ymZH7Ujz7W+0K9183Ds2osnG3NqVbayuzCNpCxQ8EhERERGRds89HbzdYfDCvB0YhsGLP+3gye+3AXDnxL6M7dOpTvu0Wi08MHUQs34/hsQos4Hy7ox8ggKsXHFixdnJGovFYqGHq9TswFHf0rXDWYXMXnWAja7Z3wB2lgse/bbvKAB94xuvMXZb0zXGLFsLsFro1kHZWtL6qeeRiIiIiIi0aynZhWxNycFiAcOAz9ceJrvQzvxt6QDcd+YAbp/Qt977P6VvLHP/OI6/fbGJbzemcO1JPekUEeyv4ddKz05hbEvNZf8Rb1aV02nw+//+5pN1BL5la7/sOcJbP+8Fmq5HU1vQJy6Ca0/qSc9OYQTalLMhrZ+CRyIiIiIi0q4tcmUdjegew8ieHXhz6V5P4Oj/zhnMjaf2avBrxIQF8fJVI/i/nMHERzZt4AigZyezdOpAmZK8L9cdrhA4AjPzyOk0yMwv5s7Za3E4DS46oSvnDuvcZONt7SwWC49dMLS5hyHiNwoeiYiIiIhIu7bAFSiaMCCe2yb0JTm7iHmb03j4vMFcPaan317HYrGQWGYWrqbkKVtzZR4V2R089+OOCusF2awU2h0cOFrAXz/fQEZuMQMSInn8gqF1ahYuIm2LgkciIiIiItIm/LrvKMEBVobVYRaz4lIHy3ZlAjBhYDw2q4VXrjqBgpJSwoLaztcl94xr+12ZR++v2M/hrEI6R4fw3GXHc9fstdw6vg+frj7EttRcbnl/NdvTcgkPsvHqNSe0qZ+FiNSd/gKIiIiIiEirl5xVyJX/+YVAm5Vf7p9EdFhgrbZbtfcoBSUO4iODGdIlyrO8rQVLenb0lq0dyy/hZdesb/dM7s/JfWL57cHJAESHBnLfpxvYnmb2PXr6kmH0iVOjbJH2rm39RRQRERERkXbph82plDoNSp0Ovt+UwhWjewDw5HdbmbcljXduOJGk2HDunbOen7ak0S3ESnqH/WxKNoMkEwbEt+myrC4xIQRYLZSUOrl3znqyC+0MSIjk4hO6+ax36aju5BSV8vTcbdx4ai/OGdalmUYsIi2JgkciIiIiItLq/bg5zXP/i7WHPcGjN5bsAeCi15az8N7T+XzNIZwGZBVa2fTdds82EwbGNe2Am1iAzcqUIQl8tzHV0wz8L2cPwGatGDC78dReXHNSD4IDbE09TBFpoTRnoIiIiIiItGrH8ktYte+o5/HKvUc5nFVIbpHds+xofgn3zVmP04CEyGDO6+Hg1L6dCAm00jUmlHH92nbwCOCRc4cQFWLmD4zp1ZEJA+KrXFeBIxEpS5lHIiIiIiLS6pSUOnlvxT5CAm0E2aw4nAaDOkcRFRLAyr1H+WrdYU4rFxD6cYuZnTSyZwyTIvOZOnUkWG3YLBaslWTgtDXxUSG8dMUI/rNkD49dMKRNl+mJiH8peCQiIiIiIq3KjrRc/vjROrak5ADQNSYUgHOGdaZTeBAr9x7ly7WHPU2ie3QM4+CxAgzD3H549xjIOgxAoK19FWNMGBjPhIFVZxyJiFSmff2lFBERERGRVsvpNHj7572c8++fPYEjgMNZhVgscMGIrpx9XGeCbFZ2pOUxd3MqACN7duDEpI6e9Yd3j27ysYuItGYKHomIiIiISIu1eEcGU15YzBuLd3PtOyt57JstlJQ6mTAgjg9uHONZb2zvTnSNCSU6NJBJg8zMmm82JANm5tHZQxMBCLJZGdw5qunfiIhIK6ayNRERERERabE+W32IHWl5PPn9NgBCA238bdogrh7TA4vFwqSB8czfls5VY3p4trlgRFe+35TqKVNLig1jXL843luxn5N6dyI4QNfQRUTqQsEjERERERFpsfYfLfDcP6FHDM9eejy94yI8y166cgTbU3MY2dNblnb6gDiiQwPJLjRnW+vRMZzYiGAW3ns6AHa7dxY2ERGpmYJHIiIiIiLSYh10BY++vP0Uju8WXWGGsIjgAJ/AEZjTzE8b1pkPVx4AoGensKYZrIhIG6V8TRERERERaZFyiuwczS8BoE9ceJ2mlr9oRFcAOoQF0ik8qFHGJyLSXijzSEREREREWqQDR8yso07hQUSGBNZp21FJHXnu0uPpHB1Sp6CTiIhUpOCRiIiIiIi0SPtdwaMe9Sw7u3hkN38OR0Sk3VLZmoiIiIiItEj7j+YD0LOjehaJiDQnBY9ERERERKRFOuDJPApv5pGIiLRvCh6JiIiIiEiL5C5bU+aRiEjzUs8jERERERHxu4zcYjYcyiI4wMaopA6EBNrqtH1+cSlbU3MASIpV8EhEpDkpeCQiIiIiIn532Rsr2Jtp9iyKCA7gzCGJnD+8Cyf36USAreYCiDcW7yarwE6PjmEc1zWmkUcrIiLVUfBIRERERET8KrvA7gkcRYcGkl1o57M1h/hszSE6hgcxOqkjd07qy5Au0RW23ZuZz9++2MjKvUcBeGDqQIIC1G1DRKQ5KXgkIiIiIiJ+te+IGTiKjwzml/snsebAMb5al8y3G1M4ml/C3M2pFJU6mDl9tM92hmFw75z1rN5/DIBpx3XmzCGJTT5+ERHxpeCRiIiIiIj4lTt4lNQpHKvVwqikjoxK6shD5w7my7WHue/TDexMy6uw3dxNqazef4zQQBuf/mEsgztHYbFYmnr4IiJSjvI/RURERETEr/ZlmrOklW90HWizMnFgPADJ2YUUljg8z5WUOnlq7jYAbj6tN0O6RCtwJCLSQih4JCIiIiIifuXOPOrZKbzCcx3Dg4gODcQw8PRFAvjgl/3sP1JAXGQwN5/Wu8nGKiIiNVPwSERERERE/ModPOoVWzF4ZLFY6BNnLt+TaZauZRfY+deCnQD8aXJ/woPVXUNEpCVR8EhERERERPxqX6Y78yis0ud7x0UAsCfDXO+VRbvIKrDTPyGCS0d1b5pBiohIrSl4JCIiIiIifpNdYOdYgR0wG2ZXprcr82hrSg5fr09m5rJ9ANw/dRA2q/ociYi0NMoHFRERERERv9mZngtAXGRwleVnfVyZR99vSuX7TakAnNo3ltP7xzXNIEVEpE4UPBIREREREb95Z9leAE7q3anKddw9j8BsoH3pqG7cNr6vZlcTEWmhFDwSEREREZF6cTgNMvOKSckuIjW7iH1H8vluYyoWC9wxoW+V2yV1CmdYt2ichsFrV4+ke8fKeyOJiEjLoOCRiIiIiIjU2Ys/7eDlBbsodRoVnpt2XGcGJEZWuW2AzcpXt58CoGwjEZFWQMEjERERERGps09XH6LUaWCzWoiPDCYxOoTEqBC6dwzjpnG9a9xeQSMRkdaj1c229sorr5CUlERISAhjxoxh1apV1a4/Z84cBg4cSEhICMcddxzfffddE41UpJHlZ8K+ZWBUvNonIiIi0picToO0nCIAFt93Oivun8QXt53Ca9eM5IGpg4iLDG7mEYqIiD+1quDRxx9/zIwZM3j44YdZs2YNxx9/PGeeeSbp6emVrr98+XKuvPJKbrzxRtauXcsFF1zABRdcwKZNm5p45CKN4ItbYOZUOPBLc49ERERE2pnMvGLsDgOrBRKjQpp7OCIi0shaVfDo+eef56abbmL69OkMHjyY119/nbCwMN55551K13/ppZc466yzuO+++xg0aBCPPfYYJ5xwAi+//HITj1zEz0pLYN/P5v3MHc07FhEREWl3DmcVAmbgKMDWqr5SiIhIPbSankclJSWsXr2a+++/37PMarVyxhlnsGLFikq3WbFiBTNmzPBZduaZZ/Lll19W+TrFxcUUFxd7Hufk5ABgt9ux2+0NeAdNxz3O1jJeqZ2yx9WSvoGAUjNV3JGTilPHutXT/9u2Tce37dMxbpt0XKt28EgeAInRIa3y59Nox9Zhx/rLyxg9T8HoNtq/+5Y60f/ftk/H2D9q+/NrNcGjzMxMHA4HCQkJPssTEhLYtm1bpdukpqZWun5qamqVr/Pkk0/y6KOPVlj+448/EhbWuqYQnTdvHgDrj1jILIIT4wyigpp5UNJg8+bNo3f6XI5zPd6/5Vc25qiXV1vh/n8rbZOOb9unY9w26bhWtDDZAtgg/2ir7inq72PbM3MBww/OpMQWzk+Dn8EeUPWMc9I09P+37dMxbpiCgoJarddqgkdN5f777/fJVsrJyaF79+5MmTKFqKioZhxZ7dntdubNm8fkyZMJDAzkpZd+Zk9mAZdOGsVJvTs29/Cknsoe15CvP/UsT4oNo/vUqc04MvGH8v9vpW3R8W37dIzbJh3Xqq39bhvsP8AJg3oz9cz+zT2cOmuUY2sYBLz9TwCCHPmcGbAS59Tn/bNvqTP9/237dIz9w11tVZNWEzyKjY3FZrORlpbmszwtLY3ExMRKt0lMTKzT+gDBwcEEB1ecHSIwMLDV/UK6x9wlJow9mQWk5dmrfA9Ld2bw+uLd3H56X07uG9vEI5W6CAwIwHrIO8ugteAI1lb2uylVa41/a6T2dHzbPh3jtknHtaLUnBIAunUIa9U/G78e20OrIW0jWAPAWYpt7fvYpjwGoTH+2b/Ui/7/tn06xg1T259dq+luFxQUxMiRI5k/f75nmdPpZP78+YwdO7bSbcaOHeuzPpgpbVWt31Z1iTFnwEh2NTaszOuLd7Ns1xGuemslX6w91FRDk/rIPgh5ZUov8yufbVBERESksaRkm+eVXWJCm3kkLchq1yQ+Qy+BoAjAgMKjzTokERF/aTXBI4AZM2bw5ptv8t///petW7fyhz/8gfz8fKZPnw7Adddd59NQ++6772bu3Lk899xzbNu2jUceeYTffvuNO+64o7neQrNwf6jvSs/jwleXcenry1mwzZuR5XAa/Lr3mOfxqwt3s+lwNs/M3UZ+cWmTj1eqZ3FnHYVEm7d5Ch6JiIhI00rONifuUPDIpTALNn5m3h81HYLCzfslteslIiLS0rWasjWAyy+/nIyMDB566CFSU1MZPnw4c+fO9TTFPnDgAFarNx528skn8+GHH/Lggw/ywAMP0K9fP7788kuGDh3aXG+hWXSJNj/U525OpaTUCcCvM3/jD6f34b4pA9iZnkuJw+lZf1dGHvd9uoGtKTkEWC3MmDKgWcYtlbMc+tW80/9s2PARFGVBaQkEqBu6iIiINL7iUgcZuebsxJ2jQ5p5NC3Ehk+gtBDiBkH3MRDomminJL95xyUi4ietKngEcMcdd1SZObRo0aIKyy699FIuvfTSRh5Vy+a+IuQOHLm9tmg3KVmFnNCzAwBje3fiwNECDmcVsjXFbJr10a8HuXNSPwJtrSpJrU3z9DvqPwU2zgHDAfkZEN21eQcmIiIi7cLudDMgEhpoo2O4Ll5hGLD6XfP+qN+BxeLNPLIreCQibYMiAu1A5xjfK0L3nNGfZy4ZRoDVwpfrknnsmy0AnNAzhmHdon3WTc8tZt4W36bj0nwCHIWQvtl80P0kCI8z76vvkYiIiDQRd/uDk/t0wmKxNPNoWoCDqyB9CwSEwrDLzGWezCOVrYlI26DgUTvgLltz65cQwWWjuvPODScSHmTD7jAAGNG9A8d3j/GsF+TKNvrgl/1NNlapXkzBHiyGE6K7m5lGEa7gUV5G8w5MRERE2o15W82LVmcMTmjmkbQQv7kbZV/snVktyBU8sit4JCJtg4JH7UBokG9Kcf+ECABO6x/HJ7eOJTEqhKiQAE5M6sjx3WI86919Rj+sFli++wi7M/KaetjiKIWMHT6LOubvNO90H2Pehsebt8o8EhERkSaQnlPE+oNZAEwaGN+8g2kJCo7C5i/M+6Ome5cHuhtmq2xNRNoGBY/aCXczw0CbhZ6dwj3Lh3SJZtF9p7P0LxOJDgvkuG7RBNmsWC1w8QndmOg6KZj1y4FmGXe79r+74ZUTYeE/PIs65pULHkW4Tto045qIiIg0IofToKTUyQ+bUwEY3j2G+Cg1y2b9R+AohsTjoOtI7/IgNcyuFcOA5S/D7oXNPRIRqUGra5gt9bB7AZfYlpNCH2Jju1Rofh0SaCMk0AZARHAAb14/Cnupk8ToEK4+qSc/bU3n09UHue/MAYQG2fw2rNTsIrakZDNxoFKeK9i3DNZ9YN5f/DTEDYT+0+iYv8tc1n20eevpeaSyNREREWkcaw4c47YP1hAREoBhmO0OzhnWuZlH1QhK8uHXt6HvGZAwuOb1DcNbsjZyutko283TMFtla9XauwR+/Jt5/w/LIWFI845HRKqkzKP24Pu/MD3jn/S3HqJfQmSNq4/vH+epYR/fL47uHUPJKSrlfxuS/Tqsk56cz+9m/saqvUf9ut824Yf7zdso1wxqi5+GjO0EOgsxAsMhYai5PMIVeMtTU3MRERHxj13peRTZHQB8syGZK//zC6k5RexKz2N3Rj6hgTYuHdW9mUfpZw47fHIdzPs/+O6+2m2zfxkc2WmWqB1XbnZnla3Vzr6l3vuf3gilJc03FhGploJH7UFYJwB6hRVx3vFd6rSp1WrhqtE9Af82zi7bQ2lfpj5UfRTlQMp68/61X4LFChnbsG4x6+mNrieAzZU0GJlo3uYqeCQiIiINt+5gFmc8v5gLXlnGC/N2cMeHaykudXJiUgdPYs1FJ3QlOjSweQfqT4YBX98Fu34yHyevAaej5u3WfWjeHncJhET5PqeG2ZUzDFjwBKz/2Hy8f7n3uYytsP3b5hmXiNRIwaP2wBU8evLMLpw5JLHOm182qhtBNisbDmWz4VCWX4b07YYUz/2IEFVP+sh09TWKSIC4/tDtRABsy54HwOg62rtupCtlPDcFERERkYZasNW8ILUtNZeX5pvnJNNPSeKjm8fy17MGMjAxklvH92nOIfrfoqdg/YdgsYEtyAz4uM/HqlJaDFu/Me8Pu7zi84HunkcKHvlI3wpLnoFv/mhmZR36zVw++ALzdu0HzTUyEamBgkftgSt4RMGRem3eKSKYqceZQacPftnPwaMFHM1vWErpN2VK4OwOZ4P21eZkbjdvY/ubt30n+zxt9DvT+8CTeZRiXskRERERaYBV+7ztBKwW+Pv5Q3j43CHYrBZuGd+HuX88je4dw5pxhH5WWgRLnzPvn/MCdB1l3k9eW/12uxdAcbZ5Ia/H2IrPe3oeKcPex7G95q29wNtsPDweJj1kLt81H7IPNd/4RKRKCh61Bw0MHgFcc5JZuvbJb4cY98xCzn/lZ0pK6xf0OXi0gB1p3rI1h1NBDx+ZO8xbT/BokuepvbETzbI1N3fwyF4AxTlNNEARERFpi0pKnaw7mAXAzOknMm/GeK4bm9SsY2p0GdvBaYeQGDjhOugywlxeU/Bo0+fm7eALwFrJV6pAzbZWqawyMzivfN28TToFOvWBpHGAAetmN8vQRKR6Ch61B+Gx5m1+Zr13MbJnB/rEhXseHzxa6JM9VBe/7vNtkF2q4JGvDFfwKG6Aedt5OCSNw0gcxpYu5dKig8IhONq8n5vaZEMUERGR5pVfXMriHRl+zeDelJxNkd1Jh7BAxvePo09chN/23VJZ0jebdxKPM2dL6zLcfFxd8MgwYI9ravnB51W+jjvzSGVrvo6V6aHqvmDaa7x5O+Ia83bt++BUZYJIS6PgUXvgh8wji8XC7RP6AhAfGQzAW0v3eqZrrYtf9x3zeazMo3LKl61ZrXDDN5TeuIBSW2jF9aPU90hERKQ9Sc8t4uLXlnP9O6t4f4X/JjT51TUD7qikjljKTjvfhlnSygSPwJt5lLoBivMq3ygnGfIzzB5J7vXLU9la5cpmHrn1d7VkGHQeBEdB1n7Y/3PTjktarpJ8yD7c3KMQFDxqH/wQPAK46IRuLLlvAj/88TRCA21sSclh0+G6l0qt3m+emARYzZMSZR6VUVoCR1214O7gUU08fY+UeSQiItLWHTxawGWvr2Bbai4AC7al+23fK/aY54qjkzr6bZ8tnSVto3nHHTzq2Ac69DJ7IS3/V+UbuWfFjRsIgZVc2AM1zK5KVrlgZ+fjIco1G3RQGAy92Ly/5v2mHZe0XJ/fDC8N81ZnSLNR8Kg98FPwCKBHpzA6hAcxtKs5HemBo3X7QMwqKPH0OxrdyzwxcahhttfRPWA4ICjS+0FaE/eMa+lba54ZRERERFqtnWm5XPr6CvYdKSA2wswE/3XfUYrstZhWvgZFdge/uIJHp/aLbfD+WgXD8JatJQw1b61WOOMR8/6yf1We8eAOHnU+vup9B7mCR3YFjzwMo2LmUf+zfB+PuNa83fo1FGY1ybCkBSsthp0/grMUDq1q7tG0ewoetQdlg0d+mpErPioEgLScojptt+aAWbLWOy7cU/6mzKMyPCVr/cy6+9pwZx4texFeGaMAkoiISBu0LTWHy95YQWpOEf3iI/jmzlOJjwymuNTJmv3Hat5BDVbvP0aR3Ul8ZDADEyP9MOKWL9R+BEtRNlgDvL0mAQafD91PgtJC+PJWcJYLztUmeBTo7nlURelbe1SU5Z3gpcfJYAsyG46X1fUEiB9sZn69NQn+dQKkbmrqkUpLkbIeHK5Zvt3VGdJsFDxqD9wNs0uLqr/6UVoCi5+peXYJICHSDB6l5xbXaSg/bTVTq8f06oTNNTOFeh6VUX6mtdpwZx6BmbW0d4l/xyQiIiLNyuk0+MtnGzlWYOf4btF8cstYEqNDOKWveY63bHf9J0Vx73/RdvMcbVy/uNbV7+jY/np/qYwudGXBxA2EgGDvExYLnP+yWXq2dwkse8l3w5R15q27uXZlglS2VoG7WXZ4PFz1MdzxGyQM9l3HYvE2zj6yC47uhl/fatpxSstxcKX3/rF9zTYMMSl41B4EhkGAGeypdsa1Ff+GhU/Af06vcZfxUeYHbHodMo9KHU5+2GT25Tl7aKJ6HlXGM9NaXYJHib6P89L8Nx4RERFpdl+sPcz6g1mEB9l48/pRdAgPAuDkPmZ2+bwtafWaxARg/5F8Rv/jJ95cagZgTuvfikrWivPgzQnw5kSw1y0bHiDKHTxyl6yVFdsPpv7TvL/gcTj4q3k/+7BrkhJL5du5BblmqnMUV8xcaq/cJWsxPSAkCjr0rHy9YZebWUluu+f7rXqiSk4HfH0XfPEHs42EtAw+wSNlHjU3BY/aA4uldn2P9i+v9S4TXMGjtNzaf1Cv3HuUI/kldAgLZGyfTthsruCRQ8EjD0/Z2oDq1ysrPN73sT7wRERE2pR3lplfmm6f2Jd4V/Y3wJTBiYQF2diRlseSnfXLPvr7/7aQmWeWhcRGBHN6//gatmhBds0zz20Lj9br4ll04UHzTmIVQaDhV5sNnA0HfHYjFGXDipfN57qdCMERVe/c3TAbzNmi3PLS4Ytb4dBvdR5vq1c2eFSd8Fi4fBac/U8ziJR1wJud31gO/AJr/gvrP4TXTtX5dGMrzoPPboKt/6t6HcOAg2X6HCnzqNkpeNRe1CZ4VIe0WnfZWlpO7cvWvt1oTiV/5pBEAm1WT+aRw6mG2QA4nd5+RXUpW0sYAmFlrhLqw05ERKRNOZZvBndO6eObFRQdFsiVo80v4m8s3l3n/S7Ylsb8bekE2ix8dfspLPvrBKLDAhs+4Kay9Rvv/XpMDBNV4Cqjcs+0Vp7FAue8YAY7svbDnBu8JVQT7q9+5wHBYHF91SrbNmLp87B+Nvzwt6q3tReaF3WrqxhojdwzrVWVcVRW/ykw5mZIGmc+3vFD440LYNdP3vv2fNj8ZeO+Xnu39DnY+Al8fE3lzxsGLHrSDApbXX+TCo5AUd1n+hb/UfCovahV8Kj2Df0qa5j97YYUJj23iLUHKjZtLFuyNvU4s0dPgKvnkcrWXHIOmycX1gDo2Kv224VEwT2b4aYF5uMjdT95FBERkZaruNS80BYcWPHU/Xen9sJmtbB89xH2ZeZXeL7qfTr4+/+2mPs4pRfHd48hOMDmnwE3hdJi34BCwdG6bV+cS0SJ2eeJhCqCRwAh0XDx22Cxwe4FZvPenqdC7wnV799iKdM023VcHHbYOMe8f2gV5Jc5L89JhlVvwqxL4ekkePds+OT6ur2nlq62mUdl9Zti3u5Z1PDX/+Ye+OBiMyiXl+5b6rh7vnnbdaTr9RY2/PWkamXL0cozDDO4uvhp8/Gkh7wXylW61qwCmnsA0kRqEzwqe1XEUQq2qn893GVruUWlFJY4SMsp4r5P11NQ4uCrdcmM6NHBZ/3yJWsAATZ35pGCR4C3ZK1jb7DV8apfYIjZ7BHMmSwKjkJYR78OT0RERJpHiTt4VElwp2tMKKOTOrJizxEWbU/nhtiqL0D9uu8of/xoHQ9MHcS+I/nsO1JAfGQwd07q12hjbzR7l0BJrvdxHTOPLBlbATAiErGEd6p+5e6j4bx/w6bPzF5I4+6t3ay4QWHmGN3Bo13zocCVTWQ4zSnIh19pBjP+PbLixDYHV5oT2gQE0Sa4G2bXJXjU9QTzNn1rw167tAR+e8e8/2x/sxQxIAR6nGTOrOeeQW/K42bg7sAvZlVGUFjV+5T6y03x3t/8hXlspr1gXkD/5o+w5j3zubOehpNuha1fm/93ju2rfpZDaVTKPGov3DOuVZf+Wlwm86i4+pTAiOAAQgPNE5jk7EL++PE6CkrMZoC7MypmMJUvWQOwqWG2r/qUrJUVFO6dea2us44YBnz/V1jyz/q9toiIiDQad+ZRUEDlp+6nD4gDYOH2jGr388rCXRzOKuThrzfx8oJdADwwdRARwa3wevLWr30f1zV45Jr+3aiu6XVZI66Gaz+Hs5+GiLjabePue+QOCq2fbd4GRZq3278zb9O3muuERMOkh+HWZRAcBU47HNlZu9dq6QyjTOZRUu23c58X5yY3rGSpKKvMWFwNzEuLzIymxU+ZjxOHQY+xEN3dzDCrQz9YqYZhQPYhs0UHmFmD2Ye8z8+5wQwGv3EafH6zGTiyWOG8l83AEUCHJPO2njMrin8oeNReuIMKVaX6OR2QX+aEo+wf2EpYLBZP9tGj/9vCuoNZngswezJ8U6ZLHU7mlitZA8r0PFLwCIAMV+ZRXB2aZZfXsY95e7SOpWvJa2Hla+ZsIg57/V9fRERE/MrpNChxuDOPKj91nzDQbHL9y54jFJZUPrNXem4RS11NtTPzSii0OzgxqQPnD+/SCKNuZE4HbHMFXtzBhbr2PEqvY/CoPoLKlK0VHoPt35uPz3zCvN32rVmqlmueJ5M4DMbNMBt4x7umsE/b3Hjja0oFR81eQgDR3Wq/XWgMRLhmFm5I0+zCMm01pj4L92yB21eZTbkHngMdesEpd5sZZX1cJYl7F9X/9cTrl9fghSHwyonm7/vBVWZwrjx7Pmz61GzhcfHbcMK13uc6uDIqM9tIMLWVaoWXGaReOg8zb90pmeXlpXuj8ACFWTXuMj4qhH1HCliywww6/d+0wfz9my0kZxdSZHcQ4spMWrn3KEfLlaxB2cwjNcwGGp55BGaq5/6fK+97tOZ9yEuF0+6r+FzZJtsFRyAysf5jEBEREb9xB46g6uBRv/gIukSHkJxdxKyV+5l6XGf2ZuazJyOPPZn57MvM92QlhQRaKbI7sVrgkfOGYKlN+VVLc+AXs4QlJAYGnQdLn6175lFaEwaP7AVmA2ZHMcQPgROuM3serf0AvrsXhl5irhfpvchKwhA4+EvbCR5l7TNvIxLNdgt1ETfAPIfN2A7dRtXv9d09sTr2htE3+e57zM2+63YZYWa/ZDTyDG/tQWkx/PyCef/ILvP33VJN/kpACFz2vtkwvawuI8zbQ6sqbiNNRsGj9qLzcPP26B5zmtGQaN/nc5J9Hxdl17jLhCjvH/5zhnVm+ilJvDR/J9mFdvZm5jOocxRQeckaeDOPSh3KPAK8PY8aEjxynwCV/8PqKIVvZ5hR/uMu9aZ+upWtI8/PVPBIRESkhSi2lw0eVd7Q2mKxcPHIbvx7wS4e/3Yrj39bdX+Yv5w1kNScIvrERjCkS3SV67Vo7um9B0yFiATzfl2CR04HFte5j5EwxM+DK8NdtlZSAOs/Mu8ff4WZ3XLey2YPoH1LYec887my51/ucbWZ4JGrZK02M62VFzcA9i6GjG31f3135lFoh+rXg/pn8ktFm7+A/HSI7GJmdq18vfJKGGsgTHwQep3m7XNVVvcx5m3mDvV2bUYKHrUXYR0hugdkH4CUDdBrnO/zuXUPHiW6ytYSo0J4/IKhWCwW+sSFs+ZAFrsz8hjUOarKkjUAm2Zb8yo46i0bbEjwqPd483b/CjPSH2AeI/JSvemhWQcqBo/KnpjkV98vQaTdKs41Z86xquJbRJpOscPMDLdYINBWdZbQH8/oT3CAlX/N34XTMOjRKYzeseH0ig0nKTacg0fNzPArR/fwZIe3SoYB274x7w86x5zWHuo229rRPVhKCym1BEGH3v4fo1twhHm7f5mZRWSxmhfxwDygcQPM4FGx67zbJ/PIdUGwrQSP6tMs283d0sEfZWu1Ch65fieO7a9xEiGpwW/vmrejf2/2Lxp9k9ko/vAa85j8+qb5fMJgOPWPVe8nvBN06mf2ADu4Cgac1ehDl4r0P6E96XK8K3i0rmLwqB6ZR5ef2J0DRwv4w+l9iQkzZ4HoHRfBmgNZnr5Hq/ZVXrIG6nnkw12yFtXVe6JRH3EDzStweWnmH1b3cS7blK7sfbeyJyZZB2Ddh9D3DIiIr/9YRNqSLV+ZDR1DO8Dom+H0vzb3iESknXBnHgUHWKstMbNZLdwxsR+/H9ebAKuFAFsbDXSnrIPsg2ZWT5+JZgkbQM5hWPwMDL4A4mq4EJe6wdwktDuR1kYMpCWdZmZJrfmv+bj3BIgqEyAqfzGvbOZR/CDzNje5ZWZaFOWYzab7TYbA0JrX9zTLrkfmUawreNSgzCNXcDG0Fj/HqK5gCzbLDHMO+R6nTZ+ZWfpjbqn/WNoTd8CvvyvYY7XBgLPNf6ve9K7nzvaqTo8xruDRSgWPmkkb/VSRSrmnNays71HOYd/HtQge9Y2P5I1rRzG8e4xnWe84s7Z7j2vGtfUHzf2c3DfWp2QNIMCm2dY8/FGyBuZVrF6u7KM9i7zLsw5675cPHhVlm0FFt6XPwpd/gOcGQurGho1HpLzCLPj8Ftj6TXOPpPZyU+F/d5vTKhccgUVPeaddFhFpZJ6Z1moZDAoJtLXdwBF4Pz/6nmEGLcJcFyeP7YWFT8D8R2veh2umtZzQemTB1MWwS80ghNvxV/o+Xz6QUjbzKCTKnPULGhY08be0zWbA7t8j4ZNrYfXMiuvkH6k4w7MneNSAzKNj+8FeVPftoW6ZR1arN2Dk7iPqdMLcB+DT38H3f/btFyqVc5R6g3bhlVyQjurqvd+xFhmA7tK11e/C21Pg3anYPriAsbuewbrgUTMrURpVG/5kkQo6uxqNlQ8elRZ7a63dahE8qkyfODNrZme6GTzanmpOqTkoMbLCut7Mo3beMDtzp/eqWUNmWnPrXUnwKPtg5ffBt98ReD/cDQe8MR6+/ZPZUF3EH1a+Dhs+gq9ua9iUu03FMMzAUeExcxac0I6A0bDUeRGROiguNcvWgltzqZk/ufsdDTrPvA3zzWz3zF5bHVez7OzQ7n4cWCVCO8Bg1ziDImDgNN/ny/f/Kd9z0n1RcccP8I9u8MPfGmectZV1EF4fB++cafaxAc/P0qOkAF4/FV472bzv2bYBZWvhcWYjZQyzFUN91CV4BNDJ3fdoj1kaOec6+OUV7/PlqzakIk8fMkvlmXNls/A61SLzqNd4cya2wmNm9tH+ZVj3/0x87iZsK/5du//70iAKHrUnsf3M22P7zOi52/y/Q/oWCIuFkTeYy+oZPDquq9l4cVtqLvnFpWxLzQVgYGJUhXU9PY/ac8PsI7vh1ZNg3SzzsfsYNYQ78yh5jfc4+pStlckyczphRZkPwvIMB/z6FvxrhJkKrmwLccs6AJs+9/1bUhOH3XuFsigbVv2nUYbmV+s+hB1zwRYEF77hnTpZJygi0kTcmUdVzbTWrmTsMLO1rYHe2ZjKfyk9tg+cjgqbehiG50Jqo2ceAYy9A4Ii4aQ/QFCY73PVla2B96Liqv9ASS5s+KR5syuO7fWdnRkqnhtu+9YstctLg0O/mssMo2ENsy0W788mt4mCR+5MmEO/wn/PNYOWtiAzkAW6sFob7j6qYZ3McrXy6pp51KEn3LoMrphtzsh26UxKL/gP+UGx5vM5lbTmEL/Sp1B7EtXFbNTnKPFeLcg+DL+8Zt4//xWzERmYKYZ5dW+c3CUmlK4xoTicBr/uO8puV/nagGozj9px8GjbN+As9T6O9UPmUUx36NTXLLHZ97O5LLuKsrWfHoatX5snYeVTqafPheu/MafGLMkzU8E/ub7h45PW7/BqePE4+HQ67FlY++22fw+5Kd4pWle8bDahbqmyD8FcV2+j0+83mznGDzQfl8/YExFpJGV7HrV721xZR73He2cOLt9vx2mvvL+j25FdkJeGYQsmKyypUYbpo8tweOCQOZNUeSHREBLjvV/+vbgzj+yuDJ789ObNeHF/Znc5AS543TWmcuVpGz7y3j+wwrzNS4fSIsACUd3q99rukr7clPpt726oXtveUR17mbcbPjYDSCExcO2X0PNkc3lbnGDGXgi5af7bn/v7ZlU9VMNizYxuW1DtW3fED4SBU82MviEXYgy5iLzgLuZzOfX83ZBa06dQe2ILNKdJBO+H6up3zSsIPU81G4+5P4g3fQbP9oOVb9T5ZUb2NCP6c347hN1hEBEcQLcOFRvp2azqeeQpFwyKhKGXQI+T/LNfT9+jxeZt+YbZhmFmFC3/l7nsgldh0Lm+++iQZDbc/v0COOspc1lLqrmX5mEvglmXeR+XL4Oszq9vmbcn32kGOAuPwa9v+3d89bHhE3hljBkUA9g1Hz69ET65DopzoOsoOPku87k4V/BImUci0kRKHO7gkcrWvCVr51a/XnX9aPaa50ZGtxNxWoP8NLAGcGfilO135FZZO4PktY07nuq4g0ehMd6So7LBo9w02L3A+3j/cvPWnXUU1QUC6vkzj0jwvkZt5aQwMPlTbLMvg+R15rJaZx6VKaOK6Qm//wmSTmnbmUdzpsOLQyvvj1sf7t+N8NjKn7da4fr/wQ3fNqghfFGQ65jWN7AotabgUXsT7Yr2Zx0wex25S0hG32TeuoNHABhmQ7h1s+v0EqOSzP/A3240/wMPSIysdHYQd8Psdpt5VJTjvSJzy2K45G0zwOcPvU83b919j8oGj+z55lWU7+4zH098EIZd5v0wBLOu3P0hbbVCr9Nc2xb6Z3zSeqVvhoIyJ4q1LXHN3Ok6YbfAib+Hcfeay5f/u3nLIfevgC9vMwOjW74y/97NuhQ2fWoGkwJC4MLXvdP0uk/kM5R5JCJNo9ju7nnUzk/bsw+5AicWGDC1+nWrDR4tBcBIGlf1Ok3J3TS7fMkaVJ6RnrKuUYdTLXfwKDjSzBoB3wycTZ+ame8Rrvdy6FezZN3T76geJWtudck8OvgrfPo7Al4ZwYC0r7HuWQDFrvOV2gaPuo6E6B7mBfbfz/e2lnA3fm6LmUc7vjcrVL691z/7c/+Myn7HKC9xKHQf3aCXKQx0HVP1oWp07fxTqB2KcTUGzD4IW742/1NHdvY28PMJHrl8dXudZkZyZx65DaykZA28mUd2RzttmL1noVmy1rFP7ZrE1UWvcYDF7AuQvs3MngAzwwnM2dQMJ4y41vslvuxVgZgeZtDILSDEvC2t5wwX0naUn4GvMKt22/32jnnb/0zz9+u4S83stoJMmH1F7ffjT9mHzewip937+Lv7zGzMfmeaM/lc8KpvL7I419TJx/b7NgIVEWkkdZ1trc1yZ1N3O7FiGUz56derCh45nbDPFTzqeaqfB1hP7r5HlWUehXeq2BC8WTOPXOeTwZHegEDhUW+PqfWukrVxfzLLvOwFZr8m9/GoT7Nst9r2PNr4Kbx9Bmz6DIuz1NsPx622waOQKLh7PUz/FiLKBD/c99ta8Mhh994/tMo/k5rUJnjkB0WByjxqKu38U6gdck/5mXUQfn3TvD/qd96Ml7LBo26jYfg15hepT6f7zt5VjYGJUcRGeKclLR9McmvXPY/yMrwzZgw42//7D+1g1tgDrPvAtayjN0hlOKH3BDjnBbMJIfj+YS/fwNFdg6/MIykfPKpN5lFJgbcp/Im/N29tAXDey+bsM3uXwI9NPIOMvQg+vtqsx3dPo5yy3mxIarHCFR/CNZ/B0It9twuP9c64dmRn045ZRNolT8Ps9jbbmmHAzy+YM42BN1s76ZSK697wLUz4G0x53Hx8dG/l+9zypTkDVGA4RpcRfh9yvRx/JSSNMy/oVcadfeQuo0pea06B3hzcAYXgaG+ZkeE0y9DTt0LqBnM2rKEXe7Pgf3jA7JsJfgoe1RAgcFdV9D8L+40L+KXPfb7P1zZ4BL4XUt3cmUdtrWytfDBs4ye1227rN/DFrZVn/XiCR1WUrflJkTKPmoyCR+2Nu2xt54/mFIfWQDihTBPkssGjpFPh3JfMunJHCcy+ykwDrYHNamHOrWN5/rLjeeeGUZw/vGsV67lmW2uPwaPv7jWzvzr2gdP8lBpanvtDe8375m2HJG9dffwQuOw93zK5oAhvhlH54JF7ueHwvTIh7U/KBvO260jztjbBo02fmevF9IQ+k7zLe42Di1xB7D1L/DvO6hgGfPNH8wQ8tIMZRAVvMCiyi7dMrTyLxZuJVF1ZhIiInxSXusrW2lvD7MNr4KdH4MPLzBnUDvxiLu8xtuK6CYNh/J+9M2JW9vc5ZYOZeQ1w4u/MJr0tQcJguOGbyoNiYJ6PA5z6RwgMN4NfM6dV3xS8sZQtW7MFegMx+RlmSwSAflPMjKlzX4LTygVu6jPTmps7eJRXTc+jknzv78mZ/4DEYeQFJ/iuU1mVRV24s97y21jwqPzPdcePNW+za76Zwb1+tjmpTvnvCJ6eR42beaSytabTzj6FxBPxd9ceDz4fIsv8UfXJPDrR/AJ18dtmloo9H2ZdUqtGsb1iw7nohG5MHJjgKU8rr133PEp1fQGf9mzdroDUhTt4VJRl3g461/wQP+k2M6MiJMp3fYvF+8e9qswjUPZRe+Z0QNpm8777ZNb9+1Udd6PsUb+reBXPfbKcfaDijC2NZdNn5omOxQaXzqzYqN5d3luVKM3qISJNp8SdedTegkfHymQPfXm7N8BfXX8U93Tfx/Z6S6nc1vzXLL/vMxEmPeLXoTaq0+6FW5aamUkXvwnBUXDwF3j9VNg+t2nHUjZ4BN6+R3npsGGOeX/Y5eZtaIyZDdahl3f7BmUe1aLn0b5lZil6TA/v74LFihFRpp9UZVPG14U7iyYvw7wY1VLsWQwr/1P/MZXPpNq/vPoMt5IC+PR35oVlMEvdfnrEdx1P5lEVs635iSfzqCDT7OkrjaadfQqJp2zNzd0o2y0kGgLDzPvuqSgDguGKWWYZW1EWLPuXX4YS0J5nW3N/+EZU0hzRX7qP8ZbjWKxw/BWQeByc9aR3hozy3F+KO/X1Xe7OPAL1PWrPju41g8gBobXPPErbbDb3tAXBiGsqPh8SDZ1cmTyH1/h1uFXa68pyGnOLGWR1/967uTM0q9LQ6YJFROrAU7bW3mZbKzub5/6fzdvYAdVfdIvpYfZ3LC2qeLHTffFj2BVVZ5e2RAHB0HmYeZFv4DRzkpXOw81SsdmXw/y/N91YygeP3Bcdt3wFOYfMcrb+Z3nXt1jguEu8jxvUMNt1zlyUbQYuCo6afVnfmuztg+Se6a3PRG9bBsDo2Au/cQdCSgubd8KPsgwDPvs9fH8fpG+p3z7cmUd9zzD7VZXkVt+cfc9C83thVDe4xNXXcsXLvn1y85qm51FJQCSGO5OwfE+svAz477kw54aWFexrpRQ8am/KfilKPM4MMJRltcEdv8HdG8wrBm5B4XCSK9X36G6/DMXm6XnUDhtmez58IxrvNQJDvRkVfSZW/IJcmbOegkkP+5YWgfkBrKbZ4p7KPmGwt4FnTcGjTNeV4s7Dq65573qCeZvcRMEjd6q/u7whMNQ8UXIrH2QvT8EjEWlCxXZ3z6N2dtru/lttLVNi776wWRWrzdvz0f2ZBeaXxjTXl+qEIX4bYrPo2Btu/NHMJAdY+hzsnNc0r10heOQ6F1j3oXk75AIIDPHdpmzvwNqci1YlOMq8eAWw9n14dSys/cDMeHFPyrHX1VS99wSfTZ3DrjTvlG+sXq9xRHgvtLeU0rWcZO9Yju2rfJ0f/gbf/6XqAIo7eBTZ2ZtdvrealgLbvjVvB51rHuOxd5iPv7zNvNhoGE3W8wiLxXtBvuy5WW4a/Pcc831s/kJlbX7Qzj6FhOAI7x/O0Tf7ROU9ortWXpPsvlqQdcAvQwlorz2PSku8ARj3h29jGXu7mdUx/i+1W7/rCTBuRuVX5NzBI7uCR+3WRldKeu/TvSWuNc2S5j5xKD8zTlldXMGjyjKPUjbAwn/AEf8ErQHvF5Ky5WllT2hryjxS2ZqINCF3z6N2N9talivzaOo/4fJZ0HeymTFaE3dmbNngUc5hc6p2awDE9vf/WJtaQLCZSX7S7ebj7+5tmrYCntnWXK0P3Bklpa7XPv6KitvED4KrP4Pp3/v22qwri8WbffT9nyEv1ZuFtv4j8/zUnW1WrrTRGHYlXPgf+P1P9X/9stzv251Z09zKTmZSWYAkN83MClr5etUBFHfZWkQC9DrNvL/rp8qDTY5S2P69ed89Y/cZj5hVKsXZMOd6MzPO/XvRyJlHAIbn3CzZeztzKmRs866UtqnRx9HWtbNPIQFg8qMwcjocd1ndtnPXKeckmwGQBrK119nWSvK894MaOXjU/0y487fq+wPUlrvvUal6HrVL2Ydh93zz/vCrvZk6NWUeeU5GqgkeuTOPDq/2ra//+UV4Yxwsfhr+M8E7TXNDGIY3eFQ2w6jsFMm1zjzSFSwRaXze2dba2Wm7u2wtpjsMOgeu+dQMRNSk7GeKmzvrqFM/CGghjbL9YcL95mfSsX3eWekakyd4VK7nEZjfE7qfVHEbgH5n1Jw1Vhuez2oLnHwn3LnGnPAla7+ZjWQ4zItbkeXaM1gscPzl3lmHG6qlNc1OKxM8qqyRetmgSVUVJO5yr4gEs3TNYoX9y+CXV33Xc5TC0meh8KgZvHM3sLcFwqXvmkkKKethxSvm8oBQs4KlsbmP+fd/gcXPwLtT4cgu85wuaZz5nLvnrNRbO/sUEgBOuA7OfbFiWmlNwmNd6aKGbx16PXl6HjnaWfDInfIbGNbKau7rkHl0ZLdZg77tu8YdkzSe9G3w+c3w4eXw3vnw/gXmdLw9TzFPvtyZR47i6q925pe5klWVxGHmCUhBpnnyB2aQZ7mrv1pUV/NK1jd/bOi7Mq+E2V09CspmG5XtA1Zjw2zXujkpqp8XkUbnnW2tvfU8qiTQXxvuzKO0zd7Pp3RXv6OEwf4ZW0sRHOkt0XKXiTemqnoegdkou7Kp7f1p7O1mBtr072HK4xDW0Zz8B8wLTWDOKFxZZYU/ufselZ/evrn4ZB4drvi8u98XmAGVypS92NepD0x5wnz844NmTyu3+Y/CoifN+yOn+36Xie5mHiOAn10z2SYObfzjAThH/d78W5GfDgufMJvmx/SEG741ZwAE35+T1IuCR1J7FkuZ2doaXrpm8zTMbmc9j9wfvEGN2O+oMXh6HtUi8+jLP5g16B9d2bhjksaz/N/mtLs75sKeRZC5w1w+6nfmbVCEeVUKqs8+cp+MVJeyHBgC4/9q3l/4hPl/JDfFnI7YYoPfuzKeju6B4ryq91Mb7sB3eJzvLIKRZQNJXavfh/vqVmlhzZlXItLuzd+axhuLd3tmTaurdjnbWmGWN8ulplLi8qK6mhcsDIdZ+gzezKP4NhY8Au+sYkf3NP5ruc9h3TP2lu1lM6ySkjV/c2eg9RzrXeYOHrkDObXJTmuoMPfsXkcb/7Vqo6aytbJNtKtqA+DueeS+2HfSH+CE680Lh5/eCLvmmzMYuvtbnfkPmPRQxf0cfwVg8c7CNroWpaZ+YHQfA3ethQteg4Sh0Pl4mP6d2Yolcai5koJHDdaK0h6kRejQEzK3+yV4FGBrp2Vr5a/atBaBdcg8Orq35nWkZXNnDI24FnqNN/srhMd5m7BbrWb2UeExM4Di7kPgtvgZ2PezGQCC6svWwAxKrfqPmU798wveZv5xA8xMn/A488TwyE7oMqL+76uqK9nu8YdEe0+Kq+JusF2UZQa5yk4uICJSxsJt6fz+vd8wDFi19yivXH0CIYF1yyAqbo/BI3egP6xT3UteLBYz+2j7d2bpWo8xkL7VfK61N8uuTKcmCh6VFoPD1bbCfQ6beJx5IanXaRDbt+ptG1PSOHN2YYdrivamCB65LwDbCxr/tWpSnOt73l1T2VqVwSPXeV+kK3hkscA5L5jneFu+hI+vgdPuM7PEQ2Kq6Z3bDXqPNy88RnYxm6g3FVsgDL/K/FdWwnHm7dG95s+rtX0Ha0Ha0aeQ+IUfM4/abcPs1ho8cs9wUZvMI83I1vq5r6YNOBuGXQqDzzOv9JU9UaiuafYvr5qznrhPWMJrCB4FBMGUx8z7K14xT/rBPDEFb4PThqble4JH5a5kuycJ6FDL6XzLN2YUESnnaH4Jd81e66lunb8tnd//9zcKSkqr37Acz2xr7Sp4VMXf6toq3/co23XeWtu/8a2JJ/Not9mfMP9I47yO+/wVvMGT2H5m36HLP2ic16yNoDDv7GDQNAFCd0CzJL/xX6smmTsBwzsrYW4KlK3qcNi9jcSh8p5HOSnekv6y52tWG1z0ptkDyV5glqwBDJhaffPzU2eY7QjOeLhhTdL9JSLOlTVuwIGVzT2aVq0dfQqJX/g1eOTKPGpvPY9KWmnwqC6ZRy3hSow0TKEreFTdtLZVNc0uKTAzksqqKfMIzJORnqeawcfVM81l5YNHZU+A6sN9Nbt85lGv02Hig+asPrXhaZqtGddEpHJrDxwjt7iUnp3CeO93owkLsvHzrkyuf2cVuUX2Wu+nXfY8yqrib3VtlZ1xrTjP+zkVXUNZcmvkDojlZ8ALg+GtiWbAwN/cZYRBEWZQwa1jr+Y/p3X3tIEmyjxyB48aWErvD+6LfZ36AhYzO6wg0/t82iZzmbvVwNG95sRH6z40y9H+NQKeH2g+FxRpzsxdVkAQXPa+tzE2mOWD1ek9Hv6yr/LZ95pL79PN289vavi5ZDum4JHUjTt4tPETs5N+A3h7HrWz4JEn86iG0piWpi6ZR866XVWVFsh9MhJWXfDIlXlUlOW7vLKASm2CRxYLnPkEUCa7qULm0Y6a91MdzxeSclezbQFmOnZtZyaMUvBIRKq3N9O8kj+0SzSn9Y/j/RvHEBkSwK/7jnHNWyvJKqjdzLXtbrY1w4DNX5j3O9WzFMpd3nxsrzcDNjiq+YMcjSE0xizvc2usmdeKys201pIMONs8T008zsx4aWyB7uBRC7hY6r5YFxHn7VeUfcjs9/XlbfC2K7DWdZRZ3ue0mzPZfvkH2PSpt9yxY2/zIlplgsLgqo/NC3ydj4c+Exv3PTWGs5+GLieYF0eXPtfco2m12smnkPiNO3gE8MZpkFH/L3LqedTKGmbXJfNIWjenw3uVtrqTME/wyLVuYRZs+gwytvmuFxhe+54VXYb7XqlKHGbe+rtsraYZ1WribrCdU0XwaOOn8NwgpUeLtGP7j5hfLHt2CgNgZM8OzL7pJDqEBbL+UDZX/OeXWgWQ2l3D7C1fwoHlZjBg9E3120doB2/gaev/zNuaJkNozdyla25r3vP/a7TktgsdesJty+HaL5vm9VpS2Zo7eBTawZtZ9+YEM0C0bpaZddR1pNngulMf8/mMbWYw9bQ/wzWfw5/3ms2mT7q16tcJiYbp38ItS3wnHGktQqLNi4RQ8TxVaq2dfAqJ3yQcZzbFc8usf9pfu59trSV++FantplHTofvY01l3voUZgGu41Zd8MjdKLowCzZ8Ai+fCJ/+Dr6913e92mQdlTXx/8yrZz3GejOf4lzBoyO7wFHPzDanw3vCUP5Eu67cDSXds5OU99mNkJsMPz3csNcRkVZr3xHzi2VSrDd4PrRrNB/fMpa4yGC2peby6qIqmteW4W2Y3Q7K1uyF8KNrBqdT7q5/zyPwlq5t/dq8bYsla27lzyl3zfOdnt0fWvr5a8fevrO/NaaWGjyKKDN5iTUAhl4MN/4ENy2A7id6S8+GXAi3r4KJf4O+k6rPMm9L3AHlI7v1/aSeFDySugkIguv/B/3PNh/nZ1a/fnW7cjXMdhrgbE/ZRy39w7cqtc08Kt/rxl6LMjdpWdz9joKjqm906M48WvaiWUPunqEtt1wTaWsdv/BEd4W718MN33mXRXUzA5hOu1k2Wx8Z283+BEEREDewfvtwczeUdM9OUlbZ/yOBYQ17HRFptdxla71ifTMv+ydE8o8LzZLcj389SGGJo8K2ZXl7HrWD0/YVL5vNraO6msGjhujiaprt7tPpnuigLQorEzTpPcGcXn3mOXB4jf9eo7W2XWgM7obhLaHnkbt1QEgMdHMFTJPGmZlEl7xjBo3cpv4T/rgRLp3pLb9vTzokmb2fSvKqvvgn1WoHn0LSKNy11e5puOvBnXkE7azvUWsNHgW4gkc1ZR6V/zLdEj5YpW7KXsWqjjt4VJJn/n6MuKby9dz9k+oiMBSsZT6irFY44Vrz/pd/gGX/qvtVo0O/mrddRtQ9oFWeu69AfiXBo8O/lVmvjllXItIqJGcVcunry5nx8Tp+3plZoQS/uNRBcpb5eekuWytr4sB4unUIJbvQzv/WVz9rozvzKKitB49ykmHp8+b9Mx41+6w0hDvzyC2qAVlMLd0ZD5szYl3/jRkwcPd2+e95sHepf16juAX3PGpq7t/NljBBTNlztlPuMTOKrvvat9WIm9VW+fL2IiAIYlyz6x7Z1bxjaaVazafQ0aNHufrqq4mKiiImJoYbb7yRvLyqv5QePXqUO++8kwEDBhAaGkqPHj246667yM7OrnIbqYPwhgePAsoEj9pV3yN38CiolX34uuuba8o8Kv9luuzUrtI61KZZNpjpz7Zg6Hcm3PYLTH3WO5tHWeWz0errrKfhpNvN+/P+D+b+tWKZZHXcQZ1uJ1a/Xm1ElMk8Kh/E2rfMe9/dYFRE2pTP1xzi133H+HztYa55eyWnPLWAp77fxs408zPv4NFCnAaEB9mIiwiusL3NauHak8wvMbNWVT+DbbG9nZSt/fSo+WW822g47pKG7y/xOLN0x60tl61Fd4NrPoNe48zP7uu/NrNPSnLhg4th+/d136fTATvnwa9vweJnvE3MlXnUcsvWrFaIG+B78U18lS1dkzprNb9ZV199NZs3b2bevHl88803LFmyhJtvvrnK9ZOTk0lOTubZZ59l06ZNzJw5k7lz53LjjTc24ajbMHd6bAPK1nwzj9pR36M2n3mU4ftYmUetj7tsrabMo6RT4YFkuPoTc6rewFDfXkIdXY0ZJz/qn3FZrXDWP2DKE+bjla/DF7fUPgPpkDt4NKrhY3EHj+wFFX/H9//svV+kCxYibYVhGDz1/Tb+8d1WNh42/28P6xZNdGggqTlFvL54N5NfWMKNM39la4oZOE6KDcdisVS6v4tO6IbVAusPZrH/SNVfQj1la215trXktbDhI/P+2U+Zs282VGAIJAz1Pm7LZWvlBUfC1Z/CgGngKIaPrzUzu+pi/Ucw6xL49k+w8AnY77ow0h7LncprSWVrtc0WF5O7abgyj+oloOZVmt/WrVuZO3cuv/76K6NGmSf9//73v5k6dSrPPvssXbpU/DAYOnQon332medxnz59eOKJJ7jmmmsoLS0lIKDyt15cXExxcbHncU6O+eFvt9ux2+3+fFuNxj3OxhyvJTiGAMCZn4Gjvq9TJtuoqNhOSBu/oOZmK8rBCpQGhGHU4WfXFMe1OlZrEDbAWVJQ7TG35qRQ9lCWFmTV6X22V819fMuy5mWYxzokpnb/v53edWxxg7C6PpBLz38Nw2IzT979+b5OvAVLeDy2r/6AZeMc7Cff452NrSrFuQSkb8UC2BOOb/h4LEEEBIVjKcnHnnXYGygznAQcWo37a49RmEVpmc+PlnB8pXHoGLdNZY/rT1vTeX2xebXa3X/oz1P6Mbx7DIu2Z/DlumQW7chk/rZ0ftljZmb36BBa5e9ETIiVsb07sWz3Eb5cc4jbTq+8kb97tjUrzjb7+2XdNtf83BkwDUf8ML99Zlg7j8CWsg4Ae1iiz37b/v9ZG1z0NgFvjseSuZ3SA79iDJha662tKRuwAUZsf4xuozHCOkFEZ5zHXebfz/RG1GjH2BJEIGCUFFDazD+LgMJjWIDSwIh2eb5d12Nsjell/q3J3Fn/77BtUG1/fq0ieLRixQpiYmI8gSOAM844A6vVysqVK7nwwgtrtZ/s7GyioqKqDBwBPPnkkzz6aMWr5D/++CNhYa2r8em8efMabd8J2Xs5CchJ2cvi776rcf3KmMkC5rH4Yd48Iqvpy9uWTDiSTBSwct0WMuuRMdmYx7U6SZm7OR5IO7SfVdUc80HJKyn7Nf63ZYtI25TV2MNrM5rr+JY1KPlX+gP70nLYWMf/3wOybLhbUc/7bSclAZHAYX8PEQhmXEhPOhbsZt0Ps0juMKbatWPy9zAeg6KAGH5YstovI5hkiSCCfH756WuORgwAIKw4g8l2bwZBYVYq88r8DFvC8ZXGpWPcNn0zdx7PbrCBKzTs7kN0cOMvHNlqrnNuBxg6GF7baiPf1QQ7JD+Z776r+m9gDywsw8a7S3eyfcd2gm0QZIVAK3QKNugdBYV283WXLV7E5ooVcG3CsAMr6QXsyA5kez3PKyvT/UgArrbZ/LBiIw7bzgrrtPX/syc4OtId2L78G3bVdN5pGPRP+4pSawgd83fSFdgUfCJ7LFOgEPPfgp9r2EnL4+9jHFCazzTA4rTz/TdfY1ib7yv1mVlphABLf9tMzpb22yqitsc4LucIJwP5B9azwI9/a1q7goLa9e9qFcGj1NRU4uN9m44GBATQsWNHUlNTa7WPzMxMHnvssWpL3QDuv/9+ZsyY4Xmck5ND9+7dmTJlClFRraPG1263M2/ePCZPnkxgYONEZCyHE2HP80QH2pk6tfZXMcq7d9U8Sp0Gp0+YSEJUiB9H2HIF7H4AimDMuEkYXUbUerumOK7VsWzIgYMzSegUXe0xt/1vLpSZwGDUsIEYQ+r/O9JeNPfxLcv63XxIg56DRtD9tLodO8s2B3z2JYYtmDPOvcw/pQdVsDl/gPW7OaFbKMPHVz9Oy5YvYQcEJQ5o0N8sn9fPeAUOpTH2uD4Yg8x9WnbMhS1gBIRgKS0i1FLC1KlTW9TxlcahY9w2bU/J4unPf2HN0UBPQMite4dQLjlvXIVtzsrIZ93BLPrFR3Bc16gqy9YAxhXZ+fqfS8gqcfDdwYop2LN/fyLOFWaz/7PPPIMOYUENfEctk+3jD+AI9B0xjj4n+PGc4Uh/eP1NjIhEzjz3Ip+n2sv/WeuSTbB0BYPiAulf0+df6kYC3/4cACPWvCgy6KQpDBzYOs/jGu0YO+yw8Q8AnD1pXPOVjBkGAevNL/2nTjnXnKWwnanzMc4aCq88Q4Q9k6lnn1V5r852yF1tVZNmDR799a9/5emnn652na1btzb4dXJycpg2bRqDBw/mkUceqXbd4OBggoMrXtYJDAxsdR8sjTrmaHOmIUvBEQIDAur9BdFmtVDqNLDYAlrdz7feSsyrAgHhHaAe77nZfheDzeaAVkcJ1upeP2uvz8MAR2G93md71SL+1hSbvTxsEXHY6jqWpJMhIBRL15EEBjXyl5zEIbAebEe21zzOXPPKv7VjUvW/v3URaf4dDCg84v0dP2pe1bb0OAn2LMJSnEugzfuFsEUcX2lUOsZtQ35xKbd/+P/snXd8G/X9/5+n5b23YyfO3oNMCCFAEiCEDYVSoEAZpVBKC13Q9WvLt7ulLXRQaEvZtJRRNgQCCRkkkL2nneG9t2Wt3x+fO51kS7JsS5Zkf56Phx93ujudPrLW3ete79d7Gx8drEVEhDoYm53ELUvG8sNX9wAwsyjN52s9pTCdKYXpQT1OptnMS3ctZs2BGsrq2um0OensdrC3opnK5i4+Pa7npiXFx2E2x8R13/7TJi4GmzKKQ3vMkD8VPv8sSkqB38/lsP/M5goRyNBwtO/fv5Mb3bNK3UEATJmjY/44LuSvsdksGoY4rJid1sj9f6xt7ugAc0pOzL9OgyHo1zhzNCgGFEc35u5m2RVXJdjPR0R/gb75zW9y8803B9xm3Lhx5OfnU1Pj3cHJbrfT0NBAfn5+wPu3traycuVKUlJSeOWVV4b3j8NQkqh2W7N3iU4DcckD2o3JoGAFHI4R0m3N5YrdwGyt21qgwOyD78CJTaK7Sf4sqNgmftgksUWwgdm+SMmHe/cO+DuhX+ROFdOaA31v26R2Mwpli9pkIR55dRisVcdSLMQjcIn2xqak0D2uRCIJO2sO1PDRwVoMCkxPd3LfpQs4e3IeigKPrzvGiYYOphemheSxpuSnMiXf293+x/cP8/v3D7HrlC4eaTlLw5JWtZIgJfBx/YCYenHo9xlLuLtLBREQfOzD3svSikI7nuGCJRE6raJxRqToahJTgxnMsRWvEjGMZkjOh9YKaD4pxaN+ElHxKCcnh5ycnD63O+OMM2hqamLr1q3MmzcPgDVr1uB0Olm0yH/ORUtLCxdccAFxcXG89tprxMePjLKoIcGS7Fbc6agf8Imi1nHNNlK6rdk6wKU+11gTj7Rua7Yu3+sddnj7O2L+9LuESFaxLTo6UUj6R4fWuSNzYPdPygrdWAKRO01MG46K96U5wHd8WMQj9YCjzaNOs2afmBbMAlOCEFu7miFZikcSSSyx42QTAF9YUMxCYylLJmRhUI9Z7l42gX+uL+XS2eHr3jU5XxxX7S4X4zAaFEzGYSoeOWzQrnZqTRlBHdGGCk086qgTnbn8XRiyW6Fsg/cyY5zeYVnijSVZ/D8jeZzr2WktjDEBw460IlU8OgWj5kV6NDFFTPwKTZ06lZUrV3L77bezZcsWNmzYwN133821117r7rRWXl7OlClT2LJlCyCEo/PPP5/29nb+8Y9/0NLSQlVVFVVVVTgcjkAPJwkGRYEk9ceko27Au9EOhBzOEeI80lxHiiH2rhD05TwqWwdNx4XgcPZ3dUHROnLD+2IWzXmUGOVtX5PzID5dCLL1vUNQvWg6LqZhEY9U55HTAbWHxHzuVIhXXQldzb3vK5FIoprtJ8RJ2Zzi3u6ia+YX8843llKcGb7f8Ul54gJTdYvoADz8XUcu4Z5IHKKLDyOJuGRIKRDz9QESs09s6n2Ml1oIhmH83hsMFvWiUHd74O3Ciad4JAkezU3XHI6GLsObmPk2ePbZZ5kyZQrLly9n1apVLFmyhMcee8y93mazcfDgQXdS+LZt29i8eTO7d+9mwoQJFBQUuP9OnjwZqacxvNB+4NvrB7wLzXlkHylla5/8RUxTi2LvCkFfzqPdL4np9MvFgYpFdVZJ51FsYevSnTTJYSgfCCWKoruPKndB1R6o3Nl7O5crvGVrtQfgw5/Dc9cIN6YpAdJLpHgkkcQo3XYneypEeOjsotCUpvWXMVlJXoJRomWYZh0BtFaKaUqBFCrCRTCla5vUY1RPIUKWrPlHuwjcHcGyNSkeDYw0NVi8+VRkxxGDxMwvUWZmJs8995zf9SUlJbhcugBxzjnneN2WhAFNPOqP86i5HP53F8y/FaZdilkVj0aE8+jIB7Dhj2J+5c8jO5aBEMh5ZLfC/tfF/IyrxNTtPJLiUUxRsw+cdnEgkhoD5QMlZ8KJjfDRL6H5BJiT4FsHvctC22tFPptiEMJtqEhSnUeNZbDWo/nDuLPFCZAUjySSmORAVQvddidpCWZKshIZfOuW/mM0KEzMS2ZPuRCxVs7Ii8AohghNPEotiOw4hjNZE6DsY//i0cktcPhdUIxw6SPw7xvE8hHYvSto3M6jSJatNYlpQnrkxhCLpBWLabM0lPSXmBGPJFGIu2ytH86jnc+JENljH8GdmzAaVeeRv8yjqj2w8WFY/v90lTgWaa2GV+4Q8/NvhamXRHY8A8GkdiH05Tw68oHo0JVSAKMXi2UWWbYWk1TtEtOC2bHhjjvjq/DpP4RwBGBrFwHaxQv0bTTXUUohmELYAa5gFkxYIZxa+bPF/6xgll4/L8UjiSQm0fKOZheno0Twe9Do4cK5Y+n4iI0j7LRozqMod7vGMpljxbSh1Pd6zRk/5wvidw0FcEnnUSC041xZthZ7uMvWpPOov/RbPGpvb+eXv/wlH3zwATU1NTh7nPQfO3YsZIOTRDlagF7VnuDv0+bRleiVOzAZHgQCOI8ePVOfv/Ix39tEO06nEI7aayF3Olzws0iPaGCYPJxHLpe3sLDnv2I6/Urdcq45j2TZWmxRqYpH+bMiO45gSciAc78Hb31LX1a731s8aiwT01CWrIHo2HHDS/7XS/FIIolJ1h0Sjuq5o9MjOo4vLChm58kmLppVENZ8pYjTWiGmMiw7fGSo4pH2e9iTih1iOvNq4TRPKxYXZWL5wm24sWhlaxEUjxrUDKukvhtQSTzQxKMWmXnUX/otHt12222sXbuWL37xixQUFET0iowkwkxYAZv/CrtegOKFsOBWfZ3TIbpn9Ox+5KnwVu0iI7mVUgzYfYlHdR4BuP5+7Kr3iVKwuoNwzgMw6YIBP52wsfGPovWpKQGufkIv/4o1PF9Lu1W/3d0OB98W81rJGkCc2nZYOo9iC0/nUayw4Dbhetv7Mux5CWo8ikzaamDDH8R85rihHZcUjySSmKO5w8baQ+JC16qZkS2junp+MWOykpg3Zpi7Clpk2VrYySgR00YfzqPudv04O3e6mI5ZDLtOyE5UgdDK1mwREo+cTjj0npgfd3ZkxhCraBEGbdXinKa7XVTFHF0j3Hmrfg150yM6xGil3+LR22+/zZtvvsmZZ57Z98aS4c3EFXDO9+Cjn4ur/umjYeJ5wpXy9xWie8Y9271Fhx61pSWUs40iRm95EGqmwOlf0Vdue1Kf9xdGt/pHcGS1mP/siegTj6xtIkgXxBdRzuTIjmcwmDxEr4NvwpRLRAnQwbfB1iEOTEbN1bexSOdRzOF0QPVeMR9L4pGiwNSLRZc4T/GooRSevkIcLCflwJn3DO24pHgkkUQlpXXt/Pi1vdy8uIRzp+R6rXt7TyU2h4sp+SlMykvBZrNFaJQi9+iM8SOg+5g7MFs6j8KGJh511ENXC8Sn6utqDwAu8TuZrDpYLvszrPixFPQCMRRlax0N8O73xAX5yRfCzM/p6yp3QFuVGEfJWeEbw3AkMVOc19g74bFzRd4nHkaGLY/BJX+M2PCimX63NMjIyCAzMzMcY5HEImd/B2ZfJ1plv3izKHlpqYCKbcKG3NMx1KSKR+oBwhhXOdOU4xQeeALe+S7sfUWsd7lg13/0+zUcE8t6oh1wQP+Cu4eKphPg6BbtxE/7YqRHMziMZn3+v7eIMEWHDfa8LJbNuMq7lE0GZsce9UeEEGhOgswYzNfImSqmtQdEOe0/LxDCUfoYuOXdoRdvpXgkkUQl//fGPtYequXOZ7ey+5T35/O1naKE6tI5UsgYMrRIg5RhHAoeaeJT9UY3PY/Nq/eJae5UfZnRJIWjvnAHZodRPNryGOx8XsRDvPIVcdytcegdMR2/TM8llQSHokDGGDFfsxdwie69k1aKZae2Rmxo0U6/xaMHH3yQH/3oR3R0RLAtoSR6UBShzI5dKhwmz10DB9/S17sc+ry1FbqaxPz4ZQAUO8spUmr1bV67R/yo1ewTVkKDKljY2oWTqSftHoJRe23v9ZGmRa3jTyuKjfDhQPQc/+F3xQ+Z5vya8Tnv9doVma5m3yHbkuhDE3czx8Vmu2RNHGqthCcuFN8heTPg1vcgKwJimBSPJJIh5a3dlfxt7dGA2+w82cQHB4RY0WVzcvtTn1HTIn6j7A4nnx0XAbQXTJfhzUNGW7WYJkvxKKz4yz3S3Lq5skynX5i1zKMwnhNrnYwBnDY9IBv0863JF4bv8YczF/wM5n0JLv8r3HcA7toEFz0k1tXsi2yWVRTT77OD3/3ud7z77rvk5eUxc+ZM5s6d6/UnGYGYLHDN05AzRZy0vft9fZ2naKDlHcWnQ+EcAIodpyhUPLq1WVuEq+WwKkiMXapbbRt6HBC6XN6d3tr70fVtqGhRn/NwaXWqHXhMv1JM9/xXOKtypkLeNO9t04rF83ZYYcezQztOycDQDkoSYzRfIz5Vb79qbYHRZ8DNb0aug48mHnke7EkkkrDgcrn4zn938Yu3D1BW5/+g/7F1orHLyun5TMhNpqqli9uf+owum4PSuna67U6SLEbGZiUN1dBHNnarfmFRhv6GF3+5RzVquXrP4zhJYEIdz1B/FN7/Cez+r8gBqz8K1XtAMSK636Gf9zSfgqrdoBhg4vmhefyRxoQVcMkfYM51ussubZTI0HQ5oHJnRIcXrfQ78+jyyy8PwzAkMU9COpz3U+E8clj15TYPNV5zNaQVQ/YkAEY5TlGoqF3bpl4KpWuhfKvewW3cOWLaWCa+REuW6PuztgoVXqO7VYhVPUO6I0mzmuI/XLpVXPOk+MGavAoMRtj9oljuGZStYTTBmV+Ht78D6/8Ac2/0Ln2TRI62GuHkK+jRUU07gI9PH+oRhY5Rc0W22qQLIx9QnzVBTMu3QmdT5MYhkYwAGjtstFntAFQ2d1GS7Vv82VLWAMBtZ40lOzmOy/+ygZ2nmvnuS7tYpuYfTc5PwWCIcbdwrKCVrBnMst14uMnsy3kkxaN+EcqyNbsVnv+CaACkoR2LjT1LnE/UH9bFI61RTdFCSMoe/ONLdEbNgwNvwKnPRHC8xIt+iUd2ux1FUbjlllsoKioK15gkscq4c8UXnXYCCmD3dB6p4lF6MWRPBCDPUUmJoroCxiyGWZ+Hf1+vC1Djzhb3O/pBb+eRlnFkThQ1wE6bWJYWRe9NrWwtdZhkJxTM1oOUl/0Q9r0m/u8zrvS9/dwbYd1vRLvX0rVC5ZdEDpcL3vuBqKF3dMPKX8Lpd+rrNYdMLB/Ar/qt+B6ZeIEQMCNJ/kxRBlCzF8PelwFZBiORhIuKpk73fG2b1ec2Na1d1LZaURSYVphKosXEX66fy43/2ML/dlSwRi1nm1qQ6vP+kjDQropHyXmxX94f7bid/B7Oo/Z6vWwwZ8qQDymmcYtHIXAeffyQEI4SMsV5UtVu/Xxq+hWw43lv8UjLO5q8cvCPLfGmaL4Qj8o/i/RIopJ+la2ZTCZ+85vfYLfbwzUeSSxjssDUS7yXeTqPmj2cRykFYEnGiJPTDWpQX1qR6Ji08MvidkIm5M3Ug3vre4pH4uohidl6CGB7lIVmu8vWokjQChUZY+BLb8MXX/WfJ2NOgNGni/mer59k6GmpgE1/EsIRwDv3w64X9fXDQTxKzoUpF0VeOAJxIjRXBOUbdj4T4cFIJMObck/xqNVbPKpu6eLzf9vE7949BMDY7CQSLeI7YvH4bL67Upw0t3aJ49spUjwaOjTnUXJu4O0kg0eLHmg4pi/TStbSx+iNTiTBoTl+NPFtMGz5m5he9Fu4Yx18twyu+4/I4znti/p5Tke9qLwoXSduT141+MeWeFO0QExPbPbdrGmE0+/Mo2XLlrF27dpwjEUyHJhzHe66XPCdeaSFR6ula6lKp74c4LwH4axvweV/EaG9ms226bj3Y2lCUWKmXicfbeKRVrY2XJxHPSmaJ9xhgcgcJ6aeByuSyGBtEdOETFh4h5h/9Stw5H0xr5VWJaQP9ciGLzOvAcWIUrWL+O6GSI9GIhm2VAQQj/605gibSxv492fiItb0wjSv9dctGk1ynC44TytICeNIJV64w7KleBR2tFLqphOiTAr0krU8GZbdb7TzlubywYkM9m794p3aUIj4NJh0gTivMhjFuQ4I8ejoh+IiYMZY97mUJISMmg/GOGirkucuPuj3pdkLL7yQ+++/n927dzNv3jySkrxryi+99NKQDU4Sg4xZDF/+SOTcnNzsO/MovVjftmKbvl4LujXHw/If6su1A4qewpBm3UzKBqfqhuuIIvHI5fLutjZSkeJR9KB1BLEkiZK1jnoRev7vG+Gm14aH8yjaSMoSn4H6wyRbKyM9Golk2BJIPKps9u74Ob3Q21mUFGdi6aRs3toturpOzpfOoyFDOo+GjuRciEsVF5IajkHuVKhWnUcy76j/pBQCiojaaK+D5AEGvrvjPhSIS/O9jdt51OBRsnahLPUMB+Z44T46vh7KPo5Mt94opt/i0V133QXAQw891Gudoig4HI5eyyUjjMI5Qiw5udl35pEmEo07R5TQAHZDPCbti7EnSZp4VCsEGe2LUhOKErPAqb7vosl51NUENjVEb7g6j4JBikfRg/Z+tCQJV9/lf4XOBji6Bp69Wm+THMuB2dFI1gRVPAqBtV0ikfikokk/3uiZeXSkptXr9jQfZWl3nTOBt3ZXMbs43cuFJAkzbudRXmTHMRJQFHEiXLEd6o8I8cgdlj01smOLRUwW8b5tqxIxFZ7iUWu16JQ2YXnf+9Fc3/Gp4tjMF9o5UlsNHPtQzE++cMBDl/RByRJVPFoP826O9Giiin6XrTmdTr9/UjiSuDGpHY5s6pVAhw1a1avumng0+gz35gaX3b96rtUUO+3eYdya8ygx26NsrXbwYw8VmusoITOyHZ8ijSYeNR4Hh8xLiyhaRxBzopiaLHDN0yKTq7MBatWDSOk8Ci3qVaukLuk8kkjChb/Mo9YuG2X1HV7b9nQeAcwYlcb7953NP2+aH75BSnrT5hGYLQk/WaJhDXWHxQVZWbY2ONyla6e8l7/2NXjmSji8uu99BOP61sSjw++J85+4NK/zKEmI0bp7734RHpknRCQJMADxSCIJCnMP8ailAlxOMFp0occjmM/gCiAqmOJ0G6ens8gtHmWK0hAYXNmaywXvfh/e//HA9+GJlneUNio0+4tVUgpF7bDTpgeISyJDt4fzSCMuGfJ62NWleBRaVPEo2VoV4YFIJMMXf2Vr+yuF66ggLZ4vLx3HvSsmkZUc53MfE3KT/a6ThAlNPEoaYMmPpH9ouUf1R0VFQHcrGMz6ckn/0I7xPcUjpxOObxDzxz7qex/ahfFArm9NPNKyKycsA6O5HwOV9IuiBboRov4I/PuLIitM0v+ytZ/+9KcB1//oRz8a8GAkwwhzvJja1YM5z7BsD0vmxoxLWdz4Gkdyzyfgz1ZSNlibhbMoW71q0q6JRx7lboMpW6s75C6jY8l9wj46GNyd1ka4eKSFntceEKVrWqtYydCjZZBpziMNzQ2oIQOzQ4t6UC7FI4kkPFjtDmo8BKOGdisOpwujQWFPeTMgQrK/t0qW5kQdsmxtaMnWxKPDUK12O86eJIWIgaIdP3mKR/VHoLtNzJ/c3Pc++uM80tA6gknCgzkerv4XVO6Eg2+K6QvXwy3vgiWxz7sPZ/otHr3yyitet202G6WlpZhMJsaPHy/FI4mgZ9laz7wjldcKv8EL1aOZNeGqPsSjHGg46l2W5hmYrXV4G4x4dHKLPt9WEwLxSC1bG+niEYjSNU080jpJSIYed2B2jx++9J7ikXQehRRVPEq01uJw2MAsD9IlklBS3SyEI4vJgM3hxOmC+nYrqfFm3tkjRNsZo2QIdlQiA7OHFrfz6AjUqOJRT/exJHhSfTiPKrZ7zO8Qnae1i+q+CKbTrdZtTSN/Vj8GKRkQk1eKvznXwWNnQ9UueP3rcOVjIzqovN/i0fbt23sta2lp4eabb+aKK64IyaAkwwB32ZoaYNnkWzwymCy85lzMBGMfbXG13CPtIAO8A7MVg/ey/tDRAKc+g+Mb9WXtNfrVmYEiy9Z03KHZpZEdx0hHC8w2e3fJ9PpcGkxgSUYSQlIKcJkTMdg6cDQdh3zpfpBIQsnxBvHdVpSeQEuXjbq2bg5VtfHQ6oNsO9GExWjggun5ER6lpBddzfrvkhSPhoZMtXNUR71eWiXDsgeOlnnUUq4v8xSPnDbhWhm9yP8+tLK1/jiP8mf2a5iSQZBeDFc/CU9dBrv/IyookrJFYHn66EiPbsgJSeZRamoqP/nJT/jhD3/Y98aSkYFbPFKdDprzqIfDwWQQyq3d6Qq8P3cgtq/Mo2zxB9CmdmTrD+/9AJ67GnY+py9rC0FXJFm2ppM5Vkxlx7XI4s955CkexaeP6CsqYUFR3AfsSsPRCA9GIhl+7DzZBMC0wlSy1cyiO57+jG0nmkhLMPPMbYuY6qPDmiTCaBft0sdAXB8XESWhIS4ZMtRjsqNrxDRXhmUPGF+ZR5p4ZFTz0/oqXdPK1gJlHsWn6fPGOBkvMNSMPQsu+JmYX/drePs78PQV+nH1CCJkgdnNzc00NzeHaneSWEcTj+yq88hdtlbktZlRFY8cTmfg/fXsptZeL65YgVDj04qEY8LW3rvjQV/seLb3srYQdG2TZWs6mvOoXp44RxRNzLX0dB55fC4HW64p8YlL/QxI8UgiCT3bTjQBcNroDHJSxAlbe7eDUekJvHTnGSwcmxng3pKIcfg9MZ14fmTHMdIoOVNMXeqxt3QeDRzt4ltrJTw0HX49XheLZlwlphW9q3a8CKZszfOinqxoiAyLvgJzbwIU4eCvPwJrHoz0qIacfpetPfzww163XS4XlZWVPP3001x44YUhG5gkxumVeaQFZg/WeaQ6i16/R9zOnS7qgBUFcqZA9R5Rk9ozw8Ufti5R8ubqIV4Fch611UBrFRQEqDd2ufSytdTC4MYynNHEo8ZScDrAYIzseEYqWoBjz7K1FI9yDrsVSehxZXp0uJFIJCHD5XKx/YS4cj93dDplde18fLiO6YWpPHHzAnJTA2SNSCKHy6W3MZfi0dBSchZsf0bMW1JGZOlNyEjMFuc2zSe9OwpnTxZ5OTufE8e+gQgmMNsTeVE6MigKXPJHWPUbOPohPP95+PTvcP7PvJpBDXf6LR79/ve/97ptMBjIycnhpptu4oEHHgjZwCQxjtlDPHK5PDKPejqPxIfN7uhLPFLL0trrYOfzcOAN0Vr0ir/qanz+LCEeVe6CKRcFN876w7pwNPF8IRpV7gwsHv3tbGitgDs3Qp4fq29no95pTn7JQ2qReL0c3cKRFay4Jwkt/srWPMU8a9vQjWcE4cqSZWsSSTgoq++gscOGxWhgWmEqozMTmVOczsoZ+STF9fswVzJU1B4UJ9zGOChZEunRjCzGnKnP506VpeqDwWCAO9aJpjCmOHHx3BwvjnvrDolt+sr71DKPApWtgRD9yj6GxfcMdtSSgaIo4nXW3HuOblFlM4I6sPX7V7W0VAbeSoLAXbbWKbKJNCGlh3hkcpet9SEeaUGK9Yfhre+I+XMfgILZ+jYFs4TCX7Ur+HHW7BfT0Yvh+hdh679Ekn67n7I1l0sIRwD7X/cvHmnBeYnZgTssjBSMJsgYIyyeDcekeBQptLI1c4AfuW4pHoUFmXkkkYSFbcfFVfsZo1KJMxmJSzZy1byiPu4liThHPxDTkiUj6sQrKkgvFqG/jWWyZC0UJGbCmMW9l2eUiGlXk7io7M9ZFKzz6NrnxHH0qLkDHakkVGgVNjDixKN+e6xuueUWWltbey1vb2/nlltuCcmgJMMAT+eRlneUnC/UWg+M7rK1fmQedbdC8elw5je8t9HaVlbuDH6cWpvS3Cnq46gilT/nUZdHrldHg//9DkHJ2pGaNv7z6UmcfQlv0YK745oMzY4Y3WpXm56ZR564HEMzlhGGO/OotVK6uySSELKvsgWA2cXpkR2IpH+UrRfTcWdHdhwjlSkXi+nYpZEdx3AmLlk/r2gs879dMJlHIDIppXAUHRhNImsX9IiWEUK/xaMnn3ySzs7e/6TOzk6eeuqpkAxKMgxwZx51+S1ZA915tLu8hbq2AFkrmngEoo34lX/rnZujta1sKReB2sFQc0BMc6eJaXKemPoLzG6t0ucDOQg055GP5xwq7nl+O995aRfPbj4etscIKVI8ijyBnEdX/l2UFl795NCOaaSQkIHVpHYTkp8BiSRkNHZ0A5CbIl2+MYPTobeJlyVrkWH5j+D2NXqosyQ8uLsN+6nccbn6n3kkiQ5MPZpDjRCCFo9aWlpobm7G5XLR2tpKS0uL+6+xsZG33nqL3NzccI5VEktopVq2Dj0s20ep0rwxGRgNCjtPNnHLvz71v7/4dP2E98Jf6VZQr21SdYHixKbgxul2Hqm23WRVpGqrFl/oPWmt1Oer9/nfb0t4nUfH69vdV1sfXXuMbnsfzq1oQIpHkcdf5hHArKvhexUw/fIhHdJIoi1ODSaXpWsSScho7bIDkBIv841ihuo9wsltSYH82X1vLwk9pjgYNU/mHYUb7Xyl9oD3BWgNWwc4bWK+r8wjSXThPteVziOfpKenk5mZiaIoTJo0iYyMDPdfdnY2t9xyC1/96lfDOVZJLGH2UGOb/TuPFk/I5n9fPROjQWHXqWZONXb43p/BAFc+Dhf/HuZc7/9xJ68S021BuCesbdCkunZyVPFIs5c6bfqVAE88v/hbK/yXrrnL1sITlv3uXn0c5U2dvLq9PCyPE1Lc4pHMTYsYNq1sLdn3epNl6MYyAmmPU52N9UciOxCJZBjR2iVOvKR4FENoJWtjzhDlHxLJcCVDdR6t/RX8foZe8aChlawZTIEjBSTRxwh1HgX9jf3hhx/icrlYtmwZL730EpmZme51FouFMWPGUFgoW5JLVNxlax3QdELMp/luBTpjVBozR6Wx42QTm481UDTPT+jY1Iv7ftz5t8CmP4n2r41lvh1KGnUHxTQpF5KyxLw5HuLSwNos8pUSM73v4+k8AuFc8mW51rYLk/Po3b0ik2l0ZiInGjpYe6iWaxZEeQi1p/PI5ZJXuyJBdxCB2ZKw4XYe1R+FTX+BLX+DG/8X+HtKIpEERHMepcabIzwSSVDYOvU28bJkTTLc0crWQFyY3vcq5N6vL/MsWZPHxbHFCHUeBS0enX22CLQrLS1l9OjRKPINLgmE5jxyOfWQuAD5P4vGZbLjZBOfHKsfXJeUrPEw7hw49pHonLbix/631Tqt9ew0kZwrxKPSdZA1wTtbqafltNqPeKR1a/PMagoRNa1WtqrdZb50Zgk/eX0fFc0x8MWVVgyKUXTea62C1IJIj2jk4Q7MluJRJNDFoyNQtUd8Nx5dI0RviSTCOJ0u9lW2MDk/BbOx35GYEUOWrcUY79wvLrwlZsPsL0R6NBJJeOl5cUhz3Wl0qhUMsmQt9jCp4tEIcx71++hgzJgxrF+/nhtuuIHFixdTXi7KZZ5++mnWr1/fx70lIwazRwvDWtXhE6A9++njhPNnc2mADmbBMv9WMd32FNgDhHC7xaNp3su1cb71LVj9I+91mqNI+8Lw1z2hrUZMkweeA/ZpWQN3PP0ZJxu8S/ne3y/2Pbs4nbmjRbheRVP0iUcn6jtweHaCM1n0/63MPRp6XC6PwGxpjY4E7fGqeFR3WM890pyZEkmEeXl7ORc/sp5H1sRWWWWbVROPpPMo6tn1oriwhwJXPT6oYySJJCbImy6EUq0i4+Rm/UIeQN0hMZUO5NjDs7P4CKLf4tFLL73EBRdcQEJCAtu2bcNqFSfnzc3N/PznPw/5ACUxitECivr20oLg0vyLR/PV4OwTDR1eQkhzp43XdlbQZetH+/DJqyClADrqYd9r/rdzi0dTvJev/CVMu1zM734RnB5h1JrzSOvs1lHXe78Ou3hs0Lu3DYDv/HcX7+6t5nOPbvRavloVj1ZOz6cgXYhYNa1WbI7oCc1ec6Capb/5kN+8e9B7hVa6dnwjfPgL3+GBkvBg6wRUMU86jyKCO/Ooq0kX8rRulBJJhNl+Qjha96vNGGIBl8slM49ihbrD8MY3xPzSb8P4ZREdjkQyJMSlwDd2w3dLRXyHo9u7qY/WfCdvmu/7S6IX6TwKjv/7v//j0Ucf5fHHH8ds1q/ynHnmmWzbti2kg5PEMIqiq+wgOmrEp/ndPCXezIzCVAA2l9a7l//ktb3c8/x2HnwjQGeznhhNMO9mMf/ZP/xv5895lDNZhHPHpYqua6c8usBpYkfeDDFt9yEeddQDLiGeJWYFP+4elNaJKxPVLVYOVImD+Q47fHJMuLMumJ5HdlIcFqMBlwuqmqPny2tfhRjvwaoeJyGaePTh/8HaX8K73x/ikY1gbB4ONpl5FBEchjhcPUP0pfNIEiWU1YvfnJqW6Pkt6Qur3YnNIURxKR5FMbZOePFm6G6DkrPgnPv7vItEMmywJAqXyjgRAcPRD/V1Wtdn7bxCEjtI51FwHDx4kKVLl/ZanpaWRlNTUyjGJBkuaEFiIMqV+sjJ0krXPjmql669rHYRe3ZzP0+w5t4o8nVObILqvb3XdzaKbmkAOVN6rzdZYNIFYv7A62LqckFbEM6jdrVkLTHLOy+pH9gcTkwG/f/12DpR5rW3UcHudDExN5lxOckYDIrbfVQZReJRfXs3AC1qFoUbTTzSOLl5iEYkcdukTfEDfl9KBo8rc7z3gmbpPJJEB2V1QmCuaQ1Q7h1ltKiuI0WBJIsUj6KW9X+A6j0iB/Kqv8vfIMnIZNw5YnpsrZi6XLrzqOeFbEn0I51HwZGfn8+RI73r4devX8+4ceN83EMyYvF0N2SM9b+dyqJxorOZp/MoM0lvHW6196N0LbUQplwk5j/14T7SWmWmFkF8qu99TFG7u+1/Q3zBdzYKuymIGmaA9vre92sTndBIGngt/4mGDuweeUGflglBbVeDEJQumJ7vXleQJr68oin3qFETjzpt3it6ikeaCDdU1B+FPy+CHc8N7eNGA5rzSLaCjSi9xKPWysDZbBJJiNl8rJ5NR71/u6x2h7vxQm2rFadnXl0Uo4VlJ8eZMBhkI5eoRbtQdM79kJIfeFuJZLgyVnUeVe+GtlpoPiUa9BhMkD0psmOT9B/pPAqO22+/na9//ets3rwZRVGoqKjg2Wef5Vvf+hZ33nlnOMYoiVVMHs6jwtP63Hx+SSYGBcrqO9wlWBmJemnkzpPN/Xv8BWpw9q5/g7XVe12tn05rnkxYAcY4aCwV7qXmU2J5YrbIVALRVc3V4yC7Te20ljzwTmultcIlUqgKQycbOqlvs3KgSRwcr5yhH3wVposvr2jquNbQIUQj7aqwm57i0VDzxr1QewBeHYHfVd0yLDsqyBrfe5n23SKRhBmbw8nnH/uELzz+Ccfr9dDWkw0d7p8yu9NFQ0d3hEbYPzTxKFWGZUc3jaVimhPgmEsiGe4k50CeetG0dK1eGZE9SVQ8SGIL6TwKjvvvv5/rrruO5cuX09bWxtKlS7ntttu44447+NrXvhaOMUpiFc+Oa0GIR6nxZmaMErlImvuoqUMXHz455sPlE4ixZ0PWBFFjv+s/3utqghCP4pJhwnIxf+ANvWtc9kRIyhbzDqvYvyda2dognEfH6sQ+547JIDclDoB/bjxOt1NhVHo80wt1t1RhmioeRZHzqKFdOClaOnuUraWP8b7dU9QLN1q3vFjE5YL3fzJw15RNPVGUYdkRpZfzCGTukWTI6LbrjRVeUcvCQS9Z06iOkdwjGZYdAzhsemOAzL5d6BLJsEbLPTr2EdSo4pEsWYtNpPMoOBRF4fvf/z4NDQ3s2bOHTz75hNraWh588EE6O0fWP0/SBw4P10kQ4hHAorGidO2TY/U4nS4aPa5+epazBYWiwPxbxPyn//B2CPkLy+6JZ+maFmqXO1WU/mhleT1Ds9tU8WgQLWiPqc6jcTnJTM5PAeCxj8sAWDE1F8UjP0pzHlU2Rc/BfmO7eO07bQ6vkxWvHCzoLbyFG8/2qLFG+VZY/xC8cZ/o6NdftOcuw7Ijipd4pOWtydwjyRBhd+i/g6/vrHDPl9V7fzfWtMRGKaXmPJLiURTTfBJcDnGVPlmWrElGOOPOFdNjH8GprWJ+qCMcJKFBOo/6h8ViYdq0aSxcuBCz2cxDDz3E2LHyioLEgzqPNu1JwXUdc4dmH2ugudOGZ+xCzyujQTHnOtH1rWavdzizWzzyEZbtyeQLRfB29W449I56H1VwSlTdRx09RK12rWxt8OLR+JwkpqjikcaF0/O8bheqgdll9e3YHE6igYZ2XfRr7Vm6dtsaOO0GMW+V4lHQaOKlvRPqDvX//tpzl5lHkSV9jLCtF8yB0aeLZdJ5JBkibE79N+JobTv3PL+df6wv7eXsrWkd+oPhIzWtvLGrgj3lzbRZgxPIdeeRLFuLWhrUkrWMEjAM+LRDIhkejDkDjBYhqh55X122OLJjkgyMEeo8CvpSjdVq5cc//jGrV6/GYrHwne98h8svv5wnnniC73//+xiNRu69995wjlUSa7j6L2TML8lEUUSb+v092rxXtXThcLow9icUMyEDpl0Gu14Q4s/o00UmUUcdoED25MD3T8wUX+plH3s7j0AIYs0ndLFIo23gZWsul4vXd1Wyu1zkO43LTna3IQbIjXcxd3S6132KM4WT5GhtO2f+cg0/vnQ6q2YW9PuxQ0Vnt4NOmx5u3tJlJys5Tt+gaJ7otLL9maF3HtkGIEBGC7UeYmzVLsjrp81Ze+7SeRRZDEa4Y52Y3/hHMR2IGCiRDABP5xHAazsreM3DgRRnMmC1O6keYueRy+Xi2sc+oa5Nv/CQkxLHwpJMJuen8NbuSr6xYpJX3h9I51FMoOUdBdE4RSIZ9liSoHiROK9wWMUF7oI5kR6VZCBI51FgfvSjH/HXv/6VkpISysrKuPrqq/nyl7/M73//ex566CHKysr47ne/G86xSmKNrIliOv3KoO+SlmB25/m8s6cKgKKMBIwGBYfTRe1AWghrIc2djWKqiUCZY4PLf5l6qfdtzXmUpAZi9yxbax9YYPaJ+g5ueuJT7nl+O502B3OK05lSkOLlPFqY6/QqWQMYl53EN1ZMJDs5jppWK3c9u40nN5b167FDSc+g1V4d1wDi1OcUjsyjU1vh8PsiiLCz0btc0REbIbA+0dxyAJU7+3//qt1impAekuFIBoHBIP5KzhK3D70LXf1sCCCRDAC76jwyKPDPm+dz33mTOG9aHgVp8RSkxXPp7EJg6J1HbVa7WzjKThbBsbWtVt7cXclDqw9xoKqVv6072ut+LVI8in4055HMO5JIBFruEUDxAhmWHatI51FgXnzxRZ566ikuvfRS9uzZw6xZs7Db7ezcubPXyaxEAsAXXoA9/4XT7+rX3U4fm8We8hbe2i3Eo+zkOJxOFxXNXVQ0d5KfFt/HHnoQL0K43SdntQfENNiuH1Mugre/LeaT84UbCTzK1vxkHvXDefSfz07yo//tocvmxGIycPe5E7jj7HGYjQYm5CZjMijYnS4WZPdun6woCt9YMYk7zxnPr985yD/Wl/LwB4e5Zn4xCRZj0GMIFY3tPcSjnmVroItH3W2glVE0lgqhbzDfJzUH4O/LvJeZEiC1AMYv917udMaWhV5730L/xaOmE7D1X2J+9rUhG5JkkIyaJ3KPag/Anpdh/pciPSLJMEdzHiVaTCybkseyKd5l0E9/cpwXt54acueR1hwjzmTgsx+cR0uXjcPVbTy9qYy391RhtTvZdaqZzm6H1++aLFuLARrLxFQ6jyQSwbhzYc3/ifkxZ0Z2LJKBI51HgTl16hTz5s0DYMaMGcTFxXHvvfdK4Ujin+wJcM79EJ/a97YeLFJzj+raxMFrZpKFgsGEQmuP36WWwZVvE9NAndY8SRsFhXN730fLcfJ0HjkdupgUZOZRY3s3P3xVCEeLx2fxztfP4p7lE4kziQPkeLORN+5Zwqt3nk56nP/9xJmM3H/hFIozE6hv7+b5LZHJUWnoKR717LgGYEnW523tsO438Mhc2PPSIB9cvTJtjBMliyAyghqOwaePe29rj6ErBV0t0KJ3RqJyly66BcPHDwnX1dilelijJPIoip7/tf2ZyI5FMiLQnEcmo+9jN627Z81AXL6DoFl1qKYnChEoNd7MvDEZ/OHa0zjw4EryU+NxOF1sP9nodT9ZthYDSOeRROJNwRz9wrYUj2KXEeo8Clo8cjgcWCy6rc5kMpGcnBzgHhLJwDitR6ZPZpKFAtVtVNk8gA+op/Ooux0OvCFuT1ju/z69BnW9mI5dqi/TnEee4lFHvZr1pOjr++DFrSex2p1MK0jl2dsWMS6n9+dqSn6qu5wvEGajgTvPngDAY+uOYbU7+rhH6OklHvlyHpkTQFG/fqxtIpAc4PB7g3twrQxuzGL4bhl8vwru2e7bZdY9RPlHTodwCnU0DHwfWt5RUq640tHdqudIBMPRNWK6+J7BObskoWfaZWJasa1/gqBEMgDsahcKk5/swLxU8Vtb3Ty0V1Ld4lFC7/INRVFYoHZi/bS0p3gknUdRjb1bv6ijRQhIJCMdowmu+iec91MoWRLp0UgGygh1HgV9qcblcnHzzTcTFyeuSnV1dfGVr3yFpCTvzj0vv/xyaEcoGXFkJ8cxKj2B8iYhFGUm6QeTFQNxHsWpoou1Bfa/LkqlMkpg9BnB72P+rWL77En6Mi3zyLNsTStZS8wSPw594HS6eOYT4RC68YwxIXHyXTVvFA9/cJiqli5e2lrOdYtGD3qf/aG388iHeKQoYEkBa7N4PTrUE4JTn+rb1B+FZ66CM++B+bcE9+Cau0xzm5kTxAHrqLlQu9972+42oH+5VANi67/gzfvEfN4McaAw7hyYeEHwZXPa2POmCbGt/DOo3AFZ4wPeDYD2emg6LuaLFvRz8JKwo5W3upxCFNTEbokkDGhlayY/3z1a986a1i6sdofbAduL178OLZWiPD0E5b9a2Vpagm8RaGFJBq/vrGBLWT0w0b1ccx6lSudRdFK5Q5xYJWZJ8Ugi8WTiCvEniV3MqnhkG1niUdC/+DfddBO5ubmkpaWRlpbGDTfcQGFhofu29ieRhIKZo/T3UkZiCJ1HO54T83Ou758DQ1EgbzoYPQ5sk1RnUVu1vqxdFY+CLFnbU9HMiYYOUuJMXDZnVPDjCUCcyciXl4qDtL98dASbY2jdDI09A7N9OY/AOzS7U3XlNBzTHTpH1wh3zZ5+CNLWZu99a+RN772t1ro+3FTu0Oer98DmR+H5a2Hbv4LfR9NJMc0cDwWz1f0GmXtUuV2/rwzLjj7M8frVq86miA5FMvzRfg/8la3lJMeRZDHidMHJBj+/t52NQhQ//C7UHw7JuJo6xe9GWqIf8WisKBPferyRdqteCi3L1qKc4xvEdPQZ0vUqkUiGFya1bC2WYjBCQNC/tk888UQ4xyGReDGzKI139orA7Kwki/uAsqKHlX7doVpe3V7OTy6b7t+27ikendwi5nt2UBsIWte1qj3iCmxqAbSpndaSgnO0HK0Vreqnj0oNabj1FxaO5s8fHuFUYyev7ajgqnlFfd7n07IGEsxGZowanAisOY+0Dnk+M48A4tTyvO4275KuU5/BpPNFCSAIx1iwaM6juB7PIZLikeZGW/4jIeB88lc4+QnU9eOkS/tfJGVDqioyBiselaviUeFpwT+eZGhJyIDWSuhqAsZEejSSYYyjj7I1RVEYk5XEvsoWjte3MyHXRzxB9T593toWknFpzqN0P86jSXnJjMlK5Hh9B+/vr+bS2YW8s6eK0jrxPS7L1qKU4xvFdMziyI5DIpFIQo10Hkkk0YOX8yjJQmGaFpjtre7+9I19vLy9nJe3leMXrYTJ3qWrw2l9iyl9kl4MxacDLtj7iljWT+dRaa048B2bHdr8sASLkdvO0t1H2gmDP6pburj60U1c/Mh6XK7A2/ZFvdpueZQacu7XeaSFZns6j0AvXdOypPrTwlzLPOoZ0p43o/e23aE56ekTzZmWOw2mXw5TLxa322uD34cmHiVkejiPdkEwr1WFGhA/am7wjycZWuLTxbSzMeBmEslgsWlla0b/h38l2YkAlNX7yYWr8RCPOgeR5eZBS4/A7J4oisJlswsBeGrTcW564lPufHYbbVY7Y7OTmJKf4vN+kgjidMCJzWJeikcSiWS44XYeSfFIIok4nuKR2ahQoOYw1LZZaVavUJY3dXKkRggAO081+d9ZXA8hwZyou14GPdDPienuF8VUc5kkBRaPOrsdVLd0cUy9ajouOyng9gPhhtNHk5Zg5mhtO++qLi5/7K/U3T1W+8DL3N7aXcnq/UIs0V5Dn5lHoL8GbdWiE5hG+Wdi2jEQ8UhzHvV4zZN8hJfbhigwu62HoOgraL0vtBO0xCzR8c9gEsuaT/Xe1ukUeVEH34END8OJTWJ5oRSPohatnFCWrUnCjLvbmh/nEcCYLPF7VFbnx51ZvUefH0wjAA/6yjwCuOw04brceryRdYdqsRgN3LNsAm9//azwOI8cNnj/xyjHPgr9vkcC1XtEKbklBfJmRno0EolEElrMIzMwW4pHkqgkI8nChNxk4kwGZhelk5VkITclDpcLLvjDOj48UMO6Q7pzY+fJJv87MxjFwYtGkCVlQTHtclCMwt1Rf1R3kySLx3C5XPy//+3hJ6/v9XL0fP2F7Zz16w/dos7YMIhHKfFmbjxDlMA8vel4wG3r2nTxRsuQ6C9tVjvf/M9OHE4XV542iotnFQB6F51eaM6jphPey09tFQKIp/MoWDeUu2zNx1VopUdZ4FCUrTmdHuJRnphq77/+iEfaCVpiJpjihIAEvUvX7N3w5CXwyFx4/vOw+ofCzWJOhHx58B61aM6jrqZIjkIyAnB3W/OTeQQwVhOP6r2/Iw9Vt3LP89s5snuzvjBEziM986h3tzWN8TnJLFK7rp01MZt3713KfedPJt4cupJvL45vhPW/x/jOt8Oz/+HOoXfFtGRJUA1EJBKJJKbQnEc2mXkkkUQFb3xtCe1WOxlqt7VHvziP+/69g7L6Dr70r0+97O1Ha9tp6bKRGij3qFstaQqleJScIzpnHf0Adv+3l/OoqqWLJ1XhZmFJJhfOLMDpdPHx4Tq6PRw+Y3NCLx4BXLtwNH/68AibjtVz+Z83kJ0cx6M3zO1VsnCiQXfhtFnt5KTE9fuxth5vpNPmYFR6Ar+5ejabS0WpVYs/MUpzB2niUVKOyM+wNkP9EV1ccTlFiZkvQagn1h7d1jy56xM4+CaUrYcj7w9N2VpXEzhV8Ux732kuqIGUrSWK0FgKZkPVbiEeaWVwAFseg+PrwWCGnCmQPVF0CJx4XujcdpLQEwnnkSbIyhDbEUVf3dYAxmSJsrXjPcrW/t//9vLJsVp+HlcK2tsmRM4j7SKDv8wjjcdunE9FUydT8lNC0p00IOp3tNJYiqWoNbyPNRw58KaYTlkV2XFIJBJJONCcRy6HcKoaR0b2Xsw4jxoaGrj++utJTU0lPT2dW2+9lba24E7+XC4XF154IYqi8Oqrr4Z3oJKQEW82kpWsixhzR2fw9teXctuSsSiKbnO3qELI7lMByps8218HmUcUNDOvFtPdL/ZymVS3WN2b/eqdA3TbnZxo6KDT5nAvNxoUijMSQzsmlVHpCZwzSYgWO0428f7+avZX9j4IPuFxhbltgM6jT0vFScSicZkYDYpbyOuzbM0tHuXqoc6nPtXL1iD40jUt86hn2RpAziRYcq8u4gyF80jLO0rIEI4h0B+/oy44R5XL5SEeiavuFMwRU0/nUWsVrP2VmL/493Dnerj6CTj3ASiaP6inIQkzCRliOlSZR82n4DcT4A8z4d3vC7efyyVCH51D251RMrTY1W5r5gDOoxLVCXuqscN9keNwdSubjtVTpNSSrHhY9EPlPOoInHmkkZZgZmpBaviFI/D6PKZ3lIb/8YYTzeVqp1EFJq2M9GgkEokk9GjOIxhR7qN+i0dr1qzh7rvv5uKLL+aSSy7hnnvuYd26deEYmxfXX389e/fuZfXq1bzxxhusW7eOL3/5y0Hd9w9/+MPQHGhIwk6CxcgPLp7Gf79yBlMLUlk4NpPzpgmhZkeg0jVPJ0oonUcAUy4SrbbrD+tBomrZWnWLfpBdVt/Bs5uPc7DaW7xJNBuxmMKn495wunf3pr0VvYWY4x7Oo1arH7GnD7Zo4pFaVqBlVzR12nD6CuzWytYa1ZK6xExd5Di1RRdMIHjxqCuA80jDrAp1/sQjp8P38oGgiUdayRroziOnPbgype52PRPK03kEunhk74YXbxbOq4I5MOf6QQ5cMqQMddna3leEeNl8Ejb9Cf6+DB6aCr8shr8sAsfABGRJ9KOVrRkDZB7lpsSRYDbidAkBCURINcA1Y3ocIFfvg8fOgW1PBT+IzkZ47FxY/f/cizTnUaDMoyHH4/OY3n4scuOIRQ6+JabFC0N/wU4ikUiiAVMcbhvuCMo96tcZ61e+8hVWrFjB888/T319PbW1tTz77LOce+65fO1rXwvXGNm/fz/vvPMOf//731m0aBFLlizhkUce4YUXXqCioiLgfXfs2MHvfvc7/vnPf4ZtfJKhZ96YTN7++ln8544zmF0sXEX7KgK0dPd0HoVaPIpPhUkXiHmXKjyoZWs1qniUoGYyPPzBYT4r875S22oN74nasim5/OOm+Vw0U2QQ7fXxfzrhUZ4wEOdRl83BDjW0fEGJEI8K0uKJNxvotjt7ZWcAuvNI61CXkKGLR4ffF+VqGsGW8/gLzPbEopYI+hKP9r0GP82CrU8G93h90TPvCMSPjTa+YHKPNBHNFK8LX3nTQTFAW5VwHG1Ug7HjUuGqf0CAkhRJFDLUZWtH3hfT2V+AGZ8DcxK0VgqRsu6QmJcMS7TAbHOAbmuKojBOLaU+VN1KS5eNl7aJcP4Lxid4b3xiI1RshzU/C961tv91kRO44Q9QdwTwcB4l+M88GnI8Po8ZHVI86hc7nhXTqZdEdhwSiUQSLhRFHJvDiHIeBZ159Morr/DEE0/wz3/+k5tuusnt5HE6nfzrX//izjvv5LzzzuPSSy8N+SA3bdpEeno68+frpRcrVqzAYDCwefNmrrjiCp/36+jo4LrrruPPf/4z+fn5QT2W1WrFatVLjVpaxMmozWbDZhuYI2Oo0cYZK+MdLPkp4mCzsrnT73M2WlLcSqkjIQtniP83ytQrMe37n/u2zZIGNhsV6lXby+YU8GlZI0dr23liQxkAcSYDVruTO84aG9RrNZjXdemETJrarby5u5K9Fc1e+2jtslPfrgdmN3dY+/0Y28oa6bY7yU62UJRmcd9/Sn4KO042s+NEA8Xp3jlKBmMinjGnjvh0nHmnYQZo8e4iZm+vx9XXmFxOTNZWFMBmTAA/2xtMCRgBR1drr/eBcdOfMeDCteZB7FOvAHOCz30Ei6G5AiPgTMrB4fFYpsQsFGsL9uZKXGklgP/XV2mpxgS4EjKw21VhT7FgypqIUncQ+6ltGA68iQFwLPsRzrQxfp+7JHIE+vwq5mRMgLOz0et9Eha62zEd3yg+J6d/TWRi2TpQTn2K6bmrxBhbayApuN9MiU4s/PZ2dYvvEIMSeJzTClLYW9HCzhONlDd20NHtYHxOEuOSxX26XGbiFY/7t1VhL9uIq3hRn2MwnPzU/d3v2PBHOs//rbuUO8kcPf8/Y3uD+7ghvaMUW3d3wO0lAqViG6aK7biMcdinXx3Vv0ex8JmVDA75Gg9/Ivkam8zxKPZObF1tUf1dFwzB/v+CFo+eeOIJ7rvvPm6++Wav5QaDgVtuuYWDBw/yj3/8IyziUVVVFbm53rZXk8lEZmYmVVX+W5Dfe++9LF68mMsuuyzox/rFL37BT37yk17L33vvPRITw5NLEy5Wr14d6SEMCaWtACbKqht56623fG4zs6qRcer8tkOnqKj1vd1AMThtrDQmYnZ0YDUm88674n+/9YgBMNBWfZzlWXC01uguG7hpgg2jAuOsh3nrrcNBP9ZAX9e6DgATe0418sabb6FVLZxqF8s1Nm/biaViR7/2/d4pBTBSZOni7bffdi9P7hbP/431OzGe2u51n+L6Y3g2jz9a0cj+9ds535xBgs07+2XX5o85eSRwPpDJ0clFiG3e+WgTToPvK9jja04wA6goO8w2j/dLfHc9F5z8BAClvZb9z32f0pwVgZ+4D1I7T3Da8b9Tmr2MZGslE4FjNe3s9XisJd0msoBt69+jMt37ufZ8fXNadrEYaLGb+chjH3MdWRQDpR8+w/iaHQC8f8JIV1Vo39uS0OLr85vXfITTgZaq46z18x0WKvKad3C6o5sOcxarNx8G5Yh73bnxRaR2neLTj96hNvVUgL1IAhHNv707qsV3dUNtjd/fS4DsmirOM1Tx4U4nDVYFUDgtuYWDuz9jOlCp5DKWcq/7lL39MHuL+i6ZPXf/B7i9oTue562ORUAGCi7WrVlNgIq6IWXh8QMUqPPx9mbee+sFOi3ZER1TLDDn+OOMAU6lzmPbR5v73D4aiObPrCQ0yNd4+BOJ1/h8OyQAGz56n+bEI31uH810dHT0vRH9EI+2bdvGD37wA7/rr7zySq666qpgdwfA/fffz69+9auA2+zfv79f+9R47bXXWLNmDdu3b+97Yw8eeOAB7rvvPvftlpYWiouLOf/880lNDVAKE0XYbDZWr17Neeedh9kcRfkBYaKiqZM/7PmYVruBlSvPx+DjyNPw0Q6oE6Uapy05jzljloR8HEbXGtj1HJaMUaxaJbqLvPjkVqit56z5s7hiTiG7nviMT0qFWPDFS84lPzU+6P0P9nV1OF38ft8HdNmcWMbOo6PbwZGadrY2NwJN7u3GjJ/MqrPH+d2PL/775FagnotPn8qqM/SMpfat5ax/dS+dCdmsWuUd2qwccMGJx9y3x8+Yz9jTV2HsfBEOvO617ewpJcxc0EfHlpZy2AUug5mVF13mt4uUsq0Wyp9nVE4a+av0fRo2/wX2gssYh+KwMrNrM1NXPRTkf0DH8P6PMHaWcdrJf+JSy9XGzlzEmNP1xzK2vwCHDjNv8mic88Ryf6+vsqcdjkJKXon7fSXGWwbvb2RCwxoUnLgyxrLs8i/2e7ySoSHQ51c5lQPHHiItzuX1Gocaw9Z/YtjzNwDip69i1UUXea031j8KJ06xcOYEXNNlh6T+Egu/vY2bT8CxAxQW5LNq1Ry/253317NJtOxlVesvqXGOJinOyPevX0bqxq1QAe1JxdDuLR6N797HmAsvDNzBr6MB83ZxP1dKAcbWSs7M74KdkJZg4eKLzg3F0wwJxqf/Ch5xe2dPSMEwQ34uAtLZiOlhkUdacOkPWFW0MMIDCkwsfGYlg0O+xsOfSL7GprL/B42NLI07gGPFjXqeawyiVVv1RdDiUV1dHUVFRX7XFxUVUV9f73e9L775zW/2cjL1ZNy4ceTn51NTU+O13G6309DQ4Lccbc2aNRw9epT09HSv5VdddRVnnXUWH330kc/7xcXFERfXu0252WyOuS+dWBzzQCjMNKIoYHO4aLW5yE724ThJTHfPmtIKIRz/l4W3wp4XUUYvcv/fa1uFzb0wIwmLxcIPLp7OZX/eQH5qPEWZyQMKch/o62oGpuSnsuNkE199fqff7Trsrj7339xp465nt3LxrEKumV/M9pPiCPuMCTle9509WnSR2lvRgslk8n6+iWle+zQm52A0m6F4QS/xyNjdJtYFwi4UcyUuBbMlQG5Ggnhcg60Dg7bPHc/BeiEUKWd8FdY/hFJ/BLOB/rferNUFb0UNzDamFnqPXw1UN3Y19npevV5fq/jfGpKy9PGC+D8Bil3UWSslS0bE5z3W8fn5TRZuBqWrKXyvYWs1vPd9cNogfyaGc+/3fj8BJIlAdlN3S3i+I0cI0fzb61QLsSxmk/8xOuyYmg4BUEQ1+xjN5+YWkZGcADaRFedIGwPtn3jcSUFpPom5dg+MmutjpypV28Q0exIvd83jKp6Hw+8BN5GeGGX/N7VRgyu9BKWpDFPNLozmayI8qCjnsxdFcGzeTEwliwMLiVFENH9mJaFBvsbDn8i8xqLiwbDrOQz2Drj6XzHzvdeTYP93QYtH3d3dAXdqMpno7mc9eE5ODjk5fYcXn3HGGTQ1NbF161bmzZsHCHHI6XSyaJHv+vr777+f2267zWvZzJkz+f3vf88ll8gAv+GE2WggKymOujYr1S1dZCf3Fv/CGpitUTQf7tuvh98C1a0iMDtPdRjNGJXGG19bQnKcKSIdAC+eVcCOk01kJlmYmJvMxLxkJuamMCkvhQ1H6vjTh0eCCsz+z6cn2XCkng1H6pk5Ko02q52UOBNT8r3deRNzU7AYDbR02TnZ0MnoLI/Sz7wZImhO61CgtaEvWtD7AYPptmYNotMagEUdg021Z+58AV69U8znz4Qzvw6b/gwOq2hpnjm278f2pHqPmE69RATDAqTkeW+jvQfba/venxaYrXVa0yg+HSas0MOPS87q3zgl0YP2ndHVIrr9GYwBNx8QW/8lhKOiBXDrat8HN9p7rCM07dcl0Yc7MDtQbVjLKRSnyD7IUsT36hfPKBHr1O/ZuKzR4NmvZMpFcOAN2P9aYPHoxCYxjqJFPLV5IlfFQVr5OsxcT2ZSFIVlgzsw2znuXIzbnkCp6J+TfcThdMKn/xDzC26J2RMoiUQiCRqjxzlnSeirWqKRoMUjgB/+8Id+c3+CrZMbCFOnTmXlypXcfvvtPProo9hsNu6++26uvfZaCgsLASgvL2f58uU89dRTLFy4kPz8fJ+upNGjRzN2bD9PBiVRT16qLh5NL0zrvYEmHhlMeltsRCnXkZo22qw25o7OGLygk6wLU102h7uDTF6KXp42tSBy5Y+3nTWOG04fQ7y598npnnIh0LQF0f0tzqx36ll7SAgg80syerV/tpgMTC1MZefJJjYerWN01mh9ZXIOLLhNtAoHSFDFo4I5oBjB5cCBESOOIMWjVnVwfYlHHt3WKnbA618Xt8+4G1b8WDiNMkqg7iA0lvZPPGqtVgUhBa54DMY9JzoRjTnTe7tgxCOXC7Y8Bp/8VdzuKR4ZDHDl4/D3FaKr2/joKfeQ9BP3d5JLvNc1ITVUOGzwmdpxdNFX/J/UaZ/Bjv65iCWxg5a51/O72ov6o+7ZLFpYMiGbCbmqFV/9ns3I7PF9NP0KIR7tew2W/z//77ETIgOnPnMuu1w51LpSyVFaWGA4wBULrxvYkwoXnaLE3DXuXNj2BErlDiGQyG6WvildCw1HwZICM6VDSyKRjAAW3QHbn4YLfgFjzoj0aIaEoMWjpUuXcvDgwT63CRfPPvssd999N8uXL8dgMHDVVVfx8MMPu9fbbDYOHjwYVhFLEr3kp8azt6KFqmar7w00QSEph8pWK//4uJSdp5rYU97i7vLy+I3zOW9anu/7D4DaVjGWOJOB1IR+6bRhxZdwBJAcL8bYGoTzKDVedyH+57OTACwY6/uE94Lpeew82cQbuyq5duFo75VL7tXFozS1LNaSKFrRV+3iuDOHcYYq6Grqc0xugSneh3joiVaP3FYD//6icD5NvADOe1A/KcgcK8SjhlIY3/dDu9FcR1njxfNYcJvv7ZLU0NVAJ+k7X4C3v6Pf7ikegRAZvrJetAhN8rFeEhuYLGBOEiVBXU2hF4+qdkNbFSRkwNQATS20x+2UzqPhit0hxCOTMYAA0qC3pZ+b7eDSS6bp67qE8ygrU79Q4lRMHM9cQokxDqXhKNTshzyP+7hcQkyydUGFKFs7ljATFzVscM7gcuNGrsqt4Mp5/qMRhhxbF6glwa7i07ErFkzdbVB/GHImR3hwUcpnquto9uchLnZzPyQSiSRoFtwq/kYQQZ/R+ssIGioyMzN57rnn/K4vKSnB5Qrcjamv9ZLYJS9NOHuqW7p8b1AwGxKzYeL5/PytA7y+s6LXJnvKm0MqHlWpY8lPi49IiVp/SY4TXwdt1r5bNdocTvf88Xoh2C7yIx5dMquQX79zkI1H66hp7SLXw4VFUrYQP9prIW2Uvnz+LZx87We85VzE3Yb/9a9sLS4l8Haa86ijTkwzx8GVj3lfTc5Q3UaNpX0/rieaeJQ3I/B2acViWntAP7HypKUS3vmu9zIPx5wXlkS9FE8SuySkC/HowJuQMwXMCeK9mVrY932dTnjvB0I4Pee7vddrDrf00UKo8ocsWxv22NXvbrMxwG9Sg/69t6xYgTyP71T1e9bkkVnX6Ezg3Ee28kziLJbwKYc+epbcS/4f6YkW2PuKcHde+Bvx/nN0Q1Iuh7qzgRpsiflghYvGR9nvpHbBQjFAQjrNiWPIaj8M5dukeOSLlgo4oHbvmz+yTqQkEolkJBG093bcuHH9DsSWSIYKrWuZX/EoKRu+dYjuVX/gwwMifP37q6by/n1L+eZ5kwAob+oM6Zi0sXiWrEUzmvMomLI1m8NbiI0zGZg5Kt3ntsWZicwpTsfpgrd3V/XeIH8mjF/mtehw8ec4q/uPfOZUD9KDEY+6NPHIf9may+XiQL0ufGFOgmuf88qpAvRStQY/4pHdT75b9V4xze9DPCqYDUaLOKn3KBFRBwlvfEM858LTxB+KuI9k+KIJN+/9AJ79HPzrIvjDLJG71Rd7/guf/Bk++rlwofXEnZvVR5txWbY27AmqbK3B4zupZ2mttff37GfOyViMBl7pEpmUjr3/47QHV/OTp96CF2+GrmbaP/ydO++I0adzolG8T7NyRLxAvD24Li9Dhpp3RHwaKAYaE9UOpOVbIzakqGbrk+BywOjF3q4ziUQikQwrghaPysrKcDgc4RyLRDJg8lJFYFmVP/EIwGBkc2k9bVY72clx3LpkLBNyUyjKTACgvLGTyuZOqpoD7KMfHKpuA4R4EgukaM6jIMrWuu3e3wWnjU7HYvL/dXLJbOGe8OX46kmXzcFj60TZRItL/O9c/ck8ChCY/dGhWj735D4cqKV7l/8Fcqf23tDtPCrrva72EPxqDLz/497rqoJ0HpnjYdR8MX9io9cqZc+LcOgdIS5d9hcRbnzvXsidEnifktjm3O/D+OUw+gwhFJqTRMC1drK643n44EEhLnridMLHD+m3fX1W2lWXna/SR09k2dqwRxOPzEGWrdHeQ0h0Z8ulUPW51ziYdxFz73qCHf/vPC6/9lYcipGphpOMoZLFh3/rvltrcyOuE2p3ttFnuB2rCamqoBlt7zk174gE0TG0SROP1LI7iQcOG2x7UsyPsPINiUQiGWnI1D/JsCDP7Tzyk3mksnqfaJ2+YmouBvXK66h0IVAcrW3jkkfWc9mf19Ntd/rdR7DsPtUEwKyiPjJ4ooTBOI8WlgTOaLloZgGKAp8db/Tr8HK5XLy2s4Llv1vLi1uF26IZUWIWnHjUt/PoSHUbbSTyu5RvwzVPw/TLfW/o6TzqebJ+aovo1Fb6sfdyu1XkJEHf4hHowXrHN7kXxdsaMb73gLhx9nfFFVyj2bukTzI8mbwSvvgy3PIO3LFOdK8C4Uyzd8OrX4GPf6uXRoJ4b37wY6jdry/THBOeaE6ipD6cR+6ytcaBPgtJlKOVHJv8OY+cDm/R3NN55HLpDs/4VPJnnM3kO58jp2A0iRYTZ82ahHGsyL58dE4ZSwy73XfNddbiKNsgbow+nZMNQjxKycwVy8JdKtnRAK/d4/V9GxCtbE0tF25MUsWjqt3+nacjlYNvQ2ulcDZOld2MJRKJZDjTrxTfd999l7S0wCfCl14aIIxTIgkT+WrmUWVzJ06nyy0M9eTDg6JkzTPbqDBd3LemVReeSuvamZzfR3ZOAFwuF7tOCcEjZsSjuOADs7sd3uLawrGBHQ35afEsLMlkc2kDb+6q4MtLvVOoj9W28c0Xd7L9RJPYPjWe76yczMP/E1e5DV1N8MRFcM2T/k+APU5q/FHfLg76X7Yu5DvTlvvcpqmjm/T00YAiMmjaayE5V99AOxHvbve+Y90hcNpFmUNaEMGvoxcDv4Pj6gmVy8XsE0+gdDWLjnNnfqPvfUiGL1kTxLT+KNTs1ZfbPJyR6x+CDX/0vp8vobUjSOeR6rKgu1WcIAfKR5LEJA7VeeRXPGo+KXKJNDrq9Q5jdqtww4H/bLlpl8KxD5ly7ClQumkxpGHARbKzBYOtDbsxEWfODE40rAEgM1vtitsZZsFy7a+FO2bbk/DjIC5G9HAedVhycSVkoHQ2CgF31NwwDjbG2PaUmM69EUxxgbeVSCQSSUzTL/HopptuCrheURRZ2iaJCGMyk0iJM9HUYePl7eV8zkfXFofTRbmaszBjlC7o5KfGY1DA6WEwOVjdOijxqLypk/r2bkwGhakFfbSOjxJS4kQHNavdSbfdGbAMzTMwe2x2EvPGZPS5/0tmF7K5tIHXd1b2Eo8eXXuU7SeaSLQY+crZ47n9rHEkWIw88n42h9tGMdFQDsfXw9EPYdbVvh8giMDsRlU8qm2z4nC6euV+PPTeQR5ec4SfXzGT69KKofkE1B32Ix61ee/cs2QtmODX4oUijLXpOLRUoBz5kPyWHbiMFpTL/wrG6OnQJ4kAWepnpP4IVGzXl1s9smH2vSamK34Me1+Fyh2+OxNqpUd9iUfx6eI96XKKMqKU/AENXRK92Prqtla9T0yzJwlB3OXQOwB6vvcsfr5np1wMb9wHViHQpE46i66WWqjYDMDm7rHc/cuP6LQ5UBTIydXEowZY/wfRBfP8B8HguyvogGk60b/tNQefloenKLgK5qAc+1CUrknxSKdWddxOWhnZcUgkEokk7PSrbK2qqgqn0+n3TwpHkkiRYDFy9zJxpf7X7xygtat3x7CG9m6camOrrCT9irrJaHAHbmscqmod1Hh2q66jyfkpxJtDfBAcJpLi9HG291G6polHXzqzhA/uO5sES9/P8cIZ+RgNCrvLm9l9qpnnt5ygRX2dTqmi3oOXzeCe5RPd+0tPTmBV9y9oTVVdGIGuTruzOPyLdQ0dQjxyOF3Ut3mXOL6y/RQPrzkCwJoDNXroZ80+751o4pG1x3vE3Wltuv8xehKfKsLCAfb9z12u5jzr2zJwVKKLRw1HRYcnDe1957CLlugAUy8Vjjfw4zwKsmzNYNDdR7Lj2rBE67Zm8tdtrUotNRs1T39PaaVr2nvPkuLdndKT5FwYs1i/PWYx8YX6d+I+8zQaO8T3fmFaAuZkLfOoUeTIffJn2PJ4f59W3yR6lFY7gzhW1X5rPLpcugpUwahc5h65cbmgXTi6vS6ySCQSiWRYIjOPJMOGm88sYUxWIjWtVr72/Hb3QbJGrVqWlplo6XXVdVRGgtftg9WDE492ukvW0ge1n6HEZDSQoApdfeUeaZlQFqPBb4lgT7KS4zhzgjhRuORP63ng5d38a0MZgDukvOfrkJVkwYaJ6jS105iHq8LmcLLxSB1dNvVEQDtpjvdfJqg5j8A7XL2mtYsfvqqXBhkN6CKQZ8YM6CfV3W3eeUjVQYZlezLmTDH94KcoXc00JYzBecbXgr+/ZPiSqYpH7bVwbK2+XDuBrz8CDqsI1s4YqzskBlO2BnrHtcqdIghXMqzos2ytWhWP8mdCUo6Y1wLX3d+xfbhpp3rEF4xZDDl62P8tX/gCj984n8/NK+KHF0/VxUqXE1C/Tz/4KTSdDPIZBYklWZ9vKe97+8qdYurxmXEVLRAzh1fLz4aGtRXs6m+pFI8kEolk2CPFI8mwIc5k5JEvnEa82cBHB2v58et7cXmc3NepTpOclN41+YXp3qLFoUGKR4fV+08rjI2SNQ0tNLuv3COt9CFgxx4fXDKrwOv2RwdrcLlcVDQL51FBmrcDLFN1iDW7RHC2Vkpgdzi585ltXPf3zfxtrdoZSC2p+OE7J7j9qc/YdLTe6/UH3XkEeHXV+9XbB70Es+ZOm4d45JE3A7p45LR7Z4No2+X3QzwarYZm20R4bGnOCjDIcjUJ4gQ9Wc1ma/YoudFKh9xi5TThAtFE00CB2Yl9OI9Ad2i8+hVY82C/hy2Jbmxu8cjPd3eVL/Goh/MoQGkwIHKPTAmQUgB5MyFnsliuGDCOXsh50/L47dWzWTmjQHSeNPfoSGprh7e+1btZwWDwLDP21UXTk6Nr4PC7oBhh+hXuxa6xZ4vPUHsNHPkgdGOLZbT3hjkJLEmRHYtEIpFIwk7QZ35paWm899574RyLRDJoZhWl84fPn4aiwDOfnOAf60vd6zTnkS/xaJQqHplVK/+Jhg46uvsOjvZHoypS5Pp4rGhGC83u03mkurr6Kx6dPz0fi8d9kuPNNHfa6LKJ/eX1KB/MShb/v0anenLR1YTL5eL+l3fz/n7ROe94gxpcrQZmb66wsXpfNV94/BMu+dN6/rej3F1m5+k8qladRx8fruWlbaK7270rJgHQ3GnXHUTV+0RgrIZ2Ig5gVU9IWqvFQbRigJypwf9DNPEIcBnMVKbND/6+kuFP+pjey7QT+J5ON628pmfmkcOmO0aCcR7lepRMat2xJMMGu/u724fzqKtZF1byZuhljm7xqO+OlgCkFsIda+GWd0V2W/EiGLMEFt7hW3hK8Cgpy5oIBjMcegf2vRr08+oTzzLjxuOBt/3gp2K68HbvEmKjGWZ9XszveCZ0Y4tl2rSStZzIjkMikUgkQ0LQZ34/+9nPuPPOO7n66qtpaJBZCJLoZeWMfL6/SpzA/+yt/by7twoQIckA2ck+xCO1XGrGqDSyky24XHC4uq3XdsHSpGY6pCeYB7yPSKB3XAtsybepZWtmU3AlaxppCWa+dcEk4s3iq6e21Uql6gDKTLL0yofSsqnqHKp41NnEL94+wH+3nnJv09ZlF1eo1ZODVlciE3KTiTcb2FPewtdf2MHSX3/IM58cp6lTf17VLVaaOrr51ouiPOGG00ezdJI4WWrptImyIWOcuAreVKYPylM86tZO5NWr9ZnjwdLjKnogknNEMC3gGncuNpO8civxQHNsgIc4pDmPVKeb5pDTnEdl6+Hh02DzY+K25pRTPPKMAnH+g3DBL8R8MOU9kpjCrjqPjL6cR9p7Kq1YONA0p5oWiBys8wjEezdDFT/NCfClN+HCX/re1vN9WXImnPVNMf/Wd0LXhc1LPCrzv52tUy9ZW3xP7/WnXS+mB9/p3XFzJKLlHSXJkjWJRCIZCQQtHt11113s2rWL+vp6pk2bxuuvvx7OcUkkg+LWJWO54fTRuFzw9Re2s+tUE3UBnEcrp+dz4Yx87lk+0d0dbduJgR+0aiJFemJstbpOU8Wu5s4+xCOHnnnUX768dDwv3ymyfmpbu9zlYz1L1kAvW6u1iXUVVZU8tk6UqS2bIg5WW7vsInNBbSHdSgLfXTmFjfcv55vnTSI7OY7K5i5+8OoeryqIqpYuvvfKbqpbrIzLSeL7q6Z5P3+jCXLVrA7tpMrp8D6Z0ZxHPU/k+8OMzwEKzvm39v++kuHNglthwnlw/X9h8d1imeb+0Lr7aaHrmnhUuQMajsHb34a9r+h5RwmZ/kOOPYlLgZlqR8PWKrB3B95eElMEDMwu3yqm2nuqeJGYfvo4rPmZLlz2lXnUXxI9xKO0IjjrPuFAaq+B1f8vNI/hKR6d2gKH3vVdFld3SOQvJWQIB1VP8qZDXJr4vQl1LlO043LBh7+Aj3+nL2uTYdkSiUQykujXmd/YsWNZs2YNP/jBD7jyyiuZNWsWc+fO9fqTSKIBRVH48SXTOXtSDl02J7f86zN2qSHWOT6cR1nJcfz1hnmcOzmXpROF/XrNgZoBPbbT6aJJLVtLT4wt51GaOl7NOeUPrWzNYhpYbJom4NW3d3OyUeT9+BKPtLK1qm6xrrlRlE98b9UUbjh9NKCW2KknNU6XQjvxzBuTQWaSha8tn8iG+8+lqEcQN8C7e6p4a3cVJoPCHz4/hwSL0S0etVnt4iTLXbqmikOdTbhDXUG/8uw+ke9H3pHG0m/Dd0txjV/e//tKhjeFp8EN/4WJ54kTVhAnwR0N0FohbmtlZr5cRS/fAQffFvPBlKxpJGUL1x0u/XEkwwLNedSrbM3lgh3Pi/mxZ4vp7GvhHNEFknW/hvUPiflgnEf9wbNsLa0YTHFwyR/F7e1Ph8bh4ykela6D566B3S+K2y4X7HkZXrxZTEF8rhQ/ztq0IjFtOeV7/XCl7jCs/aUaaK7msGkljUmybE0ikUhGAv1OZj1+/Dgvv/wyGRkZXHbZZZhMMtxVEp2YjAb+dN1pXP3oJg5UtboDs7NTAruBlk3N5Wdv7WfzsQbarHZ3KVewtHXbUY/P3WJErJAepPOo2z6wwGyNzCQLBgWcLthbLoSffF/ikeo8Ku8SIlKa0s4XFhbz5aXj2VIqynHarHa3G6ONeMbnprodSyCC1Kfkp3KqsdNr361qrtO9501yd8VL9Xi9WrrsZPbsuOZZsgYeZWua82gA4pHWHt0mu/dIAqCdsFtb9Pdj+hjdBdKzy2BSrnBuaKHXSUGEZWsoijhBbjgKzacgo2RQQ5dED3aHn7K1U59CzV4RdD1bzfVRFDjnfkjJhzfuhTaRM9dn5lF/SejhPAJRvhafLjK8GssG5ur0xOqjCcaGP4qy4XcegBMbvdflBsiuSysS/6vmESYelXp0fTz2Ecy90cN5lBeRIUkkEolkaOnXWfHjjz/ON7/5TVasWMHevXvJyZFXGiTRTUq8ma+eO4GvPb/dvSwnubdI4cm47CRKshIpq+9g/eE6Vs7I79djNquunXizoVeGT7TT37K1gYpHRoNCVnIcta1WdpULR1hBWm93kCYClbabIQ7SaOeWM8cCnvlMunjUSiLzx/R2YEzMS3YHbKfEm9zd5OaPyeArZ493b2c2GkiyGGnvdtDSafMQj1RxqKd4ZG0DuxXq1EyQgYhHEkkwuMWj1t4la6BnImlc8Sh88BOPluOZ9AtP8UgybLCr4f9mQw9Xzaf/ENMZV/Z2sc27WYiR//2SKBHu73upLzz3p4lHAJnjoGIbNJSGXjwyJQgR9jHVZWW0eHfPDCgejRLTkfbZOPaR9/zcG3XnkQzMlkgkkhFB0Gd+K1eu5Lvf/S5/+tOfePnll6VwJIkZFpR4H+j6yjzyRFEUlk0RV9E+Otj/0jU9LDu28o5AL7Nr6gicc2IL1LEnSLTywf2VQvjxVbaWmxJHYVo8zS4RJJ2kWJmYLbZLifcI91bL1rSw7J5M9Fg2qyiNtAQzKfEmfv/5ORh7nER5CWiaGNRQKoSiXs6jNpGR4bQL54fniY9EEko0h1GXh/PI84S6p/Modyp84d+Qqp7o9tcZkFYsps0jLNdlmGNTnUcmT+G/4ZhewrXAT/balFVw81uw8Msw+7rQDsotVimQ4pEzlDlWH99gcLn0rLDr/gNf2SCED42ZV8M92yF9tL7Ms+tgT7Tv+eYRFCjvdEDpx/rtYx+JLqRtMjBbIpFIRhJBO48cDge7du2iqEieHElii/y0eArS4t1dvbKT+xZ1Th+XyT83lLLjZFOvdS9sOcG2E4383+UzfWb+NHXGZt4R6IJXsM6juAFmHgHkpsaxr1K/7atszWQ08Jcb5nHlnz0OWjubIDnHLR5Z7U5sHc2YEWHZuam99zMpT8/oKExL4FdXzcJkMPh8zNQEMxXNXeJ/kJQjTrrbqqH2AHT26DTZ3a67QPJm+M/IkEgGi6fzqNrjPafhKR4pRkjOFyWRX3wFNj4MC27v3+O5T5BHmLtimKM5j0yeovna34DLIcLZR83zf+eieeIv1GiZRykFYPL4fc5QxaPG0sHtv7sdd1ZdyVmiI+byH4qQ55KzYLQaDD52KWx/RsznTPG/v5EorFbsAGuzyF5zOcSFlOo9eimjDMyWSCSSEUHQZ36rV6+WwpEkZhmXo7dAzwiiA5qWgXO4po3ObofXuvtf3s1/PjvF81tO+Lyv5jyKtbwj8AjM7jPzaHBla9A7uLw4w3eL+znF6Tz/5cV0GdXXsKsJgCSPLKrudtEBrc2VQK4PZ9n4HN155AKKMhJ9Ckfgo3TPM/eoV9manxN5iSTUaDkzXU1Qc0DM5/sRjxLS9c5qOZPhsj/rnQODZaSW5gxz7G7nkSoe1R2BXS+I+XMfiMygMsaIac4k7+Vu59EgxSOtZE0xglktj45LgaXf0oUjgGmX6/OBSvNGorBa+pGYjj0LxohuqRz7SAZmSyQSyQhj4Gd+EkkMMTFXd54YemY9+CAvNY6clDgcThf71LIq0B03AJ8db/R1V7fwEovOI7dw0me3tcEFZoN3+eD4nCSKM32LRwCLxmURn6x2i+pqdj92llm4vLrbxbJWEsnz4TxKsOjZU/VqcLo//ItHe32XrfkqIZJIQo0mHtk6wGEFSzKkl+jrzfG9tx0MI/EEeQSgdVszaeLi2l+J1vSTLgzsOgonY86Ea56GSx/xXh4q55EmHsWlBHaHTjwPPvcEfPmjwPvTSkFbKkTpli8cNrB1+V7X1QL/vQWe+7zYLhY4poZljztH/AEceFN8H4F0HkkkEskIQYpHkhHBXeeMJyvJwrULioPaXlEUZo0SV/J3n2pyL6/zEB4OeIhKnjSreUGxnHkU7sBs8BaPggolT1CdFZ1NYrrxT3xq/BJfMH5Ae4sQ8lpdiT6dRwDZqtNpycTAV0h7i0equ6N6L7Sr4pFBFQatbR7hxdJ5JAkj8T0Eodxpuruor20Hglaa03RSZMZIhgV2z7y62oN61tE590duUIoC0y71zhwCEZgN4j04GJHFUzzqixlXQuFpgbdJLQQUIeJ21Pne5qVb4dfjhMDkSfMp+OdK2PMSHHoHjm/oe0yRxtYJJz4R82PPhvHnivmT6rK4VCFmSyQSiWTYI8UjyYggNzWeLd9fwS+vmhX0fWYWCbFC6wYGUNOii0eHa9q8xCQNd2B2DDqPNMGrqdOGK8AJoyYeWUwDz/hJ9ig7u3BGQd930LpJdTWJq6Crf4gBF3OVw7Q1C1Gny5jkVc7myWt3n8mvPzeLL54+JuDDaOJRi6+ytfrDYl7rxNNwTJw8KAbICdCdJ0pwOF3UtHbhcEoxIOYwxYmOUBqBnG6hcB6ljwZjHNjaof7I4PcniQo055HRoMBHvwRcMOViKJwT0XH5JCVfdEVzOaDJd5l4UGhh2cGIR8FgNIt8JvDtzGs6Cfv+Jz47e1+BPy2El26DU1vh8eVQs1ff9tB7oRlTODm5WQhlKYWQPVHkQSV7XPCZc73M+5NIJJIRghSPJCOGnl21+mJWkeY88hCPWr3Fok+O9ShjQi9bS4tB8UgTThxOF21Wu9/tbCHIPJroEWI9vTCIk92EdDGt2S8s/y4xhlSlg642tYQwwMlBYXoC18wv9hly7kkv51H2JDCYRLlc+TaxbPTpYnpys5hmjhchrFHMrlNNzPnpeyz82Qdc/ejGIX3spo5uNhyp45/rS3ng5V1c9/gn/G/HCOpUFCo8RaFATrdAnaKCxRQHxQvFfOnawe9PEhVomUfJzYeFsAGRdR0FQlEgo0TMD6Z0rT/Oo2DRMsG2Pw2NZd7la9r/FeDAW1CnOrz+vgzaqsTn84Kfi/WH3w3dmMLFsY/EdNzZ4jVRFL10zRQPS74RoYFJJBKJZKgJutuaRDLSmKGWrR2pbaPdaicpzkRNq3eGwa5TzVw8q9Brmdt5FINla/FmAxaTgW67k+ZOGynxvgUwLfOoLyEmEHOK03nsi/MYn5uMEsxVS815tP4hIRwZLeDoJoUObB3iyrIhIc3//YMkrWfpnilOCEg1+8QVcGMcFMwW67rbxDQGStY+PlxHa5cQBLedaMLhdPVbUB0Ix+vbueAP6+iyeWeD7DjZxOLx2V7li5I+iEvRy2TyZvZef+1zsOvfsOz7oXm8krOg7GPRonvBbaHZpySiaN3W8rb/EXDB1Esh38d7KVrIHAu1+wcXmh0O8WjqJXDqU/jsn+LPkiwcOXnToGy9vp12gUFj3LlwzZNifvWPhKuv/ihkjQ/d2EKNlnc09mx92ezPi6D1M78uHGISiUQiGRFI55FE4ofclHgK0uJxuWBvhRAnPMvWACqbewdiNneqmUcx6DxSFIV01XnTFCA0u9suOtANxnkEcP70fK9OaAHRnEcup3BgnP8zQDiPtBBtU2L6oMYDkBrvI/fJs0QoZ7J3Z6ue66OUqh7v1fZu/86yUPL+/hq6bE4yEs2cPy2Pry2bwNSCVDq6HTyy5vCQjGHY4Hnym+fDXTTlIrjmqd7vz4Ey9iwxLVsvc4+GCXanixKlkpRjb4oFZ383sgPqC3dodtnA9xEO8WjxPSLku/A0cSGjuw3KP4NtT4lyZg2n+juSPwtW/hKuf1F8PuPTYPQZYt3RNaEbV6jpbITKHWJ+nId4NH4ZPFAO50SoQ59EIpFIIoIUjySSAGjuo11qaLbmPJqYKwSPqubOXvfRnUexJx6Bj8wfH9g059EgxaN+oTmPAC7/qzujI5V2zHbhAIpPTu91t/7Sq2wNvMWhvBm9w0H7CliNAqpbvMUjzYUUbjYdFaWdd5w9nsdunM83z5/Mjy4Wwsdzm0/Q2hUj3YaiAU0UyigJ7YmwP0bNF5kzHXWiXFQS89gdLr5sfAMFF0xaGf2uyUxVPIo255EW8v3lj+B7FXDXZvjcP2Hpt4Uraeol3tsvvB1Ov1PkJWloLe/Lt4ZuXKGmbL24YJM9SQ0K9yAuWWYdSSQSyQhDikcSSQDcHdfU0GzNeTSrKB3w7TyK5cwj0B1TTQHFo8FnHvWbceeIk+dzfwBTL3afSKconaQg2gUnpGQM+mG0183LeZXncYKVN837JEQxQvGiQT9uuKnukdfVFmbxqLK5k20nGtlSKsSj08dludedMT6L/NR47E4Xh6rbwjqOYYX2vssbohN+k0XP9yr7eGgeUxJeHFauMqplVWd+I6JDCQq3eHQs8HaBcAdmhyBI3hdGM+ROgRlXwbIfwOefgfMe9N4m00dZ2qh5YhrN4pFWsqZlHEkkEolkRCPFI4kkADN7hGZrgdlzisXy6pYunB6dq1wuF83ubmuxl3kEkKZ1XPNTtuZ0utwde8zGIbzqWDQfvnsczv62uK2JR3SQprQDkJyePeiHyU4SGTz17Va945yX82i6t/OocM7QuEAGSU0P51GbNbyOny8/tZUr/7KRli47yXEmZvQIRZ+YJ/6HR2pawzqOYUVippjmB981ctBopWul64buMSVhI9dZT5xiw2WM14XBaMazbC2Y0sk3vwVPXQ52D7E8HM6jvkgrEl04NXxlGo2aK6Z1h9yl11GHFpbtmXckkUgkkhGLFI8kkgDMVJ1Hx+raae2yucvWpo9KQ1FE+VZ9e7d7+/r2brodThQFspJiVTzyUbblgc2jq4x5EIHZA8LTIq9eRTYpTrIVcWU5JbNg0A+RnSJety6bk/Zuke1ESoHokJOQAQVzhF1fo2TJoB8z3DidLrfwmZ0snl9LmJ1HmlsPRDc9Uw+X2sRccSInnUf94Iyvwel3wfxbhu4xS5aKadl6745SkpjD5XKR4xJOQGdqYWyUHKWPFu5Oeye0VvneprsDDr8PHQ3w6eNw7EM49ZnHevU7ZijFI6MZUtWObOYkSM7rvU1SNqSPEfMV24dubMHSWg31hwEFSs6M9GgkEolEEgVI8UgiCUBWchyj0hMA0Vmtrk0IRaPSE8hJFg4VzyDi0jrhgClMSyDebBzi0YYGvWyt2+f6brt+AjmkmUc9MSfgULwbRk4oKRn0bhMtJpIs4rWr1Uq9FAVuflPkWiRmgiVJv0PRwkE/Zripb+/G4XRhUKAkS4w9nGVrnu8RgKvmFvXaRnMeHa6R4lHQ5E6Blb+A5Jyhe8zCOcJp19UE1buH7nElIcfudFGgCPHIlTIqwqMJEqNZuHgAGv3kHq37NTx7Ffx9ub6scqeYttXopVdJueEbpy/SR4tp5jj/Ql00l66d2CimeTPEhROJRCKRjHikeCSR9MEstXTto4M1OJwut6uoIC0egCqPcqDSWiEejctJ6r2jGCFDFY9qe2TkaGhh2TDEmUc9URTsZr0UqkVJJS05ISS71trHe/0PEjMhRb167JmdEQNXZLWw7OzkOHc5ZTgDszXhUVFg0wPLuHq+D/FIDZ0/Ui3L1qIaoxnGLBbzpTL3KJZxOF0UauJRWoyIRyDEF/Cfe7T+973XV+4UTrlX7oD2GsiZKroRDiWaqyhrnP9t3OLRtvCPp78c3ySmY86I7DgkEolEEjVI8Ugi6QMt9+jtPcIyn5Mch8loIF8Tjzw6rpXWC/FobHbsikcT84S1f3+lflLf3GHjGy9s59+fnnCHZRsNCkZDZMseHBa9DMGRkBVgy/7hUzzyxGCEe7bD17bFxBVZTTzKS40nJV64tcKZeaTlZaUlmClIS0DxcdVdK1uraO6SHdeinRI190iGZsc0NofT7TxSUmNJPOqj41ru9N7LKnfCxofh6BrRMfDqJ8CSGL4x+qJIFYYCuVM1d1J7XfjH019OqOLRaCkeSSQSiURg6nsTiWRkM2tUOgCnGoVItKBEhNYWpAmXi2fHNc15pJUGxSKa0+pQdStdNgcmg8Ldz2/j48N1bDpWz+LxIpR6SMOy/eCw6A6g+IzB5x1pZKsliXVtfsQj0K+GxwDVapfAvNQ4kuNU8SicziNVPMoIEBqflmgmNyWOmlYrG4/Wc/60PJ8ikyQK0EKzj28Ehx2M8tAhFrE79LI1Q3pvN2DUooVmNx33vd7g4zpo3UFYo3Y8u/BXkDs1PGMLxPxbRWZY1gT/22iCVnf70IwpWLpaoHqPmJfikUQikUhUpPNIIukDLTRb4+xJIm9Edx71zjwaG8Nla/mp8WQnx+FwuthXSse/bAAAbpNJREFU2cIv3j7Ax4fFVdHqFqu73CmiJWsq8SmZ7vmEdB+BpAOkT+dRjKE5j3I9nEfhDMxu7BBla1r4uj8m5wv30R1Pb+X37x8O23gkgyR/luhuaG2Bqp2RHo1kgIjMowYAlFgqW9PCpttqfK/3cu0owg3qcoLTDtOvhLk3hn2IPlEUyJnkW9zSMKvHCrYoE49ObhH/w4wSSA3dhRmJRCKRxDaRP/uTSKKctEQzY7J0u/tSVTzSMo/2VbZQ09KF0+miTC1bGxfDZWuKorjdR796+wD/WC9KBbQSNe05xg11pzUfmJPS9RtJoQsR1sLQh4t4pHUJzEuJJ9ldthZO55EQj7T8LH/cd94k5hSnA7DxSBSWbUgEBiOMUbsKlq4b+sf/5FF48hJ47Bz4VQls/NPQj2EYYHd6lK2lxZDzKEm4Xemo773O5fIWj0bNg6IFYj6jBC75Y3R3lXM7jzoiO46eaGHZoxdHdhwSiUQiiSoif/YnkcQAmvtoSn6K23Gk5RodqGpl8S/XcMuTn2K1OzEbFXeHtlhlhvp8N5eKq9T3LJvgDjg+qnbHigbnkVdwdQg76bidR4HK1mIIz7K1lCgpWwM4bXQGP7x4GuBd/imJQrTStZ6h2XtfhTU/E+Vs4cDlgvd+IESriu3Q2Qhb/xWexxrmOLrayVTU7oaphZEdTH/QLgy01/Ze19UMTjUz7YaX4Op/weKvwfhl8PlnID61932iCbfzKMrEIxmWLZFIJBIfRMHZn0QS/Zw3TdjmPVuOzxyVxl+un8v8MRnYnS4+OigObIszEzFFg7AyCGZ5lOqdPy2Pb6yYRHGmuEJ6tDaKxKN4j5JC7ep0CMgeZs4jLbspJyWOlHjhBmoNY2B2oxaY3YfzCHQHX7Xq3pNEKSWq8+jkFiHogJi+8Q3RKn3n8+F5XFuHLg5c8HMxrT8CVtmlr7+4WsoB6HDFQXx6ZAfTH9ziUZ3ooOaJ5jqKS4UJKyC9GMYuhS++Avkzh3acA8Giikfd7frnKtLYrVC+VcxL55FEIpFIPIiCsz+JJPq5dHYhG+9fxm1njXUvUxSFVTML+O+di3nnG2fxxdPHUJAWzzXziyM40tCwoCST7GQLs4rSeOjzczAYFEar4tExNdcpGgKzvU6AQlm2lhJEYHYMUd8mysgykyxDFJitla0Fdh4B5KbEYVBEHstw+X8PS7Ing2KA7lZoqxbL2muFEwjg49+CQxV5rK1w5P3eJ/oDoatFTBUjnH4XpI4CXFC5a/D7HmEoLRUAVCnZ0V3K1ZNEtZOmywFdTd7rNDdSYui6bQ4pWtmayyFEm2igfBs4rOI3NWt8pEcjkUgkkihCikcSSRAoikJhuu+W4wBT8lN58PIZbHpgOV85O/YPttISzWy8fzkv37nYLTYUZ4hSvGO1mngUBV8fniUJyaEvW6trsw4LN0x9uzgpyUqKc2cetYY180grW+vbeWQyGshNEe4jWboWxZgskKYK4/VHxbTOI+S8sQx2/VvMv3AdPHMVbHty8I+rOYziUoTgUXiauF25Y/D7HmEorZUA1CmZfWwZZZgs+oWCnqVrHarzKIQXD4YUs0c+YrSUrrnzjs6ILZFRIpFIJGEnCs7+JBJJNGIxGbzK77SyNS1o2RIFgdnhKlvLShaOGZvDRXNn+Mq7hoKObjtdNuEAyUq2uLuttQ5Ft7UgnEegdy6U4lGUo7kQGjTx6JCYGsR7inW/FdlHWqj2tqcG/5hu8UgVigvmiGnF9sHve4Rh6BDdyhqUjAiPZABo3+89xSPtdqyKR0YTGNXvye4o6bhWvU9MR82L7DgkEolEEnVEwdmfRCKJBTTxSMMSFc4jT/EodCcPcSYj6aprpro1tgUNrWQtzmQg0WIkJU48r6EJzO7beQRQmK6JR51hG5MkBGSq4pHmPKo/Iqan3QCJ2dBYCh//Tt8+FKHMVrVsLS5FTAvniGnFjsHve4RhUF06TYb0yA5kIHjmHnmi3U6K0bI1ALP62xotziOtLDWWOvJJJBKJZEgwRXoAEokkNijO8BaPoqNsTRWPTAlgSQ7prkuyktjR0cTBqlam5Ed5x54A1LcL8SgryYKiKO6ytU6bA7vDOeBw9798dIQXtpzkudsXUaS+N5o7bLy49aQ7VD2YzCOA/FRRElk1RM6jnSeb+P6ruzEaDOQkW8hKiqM4M4EbF5eQGh+c4DUi8ec8KpgthKXVP4S1v9S31/KQBoNn2RrozqP6IyIPKdq7aUURxg7h0mk2DCfnUYyXrYEIze5qGlrnUXM5pBSAwcf3f2uVmIawFFwikUgkw4MoOPuTSCSxQILF6O5CBmCOhrK1jLEiSDd3asizGWaqHef2lDeHdL8DobnTxu9XH6K8qf/OnAYt70h97bQMK9BLEAcynl+/c5ATDR08/clxAFwuF/e8sJ3/e3M/djUnKi0hOCGmIIiytc5uR8jyp17ZXs6e8hZ2nmzi/f01/Puzk/z2vUP859OTIdn/sMXtPDomplrmUdZEWHCrcB+5PEKy1e5eg0JzHmkiUXIOpBYBLqiSodn9wdQphJbmYeU8ivGyNdA7roXLedRaBWt+BrWq2LvnZfj9NNj8qO/t20R5I8n54RmPRCKRSGKWKDj7k0gksUJxZoJ73hIN3dZSC+CrW+CGl0K+a108agn5vvvLXz86yh8/OMxXn92Gq5/tnD07rYHIqopThT9fuUdHalr7zHl6dbsuCpxqEILWC5+eZO0hb1dARlJwzqOCPsrW6tusLPz5+9zxzNag9tcXNWop4ufnF/OLK2eycKwIEK6V3d4C43YeHQNbJzQJ4ZDsSeIEePHXvLdvqRh8+/GeziOQpWsDRBOPWkwxFpgNHuKRn8yjxNBl3g05WtlaOJxHJzbD386Gdb+Gd78nlh18S0wPv9t7e1snWNULJil5oR+PRCKRSGIaKR5JJJKgGe2RexQVZWsA2RMgMfQnQ9NHCafDnormfgs2oeb9/SKDYsfJJl7fVdmv+3qWrWmkqKVZPZ1HpXXtrHhoHXc961+kcblcPLv5uPv2zlNNnGzo4P/e2Ndr2ySLMagx9uU82nWqmdYuO58crQ9qf31R0yJEoqWTcvjCwtEsUsWjzm5HSPY/bEkfLcKx7Z1wfINwGcWl6uUtC26DlEIwidcTRzd0DPI1CyQeyY5rvinfBntf6bXY3CXEozZTDJatJfooWyvfqrvfQtgwYcjRnEehFo8++yf86yJoU8vQytaDrUsPm6/e2/s+WsmaKUEPqZdIJBKJRCVKzv4kEkks4Jl7FDXiUZiYlJeCxWSgtcvO8frIBZker2/nSE2b+/bvVx/ql5jVoIlHyZ7ikShda+nhMDqmZhUdqm7DHw3t3V7rTzV2cvdz22jvdrCwJJMfXTzNvU4JspQwP03PPGr3UUp3qlH8/1utdp/r+0tNqxCPclNFKV+iRfw/2q1SPAqI0SwEJIBTn4lpSr5eMhqXDHeshbs/hWTVtdB8anCP2TMwG6DgNDGVziPfvHQbvHiztzjgdGDpagCg1RiD4pE786gOjn4IT14Cjy8TwojRAtkTIzu+wRDqwGynE167B964F5w2mHaZKEGzd8Khd/Sg+/ZavURNw12ylhvyUnCJRCKRxD7D++xPIpGEFK+ytWjIPAojZqOBqfnihHVPReRyjz7YLw7mZxenYzEaKK1rp7Qu+CvUetmanldVlCFex4fXHMbm0DNqtHK1xvZuvwKVJkalJ5oZlyOumO881Uyixchvrp7FTYtL+PYFk/nHTfODHmNhWjxjs5OwO128tK232HCqUS9n04SfgeJyudxla7kp4n+SFCccUp228HWgGzYkqC6/JjUfqqc7ITlXCExap7WWisE9ntt55PE4mvOo/rAIzZZ4o+UCndyiL+toQEF81jti0Xmkla2d2AhPXw6l64QLbvZ18JX1sd0ZzKKVrYVIPDr8Lmx7ElBgxY/h6idhwnKxbv1D3tv2dB9pLqUUmXckkUgkkt4M77M/iUQSUoqjsWwtjExXc492DyI0+7OyBs797Ufc+q9PeWHLCWr7KX68u1cczF8yq4B5Y8RJ3/ojdYHu4kW9FpjtUbb2vVVTSbQY2XCk3qvcTBOP7E4XLZ2+hRRNPMpMtDCnKN1rn2OykjAaFL567gSWTw0+L0NRFL50ZgkAT2wo6xWM7SkeDbYjW6vVTpdNnETnpojyqgSzEI+k8ygItODqllPet3uSOkrdbpCh2V0+nEdJ2ZBWLOZlaHZvNAeLZ1lfuxChG1zJmOPiet8n2vEMxDbFw6KvwD3b4Yq/Qs7kyI0rFGidQm0hKltrLBPTaZfCknuFg2j8MrGscqf3tj3Fo1ZRIu12DkokEolE4sHwP/uTSCQhw7NsLSoCs8NMKDquvbW7itK6dj44UMP9L+9m4c/f5+pHN1IWhHtoT3kzm0sbMBoULpxZwFmTROnGukPBi0e+ytamFqTy+8/PAeDJTcd5bvMJAC/BSBOdetLYoQdwL54gxnPWxGyuXzQ66DH54qq5RaTEmyita+ejQ96lFCcb9SvymmvIF0dq2jhU3RrwcbS8o5Q4EwlqJlOS2oGuo1s6j/pEcwC5nUcpvrdzO48GKR75ch4BFMwWU1m65o3DJkqVQM+2AXc5Up0rjbFZiT7uGOVkjYdR86DkLLhzI1z4K72EMtYJdWC2ljOWlKsvG78MLB6f1Xjx29bbeSTFI4lEIpH4R4pHEokkaArS4jEahGg0EpxHnh3XBhqa3dolTuQWlGQwqygNlws+LWvk5e19n1T//WPREv2imQWMSk9g6URx9X3T0TqvcrNA9Oy2pnHB9Hy+df4kAH70vz18cqzeq8uaJjr12p+6PCPJwpWnjeK52xfx+I3zg8438kdSnIlrFwg3yRMbyrzWeTqPqlt8i0dtVjsrHlrL+b9fFzAXSROfclJ194UmInXIwOy+0U46tSwjf6G6budRqMrWeohU7o5r25F4YNM/K67qfWBXRWA1aLrOlca4nORIjGxwGM1w+xq4+Q29699wIdRla5p4lJilL0vMhC++DAlqyeK8m8X05Gb9MwYeZWtSPJJIJBJJb4b/2Z9EIgkZJqOBQrWtunmYZx6BCM02GxWaO21uAaOyuZMVD63lXxtKg9pHa5cQMi6dXchrdy/ha8smAFDXR1v42lYrb6id1W4/axwA0wpSyUyy0N7tYPuJpqAeXy9b612q8tVzJ3DJ7ELsThd3PrOV8ib95MWfeNToUbZmMCgsHp9NvDm4rmp9ceMZJRgU+PhwndtB1G61e42lusX3/22DRylfWb3/K/ha2aCWdwSQZNGcR1I86hOtTM2hvg6amNQTLYNGK6EZKH7FIzU0W3Zc88ZDPFKcNt1ZojmPSHNnlUmiBLP6eoSqbM0tHvXoQlq8EO7+DG5dDWfcLRxPDUfhsXP094m7bE1mHkkkEomkN8P/7E8ikYSU0WrukWUEOI8sJgOT1dBsLfdo7cFajtS08UoQziGAVqtw86TEmwHIUUWLhjbf4ozGO3sqsTtdzCpKY2aROEE3GBSWqKVi6w/XBro7AB8frqXL5kRRvMvWNBRF4Tefm0VBWjyNHTY2HNHbqvsTjxraxfPJSOq9v8FSnJnIBdPFScsTqjhX3tTptU2VH+fRRwf1/0eg7nha2VqOmncEkOh2HsmytT6J6yEW+XMe5c8U06rd4BjE/9Xdba1n2ZoqHtUfkaHZHrS09iixVZ1ZDlUUqHWlx6bzaDgTcueR6Krn5TzSSMoWIlJyLnzxVeEQrD8Cjy+H7c/KsjWJRCKRBGT4n/1JJJKQMjFXiCk9y6CGKzN7hGZrDqR6P+JKT7QcoZR44W7R/m/+xBmNN3cL19HFswq8li+ZqOYeHQ6ce3S0to27nt0GwOfnF7tzfXoSbzYyNltc+W6zemYe+ROPrOrzMAd8/IFyy5KxALy8rZyG9m5ONXqfUNX4EI9cLhdrD+o5SYHEo9q23s4jt3gkA7P7pmdAtr/Mo6yJImPF1gG1+wf+eFYfgdkASVkyNNsHlbWNXrdbSz8FoKNRfJ80GdIpSI3vdT9JBNEyj2yhFo8yA283ehHc8TGMXw72TvjfXfpnSZatSSQSicQHMSMeNTQ0cP3115Oamkp6ejq33norbW1tfd5v06ZNLFu2jKSkJFJTU1m6dCmdnZ193k8ikfjmnuUT+c3nZnH1/BhujdwPZvQIzdbEjPo+nEMaWuaR5jzKTFTFow7/969p7WJLqTgBuHCGt3h0lioe7TrVRJOffTR32Lj9yc9o7bIzf0wGP7lsesAx5qT0Lmnz6zzqEM8n00cZXCiYPyaDGaNSsdqdPL/lBCcbxPd1tuqc8lW2drimjQqPLmzHA5StaeKTV9maKqy1d9sHnG01YujpAPLXbc1ggFGqO6h8q//9uVz+nUkul/+yNZC5Rz6oamjwut1R+hkA3Y1q9lRyPgbD8G92EFNo3dZCHZjty3nUk6QsuP6/sOwHoKinBCVnQe600IxFIpFIJMMK35eio5Drr7+eyspKVq9ejc1m40tf+hJf/vKXee655/zeZ9OmTaxcuZIHHniARx55BJPJxM6dOzEYYkYzk0iijswkC1fPL470MIaMGYW6eORyudzOo06bg45uO4mWwF+jWuaR23mU3Lfz6N09VThdMLs4neJM785IBWkJTMxN5nBNGxuP1rNqpre4ZHM4+epz2zhW186o9AQe/eI84kyBM4lykoMXj9yZR2FyHimKwi1njuW+/+zk6U3HWTxenAAtGpvFm7srqW7pwuVyeQV07zrlXaoTKPOoRss8Su3tPHK6wGp3hizDaVjSM+PIX9kawKj5ULpOiEdaQK8n3R3wl9NFmHPBHCEGGUyiY5jDCk47uNRgeF8iVcEc2P86nPpsYM9lGFLX0ARAG4kk00Fm5zG6OtowtArxyJw5KoKjk/jEEsJuay5X/8QjEELv0m/DgtvE/ftyLEkkEolkxBIT4tH+/ft55513+PTTT5k/fz4AjzzyCKtWreK3v/0thYWFPu937733cs8993D//fe7l02ePHlIxiyRSIYHk/NTMBkUGjtslDd1emXw1Ld1k5jZT/FILVtr7OjG4XS5u9d5opWsXTTTd2jpWRNzOFzTxseH63qJR7946wDrj9SRaDHy95vmk+1DGOqJL+eR/7I1tdtaYvjKFi+aVcBPXt9HVUsXr+4Q2VKfX1DMm7srsdqdNHfaSPd4/Ar1NZmUl8yh6ja/ZWtOp4uyOnGClueVeaS/hh3dDikeBaKniOPPeQSitTpA+Tbf6+sPQ9NxMX9io/jzhWLQS3s8KTlLTI99KAQnY3gEzViioUkIqR3Jo+luqySTZtZtWMuZXSLLJiVnTCSHJ/GFZ9maww7GQRyaW1vBqXbNTOinCKR1YpNIJBKJxA8xIR5t2rSJ9PR0t3AEsGLFCgwGA5s3b+aKK67odZ+amho2b97M9ddfz+LFizl69ChTpkzhZz/7GUuWLPH7WFarFatVL4toaRF5CzabDZvN5u9uUYU2zlgZryQ45OsaGYzAxNxk9le18umxOq/A5urmDvJT/J+wWm0Ouh3COZFoEq9dslmIRS4X1LZ0kKWKSdrrWtHY5i5ZO29Kjs/Xe/G4dP65AdYdqqG7u9vtwrE7nDy1qQyAX185gwnZCUG9XzITe/8UNLRZfd5XyzxKiTOE7b1oAFZOz+Pfn53C6YKMRDMLx6SRkWimscPGh/urvLKgTjUIQWhRSQaHqtuobO6itaOrlwi0/kg9Fc1dJMeZmJaf5DX+OJMBq91JS0cXKZbQl/UMm8+vMRHPd7zdmIDL33PKm4UZcNXsw97W0Kv0TGlvxAS4UotwLP0OSs0+IRQZLdDVhHHbvwBwGeOw232UtuXNxpSQidLZgL10A64xZ4biGQ6YaHiNm5qFeGS0JNKSMZ3Mxo2c3PYu8U4hqI4eMzb234NDTLhfV8UQJw7Gq/fg+uVoHFc8jmvi+b43tltRTm3BVXy6b7G0tUZ85kwJ2BUzyNc6INHwmZWEF/kaD3/kaxwagv3/xYR4VFVVRW5urtcyk8lEZmYmVVVVPu9z7NgxAH784x/z29/+ljlz5vDUU0+xfPly9uzZw8SJE33e7xe/+AU/+clPei1/7733SEz0ceUzilm9enWkhyAJA/J1HXpSHQbAwNNrduJy6WWv767dSHmG/4yclm4AEwou1n6wGs1klGg00uFQ+N/b75Pf42vlkVc+xukyMibZxa5NH+IrCtjqAKNipLypiydffpvcBLG8yQp2pwkDLmxlW3nreHDPr7RJQchkOuV1zbz11ltey7od0GkTPxtb13/E3jD+guR1gvYTNTnZyrvvvM3cdAMfdBi4/6Vd1B7eTp76vHcdEa+Pva6MeKOBLofCc/97t9f/9h8HxXanZXSz9oP3vNaZMGJF4Z33P6QgjF/1sf75TbTWcp7H7Y8+2U57vO/fYYAVllySumvY+vIjVKfN8VqX17yd04Emu4V15enAYn2ly8ll/AsAxd7Z672oMTd+KsWdGyh971H2jWr2uc1QE8nXuKGpAQzQ3tVNS5IoL57VvgEM0OJKpKl0H28d3xex8cUy4XpdUzuOc646r9ja4b+38PGkH9Ka0Ls8fEL1G0yv+A+VqaexZdzX9ZwilfT2Y5wNdCoJrPbzmZH0Jta/lyV9I1/j4Y98jQdHR0dwTRsiKh7df//9/OpXvwq4zf79A+vS4nSKq/133HEHX/rSlwA47bTT+OCDD/jnP//JL37xC5/3e+CBB7jvvvvct1taWiguLub8888nNTWAPT+KsNlsrF69mvPOOw+zWdr4hwvydY0cjZtPsPmNA+xuMgK6WDR2yixWzfOfIVJa1w5bN5AUZ+biiy5wL//DofWU1nfwzIkURmcm8rcbTsPgcrB69WpOOLOAJq49czKrlpT43ffLtZ/ySWkj7zXlEN9m4HhDB7eeWQLb9pObGs/FF50d9PObUN3KX/Zv8lrW6TKyatUFXssqm7tgyzrMRoUrLrnQK3co1DidLl7+w3pONXZy+8r5LJ2YzfkOJzc/uZXNpY28cCqV/95xOinxJh4+sgFoZ+VZC9nVeYi9Fa00pU3kpuUT3GWB1S1d3Lf5Y8DFA59bwsQ873blv96/jvamLuYtWsyc4vSQP59h8/ntbIR933TfPPv8S0Tbbz8YXathx9MsyO7Aed4qr3XKnnY4Bmm5RaxatarXfZ31p2M4+QmAz/UAyj4rvLKBCc6jlPjZZqiI9Gvc2mVn85a1YID8wmIKT/scvPg/5ihHAWiPy+XSiyP7P4pFwv66NhyDgz903zQ5uzi38m/Yv/QeJGV7bWp88XkAClq2c3HcFpwrfuq1XjnyPhyChMxRfj8zEp1If2Yl4Ue+xsMf+RqHBq3aqi8iKh5985vf5Oabbw64zbhx48jPz6empsZrud1up6Ghgfx835kgBQWipGHaNO+OEVOnTuXEiRN+Hy8uLo64uN75H2azOebekLE4ZknfyNd16Jk9WmRH2BzeLqPmLkfA16JTrbRJjTd5bZeVHEdpfQcnGzs52djJrvJWFoxJo6UbPjvRBMAlc0YF3PfSybl8UtrIp2V6a+4nN4nvtrzU+H69RwoydCElNd5ES5edLpsTm0vxygNqsYqrEhmJFiyW8GUeaTxx8wIOVLWybGo+iqJgNsOfr5/HJY+s51hdB/e/spdHb5gnRC1gdHYKK6bms7eilb+uK2XL8SZ+ddUsJuQm89beEzicLuaOTmdaUe9sD63jms2phPXzFfOfX4N3joo5ORMCPZ8J58KOpzEeX4+x53Z2kVVliE/F4Gsfn/sHPH0lzLrG//9swnIAlLpDmF02MBjhmatE+Pb5/xfsswopkXqNK2o6SECUlVoSkqFYlPobFPG9Zc4oiu33XoQJ2+ua6BFCP+NzUL4VpbEU88tfghv/ByaPY9K6Q+5Z4+a/YMyd7B1G3y3cd0pStnyt+0HMfy9L+kS+xsMf+RoPjmD/dxFtO5aTk8OUKVMC/lksFs444wyamprYulVv97tmzRqcTieLFi3yue+SkhIKCws5ePCg1/JDhw4xZowMjJRIJMEztSAVk49g69++d5DFv/iAA1W+1fqWLlE/nBLv/YWshWZrbDhaB8DOBsXdZa0oI3Dt1PnT8rGYDCRZjKSowscxNQw6NzU+0F17kZ5gdj+/wvQELCbx06CJMhoN7k5r4ReOACbmpXDJ7EIvh1N2chx/vWEeFqOB9/ZV88t3DtDR7QCgIC2ery+fyP9dPoMki5GtxxtZ9fDH/PnDI7y8TQRvXzm3yOdjaSJZu7oviR+MJr21uMEMpj7ea2NVB1z1Hmir9V5nbRVTfx3b0org7i2w9Fv+95+UBXHqyXfTcajYDmUfwyePgq3L//2GIVXNXcSjBt2bEyClAFdynnt9er489olKPMPg51wH1/1bfCZObII37hMBeSDez42lYn7BbWL65jfh2Ef6/fvbaU0ikUgkkn4QEz3rp06dysqVK7n99tvZsmULGzZs4O677+baa691d1orLy9nypQpbNmyBRDtnr/97W/z8MMP89///pcjR47wwx/+kAMHDnDrrbdG8ulIJJIYI95s5N7zJrlvayHXDqeLiuYu/vzhUZ/369lpzX3/ZG/xZeNRccC/o16IJBf36KDmiwm5yXxw39lsuH8Zv7tmtte6vNS+O6x5YjAo7q5sqQlmTlPLtv63XQgubVY7z20+wc/fEmXE4ey0FgxzitP56WXTAXhsnci3y0qyEG82YjAo3HD6GN6772zOnpRDt93Jb949yIGqVixGg1fQtieJFpH51NHtI5hZ4o0m9sSnQl+li0nZkDdDzB9f773OLR55B2n3mwxVFGk8Lv5AdJyq3ju4/cYYVS1dJChqww9zIigKSsEc93pTum/hVBJh4lKE42jKxTDuHMiZDFc/IfKMdjwDR94X29UfBpcT4tNh1W9h5jXgtMN/boR69TeoQzRbkOKRRCKRSMJBTIhHAM8++yxTpkxh+fLlrFq1iiVLlvDYY4+519tsNg4ePOgV9vSNb3yDBx54gHvvvZfZs2fzwQcfsHr1asaPHx+JpyCRSGKYr547gb/fOJ8r547iliVjvda9s6eSmtbeLodW1XmUmhDYebTrVDNl9e0cbREn4hfO9F2O25PizETSEy0UZ3q7lDzb0AdLrio4pSWYufGMEgCe23KC772ym0U/e5/vvbLbLcBccZr/nKeh4tqFo1k0Vi+hKkxP8Fo/Kj2Bf31pAQ9dM5s09f+/Ylou6X6EL8151CGdR30Tr4pH/hxDPSlaIKaVO72Xh0w8KhHTxjLxp1GxbXD7jTFqWrpI8HQeARSepm+Q0rcoLYkAiiJKNK99VpRdAkxYAQtuF/PbnxHTWtVJnztV3OfSR6B4EXQ1w4c/F+vcziPv8lKJRCKRSEJBTHRbA8jMzOS5557zu76kpASXq3fXo/vvv5/7778/nEOTSCQjhBXT8lgxLY8PD3pnsNkcLv695SRfW+7dxdGf8ygzSXcGWYwGuh1OHnzzAC4UZhel9Vmy1pOiDG/hJK+fZWsAOZrzKN7M+dPzyEuNo7rFynObRY7SuOwkvrBwNFfNKxqysrW+uGR2IZtLxZX2grTez1lRFK6cW8RZE3N4Z28Vl/hxHQEkxYmTtnardB71iSYaBSv65M8U06o93svDIR51eXRcq9gxuP3GGFUtXeTj4TwCb/EoNfKir6QfnHY9bPkbHHxbBNXXqA1kciaLqTleOJD+dhbsfQVKlsDel8U6KRRKJBKJJAzEjPNIIpFIooVsD/GnUBUtnttyArvD6bVdix/xqMNDoLh6viglWXdYXDG+cEYe/SUl3kx6ou5uyu1n2RpAToruPDIbDXzz/MmkJ5q5eFYBz92+iA++eTa3Lx0XNcIRwMoZukPL7ux98UAjJyWOL54+xq/rCPSytU7pPOqb+DTvaV+4xaPd3sutalZYKMWjpuP68ortg9tvjFHdYiVe6ek8mqNvkFo45GOSDIL8WZA7DRxWIQ7VHhDLc6bq2xTMEqVuLge88Q0hnhYvghlXRWLEEolEIhnmSPFIIpFI+olnZtE3z59MVpKFyuYu3t9f7bVdq5/A7EXjRB5FRqKZr6+Y6BYuAFZO7794BFDs4VbKHUDZ2nnT8shJieOcyTkAXDO/mB0/Op8/XTeXxeOzvUKro4Xs5Di0HPOpBYMTIGRgdj/ob9la7jRAgbYqaPNw7YW7bK12P3R3+LjD8KS6pcvdbc0tHqXkQ8lZ4n+UNSFiY5MMAEWBaZeL+eOboO6wmM+Z5L3dkvsABYxxotTtxtcgLhmJRCKRSEKNFI8kEomkn3iKR6ePz+LzC4oBePqT417b+StbW1CSwfO3n8679y4lNyWeO88WOWwlyS5G9cjuCZbiTP1+/Q3MBlg+NY9Pv7+CpZNyBvT4kWLtt8/lnuUTueucwZ0YJ7mdR7JsrU88A7OD2j4ZstSsQU/3UajFo7pD0CJC3rEki3Dhnm6nYUy1V+aRR+nrTa/D3VtFmZMkttDe221V0FIh5tN7dM0bdzZ8dQvctx8u+q18nSUSiUQSNmIm80gikUiihTiTkT9fNxe708mo9ASuWzSaR9ceZcOReo7UtDEhV1z1ben07TxSFIUzxuvdcO48ZzxZSSY6j+8a8Jg055HZqES8G9pQUpyZyH3nTep7wz5IkM6j4NE6OSX0I5Q3fybUHxFizoTlYlmoxKO0YtGZyqW+duYk4bY59LYoXRu9aHD7j2Le2l1JY0c3pxVn0NhhI8HSw3kEwsFilId7MUmK6kStPwbd6ucl2Yc7tacbSSKRSCSSMCCPJiQSiWQAXOQRvlyUkciyKXm8v7+aZz45zo8vFW3kNedRanzgr1qT0cDV84p4q3rg4pEWmp2bEo/BEH0lZtGOFpgtM4+CYN5NIltlwa3B3yd/pshtqfYIze5uE9PBikcmiwiDbj4pbmeUwKi5ung0TPm0rIG7nvXuKJegCMEa08AcjJIoI1nNdWs5JaaWFFmSJpFIJJKIIcvWJBKJJATceIYoJXhp6yl3x65WqziRS+3hPAoHUwtECdH4XHliMRASzGq3NVm21jfpo0V5jFaKFgx5PkKzQ+U8AtHaXCMlX+8yVrHN9/bDgL+tPQaAp1acbFDFI7MUj4YFKfmBb0skEolEMoRI8UgikUhCwJIJ2ZRkJdJqtfPqjnJcLhfljZ2Ad0ZSuJg3JoNnbl3Eb6+eFfbHGo4kxQl3WIdVOo/CgtZxre4Q2DrB6fBwHgWZnRSIC38N828R8xPPg4I56uMdhq6Wwe8/yjhS08b7+6tRFPjhxdPcyxMVH5lHktglPg1MHhlGUjySSCQSSQSR4pFEIpGEAINB4YbThfvo6U3HOVrbTmOHjTiTgSn5ITg57gNFUVgyMXtAndYkkJ4o3GGl9e3YHc4Ij2YYkpIPidkixLpmny4cQWicRyYLXPx7+O5xOP1OSM4RWUi4oGrg5aDRyt8/Fq6jFVPzuPGMEvdyo0MI1tJ5NExQFO+Mo5QC/9tKJBKJRBJmpHgkkUgkIeLqecXEmw0cqGrlb2uPAjC7KB2LSX7VRjvzx2SSlWShttXKRwdrIz2c4Yei6O6jqj16yZrRAqb+dwf0S0K6Pl84R0yHWe5RTWsXL28TXeXuWDoOo0HhmvlFAKSZ1LJLKR4NHzwFI+k8kkgkEkkEkWc0EolEEiLSEs1cNnsUAC9uFQGn80oyIjkkSZBYTAaumidOwF/49GSERzNMyffIPQpl3pE/3LlHw0s8enJjGd0OJ6eNTmfeGPH98osrZ/HklxZgdnaJjWTZ2vAhRTqPJBKJRBIdSPFIIpFIQsiXzxZOAI15o6V4FCtcM78YgA8P1lDT2hXh0QxDpHg0aNqtdp755AQgXEeKIr5rjAaFs8eno7jUzC7pPBo+JHu4jaTzSCKRSCQRRIpHEolEEkLG5yRz1dxR7ttzx0jxKFaYkJvMnOJ0HE4X7+6pivRwhh+aeFS9B7qaxXw4xSMtNLvhGHQ2hu9xhpD/fHaS5k4bJVmJnDeth5Bg69DnpfNo+OApGEnnkUQikUgiiBSPJBKJJMR8d+UUJuQmc9HMAjKTwt9pTRI6Lp4lTs7e2FUZ4ZEMQ7ImgjFOhGVX7RbLQtFpzR+JmZBRIuYrd4bvcYYIh9PFP9aXAnDrWd4OR0B0sQNQjGA0D/HoJGEjRTqPJBKJRBIdSPFIIpFIQkxWchzv33c2f75+bqSHIuknF84U4tGWsgZqWmTpWkgxmiBPbSt/YpOYhtN5BHrpWvm28D7OEFBa18apxk4SzEY+N7eo9waa88icKALKJcMDr25rUjySSCQSSeSQ4pFEIpFIJCqj0hM4bXQ6Lhe8v78m0sMZfmila2UbxHSoxKNhkHu0v1LkRE0pSCHBYuy9geY8knlHw4v0MWKalCtfW4lEIpFEFFOkByCRSCQSSTSxeHwW2080sbu8CRgd6eEML/JU8cjWLqbaiXG40HKPqveG93GGgANVLQBMyfdT6mfXOq1JgWFYkT0BLnoIMsdGeiQSiUQiGeFI8UgikUgkEg9mFKYBsKe8xb3M5XKx81Qzk/P8uD4kwaE5jzSmXxHex0sXHfRoqQCXK6bLuQ6ozqOpBX7cWp5la5LhxYJbIz0CiUQikUhk2ZpEIpFIJJ7MGCXEo4NVrXTbndgcTu77z04u//MGfvxa7DtYIkredH0+Oc/7djjQulPZO6GrKbyPNQhcLhfbTjRS32b1u83+yj6cR7JsTSKRSCQSSRiR4pFEIpFIJB4UZSSQGm+i2+Fkd3kzdz6zlVe2lwPw5u5KrHZHhEcYw8R7CB8TVoTfCWROgPh0Md9aFd7HGiAHqlq48I8fc+VfNrLsd2t5fWdFr22aO2xUNIuytMn5fTmPpHgkkUgkEokk9EjxSCKRSCQSDxRFcbuPbnvyU97fX0OcyUBqvIk2q531h+siPMIY57I/C+HovAeH5vFSC8W0pbcoEw38a0MZB6paURRo7rTxtee38/UXttPcYXNvo+UdjUpPIC3B7HtH0nkkkUgkEokkjEjxSCKRSCSSHmjiUWOHjZQ4E0/dspAr1fbob++JTgdLzHDaDXDDS5CUNTSPp5WuRanz6FitCA//9VWzuGf5RIwGhf/tqOCCP6xzC5UHqvrIOwLpPJJIJBKJRBJWpHgkkUgkEkkP5o3JACA72cLzXz6dReOyWDkjn//f3p3HR1me+x//zpJM9oSELCwJqxBA1qII7lXQunvaqtUeaqttRXus1bZHbV3w1KpttVbbU3ta6/YDrXWvaxGlRUGQfREB2SEkgezrZDLz/P54ZiYJySQhmSUz83m/Xrxm5plnuWcu4hMvrvu6JWnJZ2UyDCOSw8Px8CePBmbl0e6jZvJofEG6bp07Ti/dMFujBqeqtLZZ33xylR7+5/ae+x1J7SqPaJgNAACCj+QRAADHmDshX3+8Zobe/K/T/VVIM4oGyWa1qKbJpdLa5giPEL2W4U0e1R6O7Di6UNvs0lFvk+yRg1MlSdOLBumtm0/TNbOKJEmPf/CFPtxeLkkq7rbyiGlrAAAgdEgeAQBwDKvVoq9MHqKCzCT/tkS7VSOyzaqOXeUNkRoajle6WTE2EKet7fVWHQ1Ocygjqa2XUUqiXfdfPlkzirIkSWW1ZoKp+8oj37Q1Ko8AAEDwkTwCAKCXxuSlSZJ2HamP8EjQa+nehtkDcNraHm/yaLS36uhYs0a39YVy2K0aFWA/SVQeAQCAkCJ5BABAL43JJXkUdTIGbsNsX7PsQEmhWaOy/c/HF6TLZrUEPhkNswEAQAiRPAIAoJfG5Jr/k0/yKIr4GmbXl0nu1siOpR2Px9AX3r9Ho3K7Th7NHJntTxgVF3TT70iiYTYAAAgpkkcAAPSSb9raZyW1envzYdU0uSI8IvQoNVey2CTDIzWUR3o0kqSaRpfmPPiB3tpkNvEOVHmU5rDrxKFmn6Nu+x1JTFsDAAAhRfIIAIBeGjPYTB5VNbp046J1evif2yM8IvTIapMyh5nPq/ZGdCg+a/dX+lfsc9itmjo8K+C+d14wQV+dMVxfmzm8+5NSeQQAAEKI5BEAAL2UmZLQ4fUr6w51uV9No0tvbipRs8sdjmGhJ7nF5mP5tsiOw8u3Wt/EIRn610/O7rCq37Fmjc7Rw1dM7bAaW5eoPAIAACFE8ggAgONw2bSh/uf1zlaVVDd12ufxD3bqB4vX62+fHgjn0BBI7njz8cjAqBTz9cw6d2J+t4mj4+JvmE3lEQAACD6SRwAAHIeHr5im9XfN1dThmZKkT3ZXdNpnf6X5P/I7y+vCOjYE4Ks8OvJ5ZMfh5UsejQnQKLtPqDwCAAAhRPIIAIDjYLNaNCg1UaeMzpHUdfKosqFFknS4urnLc7yxsUTXPrVa5bVdv48gy51gPg6YyiNz2tqY3LTgndSXPLKTPAIAAMFH8ggAgD44ZYyZPPpo51G5PUaH9yobzeTRoS6mtLk9hn7x5mdatv2IHv/gi9APFFLuOPOxvlR65XvSF0sjNpTKhhZ/cnF0UCuPfNPWSB4BAIDgI3kEAEAfnDIqR5nJCSqpadb728o6vFflTQ501Q/pk90VKq9zSpJeXHNA2w7XqqXVE/oBxzNHupTu7VW16W/S2z8J26W3HKrR7AeW6so/rdSzK/dqlbdSbVhWslIS7cG7ENPWAABACJE8AgCgD5ITbbpmVpEk6cnle/zb3R5D1U0uSVJtc6vqna0djnt9Q9sKbc5Wj77yu+W6/H8/DsOI45yj3RSxyl1hu+wbG0t0uKZZq/ZU6u7Xt2rBonWSpDF5QZyyZhg0zAYAACFF8ggAgD6aP3uk7FaLVu+t1KaD1ZKk6sYWGe1msR1uV31U2+TSO1tKJUkLzhrj3761pFZNLe6QjfPtzYe1taQmZOePCqcsaHtuTVCHIIXQ56Vm0/RzJ+RrWmGWf/s0b8P1oGh1SvJ+HiqPAABACJA8AgCgjwoyk3TxVHM61JMfmdVHVd5+Rz7t+x499uEu1TW3amxemn4yb7w+u+88Oezmrbg0RM2zdx2p142L1um/nl8fkvNHjZnfke4sMZ97XFJTVVguu8ObPFpw1mi9dtOp+vj2L+vP82dqwVljg3cRX9WRRPIIAACEBMkjAAD64brTRkmS3tp0WIdrmlRR3zF5dLjGTAqVNEr/b9UBSdI9F0+U1WpRSqJdw7LM/9kvrQlN8si34tuhqs79l+JOYqqU5K34aTgS8svVNLr8ScFx+emSzF5HcyfmKznRFrwLtXr/7lgTJFtC8M4LAADgRfIIAIB+OHFYpmaNylarx9AzK/Z1qjwqqW6SYRh6eY9Vbo+h8ycV6PQTcv3v52ckSZLKQlR5VN1kjsfZ6gnp1LiokZpnPtaXh/xSn5fWSjITRulJIUzq+Jtl0+8IAACEBskjAAD6yVd9tHjVPh08psLnUHWT3tlSpi9qrXLYrfrZhRM6vF+QaSaPQjVtrbrR5X9eeUxiKy6l+ZJHZd3v109vbz6sR5bskCQVF6SH9FptzbKZsgYAAEIjiGvEAgAQn86ZkK+ROSnaW9GoPy/fLUlKTrCpyeXWZyW1WvHFUUnS908fpcLsjtUhvsqjUE1bq2lqSx5VNbT4p8nFrVRv1VcIp60dqXPqB4vXyePtYT0+5MkjX+VRnMcWAACEDJVHAAD0k81q0bdPNauPymqdkqR5k/KVnGDT56V1Kq11Ktth6Lunj+x0bEGGw3tcaJJHVQ1t1Ubtq5DiVlrop61tPlTtTxxJ0sShGSG7lqR2lUdMWwMAAKFB8ggAgCC4bPow2awW/+tJQzP00NemtL0/wqOkhM5Nkn3T1kLX84hpax34eh41hC55tOlgjSRpRE6Kfnr+eJ03qSBk15JE5REAAAg5pq0BABAEmckJmjlikFbtqZQkDUpJ1CVTh6ql1aPaRqeyK7Z0eVxbw2xnSMbVvtqomuRRu8qj0E1b23LITB5dO2ekvyItpOh5BAAAQozKIwAAguScCXn+59mpiZKkr31puP7zlCJZLF0f077yyNN+rlMPnl25V6f8cqk2e6tcAqlpaksYVTaQPPInj8JQeTRleGbIrtEBq60BAIAQI3kEAECQfLm4LXmU5uhdcW9umkNWi9TqMVRW16wth2r0wur9enNTSbfH3f36VpXWNmv+X1epsaVVzS53l/t1rDyi55F/2lqIKo/KaptVXueU1SJNHBLu5FFSeK4HAADiDtPWAAAIkjG5aZo6PFP7KhtVPKR3TZLtNqsGpzlUXufUaQ99KHe76qOxeWkqLuh8nrrmdiuoNbo08e73VJSdoqW3nakEW8d/F+rQ84jKIynNt9pauWQYClgS1kcbvVVHJ+SlKzmxc4+rkKBhNgAACDGSRwAABInFYtHfvj9bHsNQSmLvb7HFQzJUXndEbo+hjCS73B5DDS1u7T3a0GXyaOOBzlPV9lc2asWuCp05Lte/zTAM1TS2TzSRPPJXHrlbpIfHSwWTzT/FF0nDZ/b79M9/elCSNGdsTr/P1WvN3r8P9DwCAAAhQvIIAIAg6mpFtZ48csVUbTxQrbF5aSrKTtFNi9fp7c2lOlzT9Qps6/ZXSZImD8uU1dJW7fLWppIOyaPGFrda3B7/a5JHMqd2Tb5C2vx3qb5M+qJM+uJ9afWfpf/eK9kS+nzqgw3SR19UyGa16DvhaJRd9pm07R/SisfN14PCcE0AABCX6HkEAECEDU5z6JwJ+RqRkyqLxaKCDLOCpLSH5NF/zBim139wmhZ/d5Yk6b2tZXK1Sxa1n7ImSVUN9DySJH31z9Kdh6Trl0oXPmJua6mXnHX9Ou3SQ+avVRdNGaLC7BBPIasrk/50urTsl2YVVfFF0snfDe01AQBA3Iqa5FFlZaWuueYaZWRkKCsrS9ddd53q6+u7Paa0tFT/+Z//qYKCAqWmpmrGjBl6+eWXwzRiAAD6Zoh3BbauKo88HkPr91dLkmYUDZIkzRqVo8FpiappcumjnUf9+1YfU2lE5VE7ianmNLWTrmvrFeSs7fPp9lU2an2F2T/p+2eMCcYIu3d4o+RpNafhXfSodMWzTFsDAAAhEzXJo2uuuUZbt27VkiVL9Oabb+rf//63vve973V7zPz587V9+3a98cYb2rx5s/7jP/5DV1xxhdavXx+mUQMAcPwKvMmjriqPdh9tUE2TSw67VRO8TbltVosunDxEkvTq+kP+fX39jvIzHJLMaWzO1q5XZRvoDMPQil1HVVHvDP7JE9PMR2f3/yjVnb9+vFeGLDrjhBxNHNq7Zun9cuRz83HkqdLMb0vWMDXnBgAAcSkqeh5t27ZN7777rj799FPNnGk2s3z88cd1wQUX6De/+Y2GDh3a5XErVqzQH//4R5188smSpJ///Of67W9/q7Vr12r69OldHuN0OuV0tv1iWltr/iuky+WSyxUd5f6+cUbLeNE7xDW2Ed/YdrzxzU01b8+Ha5o6HbNmj1lZNHlYhiyGWy6XmQy6ZEqBnlm5T+9tLVVlXZPSk+w6Wmcu4T48K1lH61vk9hg6UtOo/IzoW9L9XzuO6Prn1isrOUF3X1SsiyYXyBKkldLsjjRZGsrV2lglow8/gxX1Tr28rkSSdN3swrD8HNvKtskqyZ19gjz8dyNk+G9z7CK2sY8Yxz5iHBy9/f4shmEYPe8WWX/961912223qaqqyr+ttbVVSUlJ+vvf/67LL7+8y+PmzZunxMREPfvss8rKytKLL76o6667Ths3btTYsWO7PObee+/VwoULO21fvHixUlJYAhcAEHoVzdJ96+2yWQw9PMutLVUWVTmlM4YY+tsuq1aUW/XloR5dOqKtv5FhSA9stKmsyaKZgz2aNMjQ4UaL/nnIqsmDPNpTZ1F9q0U/ndKqYakR/HB99PYBq9472FYwPSXboytGe5Te9/7Wfmd+freymvZq5ejbVJ459biPf2u/Vf88ZNWINEM/OtGtIOW0unX69oXKbtyl1SN/oMODTg79BQEAQExqbGzU1VdfrZqaGmVkBK6ejorKo9LSUuXl5XXYZrfblZ2drdLS0oDHvfjii7ryyiuVk5Mju92ulJQUvfrqqwETR5J0xx136NZbb/W/rq2tVWFhoebNm9ftFzmQuFwuLVmyRHPnzlVCQhB+q8aAQFxjG/GNbccb35ZWj+5b/77chkUnnXGO7nz0IzW2uHXdRXNUsXuTpHp99czpmjcxv8NxhzL26Nf/3Kk1R61a09b6SONGDVfl7krVVzfr5NmnaurwzCB/wtB7+/kNkso1rTBTWw7ValOlVQeaHXpy/gxNHta/z2Or/JO0b69OmlosY+IFx3VsvbNVd/3m35Jadc5Qj+bNC8PPsGHIvvVGSdL0ed/Q9Nzxob1eHOO/zbGL2MY+Yhz7iHFw+GZb9SSiyaPbb79dDz30ULf7bNu2rc/nv+uuu1RdXa33339fgwcP1muvvaYrrrhCy5cv1+TJk7s8xuFwyOFwdNqekJAQdX8ho3HM6BlxjW3EN7b1Nr4JCeYKbEfrnVq1t1qNLebUtM2H67Sj3OzLc9KowZ3Odf0ZYzQoNUmbD9Voe2mtdpTVq6GlVbPH5GrtvmpJksVqjcq/Y18caZAk3Tp3vHLSEnXbixv1eWmdnlyxX3+4ekaPx28vrdOfl+/WT88br7xjp+05zH8csrc2ml/+cXhp5QHVNrdq9OAUTc6uDc/PcM1Bc3U4q10JeeMke/TFM9rw3+bYRWxjHzGOfcS4f3r73UU0eXTbbbfp2muv7Xaf0aNHq6CgQOXl5R22t7a2qrKyUgUFBV0et2vXLv3+97/Xli1bNGnSJEnS1KlTtXz5cv3hD3/QE088EZTPAABAKAzJTNLReqeWbmu7/7289pAMQxqWldw5ASLJYbfp6llF/teGYajJ5VZKol1/XPaFJMnlHvCz1Ttxtrq1t6JRkjQuP10FmUlacNYY/fCFDapq6N0Kcuc9+m9JkkXSr79+zNQ0R7r3QsfXMLul1aMnP9ojSbr+tJGylm06ruP7zNcsO3uMZE8MzzUBAEBci2jyKDc3V7m5uT3uN3v2bFVXV2vt2rX60pe+JEn64IMP5PF4NGvWrC6PaWw0f8m0WjsuKGez2eTxeLo6BACAAaMg06wgen9bmX/b6r2VkqQZIwb16hwWi0Upieat3u69H7o90Zc82nO0QW6PofQku3/luIxk81/Japt7bvJ4uKbJ//xIV6u1OXyrrdX1ekzLtpfr6RV7VVrbrPwMhy6ZOlRL/xmu5NF285HpagAAIEysPe8SeRMmTND555+v7373u1q9erU+/vhj/eAHP9BVV13lX2nt0KFDKi4u1urVqyVJxcXFGjt2rL7//e9r9erV2rVrlx5++GEtWbJEl112WQQ/DQAAPRuaaVYWOVs7/4PHjKKs4z6f3WZ2cXa5o+8fUHaUmRVB4/LT/SusZSR5k0dNrT0e/4+NJf7nibYufvXxVR619L7y6Ed/26Bl249Ikr57+mg57GH8lcpXeZRbHL5rAgCAuBYVySNJWrRokYqLi3XOOefoggsu0Gmnnab/+7//87/vcrm0fft2f8VRQkKC3n77beXm5uriiy/WlClT9Oyzz+qZZ57RBRccXzNMAADC7YLJQwK+N6Ood5VH7dmtZtIlGiuPdpSaFUHj8tP82zKTzYqq3lQevdEueVRe10XlUaKZPKqrqdRFjy/Xe1sDL8YhSXXNLlU1mtf9y/yZ+vapo3ocQ1CVe5NHeSSPAABAeETFamuSlJ2drcWLFwd8f+TIkTKMjr8Qn3DCCXr55ZdDPTQAAIJu1ugcjc5N1W5vo+gEm0UutyGH3aoJQ45/9U+7t+ImGnsefe5NHp2Ql+7f1lZ55JJhGP6KpGMZhqEdpW0VRUfqnHpr02HVNbt01cne/lDeyqODZeXacqhWT3+8V+dN6rqnoiSV1TZLktKT7DrXu+Kdx93HD3e8DKPdtDWSRwAAIDyipvIIAIB48/g3pisl0abzJuVrZE6qJGnK8Ewl9mGKlC1KK48Mw9CGA9WSzM/u4+t55DGkhpbAmZvapla1tJuqV17XrB/9bYNuf2WztnuTUr6eRy0NNZKkrSU1nf5Bqr3SGrN6aUhm56blIVdXKjlrJItVyhkb/usDAIC4RPIIAIABatLQTK28/Rz9/uoZGptnJjim92HKmmRWLklSa5QtGnGouklH652yWy06cVhb8shht/r7F9U2BZ665muQndiu8sqXTFrymXd6mrfyyPCutlbb3KqDVU0KpNRbeZTfxYp3IedfaW20ZHeE//oAACAukTwCAGAAy0xJUILNqhvOHKMLJw/Rd/rYX8fmXW2tNcqmrfmqjoqHpCspwebfbrFYlOHte1TTTfLoqDd5NGxQsjKSOs7WX/KZdyW7RDMx53A3+N/7+5oDevrjPV2e2zdtrSAiySOmrAEAgPCLmp5HAADEs6mFWfrDNTP6fHxClE5b27C/WpI0rTCr03sZSQk6Wt/SbeWRL3k0OC1RVotZVeSz8WCNymqble8we0ilqq3a6LEPvvA/3jZvnK46qcg/9e9wjblfQSSmrR3ZZj6SPAIAAGFE5REAAHHAl/hwRdm0NV/l0bTCztP10r19j9onhI51tM6XPHIoN73zNK/3t5X5ex6lWZr835NPZUOLfvbqFl30+EdauatCUlvPo8hMW6PyCAAAhB/JIwAA4oDdFp2VR1tLaiVJ0wozO72Xmdy24logR+tbJPmSR23JnoneFeuWfFbm73mUqmadOS7Xv8/vrpqmey6eqIwku7YdrtU3/vyJFvy/tdpZbjbaDvu0NcOQyn2VR+PDe20AABDXmLYGAEAcsFvbGkZHC2erW00ucyW1vC4SNb4eRrXNvZm25uiwSt33zxytH76wQSu+qFC9xihNksPSqiun56ul1aNBqYm6ZOpQWSwWXTptmB5Zsl2LV+3XO1tK/ecI+7S1hiNSc7UkizT4hPBeGwAAxDWSRwAAxAG7v+dR9Exbq283HS01sfOvLBn+yqNupq35kkfpiXIktCWP5k7M18icFO2taNSSXfW63Lt9Wr5N510/q8M5slMT9YvLJuvs8Xm67pk1/u1hn7bmW2lt0EgpITm81wYAAHGNaWsAAMQB37S1UFceVTa06B8bS9TS2v8kVYPTrDpKSbR16kUkmQ2zpe4rj460n7aWZvY8GpKZpJREu+ZOzJck/e+yvWo0zPfyElsCnuvs8XkdqpdyUhOP5+P0H/2OAABAhJA8AgAgDti809ZC3fPowXe26b+eX6/X1h/q97nqnGZSKM3RdaF0RrJ32pq355HHY+i5T/bp/c/K/Pu0b5g9rShLCTaLThs7WJI0d2KBJGlneb3qZVbyWFrqA47HarXosmlDO7wOK1+/ozySRwAAILyYtgYAQBxI8FYetYY4ebTpYI0k6fPSun6fyzdtLS0pQPLomMqjh977XH/6125J0rdPHak7L5jgn7aWm+ZQUU6K1t41V+neZNSXRgzSoJQEVTW6VG8kKc8iydn9uH92wUSV1jp19vjcbvcLCSqPAABAhJA8AgAgDvimfbW6Q9fzyOX2aNcRs3LnQFVjv89X7zSTR+kBK4/aeh69u6XUnziSpKc+3qvNB2vk9E6fG5xuTjHzJZwk8zv5cnG+Xl530F95pIpd0og5AceUmZKgZ79zct8/VH/4eh6x0hoAAAgzpq0BABAHEmyhn7a2r6LB31PpQGXwkkepgZJH7VZbW7RqnyTpO6eO0hPf/JJSE21as69KktkzKaWLhtuS/H2PKowMc8MbP5BW/qHfYw+6xkqp8aj5fPC4yI4FAADEHZJHAADEAV/lUSgbZm8vbesXdLCqSYbRv2v5kkeBex6ZVUR7jjZoxa4KSdL82SN0/okFevWmUzUyJ0VS96uinTFusIZkJukvqdfLM+I0c+O+Ff0ad0jUl5uPSVlSYmpEhwIAAOIP09YAAIgDdm/yyO0J3bS1HWVt/YLqna2qbnRpUD9WJOttz6PGFnNVtinDMzVysJlYGZefrtdvOk1/WPaFTh6ZHfAaKYl2vfvDM2SxStbtidK+j6SWhj6POWQajpiPqRHotQQAAOIeySMAAOKA3bvamiuE09Z2lndsNn2gqrF/yaMeeh7lZziUaLeqxdvX6OIpQzu8n5mSoDsvmNDjdTJTvH2QEtPMR5JHAAAAHTBtDQCAOGD3rrbmDtG0NbfH0GcltZLapsgdqGzq1znrmrvveZSelKDXbzpV3zi5UOdPKtAVJxX263r+6WADJXl04NO2KXQN3n5HaSSPAABA+FF5BABAHPBNW2sNQeVRXbNLNz+/XnsrGpVos2rW6Gwt33m03yuu+XseBZi2JkkThmTogf+Y0q/r+Pkrj+q63y8cnPXSs5dKnlbp1m1UHgEAgIii8ggAgDhg8yePgtvzaH9Fo776xxX6cPsROexW/fbKaZpWmCWp/yuuNfQwbS3oBlLl0aE1kqtBcjulknVSg7dhNskjAAAQAVQeAQAQBxJs5r8XBbPyaM3eSn3vubWqbGhRfoZDf54/U1OGZ6mhxUz67DnavyRMbyqPgsoxgHoeHVjd9rxkfdu0tdTBkRkPAACIaySPAACIA/7KI3dwKo+crW7d8P/WqbKhRVOGZ+r//nOmCjKTJJmrnknSuv1Vcra65bDb+nQNX8+jNEdCUMbcI9+0tdZmyd0q2SL4a9L+T9qeH1onNVWaz6k8AgAAEcC0NQAA4oCv55E7SJVH72wu1dF6p4ZkJulv35vtTxxJ0vj8dOWmO9Ts8mjt3io1tbg7He9ye/TgO5/rL8t3yxNgTL7Ko1RH35JPx803bU2SWurDc82ueNzSwU/bXpesk+qZtgYAACKH5BEAAHHA7p225grSamvPfbJPknT1yUVKTuyY3LFYLDptrDm96uq/rNKUhe/p3zuOdNjnmRV79cS/dukXb23Tf72wXs2uzgmm+mZfz6MwVR7ZEiWrt9ooklPXjnwuOWulhFTJYpPqy6SqPeZ7qXmRGxcAAIhbJI8AAIgDwaw82nu0QWv3VclutejKkwu73Of0E9p687jchv775U2qa3ZJksrrmvW793f6339r02F98y+rVN3Y0uEcDeHueWSxtFtxLYLJI9+UteEzpbwJHd+j5xEAAIgAkkcAAMQBu81MHrmC0POorLZZklSUnaK89KQu9/FVHklSmsOuwzXNevCdzyVJ/++T/apztmrK8Ewtun6W0pPsWrOvSve+sdV/jMdjqL6l1X982PiTRxGctuZrll10ijTy9Lbt1gQpKTMyYwIAAHGN5BEAAHEgmJVHjd4pZsdOV2svLyNJv/7aFN136ST9ef5MSdKiVfu1cleFlm4rkyTNnz1Sp44drGe/c7Ik6bUNJdpyqMZ/DcM71PAmj7x9jyKaPPJWHhXOkiZd3rbdkW5WRwEAAIQZySMAAOKA3Wre8luDkDxq9jbATukmeSRJX59ZqPmzR2r2mBxdPatIknTbixu0taRWFot01niz+fP0okG6ZOpQSdJD75rVSb5+RzarRUkJYfx1xRHhaWt1ZVLVXkkWc9ra8JPa3vOtuAYAABBmJI8AAIgDNu+0tVZP/6etNXqTR0kJvV8F7Y6vFGtIZpJKaswpb1OHZ2lwmsP//o/njVeCzaLlO4/qo51HVe80+yOlOeyyhLPaxl95FKHk0YFV5mP+JHOKmtUqDTMrt2QJ06pzAAAAxyB5BABAHEjwVR4FYbU137S1niqP2ktPStAvL5/sf31OccdVw4pyUnTNrBGSpAff3aba5gj0O5Ii3/PIlzwqnNW27apFUvFF0jdfjsyYAABA3CN5BABAHLBZfZVHwZy2dnyJnbOL83T9aaM0NDNJl88Y1un9//ryWKU57NpyqFZPfbxXUiSSRxGuPNrfrt+RT3qBmUAac3ZkxgQAAOIeySMAAOKAb7W1oDTM7sO0NZ+fXzRRK+44R8MHpXR6LyfNoe+fMVqS9I+NJZKkmSMH9WOkfeCrPHJGoPLI1SQd3mg+L5rV/b4AAABhRPIIAIA44FttzeXuf8+jpj5MW+ut604fpdx0sxdSfoZDPz2vOOjX6FYkV1srWS95XFJagZQ1IvzXBwAACIDkEQAAccC32lowKo+aWsx+RMl9qDzqSUqiXb+47ESdkJem3101XZkpCUG/RrcSI7jamn/K2slSOJuEAwAA9CDMjQQAAEAk2G3B63nkm7aWHILKI0k6b1KBzptUEJJz9yiSPY8OrDYfi04J/7UBAAC6QeURAABxwDdtrXWAT1uLOEeEVlszjHYrrZE8AgAAAwvJIwAA4oDdZt7yg1F51OSrPArBtLWIS4xQ8ujoTqmpUrInS0OmhPfaAAAAPWDaGgAAcaCt8mjgT1uLqHBPW6stkXYva7vesBmSLcx9ngAAAHpA8ggAgDhg8yaPgtIw2z9tLQZ/jQhnw+zP35Je+b7UUte2rXBW6K8LAABwnJi2BgBAHPA1zHZ5gtDzKB6mrTnDMG3t7Z92TBxJNMsGAAADEskjAADigN1q3vINQ/L0s/qo0dUqKdanrYU4edTqlGoPms8TUtu2Dz8ptNcFAADoA5JHAADEAV/lkdT/6qOmFvP4mKw8Sh5kPjZXh7b6qPaQ+WhPls5/wHw+aKSUkh26awIAAPRRDDYrAAAAx/I1zJb63/eoqcWsPEqJxcqj9Hwps0iq2S8d/FQac3bgfSt2SWv+Kp3xY8mednzXqfFWHWUOl2bMNyue8k/s+7gBAABCiOQRAABxwDdtTZJa+5E8MgxDjf6G2TGYPJKkEXOkTfulfSu6Tx49PsN89Lilc//n+K5R4608yhwmWSzS5K/1bawAAABhwLQ1AADiQPvKo1Z335NHzlaPDO/hSbGcPJLM5FEglXvanpdvPf5rtK88AgAAGOBIHgEAEAesVot8+aPWfvQ88q20JkkpsdjzSJJGnGo+HvxUcjV3vc+GxW3P3a7jv0bNAfMxg+QRAAAY+EgeAQAQJ3xT1/pTedTknbKWaLPKbovRXyNyxkipeZLbKZWs73qfzX9ve165+/iv4WuYTeURAACIAjH6Wx8AADiWzVt61J+G2Y3eyqOkhBj+FcJikYZMMZ8f3d75fcNoqxySpPoyqaWhd+euK5XeuV3a+5H5OnNY/8YKAAAQBjH8mx8AAGjPbjOTRy53/6etpSTG+JobOSeYjxVfdH6v1Sl5zBXnZPH+KlW1t3fn/fCX0qo/Sq3e6XCZhf0aJgAAQDiQPAIAIE7Yg1B55Ju2lhyrzbJ9csaYj0e7SB611Lc9L5gsSbL0Nnm0+8OOrzOoPAIAAAMfySMAAOKEr0dRa7+mrZkVN8mx2izbJ2es+dhV5ZGz1nxMSPVXKFmqetH3qLVFqivruC0xpR+DBAAACI+oSR7df//9mjNnjlJSUpSVldWrYwzD0N13360hQ4YoOTlZ5557rnbu3BnagQIAMED5Ko/61TDbP20tTpJHVXskd2vH95zeyiNHmpQ9qm2/npRtNptw25Okad+ULno0aMMFAAAIpahJHrW0tOjrX/+6FixY0OtjfvWrX+mxxx7TE088oVWrVik1NVXnnXeempsDLLsLAEAM8/U8avX0o+dRvExbyxhmJnk8rVL1vo7vOevMR0e6lD1aUi+nrR1caz6OPE267A/SzG8Hb7wAAAAhFDXJo4ULF+pHP/qRJk+e3Kv9DcPQo48+qp///Oe69NJLNWXKFD377LMqKSnRa6+9FtrBAgAwANmtwZi25k0exfq0NatVyvb2ParY1fE9X8+jxDRpkFl5ZOlN5dGhNebjsJlBGiQAAEB4xOxSKXv27FFpaanOPfdc/7bMzEzNmjVLK1eu1FVXXdXlcU6nU06n0/+6ttbsa+ByueRyuUI76CDxjTNaxoveIa6xjfjGtoESX2/hkZwtfb+n1Te3SJKS7NaIf55Qs2WPkbV8q9xHtssz6mz/dktjleySPIlpcmcUKkGSag/J6un+e7Uf/FQWSa0F02TE+HcXKwbKzy6Cj9jGPmIc+4hxcPT2+4vZ5FFpaakkKT8/v8P2/Px8/3tdeeCBB7Rw4cJO2//5z38qJSW6mlouWbIk0kNACBDX2EZ8Y1uk49vYYJNk0ccrV6liW9+qjzYdtEiy6UjpIb399oGgjm+gmVBlaJyk/es/0KajRf7tI45+ommSyqobtPpfa3Sh1SG7x6mUlqMBY5zQWq8LKs2m2v/8rEKuHW+H/gMgaCL9s4vQIbaxjxjHPmLcP42Njb3aL6LJo9tvv10PPfRQt/ts27ZNxcXFYRqRdMcdd+jWW2/1v66trVVhYaHmzZunjIyMsI2jP1wul5YsWaK5c+cqISEh0sNBkBDX2EZ8Y9tAie//7VupksY6fWnmTJ05LrdP59j83g7pwF4Vjx2lC74yPsgjHFgsm2qlf/xDI9JcGn7BBf7t1k92Swek/MKxuuDCC2UrGSuVb1WKs1yzL57fZYwtu5ZKmyUje7TmXnJlOD8G+mGg/Owi+Iht7CPGsY8YB4dvtlVPIpo8uu2223Tttdd2u8/o0aP7dO6CggJJUllZmYYMGeLfXlZWpmnTpgU8zuFwyOFwdNqekJAQdX8ho3HM6BlxjW3EN7ZFOr4JNm+fIoutz+OobjJXHhucnhT7f1fzzOSYtXK3rO0/a2uTuT0pw9yeM1oq36o0Z1ngGJdukCRZhp8U+99bDIr0zy5Ch9jGPmIc+4hx//T2u4to8ig3N1e5uX37l8+ejBo1SgUFBVq6dKk/WVRbW6tVq1Yd14ptAADECru1/6utVTaYPY+yUxODMqYBLWes+Vh7SGppkBJTzdftV1uT/E2zU1vKAp/rIM2yAQBA9Iqa1db279+vDRs2aP/+/XK73dqwYYM2bNig+vp6/z7FxcV69dVXJUkWi0W33HKLfvGLX+iNN97Q5s2bNX/+fA0dOlSXXXZZhD4FAACRY7f5kkd9X22tIp6SRynZUvIg87m3X5GkdsmjNPMx26ySTnGWd30ew5AOrTWfD/9SCAYKAAAQWlHTMPvuu+/WM8884389ffp0SdKHH36os846S5K0fft21dTU+Pf56U9/qoaGBn3ve99TdXW1TjvtNL377rtKSkoK69gBABgI7Fbz34xa3X1PHlU2mCuS5sRD8kiSck6QDq6Wju6UCiab23zJo0Rv5ZE3eZTmDFB5VLlbaqqUbA4pf3KIBwwAABB8UZM8evrpp/X00093u49hdPxl2GKx6L777tN9990XwpEBABAdglF5VFkfR5VHkjl17eBqqWJX27YWb9Wzb9patjltLaXliNwet6Rjegf4qo6GTJHscfK9AQCAmBI109YAAED/+HseufvW86jZ5VZDi1uSlJPaeXGJmJQzxnys+KJtm9OXPPJOW8sYJsOWKKvhNvsjHYt+RwAAIMqRPAIAIE7YrP2rPPI1y7ZbLcpIjpri5f7xNc3ukDw6pmG21SZlFUmSLFV7O5/jkDd5NJzkEQAAiE4kjwAAiBN2m3nbf3NTiXYdqe9h7858yaNBqYmyWCxBHduA5U8e7TQbX0tSyzE9jyQZ3hXXLFXextrLH5Y++aPU6pRKN5vbhtEsGwAARCeSRwAAxAnftLVPdlfq5ufXH/fxvpXW4qZZtuRvhq3mGqmxwnx+bOWRJGOQd7+qPVJ9ubT0Pund26V9H0vuFiklRxo0MnzjBgAACCKSRwAAxAnfamuS9NnhWtU1u47reN9Ka3HTLFuSElOkzELzecUXZvXRsT2PJH9iyFK1V2o42rZ980vm47CZUrxUawEAgJhD8ggAgDjRflVSw5A2H6o5ruMr4m2lNZ/2TbNbnZLHm3RzdDVtbY/U2C559Plb5uOQKeEYKQAAQEiQPAIAIE58sruiw+tNB48veVQZj9PWpI5Ns1va9YpKbKs8MnxT0qr2Sg1H2vZprjYf8yaEcoQAAAAhRfIIAIA48aWR2R1ebzxQfVzH+5JH2amOYA0pOrRPHjlrzecJqeYqaz5ZRTJkkcXVKJV91vkceRNDP04AAIAQiZN1dgEAwM8vnKDignSNHpyqBYvWHVfy6L2tpXpz02FJUnZavFYe7eq635Ek2RLVmDhYqS1HpIOrO75nTZCyx4R+nAAAACFC8ggAgDiRn5Gkm84eq3pnqywWqaSmWeV1zcpLT+r2uH0VDfr+c2v9r+Nv2pqv59GutmloiWmddmtw5JnJo0PrOr4x+ATJHmffGQAAiClMWwMAIM6kOew6Ic9Mfmw60HPfow3HVCgVZaeEYlgDV9YIs3rI7ZQOrDK3ZQzttFuDI9980r4vksSUNQAAEPVIHgEAEIemDM+SJG08WN3jvltLzD4/p40drOeuO1knDssM4cgGIKtNyh5tPv/iA/Mxa0Sn3RoS87o+nmbZAAAgypE8AgAgDk0tzJIkbezFimtbDpn7XDx1iE4/ITeUwxq4fH2PfP2Msoo67eKvPPJJyjIfC2eFblwAAABhQM8jAADi0DRf5dGBahmGIYvF0uV+hmH4k0dxV3HUnq/vkafVfBzUReXRscmjb7wgWe1S4UkhHhwAAEBokTwCACAOjS9IV6LNqpoml/ZVNOpovVMtrR7NGTu4w34Hq5pU29yqRJtVJ+SlR2i0A4Cv8sini2lrjY5jqrJyxkhpAaayAQAARBGmrQEAEIcS7VZNHJohSVq1p0Jfe2Klrv7LKtU2uzrs56s6Gl+QrkR7HP/acGzyqIvKI7fVISOtoG1DcnaIBwUAABAecfxbIAAA8W2at+/Ri2sO+reV1zo77LOlxDdlLSNs4xqQBp/Q9tzmkNonidoxBo00nyQPkmwUeAMAgNhA8ggAgDg1tdDsYbR2X5V/W2VDS4d9thwyV1qbNDSO+x1JUmqu5PAm0LIKJWuAX6EGjW7bHwAAIEaQPAIAIE5N8TbNbu9ofVvlEc2y27FY2ppmd9HvyMfIHmU+SRkccB8AAIBoQ/IIAIA4NSonVelJHadWVbRLHpXVOlXR0CKb1aLigjhulu3j63vURb8jH6Notvlk2IwwDAgAACA8SB4BABCnrFaLph5TfXS0vm3amq/q6IS8NCUl2MI5tIFp0uVSWr5UfFHAXYzCU6Sf7JLm/SKMAwMAAAgtOjkCABDHpgzP1EdfHPW/rmhoqzzyNcuO+35HPsUXmn96ksqUNQAAEFuoPAIAII6ddkLHRMfRuvaVR2az7LhfaQ0AACDOkTwCACCOzRkzWC8vmKNfXHaipI6VR1tLaJYNAAAApq0BABD3vjRikFxujySpwtvz6Gi9U4drmmWxSBOGUHkEAAAQz6g8AgAAGpzmkGQmjSRpa4k5ZW3U4FSlOfi3JgAAgHhG8ggAAGhwWqIkqba5Vc5Wt3+ltRNplg0AABD3SB4BAABlJCXIbrVIkiobWtr1O2LKGgAAQLwjeQQAAGS1WpSdalYfVdS3tK20RuURAABA3CN5BAAAJEk53r5Hu47Ua39loyRpEskjAACAuEfyCAAASGrre/T+tnJJUlF2ijJTEiI5JAAAAAwAJI8AAIAkaeJQs7/Ru1sOS5ImD6PqCAAAACSPAACA10kjsiVJLrchSZo8nOQRAAAASB4BAACvmSMHdXhN5REAAAAkkkcAAMArKyVR4/LT/K9ZaQ0AAAASySMAANDOzJHm1LWROTTLBgAAgInkEQAA8DtvUoEk6azxeREeCQAAAAYKe6QHAAAABo4zx+Vq2Y/P0pCspEgPBQAAAAMEySMAANDByMGpkR4CAAAABhCmrQEAAAAAACAgkkcAAAAAAAAIiOQRAAAAAAAAAiJ5BAAAAAAAgIBIHgEAAAAAACAgkkcAAAAAAAAIiOQRAAAAAAAAAiJ5BAAAAAAAgIBIHgEAAAAAACAgkkcAAAAAAAAIiOQRAAAAAAAAAiJ5BAAAAAAAgICiJnl0//33a86cOUpJSVFWVlaP+7tcLv33f/+3Jk+erNTUVA0dOlTz589XSUlJ6AcLAAAAAAAQI6ImedTS0qKvf/3rWrBgQa/2b2xs1Lp163TXXXdp3bp1euWVV7R9+3ZdcsklIR4pAAAAAABA7LBHegC9tXDhQknS008/3av9MzMztWTJkg7bfv/73+vkk0/W/v37VVRUFOwhAgAAAAAAxJyoSR4FQ01NjSwWS7fT3pxOp5xOp/91bW2tJHManMvlCvUQg8I3zmgZL3qHuMY24hvbiG/sI8axibjGLmIb+4hx7CPGwdHb789iGIYR4rEE1dNPP61bbrlF1dXVx3Vcc3OzTj31VBUXF2vRokUB97v33nv9VU7tLV68WCkpKcc7XAAAAAAAgAGpsbFRV199tWpqapSRkRFwv4hWHt1+++166KGHut1n27ZtKi4u7td1XC6XrrjiChmGoT/+8Y/d7nvHHXfo1ltv9b+ura1VYWGh5s2b1+0XOZC4XC4tWbJEc+fOVUJCQqSHgyAhrrGN+MY24hv7iHFsIq6xi9jGPmIc+4hxcPhmW/Ukosmj2267Tddee223+4wePbpf1/Aljvbt26cPPvigxwSQw+GQw+HotD0hISHq/kJG45jRM+Ia24hvbCO+sY8YxybiGruIbewjxrGPGPdPb7+7iCaPcnNzlZubG7Lz+xJHO3fu1IcffqicnJyQXQsAAAAAACAWWSM9gN7av3+/NmzYoP3798vtdmvDhg3asGGD6uvr/fsUFxfr1VdflWQmjr72ta9pzZo1WrRokdxut0pLS1VaWqqWlpZIfQwAAAAAAICoEjWrrd1999165pln/K+nT58uSfrwww911llnSZK2b9+umpoaSdKhQ4f0xhtvSJKmTZvW4Vztj+mJr594b+cBDgQul0uNjY2qra2lfC+GENfYRnxjG/GNfcQ4NhHX2EVsYx8xjn3EODh8uY6e1lKLutXWwu3gwYMqLCyM9DAAAAAAAABC4sCBAxo+fHjA90ke9cDj8aikpETp6emyWCyRHk6v+FaIO3DgQNSsEIeeEdfYRnxjG/GNfcQ4NhHX2EVsYx8xjn3EODgMw1BdXZ2GDh0qqzVwZ6OombYWKVartdvs20CWkZHBD1EMIq6xjfjGNuIb+4hxbCKusYvYxj5iHPuIcf9lZmb2uE/UNMwGAAAAAABA+JE8AgAAAAAAQEAkj2KQw+HQPffcI4fDEemhIIiIa2wjvrGN+MY+YhybiGvsIraxjxjHPmIcXjTMBgAAAAAAQEBUHgEAAAAAACAgkkcAAAAAAAAIiOQRAAAAAAAAAiJ5BAAAAAAAgIBIHoXRAw88oJNOOknp6enKy8vTZZddpu3bt3fYp7m5WTfddJNycnKUlpamr371qyorK/O/v3HjRn3jG99QYWGhkpOTNWHCBP3ud7/rcI5XXnlFc+fOVW5urjIyMjR79my99957PY7PMAzdfffdGjJkiJKTk3Xuuedq586dHfa5//77NWfOHKWkpCgrK6vvX0YMiYW4+jidTk2bNk0Wi0UbNmw4/i8jxkR7bJctWyaLxdLln08//bSf305sGOgxfuWVVzRv3jzl5OQE/LnsaXzxLFzx/eijj3TqqacqJydHycnJKi4u1m9/+9sex8d9t29iIa4+3Hc7i/b4cu/t3kCPL/fd/gtXjNv7+OOPZbfbNW3atB7Hx723HwyEzXnnnWc89dRTxpYtW4wNGzYYF1xwgVFUVGTU19f797nhhhuMwsJCY+nSpcaaNWuMU045xZgzZ47//SeffNK4+eabjWXLlhm7du0ynnvuOSM5Odl4/PHH/fv88Ic/NB566CFj9erVxo4dO4w77rjDSEhIMNatW9ft+B588EEjMzPTeO2114yNGzcal1xyiTFq1CijqanJv8/dd99tPPLII8att95qZGZmBu/LiWKxEFefm2++2fjKV75iSDLWr1/f/y8nykV7bJ1Op3H48OEOf66//npj1KhRhsfjCfK3FZ0GeoyfffZZY+HChcaf//zngD+XPY0vnoUrvuvWrTMWL15sbNmyxdizZ4/x3HPPGSkpKcaf/vSnbsfHfbdvYiGuPtx3O4v2+HLv7d5Ajy/33f4LV4x9qqqqjNGjRxvz5s0zpk6d2uP4uPf2HcmjCCovLzckGf/6178MwzCM6upqIyEhwfj73//u32fbtm2GJGPlypUBz3PjjTcaZ599drfXmjhxorFw4cKA73s8HqOgoMD49a9/7d9WXV1tOBwO4/nnn++0/1NPPcUPUgDRGte3337bKC4uNrZu3covsQFEa2x9WlpajNzcXOO+++7r9trxbCDFuL09e/Z0+XPZ1/HFq3DG9/LLLze++c1vBnyf+27wRGtcue/2TrTG14d7b/cGUnzb474bPKGO8ZVXXmn8/Oc/N+65554ek0fce/uHaWsRVFNTI0nKzs6WJK1du1Yul0vnnnuuf5/i4mIVFRVp5cqV3Z7Hd46ueDwe1dXVdbvPnj17VFpa2uHamZmZmjVrVrfXRmfRGNeysjJ997vf1XPPPaeUlJSeP2ScisbYtvfGG2+ooqJC3/72twOeN94NpBj3Rl/HF6/CFd/169drxYoVOvPMMwPuw303eKIxrtx3ey8a49se997uDaT49gb33eMXyhg/9dRT2r17t+65555ejYV7b//YIz2AeOXxeHTLLbfo1FNP1YknnihJKi0tVWJiYqd5lfn5+SotLe3yPCtWrNDf/vY3vfXWWwGv9Zvf/Eb19fW64oorAu7jO39+fn6vr43OojGuhmHo2muv1Q033KCZM2dq7969PX3MuBSNsT3Wk08+qfPOO0/Dhw8PeN54NtBi3Bt9GV+8Ckd8hw8friNHjqi1tVX33nuvrr/++oDj4b4bHNEYV+67vReN8T0W997ABlp8e4P77vEJZYx37typ22+/XcuXL5fd3ru0Bvfe/qHyKEJuuukmbdmyRS+88EKfz7FlyxZdeumluueeezRv3rwu91m8eLEWLlyoF198UXl5eZKkRYsWKS0tzf9n+fLlfR4DOorGuD7++OOqq6vTHXfc0ecxx4NojG17Bw8e1Hvvvafrrruuz+OPddEeY3QvHPFdvny51qxZoyeeeEKPPvqonn/+eUnEN5SiMa7cd3svGuPbHvfe7kV7fNGzUMXY7Xbr6quv1sKFCzVu3LgujyPGIRDpeXPx6KabbjKGDx9u7N69u8P2pUuXGpKMqqqqDtuLioqMRx55pMO2rVu3Gnl5ecadd94Z8DrPP/+8kZycbLz55psdttfW1ho7d+70/2lsbDR27drV5bzeM844w7j55ps7nZv5n51Fa1wvvfRSw2q1Gjabzf9HkmGz2Yz58+cf57cQm6I1tu3dd999Rm5urtHS0tKLTxx/BmKM2wvUe+F4xhfPwhXf9v7nf/7HGDdunGEY3HdDJVrjyn23d6I1vu1x7w1sIMa3Pe67/RfKGFdVVfn/u+n7Y7FY/NuWLl3KvTcESB6FkcfjMW666SZj6NChxo4dOzq972se9tJLL/m3ff75552ah23ZssXIy8szfvKTnwS81uLFi42kpCTjtdde6/XYCgoKjN/85jf+bTU1NTQP64Voj+u+ffuMzZs3+/+89957hiTjpZdeMg4cONCr68SqaI9t+31HjRpl3Hbbbb06dzwZyDFur6fGnT2NL16FM77HWrhwoTFixIhux8Z9t2+iPa7cd7sX7fFtvy/33s4Gcnzb477bd+GIsdvt7vDf0c2bNxsLFiwwxo8fb2zevLnDym7Hjo17b9+RPAqjBQsWGJmZmcayZcs6LN/ZPtN9ww03GEVFRcYHH3xgrFmzxpg9e7Yxe/Zs//ubN282cnNzjW9+85sdzlFeXu7fZ9GiRYbdbjf+8Ic/dNinurq62/E9+OCDRlZWlvH6668bmzZtMi699NJOyxbu27fPWL9+vbFw4UIjLS3NWL9+vbF+/Xqjrq4uiN9UdImFuLYX6GYZj2Iltu+//74hydi2bVuQvpnYMdBjXFFRYaxfv9546623DEnGCy+8YKxfv944fPhwr8cXz8IV39///vfGG2+8YezYscPYsWOH8Ze//MVIT083fvazn3U7Pu67fRMLcW2P+25HsRJf7r1dG+jx5b7bf+GK8bF6s9qaYXDv7Q+SR2Ekqcs/Tz31lH+fpqYm48YbbzQGDRpkpKSkGJdffnmH/1jdc889XZ6jfRb9zDPP7HKfb33rW92Oz+PxGHfddZeRn59vOBwO45xzzjG2b9/eYZ9vfetbXZ77ww8/DMI3FJ1iIa7t8Utsm1iJ7Te+8Q1jzpw5/f06YtJAj/FTTz3V5XH33HNPr8cXz8IV38cee8yYNGmSkZKSYmRkZBjTp083/vd//9dwu93djo/7bt/EQlzb477bUazEl3tv1wZ6fLnv9l+4Ynys3iaPuPf2ncUwDEMAAAAAAABAF1htDQAAAAAAAAGRPAIAAAAAAEBAJI8AAAAAAAAQEMkjAAAAAAAABETyCAAAAAAAAAGRPAIAAAAAAEBAJI8AAAAAAAAQEMkjAAAAAAAABETyCAAAAAAAAAGRPAIAAAiya6+9VhaLRRaLRQkJCcrPz9fcuXP117/+VR6Pp9fnefrpp5WVlRW6gQIAAPQCySMAAIAQOP/883X48GHt3btX77zzjs4++2z98Ic/1EUXXaTW1tZIDw8AAKDXSB4BAACEgMPhUEFBgYYNG6YZM2bozjvv1Ouvv6533nlHTz/9tCTpkUce0eTJk5WamqrCwkLdeOONqq+vlyQtW7ZM3/72t1VTU+OvYrr33nslSU6nUz/+8Y81bNgwpaamatasWVq2bFlkPigAAIh5JI8AAADC5Mtf/rKmTp2qV155RZJktVr12GOPaevWrXrmmWf0wQcf6Kc//akkac6cOXr00UeVkZGhw4cP6/Dhw/rxj38sSfrBD36glStX6oUXXtCmTZv09a9/Xeeff7527twZsc8GAABil8UwDCPSgwAAAIgl1157raqrq/Xaa691eu+qq67Spk2b9Nlnn3V676WXXtINN9ygo0ePSjJ7Ht1yyy2qrq7277N//36NHj1a+/fv19ChQ/3bzz33XJ188sn65S9/GfTPAwAA4ps90gMAAACIJ4ZhyGKxSJLef/99PfDAA/r8889VW1ur1tZWNTc3q7GxUSkpKV0ev3nzZrndbo0bN67DdqfTqZycnJCPHwAAxB+SRwAAAGG0bds2jRo1Snv37tVFF12kBQsW6P7771d2drY++ugjXXfddWppaQmYPKqvr5fNZtPatWtls9k6vJeWlhaOjwAAAOIMySMAAIAw+eCDD7R582b96Ec/0tq1a+XxePTwww/LajXbUL744osd9k9MTJTb7e6wbfr06XK73SovL9fpp58etrEDAID4RfIIAAAgBJxOp0pLS+V2u1VWVqZ3331XDzzwgC666CLNnz9fW7Zskcvl0uOPP66LL75YH3/8sZ544okO5xg5cqTq6+u1dOlSTZ06VSkpKRo3bpyuueYazZ8/Xw8//LCmT5+uI0eOaOnSpZoyZYouvPDCCH1iAAAQq1htDQAAIATeffddDRkyRCNHjtT555+vDz/8UI899phef/112Ww2TZ06VY888ogeeughnXjiiVq0aJEeeOCBDueYM2eObrjhBl155ZXKzc3Vr371K0nSU089pfnz5+u2227T+PHjddlll+nTTz9VUVFRJD4qAACIcay2BgAAAAAAgICoPAIAAAAAAEBAJI8AAAAAAAAQEMkjAAAAAAAABETyCAAAAAAAAAGRPAIAAAAAAEBAJI8AAAAAAAAQEMkjAAAAAAAABETyCAAAAAAAAAGRPAIAAAAAAEBAJI8AAAAAAAAQEMkjAAAAAAAABPT/Ab9qDAGzdACOAAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image(filename=\"./18778f8594ab45df9a35a48a1dd8d0a2.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember, IPython kernel is stateful. If you want to start over, you need to\n", + "restart the executor." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "0.00s - Debugger warning: It seems that frozen modules are being used, which may\n", + "0.00s - make the debugger miss breakpoints. Please pass -Xfrozen_modules=off\n", + "0.00s - to python to disable frozen modules.\n", + "0.00s - Note: Debugging will proceed. Set PYDEVD_DISABLE_FILE_VALIDATION=1 to disable this validation.\n" + ] + } + ], + "source": [ + "user_proxy.code_executor.restart()" + ] } ], "metadata": { From 4e222c00488db3921c7c1ba4ea99e79a4e3a290c Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sat, 27 Jan 2024 00:45:27 -0800 Subject: [PATCH 16/52] raise instead of return None --- autogen/agentchat/conversable_agent.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index c87c530f051..2b854881528 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -205,10 +205,13 @@ def __init__( self.hook_lists = {self.process_last_message: []} # This is currently the only hookable method. @property - def code_executor(self) -> CodeExecutor | None: - """The code executor used by this agent. None if code execution is disabled.""" + def code_executor(self) -> CodeExecutor: + """The code executor used by this agent. Raise if code execution is disabled.""" if not hasattr(self, "_code_executor"): - return None + raise ValueError( + "No code executor as code execution is disabled. " + "To enable code execution, set code_execution_config." + ) return self._code_executor def register_reply( From fa840091c5fa0e3c785493de13e02ba7851f94e8 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sun, 28 Jan 2024 22:16:22 -0800 Subject: [PATCH 17/52] allow user provided code executor. --- autogen/coding/base.py | 3 ++- autogen/coding/factory.py | 27 ++++++++++++++++++++++----- test/coding/test_factory.py | 30 ++++++++++++++++++++++++++++++ 3 files changed, 54 insertions(+), 6 deletions(-) create mode 100644 test/coding/test_factory.py diff --git a/autogen/coding/base.py b/autogen/coding/base.py index dc3051b039d..bb3a22b900d 100644 --- a/autogen/coding/base.py +++ b/autogen/coding/base.py @@ -1,4 +1,4 @@ -from typing import List, Protocol +from typing import List, Protocol, runtime_checkable from pydantic import BaseModel @@ -38,6 +38,7 @@ def extract_code_blocks(self, message: str) -> List[CodeBlock]: ... # pragma: no cover +@runtime_checkable class CodeExecutor(Protocol): """A code executor class that executes code blocks and returns the result.""" diff --git a/autogen/coding/factory.py b/autogen/coding/factory.py index d6af9abb427..e1f272f3de7 100644 --- a/autogen/coding/factory.py +++ b/autogen/coding/factory.py @@ -8,15 +8,32 @@ class CodeExecutorFactory: @staticmethod def create(code_execution_config: Dict) -> CodeExecutor: - """Get a code executor based on the code execution config.""" - executor_name = code_execution_config.get("executor") - if executor_name == "ipython": + """Get a code executor based on the code execution config. + + Args: + code_execution_config (Dict): The code execution config, + which is a dictionary that must contain the key "executor". + The value of the key "executor" can be either a string + or an instance of CodeExecutor, in which case the code + executor is returned directly. + + Returns: + CodeExecutor: The code executor. + + Raises: + ValueError: If the code executor is unknown or not specified. + """ + executor = code_execution_config.get("executor") + if isinstance(executor, CodeExecutor): + # If the executor is already an instance of CodeExecutor, return it. + return executor + if executor == "ipython": from autogen.coding.ipython_code_executor import IPythonCodeExecutor return IPythonCodeExecutor(**code_execution_config.get("ipython", {})) - elif executor_name == "commandline": + elif executor == "commandline": from autogen.coding.commandline_code_executor import CommandlineCodeExecutor return CommandlineCodeExecutor(**code_execution_config.get("commandline", {})) else: - raise ValueError(f"Unknown code executor {executor_name}") + raise ValueError(f"Unknown code executor {executor}") diff --git a/test/coding/test_factory.py b/test/coding/test_factory.py new file mode 100644 index 00000000000..04bafa57723 --- /dev/null +++ b/test/coding/test_factory.py @@ -0,0 +1,30 @@ +import pytest +from autogen.coding.commandline_code_executor import CommandlineCodeExecutor +from autogen.coding.factory import CodeExecutorFactory +from autogen.coding.ipython_code_executor import IPythonCodeExecutor + + +def test_create(): + config = {"executor": "ipython"} + executor = CodeExecutorFactory.create(config) + assert isinstance(executor, IPythonCodeExecutor) + + config = {"executor": "commandline"} + executor = CodeExecutorFactory.create(config) + assert isinstance(executor, CommandlineCodeExecutor) + + config = {"executor": IPythonCodeExecutor()} + executor = CodeExecutorFactory.create(config) + assert isinstance(executor, IPythonCodeExecutor) + + config = {"executor": CommandlineCodeExecutor()} + executor = CodeExecutorFactory.create(config) + assert isinstance(executor, CommandlineCodeExecutor) + + config = {"executor": "unknown"} + with pytest.raises(ValueError, match="Unknown code executor unknown"): + executor = CodeExecutorFactory.create(config) + + config = {} + with pytest.raises(ValueError, match="Unknown code executor None"): + executor = CodeExecutorFactory.create(config) From 0441eb129665bdab0c0febd3b71c3fbe58b5cdb8 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Tue, 30 Jan 2024 06:59:04 +0100 Subject: [PATCH 18/52] fixing types --- autogen/agentchat/agent.py | 11 +++ autogen/agentchat/conversable_agent.py | 5 +- autogen/code_utils.py | 12 +-- autogen/coding/__init__.py | 5 ++ autogen/coding/base.py | 10 ++- autogen/coding/commandline_code_executor.py | 83 ++++++++++++------- autogen/coding/factory.py | 12 +-- autogen/coding/ipython_code_executor.py | 31 ++++--- autogen/coding/markdown_code_extractor.py | 11 ++- test/coding/test_commandline_code_executor.py | 33 ++++---- test/coding/test_factory.py | 6 +- test/coding/test_ipython_code_executor.py | 22 ++--- test/coding/test_markdown_code_extractor.py | 4 +- 13 files changed, 153 insertions(+), 92 deletions(-) diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index b83709dc30b..66cefc710db 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -24,6 +24,17 @@ def name(self): """Get the name of the agent.""" return self._name + @property + def system_message(self) -> Union[str, List]: + """(Abstract method) Return the system message.""" + + def update_system_message(self, system_message: Union[str, List]): + """(Abstract method) Update the system message. + + Args: + system_message (str or List): system message for the ChatCompletion inference. + """ + def send(self, message: Union[Dict, str], recipient: "Agent", request_reply: Optional[bool] = None): """(Abstract method) Send a message to another agent.""" diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 2b854881528..6c06cb13dbb 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -8,9 +8,8 @@ from collections import defaultdict from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional, Tuple, Type, TypeVar, Union import warnings -from autogen.coding.base import CodeExecutor - -from autogen.coding.factory import CodeExecutorFactory +from ..coding.base import CodeExecutor +from ..coding.factory import CodeExecutorFactory from .. import OpenAIWrapper from ..cache.cache import Cache diff --git a/autogen/code_utils.py b/autogen/code_utils.py index 00fe01589d8..bcc212e67bb 100644 --- a/autogen/code_utils.py +++ b/autogen/code_utils.py @@ -8,7 +8,7 @@ import time from concurrent.futures import ThreadPoolExecutor, TimeoutError from hashlib import md5 -from typing import Callable, Dict, List, Optional, Tuple, Union +from typing import Any, Callable, Dict, List, Optional, Tuple, Union from autogen import oai @@ -40,7 +40,7 @@ logger = logging.getLogger(__name__) -def content_str(content: Union[str, List, None]) -> str: +def content_str(content: Union[str, List[Dict[str, Any]], None]) -> str: """Converts `content` into a string format. This function processes content that may be a string, a list of mixed text and image URLs, or None, @@ -81,7 +81,7 @@ def content_str(content: Union[str, List, None]) -> str: return rst -def infer_lang(code): +def infer_lang(code: str) -> str: """infer the language for the code. TODO: make it robust. """ @@ -226,7 +226,7 @@ def _cmd(lang): raise NotImplementedError(f"{lang} not recognized in code execution") -def is_docker_running(): +def is_docker_running() -> bool: """Check if docker is running. Returns: @@ -242,7 +242,7 @@ def is_docker_running(): return False -def in_docker_container(): +def in_docker_container() -> bool: """Check if the code is running in a docker container. Returns: @@ -320,7 +320,7 @@ def execute_code( work_dir: Optional[str] = None, use_docker: Union[List[str], str, bool] = SENTINEL, lang: Optional[str] = "python", -) -> Tuple[int, str, str]: +) -> Tuple[int, str, Optional[str]]: """Execute code in a docker container. This function is not tested on MacOS. diff --git a/autogen/coding/__init__.py b/autogen/coding/__init__.py index e69de29bb2d..7c223401d58 100644 --- a/autogen/coding/__init__.py +++ b/autogen/coding/__init__.py @@ -0,0 +1,5 @@ +from .base import CodeBlock, CodeExecutor, CodeExtractor, CodeResult +from .factory import CodeExecutorFactory +from .markdown_code_extractor import MarkdownCodeExtractor + +__all__ = ("CodeBlock", "CodeResult", "CodeExtractor", "CodeExecutor", "CodeExecutorFactory", "MarkdownCodeExtractor") diff --git a/autogen/coding/base.py b/autogen/coding/base.py index bb3a22b900d..3359294a59a 100644 --- a/autogen/coding/base.py +++ b/autogen/coding/base.py @@ -1,7 +1,11 @@ -from typing import List, Protocol, runtime_checkable +from typing import Any, Dict, List, Protocol, Union, runtime_checkable from pydantic import BaseModel +from ..agentchat.agent import Agent + +__all__ = ("CodeBlock", "CodeResult", "CodeExtractor", "CodeExecutor") + class CodeBlock(BaseModel): """A class that represents a code block.""" @@ -26,7 +30,7 @@ class CodeResult(BaseModel): class CodeExtractor(Protocol): """A code extractor class that extracts code blocks from a message.""" - def extract_code_blocks(self, message: str) -> List[CodeBlock]: + def extract_code_blocks(self, message: Union[str, List[Dict[str, Any]], None]) -> List[CodeBlock]: """Extract code blocks from a message. Args: @@ -45,7 +49,7 @@ class CodeExecutor(Protocol): class UserCapability(Protocol): """An AgentCapability class that gives agent ability use this code executor.""" - def add_to_agent(self, agent): + def add_to_agent(self, agent: Agent) -> None: ... # pragma: no cover @property diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py index b57d4c9f5b1..35a678eb7dd 100644 --- a/autogen/coding/commandline_code_executor.py +++ b/autogen/coding/commandline_code_executor.py @@ -1,20 +1,22 @@ -from typing import List, Optional, Union import warnings +from typing import Any, List, Optional, Tuple, Union from pydantic import BaseModel, Field -from autogen.coding.base import CodeBlock, CodeExtractor, CodeResult -from autogen.coding.markdown_code_extractor import MarkdownCodeExtractor +from ..agentchat.agent import Agent +from ..code_utils import DEFAULT_TIMEOUT, WORKING_DIR, execute_code +from .base import CodeBlock, CodeExtractor, CodeResult +from .markdown_code_extractor import MarkdownCodeExtractor try: from termcolor import colored except ImportError: - def colored(x, *args, **kwargs): - return x + def colored(x: Any, *args: Any, **kwargs: Any) -> str: # type: ignore[misc] + return x # type: ignore[no-any-return] -from autogen.code_utils import DEFAULT_TIMEOUT, WORKING_DIR, execute_code +__all__ = ("CommandlineCodeExecutor",) class CommandlineCodeExecutor(BaseModel): @@ -40,9 +42,16 @@ class UserCapability: If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. """ - def add_to_agent(self, agent): + def add_to_agent(self, agent: Agent) -> None: """Add this capability to an agent.""" - agent.update_system_message(agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE) + # system message is a string or a list of strings + if isinstance(agent.system_message, str): + system_message_str = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE + agent.update_system_message(system_message_str) + else: + system_message_list = agent.system_message.copy() + system_message_list[0] = system_message_list[0] + self.DEFAULT_SYSTEM_MESSAGE_UPDATE + agent.update_system_message(system_message_list) timeout: Optional[int] = Field(default=DEFAULT_TIMEOUT, ge=1) filename: Optional[str] = None @@ -50,7 +59,7 @@ def add_to_agent(self, agent): use_docker: Optional[Union[List[str], str, bool]] = None docker_image_name: Optional[str] = None - def _get_use_docker_for_code_utils(self): + def _get_use_docker_for_code_utils(self) -> Optional[Union[List[str], str, bool]]: if self.use_docker is False: return False if self.docker_image_name is not None: @@ -69,6 +78,30 @@ def code_extractor(self) -> CodeExtractor: """Export a code extractor that can be used by an agent.""" return MarkdownCodeExtractor() + def _execute_code(self, code: str, lang: str, filename: Optional[str] = None) -> Tuple[int, str, Optional[str]]: + use_docker = self._get_use_docker_for_code_utils() + filename = self.filename if filename is None else filename + # execute_code cannot handle None for use_docker + if use_docker is None: + return execute_code( + code=code, + lang=lang, + filename=filename, + timeout=self.timeout, + work_dir=self.work_dir, + ) + else: + exitcode, logs, image = execute_code( + code=code, + lang=lang, + filename=filename, + timeout=self.timeout, + work_dir=self.work_dir, + use_docker=use_docker, + ) + + return exitcode, logs, image + def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: """Execute the code blocks and return the result.""" logs_all = "" @@ -82,34 +115,24 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: flush=True, ) if lang in ["bash", "shell", "sh"]: - exitcode, logs, image = execute_code( - code=code, - lang=lang, - timeout=self.timeout, - work_dir=self.work_dir, - filename=self.filename, - use_docker=self._get_use_docker_for_code_utils(), - ) + exitcode, logs, image = self._execute_code(code, lang) + # exitcode, logs, image = execute_code( + # code=code, + # lang=lang, + # timeout=self.timeout, + # work_dir=self.work_dir, + # filename=self.filename, + # use_docker=self._get_use_docker_for_code_utils(), + # ) elif lang in ["python", "Python"]: if code.startswith("# filename: "): filename = code[11 : code.find("\n")].strip() else: filename = None - exitcode, logs, image = execute_code( - code, - lang="python", - filename=filename, - timeout=self.timeout, - work_dir=self.work_dir, - use_docker=self._get_use_docker_for_code_utils(), - ) + exitcode, logs, image = self._execute_code(code, "python", filename=filename) else: # In case the language is not supported, we return an error message. - exitcode, logs, image = ( - 1, - f"unknown language {lang}", - None, - ) + exitcode, logs, image = (1, f"unknown language {lang}", None) # raise NotImplementedError if image is not None: # Update the image to use for the next execution. diff --git a/autogen/coding/factory.py b/autogen/coding/factory.py index e1f272f3de7..5a21c76d0c3 100644 --- a/autogen/coding/factory.py +++ b/autogen/coding/factory.py @@ -1,13 +1,15 @@ -from typing import Dict +from typing import Any, Dict -from autogen.coding.base import CodeExecutor +from .base import CodeExecutor + +__all__ = ("CodeExecutorFactory",) class CodeExecutorFactory: """A factory class for creating code executors.""" @staticmethod - def create(code_execution_config: Dict) -> CodeExecutor: + def create(code_execution_config: Dict[str, Any]) -> CodeExecutor: """Get a code executor based on the code execution config. Args: @@ -28,11 +30,11 @@ def create(code_execution_config: Dict) -> CodeExecutor: # If the executor is already an instance of CodeExecutor, return it. return executor if executor == "ipython": - from autogen.coding.ipython_code_executor import IPythonCodeExecutor + from .ipython_code_executor import IPythonCodeExecutor return IPythonCodeExecutor(**code_execution_config.get("ipython", {})) elif executor == "commandline": - from autogen.coding.commandline_code_executor import CommandlineCodeExecutor + from .commandline_code_executor import CommandlineCodeExecutor return CommandlineCodeExecutor(**code_execution_config.get("commandline", {})) else: diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index fcf991f4d1c..cbb9c4cb369 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -1,17 +1,21 @@ import base64 import json import os -from queue import Empty import re -from typing import List import uuid +from queue import Empty +from typing import Any, List -from jupyter_client import KernelManager -from jupyter_client.kernelspec import NoSuchKernel, KernelSpecManager +from jupyter_client import KernelManager # type: ignore[attr-defined] +from jupyter_client.kernelspec import KernelSpecManager, NoSuchKernel from pydantic import BaseModel, Field -from autogen.code_utils import DEFAULT_TIMEOUT -from autogen.coding.base import CodeBlock, CodeExtractor, CodeResult -from autogen.coding.markdown_code_extractor import MarkdownCodeExtractor + +from ..agentchat.agent import Agent +from ..code_utils import DEFAULT_TIMEOUT +from .base import CodeBlock, CodeExtractor, CodeResult +from .markdown_code_extractor import MarkdownCodeExtractor + +__all__ = ("IPythonCodeExecutor",) class IPythonCodeExecutor(BaseModel): @@ -50,15 +54,22 @@ class UserCapability: the output will be a path to the image instead of the image itself. """ - def add_to_agent(self, agent): + def add_to_agent(self, agent: Agent) -> None: """Add this capability to an agent.""" - agent.update_system_message(agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE) + # system message is a string or a list of strings + if isinstance(agent.system_message, str): + system_message_str = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE + agent.update_system_message(system_message_str) + else: + system_message_list = agent.system_message.copy() + system_message_list[-1] = system_message_list[-1] + self.DEFAULT_SYSTEM_MESSAGE_UPDATE + agent.update_system_message(system_message_list) timeout: int = Field(default=DEFAULT_TIMEOUT, ge=1, description="The timeout for code execution.") kernel: str = Field(default="python3", description="The kernel to use.") output_dir: str = Field(default=".", description="The directory to save output files.") - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any): super().__init__(**kwargs) # Check if the kernel is installed. if self.kernel not in KernelSpecManager().find_kernel_specs(): diff --git a/autogen/coding/markdown_code_extractor.py b/autogen/coding/markdown_code_extractor.py index 86560dfb4d6..73a1e03e669 100644 --- a/autogen/coding/markdown_code_extractor.py +++ b/autogen/coding/markdown_code_extractor.py @@ -1,13 +1,16 @@ import re -from typing import List -from autogen.code_utils import CODE_BLOCK_PATTERN, UNKNOWN, content_str, infer_lang -from autogen.coding.base import CodeBlock +from typing import Any, Dict, List, Optional, Union + +from ..code_utils import CODE_BLOCK_PATTERN, UNKNOWN, content_str, infer_lang +from .base import CodeBlock + +__all__ = ("MarkdownCodeExtractor",) class MarkdownCodeExtractor: """A class that extracts code blocks from a message using Markdown syntax.""" - def extract_code_blocks(self, message: str) -> List[CodeBlock]: + def extract_code_blocks(self, message: Union[str, List[Dict[str, Any]], None]) -> List[CodeBlock]: """Extract code blocks from a message. If no code blocks are found, return an empty list. diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index 98a158c32e2..3886063a159 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -1,5 +1,5 @@ import sys -from typing import Dict +from typing import Any, Dict import pytest from autogen.agentchat.agent import Agent from autogen.agentchat.conversable_agent import ConversableAgent @@ -21,16 +21,16 @@ sys.platform in ["win32"] or (not is_docker_running() and not in_docker_container()), reason="docker is not running", ) -def test_execute_code_docker(): +def test_execute_code_docker() -> None: _test_execute_code({"use_docker": True}) @pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") -def test_execute_code_local(): +def test_execute_code_local() -> None: _test_execute_code({"use_docker": False}) -def _test_execute_code(config: Dict): +def _test_execute_code(config: Dict[str, Any]) -> None: executor = CommandlineCodeExecutor(**config) # Test single code block. @@ -77,7 +77,7 @@ def _test_execute_code(config: Dict): assert code_result.exit_code and "Timeout" in code_result.output or WIN32 -def test_restart(): +def test_restart() -> None: executor = CommandlineCodeExecutor(use_docker=True) # Check warning. with pytest.warns(UserWarning, match="Restarting command line code executor is not supported. No action is taken."): @@ -85,7 +85,7 @@ def test_restart(): @pytest.mark.skipif(skip_openai_tests, reason="openai not installed OR requested to skip") -def test_conversable_agent_capability(): +def test_conversable_agent_capability() -> None: KEY_LOC = "notebook" OAI_CONFIG_LIST = "OAI_CONFIG_LIST" config_list = config_list_from_json( @@ -116,7 +116,7 @@ def test_conversable_agent_capability(): ) # Test code extraction. - code_blocks = executor.code_extractor.extract_code_blocks(reply) + code_blocks = executor.code_extractor.extract_code_blocks(reply) # type: ignore[arg-type] assert len(code_blocks) == 1 and code_blocks[0].language == "python" # Test code execution. @@ -125,7 +125,7 @@ def test_conversable_agent_capability(): @pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") -def test_coversable_agent_code_execution_no_docker(): +def test_coversable_agent_code_execution_no_docker() -> None: _test_conversable_agent_code_execution({"use_docker": False}) @@ -133,11 +133,11 @@ def test_coversable_agent_code_execution_no_docker(): sys.platform in ["win32"] or (not is_docker_running() and not in_docker_container()), reason="docker is not running", ) -def test_conversable_agent_code_execution_docker(): +def test_conversable_agent_code_execution_docker() -> None: _test_conversable_agent_code_execution({"use_docker": True}) -def _test_conversable_agent_code_execution(config): +def _test_conversable_agent_code_execution(config: Dict[str, Any]) -> None: agent = ConversableAgent( "user_proxy", code_execution_config={ @@ -147,6 +147,9 @@ def _test_conversable_agent_code_execution(config): llm_config=False, ) + isinstance(agent._code_executor, CommandlineCodeExecutor) + code_executor: CommandlineCodeExecutor = agent._code_executor # type: ignore[assignment] + message = """ Example: ```python @@ -158,15 +161,13 @@ def _test_conversable_agent_code_execution(config): [{"role": "user", "content": message}], sender=Agent("user"), ) - assert "hello extract code" in reply + assert "hello extract code" in reply # type: ignore[operator] if config["use_docker"] is not False: # Check if the docker image is set. - assert ( - isinstance(agent._code_executor.docker_image_name, str) and len(agent._code_executor.docker_image_name) > 0 - ) + assert isinstance(code_executor.docker_image_name, str) and len(code_executor.docker_image_name) > 0 -def test_conversable_agent_warning_legacy_code_executor(): +def test_conversable_agent_warning_legacy_code_executor() -> None: # Test warning message. with pytest.warns(DeprecationWarning, match="legacy code executor"): - ConversableAgent("user_proxy", llm_config=False, code_execution_config=True) + ConversableAgent("user_proxy", llm_config=False, code_execution_config=True) # type: ignore[arg-type] diff --git a/test/coding/test_factory.py b/test/coding/test_factory.py index 04bafa57723..c6b5c7ca21f 100644 --- a/test/coding/test_factory.py +++ b/test/coding/test_factory.py @@ -1,11 +1,13 @@ +from typing import Dict, Union import pytest +from autogen.coding.base import CodeExecutor from autogen.coding.commandline_code_executor import CommandlineCodeExecutor from autogen.coding.factory import CodeExecutorFactory from autogen.coding.ipython_code_executor import IPythonCodeExecutor -def test_create(): - config = {"executor": "ipython"} +def test_create() -> None: + config: Dict[str, Union[str, CodeExecutor]] = {"executor": "ipython"} executor = CodeExecutorFactory.create(config) assert isinstance(executor, IPythonCodeExecutor) diff --git a/test/coding/test_ipython_code_executor.py b/test/coding/test_ipython_code_executor.py index 35c4690a18a..7c732104f73 100644 --- a/test/coding/test_ipython_code_executor.py +++ b/test/coding/test_ipython_code_executor.py @@ -17,14 +17,14 @@ skip_openai_tests = False or skip_openai -def test_execute_code_single_code_block(): +def test_execute_code_single_code_block() -> None: executor = IPythonCodeExecutor() code_blocks = [CodeBlock(code="import sys\nprint('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 -def test_execute_code_multiple_code_blocks(): +def test_execute_code_multiple_code_blocks() -> None: executor = IPythonCodeExecutor() code_blocks = [ CodeBlock(code="import sys\na = 123 + 123\n", language="python"), @@ -45,7 +45,7 @@ def test_function(a, b): assert code_result.exit_code == 0 and "854" in code_result.output -def test_execute_code_bash_script(): +def test_execute_code_bash_script() -> None: executor = IPythonCodeExecutor() # Test bash script. code_blocks = [CodeBlock(code='!echo "hello world!"', language="bash")] @@ -53,7 +53,7 @@ def test_execute_code_bash_script(): assert code_result.exit_code == 0 and "hello world!" in code_result.output -def test_saving_to_file(): +def test_saving_to_file() -> None: executor = IPythonCodeExecutor() with tempfile.TemporaryDirectory() as tmpdirname: code = f""" @@ -65,14 +65,14 @@ def test_saving_to_file(): assert code_result.exit_code == 0 and os.path.exists(os.path.join(tmpdirname, "test_file_name")) -def test_timeout(): +def test_timeout() -> None: executor = IPythonCodeExecutor(timeout=1) 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_silent_pip_install(): +def test_silent_pip_install() -> None: executor = IPythonCodeExecutor() code_blocks = [CodeBlock(code="!pip install matplotlib numpy", language="python")] code_result = executor.execute_code_blocks(code_blocks) @@ -84,7 +84,7 @@ def test_silent_pip_install(): assert code_result.exit_code == 0 and "ERROR: " in code_result.output -def test_restart(): +def test_restart() -> None: executor = IPythonCodeExecutor() code_blocks = [CodeBlock(code="x = 123", language="python")] code_result = executor.execute_code_blocks(code_blocks) @@ -97,7 +97,7 @@ def test_restart(): @pytest.mark.skipif(skip_openai_tests, reason="openai not installed OR requested to skip") -def test_conversable_agent_capability(): +def test_conversable_agent_capability() -> None: KEY_LOC = "notebook" OAI_CONFIG_LIST = "OAI_CONFIG_LIST" config_list = config_list_from_json( @@ -128,7 +128,7 @@ def test_conversable_agent_capability(): ) # Test code extraction. - code_blocks = executor.code_extractor.extract_code_blocks(reply) + code_blocks = executor.code_extractor.extract_code_blocks(reply) # type: ignore[arg-type] assert len(code_blocks) == 1 and code_blocks[0].language == "python" # Test code execution. @@ -136,7 +136,7 @@ def test_conversable_agent_capability(): assert code_result.exit_code == 0 and "hello world" in code_result.output.lower() -def test_conversable_agent_code_execution(): +def test_conversable_agent_code_execution() -> None: agent = ConversableAgent("user_proxy", llm_config=False, code_execution_config={"executor": "ipython"}) msg = """ Run this code: @@ -150,4 +150,4 @@ def test_function(a, b): ``` """ reply = agent.generate_reply([{"role": "user", "content": msg}], sender=Agent("user")) - assert "492" in reply + assert "492" in reply # type: ignore[operator] diff --git a/test/coding/test_markdown_code_extractor.py b/test/coding/test_markdown_code_extractor.py index 9df908f52cc..4185d67527b 100644 --- a/test/coding/test_markdown_code_extractor.py +++ b/test/coding/test_markdown_code_extractor.py @@ -1,4 +1,4 @@ -from autogen.coding.markdown_code_extractor import MarkdownCodeExtractor +from autogen.coding import MarkdownCodeExtractor _message_1 = """ Example: @@ -90,7 +90,7 @@ class Program """ -def test_extract_code(): +def test_extract_code() -> None: extractor = MarkdownCodeExtractor() code_blocks = extractor.extract_code_blocks(_message_1) From 7c1b559ffdf566265446ea32657cda445b42041a Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Wed, 31 Jan 2024 04:52:13 +0000 Subject: [PATCH 19/52] wip --- .gitignore | 3 + autogen/agentchat/agent.py | 94 ++++++++++++--------- autogen/agentchat/conversable_agent.py | 11 ++- autogen/coding/base.py | 4 +- autogen/coding/commandline_code_executor.py | 4 +- autogen/coding/ipython_code_executor.py | 4 +- pyproject.toml | 26 ++++++ 7 files changed, 97 insertions(+), 49 deletions(-) diff --git a/.gitignore b/.gitignore index fbcc60d1172..a10d9bc9054 100644 --- a/.gitignore +++ b/.gitignore @@ -175,3 +175,6 @@ test/test_files/agenteval-in-out/out/ # Files created by tests *tmp_code_* test/agentchat/test_agent_scripts/* + +# cache files +.cache_test diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index 66cefc710db..63b8ca9243f 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -1,61 +1,59 @@ -from typing import Dict, List, Optional, Union +from typing import Any, Dict, List, Optional, Protocol, Union, runtime_checkable -class Agent: +@runtime_checkable +class Agent(Protocol): """(In preview) An abstract class for AI agent. An agent can communicate with other agents and perform actions. Different agents can differ in what actions they perform in the `receive` method. """ - def __init__( - self, - name: str, - ): - """ - Args: - name (str): name of the agent. - """ - # a dictionary of conversations, default value is list - self._name = name - - @property - def name(self): - """Get the name of the agent.""" - return self._name - - @property - def system_message(self) -> Union[str, List]: - """(Abstract method) Return the system message.""" - - def update_system_message(self, system_message: Union[str, List]): - """(Abstract method) Update the system message. - - Args: - system_message (str or List): system message for the ChatCompletion inference. - """ - - def send(self, message: Union[Dict, str], recipient: "Agent", request_reply: Optional[bool] = None): + # def __init__( + # self, + # name: str, + # ): + # """ + # Args: + # name (str): name of the agent. + # """ + # # a dictionary of conversations, default value is list + # self._name = name + + # @property + # def name(self) -> str: + # """Get the name of the agent.""" + # # return self._name + + def send( + self, message: Union[Dict[str, Any], str], recipient: "Agent", request_reply: Optional[bool] = None + ) -> None: """(Abstract method) Send a message to another agent.""" - async def a_send(self, message: Union[Dict, str], recipient: "Agent", request_reply: Optional[bool] = None): + async def a_send( + self, message: Union[Dict[str, Any], str], recipient: "Agent", request_reply: Optional[bool] = None + ) -> None: """(Abstract async method) Send a message to another agent.""" - def receive(self, message: Union[Dict, str], sender: "Agent", request_reply: Optional[bool] = None): + def receive( + self, message: Union[Dict[str, Any], str], sender: "Agent", request_reply: Optional[bool] = None + ) -> None: """(Abstract method) Receive a message from another agent.""" - async def a_receive(self, message: Union[Dict, str], sender: "Agent", request_reply: Optional[bool] = None): + async def a_receive( + self, message: Union[Dict[str, Any], str], sender: "Agent", request_reply: Optional[bool] = None + ) -> None: """(Abstract async method) Receive a message from another agent.""" - def reset(self): + def reset(self) -> None: """(Abstract method) Reset the agent.""" def generate_reply( self, - messages: Optional[List[Dict]] = None, + messages: Optional[List[Dict[str, Any]]] = None, sender: Optional["Agent"] = None, - **kwargs, - ) -> Union[str, Dict, None]: + **kwargs: Any, + ) -> Union[str, Dict[str, Any], None]: """(Abstract method) Generate a reply based on the received messages. Args: @@ -67,10 +65,10 @@ def generate_reply( async def a_generate_reply( self, - messages: Optional[List[Dict]] = None, + messages: Optional[List[Dict[str, Any]]] = None, sender: Optional["Agent"] = None, - **kwargs, - ) -> Union[str, Dict, None]: + **kwargs: Any, + ) -> Union[str, Dict[str, Any], None]: """(Abstract async method) Generate a reply based on the received messages. Args: @@ -79,3 +77,19 @@ async def a_generate_reply( Returns: str or dict or None: the generated reply. If None, no reply is generated. """ + + +@runtime_checkable +class LLMAgent(Agent, Protocol): + """(In preview) An abstract class for LLM agent.""" + + @property + def system_message(self) -> Union[str, List]: + """(Abstract method) Return the system message.""" + + def update_system_message(self, system_message: Union[str, List]): + """(Abstract method) Update the system message. + + Args: + system_message (str or List): system message for the ChatCompletion inference. + """ diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 1b14a1bdc98..615cd722251 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -26,7 +26,7 @@ from ..function_utils import get_function_schema, load_basemodels_if_needed, serialize_to_str -from .agent import Agent +from .agent import Agent, LLMAgent from .._pydantic import model_dump try: @@ -44,7 +44,7 @@ def colored(x, *args, **kwargs): F = TypeVar("F", bound=Callable[..., Any]) -class ConversableAgent(Agent): +class ConversableAgent(LLMAgent): """(In preview) A class for generic conversable agents which can be configured as assistant or user proxy. After receiving each message, the agent will send a reply to the sender unless the msg is a termination msg. @@ -119,7 +119,7 @@ def __init__( description (str): a short description of the agent. This description is used by other agents (e.g. the GroupChatManager) to decide when to call upon this agent. (Default: system_message) """ - super().__init__(name) + self._name = name # a dictionary of conversations, default value is list self._oai_messages = defaultdict(list) self._oai_system_message = [{"content": system_message, "role": "system"}] @@ -203,6 +203,11 @@ def __init__( # New hookable methods should be added to this list as required to support new agent capabilities. self.hook_lists = {self.process_last_message: []} # This is currently the only hookable method. + @property + def name(self) -> str: + """Get the name of the agent.""" + return self._name + @property def code_executor(self) -> CodeExecutor: """The code executor used by this agent. Raise if code execution is disabled.""" diff --git a/autogen/coding/base.py b/autogen/coding/base.py index 3359294a59a..9c68844413d 100644 --- a/autogen/coding/base.py +++ b/autogen/coding/base.py @@ -2,7 +2,7 @@ from pydantic import BaseModel -from ..agentchat.agent import Agent +from ..agentchat.agent import LLMAgent __all__ = ("CodeBlock", "CodeResult", "CodeExtractor", "CodeExecutor") @@ -49,7 +49,7 @@ class CodeExecutor(Protocol): class UserCapability(Protocol): """An AgentCapability class that gives agent ability use this code executor.""" - def add_to_agent(self, agent: Agent) -> None: + def add_to_agent(self, agent: LLMAgent) -> None: ... # pragma: no cover @property diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py index 35a678eb7dd..d54667d46f6 100644 --- a/autogen/coding/commandline_code_executor.py +++ b/autogen/coding/commandline_code_executor.py @@ -3,7 +3,7 @@ from pydantic import BaseModel, Field -from ..agentchat.agent import Agent +from ..agentchat.agent import LLMAgent from ..code_utils import DEFAULT_TIMEOUT, WORKING_DIR, execute_code from .base import CodeBlock, CodeExtractor, CodeResult from .markdown_code_extractor import MarkdownCodeExtractor @@ -42,7 +42,7 @@ class UserCapability: If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. """ - def add_to_agent(self, agent: Agent) -> None: + def add_to_agent(self, agent: LLMAgent) -> None: """Add this capability to an agent.""" # system message is a string or a list of strings if isinstance(agent.system_message, str): diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index cbb9c4cb369..3d8d0e19720 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -10,7 +10,7 @@ from jupyter_client.kernelspec import KernelSpecManager, NoSuchKernel from pydantic import BaseModel, Field -from ..agentchat.agent import Agent +from ..agentchat.agent import LLMAgent from ..code_utils import DEFAULT_TIMEOUT from .base import CodeBlock, CodeExtractor, CodeResult from .markdown_code_extractor import MarkdownCodeExtractor @@ -54,7 +54,7 @@ class UserCapability: the output will be a path to the image instead of the image itself. """ - def add_to_agent(self, agent: Agent) -> None: + def add_to_agent(self, agent: LLMAgent) -> None: """Add this capability to an agent.""" # system message is a string or a list of strings if isinstance(agent.system_message, str): diff --git a/pyproject.toml b/pyproject.toml index 18038a16fa4..c890e28d482 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -49,3 +49,29 @@ unfixable = ["F401"] [tool.ruff.mccabe] # Unlike Flake8, default to a complexity level of 10. max-complexity = 10 + +[tool.mypy] + +strict = true +python_version = "3.8" +ignore_missing_imports = true +install_types = true +non_interactive = true +plugins = [ + "pydantic.mypy" +] + +# remove after all files in the repo are fixed +follow_imports = "silent" + +# from https://blog.wolt.com/engineering/2021/09/30/professional-grade-mypy-configuration/ +disallow_untyped_defs = true +no_implicit_optional = true +check_untyped_defs = true +warn_return_any = true +show_error_codes = true +warn_unused_ignores = true + +disallow_incomplete_defs = true +disallow_untyped_decorators = true +disallow_any_unimported = true From ebd242b0eb550a4e051e614444196bdf24380abf Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Wed, 31 Jan 2024 06:39:39 +0100 Subject: [PATCH 20/52] refactoring --- autogen/agentchat/agent.py | 10 ++-- autogen/agentchat/conversable_agent.py | 24 ++++---- autogen/code_utils.py | 4 +- autogen/coding/commandline_code_executor.py | 60 ++++++------------- autogen/coding/ipython_code_executor.py | 9 +-- test/coding/test_commandline_code_executor.py | 10 ++-- test/coding/test_ipython_code_executor.py | 4 +- 7 files changed, 48 insertions(+), 73 deletions(-) diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index 63b8ca9243f..7a49048e576 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -1,4 +1,4 @@ -from typing import Any, Dict, List, Optional, Protocol, Union, runtime_checkable +from typing import Any, Callable, Dict, List, Optional, Protocol, Union, runtime_checkable @runtime_checkable @@ -52,6 +52,7 @@ def generate_reply( self, messages: Optional[List[Dict[str, Any]]] = None, sender: Optional["Agent"] = None, + exclude: Optional[List[Callable[..., Any]]] = None, **kwargs: Any, ) -> Union[str, Dict[str, Any], None]: """(Abstract method) Generate a reply based on the received messages. @@ -67,6 +68,7 @@ async def a_generate_reply( self, messages: Optional[List[Dict[str, Any]]] = None, sender: Optional["Agent"] = None, + exclude: Optional[List[Callable[..., Any]]] = None, **kwargs: Any, ) -> Union[str, Dict[str, Any], None]: """(Abstract async method) Generate a reply based on the received messages. @@ -84,12 +86,12 @@ class LLMAgent(Agent, Protocol): """(In preview) An abstract class for LLM agent.""" @property - def system_message(self) -> Union[str, List]: + def system_message(self) -> str: """(Abstract method) Return the system message.""" - def update_system_message(self, system_message: Union[str, List]): + def update_system_message(self, system_message: str) -> None: """(Abstract method) Update the system message. Args: - system_message (str or List): system message for the ChatCompletion inference. + system_message (str): system message for the ChatCompletion inference. """ diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 615cd722251..a04da09164f 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -44,7 +44,7 @@ def colored(x, *args, **kwargs): F = TypeVar("F", bound=Callable[..., Any]) -class ConversableAgent(LLMAgent): +class ConversableAgent: # implements LLAgent protocol """(In preview) A class for generic conversable agents which can be configured as assistant or user proxy. After receiving each message, the agent will send a reply to the sender unless the msg is a termination msg. @@ -290,15 +290,15 @@ def reply_func( self._ignore_async_func_in_sync_chat_list.append(reply_func) @property - def system_message(self) -> Union[str, List]: + def system_message(self) -> str: """Return the system message.""" return self._oai_system_message[0]["content"] - def update_system_message(self, system_message: Union[str, List]): + def update_system_message(self, system_message: str) -> None: """Update the system message. Args: - system_message (str or List): system message for the ChatCompletion inference. + system_message (str): system message for the ChatCompletion inference. """ self._oai_system_message[0]["content"] = system_message @@ -1330,9 +1330,10 @@ async def a_check_termination_and_human_reply( def generate_reply( self, - messages: Optional[List[Dict]] = None, - sender: Optional[Agent] = None, - exclude: Optional[List[Callable]] = None, + messages: Optional[List[Dict[str, Any]]] = None, + sender: Optional["Agent"] = None, + exclude: Optional[List[Callable[..., Any]]] = None, + **kwargs: Any, ) -> Union[str, Dict, None]: """Reply based on the conversation history and the sender. @@ -1386,10 +1387,11 @@ def generate_reply( async def a_generate_reply( self, - messages: Optional[List[Dict]] = None, - sender: Optional[Agent] = None, - exclude: Optional[List[Callable]] = None, - ) -> Union[str, Dict, None]: + messages: Optional[List[Dict[str, Any]]] = None, + sender: Optional["Agent"] = None, + exclude: Optional[List[Callable[..., Any]]] = None, + **kwargs: Any, + ) -> Union[str, Dict[str, Any], None]: """(async) Reply based on the conversation history and the sender. Either messages or sender must be provided. diff --git a/autogen/code_utils.py b/autogen/code_utils.py index bcc212e67bb..1b3dff2d677 100644 --- a/autogen/code_utils.py +++ b/autogen/code_utils.py @@ -318,7 +318,7 @@ def execute_code( timeout: Optional[int] = None, filename: Optional[str] = None, work_dir: Optional[str] = None, - use_docker: Union[List[str], str, bool] = SENTINEL, + use_docker: Union[List[str], str, bool, None] = None, lang: Optional[str] = "python", ) -> Tuple[int, str, Optional[str]]: """Execute code in a docker container. @@ -365,7 +365,7 @@ def execute_code( docker_running = is_docker_running() # SENTINEL is used to indicate that the user did not explicitly set the argument - if use_docker is SENTINEL: + if use_docker is None: use_docker = decide_use_docker(use_docker=None) check_can_use_docker_or_throw(use_docker) diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py index d54667d46f6..224554646cc 100644 --- a/autogen/coding/commandline_code_executor.py +++ b/autogen/coding/commandline_code_executor.py @@ -44,14 +44,8 @@ class UserCapability: def add_to_agent(self, agent: LLMAgent) -> None: """Add this capability to an agent.""" - # system message is a string or a list of strings - if isinstance(agent.system_message, str): - system_message_str = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE - agent.update_system_message(system_message_str) - else: - system_message_list = agent.system_message.copy() - system_message_list[0] = system_message_list[0] + self.DEFAULT_SYSTEM_MESSAGE_UPDATE - agent.update_system_message(system_message_list) + system_message = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE + agent.update_system_message(system_message) timeout: Optional[int] = Field(default=DEFAULT_TIMEOUT, ge=1) filename: Optional[str] = None @@ -78,30 +72,6 @@ def code_extractor(self) -> CodeExtractor: """Export a code extractor that can be used by an agent.""" return MarkdownCodeExtractor() - def _execute_code(self, code: str, lang: str, filename: Optional[str] = None) -> Tuple[int, str, Optional[str]]: - use_docker = self._get_use_docker_for_code_utils() - filename = self.filename if filename is None else filename - # execute_code cannot handle None for use_docker - if use_docker is None: - return execute_code( - code=code, - lang=lang, - filename=filename, - timeout=self.timeout, - work_dir=self.work_dir, - ) - else: - exitcode, logs, image = execute_code( - code=code, - lang=lang, - filename=filename, - timeout=self.timeout, - work_dir=self.work_dir, - use_docker=use_docker, - ) - - return exitcode, logs, image - def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: """Execute the code blocks and return the result.""" logs_all = "" @@ -115,21 +85,27 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: flush=True, ) if lang in ["bash", "shell", "sh"]: - exitcode, logs, image = self._execute_code(code, lang) - # exitcode, logs, image = execute_code( - # code=code, - # lang=lang, - # timeout=self.timeout, - # work_dir=self.work_dir, - # filename=self.filename, - # use_docker=self._get_use_docker_for_code_utils(), - # ) + exitcode, logs, image = execute_code( + code=code, + lang=lang, + timeout=self.timeout, + work_dir=self.work_dir, + filename=self.filename, + use_docker=self._get_use_docker_for_code_utils(), + ) elif lang in ["python", "Python"]: if code.startswith("# filename: "): filename = code[11 : code.find("\n")].strip() else: filename = None - exitcode, logs, image = self._execute_code(code, "python", filename=filename) + exitcode, logs, image = execute_code( + code=code, + lang="python", + timeout=self.timeout, + work_dir=self.work_dir, + filename=filename, + use_docker=self._get_use_docker_for_code_utils(), + ) else: # In case the language is not supported, we return an error message. exitcode, logs, image = (1, f"unknown language {lang}", None) diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/ipython_code_executor.py index 3d8d0e19720..ec0eddace75 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/ipython_code_executor.py @@ -57,13 +57,8 @@ class UserCapability: def add_to_agent(self, agent: LLMAgent) -> None: """Add this capability to an agent.""" # system message is a string or a list of strings - if isinstance(agent.system_message, str): - system_message_str = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE - agent.update_system_message(system_message_str) - else: - system_message_list = agent.system_message.copy() - system_message_list[-1] = system_message_list[-1] + self.DEFAULT_SYSTEM_MESSAGE_UPDATE - agent.update_system_message(system_message_list) + system_message = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE + agent.update_system_message(system_message) timeout: int = Field(default=DEFAULT_TIMEOUT, ge=1, description="The timeout for code execution.") kernel: str = Field(default="python3", description="The kernel to use.") diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index 3886063a159..db6ae963510 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -18,7 +18,7 @@ @pytest.mark.skipif( - sys.platform in ["win32"] or (not is_docker_running() and not in_docker_container()), + sys.platform in ["win32"] or (not is_docker_running()) or (in_docker_container()), reason="docker is not running", ) def test_execute_code_docker() -> None: @@ -112,7 +112,7 @@ def test_conversable_agent_capability() -> None: # Test code generation. reply = agent.generate_reply( [{"role": "user", "content": "write a python script to print 'hello world' to the console"}], - sender=Agent("user"), + sender=ConversableAgent(name="user", llm_config=False), ) # Test code extraction. @@ -121,7 +121,7 @@ def test_conversable_agent_capability() -> None: # Test code execution. code_result = executor.execute_code_blocks(code_blocks) - assert code_result.exit_code == 0 and "hello world" in code_result.output.lower() + assert code_result.exit_code == 0 and "hello world" in code_result.output.lower().replace(",", "") @pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") @@ -130,7 +130,7 @@ def test_coversable_agent_code_execution_no_docker() -> None: @pytest.mark.skipif( - sys.platform in ["win32"] or (not is_docker_running() and not in_docker_container()), + sys.platform in ["win32"] or (not is_docker_running()) or (in_docker_container()), reason="docker is not running", ) def test_conversable_agent_code_execution_docker() -> None: @@ -159,7 +159,7 @@ def _test_conversable_agent_code_execution(config: Dict[str, Any]) -> None: reply = agent.generate_reply( [{"role": "user", "content": message}], - sender=Agent("user"), + sender=ConversableAgent("user"), ) assert "hello extract code" in reply # type: ignore[operator] if config["use_docker"] is not False: diff --git a/test/coding/test_ipython_code_executor.py b/test/coding/test_ipython_code_executor.py index 7c732104f73..89e937e6369 100644 --- a/test/coding/test_ipython_code_executor.py +++ b/test/coding/test_ipython_code_executor.py @@ -124,7 +124,7 @@ def test_conversable_agent_capability() -> None: # Test code generation. reply = agent.generate_reply( [{"role": "user", "content": "print 'hello world' to the console"}], - sender=Agent("user"), + sender=ConversableAgent("user"), ) # Test code extraction. @@ -149,5 +149,5 @@ def test_function(a, b): print(test_function(123, 4)) ``` """ - reply = agent.generate_reply([{"role": "user", "content": msg}], sender=Agent("user")) + reply = agent.generate_reply([{"role": "user", "content": msg}], sender=ConversableAgent("user")) assert "492" in reply # type: ignore[operator] From 85802d82e0fc36e3dbc57abd3b83a32ee72adcd4 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Wed, 31 Jan 2024 06:50:44 +0100 Subject: [PATCH 21/52] polishing --- autogen/agentchat/agent.py | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index 7a49048e576..7bd63b7fe0d 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -9,22 +9,6 @@ class Agent(Protocol): Different agents can differ in what actions they perform in the `receive` method. """ - # def __init__( - # self, - # name: str, - # ): - # """ - # Args: - # name (str): name of the agent. - # """ - # # a dictionary of conversations, default value is list - # self._name = name - - # @property - # def name(self) -> str: - # """Get the name of the agent.""" - # # return self._name - def send( self, message: Union[Dict[str, Any], str], recipient: "Agent", request_reply: Optional[bool] = None ) -> None: From 702bdd39466bdf38a5d964cc9bed73bedea8fe40 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 1 Feb 2024 10:00:04 +0000 Subject: [PATCH 22/52] fixed failing tests --- test/agentchat/test_tool_calls.py | 4 ++-- test/coding/test_commandline_code_executor.py | 10 +++++++--- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/test/agentchat/test_tool_calls.py b/test/agentchat/test_tool_calls.py index f440a5b26f6..da4061e0be3 100644 --- a/test/agentchat/test_tool_calls.py +++ b/test/agentchat/test_tool_calls.py @@ -188,7 +188,7 @@ def test_update_tool(): def test_multi_tool_call(): class FakeAgent(autogen.Agent): def __init__(self, name): - super().__init__(name) + self.name = name self.received = [] def receive( @@ -275,7 +275,7 @@ def receive( async def test_async_multi_tool_call(): class FakeAgent(autogen.Agent): def __init__(self, name): - super().__init__(name) + self.name = name self.received = [] async def a_receive( diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index db6ae963510..0657d0b4714 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -125,8 +125,10 @@ def test_conversable_agent_capability() -> None: @pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") -def test_coversable_agent_code_execution_no_docker() -> None: - _test_conversable_agent_code_execution({"use_docker": False}) +def test_conversable_agent_code_execution_no_docker() -> None: + with pytest.MonkeyPatch.context() as mp: + mp.setenv("OPENAI_API_KEY", "mock") + _test_conversable_agent_code_execution({"use_docker": False}) @pytest.mark.skipif( @@ -134,7 +136,9 @@ def test_coversable_agent_code_execution_no_docker() -> None: reason="docker is not running", ) def test_conversable_agent_code_execution_docker() -> None: - _test_conversable_agent_code_execution({"use_docker": True}) + with pytest.MonkeyPatch.context() as mp: + mp.setenv("OPENAI_API_KEY", "mock") + _test_conversable_agent_code_execution({"use_docker": True}) def _test_conversable_agent_code_execution(config: Dict[str, Any]) -> None: From a87a7f1f618948a8920373a17f98542d33fc0a84 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 1 Feb 2024 11:35:30 +0100 Subject: [PATCH 23/52] resolved merge conflict --- .gitignore | 2 +- README.md | 2 +- autogen/agentchat/__init__.py | 7 +- autogen/agentchat/conversable_agent.py | 64 ++- notebook/agentchat_function_call.ipynb | 213 ++++++---- notebook/agentchat_function_call_async.ipynb | 211 ++++++---- ...at_function_call_currency_calculator.ipynb | 62 +-- .../autogenbench/autogenbench/version.py | 2 +- test/agentchat/test_conversable_agent.py | 58 ++- .../test_function_and_tool_calling.py | 378 ++++++++++++++++++ test/oai/test_client.py | 14 +- website/README.md | 4 +- website/docs/Use-Cases/agent_chat.md | 30 +- 13 files changed, 827 insertions(+), 220 deletions(-) create mode 100644 test/agentchat/test_function_and_tool_calling.py diff --git a/.gitignore b/.gitignore index a10d9bc9054..66ccc528dcc 100644 --- a/.gitignore +++ b/.gitignore @@ -176,5 +176,5 @@ test/test_files/agenteval-in-out/out/ *tmp_code_* test/agentchat/test_agent_scripts/* -# cache files +# test cache .cache_test diff --git a/README.md b/README.md index 6c2b30ff170..3ede4d9572b 100644 --- a/README.md +++ b/README.md @@ -27,7 +27,7 @@ :fire: Nov 1: AutoGen is the top trending repo on GitHub in October 2023. -:tada: Oct 03: AutoGen spins off from FLAML on Github and has a major paper update (first version on Aug 16). +:tada: Oct 03: AutoGen spins off from FLAML on GitHub and has a major paper update (first version on Aug 16). diff --git a/autogen/agentchat/__init__.py b/autogen/agentchat/__init__.py index 3db1db73a55..52cf15b050c 100644 --- a/autogen/agentchat/__init__.py +++ b/autogen/agentchat/__init__.py @@ -1,14 +1,15 @@ from .agent import Agent from .assistant_agent import AssistantAgent -from .conversable_agent import ConversableAgent +from .conversable_agent import ConversableAgent, register_function from .groupchat import GroupChat, GroupChatManager from .user_proxy_agent import UserProxyAgent -__all__ = [ +__all__ = ( "Agent", "ConversableAgent", "AssistantAgent", "UserProxyAgent", "GroupChat", "GroupChatManager", -] + "register_function", +) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index a04da09164f..1faa121d17d 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -1000,9 +1000,20 @@ def generate_function_call_reply( func_call = message["function_call"] func = self._function_map.get(func_call.get("name", None), None) if inspect.iscoroutinefunction(func): - return False, None - - _, func_return = self.execute_function(message["function_call"]) + try: + # get the running loop if it was already created + loop = asyncio.get_running_loop() + close_loop = False + except RuntimeError: + # create a loop if there is no running loop + loop = asyncio.new_event_loop() + close_loop = True + + _, func_return = loop.run_until_complete(self.a_execute_function(func_call)) + if close_loop: + loop.close() + else: + _, func_return = self.execute_function(message["function_call"]) return True, func_return return False, None @@ -1029,7 +1040,9 @@ async def a_generate_function_call_reply( func = self._function_map.get(func_name, None) if func and inspect.iscoroutinefunction(func): _, func_return = await self.a_execute_function(func_call) - return True, func_return + else: + _, func_return = self.execute_function(func_call) + return True, func_return return False, None @@ -1054,8 +1067,20 @@ def generate_tool_calls_reply( function_call = tool_call.get("function", {}) func = self._function_map.get(function_call.get("name", None), None) if inspect.iscoroutinefunction(func): - continue - _, func_return = self.execute_function(function_call) + try: + # get the running loop if it was already created + loop = asyncio.get_running_loop() + close_loop = False + except RuntimeError: + # create a loop if there is no running loop + loop = asyncio.new_event_loop() + close_loop = True + + _, func_return = loop.run_until_complete(self.a_execute_function(function_call)) + if close_loop: + loop.close() + else: + _, func_return = self.execute_function(function_call) tool_returns.append( { "tool_call_id": id, @@ -2074,3 +2099,30 @@ def get_total_usage(self) -> Union[None, Dict[str, int]]: return None else: return self.client.total_usage_summary + + +def register_function( + f: Callable[..., Any], + *, + caller: ConversableAgent, + executor: ConversableAgent, + name: Optional[str] = None, + description: str, +) -> None: + """Register a function to be proposed by an agent and executed for an executor. + + This function can be used instead of function decorators `@ConversationAgent.register_for_llm` and + `@ConversationAgent.register_for_execution`. + + Args: + f: the function to be registered. + caller: the agent calling the function, typically an instance of ConversableAgent. + executor: the agent executing the function, typically an instance of UserProxy. + name: name of the function. If None, the function name will be used (default: None). + description: description of the function. The description is used by LLM to decode whether the function + is called. Make sure the description is properly describing what the function does or it might not be + called by LLM when needed. + + """ + f = caller.register_for_llm(name=name, description=description)(f) + executor.register_for_execution(name=name)(f) diff --git a/notebook/agentchat_function_call.ipynb b/notebook/agentchat_function_call.ipynb index 8716ed32ee8..7f92c56797a 100644 --- a/notebook/agentchat_function_call.ipynb +++ b/notebook/agentchat_function_call.ipynb @@ -61,6 +61,7 @@ "from typing_extensions import Annotated\n", "\n", "import autogen\n", + "from autogen.cache import Cache\n", "\n", "config_list = autogen.config_list_from_json(\n", " \"OAI_CONFIG_LIST\",\n", @@ -118,9 +119,78 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "9fb85afb", "metadata": {}, + "outputs": [], + "source": [ + "llm_config = {\n", + " \"config_list\": config_list,\n", + " \"timeout\": 120,\n", + "}\n", + "chatbot = autogen.AssistantAgent(\n", + " name=\"chatbot\",\n", + " system_message=\"For coding tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done.\",\n", + " llm_config=llm_config,\n", + ")\n", + "\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"user_proxy\",\n", + " is_termination_msg=lambda x: x.get(\"content\", \"\") and x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=10,\n", + " code_execution_config={\n", + " \"work_dir\": \"coding\",\n", + " \"use_docker\": False,\n", + " }, # Please set use_docker=True if docker is available to run the generated code. Using docker is safer than running the generated code directly.\n", + ")\n", + "\n", + "\n", + "# define functions according to the function description\n", + "\n", + "\n", + "# one way of registering functions is to use the register_for_llm and register_for_execution decorators\n", + "@user_proxy.register_for_execution()\n", + "@chatbot.register_for_llm(name=\"python\", description=\"run cell in ipython and return the execution result.\")\n", + "def exec_python(cell: Annotated[str, \"Valid Python cell to execute.\"]) -> str:\n", + " ipython = get_ipython()\n", + " result = ipython.run_cell(cell)\n", + " log = str(result.result)\n", + " if result.error_before_exec is not None:\n", + " log += f\"\\n{result.error_before_exec}\"\n", + " if result.error_in_exec is not None:\n", + " log += f\"\\n{result.error_in_exec}\"\n", + " return log\n", + "\n", + "\n", + "# another way of registering functions is to use the register_function\n", + "def exec_sh(script: Annotated[str, \"Valid Python cell to execute.\"]) -> str:\n", + " return user_proxy.execute_code_blocks([(\"sh\", script)])\n", + "\n", + "\n", + "autogen.agentchat.register_function(\n", + " exec_python,\n", + " caller=chatbot,\n", + " executor=user_proxy,\n", + " name=\"sh\",\n", + " description=\"run a shell script and return the execution result.\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f6952220", + "metadata": {}, + "source": [ + "Finally, we initialize the chat that would use the functions defined above:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "27d3e43a", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -133,12 +203,63 @@ "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", "\n", - "\u001b[32m***** Suggested function Call: python *****\u001b[0m\n", + "\u001b[32m***** Suggested tool Call (call_bsaGbd8WGdC869LhG62hI0uK): python *****\u001b[0m\n", + "Arguments: \n", + "cell = \"\"\"\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as patches\n", + "\n", + "# Creating a simple scene for two agents chatting\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Draw two circles representing the agents\n", + "ax.add_patch(patches.Circle((2, 2), 0.5, fill=True, color='blue', label='Agent A'))\n", + "ax.add_patch(patches.Circle((5, 2), 0.5, fill=True, color='green', label='Agent B'))\n", + "\n", + "# Example dialogues as text\n", + "ax.text(1, 3, \"Hello!\", style='italic', bbox={'facecolor': 'red', 'alpha': 0.5, 'pad': 5})\n", + "ax.text(4, 3, \"Hi there!\", style='italic', bbox={'facecolor': 'yellow', 'alpha': 0.5, 'pad': 5})\n", + "\n", + "# Setting the limits of the plot\n", + "ax.set_xlim(0, 7)\n", + "ax.set_ylim(0, 4)\n", + "\n", + "# Hiding the axes\n", + "ax.axis('off')\n", + "\n", + "# Use this line just before the plt.show() if necessary\n", + "plt.savefig(\"agents_chatting.png\")\n", + "\n", + "# Don't add plt.show() as per the instructions\n", + "\"\"\"\n", + "return cell\n", + "\u001b[32m***********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", + "\n", + "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", + "\n", + "\u001b[32m***** Response from calling tool \"call_bsaGbd8WGdC869LhG62hI0uK\" *****\u001b[0m\n", + "Error: Expecting value: line 1 column 1 (char 0)\n", + " You argument should follow json format.\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", + "\n", + "\u001b[32m***** Suggested tool Call (call_ujcz2CkK0UgEEUen7X1ctXhe): python *****\u001b[0m\n", "Arguments: \n", "{\n", - " \"cell\": \"import matplotlib.pyplot as plt\\nimport matplotlib.patches as patches\\n\\n# Create a figure to draw\\nfig, ax = plt.subplots(figsize=(8, 5))\\n\\n# Set plot limits to avoid text spilling over\\nax.set_xlim(0, 2)\\nax.set_ylim(0, 2)\\n\\n# Hide axes\\nax.axis('off')\\n\\n# Draw two agents\\nhead_radius = 0.1\\n\\n# Agent A\\nax.add_patch(patches.Circle((0.5, 1.5), head_radius, color='blue'))\\n# Agent B\\nax.add_patch(patches.Circle((1.5, 1.5), head_radius, color='green'))\\n\\n# Example dialog\\nbbox_props = dict(boxstyle=\\\"round,pad=0.3\\\", ec=\\\"black\\\", lw=1, fc=\\\"white\\\")\\nax.text(0.5, 1.3, \\\"Hello, how are you?\\\", ha=\\\"center\\\", va=\\\"center\\\", size=8, bbox=bbox_props)\\nax.text(1.5, 1.3, \\\"I'm fine, thanks!\\\", ha=\\\"center\\\", va=\\\"center\\\", size=8, bbox=bbox_props)\\n\"\n", + " \"cell\": \"import matplotlib.pyplot as plt\\nimport matplotlib.patches as patches\\n\\n# Creating a simple scene for two agents chatting\\nfig, ax = plt.subplots()\\n\\n# Draw two circles representing the agents\\nax.add_patch(patches.Circle((2, 2), 0.5, fill=True, color='blue', label='Agent A'))\\nax.add_patch(patches.Circle((5, 2), 0.5, fill=True, color='green', label='Agent B'))\\n\\n# Example dialogues as text\\nax.text(1, 3, \\\"Hello!\\\", style='italic', bbox={'facecolor': 'red', 'alpha': 0.5, 'pad': 5})\\nax.text(4, 3, \\\"Hi there!\\\", style='italic', bbox={'facecolor': 'yellow', 'alpha': 0.5, 'pad': 5})\\n\\n# Setting the limits of the plot\\nax.set_xlim(0, 7)\\nax.set_ylim(0, 4)\\n\\n# Hiding the axes\\nax.axis('off')\\n\\n# Use this line just before the plt.show() if necessary\\nplt.savefig(\\\"agents_chatting.png\\\")\\n\\n# Don't add plt.show() as per the instructions\\n\"\n", "}\n", - "\u001b[32m*******************************************\u001b[0m\n", + "\u001b[32m***********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[35m\n", @@ -147,19 +268,9 @@ }, { "data": { + "image/png": "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", "text/plain": [ - "Text(1.5, 1.3, \"I'm fine, thanks!\")" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -171,19 +282,11 @@ "text": [ "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", "\n", - "\u001b[32m***** Response from calling function \"python\" *****\u001b[0m\n", - "Text(1.5, 1.3, \"I'm fine, thanks!\")\n", - "\u001b[32m***************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", - "\n", - "The drawing of two agents with example dialog has been executed, but as instructed, `plt.show()` has not been added, so the image will not be displayed here. However, the script created a matplotlib figure with two agents represented by circles, one blue and one green, along with example dialog text in speech bubbles.\n", - "\n", - "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", "\n", - "\n", + "\u001b[32m***** Response from calling tool \"call_ujcz2CkK0UgEEUen7X1ctXhe\" *****\u001b[0m\n", + "None\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", @@ -195,56 +298,12 @@ } ], "source": [ - "llm_config = {\n", - " \"config_list\": config_list,\n", - " \"timeout\": 120,\n", - "}\n", - "chatbot = autogen.AssistantAgent(\n", - " name=\"chatbot\",\n", - " system_message=\"For coding tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done.\",\n", - " llm_config=llm_config,\n", - ")\n", - "\n", - "# create a UserProxyAgent instance named \"user_proxy\"\n", - "user_proxy = autogen.UserProxyAgent(\n", - " name=\"user_proxy\",\n", - " is_termination_msg=lambda x: x.get(\"content\", \"\") and x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", - " human_input_mode=\"NEVER\",\n", - " max_consecutive_auto_reply=10,\n", - " code_execution_config={\n", - " \"work_dir\": \"coding\",\n", - " \"use_docker\": False,\n", - " }, # Please set use_docker=True if docker is available to run the generated code. Using docker is safer than running the generated code directly.\n", - ")\n", - "\n", - "\n", - "# define functions according to the function description\n", - "\n", - "\n", - "@user_proxy.register_for_execution()\n", - "@chatbot.register_for_llm(name=\"python\", description=\"run cell in ipython and return the execution result.\")\n", - "def exec_python(cell: Annotated[str, \"Valid Python cell to execute.\"]) -> str:\n", - " ipython = get_ipython()\n", - " result = ipython.run_cell(cell)\n", - " log = str(result.result)\n", - " if result.error_before_exec is not None:\n", - " log += f\"\\n{result.error_before_exec}\"\n", - " if result.error_in_exec is not None:\n", - " log += f\"\\n{result.error_in_exec}\"\n", - " return log\n", - "\n", - "\n", - "@user_proxy.register_for_execution()\n", - "@chatbot.register_for_llm(name=\"sh\", description=\"run a shell script and return the execution result.\")\n", - "def exec_sh(script: Annotated[str, \"Valid Python cell to execute.\"]) -> str:\n", - " return user_proxy.execute_code_blocks([(\"sh\", script)])\n", - "\n", - "\n", - "# start the conversation\n", - "user_proxy.initiate_chat(\n", - " chatbot,\n", - " message=\"Draw two agents chatting with each other with an example dialog. Don't add plt.show().\",\n", - ")" + "with Cache.disk():\n", + " # start the conversation\n", + " user_proxy.initiate_chat(\n", + " chatbot,\n", + " message=\"Draw two agents chatting with each other with an example dialog. Don't add plt.show().\",\n", + " )" ] }, { diff --git a/notebook/agentchat_function_call_async.ipynb b/notebook/agentchat_function_call_async.ipynb index ca65291b2c0..bb6fa48d661 100644 --- a/notebook/agentchat_function_call_async.ipynb +++ b/notebook/agentchat_function_call_async.ipynb @@ -61,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "dca301a4", "metadata": {}, "outputs": [], @@ -71,6 +71,7 @@ "from typing_extensions import Annotated\n", "\n", "import autogen\n", + "from autogen.cache import Cache\n", "\n", "config_list = autogen.config_list_from_json(\n", " \"OAI_CONFIG_LIST\",\n", @@ -119,9 +120,73 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "9fb85afb", "metadata": {}, + "outputs": [], + "source": [ + "llm_config = {\n", + " \"config_list\": config_list,\n", + "}\n", + "\n", + "coder = autogen.AssistantAgent(\n", + " name=\"chatbot\",\n", + " system_message=\"For coding tasks, only use the functions you have been provided with. You have a stopwatch and a timer, these tools can and should be used in parallel. Reply TERMINATE when the task is done.\",\n", + " llm_config=llm_config,\n", + ")\n", + "\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"user_proxy\",\n", + " system_message=\"A proxy for the user for executing code.\",\n", + " is_termination_msg=lambda x: x.get(\"content\", \"\") and x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=10,\n", + " code_execution_config={\"work_dir\": \"coding\"},\n", + ")\n", + "\n", + "# define functions according to the function description\n", + "\n", + "# An example async function registered using register_for_llm and register_for_execution decorators\n", + "\n", + "\n", + "@user_proxy.register_for_execution()\n", + "@coder.register_for_llm(description=\"create a timer for N seconds\")\n", + "async def timer(num_seconds: Annotated[str, \"Number of seconds in the timer.\"]) -> str:\n", + " for i in range(int(num_seconds)):\n", + " time.sleep(1)\n", + " # should print to stdout\n", + " return \"Timer is done!\"\n", + "\n", + "\n", + "# An example sync function registered using register_function\n", + "def stopwatch(num_seconds: Annotated[str, \"Number of seconds in the stopwatch.\"]) -> str:\n", + " for i in range(int(num_seconds)):\n", + " time.sleep(1)\n", + " return \"Stopwatch is done!\"\n", + "\n", + "\n", + "autogen.agentchat.register_function(\n", + " stopwatch,\n", + " caller=coder,\n", + " executor=user_proxy,\n", + " description=\"create a stopwatch for N seconds\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "159cd7b6", + "metadata": {}, + "source": [ + "Start the conversation. `await` is used to pause and resume code execution for async IO operations. Without `await`, an async function returns a coroutine object but doesn't execute the function. With `await`, the async function is executed and the current function is paused until the awaited function returns a result." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "37514ea3", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -134,26 +199,32 @@ "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", "\n", - "\u001b[32m***** Suggested tool Call (call_fGgH8U261nOnx3JGNJWslhh6): timer *****\u001b[0m\n", + "\u001b[32m***** Suggested tool Call (call_h6324df0CdGPDNjPO8GrnAQJ): timer *****\u001b[0m\n", "Arguments: \n", "{\"num_seconds\":\"5\"}\n", "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[35m\n", - ">>>>>>>> EXECUTING ASYNC FUNCTION timer...\u001b[0m\n", + ">>>>>>>> EXECUTING ASYNC FUNCTION timer...\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", "\n", "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", "\n", - "\u001b[32m***** Response from calling tool \"timer\" *****\u001b[0m\n", + "\u001b[32m***** Response from calling tool \"call_h6324df0CdGPDNjPO8GrnAQJ\" *****\u001b[0m\n", "Timer is done!\n", - "\u001b[32m**********************************************\u001b[0m\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", "\n", - "\u001b[32m***** Suggested tool Call (call_BZs6ynF8gtcZKhONiIRZkECB): stopwatch *****\u001b[0m\n", + "\u001b[32m***** Suggested tool Call (call_7SzbQxI8Nsl6dPQtScoSGPAu): stopwatch *****\u001b[0m\n", "Arguments: \n", "{\"num_seconds\":\"5\"}\n", "\u001b[32m**************************************************************************\u001b[0m\n", @@ -165,9 +236,9 @@ "\n", "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", "\n", - "\u001b[32m***** Response from calling tool \"stopwatch\" *****\u001b[0m\n", + "\u001b[32m***** Response from calling tool \"call_7SzbQxI8Nsl6dPQtScoSGPAu\" *****\u001b[0m\n", "Stopwatch is done!\n", - "\u001b[32m**************************************************\u001b[0m\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", @@ -179,57 +250,11 @@ } ], "source": [ - "llm_config = {\n", - " \"config_list\": config_list,\n", - "}\n", - "\n", - "coder = autogen.AssistantAgent(\n", - " name=\"chatbot\",\n", - " system_message=\"For coding tasks, only use the functions you have been provided with. You have a stopwatch and a timer, these tools can and should be used in parallel. Reply TERMINATE when the task is done.\",\n", - " llm_config=llm_config,\n", - ")\n", - "\n", - "# create a UserProxyAgent instance named \"user_proxy\"\n", - "user_proxy = autogen.UserProxyAgent(\n", - " name=\"user_proxy\",\n", - " system_message=\"A proxy for the user for executing code.\",\n", - " is_termination_msg=lambda x: x.get(\"content\", \"\") and x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", - " human_input_mode=\"NEVER\",\n", - " max_consecutive_auto_reply=10,\n", - " code_execution_config={\"work_dir\": \"coding\"},\n", - ")\n", - "\n", - "# define functions according to the function description\n", - "\n", - "# An example async function\n", - "\n", - "\n", - "@user_proxy.register_for_execution()\n", - "@coder.register_for_llm(description=\"create a timer for N seconds\")\n", - "async def timer(num_seconds: Annotated[str, \"Number of seconds in the timer.\"]) -> str:\n", - " for i in range(int(num_seconds)):\n", - " time.sleep(1)\n", - " # should print to stdout\n", - " return \"Timer is done!\"\n", - "\n", - "\n", - "# An example sync function\n", - "@user_proxy.register_for_execution()\n", - "@coder.register_for_llm(description=\"create a stopwatch for N seconds\")\n", - "def stopwatch(num_seconds: Annotated[str, \"Number of seconds in the stopwatch.\"]) -> str:\n", - " for i in range(int(num_seconds)):\n", - " time.sleep(1)\n", - " return \"Stopwatch is done!\"\n", - "\n", - "\n", - "# start the conversation\n", - "# 'await' is used to pause and resume code execution for async IO operations.\n", - "# Without 'await', an async function returns a coroutine object but doesn't execute the function.\n", - "# With 'await', the async function is executed and the current function is paused until the awaited function returns a result.\n", - "await user_proxy.a_initiate_chat( # noqa: F704\n", - " coder,\n", - " message=\"Create a timer for 5 seconds and then a stopwatch for 5 seconds.\",\n", - ")" + "with Cache.disk():\n", + " await user_proxy.a_initiate_chat( # noqa: F704\n", + " coder,\n", + " message=\"Create a timer for 5 seconds and then a stopwatch for 5 seconds.\",\n", + " )" ] }, { @@ -243,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "2472f95c", "metadata": {}, "outputs": [], @@ -276,9 +301,17 @@ ")" ] }, + { + "cell_type": "markdown", + "id": "612bdd22", + "metadata": {}, + "source": [ + "Finally, we initialize the chat that would use the functions defined above:" + ] + }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "e2c9267a", "metadata": {}, "outputs": [ @@ -293,14 +326,21 @@ "2) Pretty print the result as md.\n", "3) when 1 and 2 are done, terminate the group chat\n", "\n", - "--------------------------------------------------------------------------------\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\u001b[33mchatbot\u001b[0m (to chat_manager):\n", "\n", - "\u001b[32m***** Suggested tool Call (call_zlHKR9LBzCqs1iLId5kvNvJ5): timer *****\u001b[0m\n", + "\u001b[32m***** Suggested tool Call (call_qlS3QkcY1NkfgpKtCoR6oGo7): timer *****\u001b[0m\n", "Arguments: \n", "{\"num_seconds\": \"5\"}\n", "\u001b[32m**********************************************************************\u001b[0m\n", - "\u001b[32m***** Suggested tool Call (call_rH1dgbS9itiJO1Gwnxxhcm35): stopwatch *****\u001b[0m\n", + "\u001b[32m***** Suggested tool Call (call_TEHlvMgCp0S3RzBbVsVPXWeL): stopwatch *****\u001b[0m\n", "Arguments: \n", "{\"num_seconds\": \"5\"}\n", "\u001b[32m**************************************************************************\u001b[0m\n", @@ -314,29 +354,23 @@ "\n", "\u001b[33muser_proxy\u001b[0m (to chat_manager):\n", "\n", - "\u001b[32m***** Response from calling tool \"timer\" *****\u001b[0m\n", + "\u001b[32m***** Response from calling tool \"call_qlS3QkcY1NkfgpKtCoR6oGo7\" *****\u001b[0m\n", "Timer is done!\n", - "\u001b[32m**********************************************\u001b[0m\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to chat_manager):\n", "\n", - "\u001b[32m***** Response from calling tool \"stopwatch\" *****\u001b[0m\n", + "\u001b[32m***** Response from calling tool \"call_TEHlvMgCp0S3RzBbVsVPXWeL\" *****\u001b[0m\n", "Stopwatch is done!\n", - "\u001b[32m**************************************************\u001b[0m\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mMarkdown_agent\u001b[0m (to chat_manager):\n", "\n", - "The results of the timer and stopwatch are as follows:\n", - "\n", - "- Timer: Timer is done!\n", - "- Stopwatch: Stopwatch is done!\n", - "\n", - "Now, I will proceed to terminate the group chat.\n", - "\u001b[32m***** Suggested tool Call (call_3Js7oU80vPatnA8IiaKXB5Xu): terminate_group_chat *****\u001b[0m\n", + "\u001b[32m***** Suggested tool Call (call_JuQwvj4FigfvGyBeTMglY2ee): terminate_group_chat *****\u001b[0m\n", "Arguments: \n", - "{\"message\":\"The session has concluded, and the group chat will now be terminated.\"}\n", + "{\"message\":\"Both timer and stopwatch have completed their countdowns. The group chat is now being terminated.\"}\n", "\u001b[32m*************************************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", @@ -346,23 +380,26 @@ "\n", "\u001b[33muser_proxy\u001b[0m (to chat_manager):\n", "\n", - "\u001b[32m***** Response from calling tool \"terminate_group_chat\" *****\u001b[0m\n", - "[GROUPCHAT_TERMINATE] The session has concluded, and the group chat will now be terminated.\n", - "\u001b[32m*************************************************************\u001b[0m\n", + "\u001b[32m***** Response from calling tool \"call_JuQwvj4FigfvGyBeTMglY2ee\" *****\u001b[0m\n", + "[GROUPCHAT_TERMINATE] Both timer and stopwatch have completed their countdowns. The group chat is now being terminated.\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n" ] } ], "source": [ - "# todo: remove comment after fixing https://github.com/microsoft/autogen/issues/1205\n", - "await user_proxy.a_initiate_chat( # noqa: F704\n", - " manager,\n", - " message=\"\"\"\n", + "message = \"\"\"\n", "1) Create a timer and a stopwatch for 5 seconds each in parallel.\n", "2) Pretty print the result as md.\n", - "3) when 1 and 2 are done, terminate the group chat\"\"\",\n", - ")" + "3) when 1 and 2 are done, terminate the group chat\n", + "\"\"\"\n", + "\n", + "with Cache.disk():\n", + " await user_proxy.a_initiate_chat( # noqa: F704\n", + " manager,\n", + " message=message,\n", + " )" ] }, { @@ -390,7 +427,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/notebook/agentchat_function_call_currency_calculator.ipynb b/notebook/agentchat_function_call_currency_calculator.ipynb index e42f91c1a6a..6637a4a1ab2 100644 --- a/notebook/agentchat_function_call_currency_calculator.ipynb +++ b/notebook/agentchat_function_call_currency_calculator.ipynb @@ -63,6 +63,8 @@ "from typing_extensions import Annotated\n", "\n", "import autogen\n", + "from autogen.cache import Cache\n", + "\n", "\n", "config_list = autogen.config_list_from_json(\n", " \"OAI_CONFIG_LIST\",\n", @@ -274,9 +276,9 @@ "\n", "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", "\n", - "\u001b[32m***** Response from calling tool \"currency_calculator\" *****\u001b[0m\n", + "\u001b[32m***** Response from calling tool \"call_ubo7cKE3TKumGHkqGjQtZisy\" *****\u001b[0m\n", "112.22727272727272 EUR\n", - "\u001b[32m************************************************************\u001b[0m\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", @@ -298,11 +300,12 @@ } ], "source": [ - "# start the conversation\n", - "user_proxy.initiate_chat(\n", - " chatbot,\n", - " message=\"How much is 123.45 USD in EUR?\",\n", - ")" + "with Cache.disk():\n", + " # start the conversation\n", + " user_proxy.initiate_chat(\n", + " chatbot,\n", + " message=\"How much is 123.45 USD in EUR?\",\n", + " )" ] }, { @@ -353,14 +356,21 @@ " amount: Annotated[float, Field(0, description=\"Amount of currency\", ge=0)]\n", "\n", "\n", - "@user_proxy.register_for_execution()\n", - "@chatbot.register_for_llm(description=\"Currency exchange calculator.\")\n", + "# another way to register a function is to use register_function instead of register_for_execution and register_for_llm decorators\n", "def currency_calculator(\n", " base: Annotated[Currency, \"Base currency: amount and currency symbol\"],\n", " quote_currency: Annotated[CurrencySymbol, \"Quote currency symbol\"] = \"USD\",\n", ") -> Currency:\n", " quote_amount = exchange_rate(base.currency, quote_currency) * base.amount\n", - " return Currency(amount=quote_amount, currency=quote_currency)" + " return Currency(amount=quote_amount, currency=quote_currency)\n", + "\n", + "\n", + "autogen.agentchat.register_function(\n", + " currency_calculator,\n", + " caller=chatbot,\n", + " executor=user_proxy,\n", + " description=\"Currency exchange calculator.\",\n", + ")" ] }, { @@ -434,14 +444,14 @@ "\n", "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", "\n", - "\u001b[32m***** Response from calling tool \"currency_calculator\" *****\u001b[0m\n", + "\u001b[32m***** Response from calling tool \"call_0VuU2rATuOgYrGmcBnXzPXlh\" *****\u001b[0m\n", "{\"currency\":\"USD\",\"amount\":123.45300000000002}\n", - "\u001b[32m************************************************************\u001b[0m\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", "\n", - "112.23 Euros is equivalent to approximately 123.45 US Dollars.\n", + "112.23 Euros is approximately 123.45 US Dollars.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", @@ -458,11 +468,12 @@ } ], "source": [ - "# start the conversation\n", - "user_proxy.initiate_chat(\n", - " chatbot,\n", - " message=\"How much is 112.23 Euros in US Dollars?\",\n", - ")" + "with Cache.disk():\n", + " # start the conversation\n", + " user_proxy.initiate_chat(\n", + " chatbot,\n", + " message=\"How much is 112.23 Euros in US Dollars?\",\n", + " )" ] }, { @@ -494,9 +505,9 @@ "\n", "\u001b[33muser_proxy\u001b[0m (to chatbot):\n", "\n", - "\u001b[32m***** Response from calling tool \"currency_calculator\" *****\u001b[0m\n", + "\u001b[32m***** Response from calling tool \"call_A6lqMu7s5SyDvftTSeQTtPcj\" *****\u001b[0m\n", "{\"currency\":\"EUR\",\"amount\":112.22727272727272}\n", - "\u001b[32m************************************************************\u001b[0m\n", + "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to user_proxy):\n", @@ -518,11 +529,12 @@ } ], "source": [ - "# start the conversation\n", - "user_proxy.initiate_chat(\n", - " chatbot,\n", - " message=\"How much is 123.45 US Dollars in Euros?\",\n", - ")" + "with Cache.disk():\n", + " # start the conversation\n", + " user_proxy.initiate_chat(\n", + " chatbot,\n", + " message=\"How much is 123.45 US Dollars in Euros?\",\n", + " )" ] }, { diff --git a/samples/tools/autogenbench/autogenbench/version.py b/samples/tools/autogenbench/autogenbench/version.py index ecbf4901d90..f102a9cadfa 100644 --- a/samples/tools/autogenbench/autogenbench/version.py +++ b/samples/tools/autogenbench/autogenbench/version.py @@ -1 +1 @@ -__version__ = "0.0.1a12" +__version__ = "0.0.1" diff --git a/test/agentchat/test_conversable_agent.py b/test/agentchat/test_conversable_agent.py index 64b8473cf69..8ff8038da7e 100644 --- a/test/agentchat/test_conversable_agent.py +++ b/test/agentchat/test_conversable_agent.py @@ -13,6 +13,7 @@ import autogen from autogen.agentchat import ConversableAgent, UserProxyAgent +from autogen.agentchat.conversable_agent import register_function from test_assistant_agent import KEY_LOC, OAI_CONFIG_LIST from conftest import skip_openai @@ -823,6 +824,47 @@ async def exec_sh(script: Annotated[str, "Valid shell script to execute."]): assert get_origin(user_proxy_1.function_map) == expected_function_map +def test_register_functions(): + with pytest.MonkeyPatch.context() as mp: + mp.setenv("OPENAI_API_KEY", "mock") + agent = ConversableAgent(name="agent", llm_config={"config_list": []}) + user_proxy = UserProxyAgent(name="user_proxy") + + def exec_python(cell: Annotated[str, "Valid Python cell to execute."]) -> str: + pass + + register_function( + exec_python, + caller=agent, + executor=user_proxy, + description="run cell in ipython and return the execution result.", + ) + + expected_function_map = {"exec_python": exec_python} + assert get_origin(user_proxy.function_map) == expected_function_map + + expected = [ + { + "type": "function", + "function": { + "description": "run cell in ipython and return the execution result.", + "name": "exec_python", + "parameters": { + "type": "object", + "properties": { + "cell": { + "type": "string", + "description": "Valid Python cell to execute.", + } + }, + "required": ["cell"], + }, + }, + } + ] + assert agent.llm_config["tools"] == expected + + @pytest.mark.skipif( skip or not sys.version.startswith("3.10"), reason="do not run if openai is not installed or py!=3.10", @@ -860,7 +902,7 @@ def test_function_registration_e2e_sync() -> None: timer_mock = unittest.mock.MagicMock() stopwatch_mock = unittest.mock.MagicMock() - # An example async function + # An example async function registered using decorators @user_proxy.register_for_execution() @coder.register_for_llm(description="create a timer for N seconds") def timer(num_seconds: Annotated[str, "Number of seconds in the timer."]) -> str: @@ -873,9 +915,7 @@ def timer(num_seconds: Annotated[str, "Number of seconds in the timer."]) -> str timer_mock(num_seconds=num_seconds) return "Timer is done!" - # An example sync function - @user_proxy.register_for_execution() - @coder.register_for_llm(description="create a stopwatch for N seconds") + # An example sync function registered using register_function def stopwatch(num_seconds: Annotated[str, "Number of seconds in the stopwatch."]) -> str: print("stopwatch is running") # assert False, "stopwatch's alive!" @@ -887,6 +927,8 @@ def stopwatch(num_seconds: Annotated[str, "Number of seconds in the stopwatch."] stopwatch_mock(num_seconds=num_seconds) return "Stopwatch is done!" + register_function(stopwatch, caller=coder, executor=user_proxy, description="create a stopwatch for N seconds") + # start the conversation # 'await' is used to pause and resume code execution for async IO operations. # Without 'await', an async function returns a coroutine object but doesn't execute the function. @@ -938,9 +980,7 @@ async def test_function_registration_e2e_async() -> None: timer_mock = unittest.mock.MagicMock() stopwatch_mock = unittest.mock.MagicMock() - # An example async function - @user_proxy.register_for_execution() - @coder.register_for_llm(description="create a timer for N seconds") + # An example async function registered using register_function async def timer(num_seconds: Annotated[str, "Number of seconds in the timer."]) -> str: print("timer is running") for i in range(int(num_seconds)): @@ -951,7 +991,9 @@ async def timer(num_seconds: Annotated[str, "Number of seconds in the timer."]) timer_mock(num_seconds=num_seconds) return "Timer is done!" - # An example sync function + register_function(timer, caller=coder, executor=user_proxy, description="create a timer for N seconds") + + # An example sync function registered using decorators @user_proxy.register_for_execution() @coder.register_for_llm(description="create a stopwatch for N seconds") def stopwatch(num_seconds: Annotated[str, "Number of seconds in the stopwatch."]) -> str: diff --git a/test/agentchat/test_function_and_tool_calling.py b/test/agentchat/test_function_and_tool_calling.py new file mode 100644 index 00000000000..893fbe35120 --- /dev/null +++ b/test/agentchat/test_function_and_tool_calling.py @@ -0,0 +1,378 @@ +import json +from typing import Any, Callable, Dict, List + +import pytest + +from autogen.agentchat.conversable_agent import ConversableAgent + + +def _tool_func_1(arg1: str, arg2: str) -> str: + return f"_tool_func_1: {arg1} {arg2}" + + +def _tool_func_2(arg1: str, arg2: str) -> str: + return f"_tool_func_2: {arg1} {arg2}" + + +def _tool_func_error(arg1: str, arg2: str) -> str: + raise RuntimeError("Error in tool function") + + +async def _a_tool_func_1(arg1: str, arg2: str) -> str: + return f"_tool_func_1: {arg1} {arg2}" + + +async def _a_tool_func_2(arg1: str, arg2: str) -> str: + return f"_tool_func_2: {arg1} {arg2}" + + +async def _a_tool_func_error(arg1: str, arg2: str) -> str: + raise RuntimeError("Error in tool function") + + +_tool_use_message_1 = { + "role": "assistant", + "content": None, + "tool_calls": [ + { + "id": "1", + "type": "function", + "function": { + "name": "_tool_func_1", + "arguments": json.dumps({"arg1": "value1", "arg2": "value2"}), + }, + }, + { + "id": "2", + "type": "function", + "function": { + "name": "_tool_func_2", + "arguments": json.dumps({"arg1": "value3", "arg2": "value4"}), + }, + }, + ], +} + +_tool_use_message_1_bad_json = { + "role": "assistant", + "content": None, + "tool_calls": [ + { + "id": "1", + "type": "function", + "function": { + "name": "_tool_func_1", + # add extra comma to make json invalid + "arguments": json.dumps({"arg1": "value3", "arg2": "value4"})[:-1] + ",}", + }, + }, + { + "id": "2", + "type": "function", + "function": { + "name": "_tool_func_2", + "arguments": json.dumps({"arg1": "value3", "arg2": "value4"}), + }, + }, + ], +} + +_tool_use_message_1_expected_reply = { + "role": "tool", + "tool_responses": [ + {"tool_call_id": "1", "role": "tool", "content": "_tool_func_1: value1 value2"}, + {"tool_call_id": "2", "role": "tool", "content": "_tool_func_2: value3 value4"}, + ], + # "content": "Tool Call Id: 1\n_tool_func_1: value1 value2\n\nTool Call Id: 2\n_tool_func_2: value3 value4", + "content": "_tool_func_1: value1 value2\n\n_tool_func_2: value3 value4", +} + + +_tool_use_message_1_bad_json_expected_reply = { + "role": "tool", + "tool_responses": [ + { + "tool_call_id": "1", + "role": "tool", + "content": "Error: Expecting property name enclosed in double quotes: line 1 column 37 (char 36)\n You argument should follow json format.", + }, + {"tool_call_id": "2", "role": "tool", "content": "_tool_func_2: value3 value4"}, + ], + "content": "Error: Expecting property name enclosed in double quotes: line 1 column 37 (char 36)\n You argument should follow json format.\n\n_tool_func_2: value3 value4", +} + +_tool_use_message_1_error_expected_reply = { + "role": "tool", + "tool_responses": [ + {"tool_call_id": "1", "role": "tool", "content": "_tool_func_1: value1 value2"}, + { + "tool_call_id": "2", + "role": "tool", + "content": "Error: Error in tool function", + }, + ], + "content": "_tool_func_1: value1 value2\n\nError: Error in tool function", +} + +_tool_use_message_1_not_found_expected_reply = { + "role": "tool", + "tool_responses": [ + {"tool_call_id": "1", "role": "tool", "content": "_tool_func_1: value1 value2"}, + { + "tool_call_id": "2", + "role": "tool", + "content": "Error: Function _tool_func_2 not found.", + }, + ], + "content": "_tool_func_1: value1 value2\n\nError: Function _tool_func_2 not found.", +} + +_function_use_message_1 = { + "role": "assistant", + "content": None, + "function_call": { + "name": "_tool_func_1", + "arguments": json.dumps({"arg1": "value1", "arg2": "value2"}), + }, +} + +_function_use_message_1_bad_json = { + "role": "assistant", + "content": None, + "function_call": { + "name": "_tool_func_1", + "arguments": json.dumps({"arg1": "value1", "arg2": "value2"})[:-1] + ",}", + }, +} + +_function_use_message_1_expected_reply = { + "name": "_tool_func_1", + "role": "function", + "content": "_tool_func_1: value1 value2", +} + +_function_use_message_1_bad_json_expected_reply = { + "name": "_tool_func_1", + "role": "function", + "content": "Error: Expecting property name enclosed in double quotes: line 1 column 37 (char 36)\n You argument should follow json format.", +} + +_function_use_message_1_error_expected_reply = { + "name": "_tool_func_1", + "role": "function", + "content": "Error: Error in tool function", +} + +_function_use_message_1_not_found_expected_reply = { + "name": "_tool_func_1", + "role": "function", + "content": "Error: Function _tool_func_1 not found.", +} + +_text_message = {"content": "Hi!", "role": "user"} + + +def _get_function_map(is_function_async: bool, drop_tool_2: bool = False) -> Dict[str, Callable[..., Any]]: + if is_function_async: + return ( + { + "_tool_func_1": _a_tool_func_1, + "_tool_func_2": _a_tool_func_2, + } + if not drop_tool_2 + else { + "_tool_func_1": _a_tool_func_1, + } + ) + else: + return ( + { + "_tool_func_1": _tool_func_1, + "_tool_func_2": _tool_func_2, + } + if not drop_tool_2 + else { + "_tool_func_1": _tool_func_1, + } + ) + + +def _get_error_function_map( + is_function_async: bool, error_on_tool_func_2: bool = True +) -> Dict[str, Callable[..., Any]]: + if is_function_async: + return { + "_tool_func_1": _a_tool_func_1 if error_on_tool_func_2 else _a_tool_func_error, + "_tool_func_2": _a_tool_func_error if error_on_tool_func_2 else _a_tool_func_2, + } + else: + return { + "_tool_func_1": _tool_func_1 if error_on_tool_func_2 else _tool_func_error, + "_tool_func_2": _tool_func_error if error_on_tool_func_2 else _tool_func_2, + } + + +@pytest.mark.parametrize("is_function_async", [True, False]) +def test_generate_function_call_reply_on_function_call_message(is_function_async: bool) -> None: + agent = ConversableAgent(name="agent", llm_config=False) + + # empty function_map + agent._function_map = {} + messages = [_function_use_message_1] + finished, retval = agent.generate_function_call_reply(messages) + assert (finished, retval) == (True, _function_use_message_1_not_found_expected_reply) + + # function map set + agent._function_map = _get_function_map(is_function_async) + + # correct function call, multiple times to make sure cleanups are done properly + for _ in range(3): + messages = [_function_use_message_1] + finished, retval = agent.generate_function_call_reply(messages) + assert (finished, retval) == (True, _function_use_message_1_expected_reply) + + # bad JSON + messages = [_function_use_message_1_bad_json] + finished, retval = agent.generate_function_call_reply(messages) + assert (finished, retval) == (True, _function_use_message_1_bad_json_expected_reply) + + # tool call + messages = [_tool_use_message_1] + finished, retval = agent.generate_function_call_reply(messages) + assert (finished, retval) == (False, None) + + # text message + messages: List[Dict[str, str]] = [_text_message] + finished, retval = agent.generate_function_call_reply(messages) + assert (finished, retval) == (False, None) + + # error in function (raises Exception) + agent._function_map = _get_error_function_map(is_function_async, error_on_tool_func_2=False) + messages = [_function_use_message_1] + finished, retval = agent.generate_function_call_reply(messages) + assert (finished, retval) == (True, _function_use_message_1_error_expected_reply) + + +@pytest.mark.asyncio() +@pytest.mark.parametrize("is_function_async", [True, False]) +async def test_a_generate_function_call_reply_on_function_call_message(is_function_async: bool) -> None: + agent = ConversableAgent(name="agent", llm_config=False) + + # empty function_map + agent._function_map = {} + messages = [_function_use_message_1] + finished, retval = await agent.a_generate_function_call_reply(messages) + assert (finished, retval) == (True, _function_use_message_1_not_found_expected_reply) + + # function map set + agent._function_map = _get_function_map(is_function_async) + + # correct function call, multiple times to make sure cleanups are done properly + for _ in range(3): + messages = [_function_use_message_1] + finished, retval = await agent.a_generate_function_call_reply(messages) + assert (finished, retval) == (True, _function_use_message_1_expected_reply) + + # bad JSON + messages = [_function_use_message_1_bad_json] + finished, retval = await agent.a_generate_function_call_reply(messages) + assert (finished, retval) == (True, _function_use_message_1_bad_json_expected_reply) + + # tool call + messages = [_tool_use_message_1] + finished, retval = await agent.a_generate_function_call_reply(messages) + assert (finished, retval) == (False, None) + + # text message + messages: List[Dict[str, str]] = [_text_message] + finished, retval = await agent.a_generate_function_call_reply(messages) + assert (finished, retval) == (False, None) + + # error in function (raises Exception) + agent._function_map = _get_error_function_map(is_function_async, error_on_tool_func_2=False) + messages = [_function_use_message_1] + finished, retval = await agent.a_generate_function_call_reply(messages) + assert (finished, retval) == (True, _function_use_message_1_error_expected_reply) + + +@pytest.mark.parametrize("is_function_async", [True, False]) +def test_generate_tool_calls_reply_on_function_call_message(is_function_async: bool) -> None: + agent = ConversableAgent(name="agent", llm_config=False) + + # empty function_map + agent._function_map = _get_function_map(is_function_async, drop_tool_2=True) + messages = [_tool_use_message_1] + finished, retval = agent.generate_tool_calls_reply(messages) + assert (finished, retval) == (True, _tool_use_message_1_not_found_expected_reply) + + # function map set + agent._function_map = _get_function_map(is_function_async) + + # correct function call, multiple times to make sure cleanups are done properly + for _ in range(3): + messages = [_tool_use_message_1] + finished, retval = agent.generate_tool_calls_reply(messages) + assert (finished, retval) == (True, _tool_use_message_1_expected_reply) + + # bad JSON + messages = [_tool_use_message_1_bad_json] + finished, retval = agent.generate_tool_calls_reply(messages) + assert (finished, retval) == (True, _tool_use_message_1_bad_json_expected_reply) + + # function call + messages = [_function_use_message_1] + finished, retval = agent.generate_tool_calls_reply(messages) + assert (finished, retval) == (False, None) + + # text message + messages: List[Dict[str, str]] = [_text_message] + finished, retval = agent.generate_tool_calls_reply(messages) + assert (finished, retval) == (False, None) + + # error in function (raises Exception) + agent._function_map = _get_error_function_map(is_function_async) + messages = [_tool_use_message_1] + finished, retval = agent.generate_tool_calls_reply(messages) + assert (finished, retval) == (True, _tool_use_message_1_error_expected_reply) + + +@pytest.mark.asyncio() +@pytest.mark.parametrize("is_function_async", [True, False]) +async def test_a_generate_tool_calls_reply_on_function_call_message(is_function_async: bool) -> None: + agent = ConversableAgent(name="agent", llm_config=False) + + # empty function_map + agent._function_map = _get_function_map(is_function_async, drop_tool_2=True) + messages = [_tool_use_message_1] + finished, retval = await agent.a_generate_tool_calls_reply(messages) + assert (finished, retval) == (True, _tool_use_message_1_not_found_expected_reply) + + # function map set + agent._function_map = _get_function_map(is_function_async) + + # correct function call, multiple times to make sure cleanups are done properly + for _ in range(3): + messages = [_tool_use_message_1] + finished, retval = await agent.a_generate_tool_calls_reply(messages) + assert (finished, retval) == (True, _tool_use_message_1_expected_reply) + + # bad JSON + messages = [_tool_use_message_1_bad_json] + finished, retval = await agent.a_generate_tool_calls_reply(messages) + assert (finished, retval) == (True, _tool_use_message_1_bad_json_expected_reply) + + # function call + messages = [_function_use_message_1] + finished, retval = await agent.a_generate_tool_calls_reply(messages) + assert (finished, retval) == (False, None) + + # text message + messages: List[Dict[str, str]] = [_text_message] + finished, retval = await agent.a_generate_tool_calls_reply(messages) + assert (finished, retval) == (False, None) + + # error in function (raises Exception) + agent._function_map = _get_error_function_map(is_function_async) + messages = [_tool_use_message_1] + finished, retval = await agent.a_generate_tool_calls_reply(messages) + assert (finished, retval) == (True, _tool_use_message_1_error_expected_reply) diff --git a/test/oai/test_client.py b/test/oai/test_client.py index b8c93e13d70..77b69cb71ca 100644 --- a/test/oai/test_client.py +++ b/test/oai/test_client.py @@ -138,12 +138,6 @@ def test_usage_summary(): # check print client.print_usage_summary() - # check update - client._update_usage_summary(response, use_cache=True) - assert ( - client.total_usage_summary["total_cost"] == response.cost * 2 - ), "total_cost should be equal to response.cost * 2" - # check clear client.clear_usage_summary() assert client.actual_usage_summary is None, "actual_usage_summary should be None" @@ -152,8 +146,16 @@ def test_usage_summary(): # actual usage and all usage should be different response = client.create(prompt="1+3=", model=model, cache_seed=42) assert client.total_usage_summary["total_cost"] > 0, "total_cost should be greater than 0" + client.clear_usage_summary() + response = client.create(prompt="1+3=", model=model, cache_seed=42) assert client.actual_usage_summary is None, "No actual cost should be recorded" + # check update + response = client.create(prompt="1+3=", model=model, cache_seed=42) + assert ( + client.total_usage_summary["total_cost"] == response.cost * 2 + ), "total_cost should be equal to response.cost * 2" + @pytest.mark.skipif(skip, reason="openai>=1 not installed") def test_legacy_cache(): diff --git a/website/README.md b/website/README.md index cc52f448078..6aa24b7fd91 100644 --- a/website/README.md +++ b/website/README.md @@ -1,6 +1,6 @@ # Website -This website is built using [Docusaurus 2](https://docusaurus.io/), a modern static website generator. +This website is built using [Docusaurus 3](https://docusaurus.io/), a modern static website generator. ## Prerequisites @@ -25,6 +25,8 @@ yarn install Install it [here](https://quarto.org/docs/get-started/). +> Note: Support for Docusaurus 3.0 in Quarto is from version `1.4`. Ensure that your `quarto` version is `1.4` or higher. + ## Local Development Navigate to the `website` folder and run: diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md index 17be8b91b48..dbdc6a95207 100644 --- a/website/docs/Use-Cases/agent_chat.md +++ b/website/docs/Use-Cases/agent_chat.md @@ -102,7 +102,6 @@ user_proxy = autogen.UserProxyAgent( ``` python CurrencySymbol = Literal["USD", "EUR"] - def exchange_rate(base_currency: CurrencySymbol, quote_currency: CurrencySymbol) -> float: if base_currency == quote_currency: return 1.0 @@ -156,12 +155,30 @@ you can call the decorators as functions: ```python # Register the function with the chatbot's llm_config. -chatbot.register_for_llm(description="Currency exchange calculator.")(currency_calculator) +currency_calculator = chatbot.register_for_llm(description="Currency exchange calculator.")(currency_calculator) # Register the function with the user_proxy's function_map. user_proxy.register_for_execution()(currency_calculator) ``` +Alternatevely, you can also use `autogen.agentchat.register_function()` instead as follows: +```python +def currency_calculator( + base_amount: Annotated[float, "Amount of currency in base_currency"], + base_currency: Annotated[CurrencySymbol, "Base currency"] = "USD", + quote_currency: Annotated[CurrencySymbol, "Quote currency"] = "EUR", +) -> str: + quote_amount = exchange_rate(base_currency, quote_currency) * base_amount + return f"{quote_amount} {quote_currency}" + +autogen.agentchat.register_function( + currency_calculator, + agent=chatbot, + executor=user_proxy, + description="Currency exchange calculator.", +) +``` + 4. Agents can now use the function as follows: ```python user_proxy.initiate_chat( @@ -216,14 +233,19 @@ class Currency(BaseModel): # parameter of type float, must be greater or equal to 0 with default value 0 amount: Annotated[float, Field(0, description="Amount of currency", ge=0)] -@user_proxy.register_for_execution() -@chatbot.register_for_llm(description="Currency exchange calculator.") def currency_calculator( base: Annotated[Currency, "Base currency: amount and currency symbol"], quote_currency: Annotated[CurrencySymbol, "Quote currency symbol"] = "USD", ) -> Currency: quote_amount = exchange_rate(base.currency, quote_currency) * base.amount return Currency(amount=quote_amount, currency=quote_currency) + +autogen.agentchat.register_function( + currency_calculator, + agent=chatbot, + executor=user_proxy, + description="Currency exchange calculator.", +) ``` The generated JSON schema has additional properties such as minimum value encoded: From 0e38de52427cbd2b997170c39f83fc24d10ce6dd Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 1 Feb 2024 11:39:40 +0100 Subject: [PATCH 24/52] fixing failing test --- test/coding/test_ipython_code_executor.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/test/coding/test_ipython_code_executor.py b/test/coding/test_ipython_code_executor.py index 89e937e6369..582ce114c58 100644 --- a/test/coding/test_ipython_code_executor.py +++ b/test/coding/test_ipython_code_executor.py @@ -149,5 +149,7 @@ def test_function(a, b): print(test_function(123, 4)) ``` """ - reply = agent.generate_reply([{"role": "user", "content": msg}], sender=ConversableAgent("user")) - assert "492" in reply # type: ignore[operator] + with pytest.MonkeyPatch.context() as mp: + mp.setenv("OPENAI_API_KEY", "mock") + reply = agent.generate_reply([{"role": "user", "content": msg}], sender=ConversableAgent("user")) + assert "492" in reply # type: ignore[operator] From 9ec323d39817c0c421e3595a20ae3dbffde2a464 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Thu, 1 Feb 2024 10:37:38 -0800 Subject: [PATCH 25/52] wip --- autogen/agentchat/conversable_agent.py | 14 ++--- autogen/coding/commandline_code_executor.py | 52 ++++++++++++++----- ...r.py => embedded_ipython_code_executor.py} | 52 +++++++++++++------ autogen/coding/factory.py | 6 +-- ...=> test_embedded_ipython_code_executor.py} | 18 +++---- test/coding/test_factory.py | 10 ++-- 6 files changed, 100 insertions(+), 52 deletions(-) rename autogen/coding/{ipython_code_executor.py => embedded_ipython_code_executor.py} (79%) rename test/coding/{test_ipython_code_executor.py => test_embedded_ipython_code_executor.py} (91%) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index a04da09164f..3ed2abb509f 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -894,24 +894,24 @@ def _generate_code_execution_reply_using_executor( if not (isinstance(last_n_messages, (int, float)) and last_n_messages >= 0) and last_n_messages != "auto": raise ValueError("last_n_messages must be either a non-negative integer, or the string 'auto'.") - messages_to_scan = last_n_messages + num_messages_to_scan = last_n_messages if last_n_messages == "auto": # Find when the agent last spoke - messages_to_scan = 0 - for i in range(len(messages)): - message = messages[-(i + 1)] + num_messages_to_scan = 0 + for message in reversed(messages): if "role" not in message: break elif message["role"] != "user": break else: - messages_to_scan += 1 + num_messages_to_scan += 1 + num_messages_to_scan = min(len(messages), num_messages_to_scan) + messages_to_scan = messages[-num_messages_to_scan:] # iterate through the last n messages in reverse # if code blocks are found, execute the code blocks and return the output # if no code blocks are found, continue - for i in range(min(len(messages), messages_to_scan)): - message = messages[-(i + 1)] + for message in reversed(messages_to_scan): if not message["content"]: continue code_blocks = self._code_executor.code_extractor.extract_code_blocks(message["content"]) diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/commandline_code_executor.py index 224554646cc..2c1ca4635d9 100644 --- a/autogen/coding/commandline_code_executor.py +++ b/autogen/coding/commandline_code_executor.py @@ -1,5 +1,6 @@ +import uuid import warnings -from typing import Any, List, Optional, Tuple, Union +from typing import Any, List, Optional, Union from pydantic import BaseModel, Field @@ -20,12 +21,33 @@ def colored(x: Any, *args: Any, **kwargs: Any) -> str: # type: ignore[misc] class CommandlineCodeExecutor(BaseModel): - """A code executor class that executes code through command line without persisting - any state in memory between executions. + """A code executor class that executes code through a terminal command line + environment. - Each execution is independent of each other. By default, it uses docker to - execute code. It can be configured to execute code locally without docker + By default, this code executor uses a docker container to execute code. + It can be configured to execute code locally without docker but it's not recommended. + + Each code block is saved as a file and executed in a separate process in + the working directory, and a unique filename is generated for each code + block. The code blocks are executed in the order they are received. + 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. + 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 "extensions" directory under path to `autogen`. + use_docker (bool): Whether to use a docker container for code + execution. If False, the code will be executed in the current + environment. Default is True. + docker_image_name (str): The optional docker image to use for code + execution. `use_docker` must be True for this to take effect. + If not provided, a default image will be created based on + python:3-slim and used for code execution. """ class UserCapability: @@ -48,9 +70,8 @@ def add_to_agent(self, agent: LLMAgent) -> None: agent.update_system_message(system_message) timeout: Optional[int] = Field(default=DEFAULT_TIMEOUT, ge=1) - filename: Optional[str] = None work_dir: Optional[str] = Field(default=WORKING_DIR) - use_docker: Optional[Union[List[str], str, bool]] = None + use_docker: bool = Field(default=True) docker_image_name: Optional[str] = None def _get_use_docker_for_code_utils(self) -> Optional[Union[List[str], str, bool]]: @@ -73,7 +94,13 @@ def code_extractor(self) -> CodeExtractor: return MarkdownCodeExtractor() def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: - """Execute the code blocks and return the result.""" + """Execute the code blocks and return the result. + + Args: + code_blocks (List[CodeBlock]): The code blocks to execute. + + Returns: + CodeResult: The result of the code execution.""" logs_all = "" for i, code_block in enumerate(code_blocks): lang, code = code_block.language, code_block.code @@ -84,20 +111,19 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: ), flush=True, ) + filename_uuid = uuid.uuid4().hex if lang in ["bash", "shell", "sh"]: + filename = f"{filename_uuid}.{lang}" exitcode, logs, image = execute_code( code=code, lang=lang, timeout=self.timeout, work_dir=self.work_dir, - filename=self.filename, + filename=filename, use_docker=self._get_use_docker_for_code_utils(), ) elif lang in ["python", "Python"]: - if code.startswith("# filename: "): - filename = code[11 : code.find("\n")].strip() - else: - filename = None + filename = f"{filename_uuid}.py" exitcode, logs, image = execute_code( code=code, lang="python", diff --git a/autogen/coding/ipython_code_executor.py b/autogen/coding/embedded_ipython_code_executor.py similarity index 79% rename from autogen/coding/ipython_code_executor.py rename to autogen/coding/embedded_ipython_code_executor.py index ec0eddace75..ada408d396b 100644 --- a/autogen/coding/ipython_code_executor.py +++ b/autogen/coding/embedded_ipython_code_executor.py @@ -7,22 +7,31 @@ from typing import Any, List from jupyter_client import KernelManager # type: ignore[attr-defined] -from jupyter_client.kernelspec import KernelSpecManager, NoSuchKernel +from jupyter_client.kernelspec import KernelSpecManager from pydantic import BaseModel, Field from ..agentchat.agent import LLMAgent -from ..code_utils import DEFAULT_TIMEOUT from .base import CodeBlock, CodeExtractor, CodeResult from .markdown_code_extractor import MarkdownCodeExtractor -__all__ = ("IPythonCodeExecutor",) +__all__ = ("EmbeddedIPythonCodeExecutor",) -class IPythonCodeExecutor(BaseModel): - """A code executor class that executes code statefully using IPython kernel. +class EmbeddedIPythonCodeExecutor(BaseModel): + """A code executor class that executes code statefully using an embedded + IPython kernel managed by this class. Each execution is stateful and can access variables created from previous - executions in the same session. + executions in the same session. The kernel must be installed before using + this class. The kernel can be installed using the following command: + `python -m ipykernel install --user --name {kernel_name}` + where `kernel_name` is the name of the kernel to install. + + Args: + timeout (int): The timeout for code execution, by default 60. + kernel_name (str): The kernel name to use. Make sure it is installed. + By default, it is "python3". + output_dir (str): The directory to save output files, by default ".". """ class UserCapability: @@ -60,29 +69,29 @@ def add_to_agent(self, agent: LLMAgent) -> None: system_message = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE agent.update_system_message(system_message) - timeout: int = Field(default=DEFAULT_TIMEOUT, ge=1, description="The timeout for code execution.") - kernel: str = Field(default="python3", description="The kernel to use.") + timeout: int = Field(default=60, ge=1, description="The timeout for code execution.") + kernel_name: str = Field(default="python3", description="The kernel name to use. Make sure it is installed.") output_dir: str = Field(default=".", description="The directory to save output files.") def __init__(self, **kwargs: Any): super().__init__(**kwargs) # Check if the kernel is installed. - if self.kernel not in KernelSpecManager().find_kernel_specs(): + if self.kernel_name not in KernelSpecManager().find_kernel_specs(): raise ValueError( - f"Kernel {self.kernel} is not installed. " + f"Kernel {self.kernel_name} is not installed. " "Please first install it with " - f"`python -m ipykernel install --user --name {self.kernel}`." + f"`python -m ipykernel install --user --name {self.kernel_name}`." ) - self._kernel_manager = KernelManager() + self._kernel_manager = KernelManager(kernel_name=self.kernel_name) self._kernel_manager.start_kernel() self._kernel_client = self._kernel_manager.client() self._kernel_client.start_channels() self._timeout = self.timeout @property - def user_capability(self) -> "IPythonCodeExecutor.UserCapability": + def user_capability(self) -> "EmbeddedIPythonCodeExecutor.UserCapability": """Export a user capability that can be added to an agent.""" - return IPythonCodeExecutor.UserCapability() + return EmbeddedIPythonCodeExecutor.UserCapability() @property def code_extractor(self) -> CodeExtractor: @@ -90,6 +99,19 @@ def code_extractor(self) -> CodeExtractor: return MarkdownCodeExtractor() def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: + """Execute a list of code blocks and return the result. + + This method executes a list of code blocks as cells in an IPython kernel + managed by this class. + See: https://jupyter-client.readthedocs.io/en/stable/messaging.html + for the message protocol. + + Args: + code_blocks (List[CodeBlock]): A list of code blocks to execute. + + Returns: + CodeResult: The result of the code execution. + """ self._kernel_client.wait_for_ready() outputs = [] for code_block in code_blocks: @@ -140,7 +162,7 @@ def restart(self) -> None: """Restart a new session.""" self._kernel_client.stop_channels() self._kernel_manager.shutdown_kernel() - self._kernel_manager = KernelManager(kernel_name=self.kernel) + self._kernel_manager = KernelManager(kernel_name=self.kernel_name) self._kernel_manager.start_kernel() self._kernel_client = self._kernel_manager.client() self._kernel_client.start_channels() diff --git a/autogen/coding/factory.py b/autogen/coding/factory.py index 5a21c76d0c3..0129e9de6ba 100644 --- a/autogen/coding/factory.py +++ b/autogen/coding/factory.py @@ -29,10 +29,10 @@ def create(code_execution_config: Dict[str, Any]) -> CodeExecutor: if isinstance(executor, CodeExecutor): # If the executor is already an instance of CodeExecutor, return it. return executor - if executor == "ipython": - from .ipython_code_executor import IPythonCodeExecutor + if executor == "ipython-embedded": + from .embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor - return IPythonCodeExecutor(**code_execution_config.get("ipython", {})) + return EmbeddedIPythonCodeExecutor(**code_execution_config.get("ipython-embedded", {})) elif executor == "commandline": from .commandline_code_executor import CommandlineCodeExecutor diff --git a/test/coding/test_ipython_code_executor.py b/test/coding/test_embedded_ipython_code_executor.py similarity index 91% rename from test/coding/test_ipython_code_executor.py rename to test/coding/test_embedded_ipython_code_executor.py index 89e937e6369..db3bf484c6f 100644 --- a/test/coding/test_ipython_code_executor.py +++ b/test/coding/test_embedded_ipython_code_executor.py @@ -5,7 +5,7 @@ from autogen.agentchat.agent import Agent from autogen.agentchat.conversable_agent import ConversableAgent from autogen.coding.base import CodeBlock -from autogen.coding.ipython_code_executor import IPythonCodeExecutor +from autogen.coding.embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor from autogen.oai.openai_utils import config_list_from_json from conftest import skip_openai # noqa: E402 @@ -18,14 +18,14 @@ def test_execute_code_single_code_block() -> None: - executor = IPythonCodeExecutor() + executor = EmbeddedIPythonCodeExecutor() code_blocks = [CodeBlock(code="import sys\nprint('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 def test_execute_code_multiple_code_blocks() -> None: - executor = IPythonCodeExecutor() + executor = EmbeddedIPythonCodeExecutor() code_blocks = [ CodeBlock(code="import sys\na = 123 + 123\n", language="python"), CodeBlock(code="print(a)", language="python"), @@ -46,7 +46,7 @@ def test_function(a, b): def test_execute_code_bash_script() -> None: - executor = IPythonCodeExecutor() + executor = EmbeddedIPythonCodeExecutor() # Test bash script. code_blocks = [CodeBlock(code='!echo "hello world!"', language="bash")] code_result = executor.execute_code_blocks(code_blocks) @@ -54,7 +54,7 @@ def test_execute_code_bash_script() -> None: def test_saving_to_file() -> None: - executor = IPythonCodeExecutor() + executor = EmbeddedIPythonCodeExecutor() with tempfile.TemporaryDirectory() as tmpdirname: code = f""" with open('{os.path.join(tmpdirname, "test_file_name")}', 'w') as f: @@ -66,14 +66,14 @@ def test_saving_to_file() -> None: def test_timeout() -> None: - executor = IPythonCodeExecutor(timeout=1) + executor = EmbeddedIPythonCodeExecutor(timeout=1) 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_silent_pip_install() -> None: - executor = IPythonCodeExecutor() + executor = EmbeddedIPythonCodeExecutor() code_blocks = [CodeBlock(code="!pip install matplotlib numpy", language="python")] code_result = executor.execute_code_blocks(code_blocks) assert code_result.exit_code == 0 and code_result.output.strip() == "" @@ -85,7 +85,7 @@ def test_silent_pip_install() -> None: def test_restart() -> None: - executor = IPythonCodeExecutor() + executor = EmbeddedIPythonCodeExecutor() code_blocks = [CodeBlock(code="x = 123", language="python")] code_result = executor.execute_code_blocks(code_blocks) assert code_result.exit_code == 0 and code_result.output.strip() == "" @@ -115,7 +115,7 @@ def test_conversable_agent_capability() -> None: "coding_agent", llm_config=llm_config, ) - executor = IPythonCodeExecutor() + executor = EmbeddedIPythonCodeExecutor() executor.user_capability.add_to_agent(agent) # Test updated system prompt. diff --git a/test/coding/test_factory.py b/test/coding/test_factory.py index c6b5c7ca21f..0d6a37a0d5d 100644 --- a/test/coding/test_factory.py +++ b/test/coding/test_factory.py @@ -3,21 +3,21 @@ from autogen.coding.base import CodeExecutor from autogen.coding.commandline_code_executor import CommandlineCodeExecutor from autogen.coding.factory import CodeExecutorFactory -from autogen.coding.ipython_code_executor import IPythonCodeExecutor +from autogen.coding.embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor def test_create() -> None: - config: Dict[str, Union[str, CodeExecutor]] = {"executor": "ipython"} + config: Dict[str, Union[str, CodeExecutor]] = {"executor": "ipython-embedded"} executor = CodeExecutorFactory.create(config) - assert isinstance(executor, IPythonCodeExecutor) + assert isinstance(executor, EmbeddedIPythonCodeExecutor) config = {"executor": "commandline"} executor = CodeExecutorFactory.create(config) assert isinstance(executor, CommandlineCodeExecutor) - config = {"executor": IPythonCodeExecutor()} + config = {"executor": EmbeddedIPythonCodeExecutor()} executor = CodeExecutorFactory.create(config) - assert isinstance(executor, IPythonCodeExecutor) + assert isinstance(executor, EmbeddedIPythonCodeExecutor) config = {"executor": CommandlineCodeExecutor()} executor = CodeExecutorFactory.create(config) From 0e65e8640bda26d1a40e05f0eb90b99a8630a18f Mon Sep 17 00:00:00 2001 From: ekzhu Date: Thu, 1 Feb 2024 15:13:01 -0800 Subject: [PATCH 26/52] local command line executor and embedded ipython executor --- autogen/agentchat/conversable_agent.py | 46 +++-- autogen/coding/base.py | 14 +- ...py => docker_commandline_code_executor.py} | 0 .../coding/embedded_ipython_code_executor.py | 34 +++- autogen/coding/factory.py | 6 +- .../coding/local_commandline_code_executor.py | 147 ++++++++++++++++ test/coding/test_commandline_code_executor.py | 162 +++++++++--------- .../test_embedded_ipython_code_executor.py | 80 ++++++--- test/coding/test_factory.py | 12 +- 9 files changed, 343 insertions(+), 158 deletions(-) rename autogen/coding/{commandline_code_executor.py => docker_commandline_code_executor.py} (100%) create mode 100644 autogen/coding/local_commandline_code_executor.py diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 691cc24ff5c..d0b50670322 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -142,16 +142,6 @@ def __init__( # Initialize standalone client cache object. self.client_cache = None - self._code_execution_config: Union[Dict, Literal[False]] = ( - {} if code_execution_config is None else code_execution_config - ) - - if isinstance(self._code_execution_config, dict): - use_docker = self._code_execution_config.get("use_docker", None) - use_docker = decide_use_docker(use_docker) - check_can_use_docker_or_throw(use_docker) - self._code_execution_config["use_docker"] = use_docker - self.human_input_mode = human_input_mode self._max_consecutive_auto_reply = ( max_consecutive_auto_reply if max_consecutive_auto_reply is not None else self.MAX_CONSECUTIVE_AUTO_REPLY @@ -170,23 +160,29 @@ def __init__( self.register_reply([Agent, None], ConversableAgent.generate_oai_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_oai_reply, ignore_async_in_sync_chat=True) - # Do not register code executor if code execution is disabled. - if self._code_execution_config is not False: - if self._code_execution_config is True or ( - isinstance(self._code_execution_config, dict) and self._code_execution_config.get("executor") is None - ): - # Legacy code executor using code_utils. - warnings.warn( - "Using legacy code executor. Please use the new code executor " - "by setting 'executor' in code_execution_config. " - "For example: code_execution_config={'executor': 'commandline'}. " - "The legacy code executor will be removed in the future.", - DeprecationWarning, - ) - self.register_reply([Agent, None], ConversableAgent.generate_code_execution_reply) - else: + # Setting up code execution. + # Do not register code execution reply if code execution is disabled. + if code_execution_config is not False: + # If code_execution_config is None, set it to an empty dict. + if code_execution_config is None: + code_execution_config = {} + if not isinstance(code_execution_config, dict): + raise ValueError("code_execution_config must be a dict or False.") + + # We have got a valid code_execution_config. + self._code_execution_config = code_execution_config + + if self._code_execution_config.get("executor") is not None: + # Use the new code executor. self._code_executor = CodeExecutorFactory.create(self._code_execution_config) self.register_reply([Agent, None], ConversableAgent._generate_code_execution_reply_using_executor) + else: + # Legacy code execution using code_utils. + use_docker = self._code_execution_config.get("use_docker", None) + use_docker = decide_use_docker(use_docker) + check_can_use_docker_or_throw(use_docker) + self._code_execution_config["use_docker"] = use_docker + self.register_reply([Agent, None], ConversableAgent.generate_code_execution_reply) self.register_reply([Agent, None], ConversableAgent.generate_tool_calls_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_tool_calls_reply, ignore_async_in_sync_chat=True) diff --git a/autogen/coding/base.py b/autogen/coding/base.py index 9c68844413d..5cb4d4e630b 100644 --- a/autogen/coding/base.py +++ b/autogen/coding/base.py @@ -1,6 +1,6 @@ from typing import Any, Dict, List, Protocol, Union, runtime_checkable -from pydantic import BaseModel +from pydantic import BaseModel, Field from ..agentchat.agent import LLMAgent @@ -10,21 +10,17 @@ class CodeBlock(BaseModel): """A class that represents a code block.""" - """The code to execute.""" - code: str + code: str = Field(description="The code to execute.") - """The language of the code.""" - language: str + language: str = Field(description="The language of the code.") class CodeResult(BaseModel): """A class that represents the result of a code execution.""" - """The exit code of the code execution.""" - exit_code: int + exit_code: int = Field(description="The exit code of the code execution.") - """The output of the code execution.""" - output: str + output: str = Field(description="The output of the code execution.") class CodeExtractor(Protocol): diff --git a/autogen/coding/commandline_code_executor.py b/autogen/coding/docker_commandline_code_executor.py similarity index 100% rename from autogen/coding/commandline_code_executor.py rename to autogen/coding/docker_commandline_code_executor.py diff --git a/autogen/coding/embedded_ipython_code_executor.py b/autogen/coding/embedded_ipython_code_executor.py index ada408d396b..f8b4d0f78f2 100644 --- a/autogen/coding/embedded_ipython_code_executor.py +++ b/autogen/coding/embedded_ipython_code_executor.py @@ -8,7 +8,7 @@ from jupyter_client import KernelManager # type: ignore[attr-defined] from jupyter_client.kernelspec import KernelSpecManager -from pydantic import BaseModel, Field +from pydantic import BaseModel, Field, validator from ..agentchat.agent import LLMAgent from .base import CodeBlock, CodeExtractor, CodeResult @@ -17,10 +17,21 @@ __all__ = ("EmbeddedIPythonCodeExecutor",) +class IPythonCodeResult(CodeResult): + """A code result class for IPython code executor.""" + + output_files: List[str] = Field( + default_factory=list, + description="The list of files that the executed code blocks generated.", + ) + + class EmbeddedIPythonCodeExecutor(BaseModel): """A code executor class that executes code statefully using an embedded IPython kernel managed by this class. + **This will execute LLM generated code on the local machine.** + Each execution is stateful and can access variables created from previous executions in the same session. The kernel must be installed before using this class. The kernel can be installed using the following command: @@ -73,6 +84,12 @@ def add_to_agent(self, agent: LLMAgent) -> None: kernel_name: str = Field(default="python3", description="The kernel name to use. Make sure it is installed.") output_dir: str = Field(default=".", description="The directory to save output files.") + @validator("output_dir") + def _output_dir_must_exist(cls, value: str) -> str: + if not os.path.exists(value): + raise ValueError(f"Output directory {value} does not exist.") + return value + def __init__(self, **kwargs: Any): super().__init__(**kwargs) # Check if the kernel is installed. @@ -98,7 +115,7 @@ def code_extractor(self) -> CodeExtractor: """Export a code extractor that can be used by an agent.""" return MarkdownCodeExtractor() - def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: + def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> IPythonCodeResult: """Execute a list of code blocks and return the result. This method executes a list of code blocks as cells in an IPython kernel @@ -110,10 +127,11 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: code_blocks (List[CodeBlock]): A list of code blocks to execute. Returns: - CodeResult: The result of the code execution. + IPythonCodeResult: The result of the code execution. """ self._kernel_client.wait_for_ready() outputs = [] + output_files = [] for code_block in code_blocks: code = self._process_code(code_block.code) self._kernel_client.execute(code, store_history=True) @@ -131,10 +149,12 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: # Output is an image. path = self._save_image(data) outputs.append(f"Image data saved to {path}") + output_files.append(path) elif data_type == "text/html": # Output is an html. path = self._save_html(data) outputs.append(f"HTML data saved to {path}") + output_files.append(path) else: # Output raw data. outputs.append(json.dumps(data)) @@ -143,7 +163,7 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: outputs.append(content["text"]) elif msg_type == "error": # Output is an error. - return CodeResult( + return IPythonCodeResult( exit_code=1, output=f"ERROR: {content['ename']}: {content['evalue']}\n{content['traceback']}", ) @@ -151,12 +171,14 @@ def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: break # handle time outs. except Empty: - return CodeResult( + return IPythonCodeResult( exit_code=1, output=f"ERROR: Timeout waiting for output from code block: {code_block.code}", ) # We return the full output. - return CodeResult(exit_code=0, output="\n".join([str(output) for output in outputs])) + return IPythonCodeResult( + exit_code=0, output="\n".join([str(output) for output in outputs]), output_files=output_files + ) def restart(self) -> None: """Restart a new session.""" diff --git a/autogen/coding/factory.py b/autogen/coding/factory.py index 0129e9de6ba..65149b5a8c7 100644 --- a/autogen/coding/factory.py +++ b/autogen/coding/factory.py @@ -33,9 +33,9 @@ def create(code_execution_config: Dict[str, Any]) -> CodeExecutor: from .embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor return EmbeddedIPythonCodeExecutor(**code_execution_config.get("ipython-embedded", {})) - elif executor == "commandline": - from .commandline_code_executor import CommandlineCodeExecutor + elif executor == "commandline-local": + from .local_commandline_code_executor import LocalCommandlineCodeExecutor - return CommandlineCodeExecutor(**code_execution_config.get("commandline", {})) + return LocalCommandlineCodeExecutor(**code_execution_config.get("commandline-local", {})) else: raise ValueError(f"Unknown code executor {executor}") diff --git a/autogen/coding/local_commandline_code_executor.py b/autogen/coding/local_commandline_code_executor.py new file mode 100644 index 00000000000..440c2548813 --- /dev/null +++ b/autogen/coding/local_commandline_code_executor.py @@ -0,0 +1,147 @@ +import os +import uuid +import warnings +from typing import Any, List, Optional + +from pydantic import BaseModel, Field, validator + +from ..agentchat.agent import LLMAgent +from ..code_utils import execute_code +from .base import CodeBlock, CodeExtractor, CodeResult +from .markdown_code_extractor import MarkdownCodeExtractor + +try: + from termcolor import colored +except ImportError: + + def colored(x: Any, *args: Any, **kwargs: Any) -> str: # type: ignore[misc] + return x # type: ignore[no-any-return] + + +__all__ = ( + "LocalCommandlineCodeExecutor", + "CommandlineCodeResult", +) + + +class CommandlineCodeResult(CodeResult): + """A code result class for command line code executor.""" + + code_file: Optional[str] = Field( + default=None, + description="The file that the executed code block was saved to.", + ) + + +class LocalCommandlineCodeExecutor(BaseModel): + """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. + 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 ".". + """ + + class UserCapability: + """An AgentCapability class that gives agent ability use a command line + code executor.""" + + DEFAULT_SYSTEM_MESSAGE_UPDATE = """ +You have been given coding capability to solve tasks using Python code. +In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. + 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself. + 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. +Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill. +When using code, you must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. +If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. +""" + + def add_to_agent(self, agent: LLMAgent) -> None: + """Add this capability to an agent.""" + system_message = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE + agent.update_system_message(system_message) + + timeout: int = Field(default=60, ge=1, description="The timeout for code execution.") + work_dir: str = Field(default=".", description="The working directory for the code execution.") + + @validator("work_dir") + def _check_work_dir(cls, v: str) -> str: + if os.path.exists(v): + return v + raise ValueError(f"Working directory {v} does not exist.") + + @property + def user_capability(self) -> "LocalCommandlineCodeExecutor.UserCapability": + """Export a user capability that can be added to an agent.""" + return LocalCommandlineCodeExecutor.UserCapability() + + @property + def code_extractor(self) -> CodeExtractor: + """Export a code extractor that can be used by an agent.""" + return MarkdownCodeExtractor() + + def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CommandlineCodeResult: + """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.""" + logs_all = "" + for i, code_block in enumerate(code_blocks): + lang, code = code_block.language, code_block.code + print( + colored( + f"\n>>>>>>>> EXECUTING CODE BLOCK {i} (inferred language is {lang})...", + "red", + ), + flush=True, + ) + filename_uuid = uuid.uuid4().hex + filename = None + if lang in ["bash", "shell", "sh"]: + filename = f"{filename_uuid}.{lang}" + exitcode, logs, _ = execute_code( + code=code, + lang=lang, + timeout=self.timeout, + work_dir=self.work_dir, + filename=filename, + use_docker=False, + ) + elif lang in ["python", "Python"]: + filename = f"{filename_uuid}.py" + exitcode, logs, _ = execute_code( + code=code, + lang="python", + timeout=self.timeout, + work_dir=self.work_dir, + filename=filename, + use_docker=False, + ) + else: + # In case the language is not supported, we return an error message. + exitcode, logs, _ = (1, f"unknown language {lang}", None) + logs_all += "\n" + logs + if exitcode != 0: + break + code_filename = os.path.join(self.work_dir, filename) if filename is not None else None + return CommandlineCodeResult(exit_code=exitcode, output=logs_all, code_file=code_filename) + + def restart(self) -> None: + """Restart the code executor.""" + warnings.warn("Restarting local command line code executor is not supported. No action is taken.") diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index 0657d0b4714..dc66a76aacc 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -1,45 +1,35 @@ +import os import sys -from typing import Any, Dict +import tempfile import pytest -from autogen.agentchat.agent import Agent from autogen.agentchat.conversable_agent import ConversableAgent -from autogen.code_utils import WIN32, in_docker_container, is_docker_running -from autogen.coding.base import CodeBlock -from autogen.coding.commandline_code_executor import CommandlineCodeExecutor +from autogen.coding.base import CodeBlock, CodeExecutor +from autogen.coding.local_commandline_code_executor import LocalCommandlineCodeExecutor from autogen.oai.openai_utils import config_list_from_json -from conftest import skip_openai # noqa: E402 -try: - from openai import OpenAI -except ImportError: - skip_openai_tests = True -else: - skip_openai_tests = False or skip_openai +from conftest import skip_openai -@pytest.mark.skipif( - sys.platform in ["win32"] or (not is_docker_running()) or (in_docker_container()), - reason="docker is not running", -) -def test_execute_code_docker() -> None: - _test_execute_code({"use_docker": True}) +def test_local_commandline_executor_init() -> None: + executor = LocalCommandlineCodeExecutor(timeout=10, work_dir=".") + assert executor.timeout == 10 and executor.work_dir == "." + # Try invalid working directory. + with pytest.raises(ValueError, match="Working directory .* does not exist."): + executor = LocalCommandlineCodeExecutor(timeout=111, work_dir="/invalid/directory") -@pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") -def test_execute_code_local() -> None: - _test_execute_code({"use_docker": False}) +def test_local_commandline_executor_execute_code() -> None: + with tempfile.TemporaryDirectory() as temp_dir: + executor = LocalCommandlineCodeExecutor(work_dir=temp_dir) + _test_execute_code(executor=executor) -def _test_execute_code(config: Dict[str, Any]) -> None: - executor = CommandlineCodeExecutor(**config) +def _test_execute_code(executor: CodeExecutor) -> None: # 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 - # Check if the docker image is set. - if config["use_docker"] is not False: - assert isinstance(executor.docker_image_name, str) and len(executor.docker_image_name) > 0 + 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 = [ @@ -47,45 +37,69 @@ def _test_execute_code(config: Dict[str, Any]) -> None: 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 + 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. - 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 + if not sys.platform 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 and saving code to a file. - file_lines = ["# filename: test_file_name.py", "import sys", "print('hello world!')", "a = 100 + 100", "print(a)"] + # 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 + 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() + + +@pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") +def test_local_commandline_code_executor_timeout() -> None: + with tempfile.TemporaryDirectory() as temp_dir: + executor = LocalCommandlineCodeExecutor(timeout=1, work_dir=temp_dir) + _test_timeout(executor) - # Test checking and reading saved file. - code_blocks = [ - CodeBlock(code="import os; print(os.path.exists('test_file_name.py'))", language="python"), - CodeBlock(code="with open('test_file_name.py') as f: print(f.readlines())", language="python"), - ] - code_result = executor.execute_code_blocks(code_blocks) - assert code_result.exit_code == 0 and "True" in code_result.output - for line in file_lines: - assert line in code_result.output - # Test timeout. - executor = CommandlineCodeExecutor(**config, timeout=1) +def _test_timeout(executor: CodeExecutor) -> None: 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 or WIN32 + assert code_result.exit_code and "Timeout" in code_result.output -def test_restart() -> None: - executor = CommandlineCodeExecutor(use_docker=True) +def test_local_commandline_code_executor_restart() -> None: + executor = LocalCommandlineCodeExecutor() + _test_restart(executor) + + +def _test_restart(executor: CodeExecutor) -> None: # Check warning. - with pytest.warns(UserWarning, match="Restarting command line code executor is not supported. No action is taken."): + with pytest.warns(UserWarning, match=r".*No action is taken."): executor.restart() -@pytest.mark.skipif(skip_openai_tests, reason="openai not installed OR requested to skip") -def test_conversable_agent_capability() -> None: +@pytest.mark.skipif(skip_openai, reason="requested to skip openai tests") +def test_local_commandline_executor_conversable_agent_capability() -> None: + with tempfile.TemporaryDirectory() as temp_dir: + executor = LocalCommandlineCodeExecutor(work_dir=temp_dir) + _test_conversable_agent_capability(executor=executor) + + +def _test_conversable_agent_capability(executor: CodeExecutor) -> None: KEY_LOC = "notebook" OAI_CONFIG_LIST = "OAI_CONFIG_LIST" config_list = config_list_from_json( @@ -102,8 +116,8 @@ def test_conversable_agent_capability() -> None: agent = ConversableAgent( "coding_agent", llm_config=llm_config, + code_execution_config=False, ) - executor = CommandlineCodeExecutor(use_docker=False) executor.user_capability.add_to_agent(agent) # Test updated system prompt. @@ -112,7 +126,7 @@ def test_conversable_agent_capability() -> None: # Test code generation. reply = agent.generate_reply( [{"role": "user", "content": "write a python script to print 'hello world' to the console"}], - sender=ConversableAgent(name="user", llm_config=False), + sender=ConversableAgent(name="user", llm_config=False, code_execution_config=False), ) # Test code extraction. @@ -124,35 +138,22 @@ def test_conversable_agent_capability() -> None: assert code_result.exit_code == 0 and "hello world" in code_result.output.lower().replace(",", "") -@pytest.mark.skipif(sys.platform in ["win32"], reason="do not run on windows") -def test_conversable_agent_code_execution_no_docker() -> None: - with pytest.MonkeyPatch.context() as mp: - mp.setenv("OPENAI_API_KEY", "mock") - _test_conversable_agent_code_execution({"use_docker": False}) - - -@pytest.mark.skipif( - sys.platform in ["win32"] or (not is_docker_running()) or (in_docker_container()), - reason="docker is not running", -) -def test_conversable_agent_code_execution_docker() -> None: - with pytest.MonkeyPatch.context() as mp: - mp.setenv("OPENAI_API_KEY", "mock") - _test_conversable_agent_code_execution({"use_docker": True}) +def test_local_commandline_executor_conversable_agent_code_execution() -> None: + with tempfile.TemporaryDirectory() as temp_dir: + executor = LocalCommandlineCodeExecutor(work_dir=temp_dir) + with pytest.MonkeyPatch.context() as mp: + mp.setenv("OPENAI_API_KEY", "mock") + _test_conversable_agent_code_execution(executor) -def _test_conversable_agent_code_execution(config: Dict[str, Any]) -> None: +def _test_conversable_agent_code_execution(executor: CodeExecutor) -> None: agent = ConversableAgent( "user_proxy", - code_execution_config={ - "executor": "commandline", - "commandline": config, - }, + code_execution_config={"executor": executor}, llm_config=False, ) - isinstance(agent._code_executor, CommandlineCodeExecutor) - code_executor: CommandlineCodeExecutor = agent._code_executor # type: ignore[assignment] + assert agent.code_executor is executor message = """ Example: @@ -163,15 +164,6 @@ def _test_conversable_agent_code_execution(config: Dict[str, Any]) -> None: reply = agent.generate_reply( [{"role": "user", "content": message}], - sender=ConversableAgent("user"), + sender=ConversableAgent("user", llm_config=False, code_execution_config=False), ) assert "hello extract code" in reply # type: ignore[operator] - if config["use_docker"] is not False: - # Check if the docker image is set. - assert isinstance(code_executor.docker_image_name, str) and len(code_executor.docker_image_name) > 0 - - -def test_conversable_agent_warning_legacy_code_executor() -> None: - # Test warning message. - with pytest.warns(DeprecationWarning, match="legacy code executor"): - ConversableAgent("user_proxy", llm_config=False, code_execution_config=True) # type: ignore[arg-type] diff --git a/test/coding/test_embedded_ipython_code_executor.py b/test/coding/test_embedded_ipython_code_executor.py index 5d8e65c503d..3f2697888b4 100644 --- a/test/coding/test_embedded_ipython_code_executor.py +++ b/test/coding/test_embedded_ipython_code_executor.py @@ -2,19 +2,24 @@ import tempfile import uuid import pytest -from autogen.agentchat.agent import Agent from autogen.agentchat.conversable_agent import ConversableAgent from autogen.coding.base import CodeBlock from autogen.coding.embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor from autogen.oai.openai_utils import config_list_from_json from conftest import skip_openai # noqa: E402 -try: - from openai import OpenAI -except ImportError: - skip_openai_tests = True -else: - skip_openai_tests = False or skip_openai + +def test_init() -> None: + executor = EmbeddedIPythonCodeExecutor(timeout=10, kernel_name="python3", output_dir=".") + assert executor.timeout == 10 and executor.kernel_name == "python3" and executor.output_dir == "." + + # Try invalid output directory. + with pytest.raises(ValueError, match="Output directory .* does not exist."): + executor = EmbeddedIPythonCodeExecutor(timeout=111, kernel_name="python3", output_dir="/invalid/directory") + + # Try invalid kernel name. + with pytest.raises(ValueError, match="Kernel .* is not installed."): + executor = EmbeddedIPythonCodeExecutor(timeout=111, kernel_name="invalid_kernel_name", output_dir=".") def test_execute_code_single_code_block() -> None: @@ -53,18 +58,6 @@ def test_execute_code_bash_script() -> None: assert code_result.exit_code == 0 and "hello world!" in code_result.output -def test_saving_to_file() -> None: - executor = EmbeddedIPythonCodeExecutor() - with tempfile.TemporaryDirectory() as tmpdirname: - code = f""" -with open('{os.path.join(tmpdirname, "test_file_name")}', 'w') as f: - f.write('test saving file') -""" - code_blocks = [CodeBlock(code=code, language="python")] - code_result = executor.execute_code_blocks(code_blocks) - assert code_result.exit_code == 0 and os.path.exists(os.path.join(tmpdirname, "test_file_name")) - - def test_timeout() -> None: executor = EmbeddedIPythonCodeExecutor(timeout=1) code_blocks = [CodeBlock(code="import time; time.sleep(10); print('hello world!')", language="python")] @@ -96,7 +89,38 @@ def test_restart() -> None: assert code_result.exit_code and "NameError" in code_result.output -@pytest.mark.skipif(skip_openai_tests, reason="openai not installed OR requested to skip") +def test_save_image() -> None: + with tempfile.TemporaryDirectory() as temp_dir: + executor = EmbeddedIPythonCodeExecutor(output_dir=temp_dir) + # Install matplotlib. + code_blocks = [CodeBlock(code="!pip install matplotlib", language="python")] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 and code_result.output.strip() == "" + + # Test saving image. + code_blocks = [ + CodeBlock(code="import matplotlib.pyplot as plt\nplt.plot([1, 2, 3, 4])\nplt.show()", language="python") + ] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 + assert os.path.exists(code_result.output_files[0]) + assert f"Image data saved to {code_result.output_files[0]}" in code_result.output + + +def test_save_html() -> None: + with tempfile.TemporaryDirectory() as temp_dir: + executor = EmbeddedIPythonCodeExecutor(output_dir=temp_dir) + # Test saving html. + code_blocks = [ + CodeBlock(code="from IPython.display import HTML\nHTML('

Hello, world!

')", language="python") + ] + code_result = executor.execute_code_blocks(code_blocks) + assert code_result.exit_code == 0 + assert os.path.exists(code_result.output_files[0]) + assert f"HTML data saved to {code_result.output_files[0]}" in code_result.output + + +@pytest.mark.skipif(skip_openai, reason="openai not installed OR requested to skip") def test_conversable_agent_capability() -> None: KEY_LOC = "notebook" OAI_CONFIG_LIST = "OAI_CONFIG_LIST" @@ -114,6 +138,7 @@ def test_conversable_agent_capability() -> None: agent = ConversableAgent( "coding_agent", llm_config=llm_config, + code_execution_config=False, ) executor = EmbeddedIPythonCodeExecutor() executor.user_capability.add_to_agent(agent) @@ -123,8 +148,8 @@ def test_conversable_agent_capability() -> None: # Test code generation. reply = agent.generate_reply( - [{"role": "user", "content": "print 'hello world' to the console"}], - sender=ConversableAgent("user"), + [{"role": "user", "content": "print 'hello world' to the console in a single python code block"}], + sender=ConversableAgent("user", llm_config=False, code_execution_config=False), ) # Test code extraction. @@ -137,7 +162,11 @@ def test_conversable_agent_capability() -> None: def test_conversable_agent_code_execution() -> None: - agent = ConversableAgent("user_proxy", llm_config=False, code_execution_config={"executor": "ipython"}) + agent = ConversableAgent( + "user_proxy", + llm_config=False, + code_execution_config={"executor": "ipython-embedded"}, + ) msg = """ Run this code: ```python @@ -151,5 +180,8 @@ def test_function(a, b): """ with pytest.MonkeyPatch.context() as mp: mp.setenv("OPENAI_API_KEY", "mock") - reply = agent.generate_reply([{"role": "user", "content": msg}], sender=ConversableAgent("user")) + reply = agent.generate_reply( + [{"role": "user", "content": msg}], + sender=ConversableAgent("user", llm_config=False, code_execution_config=False), + ) assert "492" in reply # type: ignore[operator] diff --git a/test/coding/test_factory.py b/test/coding/test_factory.py index 0d6a37a0d5d..3bc01e63499 100644 --- a/test/coding/test_factory.py +++ b/test/coding/test_factory.py @@ -1,7 +1,7 @@ from typing import Dict, Union import pytest from autogen.coding.base import CodeExecutor -from autogen.coding.commandline_code_executor import CommandlineCodeExecutor +from autogen.coding.local_commandline_code_executor import LocalCommandlineCodeExecutor from autogen.coding.factory import CodeExecutorFactory from autogen.coding.embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor @@ -11,17 +11,17 @@ def test_create() -> None: executor = CodeExecutorFactory.create(config) assert isinstance(executor, EmbeddedIPythonCodeExecutor) - config = {"executor": "commandline"} + config = {"executor": "commandline-local"} executor = CodeExecutorFactory.create(config) - assert isinstance(executor, CommandlineCodeExecutor) + assert isinstance(executor, LocalCommandlineCodeExecutor) config = {"executor": EmbeddedIPythonCodeExecutor()} executor = CodeExecutorFactory.create(config) - assert isinstance(executor, EmbeddedIPythonCodeExecutor) + assert executor is config["executor"] - config = {"executor": CommandlineCodeExecutor()} + config = {"executor": LocalCommandlineCodeExecutor()} executor = CodeExecutorFactory.create(config) - assert isinstance(executor, CommandlineCodeExecutor) + assert executor is config["executor"] config = {"executor": "unknown"} with pytest.raises(ValueError, match="Unknown code executor unknown"): From 363708ab93d6d212cf0b04902abe6cc7f7358294 Mon Sep 17 00:00:00 2001 From: ekzhu Date: Thu, 1 Feb 2024 15:14:18 -0800 Subject: [PATCH 27/52] revert notebook --- ...at_auto_feedback_from_code_execution.ipynb | 767 +++++++++--------- 1 file changed, 362 insertions(+), 405 deletions(-) diff --git a/notebook/agentchat_auto_feedback_from_code_execution.ipynb b/notebook/agentchat_auto_feedback_from_code_execution.ipynb index 349eece6a7f..061078afda2 100644 --- a/notebook/agentchat_auto_feedback_from_code_execution.ipynb +++ b/notebook/agentchat_auto_feedback_from_code_execution.ipynb @@ -60,10 +60,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ + "from typing import Dict, Union\n", + "\n", + "from IPython import get_ipython\n", "from IPython.display import Image\n", "\n", "import autogen\n", @@ -122,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -136,89 +139,117 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "First, let's get the current date using Python. \n", + "First, let's find out today's date. Then, we will fetch the stock prices for META (Facebook) and TESLA and calculate the year-to-date gain for both.\n", "\n", + "Step 1: Get today's date\n", "```python\n", - "# python code\n", "from datetime import date\n", - "\n", - "# Get today's date\n", "today = date.today()\n", - "\n", "print(\"Today's date:\", today)\n", "```\n", "\n", - "Next, we need to fetch the stock prices for META (Facebook) and TESLA for the current year. We can use the `yfinance` library in Python to fetch this data. If `yfinance` is not installed, it can be installed using pip: `pip install yfinance`.\n", + "Step 2: Fetch stock prices for META and TESLA\n", + "We will use the `yfinance` library to fetch the stock prices. If you don't have it installed, please install it using the following command:\n", "\n", - "Here is the Python code to fetch the stock prices and calculate the year-to-date gain:\n", + "```sh\n", + "pip install yfinance\n", + "```\n", "\n", + "Step 3: Calculate the year-to-date gain for META and TESLA\n", "```python\n", - "# python code\n", "import yfinance as yf\n", "from datetime import datetime\n", "\n", - "# Get the current year\n", - "current_year = datetime.now().year\n", - "\n", - "# Download stock data from the start of the year to today\n", - "meta_data = yf.download('FB', start=f'{current_year}-01-01', end=today)\n", - "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=today)\n", - "\n", - "# Calculate the year-to-date gain for each stock\n", - "meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", - "tesla_ytd_gain = ((tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]) * 100\n", - "\n", - "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain}%\")\n", - "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain}%\")\n", + "def get_ytd_gain(ticker):\n", + " stock = yf.Ticker(ticker)\n", + " start_date = datetime(today.year, 1, 1)\n", + " end_date = today\n", + " historical_data = stock.history(start=start_date, end=end_date)\n", + " start_price = historical_data.iloc[0]['Close']\n", + " end_price = historical_data.iloc[-1]['Close']\n", + " ytd_gain = (end_price - start_price) / start_price * 100\n", + " return ytd_gain\n", + "\n", + "meta_ytd_gain = get_ytd_gain(\"FB\")\n", + "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n", + "\n", + "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n", + "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n", "```\n", "\n", - "This code will print the year-to-date gain for both META (Facebook) and TESLA. The gain is calculated as the percentage increase in the closing price from the first trading day of the year to the most recent trading day.\n", + "Please execute the code blocks in the order mentioned above.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n", + ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is sh)...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 2 (inferred language is python)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 1 (execution failed)\n", "Code output: \n", - "Today's date: 2024-01-26\n", + "Today's date: 2023-08-29\n", + "\n", + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n", + "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", + "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", + "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", + "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", + "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", + "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", + "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", + "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n", + "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", + "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", + "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", + "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", + "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", "\n", "Traceback (most recent call last):\n", - " File \"\", line 9, in \n", - " meta_data = yf.download('FB', start=f'{current_year}-01-01', end=today)\n", - " ^^^^^\n", + " File \"\", line 14, in \n", + " meta_ytd_gain = get_ytd_gain(\"FB\")\n", + " File \"\", line 6, in get_ytd_gain\n", + " start_date = datetime(today.year, 1, 1)\n", "NameError: name 'today' is not defined\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "I apologize for the oversight. The 'today' variable was defined in the first code block but not in the second one. Let's correct this by defining 'today' in the second code block as well. Here's the corrected code:\n", + "Apologies for the error. It seems I forgot to include the `today` variable in the last code block. Here's the corrected code:\n", "\n", "```python\n", - "# python code\n", "import yfinance as yf\n", "from datetime import datetime, date\n", "\n", - "# Get the current year and today's date\n", - "current_year = datetime.now().year\n", "today = date.today()\n", "\n", - "# Download stock data from the start of the year to today\n", - "meta_data = yf.download('FB', start=f'{current_year}-01-01', end=today)\n", - "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=today)\n", - "\n", - "# Calculate the year-to-date gain for each stock\n", - "meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", - "tesla_ytd_gain = ((tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]) * 100\n", - "\n", - "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain}%\")\n", - "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain}%\")\n", + "def get_ytd_gain(ticker):\n", + " stock = yf.Ticker(ticker)\n", + " start_date = datetime(today.year, 1, 1)\n", + " end_date = today\n", + " historical_data = stock.history(start=start_date, end=end_date)\n", + " start_price = historical_data.iloc[0]['Close']\n", + " end_price = historical_data.iloc[-1]['Close']\n", + " ytd_gain = (end_price - start_price) / start_price * 100\n", + " return ytd_gain\n", + "\n", + "meta_ytd_gain = get_ytd_gain(\"FB\")\n", + "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n", + "\n", + "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n", + "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n", "```\n", "\n", - "This code will print the year-to-date gain for both META (Facebook) and TESLA. The gain is calculated as the percentage increase in the closing price from the first trading day of the year to the most recent trading day.\n", + "Please execute this code block to get the year-to-date gain for META and TESLA.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -227,52 +258,50 @@ "\n", "exitcode: 1 (execution failed)\n", "Code output: \n", - "\n", - "[*********************100%%**********************] 1 of 1 completed\n", - "\n", - "1 Failed download:\n", - "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n", - "\n", - "[*********************100%%**********************] 1 of 1 completed\n", - ":14: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", - " meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", + "FB: No timezone found, symbol may be delisted\n", "Traceback (most recent call last):\n", - " File \"\", line 14, in \n", - " meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", - " ~~~~~~~~~~~~~~~~~~^^^^\n", - " File \"/Users/ekzhu/miniconda3/envs/autogen/lib/python3.11/site-packages/pandas/core/series.py\", line 1037, in __getitem__\n", - " return self._values[key]\n", - " ~~~~~~~~~~~~^^^^^\n", - "IndexError: index -1 is out of bounds for axis 0 with size 0\n", + " File \"\", line 16, in \n", + " meta_ytd_gain = get_ytd_gain(\"FB\")\n", + " File \"\", line 11, in get_ytd_gain\n", + " start_price = historical_data.iloc[0]['Close']\n", + " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 931, in __getitem__\n", + " return self._getitem_axis(maybe_callable, axis=axis)\n", + " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1566, in _getitem_axis\n", + " self._validate_integer(key, axis)\n", + " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1500, in _validate_integer\n", + " raise IndexError(\"single positional indexer is out-of-bounds\")\n", + "IndexError: single positional indexer is out-of-bounds\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "I apologize for the confusion. The ticker symbol for Meta Platforms (formerly Facebook) has changed from 'FB' to 'META'. Let's correct this in the code:\n", + "I apologize for the error. It seems that the \"FB\" ticker symbol is not working as expected. Facebook has changed its parent company name to Meta Platforms, Inc., and its ticker symbol has been changed to \"META\". Let's update the code to use the new ticker symbol:\n", "\n", "```python\n", - "# python code\n", "import yfinance as yf\n", "from datetime import datetime, date\n", "\n", - "# Get the current year and today's date\n", - "current_year = datetime.now().year\n", "today = date.today()\n", "\n", - "# Download stock data from the start of the year to today\n", - "meta_data = yf.download('META', start=f'{current_year}-01-01', end=today)\n", - "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=today)\n", - "\n", - "# Calculate the year-to-date gain for each stock\n", - "meta_ytd_gain = ((meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]) * 100\n", - "tesla_ytd_gain = ((tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]) * 100\n", - "\n", - "print(f\"Year-to-date gain for META (Meta Platforms): {meta_ytd_gain}%\")\n", - "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain}%\")\n", + "def get_ytd_gain(ticker):\n", + " stock = yf.Ticker(ticker)\n", + " start_date = datetime(today.year, 1, 1)\n", + " end_date = today\n", + " historical_data = stock.history(start=start_date, end=end_date)\n", + " start_price = historical_data.iloc[0]['Close']\n", + " end_price = historical_data.iloc[-1]['Close']\n", + " ytd_gain = (end_price - start_price) / start_price * 100\n", + " return ytd_gain\n", + "\n", + "meta_ytd_gain = get_ytd_gain(\"META\")\n", + "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n", + "\n", + "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n", + "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n", "```\n", "\n", - "This code will print the year-to-date gain for both META (Meta Platforms) and TESLA. The gain is calculated as the percentage increase in the closing price from the first trading day of the year to the most recent trading day.\n", + "Please execute this updated code block to get the year-to-date gain for META and TESLA.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -281,18 +310,19 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Year-to-date gain for META (Meta Platforms): 13.540669084819019%\n", - "Year-to-date gain for TESLA: -26.48337242213101%\n", + "Year-to-date gain for META (Facebook): 132.69%\n", + "Year-to-date gain for TESLA: 120.93%\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Great! The code has successfully calculated the year-to-date gain for both META (Meta Platforms) and TESLA. \n", + "Great! The code executed successfully. Here are the year-to-date gains for META (Facebook) and TESLA:\n", "\n", - "As of today's date (January 26, 2024), the year-to-date gain for META (Meta Platforms) is approximately 13.54%, and the year-to-date gain for TESLA is approximately -26.48%. This means that META (Meta Platforms) has increased in value since the start of the year, while TESLA has decreased in value.\n", + "- Year-to-date gain for META (Facebook): 132.69%\n", + "- Year-to-date gain for TESLA: 120.93%\n", "\n", - "Please note that these values are based on the closing prices of the stocks and can vary with the market's performance.\n", + "Please note that these values are based on the stock market data at the time of execution and may change as the market fluctuates.\n", "\n", "TERMINATE\n", "\n", @@ -305,6 +335,7 @@ "assistant = autogen.AssistantAgent(\n", " name=\"assistant\",\n", " llm_config={\n", + " \"cache_seed\": 42, # seed for caching and reproducibility\n", " \"config_list\": config_list, # a list of OpenAI API configurations\n", " \"temperature\": 0, # temperature for sampling\n", " }, # configuration for autogen's enhanced inference API which is compatible with OpenAI API\n", @@ -316,20 +347,15 @@ " max_consecutive_auto_reply=10,\n", " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", " code_execution_config={\n", - " \"executor\": \"commandline\",\n", - " \"commandline\": {\"work_dir\": \"coding\", \"user_docker\": False},\n", - " # Please set use_docker=True if docker is available to run the generated code. Using docker is safer than running the generated code directly.\n", + " \"work_dir\": \"coding\",\n", + " \"use_docker\": False, # Please set use_docker=True if docker is available to run the generated code. Using docker is safer than running the generated code directly.\n", " },\n", ")\n", - "\n", - "# We use a local cache for reproducible results.\n", - "with autogen.Cache.disk() as cache:\n", - " # the assistant receives a message from the user_proxy, which contains the task description\n", - " user_proxy.initiate_chat(\n", - " assistant,\n", - " message=\"\"\"What date is today? Compare the year-to-date gain for META and TESLA.\"\"\",\n", - " cache=cache,\n", - " )" + "# the assistant receives a message from the user_proxy, which contains the task description\n", + "user_proxy.initiate_chat(\n", + " assistant,\n", + " message=\"\"\"What date is today? Compare the year-to-date gain for META and TESLA.\"\"\",\n", + ")" ] }, { @@ -352,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -366,100 +392,87 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Sure, we can use the matplotlib library in Python to plot the stock price changes for META and TESLA. If matplotlib is not installed, it can be installed using pip: `pip install matplotlib`.\n", - "\n", - "Here is the Python code to plot the stock prices and save the plot to a file:\n", + "To plot the chart and save it as an image, we will use the `matplotlib` library. If you don't have it installed, please install it using the following command:\n", "\n", - "```python\n", - "# python code\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Plot the closing prices of META and TESLA\n", - "plt.figure(figsize=(14,7))\n", - "plt.plot(meta_data['Close'], label='META')\n", - "plt.plot(tesla_data['Close'], label='TESLA')\n", - "\n", - "# Add title and labels\n", - "plt.title('Stock Price Change YTD for META and TESLA')\n", - "plt.xlabel('Date')\n", - "plt.ylabel('Price (USD)')\n", - "\n", - "# Add legend\n", - "plt.legend()\n", - "\n", - "# Save the plot to a file\n", - "plt.savefig('stock_price_ytd.png')\n", + "```sh\n", + "pip install matplotlib\n", "```\n", "\n", - "This code will create a line plot of the closing prices for META and TESLA from the start of the year to today's date. The plot will be saved to a file named 'stock_price_ytd.png'.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"\", line 6, in \n", - " plt.plot(meta_data['Close'], label='META')\n", - " ^^^^^^^^^\n", - "NameError: name 'meta_data' is not defined\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "I apologize for the oversight. The 'meta_data' and 'tesla_data' variables were defined in the previous code block but not in this one. Let's correct this by fetching the stock data again in this code block. Here's the corrected code:\n", + "Now, let's plot the chart of the stock price change YTD for META and TESLA and save it to a file named \"stock_price_ytd.png\":\n", "\n", "```python\n", - "# python code\n", + "# filename: plot_stock_price_ytd.py\n", + "\n", "import yfinance as yf\n", "import matplotlib.pyplot as plt\n", "from datetime import datetime, date\n", "\n", - "# Get the current year and today's date\n", - "current_year = datetime.now().year\n", "today = date.today()\n", "\n", - "# Download stock data from the start of the year to today\n", - "meta_data = yf.download('META', start=f'{current_year}-01-01', end=today)\n", - "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=today)\n", + "def get_stock_data(ticker):\n", + " stock = yf.Ticker(ticker)\n", + " start_date = datetime(today.year, 1, 1)\n", + " end_date = today\n", + " historical_data = stock.history(start=start_date, end=end_date)\n", + " return historical_data\n", "\n", - "# Plot the closing prices of META and TESLA\n", - "plt.figure(figsize=(14,7))\n", - "plt.plot(meta_data['Close'], label='META')\n", - "plt.plot(tesla_data['Close'], label='TESLA')\n", + "meta_data = get_stock_data(\"META\")\n", + "tesla_data = get_stock_data(\"TSLA\")\n", "\n", - "# Add title and labels\n", - "plt.title('Stock Price Change YTD for META and TESLA')\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(meta_data.index, meta_data['Close'], label='META (Facebook)')\n", + "plt.plot(tesla_data.index, tesla_data['Close'], label='TESLA')\n", "plt.xlabel('Date')\n", - "plt.ylabel('Price (USD)')\n", - "\n", - "# Add legend\n", + "plt.ylabel('Stock Price')\n", + "plt.title('Stock Price Change YTD for META and TESLA')\n", "plt.legend()\n", - "\n", - "# Save the plot to a file\n", "plt.savefig('stock_price_ytd.png')\n", + "plt.show()\n", "```\n", "\n", - "This code will create a line plot of the closing prices for META and TESLA from the start of the year to today's date. The plot will be saved to a file named 'stock_price_ytd.png'.\n", + "Please save the above code in a file named \"plot_stock_price_ytd.py\" and execute it using the following command:\n", + "\n", + "```sh\n", + "python plot_stock_price_ytd.py\n", + "```\n", + "\n", + "This will create a chart of the stock price change YTD for META and TESLA and save it as \"stock_price_ytd.png\" in the same directory where the script is located.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 2 (inferred language is sh)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: matplotlib in /home/vscode/.local/lib/python3.9/site-packages (3.7.2)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (4.41.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.4.4)\n", + "Requirement already satisfied: cycler>=0.10 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (10.0.0)\n", + "Requirement already satisfied: importlib-resources>=3.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (6.0.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: packaging>=20.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (23.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.1.0)\n", + "Requirement already satisfied: numpy>=1.20 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.25.1)\n", + "Requirement already satisfied: zipp>=3.1.0 in /home/vscode/.local/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib) (3.16.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "\n", + "Figure(1200x600)\n", + "\n", + "Figure(1200x600)\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Great! The code has successfully created a line plot of the closing prices for META (Meta Platforms) and TESLA from the start of the year to today's date. The plot has been saved to a file named 'stock_price_ytd.png'. You can open this file to view the plot.\n", - "\n", - "Please note that the plot shows the changes in the closing prices of the stocks and can help visualize their performance over the year to date.\n", + "Great! The code executed successfully, and the chart of the stock price change YTD for META and TESLA has been saved as \"stock_price_ytd.png\" in the same directory where the script is located. You can now view the chart by opening the \"stock_price_ytd.png\" file.\n", "\n", "TERMINATE\n", "\n", @@ -485,18 +498,19 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] }, + "execution_count": 5, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ @@ -511,332 +525,275 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Use IPython Code Execution Environment\n", + "## Use a Different Code Execution Environment\n", "\n", - "In the previous example, code execution happened in a separate process in a command line environment,\n", - "which is not interactive and tends to waste a lot of LLM tokens on editing code script. \n", + "The code execution happened in a separate process, so the plot is not directly displayed in the notebook. Is it possible to change the code execution environment into IPython?\n", "\n", - "In this example, we switch the execution environment to an IPython kernel which is interactive\n", - "and stateful." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "0.00s - Debugger warning: It seems that frozen modules are being used, which may\n", - "0.00s - make the debugger miss breakpoints. Please pass -Xfrozen_modules=off\n", - "0.00s - to python to disable frozen modules.\n", - "0.00s - Note: Debugging will proceed. Set PYDEVD_DISABLE_FILE_VALIDATION=1 to disable this validation.\n" - ] - } - ], - "source": [ - "user_proxy = autogen.UserProxyAgent(\n", - " name=\"user_proxy\",\n", - " human_input_mode=\"ALWAYS\",\n", - " max_consecutive_auto_reply=10,\n", - " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", - " code_execution_config={\"executor\": \"ipython\"}, # use IPython to execute the generated code\n", - ")" + "Yes! In the following we demonstrate how to extend the `UserProxyAgent` to use a different code execution environment." ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "assistant = autogen.ConversableAgent(\n", - " name=\"assistant\",\n", - " system_message=\"You are a helpful AI assistant.\",\n", - " llm_config={\n", - " \"config_list\": config_list,\n", - " \"temperature\": 0,\n", - " },\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We are using a generic `ConversableAgent` as the `AssistantAgent`'s system\n", - "message is not compatible with IPython kernel.\n", - "To \"teach\" the generic `ConversableAgent` to understand how to use IPython kernel,\n", - "we need to add to it a \"user capability\" exported by the code executor." - ] - }, - { - "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "user_proxy.code_executor.user_capability.add_to_agent(assistant)" + "class IPythonUserProxyAgent(autogen.UserProxyAgent):\n", + " def __init__(self, name: str, **kwargs):\n", + " super().__init__(name, **kwargs)\n", + " self._ipython = get_ipython()\n", + "\n", + " def generate_init_message(self, *args, **kwargs) -> Union[str, Dict]:\n", + " return (\n", + " super().generate_init_message(*args, **kwargs)\n", + " + \"\"\"\n", + "If you suggest code, the code will be executed in IPython.\"\"\"\n", + " )\n", + "\n", + " def run_code(self, code, **kwargs):\n", + " result = self._ipython.run_cell(\"%%capture --no-display cap\\n\" + code)\n", + " log = self._ipython.ev(\"cap.stdout\")\n", + " log += self._ipython.ev(\"cap.stderr\")\n", + " if result.result is not None:\n", + " log += str(result.result)\n", + " exitcode = 0 if result.success else 1\n", + " if result.error_before_exec is not None:\n", + " log += f\"\\n{result.error_before_exec}\"\n", + " exitcode = 1\n", + " if result.error_in_exec is not None:\n", + " log += f\"\\n{result.error_in_exec}\"\n", + " exitcode = 1\n", + " return exitcode, log, None" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Let's start the conversation with cache enabled." + "The implementation overrides three functions in `UserProxyAgent`:\n", + "* constructor. We get the ipython instance as the code execution environment.\n", + "* `generate_init_message`. We generate a modified initial message to send to the assistant agent, by adding the info that the execution will be performed in IPython.\n", + "* `run_code`. We execute the code with the ipython instance.\n", + "\n", + "With the new `IPythonUserProxyAgent`, we are able to run the code within the current notebook environment and display the plot directly." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n", "\n", - "Plot a chart of META and TESLA stock price gain YTD.\n", + "Plot a chart of META and TESLA stock price gain YTD\n", + "If you suggest code, the code will be executed in IPython.\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", "\n", - "Sure, I can help with that. We will use the `yfinance` library to download the stock data. If it's not already installed, you can install it using pip:\n", + "First, we need to install the necessary libraries to fetch stock data and plot the chart. Please execute the following code to install the required libraries:\n", "\n", "```python\n", - "!pip install yfinance\n", + "!pip install yfinance matplotlib\n", "```\n", "\n", - "After installing `yfinance`, we can proceed to download the stock data for META (Facebook) and TESLA. Let's start by importing the necessary libraries and downloading the data.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "After installing the libraries, execute the following code to fetch the stock data and plot the chart:\n", "\n", "```python\n", "import yfinance as yf\n", "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", + "import datetime\n", + "\n", + "# Get the current date\n", + "today = datetime.date.today()\n", + "\n", + "# Calculate the start date for YTD\n", + "start_date = datetime.date(today.year, 1, 1)\n", "\n", - "# Download historical data as dataframe\n", - "meta_data = yf.download('FB', start='2022-01-01', end=pd.to_datetime('today').strftime('%Y-%m-%d'))\n", - "tesla_data = yf.download('TSLA', start='2022-01-01', end=pd.to_datetime('today').strftime('%Y-%m-%d'))\n", + "# Fetch stock data for META (Facebook) and TESLA\n", + "meta = yf.download('FB', start=start_date, end=today)\n", + "tesla = yf.download('TSLA', start=start_date, end=today)\n", "\n", - "meta_data.head(), tesla_data.head()\n", + "# Calculate the percentage gain for each stock\n", + "meta['Gain'] = (meta['Close'] / meta['Close'][0]) * 100\n", + "tesla['Gain'] = (tesla['Close'] / tesla['Close'][0]) * 100\n", + "\n", + "# Plot the chart\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(meta.index, meta['Gain'], label='META (Facebook)')\n", + "plt.plot(tesla.index, tesla['Gain'], label='TESLA')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Percentage Gain YTD')\n", + "plt.title('META (Facebook) vs TESLA Stock Price Gain YTD')\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()\n", "```\n", "\n", + "This code will fetch the stock data for META (Facebook) and TESLA from the start of the year to the current date, calculate the percentage gain, and plot the chart.\n", + "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index 0 is out of bounds for axis 0 with size 0", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[7], line 16\u001b[0m\n\u001b[1;32m 13\u001b[0m tesla \u001b[39m=\u001b[39m yf\u001b[39m.\u001b[39mdownload(\u001b[39m'\u001b[39m\u001b[39mTSLA\u001b[39m\u001b[39m'\u001b[39m, start\u001b[39m=\u001b[39mstart_date, end\u001b[39m=\u001b[39mtoday)\n\u001b[1;32m 15\u001b[0m \u001b[39m# Calculate the percentage gain for each stock\u001b[39;00m\n\u001b[0;32m---> 16\u001b[0m meta[\u001b[39m'\u001b[39m\u001b[39mGain\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m (meta[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m/\u001b[39m meta[\u001b[39m'\u001b[39;49m\u001b[39mClose\u001b[39;49m\u001b[39m'\u001b[39;49m][\u001b[39m0\u001b[39;49m]) \u001b[39m*\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 17\u001b[0m tesla[\u001b[39m'\u001b[39m\u001b[39mGain\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m (tesla[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m/\u001b[39m tesla[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m][\u001b[39m0\u001b[39m]) \u001b[39m*\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 19\u001b[0m \u001b[39m# Plot the chart\u001b[39;00m\n", + "File \u001b[0;32m~/.local/lib/python3.9/site-packages/pandas/core/series.py:939\u001b[0m, in \u001b[0;36mSeries.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 936\u001b[0m key \u001b[39m=\u001b[39m unpack_1tuple(key)\n\u001b[1;32m 938\u001b[0m \u001b[39mif\u001b[39;00m is_integer(key) \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mindex\u001b[39m.\u001b[39m_should_fallback_to_positional():\n\u001b[0;32m--> 939\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_values[key]\n\u001b[1;32m 941\u001b[0m \u001b[39melif\u001b[39;00m key_is_scalar:\n\u001b[1;32m 942\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_value(key)\n", + "\u001b[0;31mIndexError\u001b[0m: index 0 is out of bounds for axis 0 with size 0" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", - "[*********************100%%**********************] 1 of 1 completed\n", - "\n", + "Code output: \n", + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n", + "Requirement already satisfied: matplotlib in /home/vscode/.local/lib/python3.9/site-packages (3.7.2)\n", + "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", + "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", + "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", + "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n", + "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", + "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", + "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", + "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", + "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", + "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.4.4)\n", + "Requirement already satisfied: importlib-resources>=3.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (6.0.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (10.0.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (4.41.1)\n", + "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: packaging>=20.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (23.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.1.0)\n", + "Requirement already satisfied: cycler>=0.10 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n", + "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", + "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", + "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", + "Requirement already satisfied: zipp>=3.1.0 in /home/vscode/.local/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib) (3.16.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "\n", + "[*********************100%***********************] 1 of 1 completed\n", + "[*********************100%***********************] 1 of 1 completed\n", "\n", "1 Failed download:\n", - "\n", "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n", "\n", - "[*********************100%%**********************] 1 of 1 completed\n", - "\n", - "\n", - "(Empty DataFrame\n", - " Columns: [Open, High, Low, Close, Adj Close, Volume]\n", - " Index: [],\n", - " Open High Low Close Adj Close \\\n", - " Date \n", - " 2022-01-03 382.583344 400.356659 378.679993 399.926666 399.926666 \n", - " 2022-01-04 396.516663 402.666656 374.350006 383.196655 383.196655 \n", - " 2022-01-05 382.216675 390.113342 360.336670 362.706665 362.706665 \n", - " 2022-01-06 359.000000 362.666656 340.166656 354.899994 354.899994 \n", - " 2022-01-07 360.123322 360.309998 336.666656 342.320007 342.320007 \n", - " \n", - " Volume \n", - " Date \n", - " 2022-01-03 103931400 \n", - " 2022-01-04 100248300 \n", - " 2022-01-05 80119800 \n", - " 2022-01-06 90336600 \n", - " 2022-01-07 84164700 )\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", "\n", - "It seems like there was an issue with downloading the data for Facebook (now Meta Platforms Inc.). The ticker symbol for Meta Platforms Inc. has changed from 'FB' to 'META'. Let's try downloading the data again using the correct ticker symbol.\n", + "It seems that there was an issue with fetching the stock data for META (Facebook) using the ticker symbol 'FB'. The stock symbol for META has been changed to 'META' recently. Let's update the code to use the new symbol and try again:\n", "\n", "```python\n", - "# Download historical data as dataframe\n", - "meta_data = yf.download('META', start='2022-01-01', end=pd.to_datetime('today').strftime('%Y-%m-%d'))\n", - "\n", - "meta_data.head()\n", - "```\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "import yfinance as yf\n", + "import matplotlib.pyplot as plt\n", + "import datetime\n", "\n", - "exitcode: 0 (execution succeeded)\n", - "[*********************100%%**********************] 1 of 1 completed\n", - "\n", - "\n", - " Open High Low Close Adj Close \\\n", - "Date \n", - "2022-01-03 338.299988 341.079987 337.190002 338.540009 338.540009 \n", - "2022-01-04 339.950012 343.089996 331.869995 336.529999 336.529999 \n", - "2022-01-05 333.019989 335.760010 323.839996 324.170013 324.170013 \n", - "2022-01-06 322.820007 339.170013 322.720001 332.459991 332.459991 \n", - "2022-01-07 332.739990 337.000000 328.880005 331.790009 331.790009 \n", - "\n", - " Volume \n", - "Date \n", - "2022-01-03 14537900 \n", - "2022-01-04 15998000 \n", - "2022-01-05 20564500 \n", - "2022-01-06 27962800 \n", - "2022-01-07 14722000 \n", - "HTML data saved to /Users/ekzhu/autogen/notebook/95e8fc6fa80d4f30884382f11a50c52a.html\n", + "# Get the current date\n", + "today = datetime.date.today()\n", "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "# Calculate the start date for YTD\n", + "start_date = datetime.date(today.year, 1, 1)\n", "\n", - "Great, we have successfully downloaded the data for both META and TESLA. Now, let's calculate the Year-to-Date (YTD) returns for both stocks and plot them.\n", + "# Fetch stock data for META (Facebook) and TESLA\n", + "meta = yf.download('META', start=start_date, end=today)\n", + "tesla = yf.download('TSLA', start=start_date, end=today)\n", "\n", - "The YTD return is calculated as the percentage change in price from the start of the year to the current date.\n", + "# Calculate the percentage gain for each stock\n", + "meta['Gain'] = (meta['Close'] / meta['Close'][0]) * 100\n", + "tesla['Gain'] = (tesla['Close'] / tesla['Close'][0]) * 100\n", "\n", - "```python\n", - "# Calculate YTD returns\n", - "meta_data['YTD'] = meta_data['Adj Close'].pct_change().cumsum()\n", - "tesla_data['YTD'] = tesla_data['Adj Close'].pct_change().cumsum()\n", - "\n", - "# Plot YTD returns\n", - "plt.figure(figsize=(14,7))\n", - "plt.plot(meta_data.index, meta_data['YTD'], label='META')\n", - "plt.plot(tesla_data.index, tesla_data['YTD'], label='TESLA')\n", + "# Plot the chart\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(meta.index, meta['Gain'], label='META (Facebook)')\n", + "plt.plot(tesla.index, tesla['Gain'], label='TESLA')\n", "plt.xlabel('Date')\n", - "plt.ylabel('YTD Return')\n", - "plt.title('YTD Return of META and TESLA')\n", + "plt.ylabel('Percentage Gain YTD')\n", + "plt.title('META (Facebook) vs TESLA Stock Price Gain YTD')\n", "plt.legend()\n", - "plt.grid(True)\n", + "plt.grid()\n", "plt.show()\n", "```\n", "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output:
\n", - "Image data saved to /Users/ekzhu/autogen/notebook/18778f8594ab45df9a35a48a1dd8d0a2.png\n", + "Please execute the updated code to fetch the stock data and plot the chart.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "Here is the Year-to-Date (YTD) return chart for META and TESLA. The chart shows the cumulative percentage change in the adjusted closing price of each stock from the start of the year to the current date.\n", - "\n", - "![YTD Return of META and TESLA](sandbox:/Users/ekzhu/autogen/notebook/18778f8594ab45df9a35a48a1dd8d0a2.png)\n", - "\n", - "--------------------------------------------------------------------------------\n" + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n" ] - } - ], - "source": [ - "with autogen.Cache.disk() as cache:\n", - " # the assistant receives a message from the user, which contains the task description\n", - " user_proxy.initiate_chat(\n", - " assistant,\n", - " message=\"\"\"Plot a chart of META and TESLA stock price gain YTD.\"\"\",\n", - " )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "By using the IPython kernel as the execution environment, the code is generated\n", - "and executed incrementally rather than in a single script. This is more efficient\n", - "and can save a lot of LLM tokens on going back and forth between editing and executing.\n", - "\n", - "Let's display the generated figure." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 6, "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Image(filename=\"./18778f8594ab45df9a35a48a1dd8d0a2.png\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Remember, IPython kernel is stateful. If you want to start over, you need to\n", - "restart the executor." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ + "output_type": "display_data" + }, { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "0.00s - Debugger warning: It seems that frozen modules are being used, which may\n", - "0.00s - make the debugger miss breakpoints. Please pass -Xfrozen_modules=off\n", - "0.00s - to python to disable frozen modules.\n", - "0.00s - Note: Debugging will proceed. Set PYDEVD_DISABLE_FILE_VALIDATION=1 to disable this validation.\n" + "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "[*********************100%***********************] 1 of 1 completed\n", + "[*********************100%***********************] 1 of 1 completed\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", + "\n", + "I'm glad the code executed successfully. You should now see a chart comparing the YTD percentage gain of META (Facebook) and TESLA stocks. If you have any further questions or need assistance with another task, feel free to ask.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" ] } ], "source": [ - "user_proxy.code_executor.restart()" + "ipy_user = IPythonUserProxyAgent(\n", + " \"ipython_user_proxy\",\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=10,\n", + " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\")\n", + " or x.get(\"content\", \"\").rstrip().endswith('\"TERMINATE\".'),\n", + ")\n", + "# the assistant receives a message from the user, which contains the task description\n", + "ipy_user.initiate_chat(\n", + " assistant,\n", + " message=\"\"\"Plot a chart of META and TESLA stock price gain YTD\"\"\",\n", + ")" ] } ], @@ -856,7 +813,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.4" }, "vscode": { "interpreter": { From f8b129d4629ab2334a79e5c37682b71f137393f9 Mon Sep 17 00:00:00 2001 From: ekzhu Date: Thu, 1 Feb 2024 15:27:48 -0800 Subject: [PATCH 28/52] fix format --- .github/workflows/contrib-openai.yml | 19 +++++++++++-------- test/coding/test_commandline_code_executor.py | 2 +- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml index 4019d82e7d7..f173055d7f9 100644 --- a/.github/workflows/contrib-openai.yml +++ b/.github/workflows/contrib-openai.yml @@ -5,13 +5,17 @@ name: OpenAI4ContribTests on: pull_request_target: - branches: ["main"] + branches: ['main'] paths: - - "autogen/**" - - "test/agentchat/contrib/**" - - ".github/workflows/contrib-openai.yml" - - "setup.py" + - 'autogen/**' + - 'test/agentchat/contrib/**' + - '.github/workflows/contrib-openai.yml' + - 'setup.py' permissions: {} + # actions: read + # checks: read + # contents: read + # deployments: read jobs: RetrieveChatTest: strategy: @@ -37,7 +41,6 @@ jobs: pip install -e . python -c "import autogen" pip install coverage pytest-asyncio - python -m ipykernel install --user --name python3 - name: Install packages for test when needed run: | pip install docker @@ -180,8 +183,8 @@ jobs: AgentBuilder: strategy: matrix: - os: [ubuntu-latest] - python-version: ["3.11"] + os: [ ubuntu-latest ] + python-version: [ "3.11" ] runs-on: ${{ matrix.os }} environment: openai1 steps: diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index dc66a76aacc..ba7b0e3b20d 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -45,7 +45,7 @@ def _test_execute_code(executor: CodeExecutor) -> None: ) # Test bash script. - if not sys.platform in ["win32"]: + 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 From 439afb5564f66a1d072c802d8327fd0e6fb2f0ca Mon Sep 17 00:00:00 2001 From: ekzhu Date: Thu, 1 Feb 2024 15:33:31 -0800 Subject: [PATCH 29/52] fix merged error --- autogen/code_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/autogen/code_utils.py b/autogen/code_utils.py index 1b3dff2d677..bcc212e67bb 100644 --- a/autogen/code_utils.py +++ b/autogen/code_utils.py @@ -318,7 +318,7 @@ def execute_code( timeout: Optional[int] = None, filename: Optional[str] = None, work_dir: Optional[str] = None, - use_docker: Union[List[str], str, bool, None] = None, + use_docker: Union[List[str], str, bool] = SENTINEL, lang: Optional[str] = "python", ) -> Tuple[int, str, Optional[str]]: """Execute code in a docker container. @@ -365,7 +365,7 @@ def execute_code( docker_running = is_docker_running() # SENTINEL is used to indicate that the user did not explicitly set the argument - if use_docker is None: + if use_docker is SENTINEL: use_docker = decide_use_docker(use_docker=None) check_can_use_docker_or_throw(use_docker) From d8b3061180b3998bd2ff4efcb731ec430e4291d7 Mon Sep 17 00:00:00 2001 From: ekzhu Date: Thu, 1 Feb 2024 15:55:29 -0800 Subject: [PATCH 30/52] fix lmm test --- test/agentchat/contrib/test_lmm.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/agentchat/contrib/test_lmm.py b/test/agentchat/contrib/test_lmm.py index 41513397160..dbbe7b7786d 100644 --- a/test/agentchat/contrib/test_lmm.py +++ b/test/agentchat/contrib/test_lmm.py @@ -5,6 +5,7 @@ import autogen from autogen.agentchat.agent import Agent +from autogen.agentchat.conversable_agent import ConversableAgent try: from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent @@ -72,7 +73,7 @@ def test_message_to_dict(self): self.assertDictEqual(self.agent._message_to_dict(message_dict), message_dict) def test_print_received_message(self): - sender = Agent(name="SenderAgent") + sender = ConversableAgent(name="SenderAgent", llm_config=False, code_execution_config=False) message_str = "Hello" self.agent._print_received_message = MagicMock() # Mocking print method to avoid actual print self.agent._print_received_message(message_str, sender) From 03e9d59d6d57a828acc8ee990cae9a6c9691a533 Mon Sep 17 00:00:00 2001 From: ekzhu Date: Thu, 1 Feb 2024 15:56:05 -0800 Subject: [PATCH 31/52] fix lmm test --- test/agentchat/contrib/test_lmm.py | 1 - 1 file changed, 1 deletion(-) diff --git a/test/agentchat/contrib/test_lmm.py b/test/agentchat/contrib/test_lmm.py index dbbe7b7786d..866f8a7448e 100644 --- a/test/agentchat/contrib/test_lmm.py +++ b/test/agentchat/contrib/test_lmm.py @@ -4,7 +4,6 @@ import pytest import autogen -from autogen.agentchat.agent import Agent from autogen.agentchat.conversable_agent import ConversableAgent try: From 7d7cb2ab26331bee29a44a4eb6dae992b815d329 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Thu, 1 Feb 2024 22:18:43 -0800 Subject: [PATCH 32/52] move warning --- autogen/agentchat/conversable_agent.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 610bd8aa799..454a6398215 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -142,7 +142,7 @@ def __init__( # Initialize standalone client cache object. self.client_cache = None - + self.human_input_mode = human_input_mode self._max_consecutive_auto_reply = ( max_consecutive_auto_reply if max_consecutive_auto_reply is not None else self.MAX_CONSECUTIVE_AUTO_REPLY @@ -162,16 +162,15 @@ def __init__( self.register_reply([Agent, None], ConversableAgent.a_generate_oai_reply, ignore_async_in_sync_chat=True) # Setting up code execution. - if code_execution_config is None: - warnings.warn( - "Using None to signal a default code_execution_config is deprecated. " - "Use {} to use default or False to disable code execution.", - stacklevel=2, - ) # Do not register code execution reply if code execution is disabled. if code_execution_config is not False: # If code_execution_config is None, set it to an empty dict. if code_execution_config is None: + warnings.warn( + "Using None to signal a default code_execution_config is deprecated. " + "Use {} to use default or False to disable code execution.", + stacklevel=2, + ) code_execution_config = {} if not isinstance(code_execution_config, dict): raise ValueError("code_execution_config must be a dict or False.") From 11bfa9378fa85af7e033689ce498fb110b45b574 Mon Sep 17 00:00:00 2001 From: ekzhu Date: Fri, 2 Feb 2024 11:47:38 -0800 Subject: [PATCH 33/52] name and description should be part of the agent protocol, reset is not as it is only used for ConversableAgent; removing accidentally commited file --- autogen/agentchat/agent.py | 39 +++-- .../docker_commandline_code_executor.py | 149 ------------------ 2 files changed, 28 insertions(+), 160 deletions(-) delete mode 100644 autogen/coding/docker_commandline_code_executor.py diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index 7bd63b7fe0d..c21de4cf265 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -9,28 +9,45 @@ class Agent(Protocol): Different agents can differ in what actions they perform in the `receive` method. """ + @property + def name(self) -> str: + """The name of the agent.""" + ... + + @property + def description(self) -> str: + """The description of the agent. Used for the agent's introduction in + a group chat setting.""" + ... + def send( - self, message: Union[Dict[str, Any], str], recipient: "Agent", request_reply: Optional[bool] = None + self, + message: Union[Dict[str, Any], str], + recipient: "Agent", + request_reply: Optional[bool] = None, ) -> None: - """(Abstract method) Send a message to another agent.""" + """Send a message to another agent.""" + ... async def a_send( - self, message: Union[Dict[str, Any], str], recipient: "Agent", request_reply: Optional[bool] = None + self, + message: Union[Dict[str, Any], str], + recipient: "Agent", + request_reply: Optional[bool] = None, ) -> None: - """(Abstract async method) Send a message to another agent.""" + """(Async) Send a message to another agent.""" + ... def receive( self, message: Union[Dict[str, Any], str], sender: "Agent", request_reply: Optional[bool] = None ) -> None: - """(Abstract method) Receive a message from another agent.""" + """Receive a message from another agent.""" async def a_receive( self, message: Union[Dict[str, Any], str], sender: "Agent", request_reply: Optional[bool] = None ) -> None: - """(Abstract async method) Receive a message from another agent.""" - - def reset(self) -> None: - """(Abstract method) Reset the agent.""" + """(Async) Receive a message from another agent.""" + ... def generate_reply( self, @@ -39,7 +56,7 @@ def generate_reply( exclude: Optional[List[Callable[..., Any]]] = None, **kwargs: Any, ) -> Union[str, Dict[str, Any], None]: - """(Abstract method) Generate a reply based on the received messages. + """Generate a reply based on the received messages. Args: messages (list[dict]): a list of messages received. @@ -55,7 +72,7 @@ async def a_generate_reply( exclude: Optional[List[Callable[..., Any]]] = None, **kwargs: Any, ) -> Union[str, Dict[str, Any], None]: - """(Abstract async method) Generate a reply based on the received messages. + """(Async) Generate a reply based on the received messages. Args: messages (list[dict]): a list of messages received. diff --git a/autogen/coding/docker_commandline_code_executor.py b/autogen/coding/docker_commandline_code_executor.py deleted file mode 100644 index 2c1ca4635d9..00000000000 --- a/autogen/coding/docker_commandline_code_executor.py +++ /dev/null @@ -1,149 +0,0 @@ -import uuid -import warnings -from typing import Any, List, Optional, Union - -from pydantic import BaseModel, Field - -from ..agentchat.agent import LLMAgent -from ..code_utils import DEFAULT_TIMEOUT, WORKING_DIR, execute_code -from .base import CodeBlock, CodeExtractor, CodeResult -from .markdown_code_extractor import MarkdownCodeExtractor - -try: - from termcolor import colored -except ImportError: - - def colored(x: Any, *args: Any, **kwargs: Any) -> str: # type: ignore[misc] - return x # type: ignore[no-any-return] - - -__all__ = ("CommandlineCodeExecutor",) - - -class CommandlineCodeExecutor(BaseModel): - """A code executor class that executes code through a terminal command line - environment. - - By default, this code executor uses a docker container to execute code. - It can be configured to execute code locally without docker - but it's not recommended. - - Each code block is saved as a file and executed in a separate process in - the working directory, and a unique filename is generated for each code - block. The code blocks are executed in the order they are received. - 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. - 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 "extensions" directory under path to `autogen`. - use_docker (bool): Whether to use a docker container for code - execution. If False, the code will be executed in the current - environment. Default is True. - docker_image_name (str): The optional docker image to use for code - execution. `use_docker` must be True for this to take effect. - If not provided, a default image will be created based on - python:3-slim and used for code execution. - """ - - class UserCapability: - """An AgentCapability class that gives agent ability use a command line - code executor.""" - - DEFAULT_SYSTEM_MESSAGE_UPDATE = """ -You have been given coding capability to solve tasks using Python code. -In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. - 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself. - 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. -Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill. -When using code, you must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. -If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. -""" - - def add_to_agent(self, agent: LLMAgent) -> None: - """Add this capability to an agent.""" - system_message = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE - agent.update_system_message(system_message) - - timeout: Optional[int] = Field(default=DEFAULT_TIMEOUT, ge=1) - work_dir: Optional[str] = Field(default=WORKING_DIR) - use_docker: bool = Field(default=True) - docker_image_name: Optional[str] = None - - def _get_use_docker_for_code_utils(self) -> Optional[Union[List[str], str, bool]]: - if self.use_docker is False: - return False - if self.docker_image_name is not None: - # Docker image name is set, use it. - return self.docker_image_name - # Docker image name has not being set, use the default. - return self.use_docker - - @property - def user_capability(self) -> "CommandlineCodeExecutor.UserCapability": - """Export a user capability that can be added to an agent.""" - return CommandlineCodeExecutor.UserCapability() - - @property - def code_extractor(self) -> CodeExtractor: - """Export a code extractor that can be used by an agent.""" - return MarkdownCodeExtractor() - - def execute_code_blocks(self, code_blocks: List[CodeBlock]) -> CodeResult: - """Execute the code blocks and return the result. - - Args: - code_blocks (List[CodeBlock]): The code blocks to execute. - - Returns: - CodeResult: The result of the code execution.""" - logs_all = "" - for i, code_block in enumerate(code_blocks): - lang, code = code_block.language, code_block.code - print( - colored( - f"\n>>>>>>>> EXECUTING CODE BLOCK {i} (inferred language is {lang})...", - "red", - ), - flush=True, - ) - filename_uuid = uuid.uuid4().hex - if lang in ["bash", "shell", "sh"]: - filename = f"{filename_uuid}.{lang}" - exitcode, logs, image = execute_code( - code=code, - lang=lang, - timeout=self.timeout, - work_dir=self.work_dir, - filename=filename, - use_docker=self._get_use_docker_for_code_utils(), - ) - elif lang in ["python", "Python"]: - filename = f"{filename_uuid}.py" - exitcode, logs, image = execute_code( - code=code, - lang="python", - timeout=self.timeout, - work_dir=self.work_dir, - filename=filename, - use_docker=self._get_use_docker_for_code_utils(), - ) - else: - # In case the language is not supported, we return an error message. - exitcode, logs, image = (1, f"unknown language {lang}", None) - # raise NotImplementedError - if image is not None: - # Update the image to use for the next execution. - self.docker_image_name = image - logs_all += "\n" + logs - if exitcode != 0: - break - return CodeResult(exit_code=exitcode, output=logs_all) - - def restart(self) -> None: - """Restart the code executor.""" - warnings.warn("Restarting command line code executor is not supported. No action is taken.") From 09eb58f4aa04bd8c93c04006929b35158e896cfd Mon Sep 17 00:00:00 2001 From: ekzhu Date: Fri, 2 Feb 2024 14:23:45 -0800 Subject: [PATCH 34/52] version for dependency --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index ef85c447171..07a0adf99a6 100644 --- a/setup.py +++ b/setup.py @@ -22,8 +22,8 @@ "tiktoken", "pydantic>=1.10,<3", # could be both V1 and V2 "docker", - "jupyter-client", - "ipykernel", + "jupyter-client>=8.6.0", + "ipykernel>=6.29.0", ] setuptools.setup( From b2bc99df4da81b1e6514e3fe767a57a45b642588 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 2 Feb 2024 23:12:01 -0800 Subject: [PATCH 35/52] Update autogen/agentchat/conversable_agent.py Co-authored-by: Jack Gerrits --- autogen/agentchat/conversable_agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 454a6398215..e655065db99 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -45,7 +45,7 @@ def colored(x, *args, **kwargs): F = TypeVar("F", bound=Callable[..., Any]) -class ConversableAgent: # implements LLAgent protocol +class ConversableAgent(Agent, LLMAgent): """(In preview) A class for generic conversable agents which can be configured as assistant or user proxy. After receiving each message, the agent will send a reply to the sender unless the msg is a termination msg. From 1de5c1e812895bb26700f9a05b94b193f52eec2c Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sat, 3 Feb 2024 00:48:34 -0800 Subject: [PATCH 36/52] ordering of protocol --- autogen/agentchat/agent.py | 10 +++++----- autogen/agentchat/conversable_agent.py | 5 ++--- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index c21de4cf265..447e154d85e 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -3,7 +3,7 @@ @runtime_checkable class Agent(Protocol): - """(In preview) An abstract class for AI agent. + """(In preview) A protocol for Agent. An agent can communicate with other agents and perform actions. Different agents can differ in what actions they perform in the `receive` method. @@ -84,15 +84,15 @@ async def a_generate_reply( @runtime_checkable class LLMAgent(Agent, Protocol): - """(In preview) An abstract class for LLM agent.""" + """(In preview) A protocol for an LLM agent.""" @property def system_message(self) -> str: - """(Abstract method) Return the system message.""" + """The system message of this agent.""" def update_system_message(self, system_message: str) -> None: - """(Abstract method) Update the system message. + """Update this agent's system message. Args: - system_message (str): system message for the ChatCompletion inference. + system_message (str): system message for inference. """ diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index c47e27342d6..b66ff3f9858 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -6,7 +6,7 @@ import logging import re from collections import defaultdict -from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional, Tuple, Type, TypeVar, Union +from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Type, TypeVar, Union import warnings from ..coding.base import CodeExecutor @@ -15,7 +15,6 @@ from .. import OpenAIWrapper, ModelClient from ..cache.cache import Cache from ..code_utils import ( - DEFAULT_MODEL, UNKNOWN, content_str, check_can_use_docker_or_throw, @@ -45,7 +44,7 @@ def colored(x, *args, **kwargs): F = TypeVar("F", bound=Callable[..., Any]) -class ConversableAgent(Agent, LLMAgent): +class ConversableAgent(LLMAgent, Agent): """(In preview) A class for generic conversable agents which can be configured as assistant or user proxy. After receiving each message, the agent will send a reply to the sender unless the msg is a termination msg. From a9f8ca4e5bd83273bf591b969586c3d664dcdfaf Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sat, 3 Feb 2024 01:04:22 -0800 Subject: [PATCH 37/52] description --- autogen/agentchat/conversable_agent.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index b66ff3f9858..d29bcd040a7 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -124,7 +124,7 @@ def __init__( # a dictionary of conversations, default value is list self._oai_messages = defaultdict(list) self._oai_system_message = [{"content": system_message, "role": "system"}] - self.description = description if description is not None else system_message + self._description = description if description is not None else system_message self._is_termination_msg = ( is_termination_msg if is_termination_msg is not None @@ -210,6 +210,11 @@ def name(self) -> str: """Get the name of the agent.""" return self._name + @property + def description(self) -> str: + """Get the description of the agent.""" + return self._description + @property def code_executor(self) -> CodeExecutor: """The code executor used by this agent. Raise if code execution is disabled.""" From 6835d54d2cc483deccdbd9f06c8bdaafd3b96ec4 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sat, 3 Feb 2024 01:21:34 -0800 Subject: [PATCH 38/52] fix tests --- autogen/agentchat/conversable_agent.py | 8 ++++---- test/agentchat/test_tool_calls.py | 20 ++++++++++++++++++-- 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index d29bcd040a7..323fb967fbc 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -189,6 +189,9 @@ def __init__( check_can_use_docker_or_throw(use_docker) self._code_execution_config["use_docker"] = use_docker self.register_reply([Agent, None], ConversableAgent.generate_code_execution_reply) + else: + # Code execution is disabled. + self._code_execution_config = False self.register_reply([Agent, None], ConversableAgent.generate_tool_calls_reply) self.register_reply([Agent, None], ConversableAgent.a_generate_tool_calls_reply, ignore_async_in_sync_chat=True) @@ -937,10 +940,7 @@ def generate_code_execution_reply( sender: Optional[Agent] = None, config: Optional[Union[Dict, Literal[False]]] = None, ): - """(Deprecated) Generate a reply using code execution. - - NOTE: this function uses the legacy code utils and will be removed in the future. - """ + """Generate a reply using code execution.""" code_execution_config = config if config is not None else self._code_execution_config if code_execution_config is False: return False, None diff --git a/test/agentchat/test_tool_calls.py b/test/agentchat/test_tool_calls.py index da4061e0be3..b3448ba138e 100644 --- a/test/agentchat/test_tool_calls.py +++ b/test/agentchat/test_tool_calls.py @@ -188,9 +188,17 @@ def test_update_tool(): def test_multi_tool_call(): class FakeAgent(autogen.Agent): def __init__(self, name): - self.name = name + self._name = name self.received = [] + @property + def name(self): + return self._name + + @property + def description(self): + return self._name + def receive( self, message, @@ -275,9 +283,17 @@ def receive( async def test_async_multi_tool_call(): class FakeAgent(autogen.Agent): def __init__(self, name): - self.name = name + self._name = name self.received = [] + @property + def name(self): + return self._name + + @property + def description(self): + return self._name + async def a_receive( self, message, From b3e5747b488824741a01b4b30fc4b837d1b580be Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sun, 4 Feb 2024 16:28:21 -0800 Subject: [PATCH 39/52] make ipython executor dependency optional --- setup.py | 3 +- test/coding/test_commandline_code_executor.py | 12 ++++++- .../test_embedded_ipython_code_executor.py | 36 +++++++++++++++++-- test/coding/test_factory.py | 26 ++------------ 4 files changed, 49 insertions(+), 28 deletions(-) diff --git a/setup.py b/setup.py index 07a0adf99a6..dec9829ae67 100644 --- a/setup.py +++ b/setup.py @@ -22,8 +22,6 @@ "tiktoken", "pydantic>=1.10,<3", # could be both V1 and V2 "docker", - "jupyter-client>=8.6.0", - "ipykernel>=6.29.0", ] setuptools.setup( @@ -56,6 +54,7 @@ "graphs": ["networkx~=3.2.1", "matplotlib~=3.8.1"], "websurfer": ["beautifulsoup4", "markdownify", "pdfminer.six", "pathvalidate"], "redis": ["redis"], + "ipython": ["jupyter-client>=8.6.0", "ipykernel>=6.29.0"], }, classifiers=[ "Programming Language :: Python :: 3", diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index ba7b0e3b20d..0ce9e07e91b 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -1,15 +1,25 @@ -import os import sys import tempfile import pytest from autogen.agentchat.conversable_agent import ConversableAgent from autogen.coding.base import CodeBlock, CodeExecutor +from autogen.coding.factory import CodeExecutorFactory from autogen.coding.local_commandline_code_executor import LocalCommandlineCodeExecutor from autogen.oai.openai_utils import config_list_from_json from conftest import skip_openai +def test_create() -> None: + config = {"executor": "commandline-local"} + executor = CodeExecutorFactory.create(config) + assert isinstance(executor, LocalCommandlineCodeExecutor) + + config = {"executor": LocalCommandlineCodeExecutor()} + executor = CodeExecutorFactory.create(config) + assert executor is config["executor"] + + def test_local_commandline_executor_init() -> None: executor = LocalCommandlineCodeExecutor(timeout=10, work_dir=".") assert executor.timeout == 10 and executor.work_dir == "." diff --git a/test/coding/test_embedded_ipython_code_executor.py b/test/coding/test_embedded_ipython_code_executor.py index 3f2697888b4..555b6c5c798 100644 --- a/test/coding/test_embedded_ipython_code_executor.py +++ b/test/coding/test_embedded_ipython_code_executor.py @@ -1,14 +1,36 @@ import os import tempfile +from typing import Dict, Union import uuid import pytest from autogen.agentchat.conversable_agent import ConversableAgent -from autogen.coding.base import CodeBlock -from autogen.coding.embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor +from autogen.coding.base import CodeBlock, CodeExecutor +from autogen.coding.factory import CodeExecutorFactory from autogen.oai.openai_utils import config_list_from_json from conftest import skip_openai # noqa: E402 +try: + from autogen.coding.embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor + skip = False + skip_reason = "" +except ImportError: + skip = True + skip_reason = "Dependencies for EmbeddedIPythonCodeExecutor not installed." + + +@pytest.mark.skipif(skip, reason=skip_reason) +def test_create() -> None: + config: Dict[str, Union[str, CodeExecutor]] = {"executor": "ipython-embedded"} + executor = CodeExecutorFactory.create(config) + assert isinstance(executor, EmbeddedIPythonCodeExecutor) + + config = {"executor": EmbeddedIPythonCodeExecutor()} + executor = CodeExecutorFactory.create(config) + assert executor is config["executor"] + + +@pytest.mark.skipif(skip, reason=skip_reason) def test_init() -> None: executor = EmbeddedIPythonCodeExecutor(timeout=10, kernel_name="python3", output_dir=".") assert executor.timeout == 10 and executor.kernel_name == "python3" and executor.output_dir == "." @@ -22,6 +44,7 @@ def test_init() -> None: executor = EmbeddedIPythonCodeExecutor(timeout=111, kernel_name="invalid_kernel_name", output_dir=".") +@pytest.mark.skipif(skip, reason=skip_reason) def test_execute_code_single_code_block() -> None: executor = EmbeddedIPythonCodeExecutor() code_blocks = [CodeBlock(code="import sys\nprint('hello world!')", language="python")] @@ -29,6 +52,7 @@ def test_execute_code_single_code_block() -> None: assert code_result.exit_code == 0 and "hello world!" in code_result.output +@pytest.mark.skipif(skip, reason=skip_reason) def test_execute_code_multiple_code_blocks() -> None: executor = EmbeddedIPythonCodeExecutor() code_blocks = [ @@ -50,6 +74,7 @@ def test_function(a, b): assert code_result.exit_code == 0 and "854" in code_result.output +@pytest.mark.skipif(skip, reason=skip_reason) def test_execute_code_bash_script() -> None: executor = EmbeddedIPythonCodeExecutor() # Test bash script. @@ -58,6 +83,7 @@ def test_execute_code_bash_script() -> None: assert code_result.exit_code == 0 and "hello world!" in code_result.output +@pytest.mark.skipif(skip, reason=skip_reason) def test_timeout() -> None: executor = EmbeddedIPythonCodeExecutor(timeout=1) code_blocks = [CodeBlock(code="import time; time.sleep(10); print('hello world!')", language="python")] @@ -65,6 +91,7 @@ def test_timeout() -> None: assert code_result.exit_code and "Timeout" in code_result.output +@pytest.mark.skipif(skip, reason=skip_reason) def test_silent_pip_install() -> None: executor = EmbeddedIPythonCodeExecutor() code_blocks = [CodeBlock(code="!pip install matplotlib numpy", language="python")] @@ -77,6 +104,7 @@ def test_silent_pip_install() -> None: assert code_result.exit_code == 0 and "ERROR: " in code_result.output +@pytest.mark.skipif(skip, reason=skip_reason) def test_restart() -> None: executor = EmbeddedIPythonCodeExecutor() code_blocks = [CodeBlock(code="x = 123", language="python")] @@ -89,6 +117,7 @@ def test_restart() -> None: assert code_result.exit_code and "NameError" in code_result.output +@pytest.mark.skipif(skip, reason=skip_reason) def test_save_image() -> None: with tempfile.TemporaryDirectory() as temp_dir: executor = EmbeddedIPythonCodeExecutor(output_dir=temp_dir) @@ -107,6 +136,7 @@ def test_save_image() -> None: assert f"Image data saved to {code_result.output_files[0]}" in code_result.output +@pytest.mark.skipif(skip, reason=skip_reason) def test_save_html() -> None: with tempfile.TemporaryDirectory() as temp_dir: executor = EmbeddedIPythonCodeExecutor(output_dir=temp_dir) @@ -120,6 +150,7 @@ def test_save_html() -> None: assert f"HTML data saved to {code_result.output_files[0]}" in code_result.output +@pytest.mark.skipif(skip, reason=skip_reason) @pytest.mark.skipif(skip_openai, reason="openai not installed OR requested to skip") def test_conversable_agent_capability() -> None: KEY_LOC = "notebook" @@ -161,6 +192,7 @@ def test_conversable_agent_capability() -> None: assert code_result.exit_code == 0 and "hello world" in code_result.output.lower() +@pytest.mark.skipif(skip, reason=skip_reason) def test_conversable_agent_code_execution() -> None: agent = ConversableAgent( "user_proxy", diff --git a/test/coding/test_factory.py b/test/coding/test_factory.py index 3bc01e63499..a4f40ec9162 100644 --- a/test/coding/test_factory.py +++ b/test/coding/test_factory.py @@ -1,32 +1,12 @@ -from typing import Dict, Union import pytest -from autogen.coding.base import CodeExecutor -from autogen.coding.local_commandline_code_executor import LocalCommandlineCodeExecutor from autogen.coding.factory import CodeExecutorFactory -from autogen.coding.embedded_ipython_code_executor import EmbeddedIPythonCodeExecutor -def test_create() -> None: - config: Dict[str, Union[str, CodeExecutor]] = {"executor": "ipython-embedded"} - executor = CodeExecutorFactory.create(config) - assert isinstance(executor, EmbeddedIPythonCodeExecutor) - - config = {"executor": "commandline-local"} - executor = CodeExecutorFactory.create(config) - assert isinstance(executor, LocalCommandlineCodeExecutor) - - config = {"executor": EmbeddedIPythonCodeExecutor()} - executor = CodeExecutorFactory.create(config) - assert executor is config["executor"] - - config = {"executor": LocalCommandlineCodeExecutor()} - executor = CodeExecutorFactory.create(config) - assert executor is config["executor"] - +def test_create_unknown() -> None: config = {"executor": "unknown"} with pytest.raises(ValueError, match="Unknown code executor unknown"): - executor = CodeExecutorFactory.create(config) + CodeExecutorFactory.create(config) config = {} with pytest.raises(ValueError, match="Unknown code executor None"): - executor = CodeExecutorFactory.create(config) + CodeExecutorFactory.create(config) From 371eb2845acc6b94923ada68a425e770a93457f2 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sun, 4 Feb 2024 16:38:22 -0800 Subject: [PATCH 40/52] update document optional dependencies --- .../installation/Optional-Dependencies.md | 23 +++++++------------ 1 file changed, 8 insertions(+), 15 deletions(-) diff --git a/website/docs/installation/Optional-Dependencies.md b/website/docs/installation/Optional-Dependencies.md index 33e85933253..5186079cd13 100644 --- a/website/docs/installation/Optional-Dependencies.md +++ b/website/docs/installation/Optional-Dependencies.md @@ -11,28 +11,21 @@ pip install "pyautogen[redis]" See [LLM Caching](Use-Cases/agent_chat.md#llm-caching) for details. -## Docker +## IPython Code Executor -Even if you install AutoGen locally, we highly recommend using Docker for [code execution](FAQ.md#enable-python-3-docker-image). - -To use docker for code execution, you also need to install the python package `docker`: +To use the IPython code executor, you need to install the `jupyter-client` +and `ipykernel` packages: ```bash -pip install docker +pip install "pyautogen[ipython]" ``` -You might want to override the default docker image used for code execution. To do that set `use_docker` key of `code_execution_config` property to the name of the image. E.g.: +To use the IPython code executor: ```python -user_proxy = autogen.UserProxyAgent( - name="agent", - human_input_mode="TERMINATE", - max_consecutive_auto_reply=10, - code_execution_config={"work_dir":"_output", "use_docker":"python:3"}, - llm_config=llm_config, - system_message=""""Reply TERMINATE if the task has been solved at full satisfaction. -Otherwise, reply CONTINUE, or the reason why the task is not solved yet.""" -) +from autogen import UserProxyAgent + +proxy = UserProxyAgent(name="proxy", code_execution_config={"executor": "ipython-embedded"}) ``` ## blendsearch From 34cc504a408048c7a5b0923bceb61ce046f2ca90 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Tue, 6 Feb 2024 03:03:59 -0800 Subject: [PATCH 41/52] Remove exclude from Agent protocol --- autogen/agentchat/agent.py | 1 - 1 file changed, 1 deletion(-) diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index 447e154d85e..8030a2e0e9d 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -53,7 +53,6 @@ def generate_reply( self, messages: Optional[List[Dict[str, Any]]] = None, sender: Optional["Agent"] = None, - exclude: Optional[List[Callable[..., Any]]] = None, **kwargs: Any, ) -> Union[str, Dict[str, Any], None]: """Generate a reply based on the received messages. From ac41ba131e9b53591d2a0f11c5b8c8d87cb31ed4 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Tue, 6 Feb 2024 03:07:52 -0800 Subject: [PATCH 42/52] Make ConversableAgent consistent with Agent --- autogen/agentchat/conversable_agent.py | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 75a40bda8a1..a00b05bc5df 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -1364,7 +1364,6 @@ def generate_reply( self, messages: Optional[List[Dict[str, Any]]] = None, sender: Optional["Agent"] = None, - exclude: Optional[List[Callable[..., Any]]] = None, **kwargs: Any, ) -> Union[str, Dict, None]: """Reply based on the conversation history and the sender. @@ -1386,9 +1385,7 @@ def generate_reply( Args: messages: a list of messages in the conversation history. - default_reply (str or dict): default reply. sender: sender of an Agent instance. - exclude: a list of functions to exclude. Returns: str or dict or None: reply. None if no reply is generated. @@ -1407,7 +1404,7 @@ def generate_reply( for reply_func_tuple in self._reply_func_list: reply_func = reply_func_tuple["reply_func"] - if exclude and reply_func in exclude: + if "exclude" in kwargs and reply_func in kwargs["exclude"]: continue if inspect.iscoroutinefunction(reply_func): continue @@ -1421,7 +1418,6 @@ async def a_generate_reply( self, messages: Optional[List[Dict[str, Any]]] = None, sender: Optional["Agent"] = None, - exclude: Optional[List[Callable[..., Any]]] = None, **kwargs: Any, ) -> Union[str, Dict[str, Any], None]: """(async) Reply based on the conversation history and the sender. @@ -1443,9 +1439,7 @@ async def a_generate_reply( Args: messages: a list of messages in the conversation history. - default_reply (str or dict): default reply. sender: sender of an Agent instance. - exclude: a list of functions to exclude. Returns: str or dict or None: reply. None if no reply is generated. @@ -1464,7 +1458,7 @@ async def a_generate_reply( for reply_func_tuple in self._reply_func_list: reply_func = reply_func_tuple["reply_func"] - if exclude and reply_func in exclude: + if "exclude" in kwargs and reply_func in kwargs["exclude"]: continue if self._match_trigger(reply_func_tuple["trigger"], sender): if inspect.iscoroutinefunction(reply_func): From fc684c1088c77e8434a0cbd15fe04e2f1ec4b785 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Tue, 6 Feb 2024 03:23:45 -0800 Subject: [PATCH 43/52] fix tests --- test/agentchat/test_groupchat.py | 4 ++-- test/test_graph_utils.py | 40 ++++++++++++++++++++------------ 2 files changed, 27 insertions(+), 17 deletions(-) diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index 7744916af27..f8b291f2573 100644 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -489,7 +489,7 @@ def test_selection_helpers(): def test_init_default_parameters(): - agents = [Agent(name=f"Agent{i}") for i in range(3)] + agents = [autogen.ConversableAgent(name=f"Agent{i}", llm_config=False) for i in range(3)] group_chat = GroupChat(agents=agents, messages=[], max_round=3) for agent in agents: assert set([a.name for a in group_chat.allowed_speaker_transitions_dict[agent]]) == set( @@ -498,7 +498,7 @@ def test_init_default_parameters(): def test_graph_parameters(): - agents = [Agent(name=f"Agent{i}") for i in range(3)] + agents = [autogen.ConversableAgent(name=f"Agent{i}", llm_config=False) for i in range(3)] with pytest.raises(ValueError): GroupChat( agents=agents, diff --git a/test/test_graph_utils.py b/test/test_graph_utils.py index 8518d0da6f1..8e2b039bd24 100644 --- a/test/test_graph_utils.py +++ b/test/test_graph_utils.py @@ -1,13 +1,23 @@ +from typing import Any import pytest import logging from autogen.agentchat import Agent import autogen.graph_utils as gru +class TestAgent(Agent): + def __init__(self, name) -> None: + self._name = name + + @property + def name(self) -> str: + return self._name + + class TestHelpers: def test_has_self_loops(self): # Setup test data - agents = [Agent(name=f"Agent{i}") for i in range(3)] + agents = [TestAgent(name=f"Agent{i}") for i in range(3)] allowed_speaker_transitions = { agents[0]: [agents[1], agents[2]], agents[1]: [agents[2]], @@ -26,19 +36,19 @@ def test_has_self_loops(self): class TestGraphUtilCheckGraphValidity: def test_valid_structure(self): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] valid_speaker_transitions_dict = {agent: [other_agent for other_agent in agents] for agent in agents} gru.check_graph_validity(allowed_speaker_transitions_dict=valid_speaker_transitions_dict, agents=agents) def test_graph_with_invalid_structure(self): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] - unseen_agent = Agent("unseen_agent") + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + unseen_agent = TestAgent("unseen_agent") invalid_speaker_transitions_dict = {unseen_agent: ["stranger"]} with pytest.raises(ValueError): gru.check_graph_validity(invalid_speaker_transitions_dict, agents) def test_graph_with_invalid_string(self): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] invalid_speaker_transitions_dict = { agent: ["agent1"] for agent in agents } # 'agent1' is a string, not an Agent. Therefore raises an error. @@ -46,13 +56,13 @@ def test_graph_with_invalid_string(self): gru.check_graph_validity(invalid_speaker_transitions_dict, agents) def test_graph_with_invalid_key(self): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] with pytest.raises(ValueError): gru.check_graph_validity({1: 1}, agents) # Test for Warning 1: Isolated agent nodes def test_isolated_agent_nodes_warning(self, caplog): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] # Create a speaker_transitions_dict where at least one agent is isolated speaker_transitions_dict_with_isolation = {agents[0]: [agents[0], agents[1]], agents[1]: [agents[0]]} # Add an isolated agent @@ -66,14 +76,14 @@ def test_isolated_agent_nodes_warning(self, caplog): # Test for Warning 2: Warning if the set of agents in allowed_speaker_transitions do not match agents def test_warning_for_mismatch_in_agents(self, caplog): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] # Test with missing agents in allowed_speaker_transitions_dict unknown_agent_dict = { agents[0]: [agents[0], agents[1], agents[2]], agents[1]: [agents[0], agents[1], agents[2]], - agents[2]: [agents[0], agents[1], agents[2], Agent("unknown_agent")], + agents[2]: [agents[0], agents[1], agents[2], TestAgent("unknown_agent")], } with caplog.at_level(logging.WARNING): @@ -83,7 +93,7 @@ def test_warning_for_mismatch_in_agents(self, caplog): # Test for Warning 3: Warning if there is duplicated agents in allowed_speaker_transitions_dict def test_warning_for_duplicate_agents(self, caplog): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] # Construct an `allowed_speaker_transitions_dict` with duplicated agents duplicate_agents_dict = { @@ -100,7 +110,7 @@ def test_warning_for_duplicate_agents(self, caplog): class TestGraphUtilInvertDisallowedToAllowed: def test_basic_functionality(self): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] disallowed_graph = {agents[0]: [agents[1]], agents[1]: [agents[0], agents[2]], agents[2]: []} expected_allowed_graph = { agents[0]: [agents[0], agents[2]], @@ -113,7 +123,7 @@ def test_basic_functionality(self): assert inverted == expected_allowed_graph def test_empty_disallowed_graph(self): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] disallowed_graph = {} expected_allowed_graph = { agents[0]: [agents[0], agents[1], agents[2]], @@ -126,7 +136,7 @@ def test_empty_disallowed_graph(self): assert inverted == expected_allowed_graph def test_fully_disallowed_graph(self): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] disallowed_graph = { agents[0]: [agents[0], agents[1], agents[2]], @@ -140,9 +150,9 @@ def test_fully_disallowed_graph(self): assert inverted == expected_allowed_graph def test_disallowed_graph_with_nonexistent_agent(self): - agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")] + agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] - disallowed_graph = {agents[0]: [Agent("nonexistent_agent")]} + disallowed_graph = {agents[0]: [TestAgent("nonexistent_agent")]} # In this case, the function should ignore the nonexistent agent and proceed with the inversion expected_allowed_graph = { agents[0]: [agents[0], agents[1], agents[2]], From 8eb6603929c82aa3746b95c44ce4dd2f70c98c4f Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Tue, 6 Feb 2024 03:34:54 -0800 Subject: [PATCH 44/52] add doc string --- autogen/agentchat/conversable_agent.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index a00b05bc5df..a7159530009 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -1387,6 +1387,9 @@ def generate_reply( messages: a list of messages in the conversation history. sender: sender of an Agent instance. + Additional keyword arguments: + exclude (List[Callable]): a list of reply functions to be excluded from the search. + Returns: str or dict or None: reply. None if no reply is generated. """ @@ -1441,6 +1444,9 @@ async def a_generate_reply( messages: a list of messages in the conversation history. sender: sender of an Agent instance. + Additional keyword arguments: + exclude (List[Callable]): a list of reply functions to be excluded from the search. + Returns: str or dict or None: reply. None if no reply is generated. """ From 7b65133fad781024f25f8de09633bf5f60c9e464 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Tue, 6 Feb 2024 03:37:00 -0800 Subject: [PATCH 45/52] add doc string --- autogen/agentchat/conversable_agent.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index a7159530009..73578317ee1 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -1388,7 +1388,7 @@ def generate_reply( sender: sender of an Agent instance. Additional keyword arguments: - exclude (List[Callable]): a list of reply functions to be excluded from the search. + exclude (List[Callable]): a list of reply functions to be excluded. Returns: str or dict or None: reply. None if no reply is generated. @@ -1445,7 +1445,7 @@ async def a_generate_reply( sender: sender of an Agent instance. Additional keyword arguments: - exclude (List[Callable]): a list of reply functions to be excluded from the search. + exclude (List[Callable]): a list of reply functions to be excluded. Returns: str or dict or None: reply. None if no reply is generated. From 95b4f7ffca38f7ff358cca3085336e70fd4636c6 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Tue, 6 Feb 2024 04:18:51 -0800 Subject: [PATCH 46/52] fix notebook --- autogen/coding/base.py | 2 +- ...ph_modelling_language_using_select_speaker.ipynb | 13 +++++++------ 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/autogen/coding/base.py b/autogen/coding/base.py index 5cb4d4e630b..13e84da8cf5 100644 --- a/autogen/coding/base.py +++ b/autogen/coding/base.py @@ -57,7 +57,7 @@ def user_capability(self) -> "CodeExecutor.UserCapability": ```python code_executor = CodeExecutor() - agent = Agent() + agent = ConversableAgent("agent", ...) code_executor.user_capability.add_to_agent(agent) ``` diff --git a/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb b/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb index fa1e2fedf42..a6d3603e104 100644 --- a/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb +++ b/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb @@ -54,8 +54,9 @@ "import networkx as nx # noqa E402\n", "\n", "import autogen # noqa E402\n", + "from autogen.agentchat.conversable_agent import ConversableAgent # noqa E402\n", "from autogen.agentchat.assistant_agent import AssistantAgent # noqa E402\n", - "from autogen.agentchat.groupchat import GroupChat, Agent # noqa E402\n", + "from autogen.agentchat.groupchat import GroupChat # noqa E402\n", "from autogen.graph_utils import visualize_speaker_transitions_dict # noqa E402" ] }, @@ -119,7 +120,7 @@ } ], "source": [ - "agents = [Agent(name=f\"Agent{i}\") for i in range(5)]\n", + "agents = [ConversableAgent(name=f\"Agent{i}\", llm_config=False) for i in range(5)]\n", "allowed_speaker_transitions_dict = {agent: [other_agent for other_agent in agents] for agent in agents}\n", "\n", "visualize_speaker_transitions_dict(allowed_speaker_transitions_dict, agents)" @@ -152,7 +153,7 @@ } ], "source": [ - "agents = [Agent(name=f\"Agent{i}\") for i in range(5)]\n", + "agents = [ConversableAgent(name=f\"Agent{i}\", llm_config=False) for i in range(5)]\n", "allowed_speaker_transitions_dict = {\n", " agents[0]: [agents[1], agents[2], agents[3], agents[4]],\n", " agents[1]: [agents[0]],\n", @@ -196,14 +197,14 @@ "team_size = 5\n", "\n", "\n", - "def get_agent_of_name(agents, name) -> Agent:\n", + "def get_agent_of_name(agents, name) -> ConversableAgent:\n", " for agent in agents:\n", " if agent.name == name:\n", " return agent\n", "\n", "\n", "# Create a list of 15 agents 3 teams x 5 agents\n", - "agents = [Agent(name=f\"{team}{i}\") for team in teams for i in range(team_size)]\n", + "agents = [ConversableAgent(name=f\"{team}{i}\", llm_config=False) for team in teams for i in range(team_size)]\n", "\n", "# Loop through each team and add members and their connections\n", "for team in teams:\n", @@ -239,7 +240,7 @@ } ], "source": [ - "agents = [Agent(name=f\"Agent{i}\") for i in range(2)]\n", + "agents = [ConversableAgent(name=f\"Agent{i}\", llm_config=False) for i in range(2)]\n", "allowed_speaker_transitions_dict = {\n", " agents[0]: [agents[0], agents[1]],\n", " agents[1]: [agents[0], agents[1]],\n", From fa748e09d990417c07b10e5261973da8889cf09c Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Thu, 8 Feb 2024 11:36:12 -0800 Subject: [PATCH 47/52] fix interface --- autogen/agentchat/agent.py | 1 - autogen/agentchat/conversable_agent.py | 2 +- pyproject.toml | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index 8030a2e0e9d..990f45f7144 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -68,7 +68,6 @@ async def a_generate_reply( self, messages: Optional[List[Dict[str, Any]]] = None, sender: Optional["Agent"] = None, - exclude: Optional[List[Callable[..., Any]]] = None, **kwargs: Any, ) -> Union[str, Dict[str, Any], None]: """(Async) Generate a reply based on the received messages. diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 9e2f4e3f926..ebf68a03c3a 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -47,7 +47,7 @@ def colored(x, *args, **kwargs): F = TypeVar("F", bound=Callable[..., Any]) -class ConversableAgent(LLMAgent, Agent): +class ConversableAgent(LLMAgent): """(In preview) A class for generic conversable agents which can be configured as assistant or user proxy. After receiving each message, the agent will send a reply to the sender unless the msg is a termination msg. diff --git a/pyproject.toml b/pyproject.toml index bb6a2d2703a..f1763fba37e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -77,4 +77,4 @@ warn_unused_ignores = true disallow_incomplete_defs = true disallow_untyped_decorators = true -disallow_any_unimported = true \ No newline at end of file +disallow_any_unimported = true From 547a48119892dcc7e7e686437a769039746ce23c Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 9 Feb 2024 09:47:49 -0800 Subject: [PATCH 48/52] merge and update agents --- autogen/agentchat/agent.py | 58 ++++++++++++++++++++++++++++++++------ 1 file changed, 49 insertions(+), 9 deletions(-) diff --git a/autogen/agentchat/agent.py b/autogen/agentchat/agent.py index 990f45f7144..410635bce6e 100644 --- a/autogen/agentchat/agent.py +++ b/autogen/agentchat/agent.py @@ -1,4 +1,4 @@ -from typing import Any, Callable, Dict, List, Optional, Protocol, Union, runtime_checkable +from typing import Any, Dict, List, Optional, Protocol, Union, runtime_checkable @runtime_checkable @@ -26,7 +26,14 @@ def send( recipient: "Agent", request_reply: Optional[bool] = None, ) -> None: - """Send a message to another agent.""" + """Send a message to another agent. + + Args: + message (dict or str): the message to send. If a dict, it should be + a JSON-serializable and follows the OpenAI's ChatCompletion schema. + recipient (Agent): the recipient of the message. + request_reply (bool): whether to request a reply from the recipient. + """ ... async def a_send( @@ -35,18 +42,45 @@ async def a_send( recipient: "Agent", request_reply: Optional[bool] = None, ) -> None: - """(Async) Send a message to another agent.""" + """(Async) Send a message to another agent. + + Args: + message (dict or str): the message to send. If a dict, it should be + a JSON-serializable and follows the OpenAI's ChatCompletion schema. + recipient (Agent): the recipient of the message. + request_reply (bool): whether to request a reply from the recipient. + """ ... def receive( - self, message: Union[Dict[str, Any], str], sender: "Agent", request_reply: Optional[bool] = None + self, + message: Union[Dict[str, Any], str], + sender: "Agent", + request_reply: Optional[bool] = None, ) -> None: - """Receive a message from another agent.""" + """Receive a message from another agent. + + Args: + message (dict or str): the message received. If a dict, it should be + a JSON-serializable and follows the OpenAI's ChatCompletion schema. + sender (Agent): the sender of the message. + request_reply (bool): whether the sender requests a reply. + """ async def a_receive( - self, message: Union[Dict[str, Any], str], sender: "Agent", request_reply: Optional[bool] = None + self, + message: Union[Dict[str, Any], str], + sender: "Agent", + request_reply: Optional[bool] = None, ) -> None: - """(Async) Receive a message from another agent.""" + """(Async) Receive a message from another agent. + + Args: + message (dict or str): the message received. If a dict, it should be + a JSON-serializable and follows the OpenAI's ChatCompletion schema. + sender (Agent): the sender of the message. + request_reply (bool): whether the sender requests a reply. + """ ... def generate_reply( @@ -58,8 +92,11 @@ def generate_reply( """Generate a reply based on the received messages. Args: - messages (list[dict]): a list of messages received. + messages (list[dict]): a list of messages received from other agents. + The messages are dictionaries that are JSON-serializable and + follows the OpenAI's ChatCompletion schema. sender: sender of an Agent instance. + Returns: str or dict or None: the generated reply. If None, no reply is generated. """ @@ -73,8 +110,11 @@ async def a_generate_reply( """(Async) Generate a reply based on the received messages. Args: - messages (list[dict]): a list of messages received. + messages (list[dict]): a list of messages received from other agents. + The messages are dictionaries that are JSON-serializable and + follows the OpenAI's ChatCompletion schema. sender: sender of an Agent instance. + Returns: str or dict or None: the generated reply. If None, no reply is generated. """ From cc601ccbe15bf423b8afc7083601793ac95c444d Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 9 Feb 2024 12:12:34 -0800 Subject: [PATCH 49/52] disable config usage in reply function --- autogen/agentchat/conversable_agent.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index feeb80cbee3..12911407af3 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -1106,12 +1106,13 @@ def _generate_code_execution_reply_using_executor( config: Optional[Union[Dict, Literal[False]]] = None, ): """Generate a reply using code executor.""" - code_execution_config = config if config is not None else self._code_execution_config - if code_execution_config is False: + if config is not None: + raise ValueError("config is not supported for _generate_code_execution_reply_using_executor.") + if self._code_execution_config is False: return False, None if messages is None: messages = self._oai_messages[sender] - last_n_messages = code_execution_config.get("last_n_messages", "auto") + last_n_messages = self._code_execution_config.get("last_n_messages", "auto") if not (isinstance(last_n_messages, (int, float)) and last_n_messages >= 0) and last_n_messages != "auto": raise ValueError("last_n_messages must be either a non-negative integer, or the string 'auto'.") From 313b12f0af1f805357259189f2c016cbec6bf580 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 9 Feb 2024 12:17:33 -0800 Subject: [PATCH 50/52] description field setter --- autogen/agentchat/conversable_agent.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index 12911407af3..fbba53e5e8d 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -223,6 +223,11 @@ def description(self) -> str: """Get the description of the agent.""" return self._description + @description.setter + def description(self, description: str): + """Set the description of the agent.""" + self._description = description + @property def code_executor(self) -> CodeExecutor: """The code executor used by this agent. Raise if code execution is disabled.""" From 088ce19691b9902683f2b7b5edf0271b94d4d8e8 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 9 Feb 2024 12:55:05 -0800 Subject: [PATCH 51/52] customize system message update --- .../coding/embedded_ipython_code_executor.py | 55 +++++++++++++------ .../coding/local_commandline_code_executor.py | 40 +++++++++----- test/coding/test_commandline_code_executor.py | 2 +- .../test_embedded_ipython_code_executor.py | 2 +- test/test_graph_utils.py | 32 +++++------ 5 files changed, 83 insertions(+), 48 deletions(-) diff --git a/autogen/coding/embedded_ipython_code_executor.py b/autogen/coding/embedded_ipython_code_executor.py index f8b4d0f78f2..3232c12e311 100644 --- a/autogen/coding/embedded_ipython_code_executor.py +++ b/autogen/coding/embedded_ipython_code_executor.py @@ -4,11 +4,11 @@ import re import uuid from queue import Empty -from typing import Any, List +from typing import Any, ClassVar, List from jupyter_client import KernelManager # type: ignore[attr-defined] from jupyter_client.kernelspec import KernelSpecManager -from pydantic import BaseModel, Field, validator +from pydantic import BaseModel, Field, field_validator from ..agentchat.agent import LLMAgent from .base import CodeBlock, CodeExtractor, CodeResult @@ -43,13 +43,15 @@ class EmbeddedIPythonCodeExecutor(BaseModel): kernel_name (str): The kernel name to use. Make sure it is installed. By default, it is "python3". output_dir (str): The directory to save output files, by default ".". + system_message_update (str): The system message update to add to the + agent that produces code. By default it is + `EmbeddedIPythonCodeExecutor.DEFAULT_SYSTEM_MESSAGE_UPDATE`. """ - class UserCapability: - """An AgentCapability class that gives agent ability use a stateful - code executor.""" - - DEFAULT_SYSTEM_MESSAGE_UPDATE = """# IPython Coding Capability + DEFAULT_SYSTEM_MESSAGE_UPDATE: ClassVar[ + str + ] = """ +# IPython Coding Capability You have been given coding capability to solve tasks using Python code in a stateful IPython kernel. You are responsible for writing the code, and the user is responsible for executing the code. @@ -74,17 +76,37 @@ class UserCapability: the output will be a path to the image instead of the image itself. """ - def add_to_agent(self, agent: LLMAgent) -> None: - """Add this capability to an agent.""" - # system message is a string or a list of strings - system_message = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE - agent.update_system_message(system_message) - timeout: int = Field(default=60, ge=1, description="The timeout for code execution.") kernel_name: str = Field(default="python3", description="The kernel name to use. Make sure it is installed.") output_dir: str = Field(default=".", description="The directory to save output files.") + system_message_update: str = Field( + default=DEFAULT_SYSTEM_MESSAGE_UPDATE, + description="The system message update to the agent that produces code to be executed by this executor.", + ) + + class UserCapability: + """An AgentCapability class that gives agent ability use a stateful + IPython code executor. This capability can be added to an agent using + the `add_to_agent` method which append a system message update to the + agent's system message.""" + + def __init__(self, system_message_update: str): + self.system_message_update = system_message_update + + def add_to_agent(self, agent: LLMAgent) -> None: + """Add this capability to an agent by appending a system message + update to the agent's system message. + + **Currently we do not check for conflicts with existing content in + the agent's system message.** + + Args: + agent (LLMAgent): The agent to add the capability to. + """ + agent.update_system_message(agent.system_message + self.system_message_update) - @validator("output_dir") + @field_validator("output_dir") + @classmethod def _output_dir_must_exist(cls, value: str) -> str: if not os.path.exists(value): raise ValueError(f"Output directory {value} does not exist.") @@ -107,8 +129,9 @@ def __init__(self, **kwargs: Any): @property def user_capability(self) -> "EmbeddedIPythonCodeExecutor.UserCapability": - """Export a user capability that can be added to an agent.""" - return EmbeddedIPythonCodeExecutor.UserCapability() + """Export a user capability for this executor that can be added to + an agent using the `add_to_agent` method.""" + return EmbeddedIPythonCodeExecutor.UserCapability(self.system_message_update) @property def code_extractor(self) -> CodeExtractor: diff --git a/autogen/coding/local_commandline_code_executor.py b/autogen/coding/local_commandline_code_executor.py index 440c2548813..c5ab226e1e9 100644 --- a/autogen/coding/local_commandline_code_executor.py +++ b/autogen/coding/local_commandline_code_executor.py @@ -1,9 +1,9 @@ import os import uuid import warnings -from typing import Any, List, Optional +from typing import Any, ClassVar, List, Optional -from pydantic import BaseModel, Field, validator +from pydantic import BaseModel, Field, field_validator from ..agentchat.agent import LLMAgent from ..code_utils import execute_code @@ -53,13 +53,14 @@ class LocalCommandlineCodeExecutor(BaseModel): 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 ".". + system_message_update (str): The system message update for agent that + produces code to run on this executor. + Default is `LocalCommandlineCodeExecutor.DEFAULT_SYSTEM_MESSAGE_UPDATE`. """ - class UserCapability: - """An AgentCapability class that gives agent ability use a command line - code executor.""" - - DEFAULT_SYSTEM_MESSAGE_UPDATE = """ + DEFAULT_SYSTEM_MESSAGE_UPDATE: ClassVar[ + str + ] = """ You have been given coding capability to solve tasks using Python code. In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself. @@ -69,15 +70,26 @@ class UserCapability: If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. """ - def add_to_agent(self, agent: LLMAgent) -> None: - """Add this capability to an agent.""" - system_message = agent.system_message + self.DEFAULT_SYSTEM_MESSAGE_UPDATE - agent.update_system_message(system_message) - timeout: int = Field(default=60, ge=1, description="The timeout for code execution.") work_dir: str = Field(default=".", description="The working directory for the code execution.") + system_message_update: str = Field( + default=DEFAULT_SYSTEM_MESSAGE_UPDATE, + description="The system message update for agent that produces code to run on this executor.", + ) + + class UserCapability: + """An AgentCapability class that gives agent ability use a command line + code executor.""" + + def __init__(self, system_message_update: str) -> None: + self.system_message_update = system_message_update + + def add_to_agent(self, agent: LLMAgent) -> None: + """Add this capability to an agent.""" + agent.update_system_message(agent.system_message + self.system_message_update) - @validator("work_dir") + @field_validator("work_dir") + @classmethod def _check_work_dir(cls, v: str) -> str: if os.path.exists(v): return v @@ -86,7 +98,7 @@ def _check_work_dir(cls, v: str) -> str: @property def user_capability(self) -> "LocalCommandlineCodeExecutor.UserCapability": """Export a user capability that can be added to an agent.""" - return LocalCommandlineCodeExecutor.UserCapability() + return LocalCommandlineCodeExecutor.UserCapability(self.system_message_update) @property def code_extractor(self) -> CodeExtractor: diff --git a/test/coding/test_commandline_code_executor.py b/test/coding/test_commandline_code_executor.py index 0ce9e07e91b..1ee5e6be337 100644 --- a/test/coding/test_commandline_code_executor.py +++ b/test/coding/test_commandline_code_executor.py @@ -131,7 +131,7 @@ def _test_conversable_agent_capability(executor: CodeExecutor) -> None: executor.user_capability.add_to_agent(agent) # Test updated system prompt. - assert executor.user_capability.DEFAULT_SYSTEM_MESSAGE_UPDATE in agent.system_message + assert executor.DEFAULT_SYSTEM_MESSAGE_UPDATE in agent.system_message # Test code generation. reply = agent.generate_reply( diff --git a/test/coding/test_embedded_ipython_code_executor.py b/test/coding/test_embedded_ipython_code_executor.py index 555b6c5c798..d1669096000 100644 --- a/test/coding/test_embedded_ipython_code_executor.py +++ b/test/coding/test_embedded_ipython_code_executor.py @@ -175,7 +175,7 @@ def test_conversable_agent_capability() -> None: executor.user_capability.add_to_agent(agent) # Test updated system prompt. - assert executor.user_capability.DEFAULT_SYSTEM_MESSAGE_UPDATE in agent.system_message + assert executor.DEFAULT_SYSTEM_MESSAGE_UPDATE in agent.system_message # Test code generation. reply = agent.generate_reply( diff --git a/test/test_graph_utils.py b/test/test_graph_utils.py index 8e2b039bd24..5bdcab3c6e5 100644 --- a/test/test_graph_utils.py +++ b/test/test_graph_utils.py @@ -5,7 +5,7 @@ import autogen.graph_utils as gru -class TestAgent(Agent): +class FakeAgent(Agent): def __init__(self, name) -> None: self._name = name @@ -17,7 +17,7 @@ def name(self) -> str: class TestHelpers: def test_has_self_loops(self): # Setup test data - agents = [TestAgent(name=f"Agent{i}") for i in range(3)] + agents = [FakeAgent(name=f"Agent{i}") for i in range(3)] allowed_speaker_transitions = { agents[0]: [agents[1], agents[2]], agents[1]: [agents[2]], @@ -36,19 +36,19 @@ def test_has_self_loops(self): class TestGraphUtilCheckGraphValidity: def test_valid_structure(self): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] valid_speaker_transitions_dict = {agent: [other_agent for other_agent in agents] for agent in agents} gru.check_graph_validity(allowed_speaker_transitions_dict=valid_speaker_transitions_dict, agents=agents) def test_graph_with_invalid_structure(self): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] - unseen_agent = TestAgent("unseen_agent") + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] + unseen_agent = FakeAgent("unseen_agent") invalid_speaker_transitions_dict = {unseen_agent: ["stranger"]} with pytest.raises(ValueError): gru.check_graph_validity(invalid_speaker_transitions_dict, agents) def test_graph_with_invalid_string(self): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] invalid_speaker_transitions_dict = { agent: ["agent1"] for agent in agents } # 'agent1' is a string, not an Agent. Therefore raises an error. @@ -56,13 +56,13 @@ def test_graph_with_invalid_string(self): gru.check_graph_validity(invalid_speaker_transitions_dict, agents) def test_graph_with_invalid_key(self): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] with pytest.raises(ValueError): gru.check_graph_validity({1: 1}, agents) # Test for Warning 1: Isolated agent nodes def test_isolated_agent_nodes_warning(self, caplog): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] # Create a speaker_transitions_dict where at least one agent is isolated speaker_transitions_dict_with_isolation = {agents[0]: [agents[0], agents[1]], agents[1]: [agents[0]]} # Add an isolated agent @@ -76,14 +76,14 @@ def test_isolated_agent_nodes_warning(self, caplog): # Test for Warning 2: Warning if the set of agents in allowed_speaker_transitions do not match agents def test_warning_for_mismatch_in_agents(self, caplog): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] # Test with missing agents in allowed_speaker_transitions_dict unknown_agent_dict = { agents[0]: [agents[0], agents[1], agents[2]], agents[1]: [agents[0], agents[1], agents[2]], - agents[2]: [agents[0], agents[1], agents[2], TestAgent("unknown_agent")], + agents[2]: [agents[0], agents[1], agents[2], FakeAgent("unknown_agent")], } with caplog.at_level(logging.WARNING): @@ -93,7 +93,7 @@ def test_warning_for_mismatch_in_agents(self, caplog): # Test for Warning 3: Warning if there is duplicated agents in allowed_speaker_transitions_dict def test_warning_for_duplicate_agents(self, caplog): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] # Construct an `allowed_speaker_transitions_dict` with duplicated agents duplicate_agents_dict = { @@ -110,7 +110,7 @@ def test_warning_for_duplicate_agents(self, caplog): class TestGraphUtilInvertDisallowedToAllowed: def test_basic_functionality(self): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] disallowed_graph = {agents[0]: [agents[1]], agents[1]: [agents[0], agents[2]], agents[2]: []} expected_allowed_graph = { agents[0]: [agents[0], agents[2]], @@ -123,7 +123,7 @@ def test_basic_functionality(self): assert inverted == expected_allowed_graph def test_empty_disallowed_graph(self): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] disallowed_graph = {} expected_allowed_graph = { agents[0]: [agents[0], agents[1], agents[2]], @@ -136,7 +136,7 @@ def test_empty_disallowed_graph(self): assert inverted == expected_allowed_graph def test_fully_disallowed_graph(self): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] disallowed_graph = { agents[0]: [agents[0], agents[1], agents[2]], @@ -150,9 +150,9 @@ def test_fully_disallowed_graph(self): assert inverted == expected_allowed_graph def test_disallowed_graph_with_nonexistent_agent(self): - agents = [TestAgent("agent1"), TestAgent("agent2"), TestAgent("agent3")] + agents = [FakeAgent("agent1"), FakeAgent("agent2"), FakeAgent("agent3")] - disallowed_graph = {agents[0]: [TestAgent("nonexistent_agent")]} + disallowed_graph = {agents[0]: [FakeAgent("nonexistent_agent")]} # In this case, the function should ignore the nonexistent agent and proceed with the inversion expected_allowed_graph = { agents[0]: [agents[0], agents[1], agents[2]], From 2c4ae6fb3137ab45e51496269fb3b719fb5b9aa7 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Fri, 9 Feb 2024 13:00:41 -0800 Subject: [PATCH 52/52] update doc --- autogen/coding/local_commandline_code_executor.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/autogen/coding/local_commandline_code_executor.py b/autogen/coding/local_commandline_code_executor.py index c5ab226e1e9..252c5737677 100644 --- a/autogen/coding/local_commandline_code_executor.py +++ b/autogen/coding/local_commandline_code_executor.py @@ -79,13 +79,15 @@ class LocalCommandlineCodeExecutor(BaseModel): class UserCapability: """An AgentCapability class that gives agent ability use a command line - code executor.""" + code executor via a system message update. This capability can be added + to an agent using the `add_to_agent` method.""" def __init__(self, system_message_update: str) -> None: self.system_message_update = system_message_update def add_to_agent(self, agent: LLMAgent) -> None: - """Add this capability to an agent.""" + """Add this capability to an agent by updating the agent's system + message.""" agent.update_system_message(agent.system_message + self.system_message_update) @field_validator("work_dir") @@ -97,7 +99,8 @@ def _check_work_dir(cls, v: str) -> str: @property def user_capability(self) -> "LocalCommandlineCodeExecutor.UserCapability": - """Export a user capability that can be added to an agent.""" + """Export a user capability for this executor that can be added to + an agent that produces code to be executed by this executor.""" return LocalCommandlineCodeExecutor.UserCapability(self.system_message_update) @property