ดาวน์โหลด openai python - ดาวน์โหลด openai python ซอร์สโค้ด

ไลบรารี OpenAI Python API

ไลบรารี OpenAI Python ช่วยให้เข้าถึง OpenAI REST API ได้อย่างสะดวกจากแอปพลิเคชัน Python 3.8+ ใดๆ ไลบรารีประกอบด้วยคำจำกัดความประเภทสำหรับพารามิเตอร์คำขอและฟิลด์ตอบกลับทั้งหมด และนำเสนอทั้งไคลเอนต์ซิงโครนัสและอะซิงโครนัสที่ขับเคลื่อนโดย httpx

มันถูกสร้างขึ้นจากข้อกำหนด OpenAPI ของเราด้วย Stainless

เอกสารประกอบ

คุณสามารถดูเอกสาร REST API ได้ที่ platform.openai.com API แบบเต็มของไลบรารีนี้มีอยู่ใน api.md

การติดตั้ง

สำคัญ

SDK ถูกเขียนใหม่ในเวอร์ชัน 1 ซึ่งเผยแพร่เมื่อวันที่ 6 พฤศจิกายน 2023 ดูคู่มือการย้ายเวอร์ชัน 1 ซึ่งรวมถึงสคริปต์เพื่ออัปเดตโค้ดของคุณโดยอัตโนมัติ

 # install from PyPI
pip install openai

การใช้งาน

API แบบเต็มของไลบรารีนี้มีอยู่ใน api.md

 import os
from openai import OpenAI

client = OpenAI (
    api_key = os . environ . get ( "OPENAI_API_KEY" ),  # This is the default and can be omitted
)

chat_completion = client . chat . completions . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "Say this is a test" ,
        }
    ],
    model = "gpt-4o" ,
)

แม้ว่าคุณจะสามารถระบุอาร์กิวเมนต์คำหลัก api_key แต่เราขอแนะนำให้ใช้ python-dotenv เพื่อเพิ่ม OPENAI_API_KEY="My API Key" ลงในไฟล์ .env ของคุณ เพื่อให้คีย์ API ของคุณไม่ถูกจัดเก็บไว้ในการควบคุมแหล่งที่มา

วิสัยทัศน์

ด้วยภาพที่โฮสต์:

 response = client . chat . completions . create (
    model = "gpt-4o-mini" ,
    messages = [
        {
            "role" : "user" ,
            "content" : [
                { "type" : "text" , "text" : prompt },
                {
                    "type" : "image_url" ,
                    "image_url" : { "url" : f" { img_url } " },
                },
            ],
        }
    ],
)

ด้วยรูปภาพเป็นสตริงที่เข้ารหัส base64:

 response = client . chat . completions . create (
    model = "gpt-4o-mini" ,
    messages = [
        {
            "role" : "user" ,
            "content" : [
                { "type" : "text" , "text" : prompt },
                {
                    "type" : "image_url" ,
                    "image_url" : { "url" : f"data: { img_type } ;base64, { img_b64_str } " },
                },
            ],
        }
    ],
)

ผู้ช่วยหน่วยเลือกตั้ง

เมื่อโต้ตอบกับ API การดำเนินการบางอย่าง เช่น การเริ่มเรียกใช้และการเพิ่มไฟล์ไปยังร้านค้าเวกเตอร์จะไม่ตรงกันและต้องใช้เวลาในการดำเนินการให้เสร็จสิ้น SDK มีฟังก์ชันตัวช่วยซึ่งจะสำรวจสถานะจนกว่าจะถึงสถานะเทอร์มินัลแล้วส่งคืนออบเจ็กต์ผลลัพธ์ หากวิธี API ส่งผลให้เกิดการดำเนินการที่อาจได้รับประโยชน์จากการสำรวจ จะมีเวอร์ชันที่สอดคล้องกันของวิธีการลงท้ายด้วย '_and_poll'

ตัวอย่างเช่นในการสร้างการเรียกใช้และการสำรวจความคิดเห็นจนกว่าจะถึงสถานะเทอร์มินัลคุณสามารถเรียกใช้ได้:

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

ข้อมูลเพิ่มเติมเกี่ยวกับวงจรการใช้งานของการรันสามารถพบได้ในเอกสารประกอบวงจรการใช้งานการรัน

ตัวช่วยอัปโหลดจำนวนมาก

เมื่อสร้างและโต้ตอบกับร้านค้าเวกเตอร์ คุณสามารถใช้ตัวช่วยโพลเพื่อตรวจสอบสถานะของการดำเนินการได้ เพื่อความสะดวก เรายังมีตัวช่วยอัปโหลดจำนวนมากเพื่อให้คุณสามารถอัปโหลดหลายไฟล์พร้อมกันได้

 sample_files = [ Path ( "sample-paper.pdf" ), ...]

batch = await client . vector_stores . file_batches . upload_and_poll (
    store . id ,
    files = sample_files ,
)

ตัวช่วยสตรีมมิ่ง

SDK ยังมีตัวช่วยในการประมวลผลสตรีมและจัดการเหตุการณ์ที่เข้ามาอีกด้วย

 with client . beta . threads . runs . stream (
    thread_id = thread . id ,
    assistant_id = assistant . id ,
    instructions = "Please address the user as Jane Doe. The user has a premium account." ,
) as stream :
    for event in stream :
        # Print the text from text delta events
        if event . type == "thread.message.delta" and event . data . delta . content :
            print ( event . data . delta . content [ 0 ]. text )

ข้อมูลเพิ่มเติมเกี่ยวกับตัวช่วยสตรีมมิ่งสามารถพบได้ในเอกสารเฉพาะ: helpers.md

การใช้งานแบบอะซิงโครนัส

เพียงนำเข้า AsyncOpenAI แทน OpenAI และใช้ await กับการเรียก API แต่ละครั้ง:

 import os
import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI (
    api_key = os . environ . get ( "OPENAI_API_KEY" ),  # This is the default and can be omitted
)


async def main () -> None :
    chat_completion = await client . chat . completions . create (
        messages = [
            {
                "role" : "user" ,
                "content" : "Say this is a test" ,
            }
        ],
        model = "gpt-4o" ,
    )


asyncio . run ( main ())

ฟังก์ชันการทำงานระหว่างไคลเอ็นต์ซิงโครนัสและอะซิงโครนัสจะเหมือนกัน

การตอบกลับแบบสตรีมมิ่ง

เราให้การสนับสนุนสำหรับการสตรีมการตอบสนองโดยใช้ Server Side Events (SSE)

 from openai import OpenAI

client = OpenAI ()

stream = client . chat . completions . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "Say this is a test" ,
        }
    ],
    model = "gpt-4o" ,
    stream = True ,
)
for chunk in stream :
    print ( chunk . choices [ 0 ]. delta . content or "" , end = "" )

ไคลเอนต์ async ใช้อินเทอร์เฟซเดียวกันทุกประการ

 import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI ()


async def main ():
    stream = await client . chat . completions . create (
        model = "gpt-4" ,
        messages = [{ "role" : "user" , "content" : "Say this is a test" }],
        stream = True ,
    )
    async for chunk in stream :
        print ( chunk . choices [ 0 ]. delta . content or "" , end = "" )


asyncio . run ( main ())

ไคลเอนต์ระดับโมดูล

สำคัญ

เราขอแนะนำอย่างยิ่งให้สร้างอินสแตนซ์ไคลเอนต์แทนการพึ่งพาไคลเอนต์ทั่วโลก

นอกจากนี้เรายังเปิดเผยอินสแตนซ์ไคลเอ็นต์ทั่วโลกที่สามารถเข้าถึงได้ในลักษณะเดียวกันกับเวอร์ชันก่อนเวอร์ชัน 1

 import openai

# optional; defaults to `os.environ['OPENAI_API_KEY']`
openai . api_key = '...'

