Update app.py

app.py

@@ -1,159 +1,213 @@
-"""
-FLUX Image Generator - Nineteen.ai API (Versione HF Spaces)
---------------------------------------
-Questo script utilizza l'API di Nineteen.ai per generare immagini
-con il modello FLUX.1-schnell, offrendo un'interfaccia grafica intuitiva.
-Versione ottimizzata per Hugging Face Spaces con autenticazione.
-
-Autore: Utente
-Data: 09/03/2025
-"""
-
 import os
-import io
-import time
-import base64
-import requests
 import gradio as gr
+import requests
 from PIL import Image
+from io import BytesIO
+import google.generativeai as genai
 from dotenv import load_dotenv
+import time
+import base64
+import random
 
 # Carica le variabili d'ambiente (se presenti)
 load_dotenv()
 
 class FluxNineteenGenerator:
-    """
-    Classe per generare immagini utilizzando il modello FLUX.1-schnell
-    attraverso l'API di Nineteen.ai.
-    """
+    """Generatore di immagini utilizzando l'API FLUX di Nineteen.ai"""
     
     def __init__(self):
-        """
-        Inizializza il generatore di immagini FLUX tramite API Nineteen.ai.
-        """
+        """Inizializza il generatore"""
         print("Inizializzazione del generatore di immagini FLUX Nineteen.ai...")
         
         # Ottieni l'API key da variabile d'ambiente
         self.api_key = os.getenv("NINETEEN_API_KEY")
         if not self.api_key:
-            raise ValueError("È necessario configurare la variabile d'ambiente NINETEEN_API_KEY")
+            raise ValueError(
+                "È necessario configurare la variabile d'ambiente NINETEEN_API_KEY.\n"
+                "Su Hugging Face Spaces: Aggiungi la variabile nelle impostazioni dello Space.\n"
+                "In locale: Configura la variabile nel tuo ambiente di sviluppo."
+            )
         
         # Configurazione dell'API
         self.api_endpoint = "https://api.nineteen.ai/v1/text-to-image"
         self.headers = {
             "Authorization": f"Bearer {self.api_key}",
-            "accept": "application/json",
             "Content-Type": "application/json"
         }
         
-        # Modelli disponibili
-        self.models = ["black-forest-labs/FLUX.1-schnell", "black-forest-labs/FLUX.1-dev"]
+        # Modello predefinito
         self.default_model = "black-forest-labs/FLUX.1-schnell"
-        
         print(f"Generatore inizializzato con modello predefinito: {self.default_model}")
+        
+        # Lista dei modelli disponibili
+        self.models = {
+            "schnell": "black-forest-labs/FLUX.1-schnell",
+            "proteus": "dataautogpt3/ProteusV0.4-Lightning",
+            "dreamshaper": "Lykon/dreamshaper-xl-lightning"
+        }
     
-    def generate_image(self, prompt, model=None, steps=8, cfg_scale=3, 
-                      height=1024, width=1024, negative_prompt=""):
+    def generate_image(self, prompt, model=None, steps=28, cfg_scale=7.0, height=1024, width=1024, negative_prompt=None):
         """
-        Genera un'immagine utilizzando l'API di Nineteen.ai.
+        Genera un'immagine utilizzando l'API FLUX.
         
         Args:
-            prompt (str): Descrizione testuale dell'immagine da generare
-            model (str, optional): Modello da utilizzare
-            steps (int): Numero di passi di inferenza
-            cfg_scale (float): Scala di guidance per la generazione
-            height (int): Altezza dell'immagine in pixel
-            width (int): Larghezza dell'immagine in pixel
-            negative_prompt (str): Prompt negativo per escludere elementi indesiderati
-            
+            prompt (str): Descrizione dell'immagine da generare
+            model (str, optional): Nome del modello da utilizzare. Default: None (usa il modello predefinito)
+            steps (int, optional): Numero di passi di inferenza. Default: 28
+            cfg_scale (float, optional): Guidance scale. Default: 7.0
+            height (int, optional): Altezza dell'immagine. Default: 1024
+            width (int, optional): Larghezza dell'immagine. Default: 1024
+            negative_prompt (str, optional): Prompt negativo. Default: None
+        
         Returns:
-            PIL.Image: L'immagine generata
-            str: Messaggio di stato
+            tuple: (PIL.Image, str) L'immagine generata e un messaggio di stato
         """
-        if not model:
-            model = self.default_model
-            
         try:
