logo
pub

Comment utiliser FastAPI pour envelopper l'API de Luma AI : Un guide pratique

1. Introduction à Lumalabs et Dream Machine

Alors, Lumalabs, c'est une boîte super innovante qui fait énormément parler d'elle dans le monde de l'IA et du machine learning. Et l'un de leurs trucs phares, c'est Dream Machine, qui te permet de générer des vidéos à partir de texte ou d'images, grâce à une IA hyper performante. Maintenant, devine quoi ? On a mis la main sur une API RESTful non officielle et je vais te montrer comment l'envelopper avec FastAPI. Que tu sois développeur et que tu veuilles intégrer la génération de vidéos IA dans ton appli, ou que tu souhaites juste faire mumuse avec les capacités de Luma, ce guide est fait pour toi !

Documentation de l'API : API Luma

2. Configuration de FastAPI

2.1. Installation de FastAPI

D'abord, on va mettre en place FastAPI. Si tu ne l’as pas encore installé, pas de soucis, tu peux le faire en un rien de temps avec pip. Il suffit de taper :

pip install fastapi

Tu vas aussi avoir besoin d’un serveur ASGI pour faire tourner ta super appli FastAPI, comme uvicorn :

pip install uvicorn

2.2. Création d'une Appli FastAPI de Base

Ok, commençons avec une appli FastAPI basique pour vérifier que tout fonctionne bien. Crée un nouveau fichier Python appelé main.py :

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Salut, Luma IA !"}

Maintenant, lance le serveur avec uvicorn :

uvicorn main:app --reload

Va sur http://127.0.0.1:8000/ dans ton navigateur et tu devrais voir le message "Salut, Luma IA !".

3. Envelopper l'API Luma

3.1. Configuration de ton Endpoint POST

Ensuite, on va créer un endpoint POST dans FastAPI qui va envelopper l'API Luma pour générer des vidéos. L'idée, c'est de faire une interface propre et simple pour un usage interne.

Voici comment tu peux configurer cet 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"  # Remplace ça par ton token réel

@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. Décortiquer l'Endpoint

  • Préparation du Payload : On récupère les données nécessaires comme le prompt, l’URL de callback, et les URLs d'image grâce à la fonction Form de FastAPI. Ça nous aide à créer la structure de form-data que l'API Luma attend.

  • Autorisation : On inclut le token Bearer dans les en-têtes pour un accès sécurisé à l'API.

  • Faire la Requête à l'API : Ensuite, on effectue une requête POST à l'API Luma et on renvoie la réponse au format JSON.

4. Tester ton API

4.1. Utiliser la Documentation Intégrée de FastAPI

Un des trucs géniaux avec FastAPI, c'est la doc générée automatiquement. Une fois ton appli lancée, va sur http://127.0.0.1:8000/docs, et tu verras une belle page de documentation interactive.

4.2. Effectuer une Requête de Test

Tu peux facilement tester ton nouvel endpoint /generate-video/ directement depuis la doc. Remplis les champs du formulaire avec un sample de prompt, l’URL de callback, et éventuellement des URLs d’image, puis clique sur "Exécuter" pour voir le résultat.

5. Gérer le Callback

5.1. Configuration de l'Endpoint de Callback

Après que la vidéo soit générée, l'API de Luma va envoyer une requête POST à l'URL de callback que tu as fournie. On va mettre en place un endpoint pour gérer ça :

from fastapi import Request

@app.post("/api/cb_task/")
async def handle_callback(request: Request):
    callback_data = await request.json()
    # Fais quelque chose avec les données de callback, comme sauvegarder l'URL de la vidéo dans une base de données
    return {"status": "Callback reçu", "data": callback_data}

5.2. Traiter les Données de Callback

Dans le gestionnaire de callback, tu peux traiter les données comme tu veux. Par exemple, tu pourrais vouloir sauvegarder l'URL de la vidéo dans ta base de données ou déclencher une autre action en fonction de la réponse.

6. En Résumé

Tu viens de créer un wrapper pour l'API Luma en utilisant FastAPI, ce qui rend super facile l'intégration de la génération de vidéos alimentée par IA dans tes projets. Que tu bosses sur une grosse appli ou que tu explores juste les possibilités qu'offre l'IA, cette configuration te donne un outil puissant à portée de main. Amuse-toi à coder !

SHARE