diff --git a/cli/modules/bench.py b/cli/modules/bench.py
index 801c9ccfd..094b73f63 100755
--- a/cli/modules/bench.py
+++ b/cli/modules/bench.py
@@ -8,7 +8,7 @@ import io
 import json
 import time
 from PIL import Image
-import sdapi as sdapi
+import sdapi
 from util import Map, log
 
 
diff --git a/extensions-builtin/sd-extension-system-info b/extensions-builtin/sd-extension-system-info
index cc86ce888..70ab5cf31 160000
--- a/extensions-builtin/sd-extension-system-info
+++ b/extensions-builtin/sd-extension-system-info
@@ -1 +1 @@
-Subproject commit cc86ce8887f041e88e67d336044190fd0296fd74
+Subproject commit 70ab5cf312be0fa913c5ba6ab85fbb64430507e2
diff --git a/modules/cmd_args.py b/modules/cmd_args.py
index a8f20ca58..3bca9b357 100644
--- a/modules/cmd_args.py
+++ b/modules/cmd_args.py
@@ -79,6 +79,18 @@ def compatibility_args(opts, args):
     opts.use_old_karras_scheduler_sigmas = False
     opts.no_dpmpp_sde_batch_determinism = False
     opts.lora_apply_to_outputs = False
+    opts.do_not_show_images = False
+    opts.add_model_hash_to_info = True
+    opts.add_model_name_to_info = True
+    opts.js_modal_lightbox = True
+    opts.js_modal_lightbox_initially_zoomed = True
+    opts.show_progress_in_title = False
+    opts.sd_vae_as_default = True
+    opts.enable_emphasis = True
+    opts.enable_batch_seeds = True
+    opts.multiple_tqdm = False
+    opts.print_hypernet_extra = False
+    opts.dimensions_and_batch_together = True
 
     parser.add_argument("--lora-dir", help=argparse.SUPPRESS, default=opts.lora_dir)
     args = parser.parse_args()
diff --git a/modules/img2img.py b/modules/img2img.py
index 302ae61ec..de889d4b7 100644
--- a/modules/img2img.py
+++ b/modules/img2img.py
@@ -1,47 +1,35 @@
 import os
-
 import numpy as np
 from PIL import Image, ImageOps, ImageFilter, ImageEnhance, ImageChops, UnidentifiedImageError
-
+import modules.scripts
 from modules import sd_samplers
 from modules.generation_parameters_copypaste import create_override_settings_dict
-from modules.processing import Processed, StableDiffusionProcessingImg2Img, process_images
-from modules.shared import opts, state
-import modules.shared as shared
-import modules.processing as processing
+from modules.processing import Processed, StableDiffusionProcessingImg2Img, process_images, memory_stats
+from modules.shared import opts, cmd_opts, log, state, listfiles, sd_model
 from modules.ui import plaintext_to_html
-import modules.scripts
+import modules.processing as processing
 
 
 def process_batch(p, input_dir, output_dir, inpaint_mask_dir, args):
     processing.fix_seed(p)
-
-    images = shared.listfiles(input_dir)
-
+    images = listfiles(input_dir)
     is_inpaint_batch = False
     if inpaint_mask_dir:
-        inpaint_masks = shared.listfiles(inpaint_mask_dir)
+        inpaint_masks = listfiles(inpaint_mask_dir)
         is_inpaint_batch = len(inpaint_masks) > 0
     if is_inpaint_batch:
         print(f"\nInpaint batch is enabled. {len(inpaint_masks)} masks found.")
-
     print(f"Will process {len(images)} images, creating {p.n_iter * p.batch_size} new images for each.")
-
     save_normally = output_dir == ''
-
     p.do_not_save_grid = True
     p.do_not_save_samples = not save_normally
-
     state.job_count = len(images) * p.n_iter
-
     for i, image in enumerate(images):
         state.job = f"{i+1} out of {len(images)}"
         if state.skipped:
             state.skipped = False
