Merge branch 'master' into tensorboard

9 files changed, 281 insertions, 165 deletions

diff --git a/scripts/custom_code.py b/scripts/custom_code.py
index a9b10c09..d29113e6 100644
--- a/scripts/custom_code.py
+++ b/scripts/custom_code.py
@@ -9,12 +9,11 @@ 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):

-        code = gr.Textbox(label="Python code", visible=False, lines=1)

+        code = gr.Textbox(label="Python code", lines=1, elem_id=self.elem_id("code"))

 

         return [code]

 

diff --git a/scripts/img2imgalt.py b/scripts/img2imgalt.py
index d438175c..cbdfc6b3 100644
--- a/scripts/img2imgalt.py
+++ b/scripts/img2imgalt.py
@@ -34,6 +34,9 @@ def find_noise_for_image(p, cond, uncond, cfg_scale, steps):
         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)]

         t = dnw.sigma_to_t(sigma_in)

 

@@ -78,6 +81,9 @@ def find_noise_for_image_sigma_adjustment(p, cond, uncond, cfg_scale, steps):
         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)]

 

         if i == 1:

@@ -119,25 +125,25 @@ class Script(scripts.Script):
     def show(self, is_img2img):

         return is_img2img

 

-    def ui(self, 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)

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

-        original_prompt = gr.Textbox(label="Original prompt", lines=1)

-        original_negative_prompt = gr.Textbox(label="Original negative prompt", lines=1)

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

-        st = gr.Slider(label="Decode steps", minimum=1, maximum=150, step=1, value=50)

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

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

-        randomness = gr.Slider(label="Randomness", minimum=0.0, maximum=1.0, step=0.01, value=0.0)

-        sigma_adjustment = gr.Checkbox(label="Sigma adjustment for finding noise for image", value=False)

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

@@ -151,7 +157,7 @@ class Script(scripts.Script):
     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_index = [sampler.name for sampler in sd_samplers.samplers].index("Euler")

+            p.sampler_name = "Euler"

         if override_prompt:

             p.prompt = original_prompt

             p.negative_prompt = original_negative_prompt

@@ -160,8 +166,7 @@ class Script(scripts.Script):
         if override_strength:

             p.denoising_strength = 1.0

 

-

-        def sample_extra(conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength):

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

@@ -186,7 +191,7 @@ class Script(scripts.Script):
             

             combined_noise = ((1 - randomness) * rec_noise + randomness * rand_noise) / ((randomness**2 + (1-randomness)**2) ** 0.5)

             

-            sampler = sd_samplers.create_sampler_with_index(sd_samplers.samplers, p.sampler_index, p.sd_model)

+            sampler = sd_samplers.create_sampler(p.sampler_name, p.sd_model)

 

             sigmas = sampler.model_wrap.get_sigmas(p.steps)

             

@@ -194,7 +199,7 @@ class Script(scripts.Script):
             

             p.seed = p.seed + 1

             

-            return sampler.sample_img2img(p, p.init_latent, noise_dt, conditioning, unconditional_conditioning)

+            return sampler.sample_img2img(p, p.init_latent, noise_dt, conditioning, unconditional_conditioning, image_conditioning=p.image_conditioning)

 

         p.sample = sample_extra

 

diff --git a/scripts/loopback.py b/scripts/loopback.py
index d8c68af8..1dab9476 100644
--- a/scripts/loopback.py
+++ b/scripts/loopback.py
@@ -9,6 +9,7 @@ from modules.processing import Processed
 from modules.sd_samplers import samplers

 from modules.shared import opts, cmd_opts, state

 

+

 class Script(scripts.Script):

     def title(self):

         return "Loopback"

@@ -16,9 +17,9 @@ class Script(scripts.Script):
     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)

-        denoising_strength_change_factor = gr.Slider(minimum=0.9, maximum=1.1, step=0.01, label='Denoising strength change factor', value=1)

+    def ui(self, is_img2img):        

+        loops = gr.Slider(minimum=1, maximum=32, step=1, label='Loops', value=4, elem_id=self.elem_id("loops"))

