Update app.py

app.py

@@ -1,336 +1,327 @@
-import numpy as np
 import gradio as gr
-import ast
 import requests
-
-import logging
-from rembg import new_session
-from cutter import remove, make_label
-from utils import *
-
-API_URL_INITIAL = "https://ysharma-playground-ai-exploration.hf.space/run/initial_dataframe"
-API_URL_NEXT10 = "https://ysharma-playground-ai-exploration.hf.space/run/next_10_rows"
-
-#from theme_dropdown import create_theme_dropdown  # noqa: F401
-
-from theme_dropdown import create_theme_dropdown  # noqa: F401
-
-dropdown, js = create_theme_dropdown()
-
-models = [
-    {"name": "❤ STABLE DIFFUSION MODELS ==========", "url": "stabilityai/stable-diffusion-2-1"},
-     {"name": "SD ComVis 1.2","url": "CompVis/stable-diffusion-v1-2"},
-    {"name": "SD Comvis 1.4","url": "CompVis/stable-diffusion-v1-4"},
-    {"name": "SD runawayml 1.5","url": "runwayml/stable-diffusion-v1-5"},
-    {"name": "SD stable-diffusion xl base 1.0","url": "timothymhowe/stable-diffusion-xl-base-1.0"},
-     {"name": "SD NSFW","url": "digiplay/CamelliaMix_NSFW_diffusers_v1.1"},
+import time
+import json
+import base64
+import os
+from io import BytesIO
+import html
+import re
+
+
+
+class Prodia:
+    def __init__(self, api_key, base=None):
+        self.base = base or "https://api.prodia.com/v1"
+        self.headers = {
+            "X-Prodia-Key": api_key
+        }
     
-     {"name": "SD Dreamshaper-Anime","url": "Lykon/DreamShaper"},
-     {"name": "Dreamlike Anime","url": "dreamlike-art/dreamlike-photoreal-2.0"},
-    {"name": "❤ REALISTIC PHOTO MODELS ==========", "url": "dreamlike-art/dreamlike-photoreal-2.0"},
-    {"name": "AmiIReal", "url": "stablediffusionapi/amireal"},
-    {"name": "Analog Diffusion", "url": "wavymulder/Analog-Diffusion"},
-    {"name": "Circulus 2.8", "url": "circulus/sd-photoreal-v2.8"},
-    {"name": "UltraSkin", "url": "VegaKH/Ultraskin"},
-    {"name": "Wavyfusion", "url": "wavymulder/wavyfusion"},
-    {"name": "❤ SEMI-REALISTIC MODELS ==========", "url": "stablediffusionapi/all-526"},    
-    {"name": "All 526", "url": "stablediffusionapi/all-526"},
-    {"name": "All 526 animated", "url": "stablediffusionapi/all-526-animated"},
-    {"name": "Circulus Semi Real 2", "url": "circulus/sd-photoreal-semi-v2"},
-    {"name": "Semi Real Mix", "url": "robotjung/SemiRealMix"},
-    {"name": "SpyBG", "url": "stablediffusionapi/spybg"},
-    {"name": "Stable Diffusion 2", "url": "stabilityai/stable-diffusion-2-1"},
-    {"name": "stability AI", "url": "stabilityai/stable-diffusion-2-1-base"},
-    {"name": "Compressed-S-D", "url": "nota-ai/bk-sdm-small"},
-    {"name": "Future Diffusion", "url": "nitrosocke/Future-Diffusion"},
-    {"name": "JWST Deep Space Diffusion", "url": "dallinmackay/JWST-Deep-Space-diffusion"},
-    {"name": "Robo Diffusion 3 Base", "url": "nousr/robo-diffusion-2-base"},
-    {"name": "Robo Diffusion", "url": "nousr/robo-diffusion"},
-    {"name": "Tron Legacy Diffusion", "url": "dallinmackay/Tron-Legacy-diffusion"},
-    {"name": "❤ 3D ART MODELS ==========", "url": "DucHaiten/DucHaitenAIart"},
-    {"name": "DucHaiten Art", "url": "DucHaiten/DucHaitenAIart"},
-    {"name": "DucHaiten ClassicAnime", "url": "DucHaiten/DH_ClassicAnime"},
-    {"name": "DucHaiten DreamWorld", "url": "DucHaiten/DucHaitenDreamWorld"},
-    {"name": "DucHaiten Journey", "url": "DucHaiten/DucHaitenJourney"},
-    {"name": "DucHaiten StyleLikeMe", "url": "DucHaiten/DucHaiten-StyleLikeMe"},
-    {"name": "DucHaiten SuperCute", "url": "DucHaiten/DucHaitenSuperCute"},
-    {"name": "Redshift Diffusion 768", "url": "nitrosocke/redshift-diffusion-768"},
-    {"name": "Redshift Diffusion", "url": "nitrosocke/redshift-diffusion"},
-]   
-
-
-####  REM-BG
-
-remove_bg_models = {
-    "TracerUniversalB7": "TracerUniversalB7",
-    "U2NET": "u2net",
-    "U2NET Human Seg": "u2net_human_seg",
-    "U2NET Cloth Seg": "u2net_cloth_seg"
-}
-
-model_choices = keys(remove_bg_models)
-
-
-def predict(image, session, smoot, matting, bg_color):
-
-    session = new_session(remove_bg_models[session])
-
-    try:
-        return remove(session, image, smoot, matting, bg_color)
-    except ValueError as err:
-        logging.error(err)
-        return make_label(str(err)), None
-
-
-def change_show_mask(chk_state):
-    return gr.Image.update(visible=chk_state)
-
-
-def change_include_matting(chk_state):
-    return gr.Box.update(visible=chk_state), (0, 0, 0), 0, 0, 0
-
-
-def change_foreground_threshold(fg_value, value):
-    fg, bg, erode = value
-    return fg_value, bg, erode
-
-
-def change_background_threshold(bg_value, value):
-    fg, bg, erode = value
-    return fg, bg_value, erode
-
-
-def change_erode_size(erode_value, value):
-    fg, bg, erode = value
-    return fg, bg, erode_value
-
-
-def set_dominant_color(chk_state):
-    return chk_state, gr.ColorPicker.update(value=False, visible=not chk_state)
-
-
-def change_picker_color(picker, dominant):
-    if not dominant:
-        return picker
-    return dominant
-
-
-def change_background_mode(chk_state):
-    return gr.ColorPicker.update(value=False, visible=chk_state), \
-        gr.Checkbox.update(value=False, visible=chk_state)
-
-
-
-###########
-
-text_gen = gr.Interface.load("spaces/Avenuenw/prompt-extend")
-
-current_model = models[0]
+    def generate(self, params):
+        response = self._post(f"{self.base}/sd/generate", params)
+        return response.json()
+    
+    def transform(self, params):
+        response = self._post(f"{self.base}/sd/transform", params)
+        return response.json()
+    
+    def controlnet(self, params):
+        response = self._post(f"{self.base}/sd/controlnet", params)
+        return response.json()
+    
+    def get_job(self, job_id):
+        response = self._get(f"{self.base}/job/{job_id}")
+        return response.json()
 
