Split history ui.py to ui_progress.py

1 files changed, 1928 insertions, 0 deletions

diff --git a/modules/ui_progress.py b/modules/ui_progress.py
new file mode 100644
index 00000000..9b9081b5
--- /dev/null
+++ b/modules/ui_progress.py
@@ -0,0 +1,1928 @@
+import html

+import json

+import math

+import mimetypes

+import os

+import platform

+import random

+import subprocess as sp

+import sys

+import tempfile

+import time

+import traceback

+from functools import partial, reduce

+

+import gradio as gr

+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, 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

+

+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.textual_inversion.ui

+from modules import prompt_parser

+from modules.images import save_image

+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

+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 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 is not None else 7860,

+        cmd_opts.ngrok_region

+        )

+

+

+def gr_show(visible=True):

+    return {"visible": visible, "__type__": "update"}

+

+

+sample_img2img = "assets/stable-samples/img2img/sketch-mountains-input.jpg"

+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'  # ♻️

+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 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 = []

+    fullfns = []

+

+    #quick dictionary to class object conversion. Its necessary due apply_filename_pattern requiring it

+    class MyObject:

+        def __init__(self, d=None):

+            if d is not None:

+                for key, value in d.items():

+                    setattr(self, key, value)

+

+    data = json.loads(js_data)

+

+    p = MyObject(data)

+    path = opts.outdir_save

+    save_to_dirs = opts.use_save_to_dirs_for_ui

+    extension: str = opts.samples_format

+    start_index = 0

+

+    if index > -1 and opts.save_selected_only and (index >= data["index_of_first_image"]):  # ensures we are looking at a specific non-grid picture, and we have save_selected_only

+

+        images = [images[index]]

+        start_index = index

+

+    os.makedirs(opts.outdir_save, exist_ok=True)

+

+    with open(os.path.join(opts.outdir_save, "log.csv"), "a", encoding="utf8", newline='') as file:

+        at_start = file.tell() == 0

+        writer = csv.writer(file)

+        if at_start:

+            writer.writerow(["prompt", "seed", "width", "height", "sampler", "cfgs", "steps", "filename", "negative_prompt"])

+

+        for image_index, filedata in enumerate(images, start_index):

+            image = image_from_url_text(filedata)

+

+            is_grid = image_index < p.index_of_first_image

+            i = 0 if is_grid else (image_index - p.index_of_first_image)

+

+            fullfn, txt_fullfn = save_image(image, path, "", seed=p.all_seeds[i], prompt=p.all_prompts[i], extension=extension, info=p.infotexts[image_index], grid=is_grid, p=p, save_to_dirs=save_to_dirs)

+

+            filename = os.path.relpath(fullfn, path)

+            filenames.append(filename)

+            fullfns.append(fullfn)

+            if txt_fullfn:

+                filenames.append(os.path.basename(txt_fullfn))

+                fullfns.append(txt_fullfn)

+

+        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:

+        zip_filepath = os.path.join(path, "images.zip")

+

+        from zipfile import ZipFile

+        with ZipFile(zip_filepath, "w") as zip_file:

+            for i in range(len(fullfns)):

+                with open(fullfns[i], mode="rb") as f:

+                    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 calc_time_left(progress, threshold, label, force_display, show_eta):

+    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 show_eta) 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

+

+    # Show progress percentage and time left at the same moment, and base it also on steps done

+    show_eta = progress >= 0.01 or shared.state.sampling_step >= 10

+

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

+    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 show_eta else ""}</div></div>"""

+

+    image = gr_show(False)

+    preview_visibility = gr_show(False)

+

+    if opts.show_progress_every_n_steps != 0:

+        shared.state.set_current_image()

+        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 visit(x, func, path=""):

+    if hasattr(x, 'children'):

+        for c in x.children:

+            visit(c, func, path)

+    elif x.label is not None:

+        func(path + "/" + str(x.label), x)

+

+

+def add_style(name: str, prompt: str, negative_prompt: str):

+    if name is None:

+        return [gr_show() for x in range(4)]

+

+    style = modules.styles.PromptStyle(name, prompt, negative_prompt)

+    shared.prompt_styles.styles[style.name] = style

+    # Save all loaded prompt styles: this allows us to update the storage format in the future more easily, because we

+    # reserialize all styles every time we save them

+    shared.prompt_styles.save_styles(shared.styles_filename)

+

+    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])

+

+    return [gr.Textbox.update(value=prompt), gr.Textbox.update(value=prompt_neg), gr.Dropdown.update(value="None"), gr.Dropdown.update(value="None")]

+

+

+def interrogate(image):

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

+

+    return gr_show(True) if prompt is None else prompt

+

+

+def interrogate_deepbooru(image):

+    prompt = deepbooru.model.tag(image)

+    return gr_show(True) if prompt is None else prompt

+

+

+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.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 FormRow(visible=False, elem_id=target_interface + '_subseed_row') as seed_extra_row_1:

+        seed_extras.append(seed_extra_row_1)

+        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=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])

+

+    def change_visibility(show):

+        return {comp: gr_show(show) for comp in seed_extras}

+

+    seed_checkbox.change(change_visibility, show_progress=False, inputs=[seed_checkbox], outputs=seed_extras)

+

+    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

+        was 0, i.e. no variation seed was used, it copies the normal seed value instead."""

