Aggiunti file dell'applicazione FLUX Image Generator

.gitignore

@@ -0,0 +1,31 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Environment variables
+.env
+.env.*
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Logs
+*.log
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific files
+.DS_Store
+Thumbs.db

README.md

@@ -1,14 +1,46 @@
----
-title: Flux Image Generator
-emoji: 🖼
-colorFrom: purple
-colorTo: red
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: 'Generatore di immagini basato sul modello FLUX.1-schnell di '
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# FLUX Nineteen.ai Image Generator
+
+Generatore di immagini che utilizza l'API di Nineteen.ai con il modello FLUX.1-schnell, offrendo un'interfaccia grafica intuitiva per la creazione di immagini di alta qualità.
+
+## Caratteristiche
+
+- Interfaccia utente semplice e intuitiva
+- Supporto per prompt negativi
+- Controllo completo sui parametri di generazione
+- Esempi di prompt preconfigurati
+- Autenticazione per proteggere l'accesso
+
+## Utilizzo
+
+1. Inserisci un prompt descrittivo nella casella di testo
+2. Configura i parametri di generazione secondo le tue preferenze:
+   - Modello: Scegli tra FLUX.1-schnell o FLUX.1-dev
+   - Passi di inferenza: Più passi = più dettagli (ma più lento)
+   - Guidance Scale: Controlla quanto l'immagine aderisce al prompt
+   - Dimensioni: Imposta l'altezza e la larghezza dell'immagine
+3. Opzionalmente, aggiungi un prompt negativo per escludere elementi indesiderati
+4. Clicca su "Genera Immagine"
+
+## Esempi di Prompt
+
+L'applicazione include alcuni esempi di prompt ottimizzati per FLUX.1-schnell. Clicca su uno degli esempi per utilizzarlo come punto di partenza.
+
+## Requisiti
+
+- Python 3.8+
+- Gradio
+- Requests
+- Pillow
+- Python-dotenv
+
+## Configurazione
+
+L'applicazione utilizza le seguenti variabili d'ambiente:
+
+- `NINETEEN_API_KEY`: La tua chiave API per Nineteen.ai
+- `GRADIO_USERNAME`: Username per l'autenticazione
+- `GRADIO_PASSWORD`: Password per l'autenticazione
+
+## Crediti
+
+Sviluppato da Utente utilizzando l'API di Nineteen.ai e il modello FLUX.1-schnell di Black Forest Labs.

app.py

@@ -1,154 +1,293 @@
-import gradio as gr
-import numpy as np
-import random
-
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
-
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
-
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
-
-    return image, seed
-
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
-
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
-}
 """
+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.
 
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
-
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
+Autore: Utente
+Data: 09/03/2025
+"""
 
-            run_button = gr.Button("Run", scale=0, variant="primary")
+import os
+import io
+import time
+import base64
+import requests
+import gradio as gr
+from PIL import Image
+from dotenv import load_dotenv
 
