OpenAI新开放了这些好用的API功能

'这张图片展示了一个自然景观，中间有一条木制的栈道穿过一片绿色的草地。草地上有不同类型的草和植物，背景是树木和一片多云的天空。
整个场景给人一种宁静和平静的感觉，可能是一个适合散步的地方。图片的色彩鲜艳，天空的蓝色和草地的绿色形成了鲜明的对比。'

client = OpenAI(api_key=api_key)

def recognize_encode_image():
    image_path = "img_2.png"
    with open(image_path, "rb") as image_file:
        base64_image = base64.b64encode(image_file.read()).decode('utf-8')
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "model": "gpt-4-vision-preview",
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": "What’s in this image?"
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}"
                        }
                    }
                ]
            }
        ],
        "max_tokens": 300
    }
   
    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)

    print(response.json())

图片显示了一只猫和一只狗非常靠近，显得亲密和友好。猫的一只前爪伸出，爪子的粉红色肉垫清晰可见，它的眼神似乎透露出好奇或轻微的警惕。狗的表情则比较轻松，眼睛直视镜头。
背景因为焦距的原因变得模糊，无法分辨细节。这种画面很可能被用来表现动物之间的和谐共处或者强调它们可爱的一面。

client = OpenAI(api_key=api_key)

def recognize_multiple_images():
    response = client.chat.completions.create(
        model="gpt-4-vision-preview",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
                    },
                    {
                        "type": "text",
                        "text": "What’s in these images? Is there any difference between them?",
                    },
                    {
                        "type": "image_url",
                        "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
                    },
                ],
            }
        ],
        max_tokens=300,
    )
    print(response.choices[0])

client = OpenAI(api_key=api_key)

def generate_image():
    response = client.images.generate(
        model="dall-e-3",
        pompt="一只柴犬趴在沙发上",
        size="1024x1024",
        quality="standard",
        n=1,
    )

    image_url = response.data[0].url
    print('image_url:', image_url)

client = OpenAI(api_key=api_key)

def edit_image():
    response = client.images.edit(
        model="dall-e-2",  # only dall-e-2
        image=open("img.png", "rb"),
        mask=open("img_1.png", "rb"),
        prompt="A sunlit indoor lounge area with a pool containing a flamingo", 
        n=1,
        size="1024x1024"
    )

    image_url = response.data[0].url
    print('image_url:', image_url)

client = OpenAI(api_key=api_key)

def change_image():
    response = client.images.create_variation(
        image=open("img_2.png", "rb"),
        n=2,
        size="1024x1024"
    )

    image_url = response.data[0].url
    print('image_url:', image_url)

from openai import OpenAI
client = OpenAI(api_key=api_key)

response = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Who won the world series in 2020?"},
    {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
    {"role": "user", "content": "Where was it played?"}
  ]
)
print('response:', response.choices[0].message.content)

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "The 2020 World Series was played in Texas at Globe Life Field in Arlington.",
        "role": "assistant"
      }
    }
  ],
  "created": 1677664795,
  "id": "chatcmpl-7QyqpwdfhqwajicIEznoc6Q47XAyW",
  "model": "gpt-3.5-turbo-0613",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 17,
    "prompt_tokens": 57,
    "total_tokens": 74
  }
}

client = OpenAI(api_key=api_key)

def return_json():
    response = client.chat.completions.create(
        model="gpt-4-1106-preview",  # gpt-3.5-turbo-1106
        messages=[
            {"role": "system", "content": "You are a helpful assistant, return JSON format."},  # JSON is necessary
            {"role": "user", "content": "谁赢了2020年的世界杯?"},
        ],
        response_format={"type": "json_object"} # text default
    )
    print('response:', response.choices[0].message.content)

{
  "winner": "Argentina",
  "event": "FIFA World Cup 2022",
  "runner_up": "France",
  "location": "Qatar",
  "date": "December 18, 2022"
}

{'error': {'message': "'messages' must contain the word 'json' in some form, to use 'response_format' of type 'json_object'.", 'type': 'invalid_request_error', 'param': 'messages', 'code': None}}

