Corso
Lavorare con l'API di OpenAI
3 ore
184.5K
Primi passi con l'API di OpenAI
Per iniziare, dobbiamo creare un account OpenAI e una chiave API. Per farlo, vai alla loro pagina delle chiavi API e fai clic su "Create new secret key" in alto a destra.
Questa chiave serve per effettuare richieste all'API di OpenAI. La salviamo in un file chiamato .env nella cartella in cui scriviamo i nostri script Python. Assicurati di tenerla segreta, perché chiunque potrebbe usarla per interagire con l'API tramite il tuo account.
Incolla la chiave API nel file .env con il seguente formato:
OPENAI_API_KEY=<paste_api_key_here>Nota che usare l'API non è gratuito, quindi è necessario ricaricare il tuo account prima di poter generare video con Sora 2. Per riferimento, ecco il costo al secondo di Sora 2:
Generare un video con Sora 2 usando Python
Tutto il codice di questo tutorial si può trovare in questa repository GitHub.
Per comunicare con l'API di OpenAI usando Python, useremo il pacchetto openai. Nota che, poiché Sora è nuova nell'API, serve una versione recente del pacchetto.
Possiamo usare questo comando per installarlo (o aggiornare la versione attuale se è già installato):
pip install --upgrade openaiCrea un nuovo script chiamato generate_video.py nella stessa cartella del file .env che abbiamo creato prima.
Il primo passo è importare i pacchetti necessari. Ecco quelli che useremo:
os: un pacchetto integrato per interagire con il sistema operativo;openai: il pacchetto ufficiale di OpenAI per interagire con la loro API;dotenv: un pacchetto che facilita il caricamento delle variabili d'ambiente dal file.env. In questo caso, lo usiamo per caricare la chiave API di OpenAI.
import os
from openai import OpenAI
from dotenv import load_dotenvPoi carichiamo il file .env:
load_dotenv()
API_KEY = os.getenv("OPENAI_API_KEY")Con la chiave API in memoria, possiamo inizializzare il client OpenAI, che ci permette di effettuare richieste all'API di OpenAI. Usiamo la libreria os per caricare la chiave API:
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
Infine, usiamo la funzione videos.create del client per generare un video:
video = client.videos.create(
prompt="A cat and a dog dancing",
)
print(video.id)Quando richiediamo la generazione del video, non lo riceviamo subito perché la creazione richiede un po' di tempo. Questo significa che la variabile video non è il video in sé, ma un oggetto che contiene le informazioni sul job di generazione.
Ecco perché abbiamo stampato l'identificatore del video. È l'informazione di cui avremo bisogno per:
- Monitorare l'avanzamento della generazione.
- Recuperare il video.
Spiegheremo nel dettaglio entrambi i passaggi qui sotto.
Ecco il risultato che ho ottenuto:
Monitorare l'avanzamento del video
Possiamo recuperare lo stato di un job passando l'identificatore del job alla funzione videos.retrieve(), così:
job = client.videos.retrieve(job_id)
status = job.status
progress = job.progress
print(f"Status: {status}, {progress}%")Dobbiamo attendere che l'avanzamento raggiunga il 100% per poter scaricare il video. Per comodità, costruiamo una funzione, wait_for_video_to_finish(), che monitora lo stato di un job finché non viene completato:
def wait_for_video_to_finish(video_id, poll_interval=5, timeout=600):
"""
Poll status until the video is ready or timeout is reached.
Returns the final job info.
"""
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
elapsed = 0 # Keep track of the elapsed time
while elapsed < timeout:
job = client.videos.retrieve(video_id)
status = job.status
progress = job.progress
print(f"Status: {status}, {progress}%")
if status == "completed":
return job
if status == "failed":
raise RuntimeError(f"Failed to generate the video: {job.error.message}")
time.sleep(poll_interval)
elapsed += poll_interval
raise RuntimeError("Polling timed out")La funzione ha tre parametri:
video_id: l'identificatore del video che vogliamo tracciare.poll_interval: quanti secondi attendiamo tra una richiesta di stato e la successiva.timeout: il numero massimo di secondi da attendere.
Questa funzione controlla periodicamente lo stato del video finché non viene completato o finché non scade il tempo di polling.
Scaricare il video
Ora che possiamo tracciare il processo di generazione, ci serve solo un modo per scaricare il video quando è pronto. Possiamo farlo usando la funzione videos.download_content().
Ecco una funzione che lo fa:
def download_video(video_id):
client = get_client()
response = client.videos.download_content(
video_id=video_id,
)
video_bytes = response.read()
with open(f"{video_id}.mp4", "wb") as f:
f.write(video_bytes)Workflow completo per la generazione di video con Sora
Possiamo unire questi passaggi per creare un workflow di generazione video con Sora:
prompt = "A cat and a dog dancing"
video = client.videos.create(
prompt="A cat and a dog dancing",
)
video_id = video.id
print(f"Started generating video with id {video_id}")
wait_for_video_to_finish(video_id)
download_video(video_id)Impostare dimensioni e durata del video
Lo script sopra usa solo un prompt testuale per generare il video. Tuttavia, l'API OpenAI Sora 2 offre altre opzioni, come:
model: il modello usato per generare il video. Per impostazione predefinita, èsora-2.resolution: la dimensione del video. Per impostazione predefinita, è720x1280.duration: la durata in secondi del video. Per impostazione predefinita, è di 4 secondi.
Ecco una tabella con tutti i valori possibili a seconda della modalità (in grassetto i valori predefiniti):
Per rendere lo script più comodo, possiamo usare il pacchetto integrato argparse per permettere all'utente di specificare il valore di ogni parametro.
Ecco un esempio di come impostare gli argomenti prompt e model con argparse:
parser = argparse.ArgumentParser()
parser.add_argument(
"--prompt", # Name of the argument
required=True, # Specify that the argument is required
help="The video prompt.", # Helper text
)
parser.add_argument(
"--model",
default="sora-2", # Specify a default value for the argument
choices=["sora-2", "sora-2-pro"], # Specify a list of possible values for the argument
help="Model to use (sora-2 or sora-2-pro).",
)Per caricare gli argomenti, chiamiamo il metodo parse_args(), così:
args = parser.parse_args()
prompt = args.prompt
model = args.modelLo script generate_video_pipeline.py nella repository GitHub mette insieme tutti i pezzi che abbiamo visto in uno script in grado di generare video con Sora 2.
Ecco un esempio di come eseguirlo nel terminale con parametri specifici:
python generate_video_pipeline.py --prompt "A family of dogs driving a car" --model sora-2-pro --size 1280x720 --seconds 8Questo è stato il risultato:
