Миграция в библиотеку API OpenAI Python 1.x

Статья
10/16/2024

OpenAI выпустила новую версию библиотеки API OpenAI Python. Это руководство является дополнением к руководству по миграции OpenAI и поможет вам ускорить изменения, относящиеся к Azure OpenAI.

Обновления

Это новая версия библиотеки API OpenAI Python.
Начиная с 6 ноября 2023 pip install openai г. и pip install openai --upgrade установит version 1.x библиотеку OpenAI Python.
Обновление с version 0.28.1 version 1.x момента критического изменения необходимо протестировать и обновить код.
Автоматическое повторение с обратным отключением при возникновении ошибки
Правильные типы (для mypy/pyright/editors)
Теперь можно создать экземпляр клиента вместо использования глобального по умолчанию.
Переключение на явное создание экземпляра клиента
Изменения имени

Известные проблемы

DALL-E3 полностью поддерживается в последнем выпуске версии 1.x.DALL-E2 можно использовать с 1.x, выполнив следующие изменения в коде.
embeddings_utils.py который использовался для предоставления функций, таких как сходство косинуса для семантического поиска текста, больше не является частью библиотеки API OpenAI Python.
Также следует проверить активные проблемы GitHub для библиотеки OpenAI Python.

Тестирование перед миграцией

Внимание

Автоматическая миграция используемого openai migrate кода не поддерживается в Azure OpenAI.

Так как это новая версия библиотеки с критическими изменениями, необходимо тщательно протестировать код перед переносом всех рабочих приложений, чтобы использовать версию 1.x. Вы также должны просмотреть код и внутренние процессы, чтобы убедиться, что вы выполняете рекомендации и закрепляете рабочий код только к версиям, которые вы полностью тестировали.

Чтобы упростить процесс миграции, мы обновляем существующие примеры кода в наших документах для Python на вкладках:

OpenAI Python 1.x
OpenAI Python 0.28.1

pip install openai --upgrade

pip install openai==0.28.1

Это предоставляет контекст для изменений и позволяет параллельно протестировать новую библиотеку, продолжая поддерживать версию 0.28.1. Если вы обновляете 1.x и понимаете, что вам нужно временно вернуться к предыдущей версии, можно всегда pip uninstall openai и переустановить целевой 0.28.1 объект.pip install openai==0.28.1

Для переменной необходимо задать model имя развертывания, выбранное при развертывании моделей GPT-3.5-Turbo или GPT-4. При вводе имени модели возникает ошибка, если вы не выбрали имя развертывания, идентичное имени базовой модели.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
  api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version="2024-02-01"
)

response = client.chat.completions.create(
    model="gpt-35-turbo", # model = "deployment_name"
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response.choices[0].message.content)

Дополнительные примеры можно найти в нашей подробной статье о завершении чата.

Для переменной необходимо задать engine имя развертывания, выбранное при развертывании моделей GPT-3.5-Turbo или GPT-4. Ввод имени модели приведет к ошибке, если вы не выбрали имя развертывания, идентичное имени базовой модели.

import os
import openai
openai.api_type = "azure"
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") 
openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_version = "2024-02-01"

response = openai.ChatCompletion.create(
    engine="gpt-35-turbo", # engine = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response)
print(response['choices'][0]['message']['content'])

Автозавершения

OpenAI Python 1.x
OpenAI Python 0.28.1

import os
from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-02-01",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
)
    
deployment_name='REPLACE_WITH_YOUR_DEPLOYMENT_NAME' #This will correspond to the custom name you chose for your deployment when you deployed a model. 
    
# Send a completion call to generate an answer
print('Sending a test completion job')
start_phrase = 'Write a tagline for an ice cream shop. '
response = client.completions.create(model=deployment_name, prompt=start_phrase, max_tokens=10) # model = "deployment_name"
print(response.choices[0].text)

import os
import openai

openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
openai.api_type = 'azure'
openai.api_version = '2024-02-01' # this might change in the future

deployment_name='REPLACE_WITH_YOUR_DEPLOYMENT_NAME' #This will correspond to the custom name you chose for your deployment when you deployed a model. 

# Send a completion call to generate an answer
print('Sending a test completion job')
start_phrase = 'Write a tagline for an ice cream shop. '
response = openai.Completion.create(engine=deployment_name, prompt=start_phrase, max_tokens=10)
text = response['choices'][0]['text'].replace('\n', '').replace(' .', '.').strip()
print(start_phrase+text)

