logo
pub

Come usare FastAPI per avvolgere l'API di Luma AI: una guida pratica

1. Introduzione a Lumalabs e Dream Machine

Allora, Lumalabs è un'azienda davvero innovativa, che sta facendo parlare di sé nel mondo dell'AI e del machine learning. Una delle loro caratteristiche più interessanti è Dream Machine, che ti permette di generare video da testo o immagini usando un'AI super avanzata. E indovina un po’? Abbiamo trovato un'API RESTful non ufficiale per questo, e sono qui per mostrarti come usarla con FastAPI. Che tu sia uno sviluppatore che vuole integrare la generazione di video AI nella tua app, o solo qualcuno che vuole provare le funzionalità di Luma, questa guida ti aiuterà a partire alla grande.

Documentazione API: Luma API

2. Configurare FastAPI

2.1. Installazione di FastAPI

Prima di tutto, dobbiamo configurare FastAPI. Se non l'hai già installato, può andare tutto molto veloce con pip. Basta lanciare:

pip install fastapi

Avrai bisogno anche di un server ASGI per far girare la tua applicazione FastAPI, come uvicorn:

pip install uvicorn

2.2. Creare una App Base con FastAPI

Iniziamo con un’app FastAPI molto semplice, giusto per assicurarci che tutto sia configurato correttamente. Crea un nuovo file Python chiamato main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Ciao, AI di Luma!"}

Adesso, avvia il server usando uvicorn:

uvicorn main:app --reload

Vai su http://127.0.0.1:8000/ nel tuo browser, e dovresti vedere il messaggio "Ciao, AI di Luma!".

3. Integrazione dell'API di Luma

3.1. Impostare il Tuo Endpoint POST

Ora creiamo un endpoint POST in FastAPI per avvolgere l’API di Luma per generare video. L'idea è di creare un'interfaccia pulita e semplice per uso interno.

Ecco come impostare l’endpoint:

import requests
from fastapi import FastAPI, Form

app = FastAPI()

LUMA_API_URL = "https://api.lumaapi.com/api/v1/generation/add"
LUMA_API_TOKEN = "sk-xxx"  # Sostituisci con il tuo token reale

@app.post("/generate-video/")
def generate_video(
    prompt: str = Form(...),
    callback_url: str = Form(...),
    image_url: str = Form(None),
    image_end_url: str = Form(None),
    aspect_ratio: str = Form("16:9")
):
    payload = {
        'arg_prompt': prompt,
        'callback': callback_url,
        'arg_image_url': image_url,
        'arg_image_end_url': image_end_url,
        'arg_aspect_ratio': aspect_ratio
    }
    headers = {
        'Authorization': f'Bearer {LUMA_API_TOKEN}'
    }

    response = requests.post(LUMA_API_URL, headers=headers, data=payload)

    return response.json()

3.2. Analisi dell’Endpoint

  • Preparazione del Payload: Raccoltiamo i dati necessari come il prompt, l'URL di callback, e gli URL delle immagini usando la funzione Form di FastAPI. Questo aiuta a creare la struttura di form-data che l'API di Luma si aspetta.

  • Autenticazione: Mettiamo il token Bearer negli headers per avere accesso sicuro all’API.

  • Effettuare la Richiesta all’API: Quindi facciamo una richiesta POST all’API di Luma e restituiamo la risposta come JSON.

4. Testare la Tua API

4.1. Usare la Documentazione Integrata di FastAPI

Una delle cose fantastiche di FastAPI è la documentazione generata automaticamente. Una volta che la tua app è in esecuzione, vai su http://127.0.0.1:8000/docs, e vedrai una bella pagina con documentazione interattiva.

4.2. Effettuare una Richiesta di Test

Puoi facilmente testare il tuo nuovo endpoint /generate-video/ direttamente dalla documentazione. Compila i campi del modulo con un prompt di esempio, l'URL di callback e, se vuoi, gli URL delle immagini, poi clicca "Esegui" per vedere il risultato.

5. Gestire il Callback

5.1. Impostare l'Endpoint per il Callback

Dopo che il video è stato generato, l'API di Luma invierà una richiesta POST all'URL di callback che hai fornito. Impostiamo un endpoint per gestirlo:

from fastapi import Request

@app.post("/api/cb_task/")
async def handle_callback(request: Request):
    callback_data = await request.json()
    # Fai qualcosa con i dati del callback, come salvare l'URL del video in un database
    return {"status": "Callback ricevuto", "data": callback_data}

5.2. Elaborazione dei Dati del Callback

Nel gestore del callback, puoi elaborare i dati come vuoi. Ad esempio, potresti voler memorizzare l'URL del video nel tuo database o attivare un'altra azione basata sulla risposta.

6. Conclusione

Hai appena avvolto l'API di Luma usando FastAPI, rendendo super facile integrare la generazione di video con AI nei tuoi progetti. Che tu stia lavorando su un'app grande o che stia solo esplorando le possibilità dell'AI, questa configurazione ti dà uno strumento poderoso a portata di mano. Buon divertimento con la programmazione!

SHARE