Update app.py

app.py

@@ -1,17 +1,23 @@
 import tkinter as tk
-from tkinter import ttk, scrolledtext
+from tkinter import ttk, scrolledtext, messagebox
 from PIL import Image, ImageTk
 import os
 from datetime import datetime
 import json
 import requests
 from io import BytesIO
+import base64
+import time
 
 class DrawingTutorialApp:
     def __init__(self, root):
         self.root = root
         self.root.title("Générateur de Tutoriel de Dessin")
         
+        # Configuration de l'API Hugging Face
+        self.API_URL = "https://api-inference.huggingface.co/models/stabilityai/sdxl-turbo"
+          # Remplacez par votre token
+        
         # Configuration des styles
         self.setup_styles()
         
@@ -65,43 +71,117 @@ class DrawingTutorialApp:
                                         text="Aucune étape générée", 
                                         wraplength=400)
         self.step_description.pack(padx=5, pady=5)
-        
+
+        # Indicateur de progression
+        self.progress_label = ttk.Label(main_frame, text="")
+        self.progress_label.pack(pady=5)
+        
+    def query_image(self, prompt):
+        """Génère une image via l'API Hugging Face"""
+        try:
+            response = requests.post(
+                self.API_URL,
+                headers=self.headers,
+                json={
+                    "inputs": prompt,
+                    "parameters": {
+                        "num_inference_steps": 1,
+                        "guidance_scale": 0.0,
+                    }
+                }
+            )
+            
+            # Vérifier si la requête a réussi
+            if response.status_code != 200:
+                raise Exception(f"Erreur API: {response.status_code}")
+                
+            # Vérifier si le modèle est en cours de chargement
+            if response.status_code == 200 and "error" in response.json():
+                if "currently loading" in response.json()["error"]:
+                    print("Modèle en cours de chargement, attente...")
+                    time.sleep(20)  # Attendre et réessayer
+                    return self.query_image(prompt)
+                    
+            # Traiter la réponse
+            image_bytes = response.content
+            image = Image.open(BytesIO(image_bytes))
+            return image
+            
+        except Exception as e:
+            print(f"Erreur lors de la génération d'image: {e}")
+            messagebox.showerror("Erreur", f"Erreur lors de la génération d'image: {e}")
+            return None
+
     def generate_steps(self):
         description = self.description_text.get("1.0", "end-1c")
         if not description:
+            messagebox.showwarning("Attention", "Veuillez entrer une description")
             return
             
-        # Définition des étapes standard de dessin
-        base_steps = [
-            "Esquisse de base et formes géométriques",
-            "Ajout des détails principaux",
-            "Affinement des lignes",
-            "Ajout des ombres de base",
-            "Colorisation de base",
-            "Ajout des détails de couleur",
-            "Finalisation et mise en valeur"
+        # Définition des étapes et prompts associés
+        steps = [
+            {
+                "name": "Esquisse de base et formes géométriques",
+                "prompt": f"basic sketch with geometric shapes of {description}, lineart, sketch style, black and white"
+            },
+            {
+                "name": "Ajout des détails principaux",
+                "prompt": f"detailed sketch of {description}, more defined lines, black and white drawing"
+            },
+            {
+                "name": "Affinement des lignes",
+                "prompt": f"refined line drawing of {description}, clean lines, professional sketch"
+            },
+            {
+                "name": "Ajout des ombres de base",
+                "prompt": f"shaded sketch of {description}, basic shadows and values, grayscale"
+            },
+            {
+                "name": "Colorisation de base",
+                "prompt": f"basic colored version of {description}, flat colors, simple coloring"
+            },
+            {
+                "name": "Ajout des détails de couleur",
+                "prompt": f"detailed colored drawing of {description}, with shading and color details"
+            },
+            {
+                "name": "Finalisation et mise en valeur",
+                "prompt": f"final polished illustration of {description}, complete with details and professional finish"
+            }
         ]
         
-        # Ici, vous intégreriez votre API de génération d'images
-        # Pour l'exemple, nous simulons la génération
+        # Réinitialisation des listes
         self.generated_images = []
         self.steps_description = []
         
-        for step in base_steps:
-            # Simuler la génération d'image
-            # Dans une vraie implémentation, appelez votre API ici
-            blank_image = Image.new('RGB', (400, 400), 'white')
-            self.generated_images.append(blank_image)
-            self.steps_description.append(f"{step}\n{description}")
-        
-        self.current_step = 0
-        self.update_display()
+        # Génération des images pour chaque étape
+        for i, step in enumerate(steps):
+            self.progress_label.configure(
+                text=f"Génération de l'étape {i+1}/{len(steps)}: {step['name']}")
+            self.root.update()
+            
+            image = self.query_image(step['prompt'])
+            if image:
+                self.generated_images.append(image)
+                self.steps_description.append(f"{step['name']}\n{step['prompt']}")
+            else:
+                messagebox.showerror("Erreur", f"Échec de la génération pour l'étape {i+1}")
+                continue
+            
+        if self.generated_images:
+            self.progress_label.configure(text="Génération terminée!")
+            self.current_step = 0
+            self.update_display()
+        else:
+            self.progress_label.configure(text="Échec de la génération")
         
     def update_display(self):
         if not self.generated_images:
             return
             
         image = self.generated_images[self.current_step]
+        # Redimensionner l'image si nécessaire
+        image = image.resize((400, 400), Image.Resampling.LANCZOS)
         photo = ImageTk.PhotoImage(image)
         self.image_label.configure(image=photo)
         self.image_label.image = photo