28e56f0d55e2186f63ab0522015f27b434593fd0fac74aa8e3bd6c786b28680d

scripts/custom_code.py

@@ -0,0 +1,90 @@
+import modules.scripts as scripts
+import gradio as gr
+import ast
+import copy
+
+from modules.processing import Processed
+from modules.shared import cmd_opts
+
+
+def convertExpr2Expression(expr):
+    expr.lineno = 0
+    expr.col_offset = 0
+    result = ast.Expression(expr.value, lineno=0, col_offset = 0)
+
+    return result
+
+
+def exec_with_return(code, module):
+    """
+    like exec() but can return values
+    https://stackoverflow.com/a/52361938/5862977
+    """
+    code_ast = ast.parse(code)
+
+    init_ast = copy.deepcopy(code_ast)
+    init_ast.body = code_ast.body[:-1]
+
+    last_ast = copy.deepcopy(code_ast)
+    last_ast.body = code_ast.body[-1:]
+
+    exec(compile(init_ast, "<ast>", "exec"), module.__dict__)
+    if type(last_ast.body[0]) == ast.Expr:
+        return eval(compile(convertExpr2Expression(last_ast.body[0]), "<ast>", "eval"), module.__dict__)
+    else:
+        exec(compile(last_ast, "<ast>", "exec"), module.__dict__)
+
+
+class Script(scripts.Script):
+
+    def title(self):
+        return "Custom code"
+
+    def show(self, is_img2img):
+        return cmd_opts.allow_code
+
+    def ui(self, is_img2img):
+        example = """from modules.processing import process_images
+
+p.width = 768
+p.height = 768
+p.batch_size = 2
+p.steps = 10
+
+return process_images(p)
+"""
+
+
+        code = gr.Code(value=example, language="python", label="Python code", elem_id=self.elem_id("code"))
+        indent_level = gr.Number(label='Indent level', value=2, precision=0, elem_id=self.elem_id("indent_level"))
+
+        return [code, indent_level]
+
+    def run(self, p, code, indent_level):
+        assert cmd_opts.allow_code, '--allow-code option must be enabled'
+
+        display_result_data = [[], -1, ""]
+
+        def display(imgs, s=display_result_data[1], i=display_result_data[2]):
+            display_result_data[0] = imgs
+            display_result_data[1] = s
+            display_result_data[2] = i
+
+        from types import ModuleType
+        module = ModuleType("testmodule")
+        module.__dict__.update(globals())
+        module.p = p
+        module.display = display
+
+        indent = " " * indent_level
+        indented = code.replace('\n', f"\n{indent}")
+        body = f"""def __webuitemp__():
+{indent}{indented}
+__webuitemp__()"""
+
+        result = exec_with_return(body, module)
+
+        if isinstance(result, Processed):
+            return result
+
+        return Processed(p, *display_result_data)

scripts/img2imgalt.py

@@ -0,0 +1,218 @@
+from collections import namedtuple
+
+import numpy as np
+from tqdm import trange
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import processing, shared, sd_samplers, sd_samplers_common
+
+import torch
+import k_diffusion as K
+
+def find_noise_for_image(p, cond, uncond, cfg_scale, steps):
+    x = p.init_latent
+
+    s_in = x.new_ones([x.shape[0]])
+    if shared.sd_model.parameterization == "v":
+        dnw = K.external.CompVisVDenoiser(shared.sd_model)
+        skip = 1
+    else:
+        dnw = K.external.CompVisDenoiser(shared.sd_model)
+        skip = 0
+    sigmas = dnw.get_sigmas(steps).flip(0)
+
+    shared.state.sampling_steps = steps
+
+    for i in trange(1, len(sigmas)):
+        shared.state.sampling_step += 1
+
+        x_in = torch.cat([x] * 2)
+        sigma_in = torch.cat([sigmas[i] * s_in] * 2)
+        cond_in = torch.cat([uncond, cond])
+
+        image_conditioning = torch.cat([p.image_conditioning] * 2)
+        cond_in = {"c_concat": [image_conditioning], "c_crossattn": [cond_in]}
+
+        c_out, c_in = [K.utils.append_dims(k, x_in.ndim) for k in dnw.get_scalings(sigma_in)[skip:]]
+        t = dnw.sigma_to_t(sigma_in)
+
+        eps = shared.sd_model.apply_model(x_in * c_in, t, cond=cond_in)
+        denoised_uncond, denoised_cond = (x_in + eps * c_out).chunk(2)
+
+        denoised = denoised_uncond + (denoised_cond - denoised_uncond) * cfg_scale
+
+        d = (x - denoised) / sigmas[i]
+        dt = sigmas[i] - sigmas[i - 1]
+
+        x = x + d * dt
+
+        sd_samplers_common.store_latent(x)
+
+        # This shouldn't be necessary, but solved some VRAM issues
+        del x_in, sigma_in, cond_in, c_out, c_in, t,
+        del eps, denoised_uncond, denoised_cond, denoised, d, dt
+
+    shared.state.nextjob()
+
+    return x / x.std()
+
+
+Cached = namedtuple("Cached", ["noise", "cfg_scale", "steps", "latent", "original_prompt", "original_negative_prompt", "sigma_adjustment"])
+
+
+# Based on changes suggested by briansemrau in https://github.com/AUTOMATIC1111/stable-diffusion-webui/issues/736
+def find_noise_for_image_sigma_adjustment(p, cond, uncond, cfg_scale, steps):
+    x = p.init_latent
+
+    s_in = x.new_ones([x.shape[0]])
+    if shared.sd_model.parameterization == "v":
+        dnw = K.external.CompVisVDenoiser(shared.sd_model)
+        skip = 1
+    else:
+        dnw = K.external.CompVisDenoiser(shared.sd_model)
+        skip = 0
+    sigmas = dnw.get_sigmas(steps).flip(0)
+
+    shared.state.sampling_steps = steps
+
+    for i in trange(1, len(sigmas)):
+        shared.state.sampling_step += 1
+
+        x_in = torch.cat([x] * 2)
+        sigma_in = torch.cat([sigmas[i - 1] * s_in] * 2)
+        cond_in = torch.cat([uncond, cond])
+
+        image_conditioning = torch.cat([p.image_conditioning] * 2)
+        cond_in = {"c_concat": [image_conditioning], "c_crossattn": [cond_in]}
+
+        c_out, c_in = [K.utils.append_dims(k, x_in.ndim) for k in dnw.get_scalings(sigma_in)[skip:]]
+
+        if i == 1:
+            t = dnw.sigma_to_t(torch.cat([sigmas[i] * s_in] * 2))
+        else:
+            t = dnw.sigma_to_t(sigma_in)
+
+        eps = shared.sd_model.apply_model(x_in * c_in, t, cond=cond_in)
+        denoised_uncond, denoised_cond = (x_in + eps * c_out).chunk(2)
+
+        denoised = denoised_uncond + (denoised_cond - denoised_uncond) * cfg_scale
+
+        if i == 1:
+            d = (x - denoised) / (2 * sigmas[i])
+        else:
+            d = (x - denoised) / sigmas[i - 1]
+
+        dt = sigmas[i] - sigmas[i - 1]
+        x = x + d * dt
+
+        sd_samplers_common.store_latent(x)
+
+        # This shouldn't be necessary, but solved some VRAM issues
+        del x_in, sigma_in, cond_in, c_out, c_in, t,
+        del eps, denoised_uncond, denoised_cond, denoised, d, dt
+
+    shared.state.nextjob()
+
+    return x / sigmas[-1]
+
+
+class Script(scripts.Script):
+    def __init__(self):
+        self.cache = None
+
+    def title(self):
+        return "img2img alternative test"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        info = gr.Markdown('''
+        * `CFG Scale` should be 2 or lower.
+        ''')
+
+        override_sampler = gr.Checkbox(label="Override `Sampling method` to Euler?(this method is built for it)", value=True, elem_id=self.elem_id("override_sampler"))
+
+        override_prompt = gr.Checkbox(label="Override `prompt` to the same value as `original prompt`?(and `negative prompt`)", value=True, elem_id=self.elem_id("override_prompt"))
+        original_prompt = gr.Textbox(label="Original prompt", lines=1, elem_id=self.elem_id("original_prompt"))
+        original_negative_prompt = gr.Textbox(label="Original negative prompt", lines=1, elem_id=self.elem_id("original_negative_prompt"))
+
+        override_steps = gr.Checkbox(label="Override `Sampling Steps` to the same value as `Decode steps`?", value=True, elem_id=self.elem_id("override_steps"))
+        st = gr.Slider(label="Decode steps", minimum=1, maximum=150, step=1, value=50, elem_id=self.elem_id("st"))
+
+        override_strength = gr.Checkbox(label="Override `Denoising strength` to 1?", value=True, elem_id=self.elem_id("override_strength"))
+
+        cfg = gr.Slider(label="Decode CFG scale", minimum=0.0, maximum=15.0, step=0.1, value=1.0, elem_id=self.elem_id("cfg"))
+        randomness = gr.Slider(label="Randomness", minimum=0.0, maximum=1.0, step=0.01, value=0.0, elem_id=self.elem_id("randomness"))
+        sigma_adjustment = gr.Checkbox(label="Sigma adjustment for finding noise for image", value=False, elem_id=self.elem_id("sigma_adjustment"))
+
+        return [
+            info,
+            override_sampler,
+            override_prompt, original_prompt, original_negative_prompt,
+            override_steps, st,
+            override_strength,
+            cfg, randomness, sigma_adjustment,
+        ]
+
+    def run(self, p, _, override_sampler, override_prompt, original_prompt, original_negative_prompt, override_steps, st, override_strength, cfg, randomness, sigma_adjustment):
+        # Override
+        if override_sampler:
+            p.sampler_name = "Euler"
+        if override_prompt:
+            p.prompt = original_prompt
+            p.negative_prompt = original_negative_prompt
+        if override_steps:
+            p.steps = st
+        if override_strength:
+            p.denoising_strength = 1.0
+
+        def sample_extra(conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):
+            lat = (p.init_latent.cpu().numpy() * 10).astype(int)
+
+            same_params = self.cache is not None and self.cache.cfg_scale == cfg and self.cache.steps == st \
+                                and self.cache.original_prompt == original_prompt \
+                                and self.cache.original_negative_prompt == original_negative_prompt \
+                                and self.cache.sigma_adjustment == sigma_adjustment
+            same_everything = same_params and self.cache.latent.shape == lat.shape and np.abs(self.cache.latent-lat).sum() < 100
+
+            if same_everything:
+                rec_noise = self.cache.noise
+            else:
+                shared.state.job_count += 1
+                cond = p.sd_model.get_learned_conditioning(p.batch_size * [original_prompt])
+                uncond = p.sd_model.get_learned_conditioning(p.batch_size * [original_negative_prompt])
+                if sigma_adjustment:
+                    rec_noise = find_noise_for_image_sigma_adjustment(p, cond, uncond, cfg, st)
+                else:
+                    rec_noise = find_noise_for_image(p, cond, uncond, cfg, st)
+                self.cache = Cached(rec_noise, cfg, st, lat, original_prompt, original_negative_prompt, sigma_adjustment)
+
+            rand_noise = processing.create_random_tensors(p.init_latent.shape[1:], seeds=seeds, subseeds=subseeds, subseed_strength=p.subseed_strength, seed_resize_from_h=p.seed_resize_from_h, seed_resize_from_w=p.seed_resize_from_w, p=p)
+
+            combined_noise = ((1 - randomness) * rec_noise + randomness * rand_noise) / ((randomness**2 + (1-randomness)**2) ** 0.5)
+
+            sampler = sd_samplers.create_sampler(p.sampler_name, p.sd_model)
+
+            sigmas = sampler.model_wrap.get_sigmas(p.steps)
+
+            noise_dt = combined_noise - (p.init_latent / sigmas[0])
+
+            p.seed = p.seed + 1
+
+            return sampler.sample_img2img(p, p.init_latent, noise_dt, conditioning, unconditional_conditioning, image_conditioning=p.image_conditioning)
+
+        p.sample = sample_extra
+
+        p.extra_generation_params["Decode prompt"] = original_prompt
+        p.extra_generation_params["Decode negative prompt"] = original_negative_prompt
+        p.extra_generation_params["Decode CFG scale"] = cfg
+        p.extra_generation_params["Decode steps"] = st
+        p.extra_generation_params["Randomness"] = randomness
+        p.extra_generation_params["Sigma Adjustment"] = sigma_adjustment
+
+        processed = processing.process_images(p)
+
+        return processed

scripts/loopback.py

@@ -0,0 +1,140 @@
+import math
+
+import gradio as gr
+import modules.scripts as scripts
+from modules import deepbooru, images, processing, shared
+from modules.processing import Processed
+from modules.shared import opts, state
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Loopback"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        loops = gr.Slider(minimum=1, maximum=32, step=1, label='Loops', value=4, elem_id=self.elem_id("loops"))
+        final_denoising_strength = gr.Slider(minimum=0, maximum=1, step=0.01, label='Final denoising strength', value=0.5, elem_id=self.elem_id("final_denoising_strength"))
+        denoising_curve = gr.Dropdown(label="Denoising strength curve", choices=["Aggressive", "Linear", "Lazy"], value="Linear")
+        append_interrogation = gr.Dropdown(label="Append interrogated prompt at each iteration", choices=["None", "CLIP", "DeepBooru"], value="None")
+
+        return [loops, final_denoising_strength, denoising_curve, append_interrogation]
+
+    def run(self, p, loops, final_denoising_strength, denoising_curve, append_interrogation):
+        processing.fix_seed(p)
+        batch_count = p.n_iter
+        p.extra_generation_params = {
+            "Final denoising strength": final_denoising_strength,
+            "Denoising curve": denoising_curve
+        }
+
+        p.batch_size = 1
+        p.n_iter = 1
+
+        info = None
+        initial_seed = None
+        initial_info = None
+        initial_denoising_strength = p.denoising_strength
+
+        grids = []
+        all_images = []
+        original_init_image = p.init_images
+        original_prompt = p.prompt
+        original_inpainting_fill = p.inpainting_fill
+        state.job_count = loops * batch_count
+
+        initial_color_corrections = [processing.setup_color_correction(p.init_images[0])]
+
+        def calculate_denoising_strength(loop):
+            strength = initial_denoising_strength
+
+            if loops == 1:
+                return strength
+
+            progress = loop / (loops - 1)
+            if denoising_curve == "Aggressive":
+                strength = math.sin((progress) * math.pi * 0.5)
+            elif denoising_curve == "Lazy":
+                strength = 1 - math.cos((progress) * math.pi * 0.5)
+            else:
+                strength = progress
+
+            change = (final_denoising_strength - initial_denoising_strength) * strength
+            return initial_denoising_strength + change
+
+        history = []
+
+        for n in range(batch_count):
+            # Reset to original init image at the start of each batch
+            p.init_images = original_init_image
+
+            # Reset to original denoising strength
+            p.denoising_strength = initial_denoising_strength
+
+            last_image = None
+
+            for i in range(loops):
+                p.n_iter = 1
+                p.batch_size = 1
+                p.do_not_save_grid = True
+
+                if opts.img2img_color_correction:
+                    p.color_corrections = initial_color_corrections
+
+                if append_interrogation != "None":
+                    p.prompt = f"{original_prompt}, " if original_prompt else ""
+                    if append_interrogation == "CLIP":
+                        p.prompt += shared.interrogator.interrogate(p.init_images[0])
+                    elif append_interrogation == "DeepBooru":
+                        p.prompt += deepbooru.model.tag(p.init_images[0])
+
+                state.job = f"Iteration {i + 1}/{loops}, batch {n + 1}/{batch_count}"
+
+                processed = processing.process_images(p)
+
+                # Generation cancelled.
+                if state.interrupted:
+                    break
+
+                if initial_seed is None:
+                    initial_seed = processed.seed
+                    initial_info = processed.info
+
+                p.seed = processed.seed + 1
+                p.denoising_strength = calculate_denoising_strength(i + 1)
+
+                if state.skipped:
+                    break
+
+                last_image = processed.images[0]
+                p.init_images = [last_image]
+                p.inpainting_fill = 1 # Set "masked content" to "original" for next loop.
+
+                if batch_count == 1:
+                    history.append(last_image)
+                    all_images.append(last_image)
+
+            if batch_count > 1 and not state.skipped and not state.interrupted:
+                history.append(last_image)
+                all_images.append(last_image)
+
+            p.inpainting_fill = original_inpainting_fill
+
+            if state.interrupted:
+                    break
+
+        if len(history) > 1:
+            grid = images.image_grid(history, rows=1)
+            if opts.grid_save:
+                images.save_image(grid, p.outpath_grids, "grid", initial_seed, p.prompt, opts.grid_format, info=info, short_filename=not opts.grid_extended_filename, grid=True, p=p)
+
+            if opts.return_grid:
+                grids.append(grid)
+
+        all_images = grids + all_images
+
+        processed = Processed(p, all_images, initial_seed, initial_info)
+
+        return processed

scripts/outpainting_mk_2.py