-models2 = []
-for model in models:
-    model_url = f"models/{model['url']}"
-    loaded_model = gr.Interface.load(model_url, live=True, preprocess=True)
-    models2.append(loaded_model)
+    def wait(self, job):
+        job_result = job
 
-def text_it(inputs, text_gen=text_gen):
-    return text_gen(inputs)
+        while job_result['status'] not in ['succeeded', 'failed']:
+            time.sleep(0.25)
+            job_result = self.get_job(job['job'])
 
-def flip_text(x):
-    return x[::-1]
+        return job_result
 
-def send_it(inputs, model_choice):
-    proc = models2[model_choice]
-    return proc(inputs)
+    def list_models(self):
+        response = self._get(f"{self.base}/sd/models")
+        return response.json()
 
+    def list_samplers(self):
+        response = self._get(f"{self.base}/sd/samplers")
+        return response.json()
 
-def flip_image(x):
-    return np.fliplr(x)
+    def _post(self, url, params):
+        headers = {
+            **self.headers,
+            "Content-Type": "application/json"
+        }
+        response = requests.post(url, headers=headers, data=json.dumps(params))
 
+        if response.status_code != 200:
+            raise Exception(f"Bad Prodia Response: {response.status_code}")
 
-def set_model(current_model_index):
-    global current_model
-    current_model = models[current_model_index]
-    return gr.update(value=f"{current_model['name']}")
+        return response
 
