Merge branch 'master' into tensorboard

1 files changed, 770 insertions, 781 deletions

diff --git a/modules/ui.py b/modules/ui.py
index a2dbd41e..e86a624b 100644
--- a/modules/ui.py
+++ b/modules/ui.py
@@ -1,62 +1,63 @@
-import base64

 import html

-import io

 import json

 import math

 import mimetypes

 import os

+import platform

 import random

+import subprocess as sp

 import sys

 import tempfile

 import time

 import traceback

-import platform

-import subprocess as sp

 from functools import partial, reduce

 

-import numpy as np

-import torch

-from PIL import Image, PngImagePlugin

-import piexif

-

 import gradio as gr

-import gradio.utils

 import gradio.routes

+import gradio.utils

+import numpy as np

+from PIL import Image, PngImagePlugin

+from modules.call_queue import wrap_gradio_gpu_call, wrap_queued_call, wrap_gradio_call

 

-from modules import sd_hijack, sd_models, localization

+from modules import sd_hijack, sd_models, localization, script_callbacks, ui_extensions, deepbooru

+from modules.ui_components import FormRow, FormGroup, ToolButton, FormHTML

 from modules.paths import script_path

+

 from modules.shared import opts, cmd_opts, restricted_opts

-if cmd_opts.deepdanbooru:

-    from modules.deepbooru import get_deepbooru_tags

-import modules.shared as shared

-from modules.sd_samplers import samplers, samplers_for_img2img

-from modules.sd_hijack import model_hijack

-import modules.ldsr_model

-import modules.scripts

-import modules.gfpgan_model

+

 import modules.codeformer_model

+import modules.generation_parameters_copypaste as parameters_copypaste

+import modules.gfpgan_model

+import modules.hypernetworks.ui

+import modules.scripts

+import modules.shared as shared

 import modules.styles

-import modules.generation_parameters_copypaste

+import modules.textual_inversion.ui

 from modules import prompt_parser

 from modules.images import save_image

-import modules.textual_inversion.ui

+from modules.sd_hijack import model_hijack

+from modules.sd_samplers import samplers, samplers_for_img2img

+from modules.textual_inversion import textual_inversion

 import modules.hypernetworks.ui

-import modules.images_history as img_his

+from modules.generation_parameters_copypaste import image_from_url_text

 

 # this is a fix for Windows users. Without it, javascript files will be served with text/html content-type and the browser will not show any UI

 mimetypes.init()

 mimetypes.add_type('application/javascript', '.js')

 

-

 if not cmd_opts.share and not cmd_opts.listen:

     # fix gradio phoning home

     gradio.utils.version_check = lambda: None

     gradio.utils.get_local_ip_address = lambda: '127.0.0.1'

 

-if cmd_opts.ngrok != None:

+if cmd_opts.ngrok is not None:

     import modules.ngrok as ngrok

     print('ngrok authtoken detected, trying to connect...')

-    ngrok.connect(cmd_opts.ngrok, cmd_opts.port if cmd_opts.port != None else 7860, cmd_opts.ngrok_region)

+    ngrok.connect(

+        cmd_opts.ngrok,

+        cmd_opts.port if cmd_opts.port is not None else 7860,

+        cmd_opts.ngrok_region

+        )

 

 

 def gr_show(visible=True):

@@ -69,57 +70,34 @@ sample_img2img = sample_img2img if os.path.exists(sample_img2img) else None
 css_hide_progressbar = """

 .wrap .m-12 svg { display:none!important; }

 .wrap .m-12::before { content:"Loading..." }

+.wrap .z-20 svg { display:none!important; }

+.wrap .z-20::before { content:"Loading..." }

 .progress-bar { display:none!important; }

 .meta-text { display:none!important; }

+.meta-text-center { display:none!important; }

 """

 

 # Using constants for these since the variation selector isn't visible.

 # Important that they exactly match script.js for tooltip to work.

 random_symbol = '\U0001f3b2\ufe0f'  # 🎲️

 reuse_symbol = '\u267b\ufe0f'  # ♻️

-art_symbol = '\U0001f3a8'  # 🎨

 paste_symbol = '\u2199\ufe0f'  # ↙

 folder_symbol = '\U0001f4c2'  # 📂

 refresh_symbol = '\U0001f504'  # 🔄

 save_style_symbol = '\U0001f4be'  # 💾

 apply_style_symbol = '\U0001f4cb'  # 📋

+clear_prompt_symbol = '\U0001F5D1'  # 🗑️

 

 

 def plaintext_to_html(text):

     text = "<p>" + "<br>\n".join([f"{html.escape(x)}" for x in text.split('\n')]) + "</p>"

     return text

 

-

-def image_from_url_text(filedata):

-    if type(filedata) == dict and filedata["is_file"]:

-        filename = filedata["name"]

-        tempdir = os.path.normpath(tempfile.gettempdir())

-        normfn = os.path.normpath(filename)