@@ -0,0 +1,295 @@
+import math
+
+import numpy as np
+import skimage
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image, ImageDraw
+
+from modules import images
+from modules.processing import Processed, process_images
+from modules.shared import opts, state
+
+
+# this function is taken from https://github.com/parlance-zz/g-diffuser-bot
+def get_matched_noise(_np_src_image, np_mask_rgb, noise_q=1, color_variation=0.05):
+    # helper fft routines that keep ortho normalization and auto-shift before and after fft
+    def _fft2(data):
+        if data.ndim > 2:  # has channels
+            out_fft = np.zeros((data.shape[0], data.shape[1], data.shape[2]), dtype=np.complex128)
+            for c in range(data.shape[2]):
+                c_data = data[:, :, c]
+                out_fft[:, :, c] = np.fft.fft2(np.fft.fftshift(c_data), norm="ortho")
+                out_fft[:, :, c] = np.fft.ifftshift(out_fft[:, :, c])
+        else:  # one channel
+            out_fft = np.zeros((data.shape[0], data.shape[1]), dtype=np.complex128)
+            out_fft[:, :] = np.fft.fft2(np.fft.fftshift(data), norm="ortho")
+            out_fft[:, :] = np.fft.ifftshift(out_fft[:, :])
+
+        return out_fft
+
+    def _ifft2(data):
+        if data.ndim > 2:  # has channels
+            out_ifft = np.zeros((data.shape[0], data.shape[1], data.shape[2]), dtype=np.complex128)
+            for c in range(data.shape[2]):
+                c_data = data[:, :, c]
+                out_ifft[:, :, c] = np.fft.ifft2(np.fft.fftshift(c_data), norm="ortho")
+                out_ifft[:, :, c] = np.fft.ifftshift(out_ifft[:, :, c])
+        else:  # one channel
+            out_ifft = np.zeros((data.shape[0], data.shape[1]), dtype=np.complex128)
+            out_ifft[:, :] = np.fft.ifft2(np.fft.fftshift(data), norm="ortho")
+            out_ifft[:, :] = np.fft.ifftshift(out_ifft[:, :])
+
+        return out_ifft
+
+    def _get_gaussian_window(width, height, std=3.14, mode=0):
+        window_scale_x = float(width / min(width, height))
+        window_scale_y = float(height / min(width, height))
+
+        window = np.zeros((width, height))
+        x = (np.arange(width) / width * 2. - 1.) * window_scale_x
+        for y in range(height):
+            fy = (y / height * 2. - 1.) * window_scale_y
+            if mode == 0:
+                window[:, y] = np.exp(-(x ** 2 + fy ** 2) * std)
+            else:
+                window[:, y] = (1 / ((x ** 2 + 1.) * (fy ** 2 + 1.))) ** (std / 3.14)  # hey wait a minute that's not gaussian
+
+        return window
+
+    def _get_masked_window_rgb(np_mask_grey, hardness=1.):
+        np_mask_rgb = np.zeros((np_mask_grey.shape[0], np_mask_grey.shape[1], 3))
+        if hardness != 1.:
+            hardened = np_mask_grey[:] ** hardness
+        else:
+            hardened = np_mask_grey[:]
+        for c in range(3):
+            np_mask_rgb[:, :, c] = hardened[:]
+        return np_mask_rgb
+
+    width = _np_src_image.shape[0]
+    height = _np_src_image.shape[1]
+    num_channels = _np_src_image.shape[2]
+
+    _np_src_image[:] * (1. - np_mask_rgb)
+    np_mask_grey = (np.sum(np_mask_rgb, axis=2) / 3.)
+    img_mask = np_mask_grey > 1e-6
+    ref_mask = np_mask_grey < 1e-3
+
+    windowed_image = _np_src_image * (1. - _get_masked_window_rgb(np_mask_grey))
+    windowed_image /= np.max(windowed_image)
+    windowed_image += np.average(_np_src_image) * np_mask_rgb  # / (1.-np.average(np_mask_rgb))  # rather than leave the masked area black, we get better results from fft by filling the average unmasked color
+
+    src_fft = _fft2(windowed_image)  # get feature statistics from masked src img
+    src_dist = np.absolute(src_fft)
+    src_phase = src_fft / src_dist
+
+    # create a generator with a static seed to make outpainting deterministic / only follow global seed
+    rng = np.random.default_rng(0)
+
+    noise_window = _get_gaussian_window(width, height, mode=1)  # start with simple gaussian noise
+    noise_rgb = rng.random((width, height, num_channels))
+    noise_grey = (np.sum(noise_rgb, axis=2) / 3.)
+    noise_rgb *= color_variation  # the colorfulness of the starting noise is blended to greyscale with a parameter
+    for c in range(num_channels):
+        noise_rgb[:, :, c] += (1. - color_variation) * noise_grey
+
+    noise_fft = _fft2(noise_rgb)
+    for c in range(num_channels):
+        noise_fft[:, :, c] *= noise_window
+    noise_rgb = np.real(_ifft2(noise_fft))
+    shaped_noise_fft = _fft2(noise_rgb)
+    shaped_noise_fft[:, :, :] = np.absolute(shaped_noise_fft[:, :, :]) ** 2 * (src_dist ** noise_q) * src_phase  # perform the actual shaping
+
+    brightness_variation = 0.  # color_variation # todo: temporarily tieing brightness variation to color variation for now
+    contrast_adjusted_np_src = _np_src_image[:] * (brightness_variation + 1.) - brightness_variation * 2.
+
+    # scikit-image is used for histogram matching, very convenient!
+    shaped_noise = np.real(_ifft2(shaped_noise_fft))
+    shaped_noise -= np.min(shaped_noise)
+    shaped_noise /= np.max(shaped_noise)
+    shaped_noise[img_mask, :] = skimage.exposure.match_histograms(shaped_noise[img_mask, :] ** 1., contrast_adjusted_np_src[ref_mask, :], channel_axis=1)
+    shaped_noise = _np_src_image[:] * (1. - np_mask_rgb) + shaped_noise * np_mask_rgb
+
+    matched_noise = shaped_noise[:]
+
+    return np.clip(matched_noise, 0., 1.)
+
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Outpainting mk2"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        if not is_img2img:
+            return None
+
+        info = gr.HTML("<p style=\"margin-bottom:0.75em\">Recommended settings: Sampling Steps: 80-100, Sampler: Euler a, Denoising strength: 0.8</p>")
+
+        pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
+        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=8, elem_id=self.elem_id("mask_blur"))
+        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'], elem_id=self.elem_id("direction"))
+        noise_q = gr.Slider(label="Fall-off exponent (lower=higher detail)", minimum=0.0, maximum=4.0, step=0.01, value=1.0, elem_id=self.elem_id("noise_q"))
+        color_variation = gr.Slider(label="Color variation", minimum=0.0, maximum=1.0, step=0.01, value=0.05, elem_id=self.elem_id("color_variation"))
+
+        return [info, pixels, mask_blur, direction, noise_q, color_variation]
+
+    def run(self, p, _, pixels, mask_blur, direction, noise_q, color_variation):
+        initial_seed_and_info = [None, None]
+
+        process_width = p.width
+        process_height = p.height
+
+        p.inpaint_full_res = False
+        p.inpainting_fill = 1
+        p.do_not_save_samples = True
+        p.do_not_save_grid = True
+
+        left = pixels if "left" in direction else 0
+        right = pixels if "right" in direction else 0
+        up = pixels if "up" in direction else 0
+        down = pixels if "down" in direction else 0
+
+        if left > 0 or right > 0:
+            mask_blur_x = mask_blur
+        else:
+            mask_blur_x = 0
+
+        if up > 0 or down > 0:
+            mask_blur_y = mask_blur
+        else:
+            mask_blur_y = 0
+
+        p.mask_blur_x = mask_blur_x*4
+        p.mask_blur_y = mask_blur_y*4
+
+        init_img = p.init_images[0]
+        target_w = math.ceil((init_img.width + left + right) / 64) * 64
+        target_h = math.ceil((init_img.height + up + down) / 64) * 64
+
+        if left > 0:
+            left = left * (target_w - init_img.width) // (left + right)
+
+        if right > 0:
+            right = target_w - init_img.width - left
+
+        if up > 0:
+            up = up * (target_h - init_img.height) // (up + down)
+
+        if down > 0:
+            down = target_h - init_img.height - up
+
+        def expand(init, count, expand_pixels, is_left=False, is_right=False, is_top=False, is_bottom=False):
+            is_horiz = is_left or is_right
+            is_vert = is_top or is_bottom
+            pixels_horiz = expand_pixels if is_horiz else 0
+            pixels_vert = expand_pixels if is_vert else 0
+
+            images_to_process = []
+            output_images = []
+            for n in range(count):
+                res_w = init[n].width + pixels_horiz
+                res_h = init[n].height + pixels_vert
+                process_res_w = math.ceil(res_w / 64) * 64
+                process_res_h = math.ceil(res_h / 64) * 64
+
+                img = Image.new("RGB", (process_res_w, process_res_h))
+                img.paste(init[n], (pixels_horiz if is_left else 0, pixels_vert if is_top else 0))
+                mask = Image.new("RGB", (process_res_w, process_res_h), "white")
+                draw = ImageDraw.Draw(mask)
+                draw.rectangle((
+                    expand_pixels + mask_blur_x if is_left else 0,
+                    expand_pixels + mask_blur_y if is_top else 0,
+                    mask.width - expand_pixels - mask_blur_x if is_right else res_w,
+                    mask.height - expand_pixels - mask_blur_y if is_bottom else res_h,
+                ), fill="black")
+
+                np_image = (np.asarray(img) / 255.0).astype(np.float64)
+                np_mask = (np.asarray(mask) / 255.0).astype(np.float64)
+                noised = get_matched_noise(np_image, np_mask, noise_q, color_variation)
+                output_images.append(Image.fromarray(np.clip(noised * 255., 0., 255.).astype(np.uint8), mode="RGB"))
+
+                target_width = min(process_width, init[n].width + pixels_horiz) if is_horiz else img.width
+                target_height = min(process_height, init[n].height + pixels_vert) if is_vert else img.height
+                p.width = target_width if is_horiz else img.width
+                p.height = target_height if is_vert else img.height
+
+                crop_region = (
+                    0 if is_left else output_images[n].width - target_width,
+                    0 if is_top else output_images[n].height - target_height,
+                    target_width if is_left else output_images[n].width,
+                    target_height if is_top else output_images[n].height,
+                )
+                mask = mask.crop(crop_region)
+                p.image_mask = mask
+
+                image_to_process = output_images[n].crop(crop_region)
+                images_to_process.append(image_to_process)
+
+            p.init_images = images_to_process
+
+            latent_mask = Image.new("RGB", (p.width, p.height), "white")
+            draw = ImageDraw.Draw(latent_mask)
+            draw.rectangle((
+                expand_pixels + mask_blur_x * 2 if is_left else 0,
+                expand_pixels + mask_blur_y * 2 if is_top else 0,
+                mask.width - expand_pixels - mask_blur_x * 2 if is_right else res_w,
+                mask.height - expand_pixels - mask_blur_y * 2 if is_bottom else res_h,
+            ), fill="black")
+            p.latent_mask = latent_mask
+
+            proc = process_images(p)
+
+            if initial_seed_and_info[0] is None:
+                initial_seed_and_info[0] = proc.seed
+                initial_seed_and_info[1] = proc.info
+
+            for n in range(count):
+                output_images[n].paste(proc.images[n], (0 if is_left else output_images[n].width - proc.images[n].width, 0 if is_top else output_images[n].height - proc.images[n].height))
+                output_images[n] = output_images[n].crop((0, 0, res_w, res_h))
+
+            return output_images
+
+        batch_count = p.n_iter
+        batch_size = p.batch_size
+        p.n_iter = 1
+        state.job_count = batch_count * ((1 if left > 0 else 0) + (1 if right > 0 else 0) + (1 if up > 0 else 0) + (1 if down > 0 else 0))
+        all_processed_images = []
+
+        for i in range(batch_count):
+            imgs = [init_img] * batch_size
+            state.job = f"Batch {i + 1} out of {batch_count}"
+
+            if left > 0:
+                imgs = expand(imgs, batch_size, left, is_left=True)
+            if right > 0:
+                imgs = expand(imgs, batch_size, right, is_right=True)
+            if up > 0:
+                imgs = expand(imgs, batch_size, up, is_top=True)
+            if down > 0:
+                imgs = expand(imgs, batch_size, down, is_bottom=True)
+
+            all_processed_images += imgs
+
+        all_images = all_processed_images
+
+        combined_grid_image = images.image_grid(all_processed_images)
+        unwanted_grid_because_of_img_count = len(all_processed_images) < 2 and opts.grid_only_if_multiple
+        if opts.return_grid and not unwanted_grid_because_of_img_count:
+            all_images = [combined_grid_image] + all_processed_images
+
+        res = Processed(p, all_images, initial_seed_and_info[0], initial_seed_and_info[1])
+
+        if opts.samples_save:
+            for img in all_processed_images:
+                images.save_image(img, p.outpath_samples, "", res.seed, p.prompt, opts.samples_format, info=res.info, p=p)
+
+        if opts.grid_save and not unwanted_grid_because_of_img_count:
+            images.save_image(combined_grid_image, p.outpath_grids, "grid", res.seed, p.prompt, opts.grid_format, info=res.info, short_filename=not opts.grid_extended_filename, grid=True, p=p)
+
+        return res

scripts/poor_mans_outpainting.py

@@ -0,0 +1,146 @@
+import math
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image, ImageDraw
+
+from modules import images, devices
+from modules.processing import Processed, process_images
+from modules.shared import opts, state
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Poor man's outpainting"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        if not is_img2img:
+            return None
+
+        pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
+        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id=self.elem_id("mask_blur"))
+        inpainting_fill = gr.Radio(label='Masked content', choices=['fill', 'original', 'latent noise', 'latent nothing'], value='fill', type="index", elem_id=self.elem_id("inpainting_fill"))
+        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'], elem_id=self.elem_id("direction"))
+
+        return [pixels, mask_blur, inpainting_fill, direction]
+
+    def run(self, p, pixels, mask_blur, inpainting_fill, direction):
+        initial_seed = None
+        initial_info = None
+
+        p.mask_blur = mask_blur * 2
+        p.inpainting_fill = inpainting_fill
+        p.inpaint_full_res = False
+
+        left = pixels if "left" in direction else 0
+        right = pixels if "right" in direction else 0
+        up = pixels if "up" in direction else 0
+        down = pixels if "down" in direction else 0
+
+        init_img = p.init_images[0]
+        target_w = math.ceil((init_img.width + left + right) / 64) * 64
+        target_h = math.ceil((init_img.height + up + down) / 64) * 64
+
+        if left > 0:
+            left = left * (target_w - init_img.width) // (left + right)
+        if right > 0:
+            right = target_w - init_img.width - left
+
+        if up > 0:
+            up = up * (target_h - init_img.height) // (up + down)
+
+        if down > 0:
+            down = target_h - init_img.height - up
+
+        img = Image.new("RGB", (target_w, target_h))
+        img.paste(init_img, (left, up))
+
+        mask = Image.new("L", (img.width, img.height), "white")
+        draw = ImageDraw.Draw(mask)
+        draw.rectangle((
+            left + (mask_blur * 2 if left > 0 else 0),
+            up + (mask_blur * 2 if up > 0 else 0),
+            mask.width - right - (mask_blur * 2 if right > 0 else 0),
+            mask.height - down - (mask_blur * 2 if down > 0 else 0)
+        ), fill="black")
+
+        latent_mask = Image.new("L", (img.width, img.height), "white")
+        latent_draw = ImageDraw.Draw(latent_mask)
+        latent_draw.rectangle((
+             left + (mask_blur//2 if left > 0 else 0),
+             up + (mask_blur//2 if up > 0 else 0),
+             mask.width - right - (mask_blur//2 if right > 0 else 0),
+             mask.height - down - (mask_blur//2 if down > 0 else 0)
+        ), fill="black")
+
+        devices.torch_gc()
+
+        grid = images.split_grid(img, tile_w=p.width, tile_h=p.height, overlap=pixels)
+        grid_mask = images.split_grid(mask, tile_w=p.width, tile_h=p.height, overlap=pixels)
+        grid_latent_mask = images.split_grid(latent_mask, tile_w=p.width, tile_h=p.height, overlap=pixels)
+
+        p.n_iter = 1
+        p.batch_size = 1
+        p.do_not_save_grid = True
+        p.do_not_save_samples = True
+
+        work = []
+        work_mask = []
+        work_latent_mask = []
+        work_results = []
+
+        for (y, h, row), (_, _, row_mask), (_, _, row_latent_mask) in zip(grid.tiles, grid_mask.tiles, grid_latent_mask.tiles):
+            for tiledata, tiledata_mask, tiledata_latent_mask in zip(row, row_mask, row_latent_mask):
+                x, w = tiledata[0:2]
+
+                if x >= left and x+w <= img.width - right and y >= up and y+h <= img.height - down:
+                    continue
+
+                work.append(tiledata[2])
+                work_mask.append(tiledata_mask[2])
+                work_latent_mask.append(tiledata_latent_mask[2])
+
+        batch_count = len(work)
+        print(f"Poor man's outpainting will process a total of {len(work)} images tiled as {len(grid.tiles[0][2])}x{len(grid.tiles)}.")
+
+        state.job_count = batch_count
+
+        for i in range(batch_count):
+            p.init_images = [work[i]]
+            p.image_mask = work_mask[i]
+            p.latent_mask = work_latent_mask[i]
+
+            state.job = f"Batch {i + 1} out of {batch_count}"
+            processed = process_images(p)
+
+            if initial_seed is None:
+                initial_seed = processed.seed
+                initial_info = processed.info
+
+            p.seed = processed.seed + 1
+            work_results += processed.images
+
+
+        image_index = 0
+        for y, h, row in grid.tiles:
+            for tiledata in row:
+                x, w = tiledata[0:2]
+
+                if x >= left and x+w <= img.width - right and y >= up and y+h <= img.height - down:
+                    continue
+
+                tiledata[2] = work_results[image_index] if image_index < len(work_results) else Image.new("RGB", (p.width, p.height))
+                image_index += 1
+
+        combined_image = images.combine_grid(grid)
+
+        if opts.samples_save:
+            images.save_image(combined_image, p.outpath_samples, "", initial_seed, p.prompt, opts.samples_format, info=initial_info, p=p)
+
+        processed = Processed(p, [combined_image], initial_seed, initial_info)
+
+        return processed
+

scripts/postprocessing_codeformer.py

@@ -0,0 +1,36 @@
+from PIL import Image
+import numpy as np
+
+from modules import scripts_postprocessing, codeformer_model
+import gradio as gr
+
+from modules.ui_components import FormRow
+
+
+class ScriptPostprocessingCodeFormer(scripts_postprocessing.ScriptPostprocessing):
+    name = "CodeFormer"
+    order = 3000
+
+    def ui(self):
+        with FormRow():
+            codeformer_visibility = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="CodeFormer visibility", value=0, elem_id="extras_codeformer_visibility")
+            codeformer_weight = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="CodeFormer weight (0 = maximum effect, 1 = minimum effect)", value=0, elem_id="extras_codeformer_weight")
+
+        return {
+            "codeformer_visibility": codeformer_visibility,
+            "codeformer_weight": codeformer_weight,
+        }
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, codeformer_visibility, codeformer_weight):
+        if codeformer_visibility == 0:
+            return
+
+        restored_img = codeformer_model.codeformer.restore(np.array(pp.image, dtype=np.uint8), w=codeformer_weight)
+        res = Image.fromarray(restored_img)
+
+        if codeformer_visibility < 1.0:
+            res = Image.blend(pp.image, res, codeformer_visibility)
+
+        pp.image = res
+        pp.info["CodeFormer visibility"] = round(codeformer_visibility, 3)
+        pp.info["CodeFormer weight"] = round(codeformer_weight, 3)

scripts/postprocessing_gfpgan.py

@@ -0,0 +1,33 @@
+from PIL import Image
+import numpy as np
+
+from modules import scripts_postprocessing, gfpgan_model
+import gradio as gr
+
+from modules.ui_components import FormRow
+
+
+class ScriptPostprocessingGfpGan(scripts_postprocessing.ScriptPostprocessing):
+    name = "GFPGAN"
+    order = 2000
+
+    def ui(self):
+        with FormRow():
+            gfpgan_visibility = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="GFPGAN visibility", value=0, elem_id="extras_gfpgan_visibility")
+
+        return {
+            "gfpgan_visibility": gfpgan_visibility,
+        }
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, gfpgan_visibility):
+        if gfpgan_visibility == 0:
+            return
+
+        restored_img = gfpgan_model.gfpgan_fix_faces(np.array(pp.image, dtype=np.uint8))
+        res = Image.fromarray(restored_img)
+
+        if gfpgan_visibility < 1.0:
+            res = Image.blend(pp.image, res, gfpgan_visibility)
+
+        pp.image = res
+        pp.info["GFPGAN visibility"] = round(gfpgan_visibility, 3)

