Update app.py

app.py

@@ -1,91 +1,72 @@
-import gradio as gr
-import requests
-import random
-import time
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+import os
+import uuid
+from min_dalle import MinDalle
+import torch
 
 # --- CONFIGURATION ---
-print("🚀 Démarrage de l'API CygnisAI (Proxy Pollinations)...")
+app = FastAPI()
+device = "cpu" # On force le CPU car c'est ce qu'on a
+print(f"🚀 Démarrage de l'API Image (DALL-E Mini) sur {device}...")
 
-def generate_image(prompt):
-    if not prompt:
-        return None
-    
-    # Construction de l'URL Pollinations
-    # On utilise le modèle FLUX par défaut pour la qualité
-    seed = random.randint(0, 100000)
-    clean_prompt = requests.utils.quote(prompt)
-    image_url = f"https://pollinations.ai/p/{cleanPrompt}?width=1024&height=1024&seed={seed}&model=flux&nologo=true"
-    
-    print(f"📸 Génération Image: {prompt} -> {image_url}")
-    
-    # On télécharge l'image pour l'afficher dans Gradio
-    try:
-        response = requests.get(image_url)
-        if response.status_code == 200:
-            output_path = "output_image.jpg"
-            with open(output_path, "wb") as f:
-                f.write(response.content)
-            return output_path
-        else:
-            return None
-    except Exception as e:
-        print(f"Erreur téléchargement image: {e}")
-        return None
+# Chargement du modèle DALL-E Mini (Optimisé pour CPU)
+# On utilise min-dalle qui est une implémentation légère
+try:
+    model = MinDalle(
+        models_root='./pretrained',
+        dtype=torch.float32, 
+        device=device,
+        is_mega=False, # False = DALL-E Mini (plus léger), True = DALL-E Mega
+        is_reusable=True
+    )
+    print("✅ Modèle DALL-E Mini chargé.")
+except Exception as e:
+    print(f"❌ Erreur chargement modèle: {e}")
+    model = None
 
-def generate_video(prompt):
-    if not prompt:
-        return None
-        
-    # Pollinations ne fait pas encore de vidéo "text-to-video" stable via URL simple comme les images.
-    # Mais on peut utiliser leur endpoint expérimental ou un autre service gratuit si dispo.
-    # Pour l'instant, on va utiliser l'API Pixabay comme fallback fiable, 
-    # ou simuler une vidéo via Pollinations si possible (souvent des GIFs).
-    
-    # Tentative avec l'endpoint vidéo expérimental de Pollinations (souvent instable)
-    # url = f"https://pollinations.ai/p/{cleanPrompt}?model=turbo&animate=true"
-    
-    # Pour garantir un résultat, on va utiliser Pixabay via l'API (comme dans l'app principale)
-    # Mais ici on est en Python, donc on peut le faire proprement.
-    
-    API_KEY = "53929922-0888380397f008597974652ae" # Clé Pixabay publique
-    url = f"https://pixabay.com/api/videos/?key={API_KEY}&q={requests.utils.quote(prompt)}&pretty=true"
-    
-    print(f"🎥 Recherche Vidéo: {prompt}")
+class ImageRequest(BaseModel):
+    prompt: str
+
+@app.post("/generate")
+async def generate_image(request: ImageRequest):
+    print(f"🎨 Génération image : {request.prompt}")
     
+    if not model:
+        raise HTTPException(status_code=500, detail="Modèle non chargé")
+
     try:
-        response = requests.get(url)
-        data = response.json()
-        if data['hits']:
-            video_url = data['hits'][0]['videos']['medium']['url']
-            # Télécharger la vidéo
-            video_path = "output_video.mp4"
-            v_resp = requests.get(video_url)
-            with open(video_path, "wb") as f:
-                f.write(v_resp.content)
-            return video_path
-        else:
-            return "Aucune vidéo trouvée."
-    except Exception as e:
-        return f"Erreur: {e}"
+        # Génération
+        # grid_size=1 pour générer une seule image (plus rapide)
+        images = model.generate_image(
+            text=request.prompt,
+            seed=-1,
+            grid_size=1,
+            is_seamless=False,
+            temperature=1,
+            top_k=256,
+            supercondition_factor=16,
+            is_verbose=True
+        )
+        
+        # Sauvegarde
+        filename = f"image_{uuid.uuid4()}.png"
+        # images est une PIL Image
+        images.save(filename)
+        
+        # Retourne l'URL absolue
+        # Note: Sur HF Spaces, l'URL est https://huggingface.co/spaces/USER/SPACE/resolve/main/FILENAME
+        # Mais via FastAPI static, c'est relatif
+        return {"image_url": f"https://simonc-44-ai-api.hf.space/{filename}"}
 
-# --- INTERFACE GRADIO ---
-with gr.Blocks(title="CygnisAI API (Pollinations Proxy)", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🌌 CygnisAI API (Powered by Pollinations & Pixabay)")
-    gr.Markdown("Génération ultra-rapide sans GPU requis.")
-    
-    with gr.Tab("Image Generation"):
-        with gr.Row():
-            img_input = gr.Textbox(label="Prompt", placeholder="Un chat cybernétique...")
-            img_btn = gr.Button("Générer Image", variant="primary")
-        img_output = gr.Image(label="Résultat")
-        img_btn.click(generate_image, inputs=img_input, outputs=img_output)
+    except Exception as e:
+        print(f"❌ Erreur génération : {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-    with gr.Tab("Video Generation"):
-        with gr.Row():
-            vid_input = gr.Textbox(label="Prompt", placeholder="Nature, City, Space...")
-            vid_btn = gr.Button("Rechercher Vidéo", variant="primary")
-        vid_output = gr.Video(label="Résultat")
-        vid_btn.click(generate_video, inputs=vid_input, outputs=vid_output)
+# Servir les fichiers statiques
+app.mount("/", StaticFiles(directory=".", html=True), name="static")
 
 if __name__ == "__main__":
-    demo.launch()
+    uvicorn.run(app, host="0.0.0.0", port=7860)