-#define inference function
-#First: Get initial images for the grid display 
-def get_initial_images():
-  response = requests.post(API_URL_INITIAL, json={
-            "data": []
-            }).json()
-  #data = response["data"][0]['data'][0][0][:-1]
-  response_dict = response['data'][0]
-  return response_dict  #, [resp[0][:-1] for resp in response["data"][0]["data"]]
+    def _get(self, url):
+        response = requests.get(url, headers=self.headers)
 
-#Second: Process response dictionary to get imges as hyperlinked image tags
-def process_response(response_dict):
-  return [resp[0][:-1] for resp in response_dict["data"]]
+        if response.status_code != 200:
+            raise Exception(f"Bad Prodia Response: {response.status_code}")
 
-response_dict = get_initial_images()
-initial = process_response(response_dict)
-initial_imgs  = '<div style="display: grid; grid-template-columns: repeat(3, 1fr); grid-template-rows: repeat(3, 1fr); grid-gap: 0; background-color: #fff; padding: 20px; box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);">\n' + "\n".join(initial[:-1])
+        return response
 
-#Third: Load more images for the grid
-def get_next10_images(response_dict, row_count):
-    row_count = int(row_count)
-    #print("(1)",type(response_dict))
-    #Convert the string to a dictionary
-    if isinstance(response_dict, dict) == False :
-        response_dict = ast.literal_eval(response_dict)
-    response = requests.post(API_URL_NEXT10, json={
-              "data": [response_dict, row_count ] #len(initial)-1
-               }).json()
-    row_count+=10
-    response_dict = response['data'][0]
-    #print("(2)",type(response))
-    #print("(3)",type(response['data'][0]))
-    next_set  = [resp[0][:-1] for resp in response_dict["data"]]
-    next_set_images = '<div style="display: grid; grid-template-columns: repeat(3, 1fr); grid-template-rows: repeat(3, 1fr); grid-gap: 0; background-color: #fff; padding: 20px; box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2); ">\n' + "\n".join(next_set[:-1])
-    return response_dict, row_count, next_set_images  #response['data'][0]
 
+def image_to_base64(image):
+    # Convert the image to bytes
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")  # You can change format to PNG if needed
+    
+    # Encode the bytes to base64
+    img_str = base64.b64encode(buffered.getvalue())
+
+    return img_str.decode('utf-8')  # Convert bytes to string
+
+
+def remove_id_and_ext(text):
+    text = re.sub(r'\[.*\]$', '', text)
+    extension = text[-12:].strip()
+    if extension == "safetensors":
+        text = text[:-13]
+    elif extension == "ckpt":
+        text = text[:-4]
+    return text
+
+
+def get_data(text):
+    results = {}
+    patterns = {
+        'prompt': r'(.*)',
+        'negative_prompt': r'Negative prompt: (.*)',
+        'steps': r'Steps: (\d+),',
+        'seed': r'Seed: (\d+),',
+        'sampler': r'Sampler:\s*([^\s,]+(?:\s+[^\s,]+)*)', 
+        'model': r'Model:\s*([^\s,]+)',
+        'cfg_scale': r'CFG scale:\s*([\d\.]+)',
+        'size': r'Size:\s*([0-9]+x[0-9]+)'
+        }
+    for key in ['prompt', 'negative_prompt', 'steps', 'seed', 'sampler', 'model', 'cfg_scale', 'size']:
+        match = re.search(patterns[key], text)
+        if match:
+            results[key] = match.group(1)
+        else:
+            results[key] = None
+    if results['size'] is not None:
+        w, h = results['size'].split("x")
+        results['w'] = w
+        results['h'] = h
+    else:
+        results['w'] = None
+        results['h'] = None
+    return results
+
+
+def send_to_txt2img(image):
+
+    result = {tabs: gr.update(selected="t2i")}
 
