Update app.py

app.py

@@ -1,349 +1,355 @@
+import streamlit as st
+from gradio_client import Client
+import time
+import concurrent.futures
 import os
-import random
-import uuid
-import base64
-import gradio as gr
-import numpy as np
 from PIL import Image
-import spaces
-import torch
-import glob
-from datetime import datetime
-import pandas as pd
-import json
-import re
-
-from diffusers import StableDiffusionXLPipeline, EulerAncestralDiscreteScheduler
-
-DESCRIPTION = """# 🎨 ArtForge: Community AI Gallery
-
-Create, curate, and compete with AI-generated art. Join our creative multiplayer experience! 🖼️🏆✨
-"""
-
-# Global variables
-image_metadata = pd.DataFrame(columns=['Filename', 'Prompt', 'Likes', 'Dislikes', 'Hearts', 'Created'])
-LIKES_CACHE_FILE = "likes_cache.json"
-
-def load_likes_cache():
-    if os.path.exists(LIKES_CACHE_FILE):
-        with open(LIKES_CACHE_FILE, 'r') as f:
-            return json.load(f)
-    return {}
-
-def save_likes_cache(cache):
-    with open(LIKES_CACHE_FILE, 'w') as f:
-        json.dump(cache, f)
-
-likes_cache = load_likes_cache()
-
-def create_download_link(filename):
-    with open(filename, "rb") as file:
-        encoded_string = base64.b64encode(file.read()).decode('utf-8')
-        download_link = f'<a href="data:image/png;base64,{encoded_string}" download="{filename}">Download Image</a>'
-        return download_link
-
-def save_image(img, prompt):
-    global image_metadata, likes_cache
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    safe_prompt = re.sub(r'[^\w\s-]', '', prompt.lower())[:50]  # Limit to 50 characters
-    safe_prompt = re.sub(r'[-\s]+', '-', safe_prompt).strip('-')
-    filename = f"{timestamp}_{safe_prompt}.png"
-    img.save(filename)
-    new_row = pd.DataFrame({
-        'Filename': [filename],
-        'Prompt': [prompt],
-        'Likes': [0],
-        'Dislikes': [0],
-        'Hearts': [0],
-        'Created': [datetime.now()]
-    })
-    image_metadata = pd.concat([image_metadata, new_row], ignore_index=True)
-    likes_cache[filename] = {'likes': 0, 'dislikes': 0, 'hearts': 0}
-    save_likes_cache(likes_cache)
-    return filename
-
-def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-    return seed
-
-def get_image_gallery():
-    global image_metadata
-    image_files = image_metadata['Filename'].tolist()
-    return [(file, get_image_caption(file)) for file in image_files if os.path.exists(file)]
-
-def get_image_caption(filename):
-    global likes_cache, image_metadata
-    if filename in likes_cache:
-        likes = likes_cache[filename]['likes']
-        dislikes = likes_cache[filename]['dislikes']
-        hearts = likes_cache[filename]['hearts']
-        prompt = image_metadata[image_metadata['Filename'] == filename]['Prompt'].values[0]
-        return f"{filename}\nPrompt: {prompt}\n👍 {likes} 👎 {dislikes} ❤️ {hearts}"
-    return filename
-
-def delete_all_images():
-    global image_metadata, likes_cache
-    for file in image_metadata['Filename']:
-        if os.path.exists(file):
-            os.remove(file)
-    image_metadata = pd.DataFrame(columns=['Filename', 'Prompt', 'Likes', 'Dislikes', 'Hearts', 'Created'])
-    likes_cache = {}
-    save_likes_cache(likes_cache)
-    return get_image_gallery(), image_metadata.values.tolist()
-
-def delete_image(filename):
-    global image_metadata, likes_cache
-    if filename and os.path.exists(filename):
-        os.remove(filename)
-        image_metadata = image_metadata[image_metadata['Filename'] != filename]
-        if filename in likes_cache:
-            del likes_cache[filename]
-            save_likes_cache(likes_cache)
-    return get_image_gallery(), image_metadata.values.tolist()
-
-def vote(filename, vote_type):
-    global likes_cache
-    if filename in likes_cache:
-        likes_cache[filename][vote_type.lower()] += 1
-        save_likes_cache(likes_cache)
-    return get_image_gallery(), image_metadata.values.tolist()
-
-def get_random_style():
-    styles = [
-        "Impressionist", "Cubist", "Surrealist", "Abstract Expressionist",
-        "Pop Art", "Minimalist", "Baroque", "Art Nouveau", "Pointillist", "Fauvism"
-    ]
-    return random.choice(styles)
-
-MAX_SEED = np.iinfo(np.int32).max
-
-if not torch.cuda.is_available():
-    DESCRIPTION += "\n<p>Running on CPU 🥶 This demo may not work on CPU.</p>"
-
-USE_TORCH_COMPILE = 0
-ENABLE_CPU_OFFLOAD = 0
-
-if torch.cuda.is_available():
-    pipe = StableDiffusionXLPipeline.from_pretrained(
-        "fluently/Fluently-XL-v4",
-        torch_dtype=torch.float16,
-        use_safetensors=True,
-    )
-    pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
-    
-    pipe.load_lora_weights("ehristoforu/dalle-3-xl-v2", weight_name="dalle-3-xl-lora-v2.safetensors", adapter_name="dalle")
-    pipe.set_adapters("dalle")
-
-    pipe.to("cuda")
-
-@spaces.GPU(enable_queue=True)
-def generate(
-    prompt: str,
-    negative_prompt: str = "",
-    use_negative_prompt: bool = False,
-    seed: int = 0,
-    width: int = 1024,
-    height: int = 1024,
-    guidance_scale: float = 3,
-    randomize_seed: bool = False,
-    progress=gr.Progress(track_tqdm=True),
-):
-    seed = int(randomize_seed_fn(seed, randomize_seed))
-
-    if not use_negative_prompt:
-        negative_prompt = ""
-
-    images = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        width=width,
-        height=height,
-        guidance_scale=guidance_scale,
-        num_inference_steps=20,
-        num_images_per_prompt=1,
-        cross_attention_kwargs={"scale": 0.65},
-        output_type="pil",
-    ).images
-    image_paths = [save_image(img, prompt) for img in images]
-    download_links = [create_download_link(path) for path in image_paths]
-
-    return image_paths, seed, download_links, get_image_gallery(), image_metadata.values.tolist()
-
-examples = [
-    f"{get_random_style()} painting of a majestic lighthouse on a rocky coast. Use bold brushstrokes and a vibrant color palette to capture the interplay of light and shadow as the lighthouse beam cuts through a stormy night sky.",
-    f"{get_random_style()} still life featuring a pair of vintage eyeglasses. Focus on the intricate details of the frames and lenses, using a warm color scheme to evoke a sense of nostalgia and wisdom.",
-    f"{get_random_style()} depiction of a rustic wooden stool in a sunlit artist's studio. Emphasize the texture of the wood and the interplay of light and shadow, using a mix of earthy tones and highlights.",
-    f"{get_random_style()} scene viewed through an ornate window frame. Contrast the intricate details of the window with a dreamy, soft-focus landscape beyond, using a palette that transitions from cool interior tones to warm exterior hues.",
-    f"{get_random_style()} close-up study of interlaced fingers. Use a monochromatic color scheme to emphasize the form and texture of the hands, with dramatic lighting to create depth and emotion.",
-    f"{get_random_style()} composition featuring a set of dice in motion. Capture the energy and randomness of the throw, using a dynamic color palette and blurred lines to convey movement.",
-    f"{get_random_style()} interpretation of heaven. Create an ethereal atmosphere with soft, billowing clouds and radiant light, using a palette of celestial blues, golds, and whites.",
-    f"{get_random_style()} portrayal of an ancient, mystical gate. Combine architectural details with elements of fantasy, using a rich, jewel-toned palette to create an air of mystery and magic.",
-    f"{get_random_style()} portrait of a curious cat. Focus on capturing the feline's expressive eyes and sleek form, using a mix of bold and subtle colors to bring out the cat's personality.",
-    f"{get_random_style()} abstract representation of toes in sand. Use textured brushstrokes to convey the feeling of warm sand, with a palette inspired by a sun-drenched beach."
-]
-
-css = '''
-.gradio-container{max-width: 1024px !important}
-h1{text-align:center}
-footer {
-visibility: hidden
-}
-'''
-
-with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
-    gr.Markdown(DESCRIPTION)
-
-    with gr.Tab("Generate Images"):
-        with gr.Group():
-            with gr.Row():
-                prompt = 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.Gallery(label="Result", columns=1, preview=True, show_label=False)
-        with gr.Accordion("Advanced options", open=False):
-            use_negative_prompt = gr.Checkbox(label="Use negative prompt", value=True)
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                lines=4,
-                max_lines=6,
-                value="""(deformed, distorted, disfigured:1.3), poorly drawn, bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, (mutated hands and fingers:1.4), disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, (NSFW:1.25)""",
-                placeholder="Enter a negative prompt",
-                visible=True,
+import io
+import requests
+from huggingface_hub import HfApi, login
+
+# Initialize session state - must be first
+if 'hf_token' not in st.session_state:
+    st.session_state['hf_token'] = None
+if 'is_authenticated' not in st.session_state:
+    st.session_state['is_authenticated'] = False
+
+class ModelGenerator:
+    @staticmethod
+    def generate_midjourney(prompt, token):
+        try:
+            client = Client("mukaist/Midjourney", hf_token=token)
+            result = client.predict(
+                prompt=prompt,
+                negative_prompt="(deformed iris, deformed pupils, semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, anime:1.4), text, close up, cropped, out of frame, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck",
+                use_negative_prompt=True,
+                style="2560 x 1440",
+                seed=0,
+                width=1024,
+                height=1024,
+                guidance_scale=6,
+                randomize_seed=True,
+                api_name="/run"
+            )
+            
+            if isinstance(result, tuple):
+                image_data = result[0] if len(result) > 0 else None
+            elif isinstance(result, list):
+                image_data = result[0] if len(result) > 0 else None
+            else:
+                image_data = result
+
+            if image_data:
+                if isinstance(image_data, str):
+                    if image_data.startswith('http'):
+                        response = requests.get(image_data)
+                        return ("Midjourney", Image.open(io.BytesIO(response.content)))
+                    return ("Midjourney", Image.open(image_data))
+                elif isinstance(image_data, bytes):
+                    return ("Midjourney", Image.open(io.BytesIO(image_data)))
+                elif hasattr(image_data, 'read'):  # File-like object
+                    return ("Midjourney", Image.open(image_data))
+            return ("Midjourney", "Error: No valid image data found")
+        except Exception as e:
+            return ("Midjourney", f"Error: {str(e)}")
+
+    @staticmethod
+    def generate_stable_cascade(prompt, token):
+        try:
+            client = Client("multimodalart/stable-cascade", hf_token=token)
+            result = client.predict(
+                prompt=prompt,
+                negative_prompt=prompt,
+                seed=0,
+                width=1024,
+                height=1024,
+                prior_num_inference_steps=20,
+                prior_guidance_scale=4,
+                decoder_num_inference_steps=10,
+                decoder_guidance_scale=0,
+                num_images_per_prompt=1,
+                api_name="/run"
+            )
+            if isinstance(result, (str, bytes)):
+                return ("Stable Cascade", Image.open(io.BytesIO(result) if isinstance(result, bytes) else result))
+            elif isinstance(result, list) and len(result) > 0:
+                return ("Stable Cascade", Image.open(io.BytesIO(result[0]) if isinstance(result[0], bytes) else result[0]))
+            return ("Stable Cascade", "Error: No valid image data found")
+        except Exception as e:
+            return ("Stable Cascade", f"Error: {str(e)}")
+
+    @staticmethod
+    def generate_stable_diffusion_3(prompt, token):
+        try:
+            client = Client("stabilityai/stable-diffusion-3-medium", hf_token=token)
+            result = client.predict(
+                prompt=prompt,
+                negative_prompt=prompt,
+                seed=0,
+                randomize_seed=True,
+                width=1024,
+                height=1024,
+                guidance_scale=5,
+                num_inference_steps=28,
+                api_name="/infer"
+            )
+            if isinstance(result, bytes):
+                return ("SD 3 Medium", Image.open(io.BytesIO(result)))
+            elif isinstance(result, str):
+                if result.startswith('http'):
+                    response = requests.get(result)
+                    return ("SD 3 Medium", Image.open(io.BytesIO(response.content)))
+                return ("SD 3 Medium", Image.open(result))
+            elif isinstance(result, list) and len(result) > 0:
+                image_data = result[0]
+                if isinstance(image_data, bytes):
+                    return ("SD 3 Medium", Image.open(io.BytesIO(image_data)))
+                elif isinstance(image_data, str):
+                    if image_data.startswith('http'):
+                        response = requests.get(image_data)
+                        return ("SD 3 Medium", Image.open(io.BytesIO(response.content)))
+                    return ("SD 3 Medium", Image.open(image_data))
+            return ("SD 3 Medium", "Error: No valid image data found")
+        except Exception as e:
+            return ("SD 3 Medium", f"Error: {str(e)}")
+
+    @staticmethod
+    def generate_stable_diffusion_35(prompt, token):
+        try:
+            client = Client("stabilityai/stable-diffusion-3.5-large", hf_token=token)
+            result = client.predict(
+                prompt=prompt,
+                negative_prompt=prompt,
+                seed=0,
+                randomize_seed=True,
+                width=1024,
+                height=1024,
+                guidance_scale=4.5,
+                num_inference_steps=40,
+                api_name="/infer"
             )
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
-                visible=True
+            if isinstance(result, bytes):
+                return ("SD 3.5 Large", Image.open(io.BytesIO(result)))
+            elif isinstance(result, str):
+                if result.startswith('http'):
+                    response = requests.get(result)
+                    return ("SD 3.5 Large", Image.open(io.BytesIO(response.content)))
+                return ("SD 3.5 Large", Image.open(result))
+            elif isinstance(result, list) and len(result) > 0:
+                image_data = result[0]
+                if isinstance(image_data, bytes):
+                    return ("SD 3.5 Large", Image.open(io.BytesIO(image_data)))
+                elif isinstance(image_data, str):
+                    if image_data.startswith('http'):
+                        response = requests.get(image_data)
+                        return ("SD 3.5 Large", Image.open(io.BytesIO(response.content)))
+                    return ("SD 3.5 Large", Image.open(image_data))
+            return ("SD 3.5 Large", "Error: No valid image data found")
+        except Exception as e:
+            return ("SD 3.5 Large", f"Error: {str(e)}")
+
+    @staticmethod
+    def generate_playground_v2_5(prompt, token):
+        try:
+            client = Client("https://playgroundai-playground-v2-5.hf.space/--replicas/ji5gy/", 
+                          hf_token=token)
+            result = client.predict(
+                prompt,
+                prompt,  # negative prompt
+                True,    # use negative prompt
+                0,      # seed
+                1024,   # width
+                1024,   # height
+                7.5,    # guidance scale
+                True,   # randomize seed
+                api_name="/run"
             )
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-            with gr.Row(visible=True):
-                width = gr.Slider(
-                    label="Width",
-                    minimum=512,
-                    maximum=2048,
-                    step=8,
-                    value=1920,
-                )
-                height = gr.Slider(
-                    label="Height",
-                    minimum=512,
-                    maximum=2048,
-                    step=8,
-                    value=1080,
-                )
-            with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance Scale",
-                    minimum=0.1,
-                    maximum=20.0,
-                    step=0.1,
-                    value=20.0,
-                )
+            if isinstance(result, tuple) and result[0] and len(result[0]) > 0:
+                image_data = result[0][0].get('image')
+                if image_data:
+                    if isinstance(image_data, str):
+                        if image_data.startswith('http'):
+                            response = requests.get(image_data)
+                            return ("Playground v2.5", Image.open(io.BytesIO(response.content)))
+                        return ("Playground v2.5", Image.open(image_data))
+                    return ("Playground v2.5", Image.open(io.BytesIO(image_data)))
+            return ("Playground v2.5", "Error: No image generated")
+        except Exception as e:
+            return ("Playground v2.5", f"Error: {str(e)}")
+
+def generate_images(prompt, selected_models):
+    token = st.session_state.get('hf_token')
+    if not token:
+        return [("Error", "No authentication token found")]
         