-        assert normfn.startswith(tempdir), 'trying to open image file not in temporary directory'

-

-        return Image.open(filename)

-

-    if type(filedata) == list:

-        if len(filedata) == 0:

-            return None

-

-        filedata = filedata[0]

-

-    if filedata.startswith("data:image/png;base64,"):

-        filedata = filedata[len("data:image/png;base64,"):]

-

-    filedata = base64.decodebytes(filedata.encode('utf-8'))

-    image = Image.open(io.BytesIO(filedata))

-    return image

-

-

 def send_gradio_gallery_to_image(x):

     if len(x) == 0:

         return None

-

     return image_from_url_text(x[0])

 

-

 def save_files(js_data, images, do_make_zip, index):

     import csv

     filenames = []

@@ -168,7 +146,7 @@ def save_files(js_data, images, do_make_zip, index):
                 filenames.append(os.path.basename(txt_fullfn))

                 fullfns.append(txt_fullfn)

 

-        writer.writerow([data["prompt"], data["seed"], data["width"], data["height"], data["sampler"], data["cfg_scale"], data["steps"], filenames[0], data["negative_prompt"]])

+        writer.writerow([data["prompt"], data["seed"], data["width"], data["height"], data["sampler_name"], data["cfg_scale"], data["steps"], filenames[0], data["negative_prompt"]])

 

     # Make Zip

     if do_make_zip:

@@ -181,166 +159,7 @@ def save_files(js_data, images, do_make_zip, index):
                     zip_file.writestr(filenames[i], f.read())

         fullfns.insert(0, zip_filepath)

 

-    return gr.File.update(value=fullfns, visible=True), '', '', plaintext_to_html(f"Saved: {filenames[0]}")

-

-

-def save_pil_to_file(pil_image, dir=None):

-    use_metadata = False

-    metadata = PngImagePlugin.PngInfo()

-    for key, value in pil_image.info.items():

-        if isinstance(key, str) and isinstance(value, str):

-            metadata.add_text(key, value)

-            use_metadata = True

-

-    file_obj = tempfile.NamedTemporaryFile(delete=False, suffix=".png", dir=dir)

-    pil_image.save(file_obj, pnginfo=(metadata if use_metadata else None))

-    return file_obj

-

-

-# override save to file function so that it also writes PNG info

-gr.processing_utils.save_pil_to_file = save_pil_to_file

-

-

-def wrap_gradio_call(func, extra_outputs=None):

-    def f(*args, extra_outputs_array=extra_outputs, **kwargs):

-        run_memmon = opts.memmon_poll_rate > 0 and not shared.mem_mon.disabled

-        if run_memmon:

-            shared.mem_mon.monitor()

-        t = time.perf_counter()

-

-        try:

-            res = list(func(*args, **kwargs))

-        except Exception as e:

-            # When printing out our debug argument list, do not print out more than a MB of text

-            max_debug_str_len = 131072 # (1024*1024)/8

-

-            print("Error completing request", file=sys.stderr)

-            argStr = f"Arguments: {str(args)} {str(kwargs)}"

-            print(argStr[:max_debug_str_len], file=sys.stderr)

-            if len(argStr) > max_debug_str_len:

-                print(f"(Argument list truncated at {max_debug_str_len}/{len(argStr)} characters)", file=sys.stderr)

-

-            print(traceback.format_exc(), file=sys.stderr)

-

-            shared.state.job = ""

-            shared.state.job_count = 0

-

-            if extra_outputs_array is None:

-                extra_outputs_array = [None, '']

-

-            res = extra_outputs_array + [f"<div class='error'>{plaintext_to_html(type(e).__name__+': '+str(e))}</div>"]

-

-        elapsed = time.perf_counter() - t