scripts/postprocessing_upscale.py

@@ -0,0 +1,133 @@
+from PIL import Image
+import numpy as np
+
+from modules import scripts_postprocessing, shared
+import gradio as gr
+
+from modules.ui_components import FormRow, ToolButton
+from modules.ui import switch_values_symbol
+
+upscale_cache = {}
+
+
+class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
+    name = "Upscale"
+    order = 1000
+
+    def ui(self):
+        selected_tab = gr.State(value=0)
+
+        with gr.Column():
+            with FormRow():
+                with gr.Tabs(elem_id="extras_resize_mode"):
+                    with gr.TabItem('Scale by', elem_id="extras_scale_by_tab") as tab_scale_by:
+                        upscaling_resize = gr.Slider(minimum=1.0, maximum=8.0, step=0.05, label="Resize", value=4, elem_id="extras_upscaling_resize")
+                    with gr.TabItem('Scale to', elem_id="extras_scale_to_tab") as tab_scale_to:                      
+                        with gr.Row(elem_id="upscaling_column_size"):
+                            upscaling_resize_w = gr.Slider(minimum=64, maximum=2048, step=8, label="Width", value=512, elem_id="extras_upscaling_resize_w")
+                            upscaling_res_switch_btn = ToolButton(value=switch_values_symbol, elem_id="upscaling_res_switch_btn")
+                            upscaling_resize_h = gr.Slider(minimum=64, maximum=2048, step=8, label="Height", value=512, elem_id="extras_upscaling_resize_h")
+                        with gr.Row(elem_id="upscaling_dimensions_row", elem_classes="dimensions-tools"):                              
+                            upscaling_crop = gr.Checkbox(label='Crop to fit', value=True, elem_id="extras_upscaling_crop")
+            with FormRow():
+                extras_upscaler_1 = gr.Dropdown(label='Upscaler 1', elem_id="extras_upscaler_1", choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name)
+            with FormRow():
+                extras_upscaler_2 = gr.Dropdown(label='Upscaler 2', elem_id="extras_upscaler_2", choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name)
+                extras_upscaler_2_visibility = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="Upscaler 2 visibility", value=0.0, elem_id="extras_upscaler_2_visibility")
+
+        upscaling_res_switch_btn.click(lambda w, h: (h, w), inputs=[upscaling_resize_w, upscaling_resize_h], outputs=[upscaling_resize_w, upscaling_resize_h], show_progress=False)
+        tab_scale_by.select(fn=lambda: 0, inputs=[], outputs=[selected_tab])
+        tab_scale_to.select(fn=lambda: 1, inputs=[], outputs=[selected_tab])
+
+        return {
+            "upscale_mode": selected_tab,
+            "upscale_by": upscaling_resize,
+            "upscale_to_width": upscaling_resize_w,
+            "upscale_to_height": upscaling_resize_h,
+            "upscale_crop": upscaling_crop,
+            "upscaler_1_name": extras_upscaler_1,
+            "upscaler_2_name": extras_upscaler_2,
+            "upscaler_2_visibility": extras_upscaler_2_visibility,
+        }
+
+    def upscale(self, image, info, upscaler, upscale_mode, upscale_by,  upscale_to_width, upscale_to_height, upscale_crop):
+        if upscale_mode == 1:
+            upscale_by = max(upscale_to_width/image.width, upscale_to_height/image.height)
+            info["Postprocess upscale to"] = f"{upscale_to_width}x{upscale_to_height}"
+        else:
+            info["Postprocess upscale by"] = upscale_by
+
+        cache_key = (hash(np.array(image.getdata()).tobytes()), upscaler.name, upscale_mode, upscale_by,  upscale_to_width, upscale_to_height, upscale_crop)
+        cached_image = upscale_cache.pop(cache_key, None)
+
+        if cached_image is not None:
+            image = cached_image
+        else:
+            image = upscaler.scaler.upscale(image, upscale_by, upscaler.data_path)
+
+        upscale_cache[cache_key] = image
+        if len(upscale_cache) > shared.opts.upscaling_max_images_in_cache:
+            upscale_cache.pop(next(iter(upscale_cache), None), None)
+
+        if upscale_mode == 1 and upscale_crop:
+            cropped = Image.new("RGB", (upscale_to_width, upscale_to_height))
+            cropped.paste(image, box=(upscale_to_width // 2 - image.width // 2, upscale_to_height // 2 - image.height // 2))
+            image = cropped
+            info["Postprocess crop to"] = f"{image.width}x{image.height}"
+
+        return image
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, upscale_mode=1, upscale_by=2.0, upscale_to_width=None, upscale_to_height=None, upscale_crop=False, upscaler_1_name=None, upscaler_2_name=None, upscaler_2_visibility=0.0):
+        if upscaler_1_name == "None":
+            upscaler_1_name = None
+
+        upscaler1 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_1_name]), None)
+        assert upscaler1 or (upscaler_1_name is None), f'could not find upscaler named {upscaler_1_name}'
+
+        if not upscaler1:
+            return
+
+        if upscaler_2_name == "None":
+            upscaler_2_name = None
+
+        upscaler2 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_2_name and x.name != "None"]), None)
+        assert upscaler2 or (upscaler_2_name is None), f'could not find upscaler named {upscaler_2_name}'
+
+        upscaled_image = self.upscale(pp.image, pp.info, upscaler1, upscale_mode, upscale_by, upscale_to_width, upscale_to_height, upscale_crop)
+        pp.info["Postprocess upscaler"] = upscaler1.name
+
+        if upscaler2 and upscaler_2_visibility > 0:
+            second_upscale = self.upscale(pp.image, pp.info, upscaler2, upscale_mode, upscale_by, upscale_to_width, upscale_to_height, upscale_crop)
+            upscaled_image = Image.blend(upscaled_image, second_upscale, upscaler_2_visibility)
+
+            pp.info["Postprocess upscaler 2"] = upscaler2.name
+
+        pp.image = upscaled_image
+
+    def image_changed(self):
+        upscale_cache.clear()
+
+
+class ScriptPostprocessingUpscaleSimple(ScriptPostprocessingUpscale):
+    name = "Simple Upscale"
+    order = 900
+
+    def ui(self):
+        with FormRow():
+            upscaler_name = gr.Dropdown(label='Upscaler', choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name)
+            upscale_by = gr.Slider(minimum=0.05, maximum=8.0, step=0.05, label="Upscale by", value=2)
+
+        return {
+            "upscale_by": upscale_by,
+            "upscaler_name": upscaler_name,
+        }
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, upscale_by=2.0, upscaler_name=None):
+        if upscaler_name is None or upscaler_name == "None":
+            return
+
+        upscaler1 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_name]), None)
+        assert upscaler1, f'could not find upscaler named {upscaler_name}'
+
+        pp.image = self.upscale(pp.image, pp.info, upscaler1, 0, upscale_by, 0, 0, False)
+        pp.info["Postprocess upscaler"] = upscaler1.name

scripts/prompt_matrix.py