client = OpenAI(api_key=api_key)

def reproduce_answer():
    response = client.chat.completions.create(
        model="gpt-3.5-turbo-1106",  # gpt-3.5-turbo-1106
        messages=[
            {"role": "user", "content": "随机生成一个长度为10的字符串"},
        ],
        seed=10086
    )
    print('system_fingerprint:', response)  # 在 gpt-3.5-turbo-1106中有值输出
    print('response:', response.choices[0].message.content)

import openai
import json

client = OpenAI(api_key=api_key)

# Example dummy function hard coded to return the same weather
# In production, this could be your backend API or an external API
def get_current_weather(location, unit="fahrenheit"):
    """Get the current weather in a given location"""
    if "tokyo" in location.lower():
        return json.dumps({"location": location, "temperature": "10", "unit": "celsius"})
    elif "san francisco" in location.lower():
        return json.dumps({"location": location, "temperature": "72", "unit": "fahrenheit"})
    else:
        return json.dumps({"location": location, "temperature": "22", "unit": "celsius"})

def run_conversation():
    # Step 1: send the conversation and available functions to the model
    messages = [{"role": "user", "content": "What's the weather like in San Francisco, Tokyo, and Paris?"}]
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_weather",
                "description": "Get the current weather in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city and state, e.g. San Francisco, CA",
                        },
                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                    },
                    "required": ["location"],
                },
            },
        }
    ]
    response = client.chat.completions.create(
        model="gpt-3.5-turbo-1106",
        messages=messages,
        tools=tools,
        tool_choice="auto",  # auto is default, but we'll be explicit
    )
    response_message = response.choices[0].message
    tool_calls = response_message.tool_calls
    # Step 2: check if the model wanted to call a function
    if tool_calls:
        # Step 3: call the function
        # Note: the JSON response may not always be valid; be sure to handle errors
        available_functions = {
            "get_current_weather": get_current_weather,
        }  # only one function in this example, but you can have multiple
        messages.append(response_message)  # extend conversation with assistant's reply
        # Step 4: send the info for each function call and function response to the model
        for tool_call in tool_calls:
            function_name = tool_call.function.name
            function_to_call = available_functions[function_name]
            function_args = json.loads(tool_call.function.arguments)
            function_response = function_to_call(
                location=function_args.get("location"),
                unit=function_args.get("unit"),
            )
            messages.append(
                {
                    "tool_call_id": tool_call.id,
                    "role": "tool",
                    "name": function_name,
                    "content": function_response,
                }
            )  # extend conversation with function response
        second_response = client.chat.completions.create(
            model="gpt-3.5-turbo-1106",
            messages=messages,
        )  # get a new response from the model where it can see the function response
        return second_response
print(run_conversation())

Currently, the weather in San Francisco is 72°F and partly cloudy. In Tokyo, the weather is 10°C and cloudy. In Paris, the weather is 22°C and partly cloudy.'

client = OpenAI(api_key=api_key)

def get_embedding(text, model="text-embedding-ada-002"):
   text = text.replace("\n", " ")
   return client.embeddings.create(input = [text], model=model)['data'][0]['embedding']

client = OpenAI(api_key=api_key)

def tts():
    speech_file_path = Path(__file__).parent / "speech.mp3"
    response = client.audio.speech.create(
        model="tts-1",  # tts-1-hd
        voice="alloy",  # alloy, echo, fable, onyx, nova, and shimmer
        # input="Today is a wonderful day to build something people love!"
        input="在海外游戏行业中，用户获取（User Acquisition，UA）通常是指通过购买效果广告来获取流量，类似于国内的买量。海外投放面临的主要挑战是如何选择适合的媒体和素材，以吸引有价值的用户，并评估广告投放的效果。"
    )

    response.stream_to_file(speech_file_path)

client = OpenAI(api_key=api_key)

def stream_and_play():
    text = '今天的天气怎么样？可以去公园玩吗？'
    response = client.audio.speech.create(
        model="tts-1",
        voice="alloy",
        input=text,
    )
    # Convert the binary response content to a byte stream
    byte_stream = io.BytesIO(response.content)

    # Read the audio data from the byte stream
    audio = AudioSegment.from_file(byte_stream, format="mp3")

    # Play the audio
    play(audio)