-        elapsed_m = int(elapsed // 60)

-        elapsed_s = elapsed % 60

-        elapsed_text = f"{elapsed_s:.2f}s"

-        if (elapsed_m > 0):

-            elapsed_text = f"{elapsed_m}m "+elapsed_text

-

-        if run_memmon:

-            mem_stats = {k: -(v//-(1024*1024)) for k, v in shared.mem_mon.stop().items()}

-            active_peak = mem_stats['active_peak']

-            reserved_peak = mem_stats['reserved_peak']

-            sys_peak = mem_stats['system_peak']

-            sys_total = mem_stats['total']

-            sys_pct = round(sys_peak/max(sys_total, 1) * 100, 2)

-

-            vram_html = f"<p class='vram'>Torch active/reserved: {active_peak}/{reserved_peak} MiB, <wbr>Sys VRAM: {sys_peak}/{sys_total} MiB ({sys_pct}%)</p>"

-        else:

-            vram_html = ''

-

-        # last item is always HTML

-        res[-1] += f"<div class='performance'><p class='time'>Time taken: <wbr>{elapsed_text}</p>{vram_html}</div>"

-

-        shared.state.skipped = False

-        shared.state.interrupted = False

-        shared.state.job_count = 0

-

-        return tuple(res)

-

-    return f

-

-

-def calc_time_left(progress, threshold, label, force_display):

-    if progress == 0:

-        return ""

-    else:

-        time_since_start = time.time() - shared.state.time_start

-        eta = (time_since_start/progress)

-        eta_relative = eta-time_since_start

-        if (eta_relative > threshold and progress > 0.02) or force_display:

-            if eta_relative > 3600:

-                return label + time.strftime('%H:%M:%S', time.gmtime(eta_relative))

-            elif eta_relative > 60:

-                return label + time.strftime('%M:%S',  time.gmtime(eta_relative))

-            else:

-                return label + time.strftime('%Ss',  time.gmtime(eta_relative))

-        else:

-            return ""

-

-

-def check_progress_call(id_part):

-    if shared.state.job_count == 0:

-        return "", gr_show(False), gr_show(False), gr_show(False)

-

-    progress = 0

-

-    if shared.state.job_count > 0:

-        progress += shared.state.job_no / shared.state.job_count

-    if shared.state.sampling_steps > 0:

-        progress += 1 / shared.state.job_count * shared.state.sampling_step / shared.state.sampling_steps

-

-    time_left = calc_time_left( progress, 1, " ETA: ", shared.state.time_left_force_display )

-    if time_left != "":

-        shared.state.time_left_force_display = True

-

-    progress = min(progress, 1)

-

-    progressbar = ""

-    if opts.show_progressbar:

-        progressbar = f"""<div class='progressDiv'><div class='progress' style="overflow:visible;width:{progress * 100}%;white-space:nowrap;">{"&nbsp;" * 2 + str(int(progress*100))+"%" + time_left if progress > 0.01 else ""}</div></div>"""

-

-    image = gr_show(False)

-    preview_visibility = gr_show(False)

-

-    if opts.show_progress_every_n_steps > 0:

-        if shared.parallel_processing_allowed:

-

-            if shared.state.sampling_step - shared.state.current_image_sampling_step >= opts.show_progress_every_n_steps and shared.state.current_latent is not None:

-                shared.state.current_image = modules.sd_samplers.sample_to_image(shared.state.current_latent)

-                shared.state.current_image_sampling_step = shared.state.sampling_step

-

-        image = shared.state.current_image

-

-        if image is None:

-            image = gr.update(value=None)

-        else:

-            preview_visibility = gr_show(True)

-

-    if shared.state.textinfo is not None:

-        textinfo_result = gr.HTML.update(value=shared.state.textinfo, visible=True)

-    else:

-        textinfo_result = gr_show(False)

-

-    return f"<span id='{id_part}_progress_span' style='display: none'>{time.time()}</span><p>{progressbar}</p>", preview_visibility, image, textinfo_result

-

-

-def check_progress_call_initial(id_part):

-    shared.state.job_count = -1

-    shared.state.current_latent = None

-    shared.state.current_image = None

-    shared.state.textinfo = None

-    shared.state.time_start = time.time()

-    shared.state.time_left_force_display = False

-

-    return check_progress_call(id_part)

-

-

-def roll_artist(prompt):

-    allowed_cats = set([x for x in shared.artist_db.categories() if len(opts.random_artist_categories)==0 or x in opts.random_artist_categories])

-    artist = random.choice([x for x in shared.artist_db.artists if x.category in allowed_cats])

-

-    return prompt + ", " + artist.name if prompt != '' else artist.name

+    return gr.File.update(value=fullfns, visible=True), plaintext_to_html(f"Saved: {filenames[0]}")

 

 

 def visit(x, func, path=""):

@@ -364,6 +183,20 @@ def add_style(name: str, prompt: str, negative_prompt: str):
     return [gr.Dropdown.update(visible=True, choices=list(shared.prompt_styles.styles)) for _ in range(4)]

 

 

+def calc_resolution_hires(enable, width, height, hr_scale, hr_resize_x, hr_resize_y):

+    from modules import processing, devices

+

+    if not enable:

+        return ""

+

+    p = processing.StableDiffusionProcessingTxt2Img(width=width, height=height, enable_hr=True, hr_scale=hr_scale, hr_resize_x=hr_resize_x, hr_resize_y=hr_resize_y)

+

+    with devices.autocast():

+        p.init([""], [0], [0])

+

+    return f"resize: from <span class='resolution'>{p.width}x{p.height}</span> to <span class='resolution'>{p.hr_resize_x or p.hr_upscale_to_x}x{p.hr_resize_y or p.hr_upscale_to_y}</span>"

+

+

 def apply_styles(prompt, prompt_neg, style1_name, style2_name):

     prompt = shared.prompt_styles.apply_styles_to_prompt(prompt, [style1_name, style2_name])

     prompt_neg = shared.prompt_styles.apply_negative_styles_to_prompt(prompt_neg, [style1_name, style2_name])

@@ -372,45 +205,41 @@ def apply_styles(prompt, prompt_neg, style1_name, style2_name):
 

 

 def interrogate(image):

-    prompt = shared.interrogator.interrogate(image)

+    prompt = shared.interrogator.interrogate(image.convert("RGB"))

 

     return gr_show(True) if prompt is None else prompt

 

 

 def interrogate_deepbooru(image):

-    prompt = get_deepbooru_tags(image)

+    prompt = deepbooru.model.tag(image)

     return gr_show(True) if prompt is None else prompt

 

 

-def create_seed_inputs():

-    with gr.Row():

-        with gr.Box():

-            with gr.Row(elem_id='seed_row'):

-                seed = (gr.Textbox if cmd_opts.use_textbox_seed else gr.Number)(label='Seed', value=-1)

-                seed.style(container=False)

-                random_seed = gr.Button(random_symbol, elem_id='random_seed')

-                reuse_seed = gr.Button(reuse_symbol, elem_id='reuse_seed')

+def create_seed_inputs(target_interface):

+    with FormRow(elem_id=target_interface + '_seed_row'):

+        seed = (gr.Textbox if cmd_opts.use_textbox_seed else gr.Number)(label='Seed', value=-1, elem_id=target_interface + '_seed')

+        seed.style(container=False)

+        random_seed = gr.Button(random_symbol, elem_id=target_interface + '_random_seed')

+        reuse_seed = gr.Button(reuse_symbol, elem_id=target_interface + '_reuse_seed')

 

-        with gr.Box(elem_id='subseed_show_box'):

-            seed_checkbox = gr.Checkbox(label='Extra', elem_id='subseed_show', value=False)

+        with gr.Group(elem_id=target_interface + '_subseed_show_box'):

+            seed_checkbox = gr.Checkbox(label='Extra', elem_id=target_interface + '_subseed_show', value=False)

 

     # Components to show/hide based on the 'Extra' checkbox

     seed_extras = []

 

-    with gr.Row(visible=False) as seed_extra_row_1:

+    with FormRow(visible=False, elem_id=target_interface + '_subseed_row') as seed_extra_row_1:

         seed_extras.append(seed_extra_row_1)

-        with gr.Box():

-            with gr.Row(elem_id='subseed_row'):

-                subseed = gr.Number(label='Variation seed', value=-1)

-                subseed.style(container=False)

-                random_subseed = gr.Button(random_symbol, elem_id='random_subseed')

-                reuse_subseed = gr.Button(reuse_symbol, elem_id='reuse_subseed')

-        subseed_strength = gr.Slider(label='Variation strength', value=0.0, minimum=0, maximum=1, step=0.01)

-

-    with gr.Row(visible=False) as seed_extra_row_2:

+        subseed = gr.Number(label='Variation seed', value=-1, elem_id=target_interface + '_subseed')

+        subseed.style(container=False)

+        random_subseed = gr.Button(random_symbol, elem_id=target_interface + '_random_subseed')

+        reuse_subseed = gr.Button(reuse_symbol, elem_id=target_interface + '_reuse_subseed')

+        subseed_strength = gr.Slider(label='Variation strength', value=0.0, minimum=0, maximum=1, step=0.01, elem_id=target_interface + '_subseed_strength')

+

+    with FormRow(visible=False) as seed_extra_row_2:

         seed_extras.append(seed_extra_row_2)

-        seed_resize_from_w = gr.Slider(minimum=0, maximum=2048, step=64, label="Resize seed from width", value=0)

-        seed_resize_from_h = gr.Slider(minimum=0, maximum=2048, step=64, label="Resize seed from height", value=0)

+        seed_resize_from_w = gr.Slider(minimum=0, maximum=2048, step=8, label="Resize seed from width", value=0, elem_id=target_interface + '_seed_resize_from_w')

+        seed_resize_from_h = gr.Slider(minimum=0, maximum=2048, step=8, label="Resize seed from height", value=0, elem_id=target_interface + '_seed_resize_from_h')

 

     random_seed.click(fn=lambda: -1, show_progress=False, inputs=[], outputs=[seed])

     random_subseed.click(fn=lambda: -1, show_progress=False, inputs=[], outputs=[subseed])

@@ -423,6 +252,17 @@ def create_seed_inputs():
     return seed, reuse_seed, subseed, reuse_subseed, subseed_strength, seed_resize_from_h, seed_resize_from_w, seed_checkbox

 

 

+

+def connect_clear_prompt(button):

+    """Given clear button, prompt, and token_counter objects, setup clear prompt button click event"""

+    button.click(

+        _js="clear_prompt",

+        fn=None,

+        inputs=[],

+        outputs=[],

+    )

+

+

 def connect_reuse_seed(seed: gr.Number, reuse_seed: gr.Button, generation_info: gr.Textbox, dummy_component, is_subseed):

     """ Connects a 'reuse (sub)seed' button's click event so that it copies last used

         (sub)seed value from generation info the to the seed field. If copying subseed and subseed strength

@@ -469,7 +309,7 @@ def update_token_counter(text, steps):
 

     flat_prompts = reduce(lambda list1, list2: list1+list2, prompt_schedules)

     prompts = [prompt_text for step, prompt_text in flat_prompts]

-    tokens, token_count, max_length = max([model_hijack.tokenize(prompt) for prompt in prompts], key=lambda args: args[1])

+    token_count, max_length = max([model_hijack.get_prompt_lengths(prompt) for prompt in prompts], key=lambda args: args[0])

     style_class = ' class="red"' if (token_count > max_length) else ""

     return f"<span {style_class}>{token_count}/{max_length}</span>"

 

@@ -494,22 +334,26 @@ def create_toprow(is_img2img):
                         )

 

         with gr.Column(scale=1, elem_id="roll_col"):

-            roll = gr.Button(value=art_symbol, elem_id="roll", visible=len(shared.artist_db.artists) > 0)

             paste = gr.Button(value=paste_symbol, elem_id="paste")

             save_style = gr.Button(value=save_style_symbol, elem_id="style_create")

             prompt_style_apply = gr.Button(value=apply_style_symbol, elem_id="style_apply")

-

+            clear_prompt_button = gr.Button(value=clear_prompt_symbol, elem_id=f"{id_part}_clear_prompt")

             token_counter = gr.HTML(value="<span></span>", elem_id=f"{id_part}_token_counter")

             token_button = gr.Button(visible=False, elem_id=f"{id_part}_token_button")

 

+            clear_prompt_button.click(

+                fn=lambda *x: x,

+                _js="confirm_clear_prompt",

+                inputs=[prompt, negative_prompt],

+                outputs=[prompt, negative_prompt],

+            )

+

         button_interrogate = None

         button_deepbooru = None

         if is_img2img:

             with gr.Column(scale=1, elem_id="interrogate_col"):

                 button_interrogate = gr.Button('Interrogate\nCLIP', elem_id="interrogate")

-

-                if cmd_opts.deepdanbooru:

-                    button_deepbooru = gr.Button('Interrogate\nDeepBooru', elem_id="deepbooru")

+                button_deepbooru = gr.Button('Interrogate\nDeepBooru', elem_id="deepbooru")

 

         with gr.Column(scale=1):

             with gr.Row():

@@ -532,40 +376,26 @@ def create_toprow(is_img2img):
             with gr.Row():

                 with gr.Column(scale=1, elem_id="style_pos_col"):

                     prompt_style = gr.Dropdown(label="Style 1", elem_id=f"{id_part}_style_index", choices=[k for k, v in shared.prompt_styles.styles.items()], value=next(iter(shared.prompt_styles.styles.keys())))

-                    prompt_style.save_to_config = True

 

                 with gr.Column(scale=1, elem_id="style_neg_col"):

                     prompt_style2 = gr.Dropdown(label="Style 2", elem_id=f"{id_part}_style2_index", choices=[k for k, v in shared.prompt_styles.styles.items()], value=next(iter(shared.prompt_styles.styles.keys())))

-                    prompt_style2.save_to_config = True

 

-    return prompt, roll, prompt_style, negative_prompt, prompt_style2, submit, button_interrogate, button_deepbooru, prompt_style_apply, save_style, paste, token_counter, token_button

+    return prompt, prompt_style, negative_prompt, prompt_style2, submit, button_interrogate, button_deepbooru, prompt_style_apply, save_style, paste, token_counter, token_button

 

 

-def setup_progressbar(progressbar, preview, id_part, textinfo=None):

-    if textinfo is None:

-        textinfo = gr.HTML(visible=False)

+def setup_progressbar(*args, **kwargs):

+    import modules.ui_progress

 

-    check_progress = gr.Button('Check progress', elem_id=f"{id_part}_check_progress", visible=False)

-    check_progress.click(

-        fn=lambda: check_progress_call(id_part),

-        show_progress=False,

-        inputs=[],

-        outputs=[progressbar, preview, preview, textinfo],

-    )

-

-    check_progress_initial = gr.Button('Check progress (first)', elem_id=f"{id_part}_check_progress_initial", visible=False)

-    check_progress_initial.click(

-        fn=lambda: check_progress_call_initial(id_part),

-        show_progress=False,

-        inputs=[],

-        outputs=[progressbar, preview, preview, textinfo],

-    )

+    modules.ui_progress.setup_progressbar(*args, **kwargs)

 

 

 def apply_setting(key, value):

     if value is None:

         return gr.update()

 

+    if shared.cmd_opts.freeze_settings:

+        return gr.update()

+

     # dont allow model to be swapped when model hash exists in prompt

     if key == "sd_model_checkpoint" and opts.disable_weights_auto_swap:

         return gr.update()

@@ -583,7 +413,7 @@ def apply_setting(key, value):
         return

 

     valtype = type(opts.data_labels[key].default)

-    oldval = opts.data[key]

+    oldval = opts.data.get(key, None)

     opts.data[key] = valtype(value) if valtype != type(None) else value

     if oldval != value and opts.data_labels[key].onchange is not None:

         opts.data_labels[key].onchange()

@@ -592,102 +422,264 @@ def apply_setting(key, value):
     return value

 

 

-def create_ui(wrap_gradio_gpu_call):

-    import modules.img2img

-    import modules.txt2img

+def update_generation_info(args):

+    generation_info, html_info, img_index = args

+    try:

+        generation_info = json.loads(generation_info)

+        if img_index < 0 or img_index >= len(generation_info["infotexts"]):

+            return html_info

+        return plaintext_to_html(generation_info["infotexts"][img_index])

+    except Exception:

+        pass

+    # if the json parse or anything else fails, just return the old html_info

+    return html_info

 

-    def create_refresh_button(refresh_component, refresh_method, refreshed_args, elem_id):

-        def refresh():

-            refresh_method()

-            args = refreshed_args() if callable(refreshed_args) else refreshed_args

 

-            for k, v in args.items():

-                setattr(refresh_component, k, v)

+def create_refresh_button(refresh_component, refresh_method, refreshed_args, elem_id):

+    def refresh():

+        refresh_method()

+        args = refreshed_args() if callable(refreshed_args) else refreshed_args

 

-            return gr.update(**(args or {}))

+        for k, v in args.items():

+            setattr(refresh_component, k, v)

 

-        refresh_button = gr.Button(value=refresh_symbol, elem_id=elem_id)

-        refresh_button.click(

-            fn = refresh,

-            inputs = [],

-            outputs = [refresh_component]

-        )

-        return refresh_button

+        return gr.update(**(args or {}))

 

-    with gr.Blocks(analytics_enabled=False) as txt2img_interface:

-        txt2img_prompt, roll, txt2img_prompt_style, txt2img_negative_prompt, txt2img_prompt_style2, submit, _, _, txt2img_prompt_style_apply, txt2img_save_style, txt2img_paste, token_counter, token_button = create_toprow(is_img2img=False)

-        dummy_component = gr.Label(visible=False)

-        txt_prompt_img = gr.File(label="", elem_id="txt2img_prompt_image", file_count="single", type="bytes", visible=False)

+    refresh_button = ToolButton(value=refresh_symbol, elem_id=elem_id)

+    refresh_button.click(

+        fn=refresh,

+        inputs=[],

+        outputs=[refresh_component]

+    )

+    return refresh_button

 

-        with gr.Row(elem_id='txt2img_progress_row'):

-            with gr.Column(scale=1):

-                pass

 

-            with gr.Column(scale=1):

-                progressbar = gr.HTML(elem_id="txt2img_progressbar")

-                txt2img_preview = gr.Image(elem_id='txt2img_preview', visible=False)

-                setup_progressbar(progressbar, txt2img_preview, 'txt2img')

+def create_output_panel(tabname, outdir):

+    def open_folder(f):

+        if not os.path.exists(f):

+            print(f'Folder "{f}" does not exist. After you create an image, the folder will be created.')

+            return

+        elif not os.path.isdir(f):

+            print(f"""

+WARNING

+An open_folder request was made with an argument that is not a folder.

+This could be an error or a malicious attempt to run code on your computer.

+Requested path was: {f}

+""", file=sys.stderr)

+            return

 

-        with gr.Row().style(equal_height=False):

-            with gr.Column(variant='panel'):

-                steps = gr.Slider(minimum=1, maximum=150, step=1, label="Sampling Steps", value=20)

-                sampler_index = gr.Radio(label='Sampling method', elem_id="txt2img_sampling", choices=[x.name for x in samplers], value=samplers[0].name, type="index")

+        if not shared.cmd_opts.hide_ui_dir_config:

+            path = os.path.normpath(f)

+            if platform.system() == "Windows":

+                os.startfile(path)

+            elif platform.system() == "Darwin":

+                sp.Popen(["open", path])

+            elif "microsoft-standard-WSL2" in platform.uname().release:

+                sp.Popen(["wsl-open", path])

+            else:

+                sp.Popen(["xdg-open", path])

 

-                with gr.Group():

-                    width = gr.Slider(minimum=64, maximum=2048, step=64, label="Width", value=512)

-                    height = gr.Slider(minimum=64, maximum=2048, step=64, label="Height", value=512)

+    with gr.Column(variant='panel'):

+            with gr.Group():

+                result_gallery = gr.Gallery(label='Output', show_label=False, elem_id=f"{tabname}_gallery").style(grid=4)

 

-                with gr.Row():

-                    restore_faces = gr.Checkbox(label='Restore faces', value=False, visible=len(shared.face_restorers) > 1)

-                    tiling = gr.Checkbox(label='Tiling', value=False)

-                    enable_hr = gr.Checkbox(label='Highres. fix', value=False)

+            generation_info = None

+            with gr.Column():

+                with gr.Row(elem_id=f"image_buttons_{tabname}"):

+                    open_folder_button = gr.Button(folder_symbol, elem_id="hidden_element" if shared.cmd_opts.hide_ui_dir_config else f'open_folder_{tabname}')

+

+                    if tabname != "extras":

+                        save = gr.Button('Save', elem_id=f'save_{tabname}')

+                        save_zip = gr.Button('Zip', elem_id=f'save_zip_{tabname}')

+

+                    buttons = parameters_copypaste.create_buttons(["img2img", "inpaint", "extras"])

+

+                open_folder_button.click(

+                    fn=lambda: open_folder(opts.outdir_samples or outdir),

+                    inputs=[],

+                    outputs=[],

+                )

 

-                with gr.Row(visible=False) as hr_options:

-                    firstphase_width = gr.Slider(minimum=0, maximum=1024, step=64, label="Firstpass width", value=0)

-                    firstphase_height = gr.Slider(minimum=0, maximum=1024, step=64, label="Firstpass height", value=0)

-                    denoising_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label='Denoising strength', value=0.7)

+                if tabname != "extras":

+                    with gr.Row():

+                        download_files = gr.File(None, file_count="multiple", interactive=False, show_label=False, visible=False, elem_id=f'download_files_{tabname}')

 

-                with gr.Row(equal_height=True):

-                    batch_count = gr.Slider(minimum=1, step=1, label='Batch count', value=1)

-                    batch_size = gr.Slider(minimum=1, maximum=8, step=1, label='Batch size', value=1)

+                    with gr.Group():

+                        html_info = gr.HTML(elem_id=f'html_info_{tabname}')

+                        html_log = gr.HTML(elem_id=f'html_log_{tabname}')

+

+                        generation_info = gr.Textbox(visible=False, elem_id=f'generation_info_{tabname}')

+                        if tabname == 'txt2img' or tabname == 'img2img':

+                            generation_info_button = gr.Button(visible=False, elem_id=f"{tabname}_generation_info_button")

+                            generation_info_button.click(

+                                fn=update_generation_info,

+                                _js="(x, y) => [x, y, selected_gallery_index()]",

+                                inputs=[generation_info, html_info],

+                                outputs=[html_info],

+                                preprocess=False

+                            )

+

+                        save.click(

+                            fn=wrap_gradio_call(save_files),

+                            _js="(x, y, z, w) => [x, y, false, selected_gallery_index()]",

+                            inputs=[

+                                generation_info,

+                                result_gallery,

+                                html_info,

+                                html_info,

+                            ],

+                            outputs=[

+                                download_files,

+                                html_log,

+                            ]

+                        )

 

-                cfg_scale = gr.Slider(minimum=1.0, maximum=30.0, step=0.5, label='CFG Scale', value=7.0)

+                        save_zip.click(

+                            fn=wrap_gradio_call(save_files),

+                            _js="(x, y, z, w) => [x, y, true, selected_gallery_index()]",

+                            inputs=[

+                                generation_info,

+                                result_gallery,

+                                html_info,

+                                html_info,

+                            ],

+                            outputs=[

+                                download_files,

+                                html_log,

+                            ]

+                        )

 

-                seed, reuse_seed, subseed, reuse_subseed, subseed_strength, seed_resize_from_h, seed_resize_from_w, seed_checkbox = create_seed_inputs()

+                else:

+                    html_info_x = gr.HTML(elem_id=f'html_info_x_{tabname}')

+                    html_info = gr.HTML(elem_id=f'html_info_{tabname}')

+                    html_log = gr.HTML(elem_id=f'html_log_{tabname}')

 

-                with gr.Group():

-                    custom_inputs = modules.scripts.scripts_txt2img.setup_ui(is_img2img=False)

+                parameters_copypaste.bind_buttons(buttons, result_gallery, "txt2img" if tabname == "txt2img" else None)

+                return result_gallery, generation_info if tabname != "extras" else html_info_x, html_info, html_log

 

-            with gr.Column(variant='panel'):

 

-                with gr.Group():

-                    txt2img_preview = gr.Image(elem_id='txt2img_preview', visible=False)

-                    txt2img_gallery = gr.Gallery(label='Output', show_label=False, elem_id='txt2img_gallery').style(grid=4)

+def create_sampler_and_steps_selection(choices, tabname):

+    if opts.samplers_in_dropdown:

+        with FormRow(elem_id=f"sampler_selection_{tabname}"):

+            sampler_index = gr.Dropdown(label='Sampling method', elem_id=f"{tabname}_sampling", choices=[x.name for x in choices], value=choices[0].name, type="index")

+            steps = gr.Slider(minimum=1, maximum=150, step=1, elem_id=f"{tabname}_steps", label="Sampling steps", value=20)

+    else:

+        with FormGroup(elem_id=f"sampler_selection_{tabname}"):

+            steps = gr.Slider(minimum=1, maximum=150, step=1, elem_id=f"{tabname}_steps", label="Sampling steps", value=20)

+            sampler_index = gr.Radio(label='Sampling method', elem_id=f"{tabname}_sampling", choices=[x.name for x in choices], value=choices[0].name, type="index")

 

-                with gr.Column():

-                    with gr.Row():

-                        save = gr.Button('Save')

-                        send_to_img2img = gr.Button('Send to img2img')

-                        send_to_inpaint = gr.Button('Send to inpaint')

-                        send_to_extras = gr.Button('Send to extras')

-                        button_id = "hidden_element" if shared.cmd_opts.hide_ui_dir_config else 'open_folder'

-                        open_txt2img_folder = gr.Button(folder_symbol, elem_id=button_id)

+    return steps, sampler_index

 

-                    with gr.Row():

-                        do_make_zip = gr.Checkbox(label="Make Zip when Save?", value=False)

 

-                    with gr.Row():

-                        download_files = gr.File(None, file_count="multiple", interactive=False, show_label=False, visible=False)

+def ordered_ui_categories():

+    user_order = {x.strip(): i for i, x in enumerate(shared.opts.ui_reorder.split(","))}

 

-                    with gr.Group():

-                        html_info = gr.HTML()

-                        generation_info = gr.Textbox(visible=False)

+    for i, category in sorted(enumerate(shared.ui_reorder_categories), key=lambda x: user_order.get(x[1], x[0] + 1000)):

+        yield category

+

+

+def create_ui():

+    import modules.img2img

+    import modules.txt2img

+

+    reload_javascript()

+

+    parameters_copypaste.reset()

+

+    modules.scripts.scripts_current = modules.scripts.scripts_txt2img

+    modules.scripts.scripts_txt2img.initialize_scripts(is_img2img=False)

+

+    with gr.Blocks(analytics_enabled=False) as txt2img_interface:

+        txt2img_prompt, txt2img_prompt_style, txt2img_negative_prompt, txt2img_prompt_style2, submit, _, _,txt2img_prompt_style_apply, txt2img_save_style, txt2img_paste, token_counter, token_button = create_toprow(is_img2img=False)

+

+        dummy_component = gr.Label(visible=False)

+        txt_prompt_img = gr.File(label="", elem_id="txt2img_prompt_image", file_count="single", type="bytes", visible=False)

+

+        with gr.Row(elem_id='txt2img_progress_row'):

+            with gr.Column(scale=1):

+                pass

+

+            with gr.Column(scale=1):

+                progressbar = gr.HTML(elem_id="txt2img_progressbar")

+                txt2img_preview = gr.Image(elem_id='txt2img_preview', visible=False)

+                setup_progressbar(progressbar, txt2img_preview, 'txt2img')

+

+        with gr.Row().style(equal_height=False):

+            with gr.Column(variant='panel', elem_id="txt2img_settings"):

+                for category in ordered_ui_categories():

+                    if category == "sampler":

+                        steps, sampler_index = create_sampler_and_steps_selection(samplers, "txt2img")

+

+                    elif category == "dimensions":

+                        with FormRow():

+                            with gr.Column(elem_id="txt2img_column_size", scale=4):

+                                width = gr.Slider(minimum=64, maximum=2048, step=8, label="Width", value=512, elem_id="txt2img_width")

+                                height = gr.Slider(minimum=64, maximum=2048, step=8, label="Height", value=512, elem_id="txt2img_height")

+

+                            if opts.dimensions_and_batch_together:

+                                with gr.Column(elem_id="txt2img_column_batch"):

+                                    batch_count = gr.Slider(minimum=1, step=1, label='Batch count', value=1, elem_id="txt2img_batch_count")

+                                    batch_size = gr.Slider(minimum=1, maximum=8, step=1, label='Batch size', value=1, elem_id="txt2img_batch_size")

+

+                    elif category == "cfg":

+                        cfg_scale = gr.Slider(minimum=1.0, maximum=30.0, step=0.5, label='CFG Scale', value=7.0, elem_id="txt2img_cfg_scale")

+

+                    elif category == "seed":

+                        seed, reuse_seed, subseed, reuse_subseed, subseed_strength, seed_resize_from_h, seed_resize_from_w, seed_checkbox = create_seed_inputs('txt2img')

+

+                    elif category == "checkboxes":

+                        with FormRow(elem_id="txt2img_checkboxes"):

+                            restore_faces = gr.Checkbox(label='Restore faces', value=False, visible=len(shared.face_restorers) > 1, elem_id="txt2img_restore_faces")

+                            tiling = gr.Checkbox(label='Tiling', value=False, elem_id="txt2img_tiling")

+                            enable_hr = gr.Checkbox(label='Hires. fix', value=False, elem_id="txt2img_enable_hr")

+                            hr_final_resolution = FormHTML(value="", elem_id="txtimg_hr_finalres", label="Upscaled resolution", interactive=False)

+

+                    elif category == "hires_fix":