-        gr.Examples(
-            examples=examples,
-            inputs=prompt,
-            outputs=[result, seed],
-            fn=generate,
-            cache_examples=False,
-        )
-
-    with gr.Tab("Gallery and Voting"):
-        image_gallery = gr.Gallery(label="Generated Images", show_label=True, columns=4, height="auto")
+    results = []
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = []
+        model_map = {
+            "Midjourney": lambda p: ModelGenerator.generate_midjourney(p, token),
+            "Stable Cascade": lambda p: ModelGenerator.generate_stable_cascade(p, token),
+            "SD 3 Medium": lambda p: ModelGenerator.generate_stable_diffusion_3(p, token),
+            "SD 3.5 Large": lambda p: ModelGenerator.generate_stable_diffusion_35(p, token),
+            "Playground v2.5": lambda p: ModelGenerator.generate_playground_v2_5(p, token)
+        }
         
-        with gr.Row():
-            like_button = gr.Button("👍 Like")
-            dislike_button = gr.Button("👎 Dislike")
-            heart_button = gr.Button("❤️ Heart")
-            delete_image_button = gr.Button("🗑️ Delete Selected Image")
+        for model in selected_models:
+            if model in model_map:
+                futures.append(executor.submit(model_map[model], prompt))
         
-        selected_image = gr.State(None)
-
-    with gr.Tab("Metadata and Management"):
-        metadata_df = gr.Dataframe(
-            label="Image Metadata",
-            headers=["Filename", "Prompt", "Likes", "Dislikes", "Hearts", "Created"],
-            interactive=False
-        )
-        delete_all_button = gr.Button("🗑️ Delete All Images")
-
-    use_negative_prompt.change(
-        fn=lambda x: gr.update(visible=x),
-        inputs=use_negative_prompt,
-        outputs=negative_prompt,
-        api_name=False,
-    )
-
-    delete_all_button.click(
-        fn=delete_all_images,
-        inputs=[],
-        outputs=[image_gallery, metadata_df],
-    )
-
-    image_gallery.select(
-        fn=lambda evt: evt,
-        inputs=[],
-        outputs=[selected_image],
-    )
-
-    like_button.click(
-        fn=lambda x: vote(x, 'likes'),
-        inputs=[selected_image],
-        outputs=[image_gallery, metadata_df],
-    )
-
-    dislike_button.click(
-        fn=lambda x: vote(x, 'dislikes'),
-        inputs=[selected_image],
-        outputs=[image_gallery, metadata_df],
-    )
-
-    heart_button.click(
-        fn=lambda x: vote(x, 'hearts'),
-        inputs=[selected_image],
-        outputs=[image_gallery, metadata_df],
-    )
-
-    delete_image_button.click(
-        fn=delete_image,
-        inputs=[selected_image],
-        outputs=[image_gallery, metadata_df],
-    )
-
-    def update_gallery_and_metadata():
-        return gr.update(value=get_image_gallery()), gr.update(value=image_metadata.values.tolist())
-
-    gr.on(
-        triggers=[
-            prompt.submit,
-            negative_prompt.submit,
-            run_button.click,
-        ],
-        fn=generate,
-        inputs=[
-            prompt,
-            negative_prompt,
-            use_negative_prompt,
-            seed,
-            width,
-            height,
-            guidance_scale,
-            randomize_seed,
-        ],
-        outputs=[result, seed, gr.HTML(visible=False), image_gallery, metadata_df],
-        api_name="run",
-    )
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                result = future.result()
+                if result:
+                    results.append(result)
+            except Exception as e:
+                st.error(f"Error during image generation: {str(e)}")
+    
+    return results
 