-with gr.Blocks(css ='main.css') as pan:
-    gr.Markdown("MENU")
+    try:
+        text = image.info['parameters']
+        data = get_data(text)
+        result[prompt] = gr.update(value=data['prompt'])
+        result[negative_prompt] = gr.update(value=data['negative_prompt']) if data['negative_prompt'] is not None else gr.update()
+        result[steps] = gr.update(value=int(data['steps'])) if data['steps'] is not None else gr.update()
+        result[seed] = gr.update(value=int(data['seed'])) if data['seed'] is not None else gr.update()
+        result[cfg_scale] = gr.update(value=float(data['cfg_scale'])) if data['cfg_scale'] is not None else gr.update()
+        result[width] = gr.update(value=int(data['w'])) if data['w'] is not None else gr.update()
+        result[height] = gr.update(value=int(data['h'])) if data['h'] is not None else gr.update()
+        result[sampler] = gr.update(value=data['sampler']) if data['sampler'] is not None else gr.update()
+        if model in model_names:
+            result[model] = gr.update(value=model_names[model])
+        else:
+            result[model] = gr.update()
+        return result
+
+    except Exception as e:
+        print(e)
+
+        return result
+
+
+prodia_client = Prodia(api_key=os.getenv("PRODIA_API_KEY"))
+model_list = prodia_client.list_models()
+model_names = {}
+
+for model_name in model_list:
+    name_without_ext = remove_id_and_ext(model_name)
+    model_names[name_without_ext] = model_name
+
+
+def txt2img(prompt, negative_prompt, model, steps, sampler, cfg_scale, width, height, seed):
+    result = prodia_client.generate({
+        "prompt": prompt,
+        "negative_prompt": negative_prompt,
+        "model": model,
+        "steps": steps,
+        "sampler": sampler,
+        "cfg_scale": cfg_scale,
+        "width": width,
+        "height": height,
+        "seed": seed
+    })
+
+    job = prodia_client.wait(result)
+
+    return job["imageUrl"]
+
+
+def img2img(input_image, denoising, prompt, negative_prompt, model, steps, sampler, cfg_scale, width, height, seed):
+    result = prodia_client.transform({
+        "imageData": image_to_base64(input_image),
+        "denoising_strength": denoising,
+        "prompt": prompt,
+        "negative_prompt": negative_prompt,
+        "model": model,
+        "steps": steps,
+        "sampler": sampler,
+        "cfg_scale": cfg_scale,
+        "width": width,
+        "height": height,
+        "seed": seed
+    })
+
+    job = prodia_client.wait(result)
+
+    return job["imageUrl"]
+
+
+css = """
+#generate {
+    height: 100%;
+}
+"""
+
+with gr.Blocks(css=css) as demo:
+    with gr.Row():
+        with gr.Column(scale=6):
+            model = gr.Dropdown(interactive=True,value="absolutereality_v181.safetensors [3d9d4d2b]", show_label=True, label="Stable Diffusion Checkpoint", choices=prodia_client.list_models())
+  
+        with gr.Column(scale=1):
+            gr.Markdown(elem_id="powered-by-prodia", value="AUTOMATIC1111 Stable Diffusion Web UI.<br>Powered by [Prodia](https://prodia.com).<br>For more features and faster generation times check out our [API Docs](https://docs.prodia.com/reference/getting-started-guide).")
+
+    with gr.Tabs() as tabs:
+        with gr.Tab("txt2img", id='t2i'):
+            with gr.Row():
+                with gr.Column(scale=6, min_width=600):
+                    prompt = gr.Textbox("1girl, Emma Watson, queen, pony tail hair,((full body photo)), photo realistic, high quality, 8k, white tanktop, white shorts,", placeholder="Prompt", show_label=False, lines=3)
+                    negative_prompt = gr.Textbox(placeholder="Negative Prompt", show_label=False, lines=3, value="double body, double face, double features, incorrect posture, close up, two heads, two faces, plastic, Deformed, blurry, bad anatomy, bad eyes, crossed eyes, disfigured, poorly drawn face,")
+                with gr.Column():
+                    text_button = gr.Button("Generate", variant='primary', elem_id="generate")
                     
