diff --git "a/agentchat_auto_feedback_from_code_execution.ipynb" "b/agentchat_auto_feedback_from_code_execution.ipynb" new file mode 100644--- /dev/null +++ "b/agentchat_auto_feedback_from_code_execution.ipynb" @@ -0,0 +1,1189 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Auto Generated Agent Chat: Task Solving with Code Generation, Execution & Debugging\n", + "\n", + "AutoGen offers conversable LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code.\n", + "Please find documentation about this feature [here](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat).\n", + "\n", + "In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to write code and execute the code. Here `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for the human user to execute the code written by `AssistantAgent`, or automatically execute the code. Depending on the setting of `human_input_mode` and `max_consecutive_auto_reply`, the `UserProxyAgent` either solicits feedback from the human user or returns auto-feedback based on the result of code execution (success or failure and corresponding outputs) to `AssistantAgent`. `AssistantAgent` will debug the code and suggest new code if the result contains error. The two agents keep communicating to each other until the task is done.\n", + "\n", + "## Requirements\n", + "\n", + "AutoGen requires `Python>=3.8`. To run this notebook example, please install:\n", + "```bash\n", + "pip install pyautogen\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2023-02-13T23:40:52.317406Z", + "iopub.status.busy": "2023-02-13T23:40:52.316561Z", + "iopub.status.idle": "2023-02-13T23:40:52.321193Z", + "shell.execute_reply": "2023-02-13T23:40:52.320628Z" + } + }, + "outputs": [], + "source": [ + "# %pip install pyautogen~=0.1.0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set your API Endpoint\n", + "\n", + "The [`config_list_from_json`](https://microsoft.github.io/autogen/docs/reference/oai/openai_utils#config_list_from_json) function loads a list of configurations from an environment variable or a json file.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import autogen\n", + "\n", + "config_list = autogen.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", + " },\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It first looks for environment variable \"OAI_CONFIG_LIST\" which needs to be a valid json string. If that variable is not found, it then looks for a json file named \"OAI_CONFIG_LIST\". It filters the configs by models (you can filter by other keys as well). Only the gpt-4 models are kept in the list based on the filter condition.\n", + "\n", + "The config list looks like the following:\n", + "```python\n", + "config_list = [\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " },\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " 'api_base': '',\n", + " 'api_type': 'azure',\n", + " 'api_version': '2023-06-01-preview',\n", + " },\n", + " {\n", + " 'model': 'gpt-4-32k',\n", + " 'api_key': '',\n", + " 'api_base': '',\n", + " 'api_type': 'azure',\n", + " 'api_version': '2023-06-01-preview',\n", + " },\n", + "]\n", + "```\n", + "\n", + "If you open this notebook in colab, you can upload your files by clicking the file icon on the left panel and then choose \"upload file\" icon.\n", + "\n", + "You can set the value of config_list in other ways you prefer, e.g., loading from a YAML file." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Task: Check Stock Price Change\n", + "\n", + "In the example below, let's see how to use the agents in AutoGen to write a python script and execute the script. This process involves constructing a `AssistantAgent` to serve as the assistant, along with a `UserProxyAgent` that acts as a proxy for the human user. In this example demonstrated below, when constructing the `UserProxyAgent`, we select the `human_input_mode` to \"NEVER\". This means that the `UserProxyAgent` will not solicit feedback from the human user. It stops replying when the limit defined by `max_consecutive_auto_reply` is reached, or when `is_termination_msg()` returns true for the received message." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "What date is today? Compare the year-to-date gain for META and TESLA.\n", + "\n", + "--------------------------------------------------------------------------------\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", + "\n", + "Step 1: Get today's date\n", + "```python\n", + "from datetime import date\n", + "today = date.today()\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", + "\n", + "```sh\n", + "pip install yfinance\n", + "```\n", + "\n", + "Step 3: Calculate the year-to-date gain for META and TESLA\n", + "```python\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", + "```\n", + "\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 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: 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 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", + "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", + "import yfinance as yf\n", + "from datetime import datetime, date\n", + "\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", + "```\n", + "\n", + "Please execute this code block to get the year-to-date gain for META and TESLA.\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", + "FB: No timezone found, symbol may be delisted\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", + "\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", + "\n", + "```python\n", + "import yfinance as yf\n", + "from datetime import datetime, date\n", + "\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", + "```\n", + "\n", + "Please execute this updated code block to get the year-to-date gain for META and TESLA.\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: 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", + "\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", + "\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 stock market data at the time of execution and may change as the market fluctuates.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# create an AssistantAgent named \"assistant\"\n", + "assistant = autogen.AssistantAgent(\n", + " name=\"assistant\",\n", + " llm_config={\n", + " \"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", + ")\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "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={\n", + " \"work_dir\": \"coding\",\n", + " \"use_docker\": False, # set to True or image name like \"python:3\" to use docker\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", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The example above involves code execution. In AutoGen, code execution is triggered automatically by the `UserProxyAgent` when it detects an executable code block in a received message and no human user input is provided. This process occurs in a designated working directory, using a Docker container by default. Unless a specific directory is specified, AutoGen defaults to the `autogen/extensions` directory. Users have the option to specify a different working directory by setting the `work_dir` argument when constructing a new instance of the `UserProxyAgent`.\n", + "\n", + "The whole chat is auto generated." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Task: Plot Chart" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "Plot a chart of their stock price change YTD and save to stock_price_ytd.png.\n", + "\n", + "--------------------------------------------------------------------------------\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", + "\n", + "```sh\n", + "pip install matplotlib\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", + "\n", + "```python\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", + "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", + "\n", + "meta_data = get_stock_data(\"META\")\n", + "tesla_data = get_stock_data(\"TSLA\")\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", + "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", + "\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 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 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", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# followup of the previous question\n", + "user_proxy.send(\n", + " recipient=assistant,\n", + " message=\"\"\"Plot a chart of their stock price change YTD and save to stock_price_ytd.png.\"\"\",\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's display the generated figure." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "\n", + "Image(filename='coding/stock_price_ytd.png')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "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", + "\n", + "Yes! In the following we demonstrate how to extend the `UserProxyAgent` to use a different code execution environment." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict, Union\n", + "from IPython import get_ipython\n", + "\n", + "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 super().generate_init_message(*args, **kwargs) + \"\"\"\n", + "If you suggest code, the code will be executed in IPython.\"\"\"\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": [ + "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 plot directly." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mipython_user_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", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to ipython_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", + "\n", + "```python\n", + "!pip install yfinance matplotlib\n", + "```\n", + "\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 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", + "# 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", + "# 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", + ">>>>>>>> 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", + "\n", + "1 Failed download:\n", + "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\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", + "\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", + "# 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", + "# 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", + "Please execute the updated code to fetch the stock data and plot the chart.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\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" + ] + } + ], + "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\") 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", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + }, + "vscode": { + "interpreter": { + "hash": "949777d72b0d2535278d3dc13498b2535136f6dfe0678499012e853ee9abcab1" + } + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "2d910cfd2d2a4fc49fc30fbbdc5576a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "454146d0f7224f038689031002906e6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4ae2b6f5a974fd4bafb6abb9d12ff26", + "IPY_MODEL_577e1e3cc4db4942b0883577b3b52755", + "IPY_MODEL_b40bdfb1ac1d4cffb7cefcb870c64d45" + ], + "layout": "IPY_MODEL_dc83c7bff2f241309537a8119dfc7555", + "tabbable": null, + "tooltip": null + } + }, + "577e1e3cc4db4942b0883577b3b52755": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2d910cfd2d2a4fc49fc30fbbdc5576a7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_74a6ba0c3cbc4051be0a83e152fe1e62", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "6086462a12d54bafa59d3c4566f06cb2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74a6ba0c3cbc4051be0a83e152fe1e62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7d3f3d9e15894d05a4d188ff4f466554": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b40bdfb1ac1d4cffb7cefcb870c64d45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f1355871cc6f4dd4b50d9df5af20e5c8", + "placeholder": "​", + "style": "IPY_MODEL_ca245376fd9f4354af6b2befe4af4466", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 44.69it/s]" + } + }, + "ca245376fd9f4354af6b2befe4af4466": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dc83c7bff2f241309537a8119dfc7555": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4ae2b6f5a974fd4bafb6abb9d12ff26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6086462a12d54bafa59d3c4566f06cb2", + "placeholder": "​", + "style": "IPY_MODEL_7d3f3d9e15894d05a4d188ff4f466554", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "f1355871cc6f4dd4b50d9df5af20e5c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}