# all client options can be configured just like the `OpenAI` instantiation counterpart
openai . base_url = "https://..."
openai . default_headers = { "x-foo" : "true" }

completion = openai . chat . completions . create (
    model = "gpt-4o" ,
    messages = [
        {
            "role" : "user" ,
            "content" : "How do I output all files in a directory using Python?" ,
        },
    ],
)
print ( completion . choices [ 0 ]. message . content )

API นั้นเหมือนกับ API ตามอินสแตนซ์ไคลเอนต์มาตรฐานทุกประการ

สิ่งนี้มีวัตถุประสงค์เพื่อใช้ภายใน REPL หรือโน้ตบุ๊กเพื่อการวนซ้ำที่เร็วขึ้น ไม่ใช่ ในโค้ดของแอปพลิเคชัน

เราขอแนะนำให้คุณสร้างอินสแตนซ์ไคลเอ็นต์ (เช่น ด้วย client = OpenAI() ) ในโค้ดแอปพลิเคชันเสมอ เนื่องจาก:

อาจเป็นเรื่องยากที่จะให้เหตุผลว่าตัวเลือกไคลเอนต์ได้รับการกำหนดค่าไว้ที่ใด
ไม่สามารถเปลี่ยนตัวเลือกไคลเอนต์บางตัวได้โดยไม่ทำให้เกิดสภาวะการแข่งขัน
เป็นการยากที่จะเยาะเย้ยเพื่อการทดสอบ
ไม่สามารถควบคุมการล้างข้อมูลการเชื่อมต่อเครือข่ายได้

การใช้ประเภท

พารามิเตอร์คำขอที่ซ้อนกันคือ TypedDicts การตอบสนองเป็นโมเดล Pydantic ซึ่งมีวิธีการช่วยเหลือสำหรับสิ่งต่าง ๆ เช่น:

การทำให้เป็นอนุกรมกลับเข้าไปใน JSON, model.to_json()
การแปลงเป็นพจนานุกรม model.to_dict()

คำขอและการตอบกลับที่พิมพ์จะมีการเติมข้อความอัตโนมัติและเอกสารภายในโปรแกรมแก้ไขของคุณ หากคุณต้องการดูข้อผิดพลาดประเภทใน VS Code เพื่อช่วยตรวจจับจุดบกพร่องได้เร็วขึ้น ให้ตั้งค่า python.analysis.typeCheckingMode เป็น basic

การแบ่งหน้า

แสดงรายการวิธีการใน OpenAI API เป็นแบบแบ่งหน้า

ไลบรารีนี้จัดให้มีตัววนซ้ำแบบแบ่งหน้าอัตโนมัติพร้อมการตอบกลับแต่ละรายการ ดังนั้นคุณจึงไม่จำเป็นต้องขอเพจต่อเนื่องกันด้วยตนเอง:

 from openai import OpenAI

client = OpenAI ()

all_jobs = []
# Automatically fetches more pages as needed.
for job in client . fine_tuning . jobs . list (
    limit = 20 ,
):
    # Do something with job here
    all_jobs . append ( job )
print ( all_jobs )

หรือแบบอะซิงโครนัส:

 import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI ()


async def main () -> None :
    all_jobs = []
    # Iterate through items across all pages, issuing requests as needed.
    async for job in client . fine_tuning . jobs . list (
        limit = 20 ,
    ):
        all_jobs . append ( job )
    print ( all_jobs )


asyncio . run ( main ())

หรือคุณสามารถใช้เมธอด .has_next_page() , .next_page_info() หรือ .get_next_page() เพื่อควบคุมการทำงานกับเพจที่ละเอียดยิ่งขึ้น:

 first_page = await client . fine_tuning . jobs . list (
    limit = 20 ,
)
if first_page . has_next_page ():
    print ( f"will fetch next page using these details: { first_page . next_page_info () } " )
    next_page = await first_page . get_next_page ()
    print ( f"number of items we just fetched: { len ( next_page . data ) } " )

