Upload folder using huggingface_hub

app.py

@@ -0,0 +1,423 @@
+import gradio as gr
+import numpy as np
+import random
+import requests
+from PIL import Image
+import io
+import time
+import json
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Get API token from environment variable
+api_token = os.getenv('HF_TOKEN')
+print(f"Loaded API token: {api_token[:10]}...") # Only show first 10 chars for security
+
+if not api_token:
+    raise ValueError("HF_TOKEN environment variable not found. Please check your .env file.")
+
+MAX_SEED = np.iinfo(np.int32).max
+MAX_IMAGE_SIZE = 2048
+
+API_URL = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"
+headers = {"Authorization": f"Bearer {api_token}"}
+
+def query(payload):
+    """Sendet eine Anfrage an die FLUX API mit Fehlerbehandlung und Rate-Limit-Checks"""
+    try:
+        print("\n=== Starting API Request ===")
+        print(f"Using API URL: {API_URL}")
+        print(f"Headers (auth truncated): {{'Authorization': 'Bearer ...'}}")
+        print(f"Payload: {payload}")
+        
+        response = requests.post(API_URL, headers=headers, json=payload)
+        print(f"\n=== Response Details ===")
+        print(f"Status code: {response.status_code}")
+        print(f"Content type: {response.headers.get('content-type', 'unknown')}")
+        print(f"Response length: {len(response.content)} bytes")
+        
+        if response.status_code != 200:
+            print(f"Error response text: {response.text}")
+        
+        # Prüfe auf Rate Limit
+        if response.status_code == 429:  # Too Many Requests
+            retry_after = int(response.headers.get('Retry-After', 20))
+            print(f"Rate limit erreicht. Warte {retry_after} Sekunden...")
+            time.sleep(retry_after)
+            # Versuche es noch einmal
+            print("\n=== Retrying Request ===")
+            response = requests.post(API_URL, headers=headers, json=payload)
+            print(f"Retry status code: {response.status_code}")
+        
+        # Prüfe auf JSON-Antwort (könnte eine Fehlermeldung sein)
+        if response.headers.get('content-type', '').startswith('application/json'):
+            error_data = response.json()
+            print(f"\n=== JSON Response ===")
+            print(f"Response data: {error_data}")
+            if 'error' in error_data:
+                print(f"API Error: {error_data['error']}")
+                if "loading" in error_data.get('error', '').lower():
+                    print("Model is loading, waiting 20 seconds...")
+                    time.sleep(20)
+                    return query(payload)  # Rekursiver Aufruf
+                return None
+        
+        response.raise_for_status()
+        print("\n=== Success ===")
+        print("Successfully received image data")
+        return response.content
+    except requests.exceptions.RequestException as e:
+        print(f"\n=== Request Exception ===")
+        print(f"Error type: {e.__class__.__name__}")
+        print(f"Error message: {str(e)}")
+        print(f"Full error details: {e}")
+        return None
+
+def infer(prompt, seed=42, randomize_seed=False, width=1024, height=1024, num_inference_steps=4):
+    """Generiert ein Bild mit den gegebenen Parametern"""
+    try:
+        print("\n=== Starting Image Generation ===")
+        if randomize_seed:
+            seed = random.randint(0, MAX_SEED)
+            print(f"Using random seed: {seed}")
+        else:
+            print(f"Using fixed seed: {seed}")
+        
+        # Parameter für die API-Anfrage
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "width": width,
+                "height": height,
+                "num_inference_steps": num_inference_steps,
+                "seed": seed,
+                "guidance_scale": 0.0
+            }
+        }
+        
+        print("Calling API...")
+        image_bytes = query(payload)
+        if image_bytes is None:
+            print("Failed to generate image - no image data received")
+            raise Exception("Failed to generate image")
+            
+        print("Converting image bytes to PIL Image...")
+        image = Image.open(io.BytesIO(image_bytes))
+        print("Image generation completed successfully")
+        return image, seed
+    except Exception as e:
+        print(f"Error in infer function: {str(e)}")
+        print(f"Error type: {e.__class__.__name__}")
+        return None, seed
+
+def generate_prompt(location, scene, lighting, mood, person, ethnicity, clothing, camera_perspective="", artistic_style=""):
+    """Generiert einen Prompt aus den Eingaben mit erweiterten FLUX.1-spezifischen Details"""
+    components = []
+    
+    # Kamera und künstlerische Details (wenn angegeben)
+    if camera_perspective: components.append(camera_perspective)
+    if artistic_style: components.append(artistic_style)
+    
+    # Hauptkomponenten
+    if location: components.append(location)
+    if scene: components.append(scene)
+    
+    # Person und Attribute
+    person_desc = []
+    if person: person_desc.append(person)
+    if ethnicity: person_desc.append(ethnicity)
+    if clothing: person_desc.append(f"wearing {clothing}")
+    if person_desc:
+        components.append(", ".join(person_desc))
+    
+    # Atmosphäre
+    atmosphere = []
+    if lighting: atmosphere.append(lighting)
+    if mood: atmosphere.append(mood)
+    if atmosphere:
+        components.append(", ".join(atmosphere))
+    
+    # Standard-Stilelemente für bessere FLUX.1 Ergebnisse
+    components.append("professional photography")
+    components.append("highly detailed")
+    components.append("8k resolution")
+    components.append("ultra wide focus")
+    
+    # Verbinde alles zu einem Prompt
+    final_prompt = ", ".join(filter(None, components))
+    
+    return final_prompt
+
+css = """ 
+#col-container {
+    margin: 0 auto;
+    max-width: 720px;
+}
+
+.container {
+    margin-top: 1rem;
+    margin-bottom: 1rem;
+    padding: 1rem;
+    border-radius: 8px;
+    background-color: rgba(255, 255, 255, 0.05);
+}
+
+.generate-btn {
+    background-color: #2ecc71 !important;
+}
+
+.transfer-btn {
+    background-color: #3498db !important;
+}
+"""
+
+with gr.Blocks(css=css, title="FLUX Schnell") as demo:
+    # Geteilter Zustand für die Prompts
+    shared_prompt = gr.State("")
+    
+    with gr.Tabs():
+        # Prompt Generator Tab
+        with gr.Tab("✨ Prompt Generator", elem_id="prompt_generator_tab"):
+            with gr.Column(elem_id="col-container"):
+                gr.Markdown("""## 🎨 Prompt Generator
+                Erstellen Sie detaillierte Prompts für die Bildgenerierung mit FLUX.1-spezifischen Optimierungen.""")
+                
+                # Grundlegende Szeneninformationen
+                with gr.Group(elem_id="scene_info"):
+                    gr.Markdown("### 📍 Grundlegende Szeneninformationen")
+                    with gr.Row():
+                        location = gr.Textbox(
+                            label="Location",
+                            placeholder="z.B. Rooftop, Nightclub, Street",
+                            info="Der Hauptort der Szene",
+                            elem_id="location_input"
+                        )
+                        scene = gr.Textbox(
+                            label="Scene Description",
+                            placeholder="z.B. bustling party, quiet alley",
+                            info="Was passiert in der Szene?",
+                            elem_id="scene_input"
+                        )
+                
+                # Kamera und Stil
+                with gr.Group(elem_id="camera_style"):
+                    gr.Markdown("### 📸 Kamera & Stil")
+                    camera_perspective = gr.Textbox(
+                        label="Camera Perspective",
+                        placeholder="z.B. close-up shot with 50mm lens, bird's eye view",
+                        info="Spezifische Kameraeinstellungen und Perspektive",
+                        elem_id="camera_input"
+                    )
+                    artistic_style = gr.Textbox(
+                        label="Artistic Style",
+                        placeholder="z.B. cinematic lighting, vintage film look",
+                        info="Künstlerischer Stil und visuelle Ästhetik",
+                        elem_id="style_input"
+                    )
+                
+                # Atmosphäre und Stimmung
+                with gr.Group(elem_id="mood_info"):
+                    gr.Markdown("### 🎨 Atmosphäre und Stimmung")
+                    with gr.Row():
+                        lighting = gr.Textbox(
+                            label="Lighting/Atmosphere",
+                            placeholder="z.B. natural sunlight from left, soft diffused light",
+                            info="Detaillierte Beleuchtungsbeschreibung",
+                            elem_id="lighting_input"
+                        )
+                        mood = gr.Textbox(
+                            label="Mood/Emotion",
+                            placeholder="z.B. energetic, mysterious, serene",
+                            info="Emotionale Stimmung der Szene",
+                            elem_id="mood_input"
+                        )
+                
+                # Personenbeschreibung
+                with gr.Group(elem_id="person_info"):
+                    gr.Markdown("### 👤 Personenbeschreibung")
+                    with gr.Row():
+                        person = gr.Textbox(
+                            label="Person",
+                            placeholder="z.B. young woman, old man",
+                            info="Hauptperson in der Szene",
+                            elem_id="person_input"
+                        )
+                        ethnicity = gr.Textbox(
+                            label="Ethnicity",
+                            placeholder="z.B. asian, african",
+                            info="Ethnische Beschreibung",
+                            elem_id="ethnicity_input"
+                        )
+                    clothing = gr.Textbox(
+                        label="Clothing",
+                        placeholder="z.B. elegant vintage dress, casual street wear",
+                        info="Detaillierte Kleidungsbeschreibung",
+                        elem_id="clothing_input"
+                    )
+                
+                # Generierter Prompt
+                with gr.Group(elem_id="generated_prompt_group"):
+                    generated_prompt = gr.Textbox(
+                        label="Generierter Prompt",
+                        interactive=False,
+                        lines=3,
+                        elem_id="generated_prompt_output"
+                    )
+                    with gr.Row():
+                        generate_button = gr.Button("🎨 Prompt Generieren", elem_classes="generate-btn", elem_id="generate_prompt_btn")
+                        use_prompt_button = gr.Button("➡️ Im Bild-Generator verwenden", elem_classes="transfer-btn", elem_id="use_prompt_btn")
+                
+                # Event Handler
+                generate_button.click(
+                    generate_prompt,
+                    inputs=[
+                        location, scene, lighting, mood, person, 
+                        ethnicity, clothing, camera_perspective,
+                        artistic_style
+                    ],
+                    outputs=[generated_prompt]
+                )
+                
+                use_prompt_button.click(
+                    lambda p: p,
+                    inputs=[generated_prompt],
+                    outputs=[shared_prompt]
+                )
+
+        # Bild Generator Tab
+        with gr.Tab("🖼️ Bild Generator", elem_id="image_generator_tab"):
+            with gr.Column(elem_id="col-container"):
+                gr.Markdown("""# FLUX.1 [schnell]
+                12B param rectified flow transformer distilled from [FLUX.1 [pro]](https://blackforestlabs.ai/) for 4 step generation
+                [[blog](https://blackforestlabs.ai/announcing-black-forest-labs/)] [[model](https://huggingface.co/black-forest-labs/FLUX.1-schnell)]
+                """)
+                
+                with gr.Group(elem_id="prompt_group"):
+                    prompt_input = gr.Text(
+                        label="Prompt",
+                        show_label=False,
+                        max_lines=1,
+                        placeholder="Enter your prompt",
+                        container=False,
+                    )
+                    run_button = gr.Button("Run", scale=0)
+                
+                result = gr.Image(label="Result", show_label=False, elem_id="result_image")
+                
+                with gr.Accordion("⚙️ Advanced Settings", open=False, elem_id="advanced_settings"):
+                    seed = gr.Slider(
+                        label="Seed",
+                        minimum=0,
+                        maximum=MAX_SEED,
+                        step=1,
+                        value=0,
+                        elem_id="seed_slider"
+                    )
+                    
+                    randomize_seed = gr.Checkbox(
+                        label="Randomize seed",
+                        value=True,
+                        elem_id="randomize_seed"
+                    )
+                    
+                    with gr.Row():
+                        width = gr.Slider(
+                            label="Width",
+                            minimum=256,
+                            maximum=MAX_IMAGE_SIZE,
+                            step=32,
+                            value=1024,
+                            elem_id="width_slider"
+                        )
+                        height = gr.Slider(
+                            label="Height",
+                            minimum=256,
+                            maximum=MAX_IMAGE_SIZE,
+                            step=32,
+                            value=1024,
+                            elem_id="height_slider"
+                        )
+                    
+                    num_inference_steps = gr.Slider(
+                        label="Inference Steps",
+                        minimum=1,
+                        maximum=50,
+                        step=1,
+                        value=4,
+                        elem_id="steps_slider"
+                    )
+                
+                # Event Handler für die Bildgenerierung
+                def generate_image(prompt, seed, randomize, width, height, steps):
+                    try:
+                        gr.Info("🎨 Starte Bildgenerierung...")
+                        print(f"\n=== Generate Image Called ===")
+                        print(f"Prompt: {prompt}")
+                        print(f"Settings: seed={seed}, randomize={randomize}, width={width}, height={height}, steps={steps}")
+                        
+                        image, used_seed = infer(
+                            prompt=prompt,
+                            seed=seed,
+                            randomize_seed=randomize,
+                            width=width,
+                            height=height,
+                            num_inference_steps=steps
+                        )
+                        
+                        if image is None:
+                            gr.Warning("⚠️ Bildgenerierung fehlgeschlagen. Bitte versuchen Sie es erneut.")
+                            return None, used_seed
+                        
+                        gr.Info("✅ Bild erfolgreich generiert!")
+                        return image, used_seed
+                    except Exception as e:
+                        print(f"\n=== Generation Error ===")
+                        print(f"Error type: {type(e).__name__}")
+                        print(f"Error message: {str(e)}")
+                        gr.Error(f"❌ Fehler bei der Bildgenerierung: {str(e)}")
+                        return None, seed
+
+                # Event handlers
+                run_button.click(
+                    fn=generate_image,
+                    inputs=[
+                        prompt_input,
+                        seed,
+                        randomize_seed,
+                        width,
+                        height,
+                        num_inference_steps
+                    ],
+                    outputs=[
+                        result,
+                        seed
+                    ]
+                )
+                
+                prompt_input.submit(
+                    fn=generate_image,
+                    inputs=[
+                        prompt_input,
+                        seed,
+                        randomize_seed,
+                        width,
+                        height,
+                        num_inference_steps
+                    ],
+                    outputs=[
+                        result,
+                        seed
+                    ]
+                )
+                
+                # Event Handler für Prompt-Updates
+                demo.load(
+                    fn=lambda: "",
+                    outputs=[prompt_input]
+                )
+
+if __name__ == "__main__":
+    demo.launch(share=True, server_port=7860)

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=3.50.2
+numpy>=1.24.3
+requests>=2.31.0
+Pillow>=10.0.0
+torch>=2.0.1
+python-dotenv>=1.0.0