client = OpenAI(api_key=api_key)

def stt():
    audio_file = open("speech.mp3", "rb")
    transcript = client.audio.transcriptions.create(
        model="whisper-1",
        file=audio_file,
        # response_format="text"
    )
    print(transcript)

# 原音频文案：
在海外游戏行业中，用户获取（User Acquisition，UA）通常是指通过购买效果广告来获取流量，类似于国内的买量。海外投放面临的主要挑战是如何选择适合的媒体和素材，以吸引有价值的用户，并评估广告投放的效果。

# 转文字后的内容：
在海外游戏行业中,用户获取User Acquisition UA,通常是指通过购买效果广告来获取流量,类似于国内的买量。 海外投放面临的主要挑战是如何选择适合的媒体和素材,以吸引有价值的用户并评估广告投放的效果。

client = OpenAI(api_key=api_key)

def tanslate_audio():
    audio_file = open("speech.mp3", "rb")
    transcript = client.audio.translations.create(
        model="whisper-1",
        file=audio_file
    )
    print(transcript)

# 原音频文案：
在海外游戏行业中，用户获取（User Acquisition，UA）通常是指通过购买效果广告来获取流量，类似于国内的买量。海外投放面临的主要挑战是如何选择适合的媒体和素材，以吸引有价值的用户，并评估广告投放的效果。

# 翻译后的文案：
In the overseas gaming industry, user acquisition, U.A., usually refers to the acquisition of traffic by purchasing effective advertising, similar to domestic purchasing. 
The main challenge faced by overseas advertising is how to choose the right media and material to attract valuable users and assess the effect of advertising.

OpenAI-Beta: assistants=v1

assistant = client.beta.assistants.create(
    name="Math Tutor",
    instructions="You are a personal math tutor. Write and run code to answer math questions.",
    tools=[{"type": "code_interpreter"}],
    model="gpt-4-1106-preview"
)

thread = client.beta.threads.create()

client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="I need to solve the equation `3x + 11 = 14`. Can you help me?"
)

run = client.beta.threads.runs.create(
  thread_id=thread.id,
  assistant_id=assistant.id
)

while True:
    run = client.beta.threads.runs.retrieve(
        thread_id=thread.id,
        run_id=run.id
    )
    if run.status == "completed":
        break
    time.sleep(2)

messages = client.beta.threads.messages.list(
    thread_id=thread.id
)

for msg in reversed(messages.data):
    if msg.content[0].type == "text":
        print(f"{msg.role}:", msg.content[0].text.value)
    else:
        print(f"{msg.role}:", msg.content[0])

def run_assistant():
    # step 1: 创建助手
    assistant = client.beta.assistants.create(
        name="Math Tutor",
        instructions="You are a personal math tutor. Write and run code to answer math questions.",
        tools=[{"type": "code_interpreter"}],
        model="gpt-4-1106-preview"
    )
    # step 2: 创建线程
    thread = client.beta.threads.create()
    # step 3: 创建消息
    client.beta.threads.messages.create(
        thread_id=thread.id,
        role="user",
        content="I need to solve the equation `3x + 11 = 14`. Can you help me?"
    )
    # step 4: 运行助手
    run = client.beta.threads.runs.create(
        thread_id=thread.id,
        assistant_id=assistant.id
    )
    # step 5: 轮询运行结果
    while True:
        run = client.beta.threads.runs.retrieve(
            thread_id=thread.id,
            run_id=run.id
        )
        if run.status == "completed":
            break
        time.sleep(2)
    # step 6: 输出运行结果
    messages = client.beta.threads.messages.list(
        thread_id=thread.id
    )
    for msg in reversed(messages.data):
        if msg.content[0].type == "text":
            print(f"{msg.role}:", msg.content[0].text.value)
        else:
            print(f"{msg.role}:", msg.content[0])