# Remove `await` for non-async usage.

หรือเพียงทำงานโดยตรงกับข้อมูลที่ส่งคืน:

 first_page = await client . fine_tuning . jobs . list (
    limit = 20 ,
)

print ( f"next page cursor: { first_page . after } " )  # => "next page cursor: ..."
for job in first_page . data :
    print ( job . id )

# Remove `await` for non-async usage.

พารามิเตอร์ที่ซ้อนกัน

พารามิเตอร์ที่ซ้อนกันคือพจนานุกรมที่พิมพ์โดยใช้ TypedDict เช่น:

 from openai import OpenAI

client = OpenAI ()

completion = client . chat . completions . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "Can you generate an example json object describing a fruit?" ,
        }
    ],
    model = "gpt-4o" ,
    response_format = { "type" : "json_object" },
)

การอัพโหลดไฟล์

พารามิเตอร์คำขอที่สอดคล้องกับการอัปโหลดไฟล์สามารถส่งผ่านเป็น bytes อินสแตนซ์ PathLike หรือทูเพิลของ (filename, contents, media type)

 from pathlib import Path
from openai import OpenAI

client = OpenAI ()

client . files . create (
    file = Path ( "input.jsonl" ),
    purpose = "fine-tune" ,
)

ไคลเอนต์ async ใช้อินเทอร์เฟซเดียวกันทุกประการ หากคุณผ่านอินสแตนซ์ PathLike เนื้อหาไฟล์จะถูกอ่านแบบอะซิงโครนัสโดยอัตโนมัติ

การจัดการข้อผิดพลาด

เมื่อไลบรารีไม่สามารถเชื่อมต่อกับ API ได้ (เช่น เนื่องจากปัญหาการเชื่อมต่อเครือข่ายหรือการหมดเวลา) คลาสย่อยของ openai.APIConnectionError จะเพิ่มขึ้น

เมื่อ API ส่งคืนรหัสสถานะที่ไม่สำเร็จ (นั่นคือ การตอบสนอง 4xx หรือ 5xx) คลาสย่อยของ openai.APIStatusError จะถูกยกขึ้น โดยมีคุณสมบัติ status_code และ response

ข้อผิดพลาดทั้งหมดสืบทอดมาจาก openai.APIError

 import openai
from openai import OpenAI

client = OpenAI ()

try :
    client . fine_tuning . jobs . create (
        model = "gpt-4o" ,
        training_file = "file-abc123" ,
    )
except openai . APIConnectionError as e :
    print ( "The server could not be reached" )
    print ( e . __cause__ )  # an underlying Exception, likely raised within httpx.
except openai . RateLimitError as e :
    print ( "A 429 status code was received; we should back off a bit." )
except openai . APIStatusError as e :
    print ( "Another non-200-range status code was received" )
    print ( e . status_code )
    print ( e . response )

รหัสข้อผิดพลาดมีดังนี้:

รหัสสถานะ	ประเภทข้อผิดพลาด
400	`BadRequestError`
401	`AuthenticationError`
403	`PermissionDeniedError`
404	`NotFoundError`
422	`UnprocessableEntityError`
429	`RateLimitError`
>=500	`InternalServerError`
ไม่มี	`APIConnectionError`

ขอไอดี

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับคำขอแก้ไขข้อบกพร่อง โปรดดูเอกสารเหล่านี้

การตอบสนองของออบเจ็กต์ทั้งหมดใน SDK มีคุณสมบัติ _request_id ซึ่งเพิ่มจากส่วนหัวการตอบสนอง x-request-id เพื่อให้คุณสามารถบันทึกคำขอที่ล้มเหลวได้อย่างรวดเร็วและรายงานกลับไปยัง OpenAI

 completion = await client . chat . completions . create (
    messages = [{ "role" : "user" , "content" : "Say this is a test" }], model = "gpt-4"
)
print ( completion . _request_id )  # req_123