-
         if state.interrupted:
             break
-
         try:
             img = Image.open(image)
         except UnidentifiedImageError:
@@ -62,26 +50,24 @@ def process_batch(p, input_dir, output_dir, inpaint_mask_dir, args):
         proc = modules.scripts.scripts_img2img.run(p, *args)
         if proc is None:
             proc = process_images(p)
-
         for n, processed_image in enumerate(proc.images):
             filename = os.path.basename(image)
-
             if n > 0:
                 left, right = os.path.splitext(filename)
                 filename = f"{left}-{n}{right}"
-
             if not save_normally:
                 os.makedirs(output_dir, exist_ok=True)
                 if processed_image.mode == 'RGBA':
                     processed_image = processed_image.convert("RGB")
                 processed_image.save(os.path.join(output_dir, filename))
+    if cmd_opts.debug:
+        log.info(f'Processed: {len(images)} Memory: {memory_stats()} batch')
 
 
 def img2img(id_task: str, mode: int, prompt: str, negative_prompt: str, prompt_styles, init_img, sketch, init_img_with_mask, inpaint_color_sketch, inpaint_color_sketch_orig, init_img_inpaint, init_mask_inpaint, steps: int, sampler_index: int, mask_blur: int, mask_alpha: float, inpainting_fill: int, restore_faces: bool, tiling: bool, n_iter: int, batch_size: int, cfg_scale: float, image_cfg_scale: float, denoising_strength: float, seed: int, subseed: int, subseed_strength: float, seed_resize_from_h: int, seed_resize_from_w: int, seed_enable_extras: bool, height: int, width: int, resize_mode: int, inpaint_full_res: bool, inpaint_full_res_padding: int, inpainting_mask_invert: int, img2img_batch_input_dir: str, img2img_batch_output_dir: str, img2img_batch_inpaint_mask_dir: str, override_settings_texts, *args): # pylint: disable=unused-argument
     override_settings = create_override_settings_dict(override_settings_texts)
 
     is_batch = mode == 5
-
     if mode == 0:  # img2img
         image = init_img.convert("RGB")
         mask = None