+        denoising_strength_change_factor = gr.Slider(minimum=0.9, maximum=1.1, step=0.01, label='Denoising strength change factor', value=1, elem_id=self.elem_id("denoising_strength_change_factor"))

 

         return [loops, denoising_strength_change_factor]

 

diff --git a/scripts/outpainting_mk_2.py b/scripts/outpainting_mk_2.py
index a6468e09..0906da6a 100644
--- a/scripts/outpainting_mk_2.py
+++ b/scripts/outpainting_mk_2.py
@@ -131,11 +131,11 @@ class Script(scripts.Script):
 

         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)

-        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=8, visible=False)

-        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'])

-        noise_q = gr.Slider(label="Fall-off exponent (lower=higher detail)", minimum=0.0, maximum=4.0, step=0.01, value=1.0)

-        color_variation = gr.Slider(label="Color variation", minimum=0.0, maximum=1.0, step=0.01, value=0.05)

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

 

@@ -172,54 +172,54 @@ class Script(scripts.Script):
         if down > 0:

             down = target_h - init_img.height - up

 

-        init_image = p.init_images[0]

-

-        state.job_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)

-

-        def expand(init, expand_pixels, is_left=False, is_right=False, is_top=False, is_bottom=False):

+        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

 

-            res_w = init.width + pixels_horiz

-            res_h = init.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, (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 if is_left else 0,

-                expand_pixels + mask_blur if is_top else 0,

-                mask.width - expand_pixels - mask_blur if is_right else res_w,

-                mask.height - expand_pixels - mask_blur 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)

-            out = Image.fromarray(np.clip(noised * 255., 0., 255.).astype(np.uint8), mode="RGB")

-

-            target_width = min(process_width, init.width + pixels_horiz) if is_horiz else img.width

-            target_height = min(process_height, init.height + pixels_vert) if is_vert else img.height

-

-            crop_region = (

-                0 if is_left else out.width - target_width,

-                0 if is_top else out.height - target_height,

-                target_width if is_left else out.width,

-                target_height if is_top else out.height,

-            )

-

-            image_to_process = out.crop(crop_region)

-            mask = mask.crop(crop_region)

-

-            p.width = target_width if is_horiz else img.width

-            p.height = target_height if is_vert else img.height

-            p.init_images = [image_to_process]

-            p.image_mask = mask

+            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 if is_left else 0,

+                    expand_pixels + mask_blur if is_top else 0,

+                    mask.width - expand_pixels - mask_blur if is_right else res_w,

+                    mask.height - expand_pixels - mask_blur 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)

@@ -232,31 +232,52 @@ class Script(scripts.Script):
             p.latent_mask = latent_mask

 

             proc = process_images(p)

-            proc_img = proc.images[0]

 

             if initial_seed_and_info[0] is None:

                 initial_seed_and_info[0] = proc.seed

                 initial_seed_and_info[1] = proc.info

 

-            out.paste(proc_img, (0 if is_left else out.width - proc_img.width, 0 if is_top else out.height - proc_img.height))

-            out = out.crop((0, 0, res_w, res_h))

-            return out

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

 

-        img = init_image

+            return output_images

 

-        if left > 0:

-            img = expand(img, left, is_left=True)

-        if right > 0:

-            img = expand(img, right, is_right=True)

-        if up > 0:

-            img = expand(img, up, is_top=True)

-        if down > 0:

-            img = expand(img, down, is_bottom=True)

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

 

-        res = Processed(p, [img], initial_seed_and_info[0], initial_seed_and_info[1])

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

-            images.save_image(img, p.outpath_samples, "", res.seed, p.prompt, opts.grid_format, info=res.info, p=p)

+            for img in all_processed_images:

+                images.save_image(img, p.outpath_samples, "", res.seed, p.prompt, opts.grid_format, info=res.info, p=p)

 

-        return res

+        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

diff --git a/scripts/poor_mans_outpainting.py b/scripts/poor_mans_outpainting.py
index b0469110..d8feda00 100644
--- a/scripts/poor_mans_outpainting.py
+++ b/scripts/poor_mans_outpainting.py
@@ -9,7 +9,6 @@ from modules.processing import Processed, process_images
 from modules.shared import opts, cmd_opts, state

 

 