user: I need to solve the equation `3x + 11 = 14`. Can you help me?
assistant: Of course. To solve the equation `3x + 11 = 14` for x, you would follow these steps:

1. Subtract 11 from both sides of the equation to get `3x = 14 - 11`.
2. Simplify the right-hand side of the equation.
3. Divide both sides by 3 to isolate x.

Let's do that calculation.
assistant: The solution to the equation `3x + 11 = 14` is \( x = 1 \).

assistant = client.beta.assistants.create(
  instructions="You are a personal math tutor. When asked a math question, write and run code to answer the question.",
  model="gpt-4-1106-preview",
  tools=[{"type": "code_interpreter"}]
)

# Upload a file with an "assistants" purpose
file = client.files.create(
  file=open("speech.py", "rb"),
  purpose='assistants'
)

# Create an assistant using the file ID
assistant = client.beta.assistants.create(
  instructions="You are a personal math tutor. When asked a math question, write and run code to answer the question.",
  model="gpt-4-1106-preview",
  tools=[{"type": "code_interpreter"}],
  file_ids=[file.id]
)

thread = client.beta.threads.create(
  messages=[
    {
      "role": "user",
      "content": "I need to solve the equation `3x + 11 = 14`. Can you help me?",
      "file_ids": [file.id]
    }
  ]
)

file_deletion_status = client.beta.assistants.files.delete(
  assistant_id=assistant.id,
  file_id=file.id
)

{
    "id": "msg_OHGpsFRGFYmz69MM1u8KYCwf",
    "object": "thread.message",
    "created_at": 1698964262,
    "thread_id": "thread_uqorHcTs46BZhYMyPn6Mg5gW",
    "role": "assistant",
    "content": [
    {
      "type": "image_file",
      "image_file": {
        "file_id": "file-WsgZPYWAauPuW4uvcgNUGcb"
      }
    }
  ]
  # ...
}

content = client.files.with_raw_response.retrieve_content(file.id)

run_steps = client.beta.threads.runs.steps.list(
  thread_id=thread.id,
  run_id=run.id
)