โปรดทราบว่าคุณสมบัติ _request_id ไม่เหมือนกับคุณสมบัติอื่นๆ ที่ใช้คำนำหน้า _ ตรง ที่เป็น คุณสมบัติสาธารณะ เว้นแต่จะระบุไว้เป็นอย่างอื่น คุณสมบัติ _ คำนำหน้า วิธีการ และโมดูลอื่นๆ ทั้งหมด จะเป็น แบบส่วนตัว

ลองอีกครั้ง

ข้อผิดพลาดบางอย่างจะมีการลองใหม่โดยอัตโนมัติ 2 ครั้งตามค่าเริ่มต้น โดยมีการถอยกลับแบบเอ็กซ์โพเนนเชียลสั้นๆ ข้อผิดพลาดในการเชื่อมต่อ (เช่น เนื่องจากปัญหาการเชื่อมต่อเครือข่าย), 408 Request Timeout, 409 Conflict, 429 Rate Limit และ >=500 Internal error จะถูกลองใหม่ทั้งหมดตามค่าเริ่มต้น

คุณสามารถใช้ตัวเลือก max_retries เพื่อกำหนดค่าหรือปิดใช้งานการตั้งค่าลองใหม่:

 from openai import OpenAI

# Configure the default for all requests:
client = OpenAI (
    # default is 2
    max_retries = 0 ,
)

# Or, configure per-request:
client . with_options ( max_retries = 5 ). chat . completions . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "How can I get the name of the current day in JavaScript?" ,
        }
    ],
    model = "gpt-4o" ,
)

หมดเวลา

ตามค่าเริ่มต้น คำขอจะหมดเวลาหลังจาก 10 นาที คุณสามารถกำหนดค่านี้ด้วยตัวเลือก timeout ซึ่งยอมรับวัตถุลอยหรือ httpx.Timeout :

 from openai import OpenAI

# Configure the default for all requests:
client = OpenAI (
    # 20 seconds (default is 10 minutes)
    timeout = 20.0 ,
)

# More granular control:
client = OpenAI (
    timeout = httpx . Timeout ( 60.0 , read = 5.0 , write = 10.0 , connect = 2.0 ),
)

# Override per-request:
client . with_options ( timeout = 5.0 ). chat . completions . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "How can I list all files in a directory using Python?" ,
        }
    ],
    model = "gpt-4o" ,
)

เมื่อหมดเวลา APITimeoutError จะถูกส่งออกไป

โปรดทราบว่าคำขอหมดเวลานั้นจะมีการลองใหม่สองครั้งตามค่าเริ่มต้น

ขั้นสูง

การบันทึก

เราใช้โมดูล logging ไลบรารีมาตรฐาน

คุณสามารถเปิดใช้งานการบันทึกได้โดยตั้งค่าตัวแปรสภาพแวดล้อม OPENAI_LOG เป็น info

$ export OPENAI_LOG=info

หรือเพื่อ debug สำหรับการบันทึกแบบละเอียดมากขึ้น

จะบอกได้อย่างไรว่า `None` หมายความว่า `null` หรือหายไป

ในการตอบกลับของ API ฟิลด์อาจเป็น null อย่างชัดเจน หรือหายไปทั้งหมด ไม่ว่าในกรณีใด ค่าของมันคือ None ในไลบรารีนี้ คุณสามารถแยกความแตกต่างทั้งสองกรณีได้ด้วย .model_fields_set :

 if response . my_field is None :
  if 'my_field' not in response . model_fields_set :
    print ( 'Got json like {}, without a "my_field" key present at all.' )
  else :
    print ( 'Got json like {"my_field": null}.' )

การเข้าถึงข้อมูลตอบกลับดิบ (เช่น ส่วนหัว)

สามารถเข้าถึงออบเจ็กต์การตอบสนอง "ดิบ" ได้โดยใส่คำนำหน้า .with_raw_response. ไปยังการเรียกเมธอด HTTP ใด ๆ เช่น

 from openai import OpenAI