-

 class Script(scripts.Script):

     def title(self):

         return "Poor man's outpainting"

@@ -20,11 +19,11 @@ class Script(scripts.Script):
     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)

-        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, visible=False)

-        inpainting_fill = gr.Radio(label='Masked content', choices=['fill', 'original', 'latent noise', 'latent nothing'], value='fill', type="index", visible=False)

-        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'])

+        

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

 

diff --git a/scripts/prompt_matrix.py b/scripts/prompt_matrix.py
index e49c9b20..dd95e588 100644
--- a/scripts/prompt_matrix.py
+++ b/scripts/prompt_matrix.py
@@ -18,7 +18,7 @@ def draw_xy_grid(xs, ys, x_label, y_label, cell):
     ver_texts = [[images.GridAnnotation(y_label(y))] for y in ys]

     hor_texts = [[images.GridAnnotation(x_label(x))] for x in xs]

 

-    first_pocessed = None

+    first_processed = None

 

     state.job_count = len(xs) * len(ys)

 

@@ -27,29 +27,30 @@ def draw_xy_grid(xs, ys, x_label, y_label, cell):
             state.job = f"{ix + iy * len(xs) + 1} out of {len(xs) * len(ys)}"

 

             processed = cell(x, y)

-            if first_pocessed is None:

-                first_pocessed = processed

+            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_pocessed.images = [grid]

+    first_processed.images = [grid]

 

-    return first_pocessed

+    return first_processed

 

 

 class Script(scripts.Script):

     def title(self):

         return "Prompt matrix"

 

-    def ui(self, is_img2img):

-        put_at_start = gr.Checkbox(label='Put variable parts at start of prompt', value=False)

+    def ui(self, is_img2img):        

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

 

-        return [put_at_start]

+        return [put_at_start, different_seeds]

 

-    def run(self, p, put_at_start):

+    def run(self, p, put_at_start, different_seeds):

         modules.processing.fix_seed(p)

 

         original_prompt = p.prompt[0] if type(p.prompt) == list else p.prompt

@@ -73,15 +74,17 @@ class Script(scripts.Script):
         print(f"Prompt matrix will create {len(all_prompts)} images using a total of {p.n_iter} batches.")

 

         p.prompt = all_prompts

-        p.seed = [p.seed for _ in all_prompts]

+        p.seed = [p.seed + (i if different_seeds else 0) for i in range(len(all_prompts))]

         p.prompt_for_display = original_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, p.width, p.height, prompt_matrix_parts)

         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", prompt=original_prompt, seed=processed.seed, grid=True, p=p)

+            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

diff --git a/scripts/prompts_from_file.py b/scripts/prompts_from_file.py
index 1266be6f..2751f98a 100644
--- a/scripts/prompts_from_file.py
+++ b/scripts/prompts_from_file.py
@@ -1,6 +1,7 @@
 import copy

 import math

 import os

+import random

 import sys

 import traceback

 import shlex

@@ -8,6 +9,7 @@ import shlex
 import modules.scripts as scripts

 import gradio as gr

 

+from modules import sd_samplers

 from modules.processing import Processed, process_images

 from PIL import Image

 from modules.shared import opts, cmd_opts, state

@@ -43,6 +45,7 @@ prompt_tags = {
     "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,

@@ -65,14 +68,28 @@ def cmdargs(line):
         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}'

 

-        assert pos+1 < len(args), f'missing argument for command line option {arg}'

-

         val = args[pos+1]

+        if tag == "sampler_name":

+            val = sd_samplers.samplers_map.get(val.lower(), None)

 

         res[tag] = func(val)

 

@@ -81,32 +98,36 @@ def cmdargs(line):
     return res

 

 

+def load_prompt_file(file):

+    if file is None:

+        lines = []

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

-        # This checkbox would look nicer as two tabs, but there are two problems:

-        # 1) There is a bug in Gradio 3.3 that prevents visibility from working on Tabs

-        # 2) Even with Gradio 3.3.1, returning a control (like Tabs) that can't be used as input

-        #    causes a AttributeError: 'Tabs' object has no attribute 'preprocess' assert,