{
  "object": "list",
  "data": [
    {
      "id": "step_DQfPq3JPu8hRKW0ctAraWC9s",
      "object": "thread.run.step",
      "type": "tool_calls",
      "run_id": "run_kme4a442kme4a442",
      "thread_id": "thread_34p0sfdas0823smfv",
      "status": "completed",
      "step_details": {
        "type": "tool_calls",
        "tool_calls": [
          {
            "type": "code",
            "code": {
              "input": "# Calculating 2 + 2\nresult = 2 + 2\nresult",
              "outputs": [
                {
                  "type": "logs",
                  "logs": "4"
                }
                        ...
 }

def run_assistant_code_interpreter():
    # step 1: 上传文件
    file = client.files.create(
        file=open("data.xlsx", "rb"),
        purpose='assistants'
    )
    # step 2: 创建助手
    assistant = client.beta.assistants.create(
        name="data analyst",
        instructions="You are a personal data analyst. Write and run code to answer data questions.",
        tools=[{"type": "code_interpreter"}],
        model="gpt-4-1106-preview",
        file_ids=[file.id]
    )
    # step 3: 创建线程
    thread = client.beta.threads.create()
    # step 4: 添加用户问题
    client.beta.threads.messages.create(
        thread_id=thread.id,
        role="user",
        content="帮忙分析最近的商品销量，画一个折线图，并且根据图表内容给出相关的产品建议，生成图表的时候要注意中文需要正常显示。"
    )
    # step 5: 运行助手
    run = client.beta.threads.runs.create(
        thread_id=thread.id,
        assistant_id=assistant.id,
        instructions="生成图表的时候要注意中文需要正常显示。"
    )
    # step 6: 查询运行结果
    while True:
        run = client.beta.threads.runs.retrieve(
            thread_id=thread.id,
            run_id=run.id
        )
        print("status:", run.status)
        if run.status == "completed":
            break
        if run.status == "failed":
            print("failed error:", run.last_error)
        time.sleep(2)
    # step 7: 展示结果消息列表
    messages = client.beta.threads.messages.list(
        thread_id=thread.id
    )
    for msg in reversed(messages.data):
        if msg.content[0].type == "text":
            print(f"{msg.role}:", msg.content[0].text.value)
        elif msg.content[0].type == "image_file":
            print(f"{msg.role}: file id is", msg.content[0].image_file.file_id)
            # see issue: https://github.com/openai/openai-python/issues/699
            file_content = client.files.with_raw_response.retrieve_content(file_id=msg.content[0].image_file.file_id)
            with open(f"test_{msg.content[0].image_file.file_id}.png", "wb") as f:
                f.write(file_content.content)
        else:
            print(f"{msg.role}:", msg.content[0])

    # step 8（可选）: 展示中间步骤
    run_steps = client.beta.threads.runs.steps.list(
        thread_id=thread.id,
        run_id=run.id
    )
    i = 0
    for run_step in reversed(run_steps.data):
        if run_step.step_details.type == "tool_calls":
            i += 1
            for tool_call in run_step.step_details.tool_calls:
                print(f"step {i} input<<<<<<<<<<<<<<<:\n", tool_call.code_interpreter.input)
                if tool_call.code_interpreter.outputs[0].type == "logs":
                    print(f"step {i} outputs>>>>>>>>>>>>>>>>>>:\n", tool_call.code_interpreter.outputs[0].logs)
                elif tool_call.code_interpreter.outputs[0].type == "image":
                    print(f"step {i} outputs>>>>>>>>>>>>>>>>>>:\n", tool_call.code_interpreter.outputs[0].image.file_id)
                else:
                    print(f"step {i} outputs>>>>>>>>>>>>>>>>>>:\n", tool_call.code_interpreter.outputs[0])
        elif run_step.step_details.type != "message_creation":
            print(f"other middle step:", run_step.step_details)

user: 帮忙分析最近的商品销量，画一个折线图，并且根据图表内容给出相关的产品建议。
assistant: 首先，我将打开和检查你上传的文件，以了解其中的数据结构，然后我们可以进一步分析商品销量，并尝试绘制折线图来表示数据。接下来，我将根据图表的结果给出一些建议。现在我将打开这个文件。
assistant: 文件已成功读取，数据看起来包含两列：一列是日期（"时间"），另一列是对应的销量（"销量"）。看起来像是每日销量的时间序列数据。接下来，我将使用这些数据来绘制折线图。这将有助于我们更好地理解销量随时间的变化趋势。现在我来绘制这个折线图。
assistant: file id is file-QPltLMyDx4RWUzt59PD72oY9

step 1 input<<<<<<<<<<<<<<<:
 import pandas as pd

# Load the uploaded file to see its content and structure
file_path = '/mnt/data/file-oxr4e1AhUQcmRScQYlg1wVY9'

# We'll try to read the file with pandas assuming it might be a CSV or Excel file
# If this fails, we might need additional context or information about the file format

# First, let's try to read it as a CSV
try:
    sales_data = pd.read_csv(file_path)
except Exception as e:
    print(f"Error reading as CSV: {e}")

    # Next, we'll try to read it as an Excel file
    try:
        sales_data = pd.read_excel(file_path)
    except Exception as e:
        print(f"Error reading as Excel: {e}")

# If successfully read, let's check the first few rows of the file
if 'sales_data' in locals():
    preview = sales_data.head()
else:
    preview = "Unable to read the file. It may not be a CSV or Excel file, or it could have a different structure."

preview
step 1 outputs>>>>>>>>>>>>>>>>>>:
 Error reading as CSV: 'utf-8' codec can't decode byte 0x82 in position 16: invalid start byte
          时间  销量
0 2023-11-01  50
1 2023-11-02  70
2 2023-11-03  60
3 2023-11-04  80
4 2023-11-05  40


step 2 input<<<<<<<<<<<<<<<:
 # Check the entire dataset for missing values or anomalies
sales_data_info = sales_data.info()
missing_values = sales_data.isnull().sum()

# Preparing data for plotting
# Ensuring the '时间' column is parsed as datetime if it isn't already
sales_data['时间'] = pd.to_datetime(sales_data['时间'])

# Sorting the data according to the '时间' to ensure correct plotting
sales_data_sorted = sales_data.sort_values('时间')

# Displaying data information and missing value count
sales_data_info, missing_values, sales_data_sorted.head()
step 2 outputs>>>>>>>>>>>>>>>>>>:
 <class 'pandas.core.frame.DataFrame'>
RangeIndex: 9 entries, 0 to 8
Data columns (total 2 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   时间      9 non-null      datetime64[ns]
 1   销量      9 non-null      int64         
dtypes: datetime64[ns](1), int64(1)
memory usage: 272.0 bytes
(None,
 时间    0
 销量    0
 dtype: int64,
           时间  销量
 0 2023-11-01  50
 1 2023-11-02  70
 2 2023-11-03  60
 3 2023-11-04  80
 4 2023-11-05  40)
 
 
 
step 3 input<<<<<<<<<<<<<<<:
 import matplotlib.pyplot as plt
import matplotlib.dates as mdates

# Configuring matplotlib to display Chinese characters properly
plt.rcParams['font.sans-serif'] = ['SimHei']  # Or another font that supports Chinese
plt.rcParams['axes.unicode_minus'] = False

# Plotting the sales data
plt.figure(figsize=(10, 6))
plt.plot(sales_data_sorted['时间'], sales_data_sorted['销量'], marker='o')

# Formatting the plot
plt.title('商品销量趋势图')
plt.xlabel('时间')
plt.ylabel('销量')
plt.grid(True)
plt.xticks(rotation=45)
plt.gca().xaxis.set_major_locator(mdates.DayLocator(interval=1))  # Ensure every day is marked
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))

# Showing the plot
plt.tight_layout()
plt.show()
step 3 outputs>>>>>>>>>>>>>>>>>>:
 file-q2LglNbwgnM7VHc9PjxlgslD

assistant = client.beta.assistants.create(
  instructions="You are a customer support chatbot. Use your knowledge base to best respond to customer queries.",
  model="gpt-4-1106-preview",
  tools=[{"type": "retrieval"}]
)

assistant = client.beta.assistants.create(
  instructions="You are a weather bot. Use the provided functions to answer questions.",
  model="gpt-4-1106-preview",
  tools=[{
      "type": "function",
    "function": {
      "name": "getCurrentWeather",
      "description": "Get the weather in location",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string", "description": "The city and state e.g. San Francisco"},
          "unit": {"type": "string", "enum": ["c", "f"]}
        },
        "required": ["location", "unit"]
      }
    }
  }, {
    "type": "function",
    "function": {
      "name": "getNickname",
      "description": "Get the nickname of a city",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string", "description": "The city and state e.g. San Francisco"},
        },
        "required": ["location"]
      }
    } 
  }]
)

{
  "id": "run_3HV7rrQsagiqZmYynKwEdcxS",
  "object": "thread.run",
  "assistant_id": "asst_rEEOF3OGMan2ChvEALwTQakP",
  "thread_id": "thread_dXgWKGf8Cb7md8p0wKiMDGKc",
  "status": "requires_action",
  "required_action": {
    "type": "submit_tool_outputs",
    "submit_tool_outputs": {
      "tool_calls": [
        {
          "id": "call_Vt5AqcWr8QsRTNGv4cDIpsmA",
          "type": "function",
          "function": {
            "name": "getCurrentWeather",
            "arguments": "{\"location\":\"San Francisco\"}"
          }
        },
        {
          "id": "call_45y0df8230430n34f8saa",
          "type": "function",
          "function": {
            "name": "getNickname",
            "arguments": "{\"location\":\"Los Angeles\"}"
          }
        }
      ]
    }
  },
...

run = client.beta.threads.runs.submit_tool_outputs(
  thread_id=thread.id,
  run_id=run.id,
  tool_outputs=[
      {
        "tool_call_id": call_ids[0],
        "output": "22C",
      },
      {
        "tool_call_id": call_ids[1],
        "output": "LA",
      },
    ]
)