-    with gr.Tab("TEXT TO IMAGE"):
-        
-    ##model = ("stabilityai/stable-diffusion-2-1")
-         model_name1 = gr.Dropdown(
-                label="Choose Model",
-                choices=[m["name"] for m in models],
-                type="index",
-                value=current_model["name"],
-                interactive=True,
-         )
-         input_text = gr.Textbox(label="Prompt idea",)
-
-        ##  run = gr.Button("Generate Images")
-         with gr.Row():
-             see_prompts = gr.Button("Generate Prompts")
-             run = gr.Button("Generate Images", variant="primary")
-        
-         with gr.Row():
-             magic1 = gr.Textbox(label="Generated Prompt", lines=2)
-             output1 = gr.Image(label="")
-          
-             
-         with gr.Row():    
-             magic2 = gr.Textbox(label="Generated Prompt", lines=2)
-             output2 = gr.Image(label="")
-
-            
-         run.click(send_it, inputs=[magic1, model_name1], outputs=[output1])
-         run.click(send_it, inputs=[magic2, model_name1], outputs=[output2])
-         see_prompts.click(text_it, inputs=[input_text], outputs=[magic1])
-         see_prompts.click(text_it, inputs=[input_text], outputs=[magic2])
-        
-    model_name1.change(set_model, inputs=model_name1, outputs=[output1, output2,])
-        
-    with gr.Tab("AI Library"):
-         #Using Gradio Demos as API - This is Hot!
-#get_next10_images(response_dict=response_dict, row_count=9)
-#position: fixed; top: 0; left: 0; width: 100%; padding: 20px; box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-
-#Defining the Blocks layout
-   # with gr.Blocks(css = """#img_search img {width: 100%; height: 100%; object-fit: cover;}""") as demo:
-         gr.HTML(value="top of page", elem_id="top",visible=False)
-         gr.HTML("""<div style="text-align: center; max-width: 700px; margin: 0 auto;">
-            <div
-            style="
-            display: inline-flex;
-            align-items: center;
-            gap: 0.8rem;
-            font-size: 1.75rem;
-            "
-            >
-            <h1 style="font-weight: 900; margin-bottom: 7px; margin-top: 5px;">
-            Using Gradio API - 2 </h1><br></div>
-            <div><h4 style="font-weight: 500; margin-bottom: 7px; margin-top: 5px;">
-            Stream < href="https://huggingface.co/collections/Dagfinn1962/images-64fc02ca304b8cb412ccda28" target="_blank">Collection Images</a> ina beautiful grid</h4><br>
-            </div>""")
-    with gr.Tab("Gallery"):
-    #with gr.Tab(): #(elem_id = "col-container"):
-          #gr.Column(): #(elem_id = "col-container"):
-             b1 = gr.Button("Load More Images").style(full_width=False)
-             df = gr.Textbox(visible=False,elem_id='dataframe', value=response_dict)
-             row_count = gr.Number(visible=False, value=19 )
-             img_search = gr.HTML(label = 'Images from PlaygroundAI dataset', elem_id="img_search", 
-                                 value=initial_imgs ) #initial[:-1] )
-      
-
-    b1.click(get_next10_images, [df, row_count], [df, row_count, img_search], api_name = "load_playgroundai_images" ) 
-            
-##########################  REM-BG
-    with gr.Tab("Remove Background"):
-        
-        color_state = gr.State(value=False)
-        matting_state = gr.State(value=(0, 0, 0))
-        gr.HTML("<center><h1>Remove Background Tool</h1></center>")
-        
-        with gr.Row(equal_height=False):
-            with gr.Column():
-                input_img = gr.Image(type="pil", label="Input image")
-                drp_models = gr.Dropdown(choices=model_choices, label="Model Segment", value="TracerUniversalB7")
-
             with gr.Row():