-    demo.load(fn=update_gallery_and_metadata, outputs=[image_gallery, metadata_df])
+def handle_prompt_click(prompt_text, key):
+    if not st.session_state.get('is_authenticated') or not st.session_state.get('hf_token'):
+        st.error("Please login with your HuggingFace account first!")
+        return
+        
+    st.session_state[f'selected_prompt_{key}'] = prompt_text
+    
+    selected_models = st.session_state.get('selected_models', [])
+    
+    if not selected_models:
+        st.warning("Please select at least one model from the sidebar!")
+        return
+
+    with st.spinner('Generating artwork...'):
+        results = generate_images(prompt_text, selected_models)
+        st.session_state[f'generated_images_{key}'] = results
+        st.success("Artwork generated successfully!")
+
+def main():
+    st.title("🎨 Multi-Model Art Generator")
+
+    # Handle authentication in sidebar
+    with st.sidebar:
+        st.header("🔐 Authentication")
+        if st.session_state.get('is_authenticated') and st.session_state.get('hf_token'):
+            st.success("✓ Logged in to HuggingFace")
+            if st.button("Logout"):
+                st.session_state['hf_token'] = None
+                st.session_state['is_authenticated'] = False
+                st.rerun()
+        else:
+            token = st.text_input("Enter HuggingFace Token", type="password",
+                                help="Get your token from https://huggingface.co/settings/tokens")
+            if st.button("Login"):
+                if token:
+                    try:
+                        # Verify token is valid
+                        api = HfApi(token=token)
+                        api.whoami()
+                        st.session_state['hf_token'] = token
+                        st.session_state['is_authenticated'] = True
+                        st.success("Successfully logged in!")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Authentication failed: {str(e)}")
+                else:
+                    st.error("Please enter your HuggingFace token")
+        
+        if st.session_state.get('is_authenticated') and st.session_state.get('hf_token'):
+            st.markdown("---")
+            st.header("Model Selection")
+            st.session_state['selected_models'] = st.multiselect(
+                "Choose AI Models",
+                ["Midjourney", "Stable Cascade", "SD 3 Medium", "SD 3.5 Large", "Playground v2.5"],
+                default=["Midjourney"]
+            )
+            
+            st.markdown("---")
+            st.markdown("### Selected Models:")
+            for model in st.session_state['selected_models']:
+                st.write(f"✓ {model}")
+            
+            st.markdown("---")
+            st.markdown("### Model Information:")
+            st.markdown("""
+            - **Midjourney**: Best for artistic and creative imagery
+            - **Stable Cascade**: New architecture with high detail
+            - **SD 3 Medium**: Fast and efficient generation
+            - **SD 3.5 Large**: Highest quality, slower generation
+            - **Playground v2.5**: Advanced model with high customization
+            """)
+
+    # Only show the main interface if authenticated
+    if st.session_state.get('is_authenticated') and st.session_state.get('hf_token'):
+        st.markdown("### Select a prompt style to generate artwork:")
+
+        prompt_emojis = {
+            "AIart/AIArtistCommunity": "🤖",
+            "Black & White": "⚫⚪",
+            "Black & Yellow": "⚫💛",
+            "Blindfold": "🙈",
+            "Break": "💔",
+            "Broken": "🔨",
+            "Christmas Celebrations art": "🎄",
+            "Colorful Art": "🎨",
+            "Crimson art": "🔴",
+            "Eyes Art": "👁️",
+            "Going out with Style": "💃",
+            "Hooded Girl": "🧥",
+            "Lips": "👄",
+            "MAEKHLONG": "🏮",
+            "Mermaid": "🧜‍♀️",
+            "Morning Sunshine": "🌅",
+            "Music Art": "🎵",
+            "Owl": "🦉",
+            "Pink": "💗",
+            "Purple": "💜",
+            "Rain": "🌧️",
+            "Red Moon": "🌑",
+            "Rose": "🌹",
+            "Snow": "❄️",
+            "Spacesuit Girl": "👩‍🚀",
+            "Steampunk": "⚙️",
+            "Succubus": "😈",
+            "Sunlight": "☀️",
+            "Weird art": "🎭",
+            "White Hair": "👱‍♀️",
+            "Wings art": "👼",
+            "Woman with Sword": "⚔️"
+        }
+
+        col1, col2, col3 = st.columns(3)
+        
+        for idx, (prompt, emoji) in enumerate(prompt_emojis.items()):
+            full_prompt = f"QT {prompt}"
+            col = [col1, col2, col3][idx % 3]
+            
+            with col:
+                if st.button(f"{emoji} {prompt}", key=f"btn_{idx}"):
+                    handle_prompt_click(full_prompt, idx)
+
+        st.markdown("---")
+        st.markdown("### Generated Artwork:")
+        
+        for key in st.session_state:
+            if key.startswith('selected_prompt_'):
+                idx = key.split('_')[-1]
+                images_key = f'generated_images_{idx}'
+                
+                if images_key in st.session_state:
+                    st.write("Prompt:", st.session_state[key])
+                    
+                    cols = st.columns(len(st.session_state[images_key]))
+                    
+                    for col, (model_name, result) in zip(cols, st.session_state[images_key]):
+                        with col:
+                            st.markdown(f"**{model_name}**")
+                            if isinstance(result, str) and result.startswith("Error"):
+                                st.error(result)
+                            else:
+                                st.image(result, use_container_width=True)
+    else:
+        st.info("Please login with your HuggingFace account to use the app")
 
 if __name__ == "__main__":
-    demo.queue(max_size=20).launch(share=True, debug=False)
+    main()