-            # Prepara il payload
-            data = {
+            # Usa il modello predefinito se non specificato
+            if not model:
+                model = self.default_model
+            
+            # Se viene fornito un nome breve, usa il nome completo dal dizionario
+            if model in self.models:
+                model = self.models[model]
+            
+            # Prepara i parametri per la richiesta
+            payload = {
                 "prompt": prompt,
                 "model": model,
-                "steps": steps,
-                "cfg_scale": cfg_scale,
+                "num_inference_steps": steps,
+                "guidance_scale": cfg_scale,
                 "height": height,
-                "width": width,
-                "negativePrompt": negative_prompt
+                "width": width
             }
             
-            # Log della richiesta
+            if negative_prompt:
+                payload["negative_prompt"] = negative_prompt
+            
             print(f"Generazione immagine con prompt: '{prompt}'")
-            print(f"Parametri: modello={model}, steps={steps}, cfg_scale={cfg_scale}, dimensioni={width}x{height}")
+            print(f"Parametri: modello={model}, steps={steps}, cfg_scale={cfg_scale}, dimensioni={height}x{width}")
             
-            # Effettua la chiamata API
             start_time = time.time()
-            response = requests.post(self.api_endpoint, headers=self.headers, json=data)
-            end_time = time.time()
             
-            # Gestione degli errori
+            # Invia la richiesta all'API
+            response = requests.post(
+                self.api_endpoint,
+                headers=self.headers,
+                json=payload
+            )
+            
+            # Gestisci gli errori HTTP
             if response.status_code != 200:
                 error_message = f"Errore API: {response.status_code} - {response.text}"
                 print(error_message)
                 return None, error_message
             
-            # Estrai l'immagine in formato base64 dalla risposta
+            # Decodifica l'immagine
+            end_time = time.time()
             try:
                 image_b64 = response.json()["image_b64"]
                 image_data = base64.b64decode(image_b64)
-                image = Image.open(io.BytesIO(image_data))
+                image = Image.open(BytesIO(image_data))
                 
                 print(f"Immagine generata in {end_time - start_time:.2f} secondi")
                 return image, f"Immagine generata in {end_time - start_time:.2f} secondi"
-            except KeyError:
-                return None, f"Errore: La risposta API non contiene il campo 'image_b64'. Risposta: {response.json()}"
             except Exception as e:
-                return None, f"Errore nel decodificare l'immagine: {str(e)}"
+                error_message = f"Errore nella decodifica dell'immagine: {str(e)}"
+                print(error_message)
+                return None, error_message
                 
         except Exception as e:
-            error_message = f"Errore durante la generazione dell'immagine: {str(e)}"
+            error_message = f"Errore durante la generazione: {str(e)}"
             print(error_message)
             return None, error_message
 
-def create_ui(generator):
-    """
-    Crea l'interfaccia utente Gradio.
+class GeminiPromptGenerator:
+    """Generatore di prompt creativi utilizzando Gemini AI"""
+    
+    def __init__(self):
+        """Inizializza il generatore di prompt"""
+        genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
+        self.model = genai.GenerativeModel(
+            model_name="gemini-1.5-flash-8b",
+            generation_config=genai.types.GenerationConfig(
+                temperature=1.4,  # Aumentata per più creatività
+                top_p=0.99,      # Aumentato per più variabilità
+                top_k=40,        # Aumentato per considerare più opzioni
+                max_output_tokens=8192
+            )
+        )
+        
+        # Lista di stili artistici per variare i prompt
+        self.art_styles = [
+            "hyperrealistic", "cinematic", "digital art", "oil painting",
+            "concept art", "fantasy art", "sci-fi", "surrealism",
+            "studio photography", "anime", "cyberpunk", "steampunk"
+        ]
+        
+        # Lista di atmosfere per variare i prompt
+        self.moods = [
+            "ethereal", "mysterious", "dramatic", "peaceful",
+            "energetic", "melancholic", "whimsical", "epic",
+            "intimate", "nostalgic", "futuristic", "dreamy"
+        ]
+        
+    def generate_creative_prompt(self):
+        """Genera un prompt creativo per la generazione di immagini"""
+        # Seleziona casualmente uno stile e un'atmosfera
+        style = random.choice(self.art_styles)
+        mood = random.choice(self.moods)
+        
+        system_prompt = f"""You are an expert prompt engineer for artistic image generation.
+        Create a unique and creative prompt to generate an extraordinary image.
+        Current time: {time.strftime('%Y-%m-%d %H:%M:%S')}
+        
+        The prompt must:
+        - Be in English
+        - Create a completely new and original scene, different from any previous ones
+        - Focus on the suggested style: {style}
+        - Incorporate the suggested mood: {mood}
+        - Include specific details about:
+          * Main subject and its unique characteristics
+          * Rich environmental details and setting
+          * Dynamic lighting and atmospheric effects
+          * Specific color palette and visual elements
+          * Camera angle or perspective
+        - Use vivid and evocative language
+        - Be about 2-3 lines long
+        - Include elements that work well with the FLUX.1-schnell model
+        - End with style keywords: {style}, {mood}, photorealistic, cinematic, 8K, ultra-detailed
+        
+        Generate ONLY the prompt, without any explanations or introductions.
+        IMPORTANT: Create something completely different from previous prompts.
+        DO NOT include words like 'prompt' or 'description' in the response."""
+        
+        try:
+            response = self.model.generate_content(system_prompt)
+            if response.text:
+                return response.text.strip()
+            else:
+                return "Sorry, I couldn't generate a creative prompt. Please try again."
+        except Exception as e:
+            return f"Error generating prompt: {str(e)}"
+
+def create_ui():
+    """Crea l'interfaccia utente Gradio"""
     
-    Args:
-        generator (FluxNineteenGenerator): Istanza del generatore
+    # Inizializza i generatori
+    flux_gen = FluxNineteenGenerator()
+    gemini_gen = GeminiPromptGenerator()
     
-    Returns:
-        gradio.Interface: L'interfaccia Gradio
-    """
+    def generate_random_prompt():
+        """Genera un prompt casuale usando Gemini"""
+        try:
+            return gemini_gen.generate_creative_prompt()
+        except Exception as e:
+            return f"Error: {str(e)}"
     
-    def generate_image_ui(prompt, model, steps, cfg_scale, height, width, negative_prompt):
+    def generate_image(prompt, model, steps, cfg_scale, height, width, negative_prompt):
         """Funzione per generare immagini dall'interfaccia"""
-        # Validazione dei parametri
-        if not prompt or len(prompt.strip()) == 0:
-            return None, "Il prompt non può essere vuoto."
-        
         try:
-            # Converti i parametri al tipo corretto
-            steps = int(steps)
-            cfg_scale = float(cfg_scale)
-            height = int(height)
-            width = int(width)
-            
-            # Validazione dei valori
-            if steps < 1 or steps > 50:
-                return None, "Il numero di passi deve essere compreso tra 1 e 50."
-            if cfg_scale < 1 or cfg_scale > 30:
-                return None, "La guidance scale deve essere compresa tra 1 e 30."
-            if height < 512 or height > 1536:
-                return None, "L'altezza deve essere compresa tra 512 e 1536 pixel."
-            if width < 512 or width > 1536:
-                return None, "La larghezza deve essere compresa tra 512 e 1536 pixel."
-            
-            # Genera l'immagine
-            return generator.generate_image(
+            return flux_gen.generate_image(
                 prompt=prompt,
                 model=model,
                 steps=steps,
@@ -163,124 +217,102 @@ def create_ui(generator):
                 negative_prompt=negative_prompt
             )
         except Exception as e:
-            return None, f"Errore: {str(e)}"
+            return None, str(e)
     
-    # Crea i componenti dell'interfaccia
-    with gr.Blocks(title="FLUX Nineteen.ai Image Generator") as interface:
-        gr.Markdown("# FLUX Nineteen.ai Image Generator")
-        gr.Markdown("Genera immagini utilizzando il modello FLUX.1-schnell tramite l'API di Nineteen.ai")
+    with gr.Blocks(title="FLUX Image Generator") as demo:
+        gr.Markdown("# 🎨 FLUX Image Generator")
+        gr.Markdown("Image generator with FLUX.1-schnell and Gemini AI")
         
         with gr.Row():
-            with gr.Column(scale=3):
+            with gr.Column(scale=1):
                 prompt_input = gr.Textbox(
                     label="Prompt",
-                    placeholder="Descrivi l'immagine che desideri generare...",
+                    placeholder="Enter your image description or click 'Generate Creative Prompt'...",
                     lines=3
                 )
                 
-                negative_prompt_input = gr.Textbox(
-                    label="Prompt Negativo (opzionale)",
-                    placeholder="Elementi da escludere dall'immagine...",
-                    lines=2
-                )
-                
-                model_input = gr.Dropdown(
-                    generator.models,
-                    label="Modello",
-                    value=generator.default_model
-                )
-                
                 with gr.Row():
+                    generate_prompt_btn = gr.Button("🤖 Generate Creative Prompt", variant="secondary")
+                    clear_prompt_btn = gr.Button("🗑️ Clear", variant="secondary")
+                
+                with gr.Accordion("Advanced Settings", open=False):
+                    model_input = gr.Dropdown(
+                        choices=list(FluxNineteenGenerator().models.keys()),
+                        value="schnell",
+                        label="Model"
+                    )
+                    
                     steps_input = gr.Slider(
                         minimum=1,
-                        maximum=50,
-                        value=8,
+                        maximum=100,
+                        value=28,
                         step=1,
-                        label="Passi di Inferenza"
+                        label="Steps"
                     )
+                    
                     cfg_input = gr.Slider(
                         minimum=1.0,
-                        maximum=30.0,
-                        value=3.0,
-                        step=0.1,
-                        label="Guidance Scale (CFG)"
-                    )
-                
-                with gr.Row():
-                    height_input = gr.Slider(
-                        minimum=512,
-                        maximum=1536,
-                        value=1024,
-                        step=64,
-                        label="Altezza (px)"
+                        maximum=20.0,
+                        value=7.0,
+                        step=0.5,
+                        label="CFG Scale"
                     )
-                    width_input = gr.Slider(
-                        minimum=512,
-                        maximum=1536,
-                        value=1024,
-                        step=64,
-                        label="Larghezza (px)"
+                    
+                    with gr.Row():
+                        height_input = gr.Slider(
+                            minimum=512,
+                            maximum=1536,
+                            value=1024,
+                            step=64,
+                            label="Height (px)"
+                        )
+                        width_input = gr.Slider(
+                            minimum=512,
+                            maximum=1536,
+                            value=1024,
+                            step=64,
+                            label="Width (px)"
+                        )
+                    
+                    negative_prompt_input = gr.Textbox(
+                        label="Negative Prompt",
+                        placeholder="Elements to avoid in the image...",
+                        lines=2
                     )
                 
-                generate_button = gr.Button("Genera Immagine", variant="primary")
+                generate_image_btn = gr.Button("🎨 Generate Image", variant="primary")
             
-            with gr.Column(scale=4):
-                output_image = gr.Image(label="Immagine Generata", type="pil")
-                output_status = gr.Textbox(label="Stato", interactive=False)
+            with gr.Column(scale=1):
+                output_image = gr.Image(label="Generated Image")
+                output_status = gr.Textbox(label="Status", interactive=False)
         
-        # Esempi di prompt
-        with gr.Accordion("Esempi di Prompt", open=False):
-            gr.Markdown("""
-            ### Esempi di prompt ottimizzati per FLUX.1-schnell
-            
-            Clicca su uno degli esempi per utilizzarlo:
-            """)
-            
-            examples = [
-                ["A breathtaking view of the Dolomites at sunrise, golden light illuminating the jagged peaks, morning mist rising from the valley below, ultra-detailed, cinematic, 8K resolution, photorealistic"],
-                ["Futuristic Tokyo cityscape at night, neon lights reflecting on wet streets after rain, towering skyscrapers with holographic advertisements, flying vehicles, photorealistic, cinematic lighting, 8K"],
-                ["Portrait of a weathered old fisherman with deep wrinkles and piercing blue eyes, wearing a cable-knit sweater, salt and pepper beard, golden hour lighting, ultra-detailed skin texture, photorealistic"],
-                ["Massive space station orbiting Jupiter, with Earth visible in the distance, detailed mechanical structures, solar panels, docking bays with spacecraft, photorealistic, NASA quality, 8K"],
-                ["Bioluminescent forest at night with giant mushrooms, glowing plants, mystical atmosphere, small magical creatures, ultra-detailed vegetation, photorealistic textures, fantasy world with realistic lighting"]
-            ]
-            
-            gr.Examples(
-                examples=examples,
-                inputs=prompt_input
-            )
+        # Eventi
+        generate_prompt_btn.click(
+            fn=generate_random_prompt,
+            outputs=prompt_input
+        )
+        
+        clear_prompt_btn.click(
+            fn=lambda: "",
+            outputs=prompt_input
+        )
         
-        # Collega il pulsante di generazione
-        generate_button.click(
-            generate_image_ui,
+        generate_image_btn.click(
+            fn=generate_image,
             inputs=[
-                prompt_input, 
-                model_input, 
-                steps_input, 
-                cfg_input, 
-                height_input, 
-                width_input, 
+                prompt_input,
+                model_input,
+                steps_input,
+                cfg_input,
+                height_input,
+                width_input,
                 negative_prompt_input
             ],
             outputs=[output_image, output_status]
         )
     
-    return interface
-
-# Funzione principale
-def main():
-    """Funzione principale"""
-    # Crea il generatore
-    generator = FluxNineteenGenerator()
-    
-    # Crea l'interfaccia
-    interface = create_ui(generator)
-    
-    # Avvia l'interfaccia senza autenticazione (l'autenticazione sarà gestita da Hugging Face Spaces)
-    # Utilizziamo i parametri necessari per Hugging Face Spaces
-    interface.launch(
-        server_name="0.0.0.0",
-        share=False
-    )
+    return demo
 
 if __name__ == "__main__":
-    main()
+    demo = create_ui()
+    demo.launch()