-        #    due to the way Script assumes all controls returned can be used as inputs.

-        # Therefore, there's no good way to use grouping components right now,

-        # so we will use a checkbox! :)

-        checkbox_txt = gr.Checkbox(label="Show Textbox", value=False)

-        file = gr.File(label="File with inputs", type='bytes')

-        prompt_txt = gr.TextArea(label="Prompts")

-        checkbox_txt.change(fn=lambda x: [gr.File.update(visible = not x), gr.TextArea.update(visible = x)], inputs=[checkbox_txt], outputs=[file, prompt_txt])

-        return [checkbox_txt, file, prompt_txt]

-

-    def on_show(self, checkbox_txt, file, prompt_txt):

-        return [ gr.Checkbox.update(visible = True), gr.File.update(visible = not checkbox_txt), gr.TextArea.update(visible = checkbox_txt) ]

-

-    def run(self, p, checkbox_txt, data: bytes, prompt_txt: str):

-        if checkbox_txt:

-            lines = [x.strip() for x in prompt_txt.splitlines()]

-        else:

-            lines = [x.strip() for x in data.decode('utf8', errors='ignore').split("\n")]

+    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='bytes', elem_id=self.elem_id("file"))

+

+        file.change(fn=load_prompt_file, inputs=[file], outputs=[file, prompt_txt, prompt_txt])

+

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

+        return [checkbox_iterate, checkbox_iterate_batch, prompt_txt]

+

+    def run(self, p, checkbox_iterate, checkbox_iterate_batch, prompt_txt: str):

+        lines = [x.strip() for x in prompt_txt.splitlines()]

         lines = [x for x in lines if len(x) > 0]

 

         p.do_not_save_grid = True

@@ -119,7 +140,7 @@ class Script(scripts.Script):
                 try:

                     args = cmdargs(line)

                 except Exception:

-                    print(f"Error parsing line [line] as commandline:", file=sys.stderr)

+                    print(f"Error parsing line {line} as commandline:", file=sys.stderr)

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

                     args = {"prompt": line}

             else:

@@ -134,9 +155,14 @@ class Script(scripts.Script):
             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 n, args in enumerate(jobs):

             state.job = f"{state.job_no + 1} out of {state.job_count}"

 

@@ -146,5 +172,10 @@ class Script(scripts.Script):
 

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

+        return Processed(p, images, p.seed, "", all_prompts=all_prompts, infotexts=infotexts)

diff --git a/scripts/sd_upscale.py b/scripts/sd_upscale.py
index cb37ff7e..332d76d9 100644
--- a/scripts/sd_upscale.py
+++ b/scripts/sd_upscale.py
@@ -16,14 +16,17 @@ class Script(scripts.Script):
     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 to twice the dimensions; use width and height sliders to set tile size</p>")

-        overlap = gr.Slider(minimum=0, maximum=256, step=16, label='Tile overlap', value=64, visible=False)

-        upscaler_index = gr.Radio(label='Upscaler', choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name, type="index", visible=False)

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

+        return [info, overlap, upscaler_index, scale_factor]

 

-    def run(self, p, _, overlap, upscaler_index):

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

 

@@ -34,9 +37,10 @@ class Script(scripts.Script):
         seed = p.seed

 

         init_img = p.init_images[0]

-        

-        if(upscaler.name != "None"): 

-            img = upscaler.scaler.upscale(init_img, 2, upscaler.data_path)

+        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

 

@@ -69,7 +73,7 @@ class Script(scripts.Script):
             work_results = []

             for i in range(batch_count):

                 p.batch_size = batch_size

-                p.init_images = work[i*batch_size:(i+1)*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)

diff --git a/scripts/xy_grid.py b/scripts/xy_grid.py
index 5cca168a..f04d9b7e 100644
--- a/scripts/xy_grid.py
+++ b/scripts/xy_grid.py
@@ -10,13 +10,16 @@ import numpy as np
 import modules.scripts as scripts

 import gradio as gr

 

-from modules import images

+from modules import images, paths, sd_samplers, processing

 from modules.hypernetworks import hypernetwork

-from modules.processing import process_images, Processed, get_correct_sampler, StableDiffusionProcessingTxt2Img

