hwDev001-WeatherQueryBy function_call.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b5c5dc6e-0a61-46a1-b04f-03f23c9161b2",
   "metadata": {},
   "source": [
    "## Homework 1\n",
    "\n",
    "**使用第三方天气查询API，实现完整可执行的天气查询应用**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdd6c408-1dbc-4a5d-bb13-65f38553da4d",
   "metadata": {},
   "source": [
    "首先，定义3个函数`get_city_adcode`、`get_amap_weather`和`execute_function_call`\n",
    "- get_city_adcode:用于获取城市及地区编码\n",
    "- get_amap_weather：用于通过第三方天气查询api实现当日天气查询，并返回查询结果\n",
    "- execute_function_call: 用于根据消息中的功能调用信息来执行相应的功能并获取结果\n",
    "\n",
    "然后，创建一个消息列表，并向其中添加了一个系统消息和一个用户消息。系统消息的内容是指示对话的目标，用户消息的内容是用户的问题。\n",
    "\n",
    "接着，使用`chat_completion_request`函数发出聊天请求并获取响应，然后从响应中提取出助手的消息并添加到消息列表中。\n",
    "\n",
    "如果助手的消息中包含功能调用，那么就使用`execute_function_call`函数执行这个功能调用并获取结果，然后将结果作为一个功能消息添加到消息列表中。\n",
    "\n",
    "最后，使用`pretty_print_conversation`函数打印出整个对话。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "09bb96df-00a5-4f3c-a39b-5af726fb5cbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import requests\n",
    "import os\n",
    "from tenacity import retry, wait_random_exponential, stop_after_attempt\n",
    "from termcolor import colored\n",
    "\n",
    "GPT_MODEL = \"gpt-3.5-turbo\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1126fbd4-cd23-46b2-806b-3e9928c7a392",
   "metadata": {},
   "source": [
    "#### 定义获取城市编码的函数get_city_adcode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "619343eb-dbb3-4e45-b2e4-dc148058120a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "地  区： 北京\n",
      "adcode: 110000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "\n",
    "def get_city_adcode(city_name):\n",
    "    \"\"\"\n",
    "    根据城市名称获取城市的adcode码。\n",
    "\n",
    "    参数:\n",
    "    city_name (str): 城市名称，例如 \"北京市\"\n",
    "    api_key (str): 高德地图API密钥\n",
    "\n",
    "    返回:\n",
    "    str: 城市的adcode码\n",
    "    \"\"\"\n",
    "    # 从环境变量中获取API密钥\n",
    "    api_key = os.getenv('AMAP_API_KEY')\n",
    "    if not api_key:\n",
    "        return \"Error: API key not found. Please set the AMAP_API_KEY environment variable.\"\n",
    "    \n",
    "    # 高德地图地理编码API的URL\n",
    "    url = 'https://restapi.amap.com/v3/geocode/geo'\n",
    "\n",
    "    # 构造请求参数\n",
    "    params = {\n",
    "        'key': api_key,\n",
    "        'address': city_name,\n",
    "        'output': 'json'\n",
    "    }\n",
    "\n",
    "    # 发送GET请求\n",
    "    response = requests.get(url, params=params)\n",
    "    \n",
    "    # 检查请求是否成功\n",
    "    if response.status_code == 200:\n",
    "        json_data = response.json()\n",
    "        \n",
    "        # 检查API返回的状态码\n",
    "        if json_data['status'] == '1' and json_data['count'] != '0':\n",
    "            # 获取第一个匹配项的adcode\n",
    "            adcode = json_data['geocodes'][0]['adcode']\n",
    "            return adcode\n",
    "        else:\n",
    "            return \"Error: API returned error status.\"\n",
    "    else:\n",
    "        return f\"Error: HTTP request failed with status code {response.status_code}.\"\n",
    "\n",
    "# 使用你的高德地图API密钥\n",
    "city_name = '北京'\n",
    "adcode = get_city_adcode(city_name)\n",
    "print(f\"\\n地  区： {city_name}\")\n",
    "print(f\"adcode: {adcode}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9079e5e0-718c-4590-bbdc-caf9186a74c2",
   "metadata": {},
   "source": [
    "#### 定义查询天气函数get_amap_weather()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "aebeb2fc-34d4-4861-8421-5983084ca7bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "实时天气：东城区的实时天气更新于2024-04-05 23:33:31。当前天气晴，温度为14度，西南风，风力≤3级，相对湿度61%。\n",
      "\n",
      "\n",
      "预报天气：东城区的天气预报，更新时间为2024-04-05 23:33:31。未来几天的天气情况如下：\n",
      "2024-04-05，星期5，白天晴，气温21度，南风1-3级；夜间晴，气温8度，南风1-3级。\n",
      "2024-04-06，星期6，白天晴，气温25度，西南风1-3级；夜间晴，气温11度，西南风1-3级。\n",
      "2024-04-07，星期7，白天晴，气温27度，东北风1-3级；夜间多云，气温12度，东北风1-3级。\n",
      "2024-04-08，星期1，白天多云，气温23度，南风1-3级；夜间多云，气温12度，南风1-3级。\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def get_amap_weather(city, extensions=\"all\"):\n",
    "    \"\"\"\n",
    "    使用高德天气API查询给定城市的天气状况。\n",
    "    \n",
    "    :param city: 要查询天气的城市名称或者城市的adcode。\n",
    "    :param extensions: 可选，'base' 返回实时天气，'all' 返回预报天气。\n",
    "    :return: 包含天气信息的字典，如果出错则返回错误信息。\n",
    "    \"\"\"\n",
    "    # 从环境变量中获取API密钥\n",
    "    api_key = os.getenv('AMAP_API_KEY')\n",
    "    if not api_key:\n",
    "        return \"Error: API key not found. Please set the AMAP_API_KEY environment variable.\"\n",
    "    \n",
    "    # 高德天气API的URL\n",
    "    url = 'https://restapi.amap.com/v3/weather/weatherInfo'\n",
    "    \n",
    "    # 构造请求参数\n",
    "    params = {\n",
    "        'key': api_key,        # API密钥\n",
    "        'city': city,          # 城市名称或adcode\n",
    "        'extensions': extensions, # 'base': 实时天气；'all': 预报天气\n",
    "        'output': 'json'       # 响应格式\n",
    "    }\n",
    "    \n",
    "    try:\n",
    "        # 发送GET请求\n",
    "        response = requests.get(url, params=params)\n",
    "        response.raise_for_status()  # 如果响应状态码不是200，将抛出HTTPError异常\n",
    "        \n",
    "        # 解析JSON数据\n",
    "        weather_data = response.json()\n",
    "        \n",
    "        # 根据需要提取天气信息\n",
    "        if weather_data.get('status') == '1':  # 请求成功\n",
    "            if extensions == \"base\":\n",
    "                # 实时天气信息处理\n",
    "                live_data = weather_data.get('lives', [{}])[0]\n",
    "                # 这里可以添加生成实时天气描述的代码\n",
    "                return generate_weather_realtime_narrative(live_data)\n",
    "            else:\n",
    "                # 预报天气信息处理\n",
    "                forecast_data = weather_data.get('forecasts', [{}])[0]\n",
    "                return generate_weather_forecast_narrative(forecast_data)\n",
    "        else:\n",
    "            # 返回错误信息\n",
    "            return f\"Error: {weather_data.get('info')}\"\n",
    "        \n",
    "    except requests.RequestException as e:\n",
    "        return f\"Network error: {e}\"\n",
    "\n",
    "# 对实时天气返回结果进行处理，将其处理为一段连续的文字：\n",
    "def generate_weather_realtime_narrative(live_data):\n",
    "    \"\"\"\n",
    "    根据提供的实时天气信息生成连续的文字描述。\n",
    "\n",
    "    :param live_data: 包含实时天气信息的字典。\n",
    "    :return: 实时天气的连续文字描述。\n",
    "    \"\"\"\n",
    "    province = live_data.get('province', '指定省份')\n",
    "    city = live_data.get('city', '指定城市')\n",
    "    weather = live_data.get('weather', '未知天气')\n",
    "    temperature = live_data.get('temperature', '未知温度')\n",
    "    wind_direction = live_data.get('winddirection', '未知风向')\n",
    "    wind_power = live_data.get('windpower', '未知风力')\n",
    "    humidity = live_data.get('humidity', '未知湿度')\n",
    "    report_time = live_data.get('reporttime', '未知时间')\n",
    "\n",
    "    # 构建实时天气描述文本\n",
    "    realtime_narrative = (f\"{city}的实时天气更新于{report_time}。\"\n",
    "                          f\"当前天气{weather}，温度为{temperature}度，\"\n",
    "                          f\"{wind_direction}风，风力{wind_power}级，\"\n",
    "                          f\"相对湿度{humidity}%。\")\n",
    "\n",
    "    return realtime_narrative\n",
    "\n",
    "\n",
    "# 对预报天气返回结果进行处理，将其处理为一段连续的文字：\n",
    "def generate_weather_forecast_narrative(forecast_data):\n",
    "    \"\"\"\n",
    "    根据提供的天气预报信息生成连续的文字描述。\n",
    "    \n",
    "    :param forecast_data: 包含预报天气信息的字典。\n",
    "    :return: 天气预报的连续文字描述。\n",
    "    \"\"\"\n",
    "    province = forecast_data.get('province', '指定省份')\n",
    "    city = forecast_data.get('city', '指定城市')\n",
    "    report_time = forecast_data.get('reporttime', '指定时间')\n",
    "    casts = forecast_data.get('casts', [])\n",
    "    \n",
    "    # 初始化描述文本\n",
    "    forecast_narrative = f\"{city}的天气预报，更新时间为{report_time}。未来几天的天气情况如下：\"\n",
    "\n",
    "    # 对每一天的天气信息进行描述\n",
    "    for cast in casts:\n",
    "        date = cast.get('date')\n",
    "        day_weather = cast.get('dayweather')\n",
    "        night_weather = cast.get('nightweather')\n",
    "        day_temp = cast.get('daytemp')\n",
    "        night_temp = cast.get('nighttemp')\n",
    "        day_wind = cast.get('daywind')\n",
    "        night_wind = cast.get('nightwind')\n",
    "        day_power = cast.get('daypower')\n",
    "        night_power = cast.get('nightpower')\n",
    "\n",
    "        forecast_narrative += (f\"\\n{date}，星期{cast.get('week')}，\"\n",
    "                               f\"白天{day_weather}，气温{day_temp}度，\"\n",
    "                               f\"{day_wind}风{day_power}级；\"\n",
    "                               f\"夜间{night_weather}，气温{night_temp}度，\"\n",
    "                               f\"{night_wind}风{night_power}级。\")\n",
    "    \n",
    "    return forecast_narrative\n",
    "\n",
    "\n",
    "\n",
    "# 使用函数示例\n",
    "city = '110101'  # 城市adcode，例如北京市东城区或110101\n",
    "weather_info = get_amap_weather(city, extensions=\"base\")\n",
    "print(f\"实时天气：{weather_info}\\n\\n\")\n",
    "\n",
    "# 使用函数示例\n",
    "city = '110101'  # 城市adcode，例如北京市东城区或110101\n",
    "weather_info = get_amap_weather(city, extensions=\"all\")\n",
    "print(f\"预报天气：{weather_info}\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3f605eb-ffc8-4995-a188-5af0ace1b013",
   "metadata": {},
   "source": [
    "### 定义一个执行函数execute_function_call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "104c998d-bbb5-44e5-88df-1b88541ab65d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def execute_function_call(message):\n",
    "    \"\"\"执行函数调用\"\"\"\n",
    "    \n",
    "    # 判断功能调用的名称是否为 \"get_current_weather\"\n",
    "    if message[\"function_call\"][\"name\"] == \"get_current_weather\":\n",
    "        # 如果是，则获取功能调用的参数\n",
    "        city_name = json.loads(message[\"function_call\"][\"arguments\"])[\"location\"]\n",
    "        # 使用 get_city_adcode 函数获取城市编码\n",
    "        city_code = get_city_adcode(city_name)\n",
    "        # 使用 get_amap_weather 函数获取当前天气信息\n",
    "        weather_info = get_amap_weather(city_code, extensions=\"base\")\n",
    "        results = weather_info\n",
    "\n",
    "    # 判断功能调用的名称是否为 \"get_n_day_weather_forecast\"\n",
    "    elif message[\"function_call\"][\"name\"] == \"get_n_day_weather_forecast\":\n",
    "        # 如果是，则获取功能调用的参数\n",
    "        city_name = json.loads(message[\"function_call\"][\"arguments\"])[\"location\"]\n",
    "        # 使用 get_city_adcode 函数获取城市编码\n",
    "        city_code = get_city_adcode(city_name)\n",
    "        # 使用 get_amap_weather 函数获取未来天气信息\n",
    "        weather_info = get_amap_weather(city_code, extensions=\"all\")\n",
    "        results = weather_info\n",
    "\n",
    "    else:\n",
    "        # 如果功能调用的名称不是 \"get_current_weather\" 或 \"get_n_day_weather_forecast\"，则返回错误信息\n",
    "        results = f\"Error: function {message['function_call']['name']} does not exist\"\n",
    "\n",
    "    # 返回结果\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fb91bb42-512a-4732-ae64-5ec80eb81e3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用了retry库，指定在请求失败时的重试策略。\n",
    "# 这里设定的是指数等待（wait_random_exponential），时间间隔的最大值为40秒，并且最多重试3次（stop_after_attempt(3)）。\n",
    "# 定义一个函数chat_completion_request，主要用于发送 聊天补全 请求到OpenAI服务器\n",
    "@retry(wait=wait_random_exponential(multiplier=1, max=40), stop=stop_after_attempt(3))\n",
    "def chat_completion_request(messages, functions=None, function_call=None, model=GPT_MODEL):\n",
    "\n",
    "    # 设定请求的header信息，包括 API_KEY\n",
    "    headers = {\n",
    "        \"Content-Type\": \"application/json\",\n",
    "        \"Authorization\": \"Bearer \" + os.getenv(\"OPENAI_API_KEY\"),\n",
    "    }\n",
    "\n",
    "    # 设定请求的JSON数据，包括GPT 模型名和要进行补全的消息\n",
    "    json_data = {\"model\": model, \"messages\": messages}\n",
    "\n",
    "    # 如果传入了functions，将其加入到json_data中\n",
    "    if functions is not None:\n",
    "        json_data.update({\"functions\": functions})\n",
    "\n",
    "    # 如果传入了function_call，将其加入到json_data中\n",
    "    if function_call is not None:\n",
    "        json_data.update({\"function_call\": function_call})\n",
    "\n",
    "    # 尝试发送POST请求到OpenAI服务器的chat/completions接口\n",
    "    try:\n",
    "        response = requests.post(\n",
    "            \"https://api.openai.com/v1/chat/completions\",\n",
    "            headers=headers,\n",
    "            json=json_data,\n",
    "        )\n",
    "        # 返回服务器的响应\n",
    "        return response\n",
    "\n",
    "    # 如果发送请求或处理响应时出现异常，打印异常信息并返回\n",
    "    except Exception as e:\n",
    "        print(\"Unable to generate ChatCompletion response\")\n",
    "        print(f\"Exception: {e}\")\n",
    "        return e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f111f564-db60-4440-ad69-95e957fcc21f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义一个函数pretty_print_conversation，用于打印消息对话内容\n",
    "def pretty_print_conversation(messages):\n",
    "\n",
    "    # 为不同角色设置不同的颜色\n",
    "    role_to_color = {\n",
    "        \"system\": \"red\",\n",
    "        \"user\": \"green\",\n",
    "        \"assistant\": \"blue\",\n",
    "        \"function\": \"magenta\",\n",
    "    }\n",
    "\n",
    "    # 遍历消息列表\n",
    "    for message in messages:\n",
    "\n",
    "        # 如果消息的角色是\"system\"，则用红色打印“content”\n",
    "        if message[\"role\"] == \"system\":\n",
    "            print(colored(f\"system: {message['content']}\\n\", role_to_color[message[\"role\"]]))\n",
    "\n",
    "        # 如果消息的角色是\"user\"，则用绿色打印“content”\n",
    "        elif message[\"role\"] == \"user\":\n",
    "            print(colored(f\"user: {message['content']}\\n\", role_to_color[message[\"role\"]]))\n",
    "\n",
    "        # 如果消息的角色是\"assistant\"，并且消息中包含\"function_call\"，则用蓝色打印\"function_call\"\n",
    "        elif message[\"role\"] == \"assistant\" and message.get(\"function_call\"):\n",
    "            print(colored(f\"assistant[function_call]: {message['function_call']}\\n\", role_to_color[message[\"role\"]]))\n",
    "\n",
    "        # 如果消息的角色是\"assistant\"，但是消息中不包含\"function_call\"，则用蓝色打印“content”\n",
    "        elif message[\"role\"] == \"assistant\" and not message.get(\"function_call\"):\n",
    "            print(colored(f\"assistant[content]: {message['content']}\\n\", role_to_color[message[\"role\"]]))\n",
    "\n",
    "        # 如果消息的角色是\"function\"，则用品红色打印“function”\n",
    "        elif message[\"role\"] == \"function\":\n",
    "            print(colored(f\"function ({message['name']}): {message['content']}\\n\", role_to_color[message[\"role\"]]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b29002c6-3658-4682-8af7-2bca49747024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义一个名为functions的列表，其中包含两个字典，这两个字典分别定义了两个功能的相关参数\n",
    "\n",
    "# 第一个字典定义了一个名为\"get_current_weather\"的功能\n",
    "functions = [\n",
    "    {\n",
    "        \"name\": \"get_current_weather\",  # 功能的名称\n",
    "        \"description\": \"Get the current weather\",  # 功能的描述\n",
    "        \"parameters\": {  # 定义该功能需要的参数\n",
    "            \"type\": \"object\",\n",
    "            \"properties\": {  # 参数的属性\n",
    "                \"location\": {  # 地点参数\n",
    "                    \"type\": \"string\",  # 参数类型为字符串\n",
    "                    \"description\": \"The city and state, e.g. San Francisco, CA\",  # 参数的描述\n",
    "                },\n",
    "                \"format\": {  # 温度单位参数\n",
    "                    \"type\": \"string\",  # 参数类型为字符串\n",
    "                    \"enum\": [\"celsius\", \"fahrenheit\"],  # 参数的取值范围\n",
    "                    \"description\": \"The temperature unit to use. Infer this from the users location.\",  # 参数的描述\n",
    "                },\n",
    "            },\n",
    "            \"required\": [\"location\", \"format\"],  # 该功能需要的必要参数\n",
    "        },\n",
    "    },\n",
    "    # 第二个字典定义了一个名为\"get_n_day_weather_forecast\"的功能\n",
    "    {\n",
    "        \"name\": \"get_n_day_weather_forecast\",  # 功能的名称\n",
    "        \"description\": \"Get an N-day weather forecast\",  # 功能的描述\n",
    "        \"parameters\": {  # 定义该功能需要的参数\n",
    "            \"type\": \"object\",\n",
    "            \"properties\": {  # 参数的属性\n",
    "                \"location\": {  # 地点参数\n",
    "                    \"type\": \"string\",  # 参数类型为字符串\n",
    "                    \"description\": \"The city and state, e.g. San Francisco, CA\",  # 参数的描述\n",
    "                },\n",
    "                \"format\": {  # 温度单位参数\n",
    "                    \"type\": \"string\",  # 参数类型为字符串\n",
    "                    \"enum\": [\"celsius\", \"fahrenheit\"],  # 参数的取值范围\n",
    "                    \"description\": \"The temperature unit to use. Infer this from the users location.\",  # 参数的描述\n",
    "                },\n",
    "                \"num_days\": {  # 预测天数参数\n",
    "                    \"type\": \"integer\",  # 参数类型为整数\n",
    "                    \"description\": \"The number of days to forecast\",  # 参数的描述\n",
    "                }\n",
    "            },\n",
    "            \"required\": [\"location\", \"format\", \"num_days\"]  # 该功能需要的必要参数\n",
    "        },\n",
    "    },\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86c4193f-355c-42a5-b393-471b46e26135",
   "metadata": {},
   "source": [
    "#### 查询北京当天的天气情况"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9334929d-facb-4427-a33b-c0198ed52cb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Role: system\n",
      "Content: Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\n",
      "\n",
      "Role: user\n",
      "Content: I live in Beijing.What's the weather like today\n",
      "\n",
      "\u001b[31msystem: Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\n",
      "\u001b[0m\n",
      "\u001b[32muser: I live in Beijing.What's the weather like today\n",
      "\u001b[0m\n",
      "\u001b[34massistant[function_call]: {'name': 'get_current_weather', 'arguments': '{\"location\":\"Beijing\",\"format\":\"celsius\"}'}\n",
      "\u001b[0m\n",
      "\u001b[35mfunction (get_current_weather): 北京市的实时天气更新于2024-04-05 23:33:30。当前天气晴，温度为14度，西南风，风力≤3级，相对湿度61%。\n",
      "\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# 定义一个空列表messages，用于存储聊天的内容\n",
    "messages = []\n",
    "\n",
    "# 使用append方法向messages列表添加一条系统角色的消息\n",
    "messages.append({\n",
    "    \"role\": \"system\",  # 消息的角色是\"system\"\n",
    "    \"content\": \"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\"  # 消息的内容\n",
    "})\n",
    "\n",
    "# 向messages列表添加一条用户角色的消息\n",
    "messages.append({\n",
    "    \"role\": \"user\",  # 消息的角色是\"user\"\n",
    "    \"content\": \"I live in Beijing.What's the weather like today\"  # 用户询问今天的天气情况\n",
    "})\n",
    "\n",
    "# 遍历messages列表并打印每个消息\n",
    "for message in messages:\n",
    "    print(f\"Role: {message['role']}\")\n",
    "    print(f\"Content: {message['content']}\")\n",
    "    print()  # 打印空行以便分隔消息\n",
    "\n",
    "# 使用定义的chat_completion_request函数发起一个请求，传入messages和functions作为参数\n",
    "chat_response = chat_completion_request(\n",
    "    messages, functions=functions\n",
    ")\n",
    "\n",
    "# 解析返回的JSON数据，获取助手的回复消息\n",
    "assistant_message = chat_response.json()[\"choices\"][0][\"message\"]\n",
    "\n",
    "# 将助手的回复消息添加到messages列表中\n",
    "messages.append(assistant_message)\n",
    "\n",
    "# 如果助手的消息中有功能调用\n",
    "if assistant_message.get(\"function_call\"):\n",
    "    # 使用 execute_function_call 函数执行功能调用，并获取结果\n",
    "    results = execute_function_call(assistant_message)\n",
    "    # 将功能的结果作为一个功能角色的消息添加到消息列表中\n",
    "    messages.append({\"role\": \"function\", \"name\": assistant_message[\"function_call\"][\"name\"], \"content\": results})\n",
    "\n",
    "# 使用 pretty_print_conversation 函数打印对话\n",
    "pretty_print_conversation(messages)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5955bbc-79cd-4f8e-9203-e4193fc7f83a",
   "metadata": {},
   "source": [
    "#### 预报上海3天后的天气情况，高德天气API似乎只支持3天的预报？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b7df341d-8928-4747-9ed1-9f41e28042f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Role: system\n",
      "Content: Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\n",
      "\n",
      "Role: user\n",
      "Content: I live in Shanghai, China.what is the weather going to be like in future？\n",
      "\n",
      "\u001b[31msystem: Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\n",
      "\u001b[0m\n",
      "\u001b[32muser: I live in Shanghai, China.what is the weather going to be like in future？\n",
      "\u001b[0m\n",
      "\u001b[34massistant[function_call]: {'name': 'get_n_day_weather_forecast', 'arguments': '{\"location\":\"Shanghai, China\",\"format\":\"celsius\",\"num_days\":7}'}\n",
      "\u001b[0m\n",
      "\u001b[35mfunction (get_n_day_weather_forecast): 上海市的天气预报，更新时间为2024-04-05 23:31:33。未来几天的天气情况如下：\n",
      "2024-04-05，星期5，白天晴，气温18度，东北风1-3级；夜间小雨，气温12度，东北风1-3级。\n",
      "2024-04-06，星期6，白天小雨，气温16度，北风1-3级；夜间晴，气温12度，北风1-3级。\n",
      "2024-04-07，星期7，白天小雨，气温16度，北风1-3级；夜间小雨，气温13度，北风1-3级。\n",
      "2024-04-08，星期1，白天小雨，气温18度，北风1-3级；夜间阴，气温12度，北风1-3级。\n",
      "\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# 初始化一个空的messages列表\n",
    "messages = []\n",
    "\n",
    "# 向messages列表添加一条系统角色的消息，要求不做关于函数参数值的假设，如果用户的请求模糊，应该寻求澄清\n",
    "messages.append({\n",
    "    \"role\": \"system\",  # 消息的角色是\"system\"\n",
    "    \"content\": \"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\"\n",
    "})\n",
    "\n",
    "\n",
    "# 向messages列表添加一条用户角色的消息\n",
    "messages.append({\n",
    "    \"role\": \"user\",  # 消息的角色是\"user\"\n",
    "    \"content\": \"I live in Shanghai, China.what is the weather going to be like in future？\"\n",
    "})\n",
    "\n",
    "# 遍历messages列表并打印每个消息\n",
    "for message in messages:\n",
    "    print(f\"Role: {message['role']}\")\n",
    "    print(f\"Content: {message['content']}\")\n",
    "    print()  # 打印空行以便分隔消息\n",
    "\n",
    "# 使用定义的chat_completion_request函数发起一个请求，传入messages和functions作为参数\n",
    "chat_response = chat_completion_request(\n",
    "    messages, functions=functions\n",
    ")\n",
    "\n",
    "# 解析返回的JSON数据，获取助手的回复消息\n",
    "assistant_message = chat_response.json()[\"choices\"][0][\"message\"]\n",
    "\n",
    "# 将助手的回复消息添加到messages列表中\n",
    "messages.append(assistant_message)\n",
    "\n",
    "# 如果助手的消息中有功能调用\n",
    "if assistant_message.get(\"function_call\"):\n",
    "    # 使用 execute_function_call 函数执行功能调用，并获取结果\n",
    "    results = execute_function_call(assistant_message)\n",
    "    # 将功能的结果作为一个功能角色的消息添加到消息列表中\n",
    "    messages.append({\"role\": \"function\", \"name\": assistant_message[\"function_call\"][\"name\"], \"content\": results})\n",
    "\n",
    "# 使用 pretty_print_conversation 函数打印对话\n",
    "pretty_print_conversation(messages)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75d951f0-f550-46a9-9438-feddf2666c22",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}