-                chk_include_matting = gr.Checkbox(label="Matting", value=False)
-                chk_smoot_mask = gr.Checkbox(label="Smoot Mask", value=False)
-                chk_show_mask = gr.Checkbox(label="Show Mask", value=False)
-            with gr.Box(visible=False) as slider_matting:
-                slr_fg_threshold = gr.Slider(0, 300, value=270, step=1, label="Alpha matting foreground threshold")
-                slr_bg_threshold = gr.Slider(0, 50, value=20, step=1, label="Alpha matting background threshold")
-                slr_erode_size = gr.Slider(0, 20, value=11, step=1, label="Alpha matting erode size")
-            with gr.Box():
-                with gr.Row():
-                    chk_change_color = gr.Checkbox(label="Change background color", value=False)
-                    pkr_color = gr.ColorPicker(label="Pick a new color", visible=False)
-                    chk_dominant = gr.Checkbox(label="Use dominant color", value=False, visible=False)
-
-                #######################
-                    ############################
-                    #############################
-                run_btn = gr.Button(value="Remove background", variant="primary")        
-
-            with gr.Column():
-                output_img = gr.Image(type="pil", label="Image Result")
-                mask_img = gr.Image(type="pil", label="Image Mask", visible=False)
-                gr.ClearButton(components=[input_img, output_img, mask_img])
-
-        chk_include_matting.change(change_include_matting, inputs=[chk_include_matting],
-                               outputs=[slider_matting, matting_state,
-                                        slr_fg_threshold, slr_bg_threshold, slr_erode_size])
-        
-        slr_bg_threshold.change(change_background_threshold, inputs=[slr_bg_threshold, matting_state],
-                            outputs=[matting_state])
-
-        slr_fg_threshold.change(change_foreground_threshold, inputs=[slr_fg_threshold, matting_state],
-                            outputs=[matting_state])
-
-        slr_erode_size.change(change_erode_size, inputs=[slr_erode_size, matting_state],
-                          outputs=[matting_state])
-
-        chk_show_mask.change(change_show_mask, inputs=[chk_show_mask], outputs=[mask_img])
-
-        chk_change_color.change(change_background_mode, inputs=[chk_change_color],
-                            outputs=[pkr_color, chk_dominant])
-
-        pkr_color.change(change_picker_color, inputs=[pkr_color, chk_dominant], outputs=[color_state])
-
-        chk_dominant.change(set_dominant_color, inputs=[chk_dominant], outputs=[color_state, pkr_color])
-
-        run_btn.click(predict, inputs=[input_img, drp_models, chk_smoot_mask, matting_state, color_state],
-                  outputs=[output_img, mask_img])
-
-
-                
-#            text_input = gr.Textbox()                      ##   Diffuser
-#            image_output = gr.Image()
-#        image_button = gr.Button("Flip")
+                with gr.Column(scale=3):
+                    with gr.Tab("Generation"):
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                sampler = gr.Dropdown(value="DPM++ 2M Karras", show_label=True, label="Sampling Method", choices=prodia_client.list_samplers())
+                                
+                            with gr.Column(scale=1):
+                                steps = gr.Slider(label="Sampling Steps", minimum=1, maximum=25, value=20, step=1)
+    
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                width = gr.Slider(label="Width", maximum=1024, value=512, step=8)
+                                height = gr.Slider(label="Height", maximum=1024, value=512, step=8)
+                            
+                            with gr.Column(scale=1):
+                                batch_size = gr.Slider(label="Batch Size", maximum=1, value=1)
+                                batch_count = gr.Slider(label="Batch Count", maximum=1, value=1)
+    
+                        cfg_scale = gr.Slider(label="CFG Scale", minimum=1, maximum=20, value=7, step=1)
+                        seed = gr.Number(label="Seed", value=-1)
 