+from modules.processing import process_images, Processed, StableDiffusionProcessingTxt2Img

 from modules.shared import opts, cmd_opts, state

 import modules.shared as shared

 import modules.sd_samplers

 import modules.sd_models

+import modules.sd_vae

+import glob

+import os

 import re

 

 

@@ -58,29 +61,19 @@ def apply_order(p, x, xs):
         prompt_tmp += part

         prompt_tmp += x[idx]

     p.prompt = prompt_tmp + p.prompt

-    

-

-def build_samplers_dict(p):

-    samplers_dict = {}

-    for i, sampler in enumerate(get_correct_sampler(p)):

-        samplers_dict[sampler.name.lower()] = i

-        for alias in sampler.aliases:

-            samplers_dict[alias.lower()] = i

-    return samplers_dict

 

 

 def apply_sampler(p, x, xs):

-    sampler_index = build_samplers_dict(p).get(x.lower(), None)

-    if sampler_index is None:

+    sampler_name = sd_samplers.samplers_map.get(x.lower(), None)

+    if sampler_name is None:

         raise RuntimeError(f"Unknown sampler: {x}")

 

-    p.sampler_index = sampler_index

+    p.sampler_name = sampler_name

 

 

 def confirm_samplers(p, xs):

-    samplers_dict = build_samplers_dict(p)

     for x in xs:

-        if x.lower() not in samplers_dict.keys():

+        if x.lower() not in sd_samplers.samplers_map:

             raise RuntimeError(f"Unknown sampler: {x}")

 

 

@@ -89,6 +82,7 @@ def apply_checkpoint(p, x, xs):
     if info is None:

         raise RuntimeError(f"Unknown checkpoint: {x}")

     modules.sd_models.reload_model_weights(shared.sd_model, info)

+    p.sd_model = shared.sd_model

 

 

 def confirm_checkpoints(p, xs):

@@ -123,6 +117,38 @@ 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', 'none']:

+        return name

+    else:

+        vae_path = os.path.abspath(os.path.join(paths.models_path, 'VAE'))

+        found = glob.glob(os.path.join(vae_path, f'**/{name}.*pt'), recursive=True)

+        if found:

+            return found[0]

+        else:

+            return 'auto'

+

+

+def apply_vae(p, x, xs):

+    if x.lower().strip() == 'none':

+        modules.sd_vae.reload_vae_weights(shared.sd_model, vae_file='None')

+    else:

+        found = find_vae(x)

+        if found:

+            v = modules.sd_vae.reload_vae_weights(shared.sd_model, vae_file=found)

+

+

+def apply_styles(p: StableDiffusionProcessingTxt2Img, x: str, _):

+    p.styles = x.split(',')

+

+

 def format_value_add_label(p, opt, x):

     if type(x) == float:

         x = round(x, 8)

@@ -152,7 +178,6 @@ def str_permutations(x):
     """dummy function for specifying it in AxisOption's type when you want to get a list of permutations"""

     return x

 

-

 AxisOption = namedtuple("AxisOption", ["label", "type", "apply", "format_value", "confirm"])

 AxisOptionImg2Img = namedtuple("AxisOptionImg2Img", ["label", "type", "apply", "format_value", "confirm"])

 

@@ -177,6 +202,10 @@ axis_options = [
     AxisOption("Eta", float, apply_field("eta"), format_value_add_label, None),

     AxisOption("Clip skip", int, apply_clip_skip, format_value_add_label, None),

     AxisOption("Denoising", float, apply_field("denoising_strength"), format_value_add_label, None),

+    AxisOption("Hires upscaler", str, apply_field("hr_upscaler"), format_value_add_label, None),

+    AxisOption("Cond. Image Mask Weight", float, apply_field("inpainting_mask_weight"), format_value_add_label, None),

+    AxisOption("VAE", str, apply_vae, format_value_add_label, None),

+    AxisOption("Styles", str, apply_styles, format_value_add_label, None),

 ]

 

 

@@ -238,9 +267,11 @@ class SharedSettingsStackHelper(object):
         self.CLIP_stop_at_last_layers = opts.CLIP_stop_at_last_layers

         self.hypernetwork = opts.sd_hypernetwork

         self.model = shared.sd_model