-        result = gr.Image(label="Result", show_label=False)
+# Carica le variabili d'ambiente (se presenti)
+load_dotenv()
 
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
+class FluxNineteenGenerator:
+    """
+    Classe per generare immagini utilizzando il modello FLUX.1-schnell
+    attraverso l'API di Nineteen.ai.
+    """
+    
+    def __init__(self):
+        """
+        Inizializza il generatore di immagini FLUX tramite API Nineteen.ai.
+        """
+        print("Inizializzazione del generatore di immagini FLUX Nineteen.ai...")
+        
+        # Ottieni l'API key da variabile d'ambiente o usa quella predefinita
+        self.api_key = os.getenv("NINETEEN_API_KEY", "rayon_6nzcBRzaq8f7iRzFUX2IsscMBGKgmJcO")
+        
+        # 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"]
+        self.default_model = "black-forest-labs/FLUX.1-schnell"
+        
+        print(f"Generatore inizializzato con modello predefinito: {self.default_model}")
+    
+    def generate_image(self, prompt, model=None, steps=8, cfg_scale=3, 
+                      height=1024, width=1024, negative_prompt=""):
+        """
+        Genera un'immagine utilizzando l'API di Nineteen.ai.
+        
+        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
+            
+        Returns:
+            PIL.Image: L'immagine generata
+            str: Messaggio di stato
+        """
+        if not model:
+            model = self.default_model
+            
+        try:
+            # Prepara il payload
+            data = {
+                "prompt": prompt,
+                "model": model,
+                "steps": steps,
+                "cfg_scale": cfg_scale,
+                "height": height,
+                "width": width,
+                "negativePrompt": negative_prompt
+            }
+            
+            # Log della richiesta
+            print(f"Generazione immagine con prompt: '{prompt}'")
+            print(f"Parametri: modello={model}, steps={steps}, cfg_scale={cfg_scale}, dimensioni={width}x{height}")
+            
+            # 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
+            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
+            try:
+                image_b64 = response.json()["image_b64"]
+                image_data = base64.b64decode(image_b64)
+                image = Image.open(io.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)}"
+                
+        except Exception as e:
+            error_message = f"Errore durante la generazione dell'immagine: {str(e)}"
+            print(error_message)
+            return None, error_message
 
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
+def create_ui(generator):
+    """
+    Crea l'interfaccia utente Gradio.
+    
+    Args:
+        generator (FluxNineteenGenerator): Istanza del generatore
+    
+    Returns:
+        gradio.Interface: L'interfaccia Gradio
+    """
+    
+    def generate_image_ui(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(
+                prompt=prompt,
+                model=model,
+                steps=steps,
+                cfg_scale=cfg_scale,
+                height=height,
+                width=width,
+                negative_prompt=negative_prompt
             )
-
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-
-            with gr.Row():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
+        except Exception as e:
+            return None, f"Errore: {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.Row():
+            with gr.Column(scale=3):
+                prompt_input = gr.Textbox(
+                    label="Prompt",
+                    placeholder="Descrivi l'immagine che desideri generare...",
+                    lines=3
                 )
-
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
+                
+                negative_prompt_input = gr.Textbox(
+                    label="Prompt Negativo (opzionale)",
+                    placeholder="Elementi da escludere dall'immagine...",
+                    lines=2
                 )
-
-            with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
-                )
-
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
+                
+                model_input = gr.Dropdown(
+                    generator.models,
+                    label="Modello",
+                    value=generator.default_model
                 )
+                
+                with gr.Row():
+                    steps_input = gr.Slider(
+                        minimum=1,
+                        maximum=50,
+                        value=8,
+                        step=1,
+                        label="Passi di Inferenza"
+                    )
+                    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)"
+                    )
+                    width_input = gr.Slider(
+                        minimum=512,
+                        maximum=1536,
+                        value=1024,
+                        step=64,
+                        label="Larghezza (px)"
+                    )
+                
+                generate_button = gr.Button("Genera Immagine", variant="primary")
+            
+            with gr.Column(scale=4):
+                output_image = gr.Image(label="Immagine Generata", type="pil")
+                output_status = gr.Textbox(label="Stato", 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
+            )
+        
+        # Collega il pulsante di generazione
+        generate_button.click(
+            generate_image_ui,
+            inputs=[
+                prompt_input, 
+                model_input, 
+                steps_input, 
+                cfg_input, 
+                height_input, 
+                width_input, 
+                negative_prompt_input
+            ],
+            outputs=[output_image, output_status]
+        )
+    
+    return interface
 
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
-        ],
-        outputs=[result, seed],
-    )
+# Funzione principale
+def main():
+    """Funzione principale"""
+    # Crea il generatore
+    generator = FluxNineteenGenerator()
+    
+    # Crea l'interfaccia
+    interface = create_ui(generator)
+    
+    # Configura l'autenticazione
+    username = os.getenv("GRADIO_USERNAME")
+    password = os.getenv("GRADIO_PASSWORD")
+    
+    # Verifica se le credenziali sono disponibili
+    if username and password:
+        auth = (username, password)
+        print(f"Autenticazione configurata con username: {username}")
+    else:
+        # Per test locali, disabilitiamo l'autenticazione
+        auth = None
+        print("Autenticazione disabilitata per test locali. Su HF Spaces, imposta GRADIO_USERNAME e GRADIO_PASSWORD.")
+    
+    # Avvia l'interfaccia con o senza autenticazione
+    interface.launch(auth=auth)
 
 if __name__ == "__main__":
-    demo.launch()
+    main()

requirements.txt

@@ -1,6 +1,4 @@
-accelerate
-diffusers
-invisible_watermark
-torch
-transformers
-xformers
+gradio>=3.50.2
+requests>=2.31.0
+Pillow>=10.0.0
+python-dotenv>=1.0.0