client = OpenAI ()
response = client . chat . completions . with_raw_response . create (
    messages = [{
        "role" : "user" ,
        "content" : "Say this is a test" ,
    }],
    model = "gpt-4o" ,
)
print ( response . headers . get ( 'X-My-Header' ))

completion = response . parse ()  # get the object that `chat.completions.create()` would have returned
print ( completion )

วิธีการเหล่านี้ส่งคืนวัตถุ LegacyAPIResponse นี่คือคลาสดั้งเดิมเนื่องจากเรากำลังเปลี่ยนแปลงเล็กน้อยในเวอร์ชันหลักถัดไป

สำหรับไคลเอ็นต์การซิงค์ ส่วนใหญ่จะเหมือนกัน ยกเว้น content และ text จะเป็นวิธีการแทนคุณสมบัติ ในไคลเอนต์ async วิธีการทั้งหมดจะเป็นแบบอะซิงก์

จะมีการจัดเตรียมสคริปต์การย้ายข้อมูล & การย้ายข้อมูลโดยทั่วไปควรจะราบรื่น

`.with_streaming_response`

อินเทอร์เฟซด้านบนจะอ่านเนื้อหาการตอบกลับแบบเต็มอย่างกระตือรือร้นเมื่อคุณส่งคำขอ ซึ่งอาจไม่ใช่สิ่งที่คุณต้องการเสมอไป

หากต้องการสตรีมเนื้อหาการตอบกลับ ให้ใช้ .with_streaming_response แทน ซึ่งต้องใช้ตัวจัดการบริบทและอ่านเฉพาะเนื้อหาการตอบกลับเมื่อคุณเรียก .read() , .text() , .json() , .iter_bytes() , .iter_text() , .iter_lines() หรือ .parse() ในไคลเอ็นต์ async วิธีเหล่านี้เป็นวิธีการแบบ async

ด้วยเหตุนี้ เมธอด .with_streaming_response จึงส่งคืนออบเจ็กต์ APIResponse อื่น และไคลเอ็นต์ async จะส่งคืนออบเจ็กต์ AsyncAPIResponse

 with client . chat . completions . with_streaming_response . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "Say this is a test" ,
        }
    ],
    model = "gpt-4o" ,
) as response :
    print ( response . headers . get ( "X-My-Header" ))

    for line in response . iter_lines ():
        print ( line )

จำเป็นต้องมีตัวจัดการบริบทเพื่อให้สามารถปิดการตอบกลับได้อย่างน่าเชื่อถือ

ทำการร้องขอแบบกำหนดเอง/ไม่มีเอกสาร

ไลบรารีนี้ถูกพิมพ์เพื่อความสะดวกในการเข้าถึง API ที่จัดทำเอกสาร

หากคุณต้องการเข้าถึงตำแหน่งข้อมูล พารามิเตอร์ หรือคุณสมบัติการตอบสนองที่ไม่มีเอกสาร ไลบรารียังคงสามารถใช้งานได้

จุดสิ้นสุดที่ไม่มีเอกสาร

หากต้องการส่งคำขอไปยังตำแหน่งข้อมูลที่ไม่มีเอกสาร คุณสามารถสร้างคำขอโดยใช้ client.get , client.post และกริยา http อื่นๆ ตัวเลือกบนไคลเอนต์จะได้รับการเคารพ (เช่นการลองใหม่) จะถูกเคารพเมื่อทำการร้องขอนี้

 import httpx

response = client . post (
    "/foo" ,
    cast_to = httpx . Response ,
    body = { "my_param" : True },
)

print ( response . headers . get ( "x-foo" ))

พารามิเตอร์คำขอที่ไม่มีเอกสาร

หากคุณต้องการส่งพารามิเตอร์เพิ่มเติมอย่างชัดเจน คุณสามารถทำได้โดยใช้ตัวเลือกคำขอ extra_query , extra_body และ extra_headers