+        self.vae = opts.sd_vae

   

     def __exit__(self, exc_type, exc_value, tb):

         modules.sd_models.reload_model_weights(self.model)

+        modules.sd_vae.reload_vae_weights(self.model, vae_file=find_vae(self.vae))

 

         hypernetwork.load_hypernetwork(self.hypernetwork)

         hypernetwork.apply_strength()

@@ -254,6 +285,7 @@ re_range_float = re.compile(r"\s*([+-]?\s*\d+(?:.\d*)?)\s*-\s*([+-]?\s*\d+(?:.\d
 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 plot"

@@ -262,16 +294,16 @@ class Script(scripts.Script):
         current_axis_options = [x for x in axis_options if type(x) == AxisOption or type(x) == AxisOptionImg2Img and is_img2img]

 

         with gr.Row():

-            x_type = gr.Dropdown(label="X type", choices=[x.label for x in current_axis_options], value=current_axis_options[1].label, visible=False, type="index", elem_id="x_type")

-            x_values = gr.Textbox(label="X values", visible=False, lines=1)

+            x_type = gr.Dropdown(label="X type", choices=[x.label for x in current_axis_options], value=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"))

 

         with gr.Row():

-            y_type = gr.Dropdown(label="Y type", choices=[x.label for x in current_axis_options], value=current_axis_options[0].label, visible=False, type="index", elem_id="y_type")

-            y_values = gr.Textbox(label="Y values", visible=False, lines=1)

+            y_type = gr.Dropdown(label="Y type", choices=[x.label for x in current_axis_options], value=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"))

         

-        draw_legend = gr.Checkbox(label='Draw legend', value=True)

-        include_lone_images = gr.Checkbox(label='Include Separate Images', value=False)

-        no_fixed_seeds = gr.Checkbox(label='Keep -1 for seeds', value=False)

+        draw_legend = gr.Checkbox(label='Draw legend', value=True, elem_id=self.elem_id("draw_legend"))

+        include_lone_images = gr.Checkbox(label='Include Separate Images', value=False, elem_id=self.elem_id("include_lone_images"))

+        no_fixed_seeds = gr.Checkbox(label='Keep -1 for seeds', value=False, elem_id=self.elem_id("no_fixed_seeds"))

 

         return [x_type, x_values, y_type, y_values, draw_legend, include_lone_images, no_fixed_seeds]

 

@@ -350,7 +382,7 @@ class Script(scripts.Script):
         ys = process_axis(y_opt, y_values)

 

         def fix_axis_seeds(axis_opt, axis_list):

-            if axis_opt.label in ['Seed','Var. seed']:

+            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

@@ -372,12 +404,33 @@ class Script(scripts.Script):
         print(f"X/Y plot will create {len(xs) * len(ys) * p.n_iter} images on a {len(xs)}x{len(ys)} grid. (Total steps to process: {total_steps * p.n_iter})")

         shared.total_tqdm.updateTotal(total_steps * p.n_iter)

 

+        grid_infotext = [None]

+

         def cell(x, y):

             pc = copy(p)

             x_opt.apply(pc, x, xs)

             y_opt.apply(pc, y, ys)

 

-            return process_images(pc)

+            res = process_images(pc)

+

+            if grid_infotext[0] is None:

+                pc.extra_generation_params = copy(pc.extra_generation_params)

+

+                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[0] = processing.create_infotext(pc, pc.all_prompts, pc.all_seeds, pc.all_subseeds)

+

+            return res

 

         with SharedSettingsStackHelper():

             processed = draw_xy_grid(

@@ -392,6 +445,6 @@ class Script(scripts.Script):
             )

 

         if opts.grid_save:

-            images.save_image(processed.images[0], p.outpath_grids, "xy_grid", prompt=p.prompt, seed=processed.seed, grid=True, p=p)

+            images.save_image(processed.images[0], p.outpath_grids, "xy_grid", info=grid_infotext[0], extension=opts.grid_format, prompt=p.prompt, seed=processed.seed, grid=True, p=p)

 

         return processed