+                with gr.Column(scale=2):
+                    image_output = gr.Image(value="https://images.prodia.xyz/8ede1a7c-c0ee-4ded-987d-6ffed35fc477.png")
+    
+            text_button.click(txt2img, inputs=[prompt, negative_prompt, model, steps, sampler, cfg_scale, width, height,
+                                               seed], outputs=image_output, concurrency_limit=64)
+        
+        with gr.Tab("img2img", id='i2i'):
+            with gr.Row():
+                with gr.Column(scale=6, min_width=600):
+                    i2i_prompt = gr.Textbox("space warrior, beautiful, female, ultrarealistic, soft lighting, 8k", placeholder="Prompt", show_label=False, lines=3)
+                    i2i_negative_prompt = gr.Textbox(placeholder="Negative Prompt", show_label=False, lines=3, value="3d, cartoon, anime, (deformed eyes, nose, ears, nose), bad anatomy, ugly")
+                with gr.Column():
+                    i2i_text_button = gr.Button("Generate", variant='primary', elem_id="generate")
+                    
+            with gr.Row():
+                with gr.Column(scale=3):
+                    with gr.Tab("Generation"):
+                        i2i_image_input = gr.Image(type="pil")
+
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                i2i_sampler = gr.Dropdown(value="Euler a", show_label=True, label="Sampling Method", choices=prodia_client.list_samplers())
+                                
+                            with gr.Column(scale=1):
+                                i2i_steps = gr.Slider(label="Sampling Steps", minimum=1, maximum=25, value=20, step=1)
+
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                i2i_width = gr.Slider(label="Width", maximum=1024, value=512, step=8)
+                                i2i_height = gr.Slider(label="Height", maximum=1024, value=512, step=8)
+                            
+                            with gr.Column(scale=1):
+                                i2i_batch_size = gr.Slider(label="Batch Size", maximum=1, value=1)
+                                i2i_batch_count = gr.Slider(label="Batch Count", maximum=1, value=1)
+    
+                        i2i_cfg_scale = gr.Slider(label="CFG Scale", minimum=1, maximum=20, value=7, step=1)
+                        i2i_denoising = gr.Slider(label="Denoising Strength", minimum=0, maximum=1, value=0.7, step=0.1)
+                        i2i_seed = gr.Number(label="Seed", value=-1)
 
+                with gr.Column(scale=2):
+                    i2i_image_output = gr.Image(value="https://images.prodia.xyz/8ede1a7c-c0ee-4ded-987d-6ffed35fc477.png")
+    
+            i2i_text_button.click(img2img, inputs=[i2i_image_input, i2i_denoising, i2i_prompt, i2i_negative_prompt,
+                                                   model, i2i_steps, i2i_sampler, i2i_cfg_scale, i2i_width, i2i_height,
+                                                   i2i_seed], outputs=i2i_image_output, concurrency_limit=64)
+        
+        with gr.Tab("PNG Info"):
+            def plaintext_to_html(text, classname=None):
+                content = "<br>\n".join(html.escape(x) for x in text.split('\n'))
+    
+                return f"<p class='{classname}'>{content}</p>" if classname else f"<p>{content}</p>"
+    
+    
+            def get_exif_data(image):
+                items = image.info
+    
+                info = ''
+                for key, text in items.items():
+                    info += f"""
+                    <div>
+                    <p><b>{plaintext_to_html(str(key))}</b></p>
+                    <p>{plaintext_to_html(str(text))}</p>
+                    </div>
+                    """.strip()+"\n"
+    
+                if len(info) == 0:
+                    message = "Nothing found in the image."
+                    info = f"<div><p>{message}<p></div>"
+    
+                return info
+    
+            with gr.Row():
+                with gr.Column():
+                    image_input = gr.Image(type="pil")
+                    
+                with gr.Column():
+                    exif_output = gr.HTML(label="EXIF Data")
+                    send_to_txt2img_btn = gr.Button("Send to txt2img")
+    
+            image_input.upload(get_exif_data, inputs=[image_input], outputs=exif_output)
+            send_to_txt2img_btn.click(send_to_txt2img, inputs=[image_input], outputs=[tabs, prompt, negative_prompt,
+                                                                                      steps, seed, model, sampler,
+                                                                                      width, height, cfg_scale],
+                                      concurrency_limit=64)
 
-   # text_button.click(flip_text, inputs=text_input, outputs=text_output)
-   # image_button.click(flip_image, inputs=image_input, outputs=image_output)
-pan.queue(concurrency_count=200)
-pan.launch(inline=True, show_api=True,  max_threads=400 )
+demo.queue(max_size=80, api_open=False).launch(max_threads=256, show_api=False)