+    def copy_seed(gen_info_string: str, index):

+        res = -1

+

+        try:

+            gen_info = json.loads(gen_info_string)

+            index -= gen_info.get('index_of_first_image', 0)

+

+            if is_subseed and gen_info.get('subseed_strength', 0) > 0:

+                all_subseeds = gen_info.get('all_subseeds', [-1])

+                res = all_subseeds[index if 0 <= index < len(all_subseeds) else 0]

+            else:

+                all_seeds = gen_info.get('all_seeds', [-1])

+                res = all_seeds[index if 0 <= index < len(all_seeds) else 0]

+

+        except json.decoder.JSONDecodeError as e:

+            if gen_info_string != '':

+                print("Error parsing JSON generation info:", file=sys.stderr)

+                print(gen_info_string, file=sys.stderr)

+

+        return [res, gr_show(False)]

+

+    reuse_seed.click(

+        fn=copy_seed,

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

+        show_progress=False,

+        inputs=[generation_info, dummy_component],

+        outputs=[seed, dummy_component]

+    )

+

+

+def update_token_counter(text, steps):

+    try:

+        _, prompt_flat_list, _ = prompt_parser.get_multicond_prompt_list([text])

+        prompt_schedules = prompt_parser.get_learned_conditioning_prompt_schedules(prompt_flat_list, steps)

+

+    except Exception:

+        # a parsing error can happen here during typing, and we don't want to bother the user with

+        # messages related to it in console

+        prompt_schedules = [[[steps, text]]]

+

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

+    prompts = [prompt_text for step, prompt_text in flat_prompts]

+    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>"

+

+

+def create_toprow(is_img2img):

+    id_part = "img2img" if is_img2img else "txt2img"

+

+    with gr.Row(elem_id="toprow"):

+        with gr.Column(scale=6):

+            with gr.Row():

+                with gr.Column(scale=80):

+                    with gr.Row():

+                        prompt = gr.Textbox(label="Prompt", elem_id=f"{id_part}_prompt", show_label=False, lines=2,

+                            placeholder="Prompt (press Ctrl+Enter or Alt+Enter to generate)"

+                        )

+

+            with gr.Row():

+                with gr.Column(scale=80):

+                    with gr.Row():

+                        negative_prompt = gr.Textbox(label="Negative prompt", elem_id=f"{id_part}_neg_prompt", show_label=False, lines=2,

+                            placeholder="Negative prompt (press Ctrl+Enter or Alt+Enter to generate)"

+                        )

+

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

+            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")

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

+

+        with gr.Column(scale=1):

+            with gr.Row():

+                skip = gr.Button('Skip', elem_id=f"{id_part}_skip")

+                interrupt = gr.Button('Interrupt', elem_id=f"{id_part}_interrupt")

+                submit = gr.Button('Generate', elem_id=f"{id_part}_generate", variant='primary')

+

+                skip.click(

+                    fn=lambda: shared.state.skip(),

+                    inputs=[],

+                    outputs=[],

+                )

+

+                interrupt.click(

+                    fn=lambda: shared.state.interrupt(),

+                    inputs=[],

+                    outputs=[],

+                )

+

+            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())))

+

+                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())))

+

+    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)

+

+    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],

+    )

+

+

+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()

+

+    if key == "sd_model_checkpoint":

+        ckpt_info = sd_models.get_closet_checkpoint_match(value)

+

+        if ckpt_info is not None:

+            value = ckpt_info.title

+        else:

+            return gr.update()

+

+    comp_args = opts.data_labels[key].component_args

+    if comp_args and isinstance(comp_args, dict) and comp_args.get('visible') is False:

+        return

+

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

+    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()

+

+    opts.save(shared.config_filename)

+    return value

+

+

+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)

+

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

+

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

+    refresh_button.click(

+        fn=refresh,

+        inputs=[],

+        outputs=[refresh_component]

+    )

+    return refresh_button

+

+

+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

+

+        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.Column(variant='panel'):

+            with gr.Group():

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

+

+            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=[],

+                )

+

+                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.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,

+                            ]

+                        )

+

+                        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,

+                            ]

+                        )

+

+                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}')

+

+                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

+

+

+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")

+

+    return steps, sampler_index

+

+

+def ordered_ui_categories():

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

+

+    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":

+                        with FormGroup(visible=False, elem_id="txt2img_hires_fix") as hr_options:

+                            with FormRow(elem_id="txt2img_hires_fix_row1"):

+                                hr_upscaler = gr.Dropdown(label="Upscaler", elem_id="txt2img_hr_upscaler", choices=[*shared.latent_upscale_modes, *[x.name for x in shared.sd_upscalers]], value=shared.latent_upscale_default_mode)

