Migrando para a biblioteca de API de OpenAI do Python 1.x

O OpenAI acaba de lançar uma nova versão da biblioteca de API de OpenAI do Python. Este guia é complementar ao guia de migração de OpenAI e ajudará você a se atualizar sobre as alterações específicas ao Azure OpenAI.

Atualizações

• Esta é uma nova versão da biblioteca de API do OpenAI Python.
• A partir de 6 de novembro de 2023, pip install openai e pip install openai --upgrade instalarão version 1.x da biblioteca OpenAI do Python.
• Atualizar de version 0.28.1 para version 1.x é uma alteração interruptiva, então você precisará testar e atualizar seu código.
• Tente novamente automaticamente com a retirada se houver um erro
• Tipos adequados (para mypy/pyright/editores)
• Agora você pode criar uma instância de um cliente, em vez de usar um padrão global.
• Alternar para a instanciação explícita do cliente
• Alterações de nome

Problemas conhecidos

• DALL-E3 é totalmente compatível com a versão 1.x mais recente. DALL-E2 pode ser usado com 1.x ao fazer as seguintes modificações em seu código.
• embeddings_utils.py, que foi usado para fornecer funcionalidades como similaridade de cosseno para pesquisa de texto semântico, não faz mais parte da biblioteca de API OpenAI do Python.
• Você também deve verificar os problemas do GitHub ativos para a biblioteca OpenAI do Python.

Testar antes de migrar

Importante

Não há suporte para a migração automática do código usando openai migrate com o OpenAI do Azure.

Como esta é uma nova versão da biblioteca com alterações interruptivas, você deve testar seu código extensivamente em relação à nova versão antes de migrar os aplicativos de produção para depender da versão 1.x. Você também deve examinar seu código e processos internos para verificar se está seguindo as práticas recomendadas e fixando seu código de produção apenas em versões que você testou totalmente.

Para facilitar o processo de migração, estamos atualizando exemplos de código existentes em nossos documentos para Python para uma experiência com guias:

OpenAI Python 1.x

pip install openai --upgrade

OpenAI Python 0.28.1

pip install openai==0.28.1

Isso fornece contexto para o que foi alterado e permite que você teste a nova biblioteca em paralelo, continuando a fornecer suporte para a versão0.28.1. Se você atualizar para 1.x e perceber que precisa reverter temporariamente para a versão anterior, sempre poderá pip uninstall openai e reinstalar direcionado para 0.28.1 com pip install openai==0.28.1.

Preenchimentos de chat

OpenAI Python 1.x

Você precisa definir a variável model para o nome da implantação que você escolheu quando implantou os modelos do GPT-3.5-Turbo ou do GPT-4. Inserir o nome do modelo resulta em um erro, a menos que você escolha um nome de implantação que seja idêntico ao nome do modelo subjacente.

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)

Exemplos adicionais podem ser encontrados em nosso artigo detalhado sobre conclusão de chat.

OpenAI Python 0.28.1

Você precisa definir a variável engine para o nome da implantação que você escolheu quando implantou os modelos do GPT-3.5-Turbo ou do GPT-4. Inserir o nome do modelo resultará em um erro, a menos que você escolha um nome de implantação que seja idêntico ao nome do modelo subjacente.

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'])

Preenchimentos

OpenAI Python 1.x

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)

OpenAI Python 0.28.1

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)

Incorporações

OpenAI Python 1.x

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))

Exemplos adicionais, incluindo como lidar com a pesquisa semântica de texto sem embeddings_utils.py podem ser encontrados em nosso tutorial de inserções.

OpenAI Python 0.28.1

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)

Async

O OpenAI não dá suporte à chamada de métodos assíncronos no cliente no nível do módulo, em vez disso, você deve criar uma instância de um cliente assíncrono.

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())

Autenticação

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))

Usar seus dados

Para obter as etapas completas de configuração necessárias para que esses exemplos de código funcionem, consulte o uso do início rápido de seus dados.

OpenAI Python 1.x

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))

OpenAI Python 0.28.1

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 fix

DALLE-Fix

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)

DALLE-Fix Async

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())

Alterações de nome

Observação

Todos os métodos a* foram removidos; em vez disso, o cliente assíncrono precisa ser usado.

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

Removido

• 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 (o OpenAI agora usa httpx)
• openai.aiosession (o OpenAI agora usa httpx)
• openai.Deployment (usado anteriormente para o OpenAI do Azure)
• openai.Engine
• openai.File.find_matching_files()