คุณสมบัติการตอบกลับที่ไม่มีเอกสาร

หากต้องการเข้าถึงคุณสมบัติการตอบกลับที่ไม่มีเอกสาร คุณสามารถเข้าถึงฟิลด์พิเศษ เช่น response.unknown_prop คุณยังสามารถรับฟิลด์พิเศษทั้งหมดในโมเดล Pydantic ในรูปแบบ dict ด้วย response.model_extra

การกำหนดค่าไคลเอ็นต์ HTTP

คุณสามารถแทนที่ไคลเอ็นต์ httpx ได้โดยตรงเพื่อปรับแต่งให้เหมาะกับกรณีการใช้งานของคุณ ซึ่งรวมถึง:

การสนับสนุนผู้รับมอบฉันทะ
การขนส่งแบบกำหนดเอง
ฟังก์ชั่นขั้นสูงเพิ่มเติม

 from openai import OpenAI , DefaultHttpxClient

client = OpenAI (
    # Or use the `OPENAI_BASE_URL` env var
    base_url = "http://my.test.server.example.com:8083/v1" ,
    http_client = DefaultHttpxClient (
        proxies = "http://my.test.proxy.example.com" ,
        transport = httpx . HTTPTransport ( local_address = "0.0.0.0" ),
    ),
)

คุณยังสามารถปรับแต่งไคลเอนต์ตามคำขอได้โดยใช้ with_options() :

 client . with_options ( http_client = DefaultHttpxClient (...))

การจัดการทรัพยากร HTTP

ตามค่าเริ่มต้น ไลบรารีจะปิดการเชื่อมต่อ HTTP พื้นฐานเมื่อใดก็ตามที่ไคลเอ็นต์ถูกรวบรวมแบบขยะ คุณสามารถปิดไคลเอ็นต์ได้ด้วยตนเองโดยใช้เมธอด .close() หากต้องการ หรือใช้ตัวจัดการบริบทที่ปิดเมื่อออก

ไมโครซอฟต์ อาซัวร์ โอเพ่นเอไอ

หากต้องการใช้ไลบรารีนี้กับ Azure OpenAI ให้ใช้คลาส AzureOpenAI แทนคลาส OpenAI

สำคัญ

รูปร่าง Azure API แตกต่างจากรูปร่าง API หลัก ซึ่งหมายความว่าประเภทคงที่สำหรับการตอบกลับ / พารามิเตอร์จะไม่ถูกต้องเสมอไป

 from openai import AzureOpenAI

# gets the API Key from environment variable AZURE_OPENAI_API_KEY
client = AzureOpenAI (
    # https://learn.microsoft.com/azure/ai-services/openai/reference#rest-api-versioning
    api_version = "2023-07-01-preview" ,
    # https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource
    azure_endpoint = "https://example-endpoint.openai.azure.com" ,
)

completion = client . chat . completions . create (
    model = "deployment-name" ,  # e.g. gpt-35-instant
    messages = [
        {
            "role" : "user" ,
            "content" : "How do I output all files in a directory using Python?" ,
        },
    ],
)
print ( completion . to_json ())

นอกเหนือจากตัวเลือกที่มีให้ในไคลเอนต์ OpenAI พื้นฐานแล้ว ยังมีตัวเลือกต่อไปนี้อีกด้วย:

azure_endpoint (หรือตัวแปรสภาพแวดล้อม AZURE_OPENAI_ENDPOINT )
azure_deployment
api_version (หรือตัวแปรสภาพแวดล้อม OPENAI_API_VERSION )
azure_ad_token (หรือตัวแปรสภาพแวดล้อม AZURE_OPENAI_AD_TOKEN )
azure_ad_token_provider

คุณสามารถดูตัวอย่างการใช้ไคลเอ็นต์กับ Microsoft Entra ID (เดิมชื่อ Azure Active Directory) ได้ที่นี่

การกำหนดเวอร์ชัน