@@ -0,0 +1,108 @@
+import math
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import images
+from modules.processing import process_images
+from modules.shared import opts, state
+import modules.sd_samplers
+
+
+def draw_xy_grid(xs, ys, x_label, y_label, cell):
+    res = []
+
+    ver_texts = [[images.GridAnnotation(y_label(y))] for y in ys]
+    hor_texts = [[images.GridAnnotation(x_label(x))] for x in xs]
+
+    first_processed = None
+
+    state.job_count = len(xs) * len(ys)
+
+    for iy, y in enumerate(ys):
+        for ix, x in enumerate(xs):
+            state.job = f"{ix + iy * len(xs) + 1} out of {len(xs) * len(ys)}"
+
+            processed = cell(x, y)
+            if first_processed is None:
+                first_processed = processed
+
+            res.append(processed.images[0])
+
+    grid = images.image_grid(res, rows=len(ys))
+    grid = images.draw_grid_annotations(grid, res[0].width, res[0].height, hor_texts, ver_texts)
+
+    first_processed.images = [grid]
+
+    return first_processed
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Prompt matrix"
+
+    def ui(self, is_img2img):
+        gr.HTML('<br />')
+        with gr.Row():
+            with gr.Column():
+                put_at_start = gr.Checkbox(label='Put variable parts at start of prompt', value=False, elem_id=self.elem_id("put_at_start"))
+                different_seeds = gr.Checkbox(label='Use different seed for each picture', value=False, elem_id=self.elem_id("different_seeds"))
+            with gr.Column():
+                prompt_type = gr.Radio(["positive", "negative"], label="Select prompt", elem_id=self.elem_id("prompt_type"), value="positive")
+                variations_delimiter = gr.Radio(["comma", "space"], label="Select joining char", elem_id=self.elem_id("variations_delimiter"), value="comma")
+            with gr.Column():
+                margin_size = gr.Slider(label="Grid margins (px)", minimum=0, maximum=500, value=0, step=2, elem_id=self.elem_id("margin_size"))
+
+        return [put_at_start, different_seeds, prompt_type, variations_delimiter, margin_size]
+
+    def run(self, p, put_at_start, different_seeds, prompt_type, variations_delimiter, margin_size):
+        modules.processing.fix_seed(p)
+        # Raise error if promp type is not positive or negative
+        if prompt_type not in ["positive", "negative"]:
+            raise ValueError(f"Unknown prompt type {prompt_type}")
+        # Raise error if variations delimiter is not comma or space
+        if variations_delimiter not in ["comma", "space"]:
+            raise ValueError(f"Unknown variations delimiter {variations_delimiter}")
+
+        prompt = p.prompt if prompt_type == "positive" else p.negative_prompt
+        original_prompt = prompt[0] if type(prompt) == list else prompt
+        positive_prompt = p.prompt[0] if type(p.prompt) == list else p.prompt
+
+        delimiter = ", " if variations_delimiter == "comma" else " "
+
+        all_prompts = []
+        prompt_matrix_parts = original_prompt.split("|")
+        combination_count = 2 ** (len(prompt_matrix_parts) - 1)
+        for combination_num in range(combination_count):
+            selected_prompts = [text.strip().strip(',') for n, text in enumerate(prompt_matrix_parts[1:]) if combination_num & (1 << n)]
+
+            if put_at_start:
+                selected_prompts = selected_prompts + [prompt_matrix_parts[0]]
+            else:
+                selected_prompts = [prompt_matrix_parts[0]] + selected_prompts
+
+            all_prompts.append(delimiter.join(selected_prompts))
+
+        p.n_iter = math.ceil(len(all_prompts) / p.batch_size)
+        p.do_not_save_grid = True
+
+        print(f"Prompt matrix will create {len(all_prompts)} images using a total of {p.n_iter} batches.")
+
+        if prompt_type == "positive":
+            p.prompt = all_prompts
+        else:
+            p.negative_prompt = all_prompts
+        p.seed = [p.seed + (i if different_seeds else 0) for i in range(len(all_prompts))]
+        p.prompt_for_display = positive_prompt
+        processed = process_images(p)
+
+        grid = images.image_grid(processed.images, p.batch_size, rows=1 << ((len(prompt_matrix_parts) - 1) // 2))
+        grid = images.draw_prompt_matrix(grid, processed.images[0].width, processed.images[0].height, prompt_matrix_parts, margin_size)
+        processed.images.insert(0, grid)
+        processed.index_of_first_image = 1
+        processed.infotexts.insert(0, processed.infotexts[0])
+
+        if opts.grid_save:
+            images.save_image(processed.images[0], p.outpath_grids, "prompt_matrix", extension=opts.grid_format, prompt=original_prompt, seed=processed.seed, grid=True, p=p)
+
+        return processed

scripts/prompts_from_file.py

@@ -0,0 +1,169 @@
+import copy
+import random
+import shlex
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import sd_samplers, errors
+from modules.processing import Processed, process_images
+from modules.shared import state
+
+
+def process_string_tag(tag):
+    return tag
+
+
+def process_int_tag(tag):
+    return int(tag)
+
+
+def process_float_tag(tag):
+    return float(tag)
+
+
+def process_boolean_tag(tag):
+    return True if (tag == "true") else False
+
+
+prompt_tags = {
+    "sd_model": None,
+    "outpath_samples": process_string_tag,
+    "outpath_grids": process_string_tag,
+    "prompt_for_display": process_string_tag,
+    "prompt": process_string_tag,
+    "negative_prompt": process_string_tag,
+    "styles": process_string_tag,
+    "seed": process_int_tag,
+    "subseed_strength": process_float_tag,
+    "subseed": process_int_tag,
+    "seed_resize_from_h": process_int_tag,
+    "seed_resize_from_w": process_int_tag,
+    "sampler_index": process_int_tag,
+    "sampler_name": process_string_tag,
+    "batch_size": process_int_tag,
+    "n_iter": process_int_tag,
+    "steps": process_int_tag,
+    "cfg_scale": process_float_tag,
+    "width": process_int_tag,
+    "height": process_int_tag,
+    "restore_faces": process_boolean_tag,
+    "tiling": process_boolean_tag,
+    "do_not_save_samples": process_boolean_tag,
+    "do_not_save_grid": process_boolean_tag
+}
+
+
+def cmdargs(line):
+    args = shlex.split(line)
+    pos = 0
+    res = {}
+
+    while pos < len(args):
+        arg = args[pos]
+
+        assert arg.startswith("--"), f'must start with "--": {arg}'
+        assert pos+1 < len(args), f'missing argument for command line option {arg}'
+
+        tag = arg[2:]
+
+        if tag == "prompt" or tag == "negative_prompt":
+            pos += 1
+            prompt = args[pos]
+            pos += 1
+            while pos < len(args) and not args[pos].startswith("--"):
+                prompt += " "
+                prompt += args[pos]
+                pos += 1
+            res[tag] = prompt
+            continue
+
+
+        func = prompt_tags.get(tag, None)
+        assert func, f'unknown commandline option: {arg}'
+
+        val = args[pos+1]
+        if tag == "sampler_name":
+            val = sd_samplers.samplers_map.get(val.lower(), None)
+
+        res[tag] = func(val)
+
+        pos += 2
+
+    return res
+
+
+def load_prompt_file(file):
+    if file is None:
+        return None, gr.update(), gr.update(lines=7)
+    else:
+        lines = [x.strip() for x in file.decode('utf8', errors='ignore').split("\n")]
+        return None, "\n".join(lines), gr.update(lines=7)
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Prompts from file or textbox"
+
+    def ui(self, is_img2img):
+        checkbox_iterate = gr.Checkbox(label="Iterate seed every line", value=False, elem_id=self.elem_id("checkbox_iterate"))
+        checkbox_iterate_batch = gr.Checkbox(label="Use same random seed for all lines", value=False, elem_id=self.elem_id("checkbox_iterate_batch"))
+
+        prompt_txt = gr.Textbox(label="List of prompt inputs", lines=1, elem_id=self.elem_id("prompt_txt"))
+        file = gr.File(label="Upload prompt inputs", type='binary', elem_id=self.elem_id("file"))
+
+        file.change(fn=load_prompt_file, inputs=[file], outputs=[file, prompt_txt, prompt_txt], show_progress=False)
+
+        # We start at one line. When the text changes, we jump to seven lines, or two lines if no \n.
+        # We don't shrink back to 1, because that causes the control to ignore [enter], and it may
+        # be unclear to the user that shift-enter is needed.
+        prompt_txt.change(lambda tb: gr.update(lines=7) if ("\n" in tb) else gr.update(lines=2), inputs=[prompt_txt], outputs=[prompt_txt], show_progress=False)
+        return [checkbox_iterate, checkbox_iterate_batch, prompt_txt]
+
+    def run(self, p, checkbox_iterate, checkbox_iterate_batch, prompt_txt: str):
+        lines = [x for x in (x.strip() for x in prompt_txt.splitlines()) if x]
+
+        p.do_not_save_grid = True
+
+        job_count = 0
+        jobs = []
+
+        for line in lines:
+            if "--" in line:
+                try:
+                    args = cmdargs(line)
+                except Exception:
+                    errors.report(f"Error parsing line {line} as commandline", exc_info=True)
+                    args = {"prompt": line}
+            else:
+                args = {"prompt": line}
+
+            job_count += args.get("n_iter", p.n_iter)
+
+            jobs.append(args)
+
+        print(f"Will process {len(lines)} lines in {job_count} jobs.")
+        if (checkbox_iterate or checkbox_iterate_batch) and p.seed == -1:
+            p.seed = int(random.randrange(4294967294))
+
+        state.job_count = job_count
+
+        images = []
+        all_prompts = []
+        infotexts = []
+        for args in jobs:
+            state.job = f"{state.job_no + 1} out of {state.job_count}"
+
+            copy_p = copy.copy(p)
+            for k, v in args.items():
+                setattr(copy_p, k, v)
+
+            proc = process_images(copy_p)
+            images += proc.images
+
+            if checkbox_iterate:
+                p.seed = p.seed + (p.batch_size * p.n_iter)
+            all_prompts += proc.all_prompts
+            infotexts += proc.infotexts
+
+        return Processed(p, images, p.seed, "", all_prompts=all_prompts, infotexts=infotexts)

scripts/sd_upscale.py

@@ -0,0 +1,101 @@
+import math
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image
+
+from modules import processing, shared, images, devices
+from modules.processing import Processed
+from modules.shared import opts, state
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "SD upscale"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        info = gr.HTML("<p style=\"margin-bottom:0.75em\">Will upscale the image by the selected scale factor; use width and height sliders to set tile size</p>")
+        overlap = gr.Slider(minimum=0, maximum=256, step=16, label='Tile overlap', value=64, elem_id=self.elem_id("overlap"))
+        scale_factor = gr.Slider(minimum=1.0, maximum=4.0, step=0.05, label='Scale Factor', value=2.0, elem_id=self.elem_id("scale_factor"))
+        upscaler_index = gr.Radio(label='Upscaler', choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name, type="index", elem_id=self.elem_id("upscaler_index"))
+
+        return [info, overlap, upscaler_index, scale_factor]
+
+    def run(self, p, _, overlap, upscaler_index, scale_factor):
+        if isinstance(upscaler_index, str):
+            upscaler_index = [x.name.lower() for x in shared.sd_upscalers].index(upscaler_index.lower())
+        processing.fix_seed(p)
+        upscaler = shared.sd_upscalers[upscaler_index]
+
+        p.extra_generation_params["SD upscale overlap"] = overlap
+        p.extra_generation_params["SD upscale upscaler"] = upscaler.name
+
+        initial_info = None
+        seed = p.seed
+
+        init_img = p.init_images[0]
+        init_img = images.flatten(init_img, opts.img2img_background_color)
+
+        if upscaler.name != "None":
+            img = upscaler.scaler.upscale(init_img, scale_factor, upscaler.data_path)
+        else:
+            img = init_img
+
+        devices.torch_gc()
+
+        grid = images.split_grid(img, tile_w=p.width, tile_h=p.height, overlap=overlap)
+
+        batch_size = p.batch_size
+        upscale_count = p.n_iter
+        p.n_iter = 1
+        p.do_not_save_grid = True
+        p.do_not_save_samples = True
+
+        work = []
+
+        for _y, _h, row in grid.tiles:
+            for tiledata in row:
+                work.append(tiledata[2])
+
+        batch_count = math.ceil(len(work) / batch_size)
+        state.job_count = batch_count * upscale_count
+
+        print(f"SD upscaling will process a total of {len(work)} images tiled as {len(grid.tiles[0][2])}x{len(grid.tiles)} per upscale in a total of {state.job_count} batches.")
+
+        result_images = []
+        for n in range(upscale_count):
+            start_seed = seed + n
+            p.seed = start_seed
+
+            work_results = []
+            for i in range(batch_count):
+                p.batch_size = batch_size
+                p.init_images = work[i * batch_size:(i + 1) * batch_size]
+
+                state.job = f"Batch {i + 1 + n * batch_count} out of {state.job_count}"
+                processed = processing.process_images(p)
+
+                if initial_info is None:
+                    initial_info = processed.info
+
+                p.seed = processed.seed + 1
+                work_results += processed.images
+
+            image_index = 0
+            for _y, _h, row in grid.tiles:
+                for tiledata in row:
+                    tiledata[2] = work_results[image_index] if image_index < len(work_results) else Image.new("RGB", (p.width, p.height))
+                    image_index += 1
+
+            combined_image = images.combine_grid(grid)
+            result_images.append(combined_image)
+
+            if opts.samples_save:
+                images.save_image(combined_image, p.outpath_samples, "", start_seed, p.prompt, opts.samples_format, info=initial_info, p=p)
+
+        processed = Processed(p, result_images, seed, initial_info)
+
+        return processed

scripts/xyz_grid.py

@@ -0,0 +1,734 @@
+from collections import namedtuple
+from copy import copy
+from itertools import permutations, chain
+import random
+import csv
+from io import StringIO
+from PIL import Image
+import numpy as np
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import images, sd_samplers, processing, sd_models, sd_vae, sd_samplers_kdiffusion
+from modules.processing import process_images, Processed, StableDiffusionProcessingTxt2Img
+from modules.shared import opts, state
+import modules.shared as shared
+import modules.sd_samplers
+import modules.sd_models
+import modules.sd_vae
+import re
+
+from modules.ui_components import ToolButton
+
+fill_values_symbol = "\U0001f4d2"  # 📒
+
+AxisInfo = namedtuple('AxisInfo', ['axis', 'values'])
+
+
+def apply_field(field):
+    def fun(p, x, xs):
+        setattr(p, field, x)
+
+    return fun
+
+
+def apply_prompt(p, x, xs):
+    if xs[0] not in p.prompt and xs[0] not in p.negative_prompt:
+        raise RuntimeError(f"Prompt S/R did not find {xs[0]} in prompt or negative prompt.")
+
+    p.prompt = p.prompt.replace(xs[0], x)
+    p.negative_prompt = p.negative_prompt.replace(xs[0], x)
+
+
+def apply_order(p, x, xs):
+    token_order = []
+
+    # Initally grab the tokens from the prompt, so they can be replaced in order of earliest seen
+    for token in x:
+        token_order.append((p.prompt.find(token), token))
+
+    token_order.sort(key=lambda t: t[0])
+
+    prompt_parts = []
+
+    # Split the prompt up, taking out the tokens
+    for _, token in token_order:
+        n = p.prompt.find(token)
+        prompt_parts.append(p.prompt[0:n])
+        p.prompt = p.prompt[n + len(token):]
+
+    # Rebuild the prompt with the tokens in the order we want
+    prompt_tmp = ""
+    for idx, part in enumerate(prompt_parts):
+        prompt_tmp += part
+        prompt_tmp += x[idx]
+    p.prompt = prompt_tmp + p.prompt
+
+
+def apply_sampler(p, x, xs):
+    sampler_name = sd_samplers.samplers_map.get(x.lower(), None)
+    if sampler_name is None:
+        raise RuntimeError(f"Unknown sampler: {x}")
+
+    p.sampler_name = sampler_name
+
+
+def confirm_samplers(p, xs):
+    for x in xs:
+        if x.lower() not in sd_samplers.samplers_map:
+            raise RuntimeError(f"Unknown sampler: {x}")
+
+
+def apply_checkpoint(p, x, xs):
+    info = modules.sd_models.get_closet_checkpoint_match(x)
+    if info is None:
+        raise RuntimeError(f"Unknown checkpoint: {x}")
+    p.override_settings['sd_model_checkpoint'] = info.name
+
+
+def confirm_checkpoints(p, xs):
+    for x in xs:
+        if modules.sd_models.get_closet_checkpoint_match(x) is None:
+            raise RuntimeError(f"Unknown checkpoint: {x}")
+
+
+def apply_clip_skip(p, x, xs):
+    opts.data["CLIP_stop_at_last_layers"] = x
+
+
+def apply_upscale_latent_space(p, x, xs):
+    if x.lower().strip() != '0':
+        opts.data["use_scale_latent_for_hires_fix"] = True
+    else:
+        opts.data["use_scale_latent_for_hires_fix"] = False
+
+
+def find_vae(name: str):
+    if name.lower() in ['auto', 'automatic']:
+        return modules.sd_vae.unspecified
+    if name.lower() == 'none':
+        return None
+    else:
+        choices = [x for x in sorted(modules.sd_vae.vae_dict, key=lambda x: len(x)) if name.lower().strip() in x.lower()]
+        if len(choices) == 0:
+            print(f"No VAE found for {name}; using automatic")
+            return modules.sd_vae.unspecified
+        else:
+            return modules.sd_vae.vae_dict[choices[0]]
+
+
+def apply_vae(p, x, xs):
+    modules.sd_vae.reload_vae_weights(shared.sd_model, vae_file=find_vae(x))
+
+
+def apply_styles(p: StableDiffusionProcessingTxt2Img, x: str, _):
+    p.styles.extend(x.split(','))
+
+
+def apply_uni_pc_order(p, x, xs):
+    opts.data["uni_pc_order"] = min(x, p.steps - 1)
+
+
+def apply_face_restore(p, opt, x):
+    opt = opt.lower()
+    if opt == 'codeformer':
+        is_active = True
+        p.face_restoration_model = 'CodeFormer'
+    elif opt == 'gfpgan':
+        is_active = True
+        p.face_restoration_model = 'GFPGAN'
+    else:
+        is_active = opt in ('true', 'yes', 'y', '1')
+
+    p.restore_faces = is_active
+
+
+def apply_override(field, boolean: bool = False):
+    def fun(p, x, xs):
+        if boolean:
+            x = True if x.lower() == "true" else False
+        p.override_settings[field] = x
+    return fun
+
+
+def boolean_choice(reverse: bool = False):
+    def choice():
+        return ["False", "True"] if reverse else ["True", "False"]
+    return choice
+
+
+def format_value_add_label(p, opt, x):
+    if type(x) == float:
+        x = round(x, 8)
+
+    return f"{opt.label}: {x}"
+
+
+def format_value(p, opt, x):
+    if type(x) == float:
+        x = round(x, 8)
+    return x
+
+
+def format_value_join_list(p, opt, x):
+    return ", ".join(x)
+
+
+def do_nothing(p, x, xs):
+    pass
+
+
+def format_nothing(p, opt, x):
+    return ""
+
+
+def str_permutations(x):
+    """dummy function for specifying it in AxisOption's type when you want to get a list of permutations"""
+    return x
+
+
+class AxisOption:
+    def __init__(self, label, type, apply, format_value=format_value_add_label, confirm=None, cost=0.0, choices=None):
+        self.label = label
+        self.type = type
+        self.apply = apply
+        self.format_value = format_value
+        self.confirm = confirm
+        self.cost = cost
+        self.choices = choices
+
+
+class AxisOptionImg2Img(AxisOption):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.is_img2img = True
+
+class AxisOptionTxt2Img(AxisOption):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.is_img2img = False
+
+
+axis_options = [
+    AxisOption("Nothing", str, do_nothing, format_value=format_nothing),
+    AxisOption("Seed", int, apply_field("seed")),
+    AxisOption("Var. seed", int, apply_field("subseed")),
+    AxisOption("Var. strength", float, apply_field("subseed_strength")),
+    AxisOption("Steps", int, apply_field("steps")),
+    AxisOptionTxt2Img("Hires steps", int, apply_field("hr_second_pass_steps")),
+    AxisOption("CFG Scale", float, apply_field("cfg_scale")),
+    AxisOptionImg2Img("Image CFG Scale", float, apply_field("image_cfg_scale")),
+    AxisOption("Prompt S/R", str, apply_prompt, format_value=format_value),
+    AxisOption("Prompt order", str_permutations, apply_order, format_value=format_value_join_list),
+    AxisOptionTxt2Img("Sampler", str, apply_sampler, format_value=format_value, confirm=confirm_samplers, choices=lambda: [x.name for x in sd_samplers.samplers]),
+    AxisOptionImg2Img("Sampler", str, apply_sampler, format_value=format_value, confirm=confirm_samplers, choices=lambda: [x.name for x in sd_samplers.samplers_for_img2img]),
+    AxisOption("Checkpoint name", str, apply_checkpoint, format_value=format_value, confirm=confirm_checkpoints, cost=1.0, choices=lambda: sorted(sd_models.checkpoints_list, key=str.casefold)),
+    AxisOption("Negative Guidance minimum sigma", float, apply_field("s_min_uncond")),
+    AxisOption("Sigma Churn", float, apply_field("s_churn")),
+    AxisOption("Sigma min", float, apply_field("s_tmin")),
+    AxisOption("Sigma max", float, apply_field("s_tmax")),
+    AxisOption("Sigma noise", float, apply_field("s_noise")),
+    AxisOption("Schedule type", str, apply_override("k_sched_type"), choices=lambda: list(sd_samplers_kdiffusion.k_diffusion_scheduler)),
+    AxisOption("Schedule min sigma", float, apply_override("sigma_min")),
+    AxisOption("Schedule max sigma", float, apply_override("sigma_max")),
+    AxisOption("Schedule rho", float, apply_override("rho")),
+    AxisOption("Eta", float, apply_field("eta")),
+    AxisOption("Clip skip", int, apply_clip_skip),
+    AxisOption("Denoising", float, apply_field("denoising_strength")),
+    AxisOptionTxt2Img("Hires upscaler", str, apply_field("hr_upscaler"), choices=lambda: [*shared.latent_upscale_modes, *[x.name for x in shared.sd_upscalers]]),
+    AxisOptionImg2Img("Cond. Image Mask Weight", float, apply_field("inpainting_mask_weight")),
+    AxisOption("VAE", str, apply_vae, cost=0.7, choices=lambda: ['None'] + list(sd_vae.vae_dict)),
+    AxisOption("Styles", str, apply_styles, choices=lambda: list(shared.prompt_styles.styles)),
+    AxisOption("UniPC Order", int, apply_uni_pc_order, cost=0.5),
+    AxisOption("Face restore", str, apply_face_restore, format_value=format_value),
+    AxisOption("Token merging ratio", float, apply_override('token_merging_ratio')),
+    AxisOption("Token merging ratio high-res", float, apply_override('token_merging_ratio_hr')),
+    AxisOption("Always discard next-to-last sigma", str, apply_override('always_discard_next_to_last_sigma', boolean=True), choices=boolean_choice(reverse=True)),
+]
+
+
+def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend, include_lone_images, include_sub_grids, first_axes_processed, second_axes_processed, margin_size):
+    hor_texts = [[images.GridAnnotation(x)] for x in x_labels]
+    ver_texts = [[images.GridAnnotation(y)] for y in y_labels]
+    title_texts = [[images.GridAnnotation(z)] for z in z_labels]
+
+    list_size = (len(xs) * len(ys) * len(zs))
+
+    processed_result = None
+
+    state.job_count = list_size * p.n_iter
+
+    def process_cell(x, y, z, ix, iy, iz):
+        nonlocal processed_result
+
+        def index(ix, iy, iz):
+            return ix + iy * len(xs) + iz * len(xs) * len(ys)
+
+        state.job = f"{index(ix, iy, iz) + 1} out of {list_size}"
+
+        processed: Processed = cell(x, y, z, ix, iy, iz)
+
+        if processed_result is None:
+            # Use our first processed result object as a template container to hold our full results
+            processed_result = copy(processed)
+            processed_result.images = [None] * list_size
+            processed_result.all_prompts = [None] * list_size
+            processed_result.all_seeds = [None] * list_size
+            processed_result.infotexts = [None] * list_size
+            processed_result.index_of_first_image = 1
+
+        idx = index(ix, iy, iz)
+        if processed.images:
+            # Non-empty list indicates some degree of success.
+            processed_result.images[idx] = processed.images[0]
+            processed_result.all_prompts[idx] = processed.prompt
+            processed_result.all_seeds[idx] = processed.seed
+            processed_result.infotexts[idx] = processed.infotexts[0]
+        else:
+            cell_mode = "P"
+            cell_size = (processed_result.width, processed_result.height)
+            if processed_result.images[0] is not None:
+                cell_mode = processed_result.images[0].mode
+                #This corrects size in case of batches:
+                cell_size = processed_result.images[0].size
+            processed_result.images[idx] = Image.new(cell_mode, cell_size)
+
+
+    if first_axes_processed == 'x':
+        for ix, x in enumerate(xs):
+            if second_axes_processed == 'y':
+                for iy, y in enumerate(ys):
+                    for iz, z in enumerate(zs):
+                        process_cell(x, y, z, ix, iy, iz)
+            else:
+                for iz, z in enumerate(zs):
+                    for iy, y in enumerate(ys):
+                        process_cell(x, y, z, ix, iy, iz)
+    elif first_axes_processed == 'y':
+        for iy, y in enumerate(ys):
+            if second_axes_processed == 'x':
+                for ix, x in enumerate(xs):
+                    for iz, z in enumerate(zs):
+                        process_cell(x, y, z, ix, iy, iz)
+            else:
+                for iz, z in enumerate(zs):
+                    for ix, x in enumerate(xs):
+                        process_cell(x, y, z, ix, iy, iz)
+    elif first_axes_processed == 'z':
+        for iz, z in enumerate(zs):
+            if second_axes_processed == 'x':
+                for ix, x in enumerate(xs):
+                    for iy, y in enumerate(ys):
+                        process_cell(x, y, z, ix, iy, iz)
+            else:
+                for iy, y in enumerate(ys):
+                    for ix, x in enumerate(xs):
+                        process_cell(x, y, z, ix, iy, iz)
+
+    if not processed_result:
+        # Should never happen, I've only seen it on one of four open tabs and it needed to refresh.
+        print("Unexpected error: Processing could not begin, you may need to refresh the tab or restart the service.")
+        return Processed(p, [])
+    elif not any(processed_result.images):
+        print("Unexpected error: draw_xyz_grid failed to return even a single processed image")
+        return Processed(p, [])
+
+    z_count = len(zs)
+
+    for i in range(z_count):
+        start_index = (i * len(xs) * len(ys)) + i
+        end_index = start_index + len(xs) * len(ys)
+        grid = images.image_grid(processed_result.images[start_index:end_index], rows=len(ys))
+        if draw_legend:
+            grid = images.draw_grid_annotations(grid, processed_result.images[start_index].size[0], processed_result.images[start_index].size[1], hor_texts, ver_texts, margin_size)
+        processed_result.images.insert(i, grid)
+        processed_result.all_prompts.insert(i, processed_result.all_prompts[start_index])
+        processed_result.all_seeds.insert(i, processed_result.all_seeds[start_index])
+        processed_result.infotexts.insert(i, processed_result.infotexts[start_index])
+
+    sub_grid_size = processed_result.images[0].size
+    z_grid = images.image_grid(processed_result.images[:z_count], rows=1)
+    if draw_legend:
+        z_grid = images.draw_grid_annotations(z_grid, sub_grid_size[0], sub_grid_size[1], title_texts, [[images.GridAnnotation()]])
+    processed_result.images.insert(0, z_grid)
+    #TODO: Deeper aspects of the program rely on grid info being misaligned between metadata arrays, which is not ideal.
+    #processed_result.all_prompts.insert(0, processed_result.all_prompts[0])
+    #processed_result.all_seeds.insert(0, processed_result.all_seeds[0])
+    processed_result.infotexts.insert(0, processed_result.infotexts[0])
+
+    return processed_result
+
+
+class SharedSettingsStackHelper(object):
+    def __enter__(self):
+        self.CLIP_stop_at_last_layers = opts.CLIP_stop_at_last_layers
+        self.vae = opts.sd_vae
+        self.uni_pc_order = opts.uni_pc_order
+
+    def __exit__(self, exc_type, exc_value, tb):
+        opts.data["sd_vae"] = self.vae
+        opts.data["uni_pc_order"] = self.uni_pc_order
+        modules.sd_models.reload_model_weights()
+        modules.sd_vae.reload_vae_weights()
+
+        opts.data["CLIP_stop_at_last_layers"] = self.CLIP_stop_at_last_layers
+
+
+re_range = re.compile(r"\s*([+-]?\s*\d+)\s*-\s*([+-]?\s*\d+)(?:\s*\(([+-]\d+)\s*\))?\s*")
+re_range_float = re.compile(r"\s*([+-]?\s*\d+(?:.\d*)?)\s*-\s*([+-]?\s*\d+(?:.\d*)?)(?:\s*\(([+-]\d+(?:.\d*)?)\s*\))?\s*")
+
+re_range_count = re.compile(r"\s*([+-]?\s*\d+)\s*-\s*([+-]?\s*\d+)(?:\s*\[(\d+)\s*\])?\s*")
+re_range_count_float = re.compile(r"\s*([+-]?\s*\d+(?:.\d*)?)\s*-\s*([+-]?\s*\d+(?:.\d*)?)(?:\s*\[(\d+(?:.\d*)?)\s*\])?\s*")
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "X/Y/Z plot"
+
+    def ui(self, is_img2img):
+        self.current_axis_options = [x for x in axis_options if type(x) == AxisOption or x.is_img2img == is_img2img]
+
+        with gr.Row():
+            with gr.Column(scale=19):
+                with gr.Row():
+                    x_type = gr.Dropdown(label="X type", choices=[x.label for x in self.current_axis_options], value=self.current_axis_options[1].label, type="index", elem_id=self.elem_id("x_type"))
+                    x_values = gr.Textbox(label="X values", lines=1, elem_id=self.elem_id("x_values"))
+                    x_values_dropdown = gr.Dropdown(label="X values",visible=False,multiselect=True,interactive=True)
+                    fill_x_button = ToolButton(value=fill_values_symbol, elem_id="xyz_grid_fill_x_tool_button", visible=False)
+
+                with gr.Row():
+                    y_type = gr.Dropdown(label="Y type", choices=[x.label for x in self.current_axis_options], value=self.current_axis_options[0].label, type="index", elem_id=self.elem_id("y_type"))
+                    y_values = gr.Textbox(label="Y values", lines=1, elem_id=self.elem_id("y_values"))
+                    y_values_dropdown = gr.Dropdown(label="Y values",visible=False,multiselect=True,interactive=True)
+                    fill_y_button = ToolButton(value=fill_values_symbol, elem_id="xyz_grid_fill_y_tool_button", visible=False)
+
+                with gr.Row():
+                    z_type = gr.Dropdown(label="Z type", choices=[x.label for x in self.current_axis_options], value=self.current_axis_options[0].label, type="index", elem_id=self.elem_id("z_type"))
+                    z_values = gr.Textbox(label="Z values", lines=1, elem_id=self.elem_id("z_values"))
+                    z_values_dropdown = gr.Dropdown(label="Z values",visible=False,multiselect=True,interactive=True)
+                    fill_z_button = ToolButton(value=fill_values_symbol, elem_id="xyz_grid_fill_z_tool_button", visible=False)
+
+        with gr.Row(variant="compact", elem_id="axis_options"):
+            with gr.Column():
+                draw_legend = gr.Checkbox(label='Draw legend', value=True, elem_id=self.elem_id("draw_legend"))
+                no_fixed_seeds = gr.Checkbox(label='Keep -1 for seeds', value=False, elem_id=self.elem_id("no_fixed_seeds"))
+            with gr.Column():
+                include_lone_images = gr.Checkbox(label='Include Sub Images', value=False, elem_id=self.elem_id("include_lone_images"))
+                include_sub_grids = gr.Checkbox(label='Include Sub Grids', value=False, elem_id=self.elem_id("include_sub_grids"))
+            with gr.Column():
+                margin_size = gr.Slider(label="Grid margins (px)", minimum=0, maximum=500, value=0, step=2, elem_id=self.elem_id("margin_size"))
+
+        with gr.Row(variant="compact", elem_id="swap_axes"):
+            swap_xy_axes_button = gr.Button(value="Swap X/Y axes", elem_id="xy_grid_swap_axes_button")
+            swap_yz_axes_button = gr.Button(value="Swap Y/Z axes", elem_id="yz_grid_swap_axes_button")
+            swap_xz_axes_button = gr.Button(value="Swap X/Z axes", elem_id="xz_grid_swap_axes_button")
+
+        def swap_axes(axis1_type, axis1_values, axis1_values_dropdown, axis2_type, axis2_values, axis2_values_dropdown):
+            return self.current_axis_options[axis2_type].label, axis2_values, axis2_values_dropdown, self.current_axis_options[axis1_type].label, axis1_values, axis1_values_dropdown
+
+        xy_swap_args = [x_type, x_values, x_values_dropdown, y_type, y_values, y_values_dropdown]
+        swap_xy_axes_button.click(swap_axes, inputs=xy_swap_args, outputs=xy_swap_args)
+        yz_swap_args = [y_type, y_values, y_values_dropdown, z_type, z_values, z_values_dropdown]
+        swap_yz_axes_button.click(swap_axes, inputs=yz_swap_args, outputs=yz_swap_args)
+        xz_swap_args = [x_type, x_values, x_values_dropdown, z_type, z_values, z_values_dropdown]
+        swap_xz_axes_button.click(swap_axes, inputs=xz_swap_args, outputs=xz_swap_args)
+
+        def fill(x_type):
+            axis = self.current_axis_options[x_type]
+            return axis.choices() if axis.choices else gr.update()
+
+        fill_x_button.click(fn=fill, inputs=[x_type], outputs=[x_values_dropdown])
+        fill_y_button.click(fn=fill, inputs=[y_type], outputs=[y_values_dropdown])
+        fill_z_button.click(fn=fill, inputs=[z_type], outputs=[z_values_dropdown])
+
+        def select_axis(axis_type,axis_values_dropdown):
+            choices = self.current_axis_options[axis_type].choices
+            has_choices = choices is not None
+            current_values = axis_values_dropdown
+            if has_choices:
+                choices = choices()
+                if isinstance(current_values,str):
+                    current_values = current_values.split(",")
+                current_values = list(filter(lambda x: x in choices, current_values))
+            return gr.Button.update(visible=has_choices),gr.Textbox.update(visible=not has_choices),gr.update(choices=choices if has_choices else None,visible=has_choices,value=current_values)
+
+        x_type.change(fn=select_axis, inputs=[x_type,x_values_dropdown], outputs=[fill_x_button,x_values,x_values_dropdown])
+        y_type.change(fn=select_axis, inputs=[y_type,y_values_dropdown], outputs=[fill_y_button,y_values,y_values_dropdown])
+        z_type.change(fn=select_axis, inputs=[z_type,z_values_dropdown], outputs=[fill_z_button,z_values,z_values_dropdown])
+
+        def get_dropdown_update_from_params(axis,params):
+            val_key = f"{axis} Values"
+            vals = params.get(val_key,"")
+            valslist = [x.strip() for x in chain.from_iterable(csv.reader(StringIO(vals))) if x]
+            return gr.update(value = valslist)
+
+        self.infotext_fields = (
+            (x_type, "X Type"),
+            (x_values, "X Values"),
+            (x_values_dropdown, lambda params:get_dropdown_update_from_params("X",params)),
+            (y_type, "Y Type"),
+            (y_values, "Y Values"),
+            (y_values_dropdown, lambda params:get_dropdown_update_from_params("Y",params)),
+            (z_type, "Z Type"),
+            (z_values, "Z Values"),
+            (z_values_dropdown, lambda params:get_dropdown_update_from_params("Z",params)),
+        )
+
+        return [x_type, x_values, x_values_dropdown, y_type, y_values, y_values_dropdown, z_type, z_values, z_values_dropdown, draw_legend, include_lone_images, include_sub_grids, no_fixed_seeds, margin_size]
+
+    def run(self, p, x_type, x_values, x_values_dropdown, y_type, y_values, y_values_dropdown, z_type, z_values, z_values_dropdown, draw_legend, include_lone_images, include_sub_grids, no_fixed_seeds, margin_size):
+        if not no_fixed_seeds:
+            modules.processing.fix_seed(p)
+
+        if not opts.return_grid:
+            p.batch_size = 1
+
+        def process_axis(opt, vals, vals_dropdown):
+            if opt.label == 'Nothing':
+                return [0]
+
+            if opt.choices is not None:
+                valslist = vals_dropdown
+            else:
+                valslist = [x.strip() for x in chain.from_iterable(csv.reader(StringIO(vals))) if x]
+
+            if opt.type == int:
+                valslist_ext = []
+
+                for val in valslist:
+                    m = re_range.fullmatch(val)
+                    mc = re_range_count.fullmatch(val)
+                    if m is not None:
+                        start = int(m.group(1))
+                        end = int(m.group(2))+1
+                        step = int(m.group(3)) if m.group(3) is not None else 1
+
+                        valslist_ext += list(range(start, end, step))
+                    elif mc is not None:
+                        start = int(mc.group(1))
+                        end   = int(mc.group(2))
+                        num   = int(mc.group(3)) if mc.group(3) is not None else 1
+
+                        valslist_ext += [int(x) for x in np.linspace(start=start, stop=end, num=num).tolist()]
+                    else:
+                        valslist_ext.append(val)
+
+                valslist = valslist_ext
+            elif opt.type == float:
+                valslist_ext = []
+
+                for val in valslist:
+                    m = re_range_float.fullmatch(val)
+                    mc = re_range_count_float.fullmatch(val)
+                    if m is not None:
+                        start = float(m.group(1))
+                        end = float(m.group(2))
+                        step = float(m.group(3)) if m.group(3) is not None else 1
+
+                        valslist_ext += np.arange(start, end + step, step).tolist()
+                    elif mc is not None:
+                        start = float(mc.group(1))
+                        end   = float(mc.group(2))
+                        num   = int(mc.group(3)) if mc.group(3) is not None else 1
+
+                        valslist_ext += np.linspace(start=start, stop=end, num=num).tolist()
+                    else:
+                        valslist_ext.append(val)
+
+                valslist = valslist_ext
+            elif opt.type == str_permutations:
+                valslist = list(permutations(valslist))
+
+            valslist = [opt.type(x) for x in valslist]
+
+            # Confirm options are valid before starting
+            if opt.confirm:
+                opt.confirm(p, valslist)
+
+            return valslist
+
+        x_opt = self.current_axis_options[x_type]
+        if x_opt.choices is not None:
+            x_values = ",".join(x_values_dropdown)
+        xs = process_axis(x_opt, x_values, x_values_dropdown)
+
+        y_opt = self.current_axis_options[y_type]
+        if y_opt.choices is not None:
+            y_values = ",".join(y_values_dropdown)
+        ys = process_axis(y_opt, y_values, y_values_dropdown)
+
+        z_opt = self.current_axis_options[z_type]
+        if z_opt.choices is not None:
+            z_values = ",".join(z_values_dropdown)
+        zs = process_axis(z_opt, z_values, z_values_dropdown)
+
+        # this could be moved to common code, but unlikely to be ever triggered anywhere else
+        Image.MAX_IMAGE_PIXELS = None # disable check in Pillow and rely on check below to allow large custom image sizes
+        grid_mp = round(len(xs) * len(ys) * len(zs) * p.width * p.height / 1000000)
+        assert grid_mp < opts.img_max_size_mp, f'Error: Resulting grid would be too large ({grid_mp} MPixels) (max configured size is {opts.img_max_size_mp} MPixels)'
+
+        def fix_axis_seeds(axis_opt, axis_list):
+            if axis_opt.label in ['Seed', 'Var. seed']:
+                return [int(random.randrange(4294967294)) if val is None or val == '' or val == -1 else val for val in axis_list]
+            else:
+                return axis_list
+
+        if not no_fixed_seeds:
+            xs = fix_axis_seeds(x_opt, xs)
+            ys = fix_axis_seeds(y_opt, ys)
+            zs = fix_axis_seeds(z_opt, zs)
+
+        if x_opt.label == 'Steps':
+            total_steps = sum(xs) * len(ys) * len(zs)
+        elif y_opt.label == 'Steps':
+            total_steps = sum(ys) * len(xs) * len(zs)
+        elif z_opt.label == 'Steps':
+            total_steps = sum(zs) * len(xs) * len(ys)
+        else:
+            total_steps = p.steps * len(xs) * len(ys) * len(zs)
+
+        if isinstance(p, StableDiffusionProcessingTxt2Img) and p.enable_hr:
+            if x_opt.label == "Hires steps":
+                total_steps += sum(xs) * len(ys) * len(zs)
+            elif y_opt.label == "Hires steps":
+                total_steps += sum(ys) * len(xs) * len(zs)
+            elif z_opt.label == "Hires steps":
+                total_steps += sum(zs) * len(xs) * len(ys)
+            elif p.hr_second_pass_steps:
+                total_steps += p.hr_second_pass_steps * len(xs) * len(ys) * len(zs)
+            else:
+                total_steps *= 2
+
+        total_steps *= p.n_iter
+
+        image_cell_count = p.n_iter * p.batch_size
+        cell_console_text = f"; {image_cell_count} images per cell" if image_cell_count > 1 else ""
+        plural_s = 's' if len(zs) > 1 else ''
+        print(f"X/Y/Z plot will create {len(xs) * len(ys) * len(zs) * image_cell_count} images on {len(zs)} {len(xs)}x{len(ys)} grid{plural_s}{cell_console_text}. (Total steps to process: {total_steps})")
+        shared.total_tqdm.updateTotal(total_steps)
+
+        state.xyz_plot_x = AxisInfo(x_opt, xs)
+        state.xyz_plot_y = AxisInfo(y_opt, ys)
+        state.xyz_plot_z = AxisInfo(z_opt, zs)
+
+        # If one of the axes is very slow to change between (like SD model
+        # checkpoint), then make sure it is in the outer iteration of the nested
+        # `for` loop.
+        first_axes_processed = 'z'
+        second_axes_processed = 'y'
+        if x_opt.cost > y_opt.cost and x_opt.cost > z_opt.cost:
+            first_axes_processed = 'x'
+            if y_opt.cost > z_opt.cost:
+                second_axes_processed = 'y'
+            else:
+                second_axes_processed = 'z'
+        elif y_opt.cost > x_opt.cost and y_opt.cost > z_opt.cost:
+            first_axes_processed = 'y'
+            if x_opt.cost > z_opt.cost:
+                second_axes_processed = 'x'
+            else:
+                second_axes_processed = 'z'
+        elif z_opt.cost > x_opt.cost and z_opt.cost > y_opt.cost:
+            first_axes_processed = 'z'
+            if x_opt.cost > y_opt.cost:
+                second_axes_processed = 'x'
+            else:
+                second_axes_processed = 'y'
+
+        grid_infotext = [None] * (1 + len(zs))
+
+        def cell(x, y, z, ix, iy, iz):
+            if shared.state.interrupted:
+                return Processed(p, [], p.seed, "")
+
+            pc = copy(p)
+            pc.styles = pc.styles[:]
+            x_opt.apply(pc, x, xs)
+            y_opt.apply(pc, y, ys)
+            z_opt.apply(pc, z, zs)
+
+            res = process_images(pc)
+
+            # Sets subgrid infotexts
+            subgrid_index = 1 + iz
+            if grid_infotext[subgrid_index] is None and ix == 0 and iy == 0:
+                pc.extra_generation_params = copy(pc.extra_generation_params)
+                pc.extra_generation_params['Script'] = self.title()
+
+                if x_opt.label != 'Nothing':
+                    pc.extra_generation_params["X Type"] = x_opt.label
+                    pc.extra_generation_params["X Values"] = x_values
+                    if x_opt.label in ["Seed", "Var. seed"] and not no_fixed_seeds:
+                        pc.extra_generation_params["Fixed X Values"] = ", ".join([str(x) for x in xs])
+
+                if y_opt.label != 'Nothing':
+                    pc.extra_generation_params["Y Type"] = y_opt.label
+                    pc.extra_generation_params["Y Values"] = y_values
+                    if y_opt.label in ["Seed", "Var. seed"] and not no_fixed_seeds:
+                        pc.extra_generation_params["Fixed Y Values"] = ", ".join([str(y) for y in ys])
+
+                grid_infotext[subgrid_index] = processing.create_infotext(pc, pc.all_prompts, pc.all_seeds, pc.all_subseeds)
+
+            # Sets main grid infotext
+            if grid_infotext[0] is None and ix == 0 and iy == 0 and iz == 0:
+                pc.extra_generation_params = copy(pc.extra_generation_params)
+
+                if z_opt.label != 'Nothing':
+                    pc.extra_generation_params["Z Type"] = z_opt.label
+                    pc.extra_generation_params["Z Values"] = z_values
+                    if z_opt.label in ["Seed", "Var. seed"] and not no_fixed_seeds:
+                        pc.extra_generation_params["Fixed Z Values"] = ", ".join([str(z) for z in zs])
+
+                grid_infotext[0] = processing.create_infotext(pc, pc.all_prompts, pc.all_seeds, pc.all_subseeds)
+
+            return res
+
+        with SharedSettingsStackHelper():
+            processed = draw_xyz_grid(
+                p,
+                xs=xs,
+                ys=ys,
+                zs=zs,
+                x_labels=[x_opt.format_value(p, x_opt, x) for x in xs],
+                y_labels=[y_opt.format_value(p, y_opt, y) for y in ys],
+                z_labels=[z_opt.format_value(p, z_opt, z) for z in zs],
+                cell=cell,
+                draw_legend=draw_legend,
+                include_lone_images=include_lone_images,
+                include_sub_grids=include_sub_grids,
+                first_axes_processed=first_axes_processed,
+                second_axes_processed=second_axes_processed,
+                margin_size=margin_size
+            )
+
+        if not processed.images:
+            # It broke, no further handling needed.
+            return processed
+
+        z_count = len(zs)
+
+        # Set the grid infotexts to the real ones with extra_generation_params (1 main grid + z_count sub-grids)
+        processed.infotexts[:1+z_count] = grid_infotext[:1+z_count]
+
+        if not include_lone_images:
+            # Don't need sub-images anymore, drop from list:
+            processed.images = processed.images[:z_count+1]
+
+        if opts.grid_save:
+            # Auto-save main and sub-grids:
+            grid_count = z_count + 1 if z_count > 1 else 1
+            for g in range(grid_count):
+                #TODO: See previous comment about intentional data misalignment.
+                adj_g = g-1 if g > 0 else g
+                images.save_image(processed.images[g], p.outpath_grids, "xyz_grid", info=processed.infotexts[g], extension=opts.grid_format, prompt=processed.all_prompts[adj_g], seed=processed.all_seeds[adj_g], grid=True, p=processed)
+
+        if not include_sub_grids:
+            # Done with sub-grids, drop all related information:
+            for _ in range(z_count):
+                del processed.images[1]
+                del processed.all_prompts[1]
+                del processed.all_seeds[1]
+                del processed.infotexts[1]
+
+        return processed

test/conftest.py

@@ -0,0 +1,17 @@
+import os
+
+import pytest
+from PIL import Image
+from gradio.processing_utils import encode_pil_to_base64
+
+test_files_path = os.path.dirname(__file__) + "/test_files"
+
+
+@pytest.fixture(scope="session")  # session so we don't read this over and over
+def img2img_basic_image_base64() -> str:
+    return encode_pil_to_base64(Image.open(os.path.join(test_files_path, "img2img_basic.png")))
+
+
+@pytest.fixture(scope="session")  # session so we don't read this over and over
+def mask_basic_image_base64() -> str:
+    return encode_pil_to_base64(Image.open(os.path.join(test_files_path, "mask_basic.png")))

test/test_extras.py

@@ -0,0 +1,35 @@
+import requests
+
+
+def test_simple_upscaling_performed(base_url, img2img_basic_image_base64):
+    payload = {
+        "resize_mode": 0,
+        "show_extras_results": True,
+        "gfpgan_visibility": 0,
+        "codeformer_visibility": 0,
+        "codeformer_weight": 0,
+        "upscaling_resize": 2,
+        "upscaling_resize_w": 128,
+        "upscaling_resize_h": 128,
+        "upscaling_crop": True,
+        "upscaler_1": "Lanczos",
+        "upscaler_2": "None",
+        "extras_upscaler_2_visibility": 0,
+        "image": img2img_basic_image_base64,
+    }
+    assert requests.post(f"{base_url}/sdapi/v1/extra-single-image", json=payload).status_code == 200
+
+
+def test_png_info_performed(base_url, img2img_basic_image_base64):
+    payload = {
+        "image": img2img_basic_image_base64,
+    }
+    assert requests.post(f"{base_url}/sdapi/v1/extra-single-image", json=payload).status_code == 200
+
+
+def test_interrogate_performed(base_url, img2img_basic_image_base64):
+    payload = {
+        "image": img2img_basic_image_base64,
+        "model": "clip",
+    }
+    assert requests.post(f"{base_url}/sdapi/v1/extra-single-image", json=payload).status_code == 200

test/test_files/empty.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d030ad8db708280fcae77d87e973102039acd23a11bdecc3db8eb6c0ac940ee1
+size 431

test/test_img2img.py

@@ -0,0 +1,68 @@
+
+import pytest
+import requests
+
+
+@pytest.fixture()
+def url_img2img(base_url):
+    return f"{base_url}/sdapi/v1/img2img"
+
+
+@pytest.fixture()
+def simple_img2img_request(img2img_basic_image_base64):
+    return {
+        "batch_size": 1,
+        "cfg_scale": 7,
+        "denoising_strength": 0.75,
+        "eta": 0,
+        "height": 64,
+        "include_init_images": False,
+        "init_images": [img2img_basic_image_base64],
+        "inpaint_full_res": False,
+        "inpaint_full_res_padding": 0,
+        "inpainting_fill": 0,
+        "inpainting_mask_invert": False,
+        "mask": None,
+        "mask_blur": 4,
+        "n_iter": 1,
+        "negative_prompt": "",
+        "override_settings": {},
+        "prompt": "example prompt",
+        "resize_mode": 0,
+        "restore_faces": False,
+        "s_churn": 0,
+        "s_noise": 1,
+        "s_tmax": 0,
+        "s_tmin": 0,
+        "sampler_index": "Euler a",
+        "seed": -1,
+        "seed_resize_from_h": -1,
+        "seed_resize_from_w": -1,
+        "steps": 3,
+        "styles": [],
+        "subseed": -1,
+        "subseed_strength": 0,
+        "tiling": False,
+        "width": 64,
+    }
+
+
+def test_img2img_simple_performed(url_img2img, simple_img2img_request):
+    assert requests.post(url_img2img, json=simple_img2img_request).status_code == 200
+
+
+def test_inpainting_masked_performed(url_img2img, simple_img2img_request, mask_basic_image_base64):
+    simple_img2img_request["mask"] = mask_basic_image_base64
+    assert requests.post(url_img2img, json=simple_img2img_request).status_code == 200
+
+
+def test_inpainting_with_inverted_masked_performed(url_img2img, simple_img2img_request, mask_basic_image_base64):
+    simple_img2img_request["mask"] = mask_basic_image_base64
+    simple_img2img_request["inpainting_mask_invert"] = True
+    assert requests.post(url_img2img, json=simple_img2img_request).status_code == 200
+
+
+def test_img2img_sd_upscale_performed(url_img2img, simple_img2img_request):
+    simple_img2img_request["script_name"] = "sd upscale"
+    simple_img2img_request["script_args"] = ["", 8, "Lanczos", 2.0]
+    assert requests.post(url_img2img, json=simple_img2img_request).status_code == 200

test/test_txt2img.py

@@ -0,0 +1,90 @@
+
+import pytest
+import requests
+
+
+@pytest.fixture()
+def url_txt2img(base_url):
+    return f"{base_url}/sdapi/v1/txt2img"
+
+
+@pytest.fixture()
+def simple_txt2img_request():
+    return {
+        "batch_size": 1,
+        "cfg_scale": 7,
+        "denoising_strength": 0,
+        "enable_hr": False,
+        "eta": 0,
+        "firstphase_height": 0,
+        "firstphase_width": 0,
+        "height": 64,
+        "n_iter": 1,
+        "negative_prompt": "",
+        "prompt": "example prompt",
+        "restore_faces": False,
+        "s_churn": 0,
+        "s_noise": 1,
+        "s_tmax": 0,
+        "s_tmin": 0,
+        "sampler_index": "Euler a",
+        "seed": -1,
+        "seed_resize_from_h": -1,
+        "seed_resize_from_w": -1,
+        "steps": 3,
+        "styles": [],
+        "subseed": -1,
+        "subseed_strength": 0,
+        "tiling": False,
+        "width": 64,
+    }
+
+
+def test_txt2img_simple_performed(url_txt2img, simple_txt2img_request):
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+def test_txt2img_with_negative_prompt_performed(url_txt2img, simple_txt2img_request):
+    simple_txt2img_request["negative_prompt"] = "example negative prompt"
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+def test_txt2img_with_complex_prompt_performed(url_txt2img, simple_txt2img_request):
+    simple_txt2img_request["prompt"] = "((emphasis)), (emphasis1:1.1), [to:1], [from::2], [from:to:0.3], [alt|alt1]"
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+def test_txt2img_not_square_image_performed(url_txt2img, simple_txt2img_request):
+    simple_txt2img_request["height"] = 128
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+def test_txt2img_with_hrfix_performed(url_txt2img, simple_txt2img_request):
+    simple_txt2img_request["enable_hr"] = True
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+def test_txt2img_with_tiling_performed(url_txt2img, simple_txt2img_request):
+    simple_txt2img_request["tiling"] = True
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+def test_txt2img_with_restore_faces_performed(url_txt2img, simple_txt2img_request):
+    simple_txt2img_request["restore_faces"] = True
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+@pytest.mark.parametrize("sampler", ["PLMS", "DDIM", "UniPC"])
+def test_txt2img_with_vanilla_sampler_performed(url_txt2img, simple_txt2img_request, sampler):
+    simple_txt2img_request["sampler_index"] = sampler
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+def test_txt2img_multiple_batches_performed(url_txt2img, simple_txt2img_request):
+    simple_txt2img_request["n_iter"] = 2
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200
+
+
+def test_txt2img_batch_performed(url_txt2img, simple_txt2img_request):
+    simple_txt2img_request["batch_size"] = 2
+    assert requests.post(url_txt2img, json=simple_txt2img_request).status_code == 200

test/test_utils.py

@@ -0,0 +1,33 @@
+import pytest
+import requests
+
+
+def test_options_write(base_url):
+    url_options = f"{base_url}/sdapi/v1/options"
+    response = requests.get(url_options)
+    assert response.status_code == 200
+
+    pre_value = response.json()["send_seed"]
+
+    assert requests.post(url_options, json={'send_seed': (not pre_value)}).status_code == 200
+
+    response = requests.get(url_options)
+    assert response.status_code == 200
+    assert response.json()['send_seed'] == (not pre_value)
+
+    requests.post(url_options, json={"send_seed": pre_value})
+
+
+@pytest.mark.parametrize("url", [
+    "sdapi/v1/cmd-flags",
+    "sdapi/v1/samplers",
+    "sdapi/v1/upscalers",
+    "sdapi/v1/sd-models",
+    "sdapi/v1/hypernetworks",
+    "sdapi/v1/face-restorers",
+    "sdapi/v1/realesrgan-models",
+    "sdapi/v1/prompt-styles",
+    "sdapi/v1/embeddings",
+])
+def test_get_api_url(base_url, url):
+    assert requests.get(f"{base_url}/{url}").status_code == 200

textual_inversion_templates/hypernetwork.txt

@@ -0,0 +1,27 @@
+a photo of a [filewords]
+a rendering of a [filewords]
+a cropped photo of the [filewords]
+the photo of a [filewords]
+a photo of a clean [filewords]
+a photo of a dirty [filewords]
+a dark photo of the [filewords]
+a photo of my [filewords]
+a photo of the cool [filewords]
+a close-up photo of a [filewords]
+a bright photo of the [filewords]
+a cropped photo of a [filewords]
+a photo of the [filewords]
+a good photo of the [filewords]
+a photo of one [filewords]
+a close-up photo of the [filewords]
+a rendition of the [filewords]
+a photo of the clean [filewords]
+a rendition of a [filewords]
+a photo of a nice [filewords]
+a good photo of a [filewords]
+a photo of the nice [filewords]
+a photo of the small [filewords]
+a photo of the weird [filewords]
+a photo of the large [filewords]
+a photo of a cool [filewords]
+a photo of a small [filewords]

textual_inversion_templates/none.txt

@@ -0,0 +1 @@
+picture

textual_inversion_templates/style.txt

@@ -0,0 +1,19 @@
+a painting, art by [name]
+a rendering, art by [name]
+a cropped painting, art by [name]
+the painting, art by [name]
+a clean painting, art by [name]
+a dirty painting, art by [name]
+a dark painting, art by [name]
+a picture, art by [name]
+a cool painting, art by [name]
+a close-up painting, art by [name]
+a bright painting, art by [name]
+a cropped painting, art by [name]
+a good painting, art by [name]
+a close-up painting, art by [name]
+a rendition, art by [name]
+a nice painting, art by [name]
+a small painting, art by [name]
+a weird painting, art by [name]
+a large painting, art by [name]

textual_inversion_templates/style_filewords.txt

@@ -0,0 +1,19 @@
+a painting of [filewords], art by [name]
+a rendering of [filewords], art by [name]
+a cropped painting of [filewords], art by [name]
+the painting of [filewords], art by [name]
+a clean painting of [filewords], art by [name]
+a dirty painting of [filewords], art by [name]
+a dark painting of [filewords], art by [name]
+a picture of [filewords], art by [name]
+a cool painting of [filewords], art by [name]
+a close-up painting of [filewords], art by [name]
+a bright painting of [filewords], art by [name]
+a cropped painting of [filewords], art by [name]
+a good painting of [filewords], art by [name]
+a close-up painting of [filewords], art by [name]
+a rendition of [filewords], art by [name]
+a nice painting of [filewords], art by [name]
+a small painting of [filewords], art by [name]
+a weird painting of [filewords], art by [name]
+a large painting of [filewords], art by [name]

textual_inversion_templates/subject.txt

@@ -0,0 +1,27 @@
+a photo of a [name]
+a rendering of a [name]
+a cropped photo of the [name]
+the photo of a [name]
+a photo of a clean [name]
+a photo of a dirty [name]
+a dark photo of the [name]
+a photo of my [name]
+a photo of the cool [name]
+a close-up photo of a [name]
+a bright photo of the [name]
+a cropped photo of a [name]
+a photo of the [name]
+a good photo of the [name]
+a photo of one [name]
+a close-up photo of the [name]
+a rendition of the [name]
+a photo of the clean [name]
+a rendition of a [name]
+a photo of a nice [name]
+a good photo of a [name]
+a photo of the nice [name]
+a photo of the small [name]
+a photo of the weird [name]
+a photo of the large [name]
+a photo of a cool [name]
+a photo of a small [name]

textual_inversion_templates/subject_filewords.txt

@@ -0,0 +1,27 @@
+a photo of a [name], [filewords]
+a rendering of a [name], [filewords]
+a cropped photo of the [name], [filewords]
+the photo of a [name], [filewords]
+a photo of a clean [name], [filewords]
+a photo of a dirty [name], [filewords]
+a dark photo of the [name], [filewords]
+a photo of my [name], [filewords]
+a photo of the cool [name], [filewords]
+a close-up photo of a [name], [filewords]
+a bright photo of the [name], [filewords]
+a cropped photo of a [name], [filewords]
+a photo of the [name], [filewords]
+a good photo of the [name], [filewords]
+a photo of one [name], [filewords]
+a close-up photo of the [name], [filewords]
+a rendition of the [name], [filewords]
+a photo of the clean [name], [filewords]
+a rendition of a [name], [filewords]
+a photo of a nice [name], [filewords]
+a good photo of a [name], [filewords]
+a photo of the nice [name], [filewords]
+a photo of the small [name], [filewords]
+a photo of the weird [name], [filewords]
+a photo of the large [name], [filewords]
+a photo of a cool [name], [filewords]
+a photo of a small [name], [filewords]

tmp/tagAutocompletePath.txt

@@ -0,0 +1 @@
+extensions/a1111-microsoftexcel-tagcomplete/tags

webui-macos-env.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+####################################################################
+#                          macOS defaults                          #
+# Please modify webui-user.sh to change these instead of this file #
+####################################################################
+
+if [[ -x "$(command -v python3.10)" ]]
+then
+    python_cmd="python3.10"
+fi
+
+export install_dir="$HOME"
+export COMMANDLINE_ARGS="--skip-torch-cuda-test --upcast-sampling --no-half-vae --use-cpu interrogate"
+export TORCH_COMMAND="pip install torch==2.0.1 torchvision==0.15.2"
+export K_DIFFUSION_REPO="https://github.com/brkirch/k-diffusion.git"
+export K_DIFFUSION_COMMIT_HASH="51c9778f269cedb55a4d88c79c0246d35bdadb71"
+export PYTORCH_ENABLE_MPS_FALLBACK=1
+
+####################################################################

webui-user.bat

@@ -0,0 +1,8 @@
+@echo off
+
+set PYTHON=
+set GIT=
+set VENV_DIR=
+set COMMANDLINE_ARGS=
+
+call webui.bat

webui-user.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+#########################################################
+# Uncomment and change the variables below to your need:#
+#########################################################
+
+# Install directory without trailing slash
+#install_dir="/home/$(whoami)"
+
+# Name of the subdirectory
+#clone_dir="stable-diffusion-webui"
+
+# Commandline arguments for webui.py, for example: export COMMANDLINE_ARGS="--medvram --opt-split-attention"
+#export COMMANDLINE_ARGS=""
+
+# python3 executable
+#python_cmd="python3"
+
+# git executable
+#export GIT="git"
+
+# python3 venv without trailing slash (defaults to ${install_dir}/${clone_dir}/venv)
+#venv_dir="venv"
+
+# script to launch to start the app
+#export LAUNCH_SCRIPT="launch.py"
+
+# install command for torch
+#export TORCH_COMMAND="pip install torch==1.12.1+cu113 --extra-index-url https://download.pytorch.org/whl/cu113"
+
+# Requirements file to use for stable-diffusion-webui
+#export REQS_FILE="requirements_versions.txt"
+
+# Fixed git repos
+#export K_DIFFUSION_PACKAGE=""
+#export GFPGAN_PACKAGE=""
+
+# Fixed git commits
+#export STABLE_DIFFUSION_COMMIT_HASH=""
+#export CODEFORMER_COMMIT_HASH=""
+#export BLIP_COMMIT_HASH=""
+
+# Uncomment to enable accelerated launch
+#export ACCELERATE="True"
+
+# Uncomment to disable TCMalloc
+#export NO_TCMALLOC="True"
+
+###########################################

webui.bat

@@ -0,0 +1,87 @@
+@echo off
+
+if not defined PYTHON (set PYTHON=python)
+if not defined VENV_DIR (set "VENV_DIR=%~dp0%venv")
+
+set SD_WEBUI_RESTART=tmp/restart
+set ERROR_REPORTING=FALSE
+
+mkdir tmp 2>NUL
+
+%PYTHON% -c "" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :check_pip
+echo Couldn't launch python
+goto :show_stdout_stderr
+
+:check_pip
+%PYTHON% -mpip --help >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :start_venv
+if "%PIP_INSTALLER_LOCATION%" == "" goto :show_stdout_stderr
+%PYTHON% "%PIP_INSTALLER_LOCATION%" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :start_venv
+echo Couldn't install pip
+goto :show_stdout_stderr
+
+:start_venv
+if ["%VENV_DIR%"] == ["-"] goto :skip_venv
+if ["%SKIP_VENV%"] == ["1"] goto :skip_venv
+
+dir "%VENV_DIR%\Scripts\Python.exe" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :activate_venv
+
+for /f "delims=" %%i in ('CALL %PYTHON% -c "import sys; print(sys.executable)"') do set PYTHON_FULLNAME="%%i"
+echo Creating venv in directory %VENV_DIR% using python %PYTHON_FULLNAME%
+%PYTHON_FULLNAME% -m venv "%VENV_DIR%" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :activate_venv
+echo Unable to create venv in directory "%VENV_DIR%"
+goto :show_stdout_stderr
+
+:activate_venv
+set PYTHON="%VENV_DIR%\Scripts\Python.exe"
+echo venv %PYTHON%
+
+:skip_venv
+if [%ACCELERATE%] == ["True"] goto :accelerate
+goto :launch
+
+:accelerate
+echo Checking for accelerate
+set ACCELERATE="%VENV_DIR%\Scripts\accelerate.exe"
+if EXIST %ACCELERATE% goto :accelerate_launch
+
+:launch
+%PYTHON% launch.py %*
+if EXIST tmp/restart goto :skip_venv
+pause
+exit /b
+
+:accelerate_launch
+echo Accelerating
+%ACCELERATE% launch --num_cpu_threads_per_process=6 launch.py
+if EXIST tmp/restart goto :skip_venv
+pause
+exit /b
+
+:show_stdout_stderr
+
+echo.
+echo exit code: %errorlevel%
+
+for /f %%i in ("tmp\stdout.txt") do set size=%%~zi
+if %size% equ 0 goto :show_stderr
+echo.
+echo stdout:
+type tmp\stdout.txt
+
+:show_stderr
+for /f %%i in ("tmp\stderr.txt") do set size=%%~zi
+if %size% equ 0 goto :show_stderr
+echo.
+echo stderr:
+type tmp\stderr.txt
+
+:endofscript
+
+echo.
+echo Launch unsuccessful. Exiting.
+pause

webui.py

@@ -0,0 +1,485 @@
+from __future__ import annotations
+
+import os
+import sys
+import time
+import importlib
+import signal
+import re
+import warnings
+import json
+from threading import Thread
+from typing import Iterable
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+from packaging import version
+
+import logging
+
+# We can't use cmd_opts for this because it will not have been initialized at this point.
+log_level = os.environ.get("SD_WEBUI_LOG_LEVEL")
+if log_level:
+    log_level = getattr(logging, log_level.upper(), None) or logging.INFO
+    logging.basicConfig(
+        level=log_level,
+        format='%(asctime)s %(levelname)s [%(name)s] %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S',
+    )
+
+logging.getLogger("torch.distributed.nn").setLevel(logging.ERROR)  # sshh...
+logging.getLogger("xformers").addFilter(lambda record: 'A matching Triton is not available' not in record.getMessage())
+
+from modules import timer
+startup_timer = timer.startup_timer
+startup_timer.record("launcher")
+
+import torch
+import pytorch_lightning   # noqa: F401 # pytorch_lightning should be imported after torch, but it re-enables warnings on import so import once to disable them
+warnings.filterwarnings(action="ignore", category=DeprecationWarning, module="pytorch_lightning")
+warnings.filterwarnings(action="ignore", category=UserWarning, module="torchvision")
+startup_timer.record("import torch")
+
+import gradio  # noqa: F401
+startup_timer.record("import gradio")
+
+from modules import paths, timer, import_hook, errors, devices  # noqa: F401
+startup_timer.record("setup paths")
+
+import ldm.modules.encoders.modules  # noqa: F401
+startup_timer.record("import ldm")
+
+from modules import extra_networks
+from modules.call_queue import wrap_gradio_gpu_call, wrap_queued_call, queue_lock  # noqa: F401
+
+# Truncate version number of nightly/local build of PyTorch to not cause exceptions with CodeFormer or Safetensors
+if ".dev" in torch.__version__ or "+git" in torch.__version__:
+    torch.__long_version__ = torch.__version__
+    torch.__version__ = re.search(r'[\d.]+[\d]', torch.__version__).group(0)
+
+from modules import shared, sd_samplers, upscaler, extensions, localization, ui_tempdir, ui_extra_networks, config_states
+import modules.codeformer_model as codeformer
+import modules.face_restoration
+import modules.gfpgan_model as gfpgan
+import modules.img2img
+
+import modules.lowvram
+import modules.scripts
+import modules.sd_hijack
+import modules.sd_hijack_optimizations
+import modules.sd_models
+import modules.sd_vae
+import modules.sd_unet
+import modules.txt2img
+import modules.script_callbacks
+import modules.textual_inversion.textual_inversion
+import modules.progress
+
+import modules.ui
+from modules import modelloader
+from modules.shared import cmd_opts
+import modules.hypernetworks.hypernetwork
+
+startup_timer.record("other imports")
+
+
+if cmd_opts.server_name:
+    server_name = cmd_opts.server_name
+else:
+    server_name = "0.0.0.0" if cmd_opts.listen else None
+
+
+def fix_asyncio_event_loop_policy():
+    """
+        The default `asyncio` event loop policy only automatically creates
+        event loops in the main threads. Other threads must create event
+        loops explicitly or `asyncio.get_event_loop` (and therefore
+        `.IOLoop.current`) will fail. Installing this policy allows event
+        loops to be created automatically on any thread, matching the
+        behavior of Tornado versions prior to 5.0 (or 5.0 on Python 2).
+    """
+
+    import asyncio
+
+    if sys.platform == "win32" and hasattr(asyncio, "WindowsSelectorEventLoopPolicy"):
+        # "Any thread" and "selector" should be orthogonal, but there's not a clean
+        # interface for composing policies so pick the right base.
+        _BasePolicy = asyncio.WindowsSelectorEventLoopPolicy  # type: ignore
+    else:
+        _BasePolicy = asyncio.DefaultEventLoopPolicy
+
+    class AnyThreadEventLoopPolicy(_BasePolicy):  # type: ignore
+        """Event loop policy that allows loop creation on any thread.
+        Usage::
+
+            asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
+        """
+
+        def get_event_loop(self) -> asyncio.AbstractEventLoop:
+            try:
+                return super().get_event_loop()
+            except (RuntimeError, AssertionError):
+                # This was an AssertionError in python 3.4.2 (which ships with debian jessie)
+                # and changed to a RuntimeError in 3.4.3.
+                # "There is no current event loop in thread %r"
+                loop = self.new_event_loop()
+                self.set_event_loop(loop)
+                return loop
+
+    asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
+
+
+def check_versions():
+    if shared.cmd_opts.skip_version_check:
+        return
+
+    expected_torch_version = "2.0.0"
+
+    if version.parse(torch.__version__) < version.parse(expected_torch_version):
+        errors.print_error_explanation(f"""
+You are running torch {torch.__version__}.
+The program is tested to work with torch {expected_torch_version}.
+To reinstall the desired version, run with commandline flag --reinstall-torch.
+Beware that this will cause a lot of large files to be downloaded, as well as
+there are reports of issues with training tab on the latest version.
+
+Use --skip-version-check commandline argument to disable this check.
+        """.strip())
+
+    expected_xformers_version = "0.0.20"
+    if shared.xformers_available:
+        import xformers
+
+        if version.parse(xformers.__version__) < version.parse(expected_xformers_version):
+            errors.print_error_explanation(f"""
+You are running xformers {xformers.__version__}.
+The program is tested to work with xformers {expected_xformers_version}.
+To reinstall the desired version, run with commandline flag --reinstall-xformers.
+
+Use --skip-version-check commandline argument to disable this check.
+            """.strip())
+
+
+def restore_config_state_file():
+    config_state_file = shared.opts.restore_config_state_file
+    if config_state_file == "":
+        return
+
+    shared.opts.restore_config_state_file = ""
+    shared.opts.save(shared.config_filename)
+
+    if os.path.isfile(config_state_file):
+        print(f"*** About to restore extension state from file: {config_state_file}")
+        with open(config_state_file, "r", encoding="utf-8") as f:
+            config_state = json.load(f)
+            config_states.restore_extension_config(config_state)
+        startup_timer.record("restore extension config")
+    elif config_state_file:
+        print(f"!!! Config state backup not found: {config_state_file}")
+
+
+def validate_tls_options():
+    if not (cmd_opts.tls_keyfile and cmd_opts.tls_certfile):
+        return
+
+    try:
+        if not os.path.exists(cmd_opts.tls_keyfile):
+            print("Invalid path to TLS keyfile given")
+        if not os.path.exists(cmd_opts.tls_certfile):
+            print(f"Invalid path to TLS certfile: '{cmd_opts.tls_certfile}'")
+    except TypeError:
+        cmd_opts.tls_keyfile = cmd_opts.tls_certfile = None
+        print("TLS setup invalid, running webui without TLS")
+    else:
+        print("Running with TLS")
+    startup_timer.record("TLS")
+
+
+def get_gradio_auth_creds() -> Iterable[tuple[str, ...]]:
+    """
+    Convert the gradio_auth and gradio_auth_path commandline arguments into
+    an iterable of (username, password) tuples.
+    """
+    def process_credential_line(s) -> tuple[str, ...] | None:
+        s = s.strip()
+        if not s:
+            return None
+        return tuple(s.split(':', 1))
+
+    if cmd_opts.gradio_auth:
+        for cred in cmd_opts.gradio_auth.split(','):
+            cred = process_credential_line(cred)
+            if cred:
+                yield cred
+
+    if cmd_opts.gradio_auth_path:
+        with open(cmd_opts.gradio_auth_path, 'r', encoding="utf8") as file:
+            for line in file.readlines():
+                for cred in line.strip().split(','):
+                    cred = process_credential_line(cred)
+                    if cred:
+                        yield cred
+
+
+def configure_sigint_handler():
+    # make the program just exit at ctrl+c without waiting for anything
+    def sigint_handler(sig, frame):
+        print(f'Interrupted with signal {sig} in {frame}')
+        os._exit(0)
+
+    if not os.environ.get("COVERAGE_RUN"):
+        # Don't install the immediate-quit handler when running under coverage,
+        # as then the coverage report won't be generated.
+        signal.signal(signal.SIGINT, sigint_handler)
+
+
+def configure_opts_onchange():
+    shared.opts.onchange("sd_model_checkpoint", wrap_queued_call(lambda: modules.sd_models.reload_model_weights()), call=False)
+    shared.opts.onchange("sd_vae", wrap_queued_call(lambda: modules.sd_vae.reload_vae_weights()), call=False)
+    shared.opts.onchange("sd_vae_as_default", wrap_queued_call(lambda: modules.sd_vae.reload_vae_weights()), call=False)
+    shared.opts.onchange("temp_dir", ui_tempdir.on_tmpdir_changed)
+    shared.opts.onchange("gradio_theme", shared.reload_gradio_theme)
+    shared.opts.onchange("cross_attention_optimization", wrap_queued_call(lambda: modules.sd_hijack.model_hijack.redo_hijack(shared.sd_model)), call=False)
+    startup_timer.record("opts onchange")
+
+
+def initialize():
+    fix_asyncio_event_loop_policy()
+    validate_tls_options()
+    configure_sigint_handler()
+    check_versions()
+    modelloader.cleanup_models()
+    configure_opts_onchange()
+
+    modules.sd_models.setup_model()
+    startup_timer.record("setup SD model")
+
+    codeformer.setup_model(cmd_opts.codeformer_models_path)
+    startup_timer.record("setup codeformer")
+
+    gfpgan.setup_model(cmd_opts.gfpgan_models_path)
+    startup_timer.record("setup gfpgan")
+
+    initialize_rest(reload_script_modules=False)
+
+
+def initialize_rest(*, reload_script_modules=False):
+    """
+    Called both from initialize() and when reloading the webui.
+    """
+    sd_samplers.set_samplers()
+    extensions.list_extensions()
+    startup_timer.record("list extensions")
+
+    restore_config_state_file()
+
+    if cmd_opts.ui_debug_mode:
+        shared.sd_upscalers = upscaler.UpscalerLanczos().scalers
+        modules.scripts.load_scripts()
+        return
+
+    modules.sd_models.list_models()
+    startup_timer.record("list SD models")
+
+    localization.list_localizations(cmd_opts.localizations_dir)
+
+    with startup_timer.subcategory("load scripts"):
+        modules.scripts.load_scripts()
+
+    if reload_script_modules:
+        for module in [module for name, module in sys.modules.items() if name.startswith("modules.ui")]:
+            importlib.reload(module)
+        startup_timer.record("reload script modules")
+
+    modelloader.load_upscalers()
+    startup_timer.record("load upscalers")
+
+    modules.sd_vae.refresh_vae_list()
+    startup_timer.record("refresh VAE")
+    modules.textual_inversion.textual_inversion.list_textual_inversion_templates()
+    startup_timer.record("refresh textual inversion templates")
+
+    modules.script_callbacks.on_list_optimizers(modules.sd_hijack_optimizations.list_optimizers)
+    modules.sd_hijack.list_optimizers()
+    startup_timer.record("scripts list_optimizers")
+
+    modules.sd_unet.list_unets()
+    startup_timer.record("scripts list_unets")
+
+    def load_model():
+        """
+        Accesses shared.sd_model property to load model.
+        After it's available, if it has been loaded before this access by some extension,
+        its optimization may be None because the list of optimizaers has neet been filled
+        by that time, so we apply optimization again.
+        """
+
+        shared.sd_model  # noqa: B018
+
+        if modules.sd_hijack.current_optimizer is None:
+            modules.sd_hijack.apply_optimizations()
+
+    Thread(target=load_model).start()
+
+    Thread(target=devices.first_time_calculation).start()
+
+    shared.reload_hypernetworks()
+    startup_timer.record("reload hypernetworks")
+
+    ui_extra_networks.initialize()
+    ui_extra_networks.register_default_pages()
+
+    extra_networks.initialize()
+    extra_networks.register_default_extra_networks()
+    startup_timer.record("initialize extra networks")
+
+
+def setup_middleware(app):
+    app.middleware_stack = None  # reset current middleware to allow modifying user provided list
+    app.add_middleware(GZipMiddleware, minimum_size=1000)
+    configure_cors_middleware(app)
+    app.build_middleware_stack()  # rebuild middleware stack on-the-fly
+
+
+def configure_cors_middleware(app):
+    cors_options = {
+        "allow_methods": ["*"],
+        "allow_headers": ["*"],
+        "allow_credentials": True,
+    }
+    if cmd_opts.cors_allow_origins:
+        cors_options["allow_origins"] = cmd_opts.cors_allow_origins.split(',')
+    if cmd_opts.cors_allow_origins_regex:
+        cors_options["allow_origin_regex"] = cmd_opts.cors_allow_origins_regex
+    app.add_middleware(CORSMiddleware, **cors_options)
+
+
+def create_api(app):
+    from modules.api.api import Api
+    api = Api(app, queue_lock)
+    return api
+
+
+def api_only():
+    initialize()
+
+    app = FastAPI()
+    setup_middleware(app)
+    api = create_api(app)
+
+    modules.script_callbacks.app_started_callback(None, app)
+
+    print(f"Startup time: {startup_timer.summary()}.")
+    api.launch(
+        server_name="0.0.0.0" if cmd_opts.listen else "127.0.0.1",
+        port=cmd_opts.port if cmd_opts.port else 7861,
+        root_path=f"/{cmd_opts.subpath}" if cmd_opts.subpath else ""
+    )
+
+
+def webui():
+    launch_api = cmd_opts.api
+    initialize()
+
+    while 1:
+        if shared.opts.clean_temp_dir_at_start:
+            ui_tempdir.cleanup_tmpdr()
+            startup_timer.record("cleanup temp dir")
+
+        modules.script_callbacks.before_ui_callback()
+        startup_timer.record("scripts before_ui_callback")
+
+        shared.demo = modules.ui.create_ui()
+        startup_timer.record("create ui")
+
+        if not cmd_opts.no_gradio_queue:
+            shared.demo.queue(concurrency_count=16)
+        else:
+            print('Server queues disabled')
+            shared.demo.progress_tracking = False
+
+        gradio_auth_creds = list(get_gradio_auth_creds()) or None
+
+        app, local_url, share_url = shared.demo.launch(
+            share=cmd_opts.share,
+            server_name=server_name,
+            server_port=cmd_opts.port,
+            ssl_keyfile=cmd_opts.tls_keyfile,
+            ssl_certfile=cmd_opts.tls_certfile,
+            ssl_verify=cmd_opts.disable_tls_verify,
+            debug=cmd_opts.gradio_debug,
+            auth=gradio_auth_creds,
+            inbrowser=cmd_opts.autolaunch and os.getenv('SD_WEBUI_RESTARTING') != '1',
+            prevent_thread_lock=True,
+            allowed_paths=cmd_opts.gradio_allowed_path,
+            app_kwargs={
+                "docs_url": "/docs",
+                "redoc_url": "/redoc",
+            },
+            root_path=f"/{cmd_opts.subpath}" if cmd_opts.subpath else "",
+        )
+
+        # after initial launch, disable --autolaunch for subsequent restarts
+        cmd_opts.autolaunch = False
+
+        startup_timer.record("gradio launch")
+
+        # gradio uses a very open CORS policy via app.user_middleware, which makes it possible for
+        # an attacker to trick the user into opening a malicious HTML page, which makes a request to the
+        # running web ui and do whatever the attacker wants, including installing an extension and
+        # running its code. We disable this here. Suggested by RyotaK.
+        app.user_middleware = [x for x in app.user_middleware if x.cls.__name__ != 'CORSMiddleware']
+
+        setup_middleware(app)
+
+        modules.progress.setup_progress_api(app)
+        modules.ui.setup_ui_api(app)
+
+        if launch_api:
+            create_api(app)
+
+        ui_extra_networks.add_pages_to_demo(app)
+
+        startup_timer.record("add APIs")
+
+        with startup_timer.subcategory("app_started_callback"):
+            modules.script_callbacks.app_started_callback(shared.demo, app)
+
+        timer.startup_record = startup_timer.dump()
+        print(f"Startup time: {startup_timer.summary()}.")
+
+        try:
+            while True:
+                server_command = shared.state.wait_for_server_command(timeout=5)
+                if server_command:
+                    if server_command in ("stop", "restart"):
+                        break
+                    else:
+                        print(f"Unknown server command: {server_command}")
+        except KeyboardInterrupt:
+            print('Caught KeyboardInterrupt, stopping...')
+            server_command = "stop"
+
+        if server_command == "stop":
+            print("Stopping server...")
+            # If we catch a keyboard interrupt, we want to stop the server and exit.
+            shared.demo.close()
+            break
+
+        print('Restarting UI...')
+        shared.demo.close()
+        time.sleep(0.5)
+        startup_timer.reset()
+        modules.script_callbacks.app_reload_callback()
+        startup_timer.record("app reload callback")
+        modules.script_callbacks.script_unloaded_callback()
+        startup_timer.record("scripts unloaded callback")
+        initialize_rest(reload_script_modules=True)
+
+
+if __name__ == "__main__":
+    if cmd_opts.nowebui:
+        api_only()
+    else:
+        webui()

webui.sh

@@ -0,0 +1,254 @@
+#!/usr/bin/env bash
+#################################################
+# Please do not make any changes to this file,  #
+# change the variables in webui-user.sh instead #
+#################################################
+
+
+use_venv=1
+if [[ $venv_dir == "-" ]]; then
+  use_venv=0
+fi
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+
+# If run from macOS, load defaults from webui-macos-env.sh
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    if [[ -f "$SCRIPT_DIR"/webui-macos-env.sh ]]
+        then
+        source "$SCRIPT_DIR"/webui-macos-env.sh
+    fi
+fi
+
+# Read variables from webui-user.sh
+# shellcheck source=/dev/null
+if [[ -f "$SCRIPT_DIR"/webui-user.sh ]]
+then
+    source "$SCRIPT_DIR"/webui-user.sh
+fi
+
+# Set defaults
+# Install directory without trailing slash
+if [[ -z "${install_dir}" ]]
+then
+    install_dir="$SCRIPT_DIR"
+fi
+
+# Name of the subdirectory (defaults to stable-diffusion-webui)
+if [[ -z "${clone_dir}" ]]
+then
+    clone_dir="stable-diffusion-webui-ux"
+fi
+
+# python3 executable
+if [[ -z "${python_cmd}" ]]
+then
+    python_cmd="python3"
+fi
+
+# git executable
+if [[ -z "${GIT}" ]]
+then
+    export GIT="git"
+fi
+
+# python3 venv without trailing slash (defaults to ${install_dir}/${clone_dir}/venv)
+if [[ -z "${venv_dir}" ]] && [[ $use_venv -eq 1 ]]
+then
+    venv_dir="venv"
+fi
+
+if [[ -z "${LAUNCH_SCRIPT}" ]]
+then
+    LAUNCH_SCRIPT="launch.py"
+fi
+
+# this script cannot be run as root by default
+can_run_as_root=0
+
+# read any command line flags to the webui.sh script
+while getopts "f" flag > /dev/null 2>&1
+do
+    case ${flag} in
+        f) can_run_as_root=1;;
+        *) break;;
+    esac
+done
+
+# Disable sentry logging
+export ERROR_REPORTING=FALSE
+
+# Do not reinstall existing pip packages on Debian/Ubuntu
+export PIP_IGNORE_INSTALLED=0
+
+# Pretty print
+delimiter="################################################################"
+
+printf "\n%s\n" "${delimiter}"
+printf "\e[1m\e[32mInstall script for stable-diffusion + Web UI\n"
+printf "\e[1m\e[34mTested on Debian 11 (Bullseye)\e[0m"
+printf "\n%s\n" "${delimiter}"
+
+# Do not run as root
+if [[ $(id -u) -eq 0 && can_run_as_root -eq 0 ]]
+then
+    printf "\n%s\n" "${delimiter}"
+    printf "\e[1m\e[31mERROR: This script must not be launched as root, aborting...\e[0m"
+    printf "\n%s\n" "${delimiter}"
+    exit 1
+else
+    printf "\n%s\n" "${delimiter}"
+    printf "Running on \e[1m\e[32m%s\e[0m user" "$(whoami)"
+    printf "\n%s\n" "${delimiter}"
+fi
+
+if [[ $(getconf LONG_BIT) = 32 ]]
+then
+    printf "\n%s\n" "${delimiter}"
+    printf "\e[1m\e[31mERROR: Unsupported Running on a 32bit OS\e[0m"
+    printf "\n%s\n" "${delimiter}"
+    exit 1
+fi
+
+if [[ -d .git ]]
+then
+    printf "\n%s\n" "${delimiter}"
+    printf "Repo already cloned, using it as install directory"
+    printf "\n%s\n" "${delimiter}"
+    install_dir="${PWD}/../"
+    clone_dir="${PWD##*/}"
+fi
+
+# Check prerequisites
+gpu_info=$(lspci 2>/dev/null | grep -E "VGA|Display")
+case "$gpu_info" in
+    *"Navi 1"*)
+        export HSA_OVERRIDE_GFX_VERSION=10.3.0
+        if [[ -z "${TORCH_COMMAND}" ]]
+        then
+            pyv="$(${python_cmd} -c 'import sys; print(".".join(map(str, sys.version_info[0:2])))')"
+            if [[ $(bc <<< "$pyv <= 3.10") -eq 1 ]] 
+            then
+                # Navi users will still use torch 1.13 because 2.0 does not seem to work.
+                export TORCH_COMMAND="pip install torch==1.13.1+rocm5.2 torchvision==0.14.1+rocm5.2 --index-url https://download.pytorch.org/whl/rocm5.2"
+            else
+                printf "\e[1m\e[31mERROR: RX 5000 series GPUs must be using at max python 3.10, aborting...\e[0m"
+                exit 1
+            fi
+        fi
+    ;;
+    *"Navi 2"*) export HSA_OVERRIDE_GFX_VERSION=10.3.0
+    ;;
+    *"Navi 3"*) [[ -z "${TORCH_COMMAND}" ]] && \
+        export TORCH_COMMAND="pip install --pre torch==2.1.0.dev-20230614+rocm5.5 torchvision==0.16.0.dev-20230614+rocm5.5 --index-url https://download.pytorch.org/whl/nightly/rocm5.5"
+        # Navi 3 needs at least 5.5 which is only on the nightly chain
+    ;;
+    *"Renoir"*) export HSA_OVERRIDE_GFX_VERSION=9.0.0
+        printf "\n%s\n" "${delimiter}"
+        printf "Experimental support for Renoir: make sure to have at least 4GB of VRAM and 10GB of RAM or enable cpu mode: --use-cpu all --no-half"
+        printf "\n%s\n" "${delimiter}"
+    ;;
+    *)
+    ;;
+esac
+if ! echo "$gpu_info" | grep -q "NVIDIA";
+then
+    if echo "$gpu_info" | grep -q "AMD" && [[ -z "${TORCH_COMMAND}" ]]
+    then
+        export TORCH_COMMAND="pip install torch==2.0.1+rocm5.4.2 torchvision==0.15.2+rocm5.4.2 --index-url https://download.pytorch.org/whl/rocm5.4.2"
+    fi
+fi
+
+for preq in "${GIT}" "${python_cmd}"
+do
+    if ! hash "${preq}" &>/dev/null
+    then
+        printf "\n%s\n" "${delimiter}"
+        printf "\e[1m\e[31mERROR: %s is not installed, aborting...\e[0m" "${preq}"
+        printf "\n%s\n" "${delimiter}"
+        exit 1
+    fi
+done
+
+if [[ $use_venv -eq 1 ]] && ! "${python_cmd}" -c "import venv" &>/dev/null
+then
+    printf "\n%s\n" "${delimiter}"
+    printf "\e[1m\e[31mERROR: python3-venv is not installed, aborting...\e[0m"
+    printf "\n%s\n" "${delimiter}"
+    exit 1
+fi
+
+cd "${install_dir}"/ || { printf "\e[1m\e[31mERROR: Can't cd to %s/, aborting...\e[0m" "${install_dir}"; exit 1; }
+if [[ -d "${clone_dir}" ]]
+then
+    cd "${clone_dir}"/ || { printf "\e[1m\e[31mERROR: Can't cd to %s/%s/, aborting...\e[0m" "${install_dir}" "${clone_dir}"; exit 1; }
+else
+    printf "\n%s\n" "${delimiter}"
+    printf "Clone stable-diffusion-webui"
+    printf "\n%s\n" "${delimiter}"
+    "${GIT}" clone https://github.com/anapnoe/stable-diffusion-webui-ux.git "${clone_dir}"
+    cd "${clone_dir}"/ || { printf "\e[1m\e[31mERROR: Can't cd to %s/%s/, aborting...\e[0m" "${install_dir}" "${clone_dir}"; exit 1; }
+fi
+
+if [[ $use_venv -eq 1 ]] && [[ -z "${VIRTUAL_ENV}" ]];
+then
+    printf "\n%s\n" "${delimiter}"
+    printf "Create and activate python venv"
+    printf "\n%s\n" "${delimiter}"
+    cd "${install_dir}"/"${clone_dir}"/ || { printf "\e[1m\e[31mERROR: Can't cd to %s/%s/, aborting...\e[0m" "${install_dir}" "${clone_dir}"; exit 1; }
+    if [[ ! -d "${venv_dir}" ]]
+    then
+        "${python_cmd}" -m venv "${venv_dir}"
+        first_launch=1
+    fi
+    # shellcheck source=/dev/null
+    if [[ -f "${venv_dir}"/bin/activate ]]
+    then
+        source "${venv_dir}"/bin/activate
+    else
+        printf "\n%s\n" "${delimiter}"
+        printf "\e[1m\e[31mERROR: Cannot activate python venv, aborting...\e[0m"
+        printf "\n%s\n" "${delimiter}"
+        exit 1
+    fi
+else
+    printf "\n%s\n" "${delimiter}"
+    printf "python venv already activate or run without venv: ${VIRTUAL_ENV}"
+    printf "\n%s\n" "${delimiter}"
+fi
+
+# Try using TCMalloc on Linux
+prepare_tcmalloc() {
+    if [[ "${OSTYPE}" == "linux"* ]] && [[ -z "${NO_TCMALLOC}" ]] && [[ -z "${LD_PRELOAD}" ]]; then
+        TCMALLOC="$(PATH=/usr/sbin:$PATH ldconfig -p | grep -Po "libtcmalloc(_minimal|)\.so\.\d" | head -n 1)"
+        if [[ ! -z "${TCMALLOC}" ]]; then
+            echo "Using TCMalloc: ${TCMALLOC}"
+            export LD_PRELOAD="${TCMALLOC}"
+        else
+            printf "\e[1m\e[31mCannot locate TCMalloc (improves CPU memory usage)\e[0m\n"
+        fi
+    fi
+}
+
+KEEP_GOING=1
+export SD_WEBUI_RESTART=tmp/restart
+while [[ "$KEEP_GOING" -eq "1" ]]; do
+    if [[ ! -z "${ACCELERATE}" ]] && [ ${ACCELERATE}="True" ] && [ -x "$(command -v accelerate)" ]; then
+        printf "\n%s\n" "${delimiter}"
+        printf "Accelerating launch.py..."
+        printf "\n%s\n" "${delimiter}"
+        prepare_tcmalloc
+        accelerate launch --num_cpu_threads_per_process=6 "${LAUNCH_SCRIPT}" "$@"
+    else
+        printf "\n%s\n" "${delimiter}"
+        printf "Launching launch.py..."
+        printf "\n%s\n" "${delimiter}"
+        prepare_tcmalloc
+        "${python_cmd}" "${LAUNCH_SCRIPT}" "$@"
+    fi
+
+    if [[ ! -f tmp/restart ]]; then
+        KEEP_GOING=0
+    fi
+done