Внедрение

OpenAI Python 1.x
OpenAI Python 0.28.1

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-02-01",
  azure_endpoint =os.getenv("AZURE_OPENAI_ENDPOINT") 
)

response = client.embeddings.create(
    input = "Your text string goes here",
    model= "text-embedding-ada-002"  # model = "deployment_name".
)

print(response.model_dump_json(indent=2))

Дополнительные примеры, включая обработку семантического поиска текста без embeddings_utils.py возможности найти в руководстве по внедрению.

import openai

openai.api_type = "azure"
openai.api_key = YOUR_API_KEY
openai.api_base = "https://YOUR_RESOURCE_NAME.openai.azure.com"
openai.api_version = "2024-02-01"

response = openai.Embedding.create(
    input="Your text string goes here",
    engine="YOUR_DEPLOYMENT_NAME"
)
embeddings = response['data'][0]['embedding']
print(embeddings)

Асинхронная

OpenAI не поддерживает вызов асинхронных методов в клиенте уровня модуля, а вместо этого следует создать экземпляр асинхронного клиента.

import os
import asyncio
from openai import AsyncAzureOpenAI

async def main():
    client = AsyncAzureOpenAI(  
      api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
      api_version = "2024-02-01",
      azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )
    response = await client.chat.completions.create(model="gpt-35-turbo", messages=[{"role": "user", "content": "Hello world"}]) # model = model deployment name

    print(response.model_dump_json(indent=2))

asyncio.run(main())

Проверка подлинности

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