+                                hr_second_pass_steps = gr.Slider(minimum=0, maximum=150, step=1, label='Hires steps', value=0, elem_id="txt2img_hires_steps")

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

+

+                            with FormRow(elem_id="txt2img_hires_fix_row2"):

+                                hr_scale = gr.Slider(minimum=1.0, maximum=4.0, step=0.05, label="Upscale by", value=2.0, elem_id="txt2img_hr_scale")

+                                hr_resize_x = gr.Slider(minimum=0, maximum=2048, step=8, label="Resize width to", value=0, elem_id="txt2img_hr_resize_x")

+                                hr_resize_y = gr.Slider(minimum=0, maximum=2048, step=8, label="Resize height to", value=0, elem_id="txt2img_hr_resize_y")

+

+                    elif category == "batch":

+                        if not opts.dimensions_and_batch_together:

+                            with FormRow(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 == "scripts":

+                        with FormGroup(elem_id="txt2img_script_container"):

+                            custom_inputs = modules.scripts.scripts_txt2img.setup_ui()

+

+            hr_resolution_preview_inputs = [enable_hr, width, height, hr_scale, hr_resize_x, hr_resize_y]

+            for input in hr_resolution_preview_inputs:

+                input.change(

+                    fn=calc_resolution_hires,

+                    inputs=hr_resolution_preview_inputs,

+                    outputs=[hr_final_resolution],

+                    show_progress=False,

+                )

+                input.change(

+                    None,

+                    _js="onCalcResolutionHires",

+                    inputs=hr_resolution_preview_inputs,

+                    outputs=[],

+                    show_progress=False,

+                )

+

+            txt2img_gallery, generation_info, html_info, html_log = create_output_panel("txt2img", opts.outdir_txt2img_samples)

+            parameters_copypaste.bind_buttons({"txt2img": txt2img_paste}, None, txt2img_prompt)

+

+            connect_reuse_seed(seed, reuse_seed, generation_info, dummy_component, is_subseed=False)

+            connect_reuse_seed(subseed, reuse_subseed, generation_info, dummy_component, is_subseed=True)

+

+            txt2img_args = dict(

+                fn=wrap_gradio_gpu_call(modules.txt2img.txt2img, extra_outputs=[None, '', '']),

+                _js="submit",

+                inputs=[

+                    txt2img_prompt,

+                    txt2img_negative_prompt,

+                    txt2img_prompt_style,

+                    txt2img_prompt_style2,

+                    steps,

+                    sampler_index,

+                    restore_faces,

+                    tiling,

+                    batch_count,

+                    batch_size,

+                    cfg_scale,

+                    seed,

+                    subseed, subseed_strength, seed_resize_from_h, seed_resize_from_w, seed_checkbox,

+                    height,

+                    width,

+                    enable_hr,

+                    denoising_strength,

+                    hr_scale,

+                    hr_upscaler,

+                    hr_second_pass_steps,

+                    hr_resize_x,

+                    hr_resize_y,

+                ] + custom_inputs,

+

+                outputs=[

+                    txt2img_gallery,

+                    generation_info,

+                    html_info,

+                    html_log,

+                ],

+                show_progress=False,

+            )

+

+            txt2img_prompt.submit(**txt2img_args)

+            submit.click(**txt2img_args)

+

+            txt_prompt_img.change(

+                fn=modules.images.image_data,

+                inputs=[

+                    txt_prompt_img

+                ],

+                outputs=[

+                    txt2img_prompt,

+                    txt_prompt_img

+                ]

+            )

+

+            enable_hr.change(

+                fn=lambda x: gr_show(x),

+                inputs=[enable_hr],

+                outputs=[hr_options],

+                show_progress = False,

+            )

+

+            txt2img_paste_fields = [

+                (txt2img_prompt, "Prompt"),

+                (txt2img_negative_prompt, "Negative prompt"),

+                (steps, "Steps"),

+                (sampler_index, "Sampler"),

+                (restore_faces, "Face restoration"),

+                (cfg_scale, "CFG scale"),

+                (seed, "Seed"),

+                (width, "Size-1"),

+                (height, "Size-2"),

+                (batch_size, "Batch size"),

+                (subseed, "Variation seed"),

+                (subseed_strength, "Variation seed strength"),

+                (seed_resize_from_w, "Seed resize from-1"),

+                (seed_resize_from_h, "Seed resize from-2"),

+                (denoising_strength, "Denoising strength"),

+                (enable_hr, lambda d: "Denoising strength" in d),

+                (hr_options, lambda d: gr.Row.update(visible="Denoising strength" in d)),

+                (hr_scale, "Hires upscale"),

+                (hr_upscaler, "Hires upscaler"),

+                (hr_second_pass_steps, "Hires steps"),

+                (hr_resize_x, "Hires resize-1"),

+                (hr_resize_y, "Hires resize-2"),