@@ -108,15 +94,12 @@ def img2img(id_task: str, mode: int, prompt: str, negative_prompt: str, prompt_s
     else:
         image = None
         mask = None
-
-    # Use the EXIF orientation of photos taken by smartphones.
     if image is not None:
         image = ImageOps.exif_transpose(image)
-
     assert 0. <= denoising_strength <= 1., 'can only work with strength in [0.0, 1.0]'
 
     p = StableDiffusionProcessingImg2Img(
-        sd_model=shared.sd_model,
+        sd_model=sd_model,
         outpath_samples=opts.outdir_samples or opts.outdir_img2img_samples,
         outpath_grids=opts.outdir_grids or opts.outdir_img2img_grids,
         prompt=prompt,
@@ -149,31 +132,20 @@ def img2img(id_task: str, mode: int, prompt: str, negative_prompt: str, prompt_s
         inpainting_mask_invert=inpainting_mask_invert,
         override_settings=override_settings,
     )
-
     p.scripts = modules.scripts.scripts_img2img
     p.script_args = args
-
     if mask:
         p.extra_generation_params["Mask blur"] = mask_blur
-
     if is_batch:
-        assert not shared.cmd_opts.hide_ui_dir_config, "Launched with --hide-ui-dir-config, batch img2img disabled"
-
+        assert not cmd_opts.hide_ui_dir_config, "Launched with --hide-ui-dir-config, batch img2img disabled"
         process_batch(p, img2img_batch_input_dir, img2img_batch_output_dir, img2img_batch_inpaint_mask_dir, args)
-
         processed = Processed(p, [], p.seed, "")
     else:
         processed = modules.scripts.scripts_img2img.run(p, *args)
         if processed is None:
             processed = process_images(p)
-
     p.close()
-
-    shared.total_tqdm.clear()
-
     generation_info_js = processed.js()
-
-    if opts.do_not_show_images:
-        processed.images = []
-
+    if cmd_opts.debug:
+        log.info(f'Processed: {len(processed.images)} Memory: {memory_stats()} img')
     return processed.images, generation_info_js, plaintext_to_html(processed.info), plaintext_to_html(processed.comments)
diff --git a/modules/memmon.py b/modules/memmon.py
index 8c257b92f..9b013e6b4 100644
--- a/modules/memmon.py
+++ b/modules/memmon.py
@@ -1,7 +1,6 @@
 import threading
 import time
 from collections import defaultdict
-
 import torch
 
 
@@ -17,11 +16,9 @@ class MemUsageMonitor(threading.Thread):
         self.name = name
         self.device = device
         self.opts = opts
-
         self.daemon = True
         self.run_flag = threading.Event()
         self.data = defaultdict(int)
-
         if not torch.cuda.is_available():
             self.disabled = True
         else:
@@ -39,37 +36,29 @@ class MemUsageMonitor(threading.Thread):
     def run(self):
         if self.disabled:
             return
-
         while True:
             self.run_flag.wait()
-
             torch.cuda.reset_peak_memory_stats()
             self.data.clear()
-
             if self.opts.memmon_poll_rate <= 0:
                 self.run_flag.clear()
                 continue
-
             self.data["min_free"] = self.cuda_mem_get_info()[0]
-
             while self.run_flag.is_set():
-                free, total = self.cuda_mem_get_info()
+                free, _total = self.cuda_mem_get_info()
                 self.data["min_free"] = min(self.data["min_free"], free)
-
                 time.sleep(1 / self.opts.memmon_poll_rate)
 
     def dump_debug(self):
         print(self, 'recorded data:')
         for k, v in self.read().items():
             print(k, -(v // -(1024 ** 2)))
-
         print(self, 'raw torch memory stats:')
         tm = torch.cuda.memory_stats(self.device)
         for k, v in tm.items():
             if 'bytes' not in k:
                 continue
             print('\t' if 'peak' in k else '', k, -(v // -(1024 ** 2)))
-
         print(torch.cuda.memory_summary())
 
     def monitor(self):
diff --git a/modules/processing.py b/modules/processing.py
index 118996cab..e793f12a3 100644
--- a/modules/processing.py
+++ b/modules/processing.py
@@ -6,6 +6,7 @@ import random
 import logging
 from typing import Any, Dict, List
 
+import psutil
 import torch
 import numpy as np
 from PIL import Image, ImageFilter, ImageOps
@@ -41,6 +42,33 @@ opt_C = 4
 opt_f = 8
 
 
+def memory_stats():
+    def gb(val: float):
+        return round(val / 1024 / 1024 / 1024, 2)
+    mem = {}
+    try:
+        process = psutil.Process(os.getpid())
+        res = process.memory_info()
+        ram_total = 100 * res.rss / process.memory_percent()
+        ram = { 'used': gb(res.rss), 'total': gb(ram_total) }
+        mem.update({ 'ram': ram })
+    except Exception as e:
+        mem.update({ 'ram': e })
+    try:
+        if torch.cuda.is_available():
+            s = torch.cuda.mem_get_info()
+            gpu = { 'used': gb(s[1] - s[0]), 'total': gb(s[1]) }
+            s = dict(torch.cuda.memory_stats(shared.device))
+            mem.update({
+                'gpu': gpu,
+                'retries': s['num_alloc_retries'],
+                'oom': s['num_ooms']
+            })
+    except:
+        pass
+    return mem
+
+
 def setup_color_correction(image):
     logging.info("Calibrating color correction.")
     correction_target = cv2.cvtColor(np.asarray(image.copy()), cv2.COLOR_RGB2LAB)
@@ -317,7 +345,6 @@ class Processed:
         self.seed = int(self.seed if type(self.seed) != list else self.seed[0]) if self.seed is not None else -1
         self.subseed = int(self.subseed if type(self.subseed) != list else self.subseed[0]) if self.subseed is not None else -1
         self.is_using_inpainting_conditioning = p.is_using_inpainting_conditioning
-
         self.all_prompts = all_prompts or p.all_prompts or [self.prompt]
         self.all_negative_prompts = all_negative_prompts or p.all_negative_prompts or [self.negative_prompt]
         self.all_seeds = all_seeds or p.all_seeds or [self.seed]
@@ -892,8 +919,6 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
             if not state.processing_has_refined_job_count:
                 if state.job_count == -1:
                     state.job_count = self.n_iter
-
-                shared.total_tqdm.updateTotal((self.steps + (self.hr_second_pass_steps or self.steps)) * state.job_count)
                 state.job_count = state.job_count * 2
                 state.processing_has_refined_job_count = True
 
diff --git a/modules/scripts.py b/modules/scripts.py
index 48df6c4dd..fa8a3cef8 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -3,7 +3,7 @@ import re
 import sys
 from collections import namedtuple
 import gradio as gr
-from modules import shared, paths, script_callbacks, extensions, script_loading, scripts_postprocessing, errors
+from modules import paths, script_callbacks, extensions, script_loading, scripts_postprocessing, errors
 
 AlwaysVisible = object()
 
@@ -347,7 +347,6 @@ class ScriptRunner:
             return None
         parsed = p.per_script_args.get(script.title(), args[script.args_from:script.args_to])
         processed = script.run(p, *parsed)
-        shared.total_tqdm.clear()
         return processed
 
     def process(self, p, **kwargs):
diff --git a/modules/sd_samplers_compvis.py b/modules/sd_samplers_compvis.py
index bfcc55749..8de719323 100644
--- a/modules/sd_samplers_compvis.py
+++ b/modules/sd_samplers_compvis.py
@@ -109,7 +109,6 @@ class VanillaStableDiffusionSampler:
             else:
                 cond = {"c_concat": [image_conditioning], "c_crossattn": [cond]}
                 unconditional_conditioning = {"c_concat": [image_conditioning], "c_crossattn": [unconditional_conditioning]}
-
         return x, ts, cond, unconditional_conditioning
 
     def update_step(self, last_latent):
@@ -117,17 +116,13 @@ class VanillaStableDiffusionSampler:
             self.last_latent = self.init_latent * self.mask + self.nmask * last_latent
         else:
             self.last_latent = last_latent
-
         sd_samplers_common.store_latent(self.last_latent)
-
         self.step += 1
         state.sampling_step = self.step
-        shared.total_tqdm.update()
 
     def after_sample(self, x, ts, cond, uncond, res):
         if not self.is_unipc:
             self.update_step(res[1])
-
         return x, ts, cond, uncond, res
 
     def unipc_after_update(self, x, model_x):
diff --git a/modules/sd_samplers_kdiffusion.py b/modules/sd_samplers_kdiffusion.py
index 3e4f882c6..a30d351fc 100644
--- a/modules/sd_samplers_kdiffusion.py
+++ b/modules/sd_samplers_kdiffusion.py
@@ -231,7 +231,6 @@ class KDiffusionSampler:
             raise sd_samplers_common.InterruptedException
 
         state.sampling_step = step
-        shared.total_tqdm.update()
 
     def launch_sampling(self, steps, func):
         state.sampling_steps = steps
diff --git a/modules/shared.py b/modules/shared.py
index c18e31021..0dfefa8c4 100644
--- a/modules/shared.py
+++ b/modules/shared.py
@@ -223,15 +223,12 @@ options_templates.update(options_section(('sd', "Stable Diffusion"), {
     "sd_checkpoint_cache": OptionInfo(0, "Model checkpoints to cache in RAM", gr.Slider, {"minimum": 0, "maximum": 10, "step": 1}),
     "sd_vae_checkpoint_cache": OptionInfo(0, "VAE checkpoints to cache in RAM", gr.Slider, {"minimum": 0, "maximum": 10, "step": 1}),
     "sd_vae": OptionInfo("Automatic", "Select VAE", gr.Dropdown, lambda: {"choices": shared_items.sd_vae_items()}, refresh=shared_items.refresh_vae_list),
-    "sd_vae_as_default": OptionInfo(True, "Ignore selected VAE for stable diffusion checkpoints that have their own .vae.pt next to them", gr.Checkbox, {"visible": False}),
     "inpainting_mask_weight": OptionInfo(1.0, "Inpainting conditioning mask strength", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),
     "initial_noise_multiplier": OptionInfo(1.0, "Noise multiplier for img2img", gr.Slider, {"minimum": 0.5, "maximum": 1.5, "step": 0.01}),
     "img2img_color_correction": OptionInfo(False, "Apply color correction to img2img results to match original colors."),
     "img2img_fix_steps": OptionInfo(False, "For image processing do exactly the amount of steps as specified."),
     "img2img_background_color": OptionInfo("#ffffff", "With img2img, fill image's transparent parts with this color.", ui_components.FormColorPicker, {}),
     "enable_quantization": OptionInfo(True, "Enable quantization in K samplers for sharper and cleaner results. This may change existing seeds."),
-    "enable_emphasis": OptionInfo(True, "Emphasis: use (text) to make model pay more attention to text and [text] to make it pay less attention", gr.Checkbox, {"visible": False}),
-    "enable_batch_seeds": OptionInfo(True, "Make K-diffusion samplers produce same images in a batch as when making a single image", gr.Checkbox, {"visible": False}),
     "comma_padding_backtrack": OptionInfo(20, "Increase coherency by padding from the last comma within n tokens when using more than 75 tokens", gr.Slider, {"minimum": 0, "maximum": 74, "step": 1 }),
     "CLIP_stop_at_last_layers": OptionInfo(1, "Clip skip", gr.Slider, {"minimum": 1, "maximum": 12, "step": 1, "visible": False}),
     "upcast_attn": OptionInfo(False, "Upcast cross attention layer to float32"),
@@ -241,9 +238,6 @@ options_templates.update(options_section(('sd', "Stable Diffusion"), {
     "sub_quad_kv_chunk_size": OptionInfo(512, "Sub-quadratic cross-attentionkv chunk size for the sub-quadratic cross-attention layer optimization to use", gr.Slider, {"minimum": 0, "maximum": 8192, "step": 8}),
     "sub_quad_chunk_threshold": OptionInfo(80, "Sub-quadratic cross-attention percentage of VRAM chunking threshold", gr.Slider, {"minimum": 0, "maximum": 100, "step": 1}),
     "always_batch_cond_uncond": OptionInfo(False, "Disables cond/uncond batching that is enabled to save memory with --medvram or --lowvram"),
-    "multiple_tqdm": OptionInfo(False, "Add a second progress bar to the console that shows progress for an entire job.", gr.Checkbox, {"visible": False}),
-    "print_hypernet_extra": OptionInfo(False, "Print extra hypernetwork information to console.", gr.Checkbox, {"visible": False}),
-    "dimensions_and_batch_together": OptionInfo(True, "", gr.Checkbox, {"visible": False}),
 }))
 
 options_templates.update(options_section(('system-paths', "System Paths"), {
@@ -387,16 +381,10 @@ options_templates.update(options_section(('ui', "User interface"), {
     "return_grid": OptionInfo(True, "Show grid in results for web"),
     "return_mask": OptionInfo(False, "For inpainting, include the greyscale mask in results for web"),
     "return_mask_composite": OptionInfo(False, "For inpainting, include masked composite in results for web"),
-    "do_not_show_images": OptionInfo(False, "Do not show any images in results for web"),
-    "add_model_hash_to_info": OptionInfo(True, "Add model hash to generation information"),
-    "add_model_name_to_info": OptionInfo(True, "Add model name to generation information"),
     "disable_weights_auto_swap": OptionInfo(True, "Do not change the selected model when reading generation parameters."),
     "send_seed": OptionInfo(True, "Send seed when sending prompt or image to other interface"),
     "send_size": OptionInfo(True, "Send size when sending prompt or image to another interface"),
     "font": OptionInfo("", "Font for image grids that have text"),
-    "js_modal_lightbox": OptionInfo(True, "Enable full page image viewer", gr.Checkbox, {"visible": False}),
-    "js_modal_lightbox_initially_zoomed": OptionInfo(True, "Show images zoomed in by default in full page image viewer", gr.Checkbox, {"visible": False}),
-    "show_progress_in_title": OptionInfo(False, "Show generation progress in window title.", gr.Checkbox, {"visible": False}),
     "keyedit_precision_attention": OptionInfo(0.1, "Ctrl+up/down precision when editing (attention:1.1)", gr.Slider, {"minimum": 0.01, "maximum": 0.2, "step": 0.001}),
     "keyedit_precision_extra": OptionInfo(0.05, "Ctrl+up/down precision when editing <extra networks:0.9>", gr.Slider, {"minimum": 0.01, "maximum": 0.2, "step": 0.001}),
     "quicksettings": OptionInfo("sd_model_checkpoint", "Quicksettings list"),
@@ -417,7 +405,7 @@ options_templates.update(options_section(('ui', "Live previews"), {
 
 options_templates.update(options_section(('sampler-params', "Sampler parameters"), {
     "show_samplers": OptionInfo(["Euler a", "UniPC", "DDIM", "DPM++ SDE", "DPM++ SDE", "DPM2 Karras", "DPM++ 2M Karras"], "Show samplers in user interface", gr.CheckboxGroup, lambda: {"choices": [x.name for x in list_samplers()]}),
-    "fallback_sampler": OptionInfo("Euler a", "Fallback sampler if primary sampler is not compatible", gr.Dropdown, lambda: {"choices": ["None"] + [x.name for x in list_samplers()]}),
+    "fallback_sampler": OptionInfo("Euler a", "Secondary sampler", gr.Dropdown, lambda: {"choices": ["None"] + [x.name for x in list_samplers()]}),
     "eta_ancestral": OptionInfo(1.0, "Noise multiplier for ancestral samplers (eta)", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),
     "eta_ddim": OptionInfo(0.0, "Noise multiplier for DDIM (eta)", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),
     "ddim_discretize": OptionInfo('uniform', "DDIM discretize img2img", gr.Radio, {"choices": ['uniform', 'quad']}),
diff --git a/modules/txt2img.py b/modules/txt2img.py
index 2fcb4c49d..17e5ce909 100644
--- a/modules/txt2img.py
+++ b/modules/txt2img.py
@@ -1,16 +1,15 @@
 import modules.scripts
 from modules import sd_samplers
 from modules.generation_parameters_copypaste import create_override_settings_dict
-from modules.processing import StableDiffusionProcessingTxt2Img, process_images
-from modules.shared import opts
-import modules.shared as shared
+from modules.processing import StableDiffusionProcessingTxt2Img, process_images, memory_stats
+from modules.shared import opts, sd_model, cmd_opts, log
 from modules.ui import plaintext_to_html
 
 
 def txt2img(id_task: str, prompt: str, negative_prompt: str, prompt_styles, steps: int, sampler_index: int, restore_faces: bool, tiling: bool, n_iter: int, batch_size: int, cfg_scale: float, seed: int, subseed: int, subseed_strength: float, seed_resize_from_h: int, seed_resize_from_w: int, seed_enable_extras: bool, height: int, width: int, enable_hr: bool, denoising_strength: float, hr_scale: float, hr_upscaler: str, hr_second_pass_steps: int, hr_resize_x: int, hr_resize_y: int, override_settings_texts, *args): # pylint: disable=unused-argument
     override_settings = create_override_settings_dict(override_settings_texts)
     p = StableDiffusionProcessingTxt2Img(
-        sd_model=shared.sd_model,
+        sd_model=sd_model,
         outpath_samples=opts.outdir_samples or opts.outdir_txt2img_samples,
         outpath_grids=opts.outdir_grids or opts.outdir_txt2img_grids,
         prompt=prompt,
@@ -46,8 +45,7 @@ def txt2img(id_task: str, prompt: str, negative_prompt: str, prompt_styles, step
     if processed is None:
         processed = process_images(p)
     p.close()
-    shared.total_tqdm.clear()
     generation_info_js = processed.js()
-    if opts.do_not_show_images:
-        processed.images = []
+    if cmd_opts.debug:
+        log.info(f'Processed: {len(processed.images)} Memory: {memory_stats()} txt')
     return processed.images, generation_info_js, plaintext_to_html(processed.info), plaintext_to_html(processed.comments)
diff --git a/scripts/postprocessing_upscale.py b/scripts/postprocessing_upscale.py
index b2f9c7408..9ee8878ad 100644
--- a/scripts/postprocessing_upscale.py
+++ b/scripts/postprocessing_upscale.py
@@ -1,9 +1,7 @@
 from PIL import Image
 import numpy as np
-
-from modules import scripts_postprocessing, shared
 import gradio as gr
-
+from modules import scripts_postprocessing, shared
 from modules.ui_components import FormRow, ToolButton
 from modules.ui import switch_values_symbol
 
@@ -15,7 +13,7 @@ class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
     order = 1000
 
     def ui(self):
-        selected_tab = gr.State(value=0)
+        selected_tab = gr.State(value=0) # pylint: disable=abstract-class-instantiated
 
         with gr.Column():
             with FormRow():
@@ -80,7 +78,7 @@ class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
 
         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):
+    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): # pylint: disable=arguments-differ
         if upscaler_1_name == "None":
             upscaler_1_name = None
 
@@ -97,13 +95,13 @@ class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
         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[f"Postprocess upscaler"] = upscaler1.name
+        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[f"Postprocess upscaler 2"] = upscaler2.name
+            pp.info["Postprocess upscaler 2"] = upscaler2.name
 
         pp.image = upscaled_image
 
@@ -125,7 +123,7 @@ class ScriptPostprocessingUpscaleSimple(ScriptPostprocessingUpscale):
             "upscaler_name": upscaler_name,
         }
 
-    def process(self, pp: scripts_postprocessing.PostprocessedImage, upscale_by=2.0, upscaler_name=None):
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, upscale_by=2.0, upscaler_name=None): # pylint: disable=arguments-differ
         if upscaler_name is None or upscaler_name == "None":
             return
 
@@ -133,4 +131,4 @@ class ScriptPostprocessingUpscaleSimple(ScriptPostprocessingUpscale):
         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[f"Postprocess upscaler"] = upscaler1.name
+        pp.info["Postprocess upscaler"] = upscaler1.name
diff --git a/scripts/xyz_grid.py b/scripts/xyz_grid.py
index 748fe7bbc..700cc599e 100644
--- a/scripts/xyz_grid.py
+++ b/scripts/xyz_grid.py
@@ -587,7 +587,6 @@ class Script(scripts.Script):
         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)
diff --git a/webui.py b/webui.py
index 54d159d24..7ca052a2e 100644
--- a/webui.py
+++ b/webui.py
@@ -105,7 +105,7 @@ def initialize():
     startup_timer.record("vae")
 
     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("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)
     startup_timer.record("opts onchange")