token_provider = get_bearer_token_provider(DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default")

api_version = "2024-02-01"
endpoint = "https://my-resource.openai.azure.com"

client = AzureOpenAI(
    api_version=api_version,
    azure_endpoint=endpoint,
    azure_ad_token_provider=token_provider,
)

completion = client.chat.completions.create(
    model="deployment-name",  # model = "deployment_name"
    messages=[
        {
            "role": "user",
            "content": "How do I output all files in a directory using Python?",
        },
    ],
)
print(completion.model_dump_json(indent=2))

Использование данных

Полные действия по настройке, необходимые для работы этих примеров кода, см. в кратком руководстве по использованию данных.

OpenAI Python 1.x
OpenAI Python 0.28.1

import os
import openai
import dotenv

dotenv.load_dotenv()

endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
api_key = os.environ.get("AZURE_OPENAI_API_KEY")
deployment = os.environ.get("AZURE_OPEN_AI_DEPLOYMENT_ID")

client = openai.AzureOpenAI(
    base_url=f"{endpoint}/openai/deployments/{deployment}/extensions",
    api_key=api_key,
    api_version="2023-08-01-preview",
)

completion = client.chat.completions.create(
    model=deployment, # model = "deployment_name"
    messages=[
        {
            "role": "user",
            "content": "How is Azure machine learning different than Azure OpenAI?",
        },
    ],
    extra_body={
        "dataSources": [
            {
                "type": "AzureCognitiveSearch",
                "parameters": {
                    "endpoint": os.environ["AZURE_AI_SEARCH_ENDPOINT"],
                    "key": os.environ["AZURE_AI_SEARCH_API_KEY"],
                    "indexName": os.environ["AZURE_AI_SEARCH_INDEX"]
                }
            }
        ]
    }
)

print(completion.model_dump_json(indent=2))

import os
import openai
import dotenv
import requests

dotenv.load_dotenv()

openai.api_base = os.environ.get("AZURE_OPENAI_ENDPOINT")
openai.api_version = "2023-08-01-preview"
openai.api_type = 'azure'
openai.api_key = os.environ.get("AZURE_OPENAI_API_KEY")

def setup_byod(deployment_id: str) -> None:
    """Sets up the OpenAI Python SDK to use your own data for the chat endpoint.

    :param deployment_id: The deployment ID for the model to use with your own data.

    To remove this configuration, simply set openai.requestssession to None.
    """

    class BringYourOwnDataAdapter(requests.adapters.HTTPAdapter):

     def send(self, request, **kwargs):
         request.url = f"{openai.api_base}/openai/deployments/{deployment_id}/extensions/chat/completions?api-version={openai.api_version}"
         return super().send(request, **kwargs)

    session = requests.Session()

    # Mount a custom adapter which will use the extensions endpoint for any call using the given `deployment_id`
    session.mount(
        prefix=f"{openai.api_base}/openai/deployments/{deployment_id}",
        adapter=BringYourOwnDataAdapter()
    )

    openai.requestssession = session

aoai_deployment_id = os.environ.get("AZURE_OPEN_AI_DEPLOYMENT_ID")
setup_byod(aoai_deployment_id)

completion = openai.ChatCompletion.create(
    messages=[{"role": "user", "content": "What are the differences between Azure Machine Learning and Azure AI services?"}],
    deployment_id=os.environ.get("AZURE_OPEN_AI_DEPLOYMENT_ID"),
    dataSources=[  # camelCase is intentional, as this is the format the API expects
        {
            "type": "AzureCognitiveSearch",
            "parameters": {
                "endpoint": os.environ.get("AZURE_AI_SEARCH_ENDPOINT"),
                "key": os.environ.get("AZURE_AI_SEARCH_API_KEY"),
                "indexName": os.environ.get("AZURE_AI_SEARCH_INDEX"),
            }
        }
    ]
)
print(completion)

Исправление DALL-E

DALLE-Fix
DALLE-Fix Async

import time
import json
import httpx
import openai


class CustomHTTPTransport(httpx.HTTPTransport):
    def handle_request(
        self,
        request: httpx.Request,
    ) -> httpx.Response:
        if "images/generations" in request.url.path and request.url.params[
            "api-version"
        ] in [
            "2023-06-01-preview",
            "2023-07-01-preview",
            "2023-08-01-preview",
            "2023-09-01-preview",
            "2023-10-01-preview",
        ]:
            request.url = request.url.copy_with(path="/openai/images/generations:submit")
            response = super().handle_request(request)
            operation_location_url = response.headers["operation-location"]
            request.url = httpx.URL(operation_location_url)
            request.method = "GET"
            response = super().handle_request(request)
            response.read()

            timeout_secs: int = 120
            start_time = time.time()
            while response.json()["status"] not in ["succeeded", "failed"]:
                if time.time() - start_time > timeout_secs:
                    timeout = {"error": {"code": "Timeout", "message": "Operation polling timed out."}}
                    return httpx.Response(
                        status_code=400,
                        headers=response.headers,
                        content=json.dumps(timeout).encode("utf-8"),
                        request=request,
                    )

                time.sleep(int(response.headers.get("retry-after")) or 10)
                response = super().handle_request(request)
                response.read()

            if response.json()["status"] == "failed":
                error_data = response.json()
                return httpx.Response(
                    status_code=400,
                    headers=response.headers,
                    content=json.dumps(error_data).encode("utf-8"),
                    request=request,
                )

            result = response.json()["result"]
            return httpx.Response(
                status_code=200,
                headers=response.headers,
                content=json.dumps(result).encode("utf-8"),
                request=request,
            )
        return super().handle_request(request)


client = openai.AzureOpenAI(
    azure_endpoint="<azure_endpoint>",
    api_key="<api_key>",
    api_version="<api_version>",
    http_client=httpx.Client(
        transport=CustomHTTPTransport(),
    ),
)
image = client.images.generate(prompt="a cute baby seal")

print(image.data[0].url)

import time
import asyncio
import json
import httpx
import openai


class AsyncCustomHTTPTransport(httpx.AsyncHTTPTransport):
    async def handle_async_request(
        self,
        request: httpx.Request,
    ) -> httpx.Response:
        if "images/generations" in request.url.path and request.url.params[
            "api-version"
        ] in [
            "2023-06-01-preview",
            "2023-07-01-preview",
            "2023-08-01-preview",
            "2023-09-01-preview",
            "2023-10-01-preview",
        ]:
            request.url = request.url.copy_with(path="/openai/images/generations:submit")
            response = await super().handle_async_request(request)
            operation_location_url = response.headers["operation-location"]
            request.url = httpx.URL(operation_location_url)
            request.method = "GET"
            response = await super().handle_async_request(request)
            await response.aread()

            timeout_secs: int = 120
            start_time = time.time()
            while response.json()["status"] not in ["succeeded", "failed"]:
                if time.time() - start_time > timeout_secs:
                    timeout = {"error": {"code": "Timeout", "message": "Operation polling timed out."}}
                    return httpx.Response(
                        status_code=400,
                        headers=response.headers,
                        content=json.dumps(timeout).encode("utf-8"),
                        request=request,
                    )

                await asyncio.sleep(int(response.headers.get("retry-after")) or 10)
                response = await super().handle_async_request(request)
                await response.aread()

            if response.json()["status"] == "failed":
                error_data = response.json()
                return httpx.Response(
                    status_code=400,
                    headers=response.headers,
                    content=json.dumps(error_data).encode("utf-8"),
                    request=request,
                )

            result = response.json()["result"]
            return httpx.Response(
                status_code=200,
                headers=response.headers,
                content=json.dumps(result).encode("utf-8"),
                request=request,
            )
        return await super().handle_async_request(request)


async def dall_e():
    client = openai.AsyncAzureOpenAI(
        azure_endpoint="<azure_endpoint>",
        api_key="<api_key>",
        api_version="<api_version>",
        http_client=httpx.AsyncClient(
            transport=AsyncCustomHTTPTransport(),
        ),
    )
    image = await client.images.generate(prompt="a cute baby seal")

    print(image.data[0].url)

asyncio.run(dall_e())

Изменения имени

Примечание.

Все методы a* удалены; Вместо этого необходимо использовать асинхронный клиент.

OpenAI Python 0.28.1	OpenAI Python 1.x
`openai.api_base`	`openai.base_url`
`openai.proxy`	`openai.proxies`
`openai.InvalidRequestError`	`openai.BadRequestError`
`openai.Audio.transcribe()`	`client.audio.transcriptions.create()`
`openai.Audio.translate()`	`client.audio.translations.create()`
`openai.ChatCompletion.create()`	`client.chat.completions.create()`
`openai.Completion.create()`	`client.completions.create()`
`openai.Edit.create()`	`client.edits.create()`
`openai.Embedding.create()`	`client.embeddings.create()`
`openai.File.create()`	`client.files.create()`
`openai.File.list()`	`client.files.list()`
`openai.File.retrieve()`	`client.files.retrieve()`
`openai.File.download()`	`client.files.retrieve_content()`
`openai.FineTune.cancel()`	`client.fine_tunes.cancel()`
`openai.FineTune.list()`	`client.fine_tunes.list()`
`openai.FineTune.list_events()`	`client.fine_tunes.list_events()`
`openai.FineTune.stream_events()`	`client.fine_tunes.list_events(stream=True)`
`openai.FineTune.retrieve()`	`client.fine_tunes.retrieve()`
`openai.FineTune.delete()`	`client.fine_tunes.delete()`
`openai.FineTune.create()`	`client.fine_tunes.create()`
`openai.FineTuningJob.create()`	`client.fine_tuning.jobs.create()`
`openai.FineTuningJob.cancel()`	`client.fine_tuning.jobs.cancel()`
`openai.FineTuningJob.delete()`	`client.fine_tuning.jobs.create()`
`openai.FineTuningJob.retrieve()`	`client.fine_tuning.jobs.retrieve()`
`openai.FineTuningJob.list()`	`client.fine_tuning.jobs.list()`
`openai.FineTuningJob.list_events()`	`client.fine_tuning.jobs.list_events()`
`openai.Image.create()`	`client.images.generate()`
`openai.Image.create_variation()`	`client.images.create_variation()`
`openai.Image.create_edit()`	`client.images.edit()`
`openai.Model.list()`	`client.models.list()`
`openai.Model.delete()`	`client.models.delete()`
`openai.Model.retrieve()`	`client.models.retrieve()`
`openai.Moderation.create()`	`client.moderations.create()`
`openai.api_resources`	`openai.resources`

Удаленные

openai.api_key_path
openai.app_info
openai.debug
openai.log
openai.OpenAIError
openai.Audio.transcribe_raw()
openai.Audio.translate_raw()
openai.ErrorObject
openai.Customer
openai.api_version
openai.verify_ssl_certs
openai.api_type
openai.enable_telemetry
openai.ca_bundle_path
openai.requestssession (OpenAI теперь использует httpx)
openai.aiosession (OpenAI теперь использует httpx)
openai.Deployment (Ранее используется для Azure OpenAI)
openai.Engine
openai.File.find_matching_files()

Поделиться через