โดยทั่วไปแพ็คเกจนี้เป็นไปตามแบบแผนของ SemVer แม้ว่าการเปลี่ยนแปลงที่เข้ากันไม่ได้แบบย้อนหลังบางอย่างอาจถูกเผยแพร่เป็นเวอร์ชันรอง:

การเปลี่ยนแปลงที่ส่งผลต่อประเภทคงที่เท่านั้น โดยไม่ทำลายพฤติกรรมรันไทม์
การเปลี่ยนแปลงภายในห้องสมุดซึ่งเป็นสาธารณะทางเทคนิค แต่ไม่ได้มีวัตถุประสงค์หรือจัดทำเป็นเอกสารสำหรับการใช้งานภายนอก (โปรดเปิดปัญหา GitHub เพื่อแจ้งให้เราทราบหากคุณพึ่งพาข้อมูลภายในดังกล่าว)
การเปลี่ยนแปลงที่เราไม่คาดว่าจะส่งผลกระทบต่อผู้ใช้ส่วนใหญ่ในทางปฏิบัติ

เราให้ความสำคัญกับความเข้ากันได้แบบย้อนหลังอย่างจริงจังและทำงานอย่างหนักเพื่อให้แน่ใจว่าคุณสามารถไว้วางใจในประสบการณ์การอัปเกรดที่ราบรื่น

เรากระตือรือร้นที่จะรับฟังความคิดเห็นของคุณ โปรดเปิดประเด็นที่มีคำถาม ข้อบกพร่อง หรือข้อเสนอแนะ

การกำหนดเวอร์ชันที่ติดตั้ง

หากคุณอัปเกรดเป็นเวอร์ชันล่าสุดแล้ว แต่ไม่เห็นฟีเจอร์ใหม่ใดๆ ที่คุณคาดหวัง แสดงว่าสภาพแวดล้อม Python ของคุณน่าจะยังคงใช้เวอร์ชันเก่าอยู่

คุณสามารถระบุเวอร์ชันที่ใช้งานขณะรันไทม์ได้ด้วย:

 import openai
print ( openai . __version__ )

ความต้องการ

Python 3.8 หรือสูงกว่า

มีส่วนร่วม

ดูเอกสารประกอบ

ขยาย

openai python

ไลบรารี OpenAI Python API

เอกสารประกอบ

การติดตั้ง

การใช้งาน

วิสัยทัศน์

ผู้ช่วยหน่วยเลือกตั้ง

ตัวช่วยอัปโหลดจำนวนมาก

ตัวช่วยสตรีมมิ่ง

การใช้งานแบบอะซิงโครนัส

การตอบกลับแบบสตรีมมิ่ง

ไคลเอนต์ระดับโมดูล

การใช้ประเภท

การแบ่งหน้า

พารามิเตอร์ที่ซ้อนกัน

การอัพโหลดไฟล์

การจัดการข้อผิดพลาด

ขอไอดี

ลองอีกครั้ง

หมดเวลา

ขั้นสูง

การบันทึก

จะบอกได้อย่างไรว่า None หมายความว่า null หรือหายไป

การเข้าถึงข้อมูลตอบกลับดิบ (เช่น ส่วนหัว)

.with_streaming_response

ทำการร้องขอแบบกำหนดเอง/ไม่มีเอกสาร

จุดสิ้นสุดที่ไม่มีเอกสาร

พารามิเตอร์คำขอที่ไม่มีเอกสาร

คุณสมบัติการตอบกลับที่ไม่มีเอกสาร

การกำหนดค่าไคลเอ็นต์ HTTP

การจัดการทรัพยากร HTTP

ไมโครซอฟต์ อาซัวร์ โอเพ่นเอไอ

การกำหนดเวอร์ชัน

การกำหนดเวอร์ชันที่ติดตั้ง

ความต้องการ

มีส่วนร่วม

จะบอกได้อย่างไรว่า `None` หมายความว่า `null` หรือหายไป

`.with_streaming_response`