Merge branch 'dev' into find_vae

79 files changed, 1314 insertions, 965 deletions

diff --git a/modules/Roboto-Regular.ttf b/modules/Roboto-Regular.ttf
new file mode 100644
index 00000000..500b1045
--- /dev/null
+++ b/modules/Roboto-Regular.ttf
diff --git a/modules/api/api.py b/modules/api/api.py
index cdbdce32..165985c3 100644
--- a/modules/api/api.py
+++ b/modules/api/api.py
@@ -15,7 +15,8 @@ from secrets import compare_digest
 
 import modules.shared as shared
 from modules import sd_samplers, deepbooru, sd_hijack, images, scripts, ui, postprocessing
-from modules.api.models import *
+from modules.api import models
+from modules.shared import opts
 from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img, process_images
 from modules.textual_inversion.textual_inversion import create_embedding, train_embedding
 from modules.textual_inversion.preprocess import preprocess
@@ -25,21 +26,24 @@ from modules.sd_models import checkpoints_list, unload_model_weights, reload_mod
 from modules.sd_models_config import find_checkpoint_config_near_filename
 from modules.realesrgan_model import get_realesrgan_models
 from modules import devices
-from typing import List
+from typing import Dict, List, Any
 import piexif
 import piexif.helper
 
+
 def upscaler_to_index(name: str):
     try:
         return [x.name.lower() for x in shared.sd_upscalers].index(name.lower())
-    except:
-        raise HTTPException(status_code=400, detail=f"Invalid upscaler, needs to be one of these: {' , '.join([x.name for x in sd_upscalers])}")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Invalid upscaler, needs to be one of these: {' , '.join([x.name for x in shared.sd_upscalers])}") from e
+
 
 def script_name_to_index(name, scripts):
     try:
         return [script.title().lower() for script in scripts].index(name.lower())
-    except:
-        raise HTTPException(status_code=422, detail=f"Script '{name}' not found")
+    except Exception as e:
+        raise HTTPException(status_code=422, detail=f"Script '{name}' not found") from e
+
 
 def validate_sampler_name(name):
     config = sd_samplers.all_samplers_map.get(name, None)
@@ -48,20 +52,23 @@ def validate_sampler_name(name):
 
     return name
 
+
 def setUpscalers(req: dict):
     reqDict = vars(req)
     reqDict['extras_upscaler_1'] = reqDict.pop('upscaler_1', None)
     reqDict['extras_upscaler_2'] = reqDict.pop('upscaler_2', None)
     return reqDict
 
+
 def decode_base64_to_image(encoding):
     if encoding.startswith("data:image/"):
         encoding = encoding.split(";")[1].split(",")[1]
     try:
         image = Image.open(BytesIO(base64.b64decode(encoding)))
         return image
-    except Exception as err:
-        raise HTTPException(status_code=500, detail="Invalid encoded image")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Invalid encoded image") from e
+
 
 def encode_pil_to_base64(image):
     with io.BytesIO() as output_bytes:
@@ -92,6 +99,7 @@ def encode_pil_to_base64(image):
 
     return base64.b64encode(bytes_data)
 
+
 def api_middleware(app: FastAPI):
     rich_available = True
     try:
@@ -99,7 +107,7 @@ def api_middleware(app: FastAPI):
         import starlette # importing just so it can be placed on silent list
         from rich.console import Console
         console = Console()
-    except:
+    except Exception:
         import traceback
         rich_available = False
 
@@ -157,7 +165,7 @@ def api_middleware(app: FastAPI):
 class Api:
     def __init__(self, app: FastAPI, queue_lock: Lock):
         if shared.cmd_opts.api_auth:
-            self.credentials = dict()
+            self.credentials = {}
             for auth in shared.cmd_opts.api_auth.split(","):
                 user, password = auth.split(":")
                 self.credentials[user] = password
@@ -166,36 +174,36 @@ class Api:
         self.app = app
         self.queue_lock = queue_lock
         api_middleware(self.app)
-        self.add_api_route("/sdapi/v1/txt2img", self.text2imgapi, methods=["POST"], response_model=TextToImageResponse)
-        self.add_api_route("/sdapi/v1/img2img", self.img2imgapi, methods=["POST"], response_model=ImageToImageResponse)
-        self.add_api_route("/sdapi/v1/extra-single-image", self.extras_single_image_api, methods=["POST"], response_model=ExtrasSingleImageResponse)
-        self.add_api_route("/sdapi/v1/extra-batch-images", self.extras_batch_images_api, methods=["POST"], response_model=ExtrasBatchImagesResponse)
-        self.add_api_route("/sdapi/v1/png-info", self.pnginfoapi, methods=["POST"], response_model=PNGInfoResponse)
-        self.add_api_route("/sdapi/v1/progress", self.progressapi, methods=["GET"], response_model=ProgressResponse)
+        self.add_api_route("/sdapi/v1/txt2img", self.text2imgapi, methods=["POST"], response_model=models.TextToImageResponse)
+        self.add_api_route("/sdapi/v1/img2img", self.img2imgapi, methods=["POST"], response_model=models.ImageToImageResponse)
+        self.add_api_route("/sdapi/v1/extra-single-image", self.extras_single_image_api, methods=["POST"], response_model=models.ExtrasSingleImageResponse)
+        self.add_api_route("/sdapi/v1/extra-batch-images", self.extras_batch_images_api, methods=["POST"], response_model=models.ExtrasBatchImagesResponse)
+        self.add_api_route("/sdapi/v1/png-info", self.pnginfoapi, methods=["POST"], response_model=models.PNGInfoResponse)
+        self.add_api_route("/sdapi/v1/progress", self.progressapi, methods=["GET"], response_model=models.ProgressResponse)
         self.add_api_route("/sdapi/v1/interrogate", self.interrogateapi, methods=["POST"])
         self.add_api_route("/sdapi/v1/interrupt", self.interruptapi, methods=["POST"])
         self.add_api_route("/sdapi/v1/skip", self.skip, methods=["POST"])
-        self.add_api_route("/sdapi/v1/options", self.get_config, methods=["GET"], response_model=OptionsModel)
+        self.add_api_route("/sdapi/v1/options", self.get_config, methods=["GET"], response_model=models.OptionsModel)
         self.add_api_route("/sdapi/v1/options", self.set_config, methods=["POST"])
-        self.add_api_route("/sdapi/v1/cmd-flags", self.get_cmd_flags, methods=["GET"], response_model=FlagsModel)
-        self.add_api_route("/sdapi/v1/samplers", self.get_samplers, methods=["GET"], response_model=List[SamplerItem])
-        self.add_api_route("/sdapi/v1/upscalers", self.get_upscalers, methods=["GET"], response_model=List[UpscalerItem])
-        self.add_api_route("/sdapi/v1/sd-models", self.get_sd_models, methods=["GET"], response_model=List[SDModelItem])
-        self.add_api_route("/sdapi/v1/hypernetworks", self.get_hypernetworks, methods=["GET"], response_model=List[HypernetworkItem])
-        self.add_api_route("/sdapi/v1/face-restorers", self.get_face_restorers, methods=["GET"], response_model=List[FaceRestorerItem])
-        self.add_api_route("/sdapi/v1/realesrgan-models", self.get_realesrgan_models, methods=["GET"], response_model=List[RealesrganItem])
-        self.add_api_route("/sdapi/v1/prompt-styles", self.get_prompt_styles, methods=["GET"], response_model=List[PromptStyleItem])
-        self.add_api_route("/sdapi/v1/embeddings", self.get_embeddings, methods=["GET"], response_model=EmbeddingsResponse)
+        self.add_api_route("/sdapi/v1/cmd-flags", self.get_cmd_flags, methods=["GET"], response_model=models.FlagsModel)
+        self.add_api_route("/sdapi/v1/samplers", self.get_samplers, methods=["GET"], response_model=List[models.SamplerItem])
+        self.add_api_route("/sdapi/v1/upscalers", self.get_upscalers, methods=["GET"], response_model=List[models.UpscalerItem])
+        self.add_api_route("/sdapi/v1/sd-models", self.get_sd_models, methods=["GET"], response_model=List[models.SDModelItem])
+        self.add_api_route("/sdapi/v1/hypernetworks", self.get_hypernetworks, methods=["GET"], response_model=List[models.HypernetworkItem])
+        self.add_api_route("/sdapi/v1/face-restorers", self.get_face_restorers, methods=["GET"], response_model=List[models.FaceRestorerItem])
+        self.add_api_route("/sdapi/v1/realesrgan-models", self.get_realesrgan_models, methods=["GET"], response_model=List[models.RealesrganItem])
+        self.add_api_route("/sdapi/v1/prompt-styles", self.get_prompt_styles, methods=["GET"], response_model=List[models.PromptStyleItem])
+        self.add_api_route("/sdapi/v1/embeddings", self.get_embeddings, methods=["GET"], response_model=models.EmbeddingsResponse)
         self.add_api_route("/sdapi/v1/refresh-checkpoints", self.refresh_checkpoints, methods=["POST"])
-        self.add_api_route("/sdapi/v1/create/embedding", self.create_embedding, methods=["POST"], response_model=CreateResponse)
-        self.add_api_route("/sdapi/v1/create/hypernetwork", self.create_hypernetwork, methods=["POST"], response_model=CreateResponse)
-        self.add_api_route("/sdapi/v1/preprocess", self.preprocess, methods=["POST"], response_model=PreprocessResponse)
-        self.add_api_route("/sdapi/v1/train/embedding", self.train_embedding, methods=["POST"], response_model=TrainResponse)
-        self.add_api_route("/sdapi/v1/train/hypernetwork", self.train_hypernetwork, methods=["POST"], response_model=TrainResponse)
-        self.add_api_route("/sdapi/v1/memory", self.get_memory, methods=["GET"], response_model=MemoryResponse)
+        self.add_api_route("/sdapi/v1/create/embedding", self.create_embedding, methods=["POST"], response_model=models.CreateResponse)
+        self.add_api_route("/sdapi/v1/create/hypernetwork", self.create_hypernetwork, methods=["POST"], response_model=models.CreateResponse)
+        self.add_api_route("/sdapi/v1/preprocess", self.preprocess, methods=["POST"], response_model=models.PreprocessResponse)
+        self.add_api_route("/sdapi/v1/train/embedding", self.train_embedding, methods=["POST"], response_model=models.TrainResponse)
+        self.add_api_route("/sdapi/v1/train/hypernetwork", self.train_hypernetwork, methods=["POST"], response_model=models.TrainResponse)
+        self.add_api_route("/sdapi/v1/memory", self.get_memory, methods=["GET"], response_model=models.MemoryResponse)
         self.add_api_route("/sdapi/v1/unload-checkpoint", self.unloadapi, methods=["POST"])
         self.add_api_route("/sdapi/v1/reload-checkpoint", self.reloadapi, methods=["POST"])
-        self.add_api_route("/sdapi/v1/scripts", self.get_scripts_list, methods=["GET"], response_model=ScriptsList)
+        self.add_api_route("/sdapi/v1/scripts", self.get_scripts_list, methods=["GET"], response_model=models.ScriptsList)
 
         self.default_script_arg_txt2img = []
         self.default_script_arg_img2img = []
@@ -219,17 +227,17 @@ class Api:
         script_idx = script_name_to_index(script_name, script_runner.selectable_scripts)
         script = script_runner.selectable_scripts[script_idx]
         return script, script_idx
-    
+
     def get_scripts_list(self):
         t2ilist = [str(title.lower()) for title in scripts.scripts_txt2img.titles]
         i2ilist = [str(title.lower()) for title in scripts.scripts_img2img.titles]
 
-        return ScriptsList(txt2img = t2ilist, img2img = i2ilist)  
+        return models.ScriptsList(txt2img=t2ilist, img2img=i2ilist)
 
     def get_script(self, script_name, script_runner):
         if script_name is None or script_name == "":
             return None, None
-        
+
         script_idx = script_name_to_index(script_name, script_runner.scripts)
         return script_runner.scripts[script_idx]
 
@@ -264,11 +272,11 @@ class Api:
         if request.alwayson_scripts and (len(request.alwayson_scripts) > 0):
             for alwayson_script_name in request.alwayson_scripts.keys():
                 alwayson_script = self.get_script(alwayson_script_name, script_runner)
-                if alwayson_script == None:
+                if alwayson_script is None:
                     raise HTTPException(status_code=422, detail=f"always on script {alwayson_script_name} not found")
                 # Selectable script in always on script param check
-                if alwayson_script.alwayson == False:
-                    raise HTTPException(status_code=422, detail=f"Cannot have a selectable script in the always on scripts params")
+                if alwayson_script.alwayson is False:
+                    raise HTTPException(status_code=422, detail="Cannot have a selectable script in the always on scripts params")
                 # always on script with no arg should always run so you don't really need to add them to the requests
                 if "args" in request.alwayson_scripts[alwayson_script_name]:
                     # min between arg length in scriptrunner and arg length in the request
@@ -276,7 +284,7 @@ class Api:
                         script_args[alwayson_script.args_from + idx] = request.alwayson_scripts[alwayson_script_name]["args"][idx]
         return script_args
 
-    def text2imgapi(self, txt2imgreq: StableDiffusionTxt2ImgProcessingAPI):
+    def text2imgapi(self, txt2imgreq: models.StableDiffusionTxt2ImgProcessingAPI):
         script_runner = scripts.scripts_txt2img
         if not script_runner.scripts:
             script_runner.initialize_scripts(False)
@@ -310,7 +318,7 @@ class Api:
             p.outpath_samples = opts.outdir_txt2img_samples
 
             shared.state.begin()
-            if selectable_scripts != None:
+            if selectable_scripts is not None:
                 p.script_args = script_args
                 processed = scripts.scripts_txt2img.run(p, *p.script_args) # Need to pass args as list here
             else:
@@ -320,9 +328,9 @@ class Api:
 
         b64images = list(map(encode_pil_to_base64, processed.images)) if send_images else []
 
-        return TextToImageResponse(images=b64images, parameters=vars(txt2imgreq), info=processed.js())
+        return models.TextToImageResponse(images=b64images, parameters=vars(txt2imgreq), info=processed.js())
 
-    def img2imgapi(self, img2imgreq: StableDiffusionImg2ImgProcessingAPI):
+    def img2imgapi(self, img2imgreq: models.StableDiffusionImg2ImgProcessingAPI):
         init_images = img2imgreq.init_images
         if init_images is None:
             raise HTTPException(status_code=404, detail="Init image not found")
@@ -367,7 +375,7 @@ class Api:
             p.outpath_samples = opts.outdir_img2img_samples
 
             shared.state.begin()
-            if selectable_scripts != None:
+            if selectable_scripts is not None:
                 p.script_args = script_args
                 processed = scripts.scripts_img2img.run(p, *p.script_args) # Need to pass args as list here
             else:
@@ -381,9 +389,9 @@ class Api:
             img2imgreq.init_images = None
             img2imgreq.mask = None
 
-        return ImageToImageResponse(images=b64images, parameters=vars(img2imgreq), info=processed.js())
+        return models.ImageToImageResponse(images=b64images, parameters=vars(img2imgreq), info=processed.js())
 
-    def extras_single_image_api(self, req: ExtrasSingleImageRequest):
+    def extras_single_image_api(self, req: models.ExtrasSingleImageRequest):
         reqDict = setUpscalers(req)
 
         reqDict['image'] = decode_base64_to_image(reqDict['image'])
@@ -391,9 +399,9 @@ class Api:
         with self.queue_lock:
             result = postprocessing.run_extras(extras_mode=0, image_folder="", input_dir="", output_dir="", save_output=False, **reqDict)
 
-        return ExtrasSingleImageResponse(image=encode_pil_to_base64(result[0][0]), html_info=result[1])
+        return models.ExtrasSingleImageResponse(image=encode_pil_to_base64(result[0][0]), html_info=result[1])
 
-    def extras_batch_images_api(self, req: ExtrasBatchImagesRequest):
+    def extras_batch_images_api(self, req: models.ExtrasBatchImagesRequest):
         reqDict = setUpscalers(req)
 
         image_list = reqDict.pop('imageList', [])
@@ -402,15 +410,15 @@ class Api:
         with self.queue_lock:
             result = postprocessing.run_extras(extras_mode=1, image_folder=image_folder, image="", input_dir="", output_dir="", save_output=False, **reqDict)
 
-        return ExtrasBatchImagesResponse(images=list(map(encode_pil_to_base64, result[0])), html_info=result[1])
+        return models.ExtrasBatchImagesResponse(images=list(map(encode_pil_to_base64, result[0])), html_info=result[1])
 
-    def pnginfoapi(self, req: PNGInfoRequest):
+    def pnginfoapi(self, req: models.PNGInfoRequest):
         if(not req.image.strip()):
-            return PNGInfoResponse(info="")
+            return models.PNGInfoResponse(info="")
 
         image = decode_base64_to_image(req.image.strip())
         if image is None:
-            return PNGInfoResponse(info="")
+            return models.PNGInfoResponse(info="")
 
         geninfo, items = images.read_info_from_image(image)
         if geninfo is None:
@@ -418,13 +426,13 @@ class Api:
 
         items = {**{'parameters': geninfo}, **items}
 
-        return PNGInfoResponse(info=geninfo, items=items)
+        return models.PNGInfoResponse(info=geninfo, items=items)
 
-    def progressapi(self, req: ProgressRequest = Depends()):
+    def progressapi(self, req: models.ProgressRequest = Depends()):
         # copy from check_progress_call of ui.py
 
         if shared.state.job_count == 0:
-            return ProgressResponse(progress=0, eta_relative=0, state=shared.state.dict(), textinfo=shared.state.textinfo)
+            return models.ProgressResponse(progress=0, eta_relative=0, state=shared.state.dict(), textinfo=shared.state.textinfo)
 
         # avoid dividing zero
         progress = 0.01
@@ -446,9 +454,9 @@ class Api:
         if shared.state.current_image and not req.skip_current_image:
             current_image = encode_pil_to_base64(shared.state.current_image)
 
-        return ProgressResponse(progress=progress, eta_relative=eta_relative, state=shared.state.dict(), current_image=current_image, textinfo=shared.state.textinfo)
+        return models.ProgressResponse(progress=progress, eta_relative=eta_relative, state=shared.state.dict(), current_image=current_image, textinfo=shared.state.textinfo)
 
-    def interrogateapi(self, interrogatereq: InterrogateRequest):
+    def interrogateapi(self, interrogatereq: models.InterrogateRequest):
         image_b64 = interrogatereq.image
         if image_b64 is None:
             raise HTTPException(status_code=404, detail="Image not found")
@@ -465,7 +473,7 @@ class Api:
             else:
                 raise HTTPException(status_code=404, detail="Model not found")
 
-        return InterrogateResponse(caption=processed)
+        return models.InterrogateResponse(caption=processed)
 
     def interruptapi(self):
         shared.state.interrupt()
@@ -570,36 +578,36 @@ class Api:
             filename = create_embedding(**args) # create empty embedding
             sd_hijack.model_hijack.embedding_db.load_textual_inversion_embeddings() # reload embeddings so new one can be immediately used
             shared.state.end()
-            return CreateResponse(info = "create embedding filename: {filename}".format(filename = filename))
+            return models.CreateResponse(info=f"create embedding filename: {filename}")
         except AssertionError as e:
             shared.state.end()
-            return TrainResponse(info = "create embedding error: {error}".format(error = e))
+            return models.TrainResponse(info=f"create embedding error: {e}")
 
     def create_hypernetwork(self, args: dict):
         try:
             shared.state.begin()
             filename = create_hypernetwork(**args) # create empty embedding
             shared.state.end()
-            return CreateResponse(info = "create hypernetwork filename: {filename}".format(filename = filename))
+            return models.CreateResponse(info=f"create hypernetwork filename: {filename}")
         except AssertionError as e:
             shared.state.end()
-            return TrainResponse(info = "create hypernetwork error: {error}".format(error = e))
+            return models.TrainResponse(info=f"create hypernetwork error: {e}")
 
     def preprocess(self, args: dict):
         try:
             shared.state.begin()
             preprocess(**args) # quick operation unless blip/booru interrogation is enabled
             shared.state.end()
-            return PreprocessResponse(info = 'preprocess complete')
+            return models.PreprocessResponse(info = 'preprocess complete')
         except KeyError as e:
             shared.state.end()
-            return PreprocessResponse(info = "preprocess error: invalid token: {error}".format(error = e))
+            return models.PreprocessResponse(info=f"preprocess error: invalid token: {e}")
         except AssertionError as e:
             shared.state.end()
-            return PreprocessResponse(info = "preprocess error: {error}".format(error = e))
+            return models.PreprocessResponse(info=f"preprocess error: {e}")
         except FileNotFoundError as e:
             shared.state.end()
-            return PreprocessResponse(info = 'preprocess error: {error}'.format(error = e))
+            return models.PreprocessResponse(info=f'preprocess error: {e}')
 
     def train_embedding(self, args: dict):
         try:
@@ -617,10 +625,10 @@ class Api:
                 if not apply_optimizations:
                     sd_hijack.apply_optimizations()
                 shared.state.end()
-            return TrainResponse(info = "train embedding complete: filename: {filename} error: {error}".format(filename = filename, error = error))
+            return models.TrainResponse(info=f"train embedding complete: filename: {filename} error: {error}")
         except AssertionError as msg:
             shared.state.end()
-            return TrainResponse(info = "train embedding error: {msg}".format(msg = msg))
+            return models.TrainResponse(info=f"train embedding error: {msg}")
 
     def train_hypernetwork(self, args: dict):
         try:
@@ -641,14 +649,15 @@ class Api:
                 if not apply_optimizations:
                     sd_hijack.apply_optimizations()
                 shared.state.end()
-            return TrainResponse(info="train embedding complete: filename: {filename} error: {error}".format(filename=filename, error=error))
-        except AssertionError as msg:
+            return models.TrainResponse(info=f"train embedding complete: filename: {filename} error: {error}")
+        except AssertionError:
             shared.state.end()
-            return TrainResponse(info="train embedding error: {error}".format(error=error))
+            return models.TrainResponse(info=f"train embedding error: {error}")
 
     def get_memory(self):
         try:
-            import os, psutil
+            import os
+            import psutil
             process = psutil.Process(os.getpid())
             res = process.memory_info() # only rss is cross-platform guaranteed so we dont rely on other values
             ram_total = 100 * res.rss / process.memory_percent() # and total memory is calculated as actual value is not cross-platform safe
@@ -675,10 +684,10 @@ class Api:
                     'events': warnings,
                 }
             else:
-                cuda = { 'error': 'unavailable' }
+                cuda = {'error': 'unavailable'}
         except Exception as err:
-            cuda = { 'error': f'{err}' }
-        return MemoryResponse(ram = ram, cuda = cuda)
+            cuda = {'error': f'{err}'}
+        return models.MemoryResponse(ram=ram, cuda=cuda)
 
     def launch(self, server_name, port):
         self.app.include_router(self.router)
diff --git a/modules/api/models.py b/modules/api/models.py
index 4a70f440..006ccdb7 100644
--- a/modules/api/models.py
+++ b/modules/api/models.py
@@ -223,8 +223,9 @@ for key in _options:
     if(_options[key].dest != 'help'):
         flag = _options[key]
         _type = str
-        if _options[key].default is not None: _type = type(_options[key].default)
-        flags.update({flag.dest: (_type,Field(default=flag.default, description=flag.help))})
+        if _options[key].default is not None:
+            _type = type(_options[key].default)
+        flags.update({flag.dest: (_type, Field(default=flag.default, description=flag.help))})
 
 FlagsModel = create_model("Flags", **flags)
 
@@ -288,4 +289,4 @@ class MemoryResponse(BaseModel):
 
 class ScriptsList(BaseModel):
     txt2img: list = Field(default=None,title="Txt2img", description="Titles of scripts (txt2img)")
-    img2img: list = Field(default=None,title="Img2img", description="Titles of scripts (img2img)")
\ No newline at end of file
+    img2img: list = Field(default=None,title="Img2img", description="Titles of scripts (img2img)")
diff --git a/modules/call_queue.py b/modules/call_queue.py
index 1829f3a6..447bb764 100644
--- a/modules/call_queue.py
+++ b/modules/call_queue.py
@@ -60,7 +60,7 @@ def wrap_gradio_call(func, extra_outputs=None, add_stats=False):
             max_debug_str_len = 131072 # (1024*1024)/8

 

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

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

+            argStr = f"Arguments: {args} {kwargs}"

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

             if len(argStr) > max_debug_str_len:

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

@@ -73,7 +73,8 @@ def wrap_gradio_call(func, extra_outputs=None, add_stats=False):
             if extra_outputs_array is None:

                 extra_outputs_array = [None, '']

 

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

+            error_message = f'{type(e).__name__}: {e}'

+            res = extra_outputs_array + [f"<div class='error'>{html.escape(error_message)}</div>"]

 

         shared.state.skipped = False

         shared.state.interrupted = False

diff --git a/modules/cmd_args.py b/modules/cmd_args.py
index f47c21bb..f4a4ab36 100644
--- a/modules/cmd_args.py
+++ b/modules/cmd_args.py
@@ -1,6 +1,6 @@
 import argparse

 import os

-from modules.paths_internal import models_path, script_path, data_path, extensions_dir, extensions_builtin_dir, sd_default_config, sd_model_file

+from modules.paths_internal import models_path, script_path, data_path, extensions_dir, extensions_builtin_dir, sd_default_config, sd_model_file  # noqa: F401

 

 parser = argparse.ArgumentParser()

 

@@ -102,3 +102,4 @@ parser.add_argument("--no-gradio-queue", action='store_true', help="Disables gra
 parser.add_argument("--skip-version-check", action='store_true', help="Do not check versions of torch and xformers")

 parser.add_argument("--no-hashing", action='store_true', help="disable sha256 hashing of checkpoints to help loading performance", default=False)

 parser.add_argument("--no-download-sd-model", action='store_true', help="don't download SD1.5 model even if no model is found in --ckpt-dir", default=False)

+parser.add_argument('--subpath', type=str, help='customize the subpath for gradio, use with reverse proxy')

diff --git a/modules/codeformer/codeformer_arch.py b/modules/codeformer/codeformer_arch.py
index 11dcc3ee..12db6814 100644
--- a/modules/codeformer/codeformer_arch.py
+++ b/modules/codeformer/codeformer_arch.py
@@ -1,14 +1,12 @@
 # this file is copied from CodeFormer repository. Please see comment in modules/codeformer_model.py
 
 import math
-import numpy as np
 import torch
 from torch import nn, Tensor
 import torch.nn.functional as F
-from typing import Optional, List
+from typing import Optional
 
-from modules.codeformer.vqgan_arch import *
-from basicsr.utils import get_root_logger
+from modules.codeformer.vqgan_arch import VQAutoEncoder, ResBlock
 from basicsr.utils.registry import ARCH_REGISTRY
 
 def calc_mean_std(feat, eps=1e-5):
@@ -121,7 +119,7 @@ class TransformerSALayer(nn.Module):
                 tgt_mask: Optional[Tensor] = None,
                 tgt_key_padding_mask: Optional[Tensor] = None,
                 query_pos: Optional[Tensor] = None):
-        
+
         # self attention
         tgt2 = self.norm1(tgt)
         q = k = self.with_pos_embed(tgt2, query_pos)
@@ -161,10 +159,10 @@ class Fuse_sft_block(nn.Module):
 
 @ARCH_REGISTRY.register()
 class CodeFormer(VQAutoEncoder):
-    def __init__(self, dim_embd=512, n_head=8, n_layers=9, 
+    def __init__(self, dim_embd=512, n_head=8, n_layers=9,
                 codebook_size=1024, latent_size=256,
-                connect_list=['32', '64', '128', '256'],
-                fix_modules=['quantize','generator']):
+                connect_list=('32', '64', '128', '256'),
+                fix_modules=('quantize', 'generator')):
         super(CodeFormer, self).__init__(512, 64, [1, 2, 2, 4, 4, 8], 'nearest',2, [16], codebook_size)
 
         if fix_modules is not None:
@@ -181,14 +179,14 @@ class CodeFormer(VQAutoEncoder):
         self.feat_emb = nn.Linear(256, self.dim_embd)
 
         # transformer
-        self.ft_layers = nn.Sequential(*[TransformerSALayer(embed_dim=dim_embd, nhead=n_head, dim_mlp=self.dim_mlp, dropout=0.0) 
+        self.ft_layers = nn.Sequential(*[TransformerSALayer(embed_dim=dim_embd, nhead=n_head, dim_mlp=self.dim_mlp, dropout=0.0)
                                     for _ in range(self.n_layers)])
 
         # logits_predict head
         self.idx_pred_layer = nn.Sequential(
             nn.LayerNorm(dim_embd),
             nn.Linear(dim_embd, codebook_size, bias=False))
-        
+
         self.channels = {
             '16': 512,
             '32': 256,
@@ -223,7 +221,7 @@ class CodeFormer(VQAutoEncoder):
         enc_feat_dict = {}
         out_list = [self.fuse_encoder_block[f_size] for f_size in self.connect_list]
         for i, block in enumerate(self.encoder.blocks):
-            x = block(x) 
+            x = block(x)
             if i in out_list:
                 enc_feat_dict[str(x.shape[-1])] = x.clone()
 
@@ -268,11 +266,11 @@ class CodeFormer(VQAutoEncoder):
         fuse_list = [self.fuse_generator_block[f_size] for f_size in self.connect_list]
 
         for i, block in enumerate(self.generator.blocks):
-            x = block(x) 
+            x = block(x)
             if i in fuse_list: # fuse after i-th block
                 f_size = str(x.shape[-1])
                 if w>0:
                     x = self.fuse_convs_dict[f_size](enc_feat_dict[f_size].detach(), x, w)
         out = x
         # logits doesn't need softmax before cross_entropy loss
-        return out, logits, lq_feat
\ No newline at end of file
+        return out, logits, lq_feat
diff --git a/modules/codeformer/vqgan_arch.py b/modules/codeformer/vqgan_arch.py
index e7293683..09ee6660 100644
--- a/modules/codeformer/vqgan_arch.py
+++ b/modules/codeformer/vqgan_arch.py
@@ -5,17 +5,15 @@ VQGAN code, adapted from the original created by the Unleashing Transformers aut
 https://github.com/samb-t/unleashing-transformers/blob/master/models/vqgan.py
 
 '''
-import numpy as np
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import copy
 from basicsr.utils import get_root_logger
 from basicsr.utils.registry import ARCH_REGISTRY
 
 def normalize(in_channels):
     return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
-    
+
 
 @torch.jit.script
 def swish(x):
@@ -212,15 +210,15 @@ class AttnBlock(nn.Module):
         # compute attention
         b, c, h, w = q.shape
         q = q.reshape(b, c, h*w)
-        q = q.permute(0, 2, 1)   
+        q = q.permute(0, 2, 1)
         k = k.reshape(b, c, h*w)
-        w_ = torch.bmm(q, k) 
+        w_ = torch.bmm(q, k)
         w_ = w_ * (int(c)**(-0.5))
         w_ = F.softmax(w_, dim=2)
 
         # attend to values
         v = v.reshape(b, c, h*w)
-        w_ = w_.permute(0, 2, 1) 
+        w_ = w_.permute(0, 2, 1)
         h_ = torch.bmm(v, w_)
         h_ = h_.reshape(b, c, h, w)
 
@@ -272,18 +270,18 @@ class Encoder(nn.Module):
     def forward(self, x):
         for block in self.blocks:
             x = block(x)
-            
+
         return x
 
 
 class Generator(nn.Module):
     def __init__(self, nf, emb_dim, ch_mult, res_blocks, img_size, attn_resolutions):
         super().__init__()
-        self.nf = nf 
-        self.ch_mult = ch_mult 
+        self.nf = nf
+        self.ch_mult = ch_mult
         self.num_resolutions = len(self.ch_mult)
         self.num_res_blocks = res_blocks
-        self.resolution = img_size 
+        self.resolution = img_size
         self.attn_resolutions = attn_resolutions
         self.in_channels = emb_dim
         self.out_channels = 3
@@ -317,29 +315,29 @@ class Generator(nn.Module):
         blocks.append(nn.Conv2d(block_in_ch, self.out_channels, kernel_size=3, stride=1, padding=1))
 
         self.blocks = nn.ModuleList(blocks)
-   
+
 
     def forward(self, x):
         for block in self.blocks:
             x = block(x)
-            
+
         return x
 
-  
+
 @ARCH_REGISTRY.register()
 class VQAutoEncoder(nn.Module):
-    def __init__(self, img_size, nf, ch_mult, quantizer="nearest", res_blocks=2, attn_resolutions=[16], codebook_size=1024, emb_dim=256,
+    def __init__(self, img_size, nf, ch_mult, quantizer="nearest", res_blocks=2, attn_resolutions=None, codebook_size=1024, emb_dim=256,
                 beta=0.25, gumbel_straight_through=False, gumbel_kl_weight=1e-8, model_path=None):
         super().__init__()
         logger = get_root_logger()
-        self.in_channels = 3 
-        self.nf = nf 
-        self.n_blocks = res_blocks 
+        self.in_channels = 3
+        self.nf = nf
+        self.n_blocks = res_blocks
         self.codebook_size = codebook_size
         self.embed_dim = emb_dim
         self.ch_mult = ch_mult
         self.resolution = img_size
-        self.attn_resolutions = attn_resolutions
+        self.attn_resolutions = attn_resolutions or [16]
         self.quantizer_type = quantizer
         self.encoder = Encoder(
             self.in_channels,
@@ -365,11 +363,11 @@ class VQAutoEncoder(nn.Module):
                 self.kl_weight
             )
         self.generator = Generator(
-            self.nf, 
+            self.nf,
             self.embed_dim,
-            self.ch_mult, 
-            self.n_blocks, 
-            self.resolution, 
+            self.ch_mult,
+            self.n_blocks,
+            self.resolution,
             self.attn_resolutions
         )
 
@@ -434,4 +432,4 @@ class VQGANDiscriminator(nn.Module):
                 raise ValueError('Wrong params!')
 
     def forward(self, x):
-        return self.main(x)
\ No newline at end of file
+        return self.main(x)
diff --git a/modules/codeformer_model.py b/modules/codeformer_model.py
index 8d84bbc9..ececdbae 100644
--- a/modules/codeformer_model.py
+++ b/modules/codeformer_model.py
@@ -33,11 +33,9 @@ def setup_model(dirname):
     try:

         from torchvision.transforms.functional import normalize

         from modules.codeformer.codeformer_arch import CodeFormer

-        from basicsr.utils.download_util import load_file_from_url

-        from basicsr.utils import imwrite, img2tensor, tensor2img

+        from basicsr.utils import img2tensor, tensor2img

         from facelib.utils.face_restoration_helper import FaceRestoreHelper

         from facelib.detection.retinaface import retinaface

-        from modules.shared import cmd_opts

 

         net_class = CodeFormer

 

@@ -96,7 +94,7 @@ def setup_model(dirname):
                 self.face_helper.get_face_landmarks_5(only_center_face=False, resize=640, eye_dist_threshold=5)

                 self.face_helper.align_warp_face()

 

-                for idx, cropped_face in enumerate(self.face_helper.cropped_faces):

+                for cropped_face in self.face_helper.cropped_faces:

                     cropped_face_t = img2tensor(cropped_face / 255., bgr2rgb=True, float32=True)

                     normalize(cropped_face_t, (0.5, 0.5, 0.5), (0.5, 0.5, 0.5), inplace=True)

                     cropped_face_t = cropped_face_t.unsqueeze(0).to(devices.device_codeformer)

diff --git a/modules/config_states.py b/modules/config_states.py
index 2ea00929..75da862a 100644
--- a/modules/config_states.py
+++ b/modules/config_states.py
@@ -14,7 +14,7 @@ from collections import OrderedDict
 import git
 
 from modules import shared, extensions
-from modules.paths_internal import extensions_dir, extensions_builtin_dir, script_path, config_states_dir
+from modules.paths_internal import script_path, config_states_dir
 
 
 all_config_states = OrderedDict()
@@ -35,7 +35,7 @@ def list_config_states():
                 j["filepath"] = path
                 config_states.append(j)
 
-    config_states = list(sorted(config_states, key=lambda cs: cs["created_at"], reverse=True))
+    config_states = sorted(config_states, key=lambda cs: cs["created_at"], reverse=True)
 
     for cs in config_states:
         timestamp = time.asctime(time.gmtime(cs["created_at"]))
diff --git a/modules/deepbooru.py b/modules/deepbooru.py
index 122fce7f..547e1b4c 100644
--- a/modules/deepbooru.py
+++ b/modules/deepbooru.py
@@ -2,7 +2,6 @@ import os
 import re
 
 import torch
-from PIL import Image
 import numpy as np
 
 from modules import modelloader, paths, deepbooru_model, devices, images, shared
@@ -79,7 +78,7 @@ class DeepDanbooru:
 
         res = []
 
-        filtertags = set([x.strip().replace(' ', '_') for x in shared.opts.deepbooru_filter_tags.split(",")])
+        filtertags = {x.strip().replace(' ', '_') for x in shared.opts.deepbooru_filter_tags.split(",")}
 
         for tag in [x for x in tags if x not in filtertags]:
             probability = probability_dict[tag]
diff --git a/modules/devices.py b/modules/devices.py
index c705a3cb..d8a34a0f 100644
--- a/modules/devices.py
+++ b/modules/devices.py
@@ -65,7 +65,7 @@ def enable_tf32():
 
         # enabling benchmark option seems to enable a range of cards to do fp16 when they otherwise can't
         # see https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/4407
-        if any([torch.cuda.get_device_capability(devid) == (7, 5) for devid in range(0, torch.cuda.device_count())]):
+        if any(torch.cuda.get_device_capability(devid) == (7, 5) for devid in range(0, torch.cuda.device_count())):
             torch.backends.cudnn.benchmark = True
 
         torch.backends.cuda.matmul.allow_tf32 = True
diff --git a/modules/esrgan_model.py b/modules/esrgan_model.py
index 9a9c38f1..a009eb42 100644
--- a/modules/esrgan_model.py
+++ b/modules/esrgan_model.py
@@ -6,7 +6,7 @@ from PIL import Image
 from basicsr.utils.download_util import load_file_from_url

 

 import modules.esrgan_model_arch as arch

-from modules import shared, modelloader, images, devices

+from modules import modelloader, images, devices

 from modules.upscaler import Upscaler, UpscalerData

 from modules.shared import opts

 

@@ -16,9 +16,7 @@ def mod2normal(state_dict):
     # this code is copied from https://github.com/victorca25/iNNfer

     if 'conv_first.weight' in state_dict:

         crt_net = {}

-        items = []

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

-            items.append(k)

+        items = list(state_dict)

 

         crt_net['model.0.weight'] = state_dict['conv_first.weight']

         crt_net['model.0.bias'] = state_dict['conv_first.bias']

@@ -52,9 +50,7 @@ def resrgan2normal(state_dict, nb=23):
     if "conv_first.weight" in state_dict and "body.0.rdb1.conv1.weight" in state_dict:

         re8x = 0

         crt_net = {}

-        items = []

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

-            items.append(k)

+        items = list(state_dict)

 

         crt_net['model.0.weight'] = state_dict['conv_first.weight']

         crt_net['model.0.bias'] = state_dict['conv_first.bias']

@@ -156,13 +152,16 @@ class UpscalerESRGAN(Upscaler):
 

     def load_model(self, path: str):

         if "http" in path:

-            filename = load_file_from_url(url=self.model_url, model_dir=self.model_path,

-                                          file_name="%s.pth" % self.model_name,

-                                          progress=True)

+            filename = load_file_from_url(

+                url=self.model_url,

+                model_dir=self.model_path,

+                file_name=f"{self.model_name}.pth",

+                progress=True,

+            )

         else:

             filename = path

         if not os.path.exists(filename) or filename is None:

-            print("Unable to load %s from %s" % (self.model_path, filename))

+            print(f"Unable to load {self.model_path} from {filename}")

             return None

 

         state_dict = torch.load(filename, map_location='cpu' if devices.device_esrgan.type == 'mps' else None)

diff --git a/modules/esrgan_model_arch.py b/modules/esrgan_model_arch.py
index 1b52b0f5..2b9888ba 100644
--- a/modules/esrgan_model_arch.py
+++ b/modules/esrgan_model_arch.py
@@ -2,7 +2,6 @@
 

 from collections import OrderedDict

 import math

-import functools

 import torch

 import torch.nn as nn

 import torch.nn.functional as F

@@ -38,7 +37,7 @@ class RRDBNet(nn.Module):
         elif upsample_mode == 'pixelshuffle':

             upsample_block = pixelshuffle_block

         else:

-            raise NotImplementedError('upsample mode [{:s}] is not found'.format(upsample_mode))

+            raise NotImplementedError(f'upsample mode [{upsample_mode}] is not found')

         if upscale == 3:

             upsampler = upsample_block(nf, nf, 3, act_type=act_type, convtype=convtype)

         else:

@@ -106,7 +105,7 @@ class ResidualDenseBlock_5C(nn.Module):
     Modified options that can be used:

         - "Partial Convolution based Padding" arXiv:1811.11718

         - "Spectral normalization" arXiv:1802.05957

-        - "ICASSP 2020 - ESRGAN+ : Further Improving ESRGAN" N. C. 

+        - "ICASSP 2020 - ESRGAN+ : Further Improving ESRGAN" N. C.

             {Rakotonirina} and A. {Rasoanaivo}

     """

 

@@ -171,7 +170,7 @@ class GaussianNoise(nn.Module):
             scale = self.sigma * x.detach() if self.is_relative_detach else self.sigma * x

             sampled_noise = self.noise.repeat(*x.size()).normal_() * scale

             x = x + sampled_noise

-        return x 

+        return x

 

 def conv1x1(in_planes, out_planes, stride=1):

     return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)

@@ -261,10 +260,10 @@ class Upsample(nn.Module):
 

     def extra_repr(self):

         if self.scale_factor is not None:

-            info = 'scale_factor=' + str(self.scale_factor)

+            info = f'scale_factor={self.scale_factor}'

         else:

-            info = 'size=' + str(self.size)

-        info += ', mode=' + self.mode

+            info = f'size={self.size}'

+        info += f', mode={self.mode}'

         return info

 

 

@@ -350,7 +349,7 @@ def act(act_type, inplace=True, neg_slope=0.2, n_prelu=1, beta=1.0):
     elif act_type == 'sigmoid':  # [0, 1] range output

         layer = nn.Sigmoid()

     else:

-        raise NotImplementedError('activation layer [{:s}] is not found'.format(act_type))

+        raise NotImplementedError(f'activation layer [{act_type}] is not found')

     return layer

 

 

@@ -372,7 +371,7 @@ def norm(norm_type, nc):
     elif norm_type == 'none':

         def norm_layer(x): return Identity()

     else:

-        raise NotImplementedError('normalization layer [{:s}] is not found'.format(norm_type))

+        raise NotImplementedError(f'normalization layer [{norm_type}] is not found')

     return layer

 

 

@@ -388,7 +387,7 @@ def pad(pad_type, padding):
     elif pad_type == 'zero':

         layer = nn.ZeroPad2d(padding)

     else:

-        raise NotImplementedError('padding layer [{:s}] is not implemented'.format(pad_type))

+        raise NotImplementedError(f'padding layer [{pad_type}] is not implemented')

     return layer

 

 

@@ -432,15 +431,17 @@ def conv_block(in_nc, out_nc, kernel_size, stride=1, dilation=1, groups=1, bias=
                pad_type='zero', norm_type=None, act_type='relu', mode='CNA', convtype='Conv2D',

                spectral_norm=False):

     """ Conv layer with padding, normalization, activation """

-    assert mode in ['CNA', 'NAC', 'CNAC'], 'Wrong conv mode [{:s}]'.format(mode)

+    assert mode in ['CNA', 'NAC', 'CNAC'], f'Wrong conv mode [{mode}]'

     padding = get_valid_padding(kernel_size, dilation)

     p = pad(pad_type, padding) if pad_type and pad_type != 'zero' else None

     padding = padding if pad_type == 'zero' else 0

 

     if convtype=='PartialConv2D':

+        from torchvision.ops import PartialConv2d  # this is definitely not going to work, but PartialConv2d doesn't work anyway and this shuts up static analyzer

         c = PartialConv2d(in_nc, out_nc, kernel_size=kernel_size, stride=stride, padding=padding,

                dilation=dilation, bias=bias, groups=groups)

     elif convtype=='DeformConv2D':

+        from torchvision.ops import DeformConv2d  # not tested

         c = DeformConv2d(in_nc, out_nc, kernel_size=kernel_size, stride=stride, padding=padding,

                dilation=dilation, bias=bias, groups=groups)

     elif convtype=='Conv3D':

diff --git a/modules/extensions.py b/modules/extensions.py
index 34d9d654..bc2c0450 100644
--- a/modules/extensions.py
+++ b/modules/extensions.py
@@ -3,11 +3,10 @@ import sys
 import traceback

 

 import time

-from datetime import datetime

 import git

 

 from modules import shared

-from modules.paths_internal import extensions_dir, extensions_builtin_dir, script_path

+from modules.paths_internal import extensions_dir, extensions_builtin_dir, script_path  # noqa: F401

 

 extensions = []

 

diff --git a/modules/extra_networks.py b/modules/extra_networks.py
index 1978673d..f9db41bc 100644
--- a/modules/extra_networks.py
+++ b/modules/extra_networks.py
@@ -91,7 +91,7 @@ def deactivate(p, extra_network_data):
     """call deactivate for extra networks in extra_network_data in specified order, then call

     deactivate for all remaining registered networks"""

 

-    for extra_network_name, extra_network_args in extra_network_data.items():

+    for extra_network_name in extra_network_data:

         extra_network = extra_network_registry.get(extra_network_name, None)

         if extra_network is None:

             continue

diff --git a/modules/extra_networks_hypernet.py b/modules/extra_networks_hypernet.py
index 33d100dd..aa2a14ef 100644
--- a/modules/extra_networks_hypernet.py
+++ b/modules/extra_networks_hypernet.py
@@ -1,4 +1,4 @@
-from modules import extra_networks, shared, extra_networks

+from modules import extra_networks, shared

 from modules.hypernetworks import hypernetwork

 

 

@@ -10,7 +10,8 @@ class ExtraNetworkHypernet(extra_networks.ExtraNetwork):
         additional = shared.opts.sd_hypernetwork

 

         if additional != "None" and additional in shared.hypernetworks and len([x for x in params_list if x.items[0] == additional]) == 0:

-            p.all_prompts = [x + f"<hypernet:{additional}:{shared.opts.extra_networks_default_multiplier}>" for x in p.all_prompts]

+            hypernet_prompt_text = f"<hypernet:{additional}:{shared.opts.extra_networks_default_multiplier}>"

+            p.all_prompts = [f"{prompt}{hypernet_prompt_text}" for prompt in p.all_prompts]

             params_list.append(extra_networks.ExtraNetworkParams(items=[additional, shared.opts.extra_networks_default_multiplier]))

 

         names = []

diff --git a/modules/extras.py b/modules/extras.py
index ff4e9c4e..bdf9b3b7 100644
--- a/modules/extras.py
+++ b/modules/extras.py
@@ -136,14 +136,14 @@ def run_modelmerger(id_task, primary_model_name, secondary_model_name, tertiary_
     result_is_instruct_pix2pix_model = False

 

     if theta_func2:

-        shared.state.textinfo = f"Loading B"

+        shared.state.textinfo = "Loading B"

         print(f"Loading {secondary_model_info.filename}...")

         theta_1 = sd_models.read_state_dict(secondary_model_info.filename, map_location='cpu')

     else:

         theta_1 = None

 

     if theta_func1:

-        shared.state.textinfo = f"Loading C"

+        shared.state.textinfo = "Loading C"

         print(f"Loading {tertiary_model_info.filename}...")

         theta_2 = sd_models.read_state_dict(tertiary_model_info.filename, map_location='cpu')

 

@@ -199,7 +199,7 @@ def run_modelmerger(id_task, primary_model_name, secondary_model_name, tertiary_
                     result_is_inpainting_model = True

             else:

                 theta_0[key] = theta_func2(a, b, multiplier)

-            

+

             theta_0[key] = to_half(theta_0[key], save_as_half)

 

         shared.state.sampling_step += 1

diff --git a/modules/generation_parameters_copypaste.py b/modules/generation_parameters_copypaste.py
index 99f1a0d3..f1a2204c 100644
--- a/modules/generation_parameters_copypaste.py
+++ b/modules/generation_parameters_copypaste.py
@@ -1,15 +1,11 @@
 import base64

-import html

 import io

-import math

 import os

 import re

-from pathlib import Path

 

 import gradio as gr

 from modules.paths import data_path

 from modules import shared, ui_tempdir, script_callbacks

-import tempfile

 from PIL import Image

 

 re_param_code = r'\s*([\w ]+):\s*("(?:\\"[^,]|\\"|\\|[^\"])+"|[^,]*)(?:,|$)'

@@ -23,14 +19,14 @@ registered_param_bindings = []
 

 

 class ParamBinding:

-    def __init__(self, paste_button, tabname, source_text_component=None, source_image_component=None, source_tabname=None, override_settings_component=None, paste_field_names=[]):

+    def __init__(self, paste_button, tabname, source_text_component=None, source_image_component=None, source_tabname=None, override_settings_component=None, paste_field_names=None):

         self.paste_button = paste_button

         self.tabname = tabname

         self.source_text_component = source_text_component

         self.source_image_component = source_image_component

         self.source_tabname = source_tabname

         self.override_settings_component = override_settings_component

-        self.paste_field_names = paste_field_names

+        self.paste_field_names = paste_field_names or []

 

 

 def reset():

@@ -59,6 +55,7 @@ def image_from_url_text(filedata):
         is_in_right_dir = ui_tempdir.check_tmp_file(shared.demo, filename)

         assert is_in_right_dir, 'trying to open image file outside of allowed directories'

 

+        filename = filename.rsplit('?', 1)[0]

         return Image.open(filename)

 

     if type(filedata) == list:

@@ -129,6 +126,7 @@ def connect_paste_params_buttons():
                 _js=jsfunc,

                 inputs=[binding.source_image_component],

                 outputs=[destination_image_component, destination_width_component, destination_height_component] if destination_width_component else [destination_image_component],

+                show_progress=False,

             )

 

         if binding.source_text_component is not None and fields is not None:

@@ -140,6 +138,7 @@ def connect_paste_params_buttons():
                 fn=lambda *x: x,

                 inputs=[field for field, name in paste_fields[binding.source_tabname]["fields"] if name in paste_field_names],

                 outputs=[field for field, name in fields if name in paste_field_names],

+                show_progress=False,

             )

 

         binding.paste_button.click(

@@ -147,6 +146,7 @@ def connect_paste_params_buttons():
             _js=f"switch_to_{binding.tabname}",

             inputs=None,

             outputs=None,

+            show_progress=False,

         )

 

 

@@ -247,7 +247,7 @@ Steps: 20, Sampler: Euler a, CFG scale: 7, Seed: 965400086, Size: 512x512, Model
         lines.append(lastline)

         lastline = ''

 

-    for i, line in enumerate(lines):

+    for line in lines:

         line = line.strip()

         if line.startswith("Negative prompt:"):

             done_with_prompt = True

@@ -265,8 +265,8 @@ Steps: 20, Sampler: Euler a, CFG scale: 7, Seed: 965400086, Size: 512x512, Model
         v = v[1:-1] if v[0] == '"' and v[-1] == '"' else v

         m = re_imagesize.match(v)

         if m is not None:

-            res[k+"-1"] = m.group(1)

-            res[k+"-2"] = m.group(2)

+            res[f"{k}-1"] = m.group(1)

+            res[f"{k}-2"] = m.group(2)

         else:

             res[k] = v

 

@@ -308,6 +308,8 @@ infotext_to_setting_name_mapping = [
     ('UniPC skip type', 'uni_pc_skip_type'),

     ('UniPC order', 'uni_pc_order'),

     ('UniPC lower order final', 'uni_pc_lower_order_final'),

+    ('Token merging ratio', 'token_merging_ratio'),

+    ('Token merging ratio hr', 'token_merging_ratio_hr'),

     ('RNG', 'randn_source'),

     ('NGMS', 's_min_uncond'),

 ]

@@ -409,12 +411,14 @@ def connect_paste(button, paste_fields, input_comp, override_settings_component,
         fn=paste_func,

         inputs=[input_comp],

         outputs=[x[0] for x in paste_fields],

+        show_progress=False,

     )

     button.click(

         fn=None,

         _js=f"recalculate_prompts_{tabname}",

         inputs=[],

         outputs=[],

+        show_progress=False,

     )

 

 

diff --git a/modules/gfpgan_model.py b/modules/gfpgan_model.py
index fbe6215a..0131dea4 100644
--- a/modules/gfpgan_model.py
+++ b/modules/gfpgan_model.py
@@ -78,7 +78,7 @@ def setup_model(dirname):
 

     try:

         from gfpgan import GFPGANer

-        from facexlib import detection, parsing

+        from facexlib import detection, parsing  # noqa: F401

         global user_path

         global have_gfpgan

         global gfpgan_constructor

diff --git a/modules/hashes.py b/modules/hashes.py
index 83272a07..032120f4 100644
--- a/modules/hashes.py
+++ b/modules/hashes.py
@@ -13,7 +13,7 @@ cache_data = None
 

 

 def dump_cache():

-    with filelock.FileLock(cache_filename+".lock"):

+    with filelock.FileLock(f"{cache_filename}.lock"):

         with open(cache_filename, "w", encoding="utf8") as file:

             json.dump(cache_data, file, indent=4)

 

@@ -22,7 +22,7 @@ def cache(subsection):
     global cache_data

 

     if cache_data is None:

-        with filelock.FileLock(cache_filename+".lock"):

+        with filelock.FileLock(f"{cache_filename}.lock"):

             if not os.path.isfile(cache_filename):

                 cache_data = {}

             else:

diff --git a/modules/hypernetworks/hypernetwork.py b/modules/hypernetworks/hypernetwork.py
index 1fc49537..570b5603 100644
--- a/modules/hypernetworks/hypernetwork.py
+++ b/modules/hypernetworks/hypernetwork.py
@@ -1,4 +1,3 @@
-import csv

 import datetime

 import glob

 import html

@@ -18,7 +17,7 @@ from modules.textual_inversion.learn_schedule import LearnRateScheduler
 from torch import einsum

 from torch.nn.init import normal_, xavier_normal_, xavier_uniform_, kaiming_normal_, kaiming_uniform_, zeros_

 

-from collections import defaultdict, deque

+from collections import deque

 from statistics import stdev, mean

 

 

@@ -178,34 +177,34 @@ class Hypernetwork:
 

     def weights(self):

         res = []

-        for k, layers in self.layers.items():

+        for layers in self.layers.values():

             for layer in layers:

                 res += layer.parameters()

         return res

 

     def train(self, mode=True):

-        for k, layers in self.layers.items():

+        for layers in self.layers.values():

             for layer in layers:

                 layer.train(mode=mode)

                 for param in layer.parameters():

                     param.requires_grad = mode

 

     def to(self, device):

-        for k, layers in self.layers.items():

+        for layers in self.layers.values():

             for layer in layers:

                 layer.to(device)

 

         return self

 

     def set_multiplier(self, multiplier):

-        for k, layers in self.layers.items():

+        for layers in self.layers.values():

             for layer in layers:

                 layer.multiplier = multiplier

 

         return self

 

     def eval(self):

-        for k, layers in self.layers.items():

+        for layers in self.layers.values():

             for layer in layers:

                 layer.eval()

                 for param in layer.parameters():

@@ -404,7 +403,7 @@ def attention_CrossAttention_forward(self, x, context=None, mask=None):
     k = self.to_k(context_k)

     v = self.to_v(context_v)

 

-    q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))

+    q, k, v = (rearrange(t, 'b n (h d) -> (b h) n d', h=h) for t in (q, k, v))

 

     sim = einsum('b i d, b j d -> b i j', q, k) * self.scale

 

@@ -541,7 +540,7 @@ def train_hypernetwork(id_task, hypernetwork_name, learn_rate, batch_size, gradi
         return hypernetwork, filename

 

     scheduler = LearnRateScheduler(learn_rate, steps, initial_step)

-    

+

     clip_grad = torch.nn.utils.clip_grad_value_ if clip_grad_mode == "value" else torch.nn.utils.clip_grad_norm_ if clip_grad_mode == "norm" else None

     if clip_grad:

         clip_grad_sched = LearnRateScheduler(clip_grad_value, steps, initial_step, verbose=False)

@@ -594,7 +593,7 @@ def train_hypernetwork(id_task, hypernetwork_name, learn_rate, batch_size, gradi
             print(e)

 

     scaler = torch.cuda.amp.GradScaler()

-    

+

     batch_size = ds.batch_size

     gradient_step = ds.gradient_step

     # n steps = batch_size * gradient_step * n image processed

@@ -620,7 +619,7 @@ def train_hypernetwork(id_task, hypernetwork_name, learn_rate, batch_size, gradi
     try:

         sd_hijack_checkpoint.add()

 

-        for i in range((steps-initial_step) * gradient_step):

+        for _ in range((steps-initial_step) * gradient_step):

             if scheduler.finished:

                 break

             if shared.state.interrupted:

@@ -637,7 +636,7 @@ def train_hypernetwork(id_task, hypernetwork_name, learn_rate, batch_size, gradi
 

                 if clip_grad:

                     clip_grad_sched.step(hypernetwork.step)

-                

+

                 with devices.autocast():

                     x = batch.latent_sample.to(devices.device, non_blocking=pin_memory)

                     if use_weight:

@@ -658,14 +657,14 @@ def train_hypernetwork(id_task, hypernetwork_name, learn_rate, batch_size, gradi
 

                     _loss_step += loss.item()

                 scaler.scale(loss).backward()

-                

+

                 # go back until we reach gradient accumulation steps

                 if (j + 1) % gradient_step != 0:

                     continue

                 loss_logging.append(_loss_step)

                 if clip_grad:

                     clip_grad(weights, clip_grad_sched.learn_rate)

-                

+

                 scaler.step(optimizer)

                 scaler.update()

                 hypernetwork.step += 1

@@ -675,7 +674,7 @@ def train_hypernetwork(id_task, hypernetwork_name, learn_rate, batch_size, gradi
                 _loss_step = 0

 

                 steps_done = hypernetwork.step + 1

-                

+

                 epoch_num = hypernetwork.step // steps_per_epoch

                 epoch_step = hypernetwork.step % steps_per_epoch

 

diff --git a/modules/hypernetworks/ui.py b/modules/hypernetworks/ui.py
index 76599f5a..8b6255e2 100644
--- a/modules/hypernetworks/ui.py
+++ b/modules/hypernetworks/ui.py
@@ -1,19 +1,17 @@
 import html

-import os

-import re

 

 import gradio as gr

 import modules.hypernetworks.hypernetwork

 from modules import devices, sd_hijack, shared

 

 not_available = ["hardswish", "multiheadattention"]

-keys = list(x for x in modules.hypernetworks.hypernetwork.HypernetworkModule.activation_dict.keys() if x not in not_available)

+keys = [x for x in modules.hypernetworks.hypernetwork.HypernetworkModule.activation_dict if x not in not_available]

 

 

 def create_hypernetwork(name, enable_sizes, overwrite_old, layer_structure=None, activation_func=None, weight_init=None, add_layer_norm=False, use_dropout=False, dropout_structure=None):

     filename = modules.hypernetworks.hypernetwork.create_hypernetwork(name, enable_sizes, overwrite_old, layer_structure, activation_func, weight_init, add_layer_norm, use_dropout, dropout_structure)

 

-    return gr.Dropdown.update(choices=sorted([x for x in shared.hypernetworks.keys()])), f"Created: {filename}", ""

+    return gr.Dropdown.update(choices=sorted(shared.hypernetworks)), f"Created: {filename}", ""

 

 

 def train_hypernetwork(*args):

diff --git a/modules/images.py b/modules/images.py
index fd173829..b2de3662 100644
--- a/modules/images.py
+++ b/modules/images.py
@@ -13,17 +13,24 @@ import numpy as np
 import piexif

 import piexif.helper

 from PIL import Image, ImageFont, ImageDraw, PngImagePlugin

-from fonts.ttf import Roboto

 import string

 import json

 import hashlib

 

 from modules import sd_samplers, shared, script_callbacks, errors

-from modules.shared import opts, cmd_opts

+from modules.paths_internal import roboto_ttf_file

+from modules.shared import opts

 

 LANCZOS = (Image.Resampling.LANCZOS if hasattr(Image, 'Resampling') else Image.LANCZOS)

 

 

+def get_font(fontsize: int):

+    try:

+        return ImageFont.truetype(opts.font or roboto_ttf_file, fontsize)

+    except Exception:

+        return ImageFont.truetype(roboto_ttf_file, fontsize)

+

+

 def image_grid(imgs, batch_size=1, rows=None):

     if rows is None:

         if opts.n_rows > 0:

@@ -142,14 +149,8 @@ def draw_grid_annotations(im, width, height, hor_texts, ver_texts, margin=0):
                 lines.append(word)

         return lines

 

-    def get_font(fontsize):

-        try:

-            return ImageFont.truetype(opts.font or Roboto, fontsize)

-        except Exception:

-            return ImageFont.truetype(Roboto, fontsize)

-

     def draw_texts(drawing, draw_x, draw_y, lines, initial_fnt, initial_fontsize):

-        for i, line in enumerate(lines):

+        for line in lines:

             fnt = initial_fnt

             fontsize = initial_fontsize

             while drawing.multiline_textsize(line.text, font=fnt)[0] > line.allowed_width and fontsize > 0:

@@ -357,6 +358,7 @@ class FilenameGenerator:
         'generation_number': lambda self: NOTHING_AND_SKIP_PREVIOUS_TEXT if self.p.n_iter == 1 and self.p.batch_size == 1 else self.p.iteration * self.p.batch_size + self.p.batch_index + 1,

         'hasprompt': lambda self, *args: self.hasprompt(*args),  # accepts formats:[hasprompt<prompt1|default><prompt2>..]

         'clip_skip': lambda self: opts.data["CLIP_stop_at_last_layers"],

+        'denoising': lambda self: self.p.denoising_strength if self.p and self.p.denoising_strength else NOTHING_AND_SKIP_PREVIOUS_TEXT,

     }

     default_time_format = '%Y%m%d%H%M%S'

 

@@ -365,7 +367,7 @@ class FilenameGenerator:
         self.seed = seed

         self.prompt = prompt

         self.image = image

-        

+

     def hasprompt(self, *args):

         lower = self.prompt.lower()

         if self.p is None or self.prompt is None:

@@ -408,13 +410,13 @@ class FilenameGenerator:
         time_format = args[0] if len(args) > 0 and args[0] != "" else self.default_time_format

         try:

             time_zone = pytz.timezone(args[1]) if len(args) > 1 else None

-        except pytz.exceptions.UnknownTimeZoneError as _:

+        except pytz.exceptions.UnknownTimeZoneError:

             time_zone = None

 

         time_zone_time = time_datetime.astimezone(time_zone)

         try:

             formatted_time = time_zone_time.strftime(time_format)

-        except (ValueError, TypeError) as _:

+        except (ValueError, TypeError):

             formatted_time = time_zone_time.strftime(self.default_time_format)

 

         return sanitize_filename_part(formatted_time, replace_spaces=False)

@@ -466,14 +468,14 @@ def get_next_sequence_number(path, basename):
     """

     result = -1

     if basename != '':

-        basename = basename + "-"

+        basename = f"{basename}-"

 

     prefix_length = len(basename)

     for p in os.listdir(path):

         if p.startswith(basename):

-            l = os.path.splitext(p[prefix_length:])[0].split('-')  # splits the filename (removing the basename first if one is defined, so the sequence number is always the first element)

+            parts = os.path.splitext(p[prefix_length:])[0].split('-')  # splits the filename (removing the basename first if one is defined, so the sequence number is always the first element)

             try:

-                result = max(int(l[0]), result)

+                result = max(int(parts[0]), result)

             except ValueError:

                 pass

 

@@ -535,7 +537,7 @@ def save_image(image, path, basename, seed=None, prompt=None, extension='png', i
         add_number = opts.save_images_add_number or file_decoration == ''

 

         if file_decoration != "" and add_number:

-            file_decoration = "-" + file_decoration

+            file_decoration = f"-{file_decoration}"

 

         file_decoration = namegen.apply(file_decoration) + suffix

 

@@ -565,7 +567,7 @@ def save_image(image, path, basename, seed=None, prompt=None, extension='png', i
 

     def _atomically_save_image(image_to_save, filename_without_extension, extension):

         # save image with .tmp extension to avoid race condition when another process detects new image in the directory

-        temp_file_path = filename_without_extension + ".tmp"

+        temp_file_path = f"{filename_without_extension}.tmp"

         image_format = Image.registered_extensions()[extension]

 

         if extension.lower() == '.png':

@@ -625,7 +627,7 @@ def save_image(image, path, basename, seed=None, prompt=None, extension='png', i
     if opts.save_txt and info is not None:

         txt_fullfn = f"{fullfn_without_extension}.txt"

         with open(txt_fullfn, "w", encoding="utf8") as file:

-            file.write(info + "\n")

+            file.write(f"{info}\n")

     else:

         txt_fullfn = None

 

diff --git a/modules/img2img.py b/modules/img2img.py
index 56c846d6..d704bf90 100644
--- a/modules/img2img.py
+++ b/modules/img2img.py
@@ -1,19 +1,15 @@
-import math

 import os

-import sys

-import traceback

 

 import numpy as np

 from PIL import Image, ImageOps, ImageFilter, ImageEnhance, ImageChops, UnidentifiedImageError

 

-from modules import devices, sd_samplers

+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.ui import plaintext_to_html

-import modules.images as images

 import modules.scripts

 

 

@@ -48,7 +44,8 @@ def process_batch(p, input_dir, output_dir, inpaint_mask_dir, args):
 

         try:

             img = Image.open(image)

-        except UnidentifiedImageError:

+        except UnidentifiedImageError as e:

+            print(e)

             continue

         # Use the EXIF orientation of photos taken by smartphones.

         img = ImageOps.exif_transpose(img)

@@ -58,7 +55,7 @@ def process_batch(p, input_dir, output_dir, inpaint_mask_dir, args):
             # try to find corresponding mask for an image using simple filename matching

             mask_image_path = os.path.join(inpaint_mask_dir, os.path.basename(image))

             # if not found use first one ("same mask for all images" use-case)

-            if not mask_image_path in inpaint_masks:

+            if mask_image_path not in inpaint_masks:

                 mask_image_path = inpaint_masks[0]

             mask_image = Image.open(mask_image_path)

             p.image_mask = mask_image

diff --git a/modules/interrogate.py b/modules/interrogate.py
index e1665708..111b1322 100644
--- a/modules/interrogate.py
+++ b/modules/interrogate.py
@@ -11,7 +11,6 @@ import torch.hub
 from torchvision import transforms

 from torchvision.transforms.functional import InterpolationMode

 

-import modules.shared as shared

 from modules import devices, paths, shared, lowvram, modelloader, errors

 

 blip_image_eval_size = 384

@@ -28,7 +27,7 @@ def category_types():
 def download_default_clip_interrogate_categories(content_dir):

     print("Downloading CLIP categories...")

 

-    tmpdir = content_dir + "_tmp"

+    tmpdir = f"{content_dir}_tmp"

     category_types = ["artists", "flavors", "mediums", "movements"]

 

     try:

@@ -160,7 +159,7 @@ class InterrogateModels:
             text_array = text_array[0:int(shared.opts.interrogate_clip_dict_limit)]

 

         top_count = min(top_count, len(text_array))

-        text_tokens = clip.tokenize([text for text in text_array], truncate=True).to(devices.device_interrogate)

+        text_tokens = clip.tokenize(list(text_array), truncate=True).to(devices.device_interrogate)

         text_features = self.clip_model.encode_text(text_tokens).type(self.dtype)

         text_features /= text_features.norm(dim=-1, keepdim=True)

 

@@ -208,13 +207,13 @@ class InterrogateModels:
 

                 image_features /= image_features.norm(dim=-1, keepdim=True)

 

-                for name, topn, items in self.categories():

-                    matches = self.rank(image_features, items, top_count=topn)

+                for cat in self.categories():

+                    matches = self.rank(image_features, cat.items, top_count=cat.topn)

                     for match, score in matches:

                         if shared.opts.interrogate_return_ranks:

                             res += f", ({match}:{score/100:.3f})"

                         else:

-                            res += ", " + match

+                            res += f", {match}"

 

         except Exception:

             print("Error interrogating", file=sys.stderr)

diff --git a/modules/localization.py b/modules/localization.py
index f6a6f2fb..ee9c65e7 100644
--- a/modules/localization.py
+++ b/modules/localization.py
@@ -23,7 +23,7 @@ def list_localizations(dirname):
         localizations[fn] = file.path

 

 

-def localization_js(current_localization_name):

+def localization_js(current_localization_name: str) -> str:

     fn = localizations.get(current_localization_name, None)

     data = {}

     if fn is not None:

@@ -34,4 +34,4 @@ def localization_js(current_localization_name):
             print(f"Error loading localization from {fn}:", file=sys.stderr)

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

 

-    return f"var localization = {json.dumps(data)}\n"

+    return f"window.localization = {json.dumps(data)}"

diff --git a/modules/mac_specific.py b/modules/mac_specific.py
index 6fe8dea0..d74c6b95 100644
--- a/modules/mac_specific.py
+++ b/modules/mac_specific.py
@@ -1,6 +1,5 @@
 import torch
 import platform
-from modules import paths
 from modules.sd_hijack_utils import CondFunc
 from packaging import version
 
@@ -43,7 +42,7 @@ if has_mps:
         # MPS workaround for https://github.com/pytorch/pytorch/issues/79383
         CondFunc('torch.Tensor.to', lambda orig_func, self, *args, **kwargs: orig_func(self.contiguous(), *args, **kwargs),
                                                           lambda _, self, *args, **kwargs: self.device.type != 'mps' and (args and isinstance(args[0], torch.device) and args[0].type == 'mps' or isinstance(kwargs.get('device'), torch.device) and kwargs['device'].type == 'mps'))
-        # MPS workaround for https://github.com/pytorch/pytorch/issues/80800 
+        # MPS workaround for https://github.com/pytorch/pytorch/issues/80800
         CondFunc('torch.nn.functional.layer_norm', lambda orig_func, *args, **kwargs: orig_func(*([args[0].contiguous()] + list(args[1:])), **kwargs),
                                                                                         lambda _, *args, **kwargs: args and isinstance(args[0], torch.Tensor) and args[0].device.type == 'mps')
         # MPS workaround for https://github.com/pytorch/pytorch/issues/90532
@@ -54,6 +53,11 @@ if has_mps:
         CondFunc('torch.cumsum', cumsum_fix_func, None)
         CondFunc('torch.Tensor.cumsum', cumsum_fix_func, None)
         CondFunc('torch.narrow', lambda orig_func, *args, **kwargs: orig_func(*args, **kwargs).clone(), None)
-    if version.parse(torch.__version__) == version.parse("2.0"):
+
         # MPS workaround for https://github.com/pytorch/pytorch/issues/96113
-        CondFunc('torch.nn.functional.layer_norm', lambda orig_func, x, normalized_shape, weight, bias, eps, **kwargs: orig_func(x.float(), normalized_shape, weight.float() if weight is not None else None, bias.float() if bias is not None else bias, eps).to(x.dtype), lambda *args, **kwargs: len(args) == 6)
+        CondFunc('torch.nn.functional.layer_norm', lambda orig_func, x, normalized_shape, weight, bias, eps, **kwargs: orig_func(x.float(), normalized_shape, weight.float() if weight is not None else None, bias.float() if bias is not None else bias, eps).to(x.dtype), lambda _, input, *args, **kwargs: len(args) == 4 and input.device.type == 'mps')
+
+        # MPS workaround for https://github.com/pytorch/pytorch/issues/92311
+        if platform.processor() == 'i386':
+            for funcName in ['torch.argmax', 'torch.Tensor.argmax']:
+                CondFunc(funcName, lambda _, input, *args, **kwargs: torch.max(input.float() if input.dtype == torch.int64 else input, *args, **kwargs)[1], lambda _, input, *args, **kwargs: input.device.type == 'mps')
diff --git a/modules/masking.py b/modules/masking.py
index a5c4d2da..be9f84c7 100644
--- a/modules/masking.py
+++ b/modules/masking.py
@@ -4,7 +4,7 @@ from PIL import Image, ImageFilter, ImageOps
 def get_crop_region(mask, pad=0):

     """finds a rectangular region that contains all masked ares in an image. Returns (x1, y1, x2, y2) coordinates of the rectangle.

     For example, if a user has painted the top-right part of a 512x512 image", the result may be (256, 0, 512, 256)"""

-    

+

     h, w = mask.shape

 

     crop_left = 0

diff --git a/modules/modelloader.py b/modules/modelloader.py
index 522affc6..2a479bcb 100644
--- a/modules/modelloader.py
+++ b/modules/modelloader.py
@@ -1,4 +1,3 @@
-import glob
 import os
 import shutil
 import importlib
@@ -22,9 +21,6 @@ def load_models(model_path: str, model_url: str = None, command_path: str = None
     """
     output = []
 
-    if ext_filter is None:
-        ext_filter = []
-
     try:
         places = []
 
@@ -39,22 +35,14 @@ def load_models(model_path: str, model_url: str = None, command_path: str = None
         places.append(model_path)
 
         for place in places:
-            if os.path.exists(place):
-                for file in glob.iglob(place + '**/**', recursive=True):
-                    full_path = file
-                    if os.path.isdir(full_path):
-                        continue
-                    if os.path.islink(full_path) and not os.path.exists(full_path):
-                        print(f"Skipping broken symlink: {full_path}")
-                        continue
-                    if ext_blacklist is not None and any([full_path.endswith(x) for x in ext_blacklist]):
-                        continue
-                    if len(ext_filter) != 0:
-                        model_name, extension = os.path.splitext(file)
-                        if extension not in ext_filter:
-                            continue
-                    if file not in output:
-                        output.append(full_path)
+            for full_path in shared.walk_files(place, allowed_extensions=ext_filter):
+                if os.path.islink(full_path) and not os.path.exists(full_path):
+                    print(f"Skipping broken symlink: {full_path}")
+                    continue
+                if ext_blacklist is not None and any(full_path.endswith(x) for x in ext_blacklist):
+                    continue
+                if full_path not in output:
+                    output.append(full_path)
 
         if model_url is not None and len(output) == 0:
             if download_name is not None:
@@ -119,32 +107,15 @@ def move_files(src_path: str, dest_path: str, ext_filter: str = None):
                     print(f"Moving {file} from {src_path} to {dest_path}.")
                     try:
                         shutil.move(fullpath, dest_path)
-                    except:
+                    except Exception:
                         pass
             if len(os.listdir(src_path)) == 0:
                 print(f"Removing empty folder: {src_path}")
                 shutil.rmtree(src_path, True)
-    except:
+    except Exception:
         pass
 
 
-builtin_upscaler_classes = []
-forbidden_upscaler_classes = set()
-
-
-def list_builtin_upscalers():
-    load_upscalers()
-
-    builtin_upscaler_classes.clear()
-    builtin_upscaler_classes.extend(Upscaler.__subclasses__())
-
-
-def forbid_loaded_nonbuiltin_upscalers():
-    for cls in Upscaler.__subclasses__():
-        if cls not in builtin_upscaler_classes:
-            forbidden_upscaler_classes.add(cls)
-
-
 def load_upscalers():
     # We can only do this 'magic' method to dynamically load upscalers if they are referenced,
     # so we'll try to import any _model.py files before looking in __subclasses__
@@ -155,15 +126,22 @@ def load_upscalers():
             full_model = f"modules.{model_name}_model"
             try:
                 importlib.import_module(full_model)
-            except:
+            except Exception:
                 pass
 
     datas = []
     commandline_options = vars(shared.cmd_opts)
-    for cls in Upscaler.__subclasses__():
-        if cls in forbidden_upscaler_classes:
-            continue
 
+    # some of upscaler classes will not go away after reloading their modules, and we'll end
+    # up with two copies of those classes. The newest copy will always be the last in the list,
+    # so we go from end to beginning and ignore duplicates
+    used_classes = {}
+    for cls in reversed(Upscaler.__subclasses__()):
+        classname = str(cls)
+        if classname not in used_classes:
+            used_classes[classname] = cls
+
+    for cls in reversed(used_classes.values()):
         name = cls.__name__
         cmd_name = f"{name.lower().replace('upscaler', '')}_models_path"
         scaler = cls(commandline_options.get(cmd_name, None))
diff --git a/modules/models/diffusion/ddpm_edit.py b/modules/models/diffusion/ddpm_edit.py
index f3d49c44..3fb76b65 100644
--- a/modules/models/diffusion/ddpm_edit.py
+++ b/modules/models/diffusion/ddpm_edit.py
@@ -52,7 +52,7 @@ class DDPM(pl.LightningModule):
                  beta_schedule="linear",
                  loss_type="l2",
                  ckpt_path=None,
-                 ignore_keys=[],
+                 ignore_keys=None,
                  load_only_unet=False,
                  monitor="val/loss",
                  use_ema=True,
@@ -107,7 +107,7 @@ class DDPM(pl.LightningModule):
             print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
 
         if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)
+            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys or [], only_model=load_only_unet)
 
             # If initialing from EMA-only checkpoint, create EMA model after loading.
             if self.use_ema and not load_ema:
@@ -194,7 +194,9 @@ class DDPM(pl.LightningModule):
                 if context is not None:
                     print(f"{context}: Restored training weights")
 
-    def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
+    def init_from_ckpt(self, path, ignore_keys=None, only_model=False):
+        ignore_keys = ignore_keys or []
+
         sd = torch.load(path, map_location="cpu")
         if "state_dict" in list(sd.keys()):
             sd = sd["state_dict"]
@@ -223,7 +225,7 @@ class DDPM(pl.LightningModule):
         for k in keys:
             for ik in ignore_keys:
                 if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
+                    print(f"Deleting key {k} from state_dict.")
                     del sd[k]
         missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(
             sd, strict=False)
@@ -386,7 +388,7 @@ class DDPM(pl.LightningModule):
         _, loss_dict_no_ema = self.shared_step(batch)
         with self.ema_scope():
             _, loss_dict_ema = self.shared_step(batch)
-            loss_dict_ema = {key + '_ema': loss_dict_ema[key] for key in loss_dict_ema}
+            loss_dict_ema = {f"{key}_ema": loss_dict_ema[key] for key in loss_dict_ema}
         self.log_dict(loss_dict_no_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
         self.log_dict(loss_dict_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
 
@@ -403,7 +405,7 @@ class DDPM(pl.LightningModule):
 
     @torch.no_grad()
     def log_images(self, batch, N=8, n_row=2, sample=True, return_keys=None, **kwargs):
-        log = dict()
+        log = {}
         x = self.get_input(batch, self.first_stage_key)
         N = min(x.shape[0], N)
         n_row = min(x.shape[0], n_row)
@@ -411,7 +413,7 @@ class DDPM(pl.LightningModule):
         log["inputs"] = x
 
         # get diffusion row
-        diffusion_row = list()
+        diffusion_row = []
         x_start = x[:n_row]
 
         for t in range(self.num_timesteps):
@@ -473,13 +475,13 @@ class LatentDiffusion(DDPM):
             conditioning_key = None
         ckpt_path = kwargs.pop("ckpt_path", None)
         ignore_keys = kwargs.pop("ignore_keys", [])
-        super().__init__(conditioning_key=conditioning_key, *args, load_ema=load_ema, **kwargs)
+        super().__init__(*args, conditioning_key=conditioning_key, load_ema=load_ema, **kwargs)
         self.concat_mode = concat_mode
         self.cond_stage_trainable = cond_stage_trainable
         self.cond_stage_key = cond_stage_key
         try:
             self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1
-        except:
+        except Exception:
             self.num_downs = 0
         if not scale_by_std:
             self.scale_factor = scale_factor
@@ -891,16 +893,6 @@ class LatentDiffusion(DDPM):
                 c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))
         return self.p_losses(x, c, t, *args, **kwargs)
 
-    def _rescale_annotations(self, bboxes, crop_coordinates):  # TODO: move to dataset
-        def rescale_bbox(bbox):
-            x0 = clamp((bbox[0] - crop_coordinates[0]) / crop_coordinates[2])
-            y0 = clamp((bbox[1] - crop_coordinates[1]) / crop_coordinates[3])
-            w = min(bbox[2] / crop_coordinates[2], 1 - x0)
-            h = min(bbox[3] / crop_coordinates[3], 1 - y0)
-            return x0, y0, w, h
-
-        return [rescale_bbox(b) for b in bboxes]
-
     def apply_model(self, x_noisy, t, cond, return_ids=False):
 
         if isinstance(cond, dict):
@@ -1140,7 +1132,7 @@ class LatentDiffusion(DDPM):
         if cond is not None:
             if isinstance(cond, dict):
                 cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
-                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
+                [x[:batch_size] for x in cond[key]] for key in cond}
             else:
                 cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
 
@@ -1171,8 +1163,10 @@ class LatentDiffusion(DDPM):
 
             if i % log_every_t == 0 or i == timesteps - 1:
                 intermediates.append(x0_partial)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
+            if callback:
+                callback(i)
+            if img_callback:
+                img_callback(img, i)
         return img, intermediates
 
     @torch.no_grad()
@@ -1219,8 +1213,10 @@ class LatentDiffusion(DDPM):
 
             if i % log_every_t == 0 or i == timesteps - 1:
                 intermediates.append(img)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
+            if callback:
+                callback(i)
+            if img_callback:
+                img_callback(img, i)
 
         if return_intermediates:
             return img, intermediates
@@ -1235,7 +1231,7 @@ class LatentDiffusion(DDPM):
         if cond is not None:
             if isinstance(cond, dict):
                 cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
-                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
+                [x[:batch_size] for x in cond[key]] for key in cond}
             else:
                 cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
         return self.p_sample_loop(cond,
@@ -1267,7 +1263,7 @@ class LatentDiffusion(DDPM):
 
         use_ddim = False
 
-        log = dict()
+        log = {}
         z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,
                                            return_first_stage_outputs=True,
                                            force_c_encode=True,
@@ -1295,7 +1291,7 @@ class LatentDiffusion(DDPM):
 
         if plot_diffusion_rows:
             # get diffusion row
-            diffusion_row = list()
+            diffusion_row = []
             z_start = z[:n_row]
             for t in range(self.num_timesteps):
                 if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
@@ -1337,7 +1333,7 @@ class LatentDiffusion(DDPM):
 
             if inpaint:
                 # make a simple center square
-                b, h, w = z.shape[0], z.shape[2], z.shape[3]
+                h, w = z.shape[2], z.shape[3]
                 mask = torch.ones(N, h, w).to(self.device)
                 # zeros will be filled in
                 mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0.
@@ -1439,10 +1435,10 @@ class Layout2ImgDiffusion(LatentDiffusion):
     # TODO: move all layout-specific hacks to this class
     def __init__(self, cond_stage_key, *args, **kwargs):
         assert cond_stage_key == 'coordinates_bbox', 'Layout2ImgDiffusion only for cond_stage_key="coordinates_bbox"'
-        super().__init__(cond_stage_key=cond_stage_key, *args, **kwargs)
+        super().__init__(*args, cond_stage_key=cond_stage_key, **kwargs)
 
     def log_images(self, batch, N=8, *args, **kwargs):
-        logs = super().log_images(batch=batch, N=N, *args, **kwargs)
+        logs = super().log_images(*args, batch=batch, N=N, **kwargs)
 
         key = 'train' if self.training else 'validation'
         dset = self.trainer.datamodule.datasets[key]
diff --git a/modules/models/diffusion/uni_pc/__init__.py b/modules/models/diffusion/uni_pc/__init__.py
index e1265e3f..dbb35964 100644
--- a/modules/models/diffusion/uni_pc/__init__.py
+++ b/modules/models/diffusion/uni_pc/__init__.py
@@ -1 +1 @@
-from .sampler import UniPCSampler
+from .sampler import UniPCSampler  # noqa: F401
diff --git a/modules/models/diffusion/uni_pc/sampler.py b/modules/models/diffusion/uni_pc/sampler.py
index a241c8a7..0a9defa1 100644
--- a/modules/models/diffusion/uni_pc/sampler.py
+++ b/modules/models/diffusion/uni_pc/sampler.py
@@ -54,7 +54,8 @@ class UniPCSampler(object):
         if conditioning is not None:
             if isinstance(conditioning, dict):
                 ctmp = conditioning[list(conditioning.keys())[0]]
-                while isinstance(ctmp, list): ctmp = ctmp[0]
+                while isinstance(ctmp, list):
+                    ctmp = ctmp[0]
                 cbs = ctmp.shape[0]
                 if cbs != batch_size:
                     print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
diff --git a/modules/models/diffusion/uni_pc/uni_pc.py b/modules/models/diffusion/uni_pc/uni_pc.py
index eb5f4e76..d257a728 100644
--- a/modules/models/diffusion/uni_pc/uni_pc.py
+++ b/modules/models/diffusion/uni_pc/uni_pc.py
@@ -1,7 +1,6 @@
 import torch
-import torch.nn.functional as F
 import math
-from tqdm.auto import trange
+import tqdm
 
 
 class NoiseScheduleVP:
@@ -94,7 +93,7 @@ class NoiseScheduleVP:
         """
 
         if schedule not in ['discrete', 'linear', 'cosine']:
-            raise ValueError("Unsupported noise schedule {}. The schedule needs to be 'discrete' or 'linear' or 'cosine'".format(schedule))
+            raise ValueError(f"Unsupported noise schedule {schedule}. The schedule needs to be 'discrete' or 'linear' or 'cosine'")
 
         self.schedule = schedule
         if schedule == 'discrete':
@@ -179,13 +178,13 @@ def model_wrapper(
     model,
     noise_schedule,
     model_type="noise",
-    model_kwargs={},
+    model_kwargs=None,
     guidance_type="uncond",
     #condition=None,
     #unconditional_condition=None,
     guidance_scale=1.,
     classifier_fn=None,
-    classifier_kwargs={},
+    classifier_kwargs=None,
 ):
     """Create a wrapper function for the noise prediction model.
 
@@ -276,6 +275,9 @@ def model_wrapper(
         A noise prediction model that accepts the noised data and the continuous time as the inputs.
     """
 
+    model_kwargs = model_kwargs or {}
+    classifier_kwargs = classifier_kwargs or {}
+
     def get_model_input_time(t_continuous):
         """
         Convert the continuous-time `t_continuous` (in [epsilon, T]) to the model input time.
@@ -342,7 +344,7 @@ def model_wrapper(
                 t_in = torch.cat([t_continuous] * 2)
                 if isinstance(condition, dict):
                     assert isinstance(unconditional_condition, dict)
-                    c_in = dict()
+                    c_in = {}
                     for k in condition:
                         if isinstance(condition[k], list):
                             c_in[k] = [torch.cat([
@@ -353,7 +355,7 @@ def model_wrapper(
                                 unconditional_condition[k],
                                 condition[k]])
                 elif isinstance(condition, list):
-                    c_in = list()
+                    c_in = []
                     assert isinstance(unconditional_condition, list)
                     for i in range(len(condition)):
                         c_in.append(torch.cat([unconditional_condition[i], condition[i]]))
@@ -469,7 +471,7 @@ class UniPC:
             t = torch.linspace(t_T**(1. / t_order), t_0**(1. / t_order), N + 1).pow(t_order).to(device)
             return t
         else:
-            raise ValueError("Unsupported skip_type {}, need to be 'logSNR' or 'time_uniform' or 'time_quadratic'".format(skip_type))
+            raise ValueError(f"Unsupported skip_type {skip_type}, need to be 'logSNR' or 'time_uniform' or 'time_quadratic'")
 
     def get_orders_and_timesteps_for_singlestep_solver(self, steps, order, skip_type, t_T, t_0, device):
         """
@@ -757,40 +759,44 @@ class UniPC:
                 vec_t = timesteps[0].expand((x.shape[0]))
                 model_prev_list = [self.model_fn(x, vec_t)]
                 t_prev_list = [vec_t]
-                # Init the first `order` values by lower order multistep DPM-Solver.
-                for init_order in range(1, order):
-                    vec_t = timesteps[init_order].expand(x.shape[0])
-                    x, model_x = self.multistep_uni_pc_update(x, model_prev_list, t_prev_list, vec_t, init_order, use_corrector=True)
-                    if model_x is None:
-                        model_x = self.model_fn(x, vec_t)
-                    if self.after_update is not None:
-                        self.after_update(x, model_x)
-                    model_prev_list.append(model_x)
-                    t_prev_list.append(vec_t)
-                for step in trange(order, steps + 1):
-                    vec_t = timesteps[step].expand(x.shape[0])
-                    if lower_order_final:
-                        step_order = min(order, steps + 1 - step)
-                    else:
-                        step_order = order
-                    #print('this step order:', step_order)
-                    if step == steps:
-                        #print('do not run corrector at the last step')
-                        use_corrector = False
-                    else:
-                        use_corrector = True
-                    x, model_x =  self.multistep_uni_pc_update(x, model_prev_list, t_prev_list, vec_t, step_order, use_corrector=use_corrector)
-                    if self.after_update is not None:
-                        self.after_update(x, model_x)
-                    for i in range(order - 1):
-                        t_prev_list[i] = t_prev_list[i + 1]
-                        model_prev_list[i] = model_prev_list[i + 1]
-                    t_prev_list[-1] = vec_t
-                    # We do not need to evaluate the final model value.
-                    if step < steps:
+                with tqdm.tqdm(total=steps) as pbar:
+                    # Init the first `order` values by lower order multistep DPM-Solver.
+                    for init_order in range(1, order):
+                        vec_t = timesteps[init_order].expand(x.shape[0])
+                        x, model_x = self.multistep_uni_pc_update(x, model_prev_list, t_prev_list, vec_t, init_order, use_corrector=True)
                         if model_x is None:
                             model_x = self.model_fn(x, vec_t)
-                        model_prev_list[-1] = model_x
+                        if self.after_update is not None:
+                            self.after_update(x, model_x)
+                        model_prev_list.append(model_x)
+                        t_prev_list.append(vec_t)
+                        pbar.update()
+
+                    for step in range(order, steps + 1):
+                        vec_t = timesteps[step].expand(x.shape[0])
+                        if lower_order_final:
+                            step_order = min(order, steps + 1 - step)
+                        else:
+                            step_order = order
+                        #print('this step order:', step_order)
+                        if step == steps:
+                            #print('do not run corrector at the last step')
+                            use_corrector = False
+                        else:
+                            use_corrector = True
+                        x, model_x =  self.multistep_uni_pc_update(x, model_prev_list, t_prev_list, vec_t, step_order, use_corrector=use_corrector)
+                        if self.after_update is not None:
+                            self.after_update(x, model_x)
+                        for i in range(order - 1):
+                            t_prev_list[i] = t_prev_list[i + 1]
+                            model_prev_list[i] = model_prev_list[i + 1]
+                        t_prev_list[-1] = vec_t
+                        # We do not need to evaluate the final model value.
+                        if step < steps:
+                            if model_x is None:
+                                model_x = self.model_fn(x, vec_t)
+                            model_prev_list[-1] = model_x
+                        pbar.update()
         else:
             raise NotImplementedError()
         if denoise_to_zero:
diff --git a/modules/ngrok.py b/modules/ngrok.py
index 1ad7989b..67a74e85 100644
--- a/modules/ngrok.py
+++ b/modules/ngrok.py
@@ -7,13 +7,13 @@ def connect(token, port, region):
     else:
         if ':' in token:
             # token = authtoken:username:password
-            account = token.split(':')[1] + ':' + token.split(':')[-1]
-            token = token.split(':')[0]
+            token, username, password = token.split(':', 2)
+            account = f"{username}:{password}"
 
     config = conf.PyngrokConfig(
         auth_token=token, region=region
     )
-    
+
     # Guard for existing tunnels
     existing = ngrok.get_tunnels(pyngrok_config=config)
     if existing:
@@ -24,7 +24,7 @@ def connect(token, port, region):
                 print(f'ngrok has already been connected to localhost:{port}! URL: {public_url}\n'
                     'You can use this link after the launch is complete.')
                 return
-    
+
     try:
         if account is None:
             public_url = ngrok.connect(port, pyngrok_config=config, bind_tls=True).public_url
diff --git a/modules/paths.py b/modules/paths.py
index 0e1e00e7..5f6474c0 100644
--- a/modules/paths.py
+++ b/modules/paths.py
@@ -1,8 +1,8 @@
 import os

 import sys

-from modules.paths_internal import models_path, script_path, data_path, extensions_dir, extensions_builtin_dir

+from modules.paths_internal import models_path, script_path, data_path, extensions_dir, extensions_builtin_dir  # noqa: F401

 

-import modules.safe

+import modules.safe  # noqa: F401

 

 

 # data_path = cmd_opts_pre.data

@@ -16,7 +16,7 @@ for possible_sd_path in possible_sd_paths:
         sd_path = os.path.abspath(possible_sd_path)

         break

 

-assert sd_path is not None, "Couldn't find Stable Diffusion in any of: " + str(possible_sd_paths)

+assert sd_path is not None, f"Couldn't find Stable Diffusion in any of: {possible_sd_paths}"

 

 path_dirs = [

     (sd_path, 'ldm', 'Stable Diffusion', []),

diff --git a/modules/paths_internal.py b/modules/paths_internal.py
index 6765bafe..005a9b0a 100644
--- a/modules/paths_internal.py
+++ b/modules/paths_internal.py
@@ -2,8 +2,14 @@
 

 import argparse

 import os

+import sys

+import shlex

 

-script_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))

+commandline_args = os.environ.get('COMMANDLINE_ARGS', "")

+sys.argv += shlex.split(commandline_args)

+

+modules_path = os.path.dirname(os.path.realpath(__file__))

+script_path = os.path.dirname(modules_path)

 

 sd_configs_path = os.path.join(script_path, "configs")

 sd_default_config = os.path.join(sd_configs_path, "v1-inference.yaml")

@@ -12,7 +18,7 @@ default_sd_model_file = sd_model_file
 

 # Parse the --data-dir flag first so we can use it as a base for our other argument default values

 parser_pre = argparse.ArgumentParser(add_help=False)

-parser_pre.add_argument("--data-dir", type=str, default=os.path.dirname(os.path.dirname(os.path.realpath(__file__))), help="base path where all user data is stored",)

+parser_pre.add_argument("--data-dir", type=str, default=os.path.dirname(modules_path), help="base path where all user data is stored", )

 cmd_opts_pre = parser_pre.parse_known_args()[0]

 

 data_path = cmd_opts_pre.data_dir

@@ -21,3 +27,5 @@ models_path = os.path.join(data_path, "models")
 extensions_dir = os.path.join(data_path, "extensions")

 extensions_builtin_dir = os.path.join(script_path, "extensions-builtin")

 config_states_dir = os.path.join(script_path, "config_states")

+

+roboto_ttf_file = os.path.join(modules_path, 'Roboto-Regular.ttf')

diff --git a/modules/processing.py b/modules/processing.py
index e8808beb..94fe2625 100644
--- a/modules/processing.py
+++ b/modules/processing.py
@@ -2,7 +2,6 @@ import json
 import math

 import os

 import sys

-import warnings

 import hashlib

 

 import torch

@@ -11,10 +10,10 @@ from PIL import Image, ImageFilter, ImageOps
 import random

 import cv2

 from skimage import exposure

-from typing import Any, Dict, List, Optional

+from typing import Any, Dict, List

 

 import modules.sd_hijack

-from modules import devices, prompt_parser, masking, sd_samplers, lowvram, generation_parameters_copypaste, script_callbacks, extra_networks, sd_vae_approx, scripts

+from modules import devices, prompt_parser, masking, sd_samplers, lowvram, generation_parameters_copypaste, extra_networks, sd_vae_approx, scripts

 from modules.sd_hijack import model_hijack

 from modules.shared import opts, cmd_opts, state

 import modules.shared as shared

@@ -30,6 +29,13 @@ from ldm.models.diffusion.ddpm import LatentDepth2ImageDiffusion
 

 from einops import repeat, rearrange

 from blendmodes.blend import blendLayers, BlendType

+import tomesd

+

+# add a logger for the processing module

+logger = logging.getLogger(__name__)

+# manually set output level here since there is no option to do so yet through launch options

+# logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)s %(name)s %(message)s')

+

 

 # some of those options should not be changed at all because they would break the model, so I removed them from options.

 opt_C = 4

@@ -165,7 +171,7 @@ class StableDiffusionProcessing:
         self.all_subseeds = None

         self.iteration = 0

         self.is_hr_pass = False

-        

+

 

     @property

     def sd_model(self):

@@ -458,10 +464,21 @@ def fix_seed(p):
     p.subseed = get_fixed_seed(p.subseed)

 

 

+def program_version():

+    import launch

+

+    res = launch.git_tag()

+    if res == "<none>":

+        res = None

+

+    return res

+

+

 def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments=None, iteration=0, position_in_batch=0):

     index = position_in_batch + iteration * p.batch_size

 

     clip_skip = getattr(p, 'clip_skip', opts.CLIP_stop_at_last_layers)

+    enable_hr = getattr(p, 'enable_hr', False)

 

     generation_params = {

         "Steps": p.steps,

@@ -480,16 +497,19 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments=None, iter
         "Conditional mask weight": getattr(p, "inpainting_mask_weight", shared.opts.inpainting_mask_weight) if p.is_using_inpainting_conditioning else None,

         "Clip skip": None if clip_skip <= 1 else clip_skip,

         "ENSD": None if opts.eta_noise_seed_delta == 0 else opts.eta_noise_seed_delta,

+        "Token merging ratio": None if opts.token_merging_ratio == 0 else opts.token_merging_ratio,

+        "Token merging ratio hr": None if not enable_hr or opts.token_merging_ratio_hr == 0 else opts.token_merging_ratio_hr,

         "Init image hash": getattr(p, 'init_img_hash', None),

         "RNG": opts.randn_source if opts.randn_source != "GPU" else None,

         "NGMS": None if p.s_min_uncond == 0 else p.s_min_uncond,

+        "Version": program_version() if opts.add_version_to_infotext else None,

     }

 

     generation_params.update(p.extra_generation_params)

 

     generation_params_text = ", ".join([k if k == v else f'{k}: {generation_parameters_copypaste.quote(v)}' for k, v in generation_params.items() if v is not None])

 

-    negative_prompt_text = "\nNegative prompt: " + p.all_negative_prompts[index] if p.all_negative_prompts[index] else ""

+    negative_prompt_text = f"\nNegative prompt: {p.all_negative_prompts[index]}" if p.all_negative_prompts[index] else ""

 

     return f"{all_prompts[index]}{negative_prompt_text}\n{generation_params_text}".strip()

 

@@ -512,9 +532,18 @@ def process_images(p: StableDiffusionProcessing) -> Processed:
             if k == 'sd_vae':

                 sd_vae.reload_vae_weights()

 

+        if opts.token_merging_ratio > 0:

+            sd_models.apply_token_merging(sd_model=p.sd_model, hr=False)

+            logger.debug(f"Token merging applied to first pass. Ratio: '{opts.token_merging_ratio}'")

+

         res = process_images_inner(p)

 

     finally:

+        # undo model optimizations made by tomesd

+        if opts.token_merging_ratio > 0:

+            tomesd.remove_patch(p.sd_model)

+            logger.debug('Token merging model optimizations removed')

+

         # restore opts to original state

         if p.override_settings_restore_afterwards:

             for k, v in stored_opts.items():

@@ -653,7 +682,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             if not shared.opts.dont_fix_second_order_samplers_schedule:

                 try:

                     step_multiplier = 2 if sd_samplers.all_samplers_map.get(p.sampler_name).aliases[0] in ['k_dpmpp_2s_a', 'k_dpmpp_2s_a_ka', 'k_dpmpp_sde', 'k_dpmpp_sde_ka', 'k_dpm_2', 'k_dpm_2_a', 'k_heun'] else 1

-                except:

+                except Exception:

                     pass

             uc = get_conds_with_caching(prompt_parser.get_learned_conditioning, negative_prompts, p.steps * step_multiplier, cached_uc)

             c = get_conds_with_caching(prompt_parser.get_multicond_learned_conditioning, prompts, p.steps * step_multiplier, cached_c)

@@ -769,7 +798,16 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
 

     devices.torch_gc()

 

-    res = Processed(p, output_images, p.all_seeds[0], infotext(), comments="".join(["\n\n" + x for x in comments]), subseed=p.all_subseeds[0], index_of_first_image=index_of_first_image, infotexts=infotexts)

+    res = Processed(

+        p,

+        images_list=output_images,

+        seed=p.all_seeds[0],

+        info=infotext(),

+        comments="".join(f"\n\n{comment}" for comment in comments),

+        subseed=p.all_subseeds[0],

+        index_of_first_image=index_of_first_image,

+        infotexts=infotexts,

+    )

 

     if p.scripts is not None:

         p.scripts.postprocess(p, res)

@@ -958,8 +996,22 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
         x = None

         devices.torch_gc()

 

+        # apply token merging optimizations from tomesd for high-res pass

+        if opts.token_merging_ratio_hr > 0:

+            # in case the user has used separate merge ratios

+            if opts.token_merging_ratio > 0:

+                tomesd.remove_patch(self.sd_model)

+                logger.debug('Adjusting token merging ratio for high-res pass')

+

+            sd_models.apply_token_merging(sd_model=self.sd_model, hr=True)

+            logger.debug(f"Applied token merging for high-res pass. Ratio: '{opts.token_merging_ratio_hr}'")

+

         samples = self.sampler.sample_img2img(self, samples, noise, conditioning, unconditional_conditioning, steps=self.hr_second_pass_steps or self.steps, image_conditioning=image_conditioning)

 

+        if opts.token_merging_ratio_hr > 0 or opts.token_merging_ratio > 0:

+            tomesd.remove_patch(self.sd_model)

+            logger.debug('Removed token merging optimizations from model')

+

         self.is_hr_pass = False

 

         return samples

diff --git a/modules/progress.py b/modules/progress.py
index 5655346b..269863c9 100644
--- a/modules/progress.py
+++ b/modules/progress.py
@@ -95,8 +95,16 @@ def progressapi(req: ProgressRequest):
         image = shared.state.current_image

         if image is not None:

             buffered = io.BytesIO()

-            image.save(buffered, format="png")

-            live_preview = 'data:image/png;base64,' + base64.b64encode(buffered.getvalue()).decode("ascii")

+

+            if opts.live_previews_image_format == "png":

+                # using optimize for large images takes an enormous amount of time

+                save_kwargs = {"optimize": max(*image.size) > 256}

+            else:

+                save_kwargs = {}

+

+            image.save(buffered, format=opts.live_previews_image_format, **save_kwargs)

+            base64_image = base64.b64encode(buffered.getvalue()).decode('ascii')

+            live_preview = f"data:image/{opts.live_previews_image_format};base64,{base64_image}"

             id_live_preview = shared.state.id_live_preview

         else:

             live_preview = None

diff --git a/modules/prompt_parser.py b/modules/prompt_parser.py
index 69665372..b4aff704 100644
--- a/modules/prompt_parser.py
+++ b/modules/prompt_parser.py
@@ -54,18 +54,21 @@ def get_learned_conditioning_prompt_schedules(prompts, steps):
     """

 

     def collect_steps(steps, tree):

-        l = [steps]

+        res = [steps]

+

         class CollectSteps(lark.Visitor):

             def scheduled(self, tree):

                 tree.children[-1] = float(tree.children[-1])

                 if tree.children[-1] < 1:

                     tree.children[-1] *= steps

                 tree.children[-1] = min(steps, int(tree.children[-1]))

-                l.append(tree.children[-1])

+                res.append(tree.children[-1])

+

             def alternate(self, tree):

-                l.extend(range(1, steps+1))

+                res.extend(range(1, steps+1))

+

         CollectSteps().visit(tree)

-        return sorted(set(l))

+        return sorted(set(res))

 

     def at_step(step, tree):

         class AtStep(lark.Transformer):

@@ -92,7 +95,7 @@ def get_learned_conditioning_prompt_schedules(prompts, steps):
     def get_schedule(prompt):

         try:

             tree = schedule_parser.parse(prompt)

-        except lark.exceptions.LarkError as e:

+        except lark.exceptions.LarkError:

             if 0:

                 import traceback

                 traceback.print_exc()

@@ -140,7 +143,7 @@ def get_learned_conditioning(model, prompts, steps):
         conds = model.get_learned_conditioning(texts)

 

         cond_schedule = []

-        for i, (end_at_step, text) in enumerate(prompt_schedule):

+        for i, (end_at_step, _) in enumerate(prompt_schedule):

             cond_schedule.append(ScheduledPromptConditioning(end_at_step, conds[i]))

 

         cache[prompt] = cond_schedule

@@ -216,8 +219,8 @@ def reconstruct_cond_batch(c: List[List[ScheduledPromptConditioning]], current_s
     res = torch.zeros((len(c),) + param.shape, device=param.device, dtype=param.dtype)

     for i, cond_schedule in enumerate(c):

         target_index = 0

-        for current, (end_at, cond) in enumerate(cond_schedule):

-            if current_step <= end_at:

+        for current, entry in enumerate(cond_schedule):

+            if current_step <= entry.end_at_step:

                 target_index = current

                 break

         res[i] = cond_schedule[target_index].cond

@@ -231,13 +234,13 @@ def reconstruct_multicond_batch(c: MulticondLearnedConditioning, current_step):
     tensors = []

     conds_list = []

 

-    for batch_no, composable_prompts in enumerate(c.batch):

+    for composable_prompts in c.batch:

         conds_for_batch = []

 

-        for cond_index, composable_prompt in enumerate(composable_prompts):

+        for composable_prompt in composable_prompts:

             target_index = 0

-            for current, (end_at, cond) in enumerate(composable_prompt.schedules):

-                if current_step <= end_at:

+            for current, entry in enumerate(composable_prompt.schedules):

+                if current_step <= entry.end_at_step:

                     target_index = current

                     break

 

diff --git a/modules/realesrgan_model.py b/modules/realesrgan_model.py
index d6079433..c24d8dbb 100644
--- a/modules/realesrgan_model.py
+++ b/modules/realesrgan_model.py
@@ -17,9 +17,9 @@ class UpscalerRealESRGAN(Upscaler):
         self.user_path = path

         super().__init__()

         try:

-            from basicsr.archs.rrdbnet_arch import RRDBNet

-            from realesrgan import RealESRGANer

-            from realesrgan.archs.srvgg_arch import SRVGGNetCompact

+            from basicsr.archs.rrdbnet_arch import RRDBNet  # noqa: F401

+            from realesrgan import RealESRGANer  # noqa: F401

+            from realesrgan.archs.srvgg_arch import SRVGGNetCompact  # noqa: F401

             self.enable = True

             self.scalers = []

             scalers = self.load_models(path)

@@ -28,9 +28,9 @@ class UpscalerRealESRGAN(Upscaler):
             for scaler in scalers:

                 if scaler.local_data_path.startswith("http"):

                     filename = modelloader.friendly_name(scaler.local_data_path)

-                    local = next(iter([local_model for local_model in local_model_paths if local_model.endswith(filename + '.pth')]), None)

-                    if local:

-                        scaler.local_data_path = local

+                    local_model_candidates = [local_model for local_model in local_model_paths if local_model.endswith(f"{filename}.pth")]

+                    if local_model_candidates:

+                        scaler.local_data_path = local_model_candidates[0]

 

                 if scaler.name in opts.realesrgan_enabled_models:

                     self.scalers.append(scaler)

@@ -47,7 +47,7 @@ class UpscalerRealESRGAN(Upscaler):
 

         info = self.load_model(path)

         if not os.path.exists(info.local_data_path):

-            print("Unable to load RealESRGAN model: %s" % info.name)

+            print(f"Unable to load RealESRGAN model: {info.name}")

             return img

 

         upsampler = RealESRGANer(

@@ -134,6 +134,6 @@ def get_realesrgan_models(scaler):
             ),

         ]

         return models

-    except Exception as e:

+    except Exception:

         print("Error making Real-ESRGAN models list:", file=sys.stderr)

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

diff --git a/modules/safe.py b/modules/safe.py
index e6c2f2c0..e8f50774 100644
--- a/modules/safe.py
+++ b/modules/safe.py
@@ -40,7 +40,7 @@ class RestrictedUnpickler(pickle.Unpickler):
             return getattr(collections, name)

         if module == 'torch._utils' and name in ['_rebuild_tensor_v2', '_rebuild_parameter', '_rebuild_device_tensor_from_numpy']:

             return getattr(torch._utils, name)

-        if module == 'torch' and name in ['FloatStorage', 'HalfStorage', 'IntStorage', 'LongStorage', 'DoubleStorage', 'ByteStorage', 'float32']:

+        if module == 'torch' and name in ['FloatStorage', 'HalfStorage', 'IntStorage', 'LongStorage', 'DoubleStorage', 'ByteStorage', 'float32', 'BFloat16Storage']:

             return getattr(torch, name)

         if module == 'torch.nn.modules.container' and name in ['ParameterDict']:

             return getattr(torch.nn.modules.container, name)

@@ -95,16 +95,16 @@ def check_pt(filename, extra_handler):
 

     except zipfile.BadZipfile:

 

-        # if it's not a zip file, it's an olf pytorch format, with five objects written to pickle

+        # if it's not a zip file, it's an old pytorch format, with five objects written to pickle

         with open(filename, "rb") as file:

             unpickler = RestrictedUnpickler(file)

             unpickler.extra_handler = extra_handler

-            for i in range(5):

+            for _ in range(5):

                 unpickler.load()

 

 

 def load(filename, *args, **kwargs):

-    return load_with_extra(filename, extra_handler=global_extra_handler, *args, **kwargs)

+    return load_with_extra(filename, *args, extra_handler=global_extra_handler, **kwargs)

 

 

 def load_with_extra(filename, extra_handler=None, *args, **kwargs):

diff --git a/modules/script_callbacks.py b/modules/script_callbacks.py
index 17109732..3c21a362 100644
--- a/modules/script_callbacks.py
+++ b/modules/script_callbacks.py
@@ -32,27 +32,42 @@ class CFGDenoiserParams:
     def __init__(self, x, image_cond, sigma, sampling_step, total_sampling_steps, text_cond, text_uncond):

         self.x = x

         """Latent image representation in the process of being denoised"""

-        

+

         self.image_cond = image_cond

         """Conditioning image"""

-        

+

         self.sigma = sigma

         """Current sigma noise step value"""

-        

+

         self.sampling_step = sampling_step

         """Current Sampling step number"""

-        

+

         self.total_sampling_steps = total_sampling_steps

         """Total number of sampling steps planned"""

-        

+

         self.text_cond = text_cond

         """ Encoder hidden states of text conditioning from prompt"""

-        

+

         self.text_uncond = text_uncond

         """ Encoder hidden states of text conditioning from negative prompt"""

 

 

 class CFGDenoisedParams:

+    def __init__(self, x, sampling_step, total_sampling_steps, inner_model):

+        self.x = x

+        """Latent image representation in the process of being denoised"""

+

+        self.sampling_step = sampling_step

+        """Current Sampling step number"""

+

+        self.total_sampling_steps = total_sampling_steps

+        """Total number of sampling steps planned"""

+

+        self.inner_model = inner_model

+        """Inner model reference used for denoising"""

+

+

+class AfterCFGCallbackParams:

     def __init__(self, x, sampling_step, total_sampling_steps):

         self.x = x

         """Latent image representation in the process of being denoised"""

@@ -87,6 +102,7 @@ callback_map = dict(
     callbacks_image_saved=[],

     callbacks_cfg_denoiser=[],

     callbacks_cfg_denoised=[],

+    callbacks_cfg_after_cfg=[],

     callbacks_before_component=[],

     callbacks_after_component=[],

     callbacks_image_grid=[],

@@ -186,6 +202,14 @@ def cfg_denoised_callback(params: CFGDenoisedParams):
             report_exception(c, 'cfg_denoised_callback')

 

 

+def cfg_after_cfg_callback(params: AfterCFGCallbackParams):

+    for c in callback_map['callbacks_cfg_after_cfg']:

+        try:

+            c.callback(params)

+        except Exception:

+            report_exception(c, 'cfg_after_cfg_callback')

+

+

 def before_component_callback(component, **kwargs):

     for c in callback_map['callbacks_before_component']:

         try:

@@ -240,7 +264,7 @@ def add_callback(callbacks, fun):
 

     callbacks.append(ScriptCallback(filename, fun))

 

-    

+

 def remove_current_script_callbacks():

     stack = [x for x in inspect.stack() if x.filename != __file__]

     filename = stack[0].filename if len(stack) > 0 else 'unknown file'

@@ -332,6 +356,14 @@ def on_cfg_denoised(callback):
     add_callback(callback_map['callbacks_cfg_denoised'], callback)

 

 

+def on_cfg_after_cfg(callback):

+    """register a function to be called in the kdiffussion cfg_denoiser method after cfg calculations are completed.

+    The callback is called with one argument:

+        - params: AfterCFGCallbackParams - parameters to be passed to the script for post-processing after cfg calculation.

+    """

+    add_callback(callback_map['callbacks_cfg_after_cfg'], callback)

+

+

 def on_before_component(callback):

     """register a function to be called before a component is created.

     The callback is called with arguments:

diff --git a/modules/script_loading.py b/modules/script_loading.py
index a7d2203f..57b15862 100644
--- a/modules/script_loading.py
+++ b/modules/script_loading.py
@@ -2,7 +2,6 @@ import os
 import sys

 import traceback

 import importlib.util

-from types import ModuleType

 

 

 def load_module(path):

diff --git a/modules/scripts.py b/modules/scripts.py
index 4d0bbd66..0c12ebd5 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -163,7 +163,8 @@ class Script:
         """helper function to generate id for a HTML element, constructs final id out of script name, tab and user-supplied item_id"""

 

         need_tabname = self.show(True) == self.show(False)

-        tabname = ('img2img' if self.is_img2img else 'txt2txt') + "_" if need_tabname else ""

+        tabkind = 'img2img' if self.is_img2img else 'txt2txt'

+        tabname = f"{tabkind}_" if need_tabname else ""

         title = re.sub(r'[^a-z_0-9]', '', re.sub(r'\s', '_', self.title().lower()))

 

         return f'script_{tabname}{title}_{item_id}'

@@ -230,7 +231,7 @@ def load_scripts():
     syspath = sys.path

 

     def register_scripts_from_module(module):

-        for key, script_class in module.__dict__.items():

+        for script_class in module.__dict__.values():

             if type(script_class) != type:

                 continue

 

@@ -294,9 +295,9 @@ class ScriptRunner:
 

         auto_processing_scripts = scripts_auto_postprocessing.create_auto_preprocessing_script_data()

 

-        for script_class, path, basedir, script_module in auto_processing_scripts + scripts_data:

-            script = script_class()

-            script.filename = path

+        for script_data in auto_processing_scripts + scripts_data:

+            script = script_data.script_class()

+            script.filename = script_data.path

             script.is_txt2img = not is_img2img

             script.is_img2img = is_img2img

 

@@ -491,7 +492,7 @@ class ScriptRunner:
                 module = script_loading.load_module(script.filename)

                 cache[filename] = module

 

-            for key, script_class in module.__dict__.items():

+            for script_class in module.__dict__.values():

                 if type(script_class) == type and issubclass(script_class, Script):

                     self.scripts[si] = script_class()

                     self.scripts[si].filename = filename

@@ -526,7 +527,7 @@ def add_classes_to_gradio_component(comp):
     this adds gradio-* to the component for css styling (ie gradio-button to gr.Button), as well as some others

     """

 

-    comp.elem_classes = ["gradio-" + comp.get_block_name(), *(comp.elem_classes or [])]

+    comp.elem_classes = [f"gradio-{comp.get_block_name()}", *(comp.elem_classes or [])]

 

     if getattr(comp, 'multiselect', False):

         comp.elem_classes.append('multiselect')

diff --git a/modules/scripts_auto_postprocessing.py b/modules/scripts_auto_postprocessing.py
index 30d6d658..d63078de 100644
--- a/modules/scripts_auto_postprocessing.py
+++ b/modules/scripts_auto_postprocessing.py
@@ -17,7 +17,7 @@ class ScriptPostprocessingForMainUI(scripts.Script):
         return self.postprocessing_controls.values()

 

     def postprocess_image(self, p, script_pp, *args):

-        args_dict = {k: v for k, v in zip(self.postprocessing_controls, args)}

+        args_dict = dict(zip(self.postprocessing_controls, args))

 

         pp = scripts_postprocessing.PostprocessedImage(script_pp.image)

         pp.info = {}

diff --git a/modules/scripts_postprocessing.py b/modules/scripts_postprocessing.py
index b11568c0..bac1335d 100644
--- a/modules/scripts_postprocessing.py
+++ b/modules/scripts_postprocessing.py
@@ -66,9 +66,9 @@ class ScriptPostprocessingRunner:
     def initialize_scripts(self, scripts_data):

         self.scripts = []

 

-        for script_class, path, basedir, script_module in scripts_data:

-            script: ScriptPostprocessing = script_class()

-            script.filename = path

+        for script_data in scripts_data:

+            script: ScriptPostprocessing = script_data.script_class()

+            script.filename = script_data.path

 

             if script.name == "Simple Upscale":

                 continue

@@ -124,7 +124,7 @@ class ScriptPostprocessingRunner:
             script_args = args[script.args_from:script.args_to]

 

             process_args = {}

-            for (name, component), value in zip(script.controls.items(), script_args):

+            for (name, _component), value in zip(script.controls.items(), script_args):

                 process_args[name] = value

 

             script.process(pp, **process_args)

diff --git a/modules/sd_disable_initialization.py b/modules/sd_disable_initialization.py
index c4a09d15..9fc89dc6 100644
--- a/modules/sd_disable_initialization.py
+++ b/modules/sd_disable_initialization.py
@@ -61,7 +61,7 @@ class DisableInitialization:
                 if res is None:

                     res = original(url, *args, local_files_only=False, **kwargs)

                 return res

-            except Exception as e:

+            except Exception:

                 return original(url, *args, local_files_only=False, **kwargs)

 

         def transformers_utils_hub_get_from_cache(url, *args, local_files_only=False, **kwargs):

diff --git a/modules/sd_hijack.py b/modules/sd_hijack.py
index f4bb0266..7e50f1ab 100644
--- a/modules/sd_hijack.py
+++ b/modules/sd_hijack.py
@@ -3,7 +3,7 @@ from torch.nn.functional import silu
 from types import MethodType

 

 import modules.textual_inversion.textual_inversion

-from modules import devices, sd_hijack_optimizations, shared, sd_hijack_checkpoint

+from modules import devices, sd_hijack_optimizations, shared

 from modules.hypernetworks import hypernetwork

 from modules.shared import cmd_opts

 from modules import sd_hijack_clip, sd_hijack_open_clip, sd_hijack_unet, sd_hijack_xlmr, xlmr

@@ -34,10 +34,10 @@ def apply_optimizations():
 

     ldm.modules.diffusionmodules.model.nonlinearity = silu

     ldm.modules.diffusionmodules.openaimodel.th = sd_hijack_unet.th

-    

+

     optimization_method = None

 

-    can_use_sdp = hasattr(torch.nn.functional, "scaled_dot_product_attention") and callable(getattr(torch.nn.functional, "scaled_dot_product_attention")) # not everyone has torch 2.x to use sdp

+    can_use_sdp = hasattr(torch.nn.functional, "scaled_dot_product_attention") and callable(torch.nn.functional.scaled_dot_product_attention) # not everyone has torch 2.x to use sdp

 

     if cmd_opts.force_enable_xformers or (cmd_opts.xformers and shared.xformers_available and torch.version.cuda and (6, 0) <= torch.cuda.get_device_capability(shared.device) <= (9, 0)):

         print("Applying xformers cross attention optimization.")

@@ -92,12 +92,12 @@ def fix_checkpoint():
 def weighted_loss(sd_model, pred, target, mean=True):

     #Calculate the weight normally, but ignore the mean

     loss = sd_model._old_get_loss(pred, target, mean=False)

-    

+

     #Check if we have weights available

     weight = getattr(sd_model, '_custom_loss_weight', None)

     if weight is not None:

         loss *= weight

-    

+

     #Return the loss, as mean if specified

     return loss.mean() if mean else loss

 

@@ -105,7 +105,7 @@ def weighted_forward(sd_model, x, c, w, *args, **kwargs):
     try:

         #Temporarily append weights to a place accessible during loss calc

         sd_model._custom_loss_weight = w

-        

+

         #Replace 'get_loss' with a weight-aware one. Otherwise we need to reimplement 'forward' completely

         #Keep 'get_loss', but don't overwrite the previous old_get_loss if it's already set

         if not hasattr(sd_model, '_old_get_loss'):

@@ -118,9 +118,9 @@ def weighted_forward(sd_model, x, c, w, *args, **kwargs):
         try:

             #Delete temporary weights if appended

             del sd_model._custom_loss_weight

-        except AttributeError as e:

+        except AttributeError:

             pass

-            

+

         #If we have an old loss function, reset the loss function to the original one

         if hasattr(sd_model, '_old_get_loss'):

             sd_model.get_loss = sd_model._old_get_loss

@@ -133,7 +133,7 @@ def apply_weighted_forward(sd_model):
 def undo_weighted_forward(sd_model):

     try:

         del sd_model.weighted_forward

-    except AttributeError as e:

+    except AttributeError:

         pass

 

 

@@ -184,7 +184,7 @@ class StableDiffusionModelHijack:
 

     def undo_hijack(self, m):

         if type(m.cond_stage_model) == xlmr.BertSeriesModelWithTransformation:

-            m.cond_stage_model = m.cond_stage_model.wrapped 

+            m.cond_stage_model = m.cond_stage_model.wrapped

 

         elif type(m.cond_stage_model) == sd_hijack_clip.FrozenCLIPEmbedderWithCustomWords:

             m.cond_stage_model = m.cond_stage_model.wrapped

diff --git a/modules/sd_hijack_clip.py b/modules/sd_hijack_clip.py
index 9fa5c5c5..cc6e8c21 100644
--- a/modules/sd_hijack_clip.py
+++ b/modules/sd_hijack_clip.py
@@ -223,7 +223,7 @@ class FrozenCLIPEmbedderWithCustomWordsBase(torch.nn.Module):
             self.hijack.fixes = [x.fixes for x in batch_chunk]

 

             for fixes in self.hijack.fixes:

-                for position, embedding in fixes:

+                for _position, embedding in fixes:

                     used_embeddings[embedding.name] = embedding

 

             z = self.process_tokens(tokens, multipliers)

diff --git a/modules/sd_hijack_clip_old.py b/modules/sd_hijack_clip_old.py
index 6d9fbbe6..a3476e95 100644
--- a/modules/sd_hijack_clip_old.py
+++ b/modules/sd_hijack_clip_old.py
@@ -75,7 +75,8 @@ def forward_old(self: sd_hijack_clip.FrozenCLIPEmbedderWithCustomWordsBase, text
     self.hijack.comments += hijack_comments

 

     if len(used_custom_terms) > 0:

-        self.hijack.comments.append("Used embeddings: " + ", ".join([f'{word} [{checksum}]' for word, checksum in used_custom_terms]))

+        embedding_names = ", ".join(f"{word} [{checksum}]" for word, checksum in used_custom_terms)

+        self.hijack.comments.append(f"Used embeddings: {embedding_names}")

 

     self.hijack.fixes = hijack_fixes

     return self.process_tokens(remade_batch_tokens, batch_multipliers)

diff --git a/modules/sd_hijack_inpainting.py b/modules/sd_hijack_inpainting.py
index 55a2ce4d..c1977b19 100644
--- a/modules/sd_hijack_inpainting.py
+++ b/modules/sd_hijack_inpainting.py
@@ -1,16 +1,10 @@
-import os
 import torch
 
-from einops import repeat
-from omegaconf import ListConfig
-
 import ldm.models.diffusion.ddpm
 import ldm.models.diffusion.ddim
 import ldm.models.diffusion.plms
 
-from ldm.models.diffusion.ddpm import LatentDiffusion
-from ldm.models.diffusion.plms import PLMSSampler
-from ldm.models.diffusion.ddim import DDIMSampler, noise_like
+from ldm.models.diffusion.ddim import noise_like
 from ldm.models.diffusion.sampling_util import norm_thresholding
 
 
@@ -29,7 +23,7 @@ def p_sample_plms(self, x, c, t, index, repeat_noise=False, use_original_steps=F
 
             if isinstance(c, dict):
                 assert isinstance(unconditional_conditioning, dict)
-                c_in = dict()
+                c_in = {}
                 for k in c:
                     if isinstance(c[k], list):
                         c_in[k] = [
diff --git a/modules/sd_hijack_ip2p.py b/modules/sd_hijack_ip2p.py
index 3c727d3b..6fe6b6ff 100644
--- a/modules/sd_hijack_ip2p.py
+++ b/modules/sd_hijack_ip2p.py
@@ -1,8 +1,5 @@
-import collections
 import os.path
-import sys
-import gc
-import time
+
 
 def should_hijack_ip2p(checkpoint_info):
     from modules import sd_models_config
@@ -10,4 +7,4 @@ def should_hijack_ip2p(checkpoint_info):
     ckpt_basename = os.path.basename(checkpoint_info.filename).lower()
     cfg_basename = os.path.basename(sd_models_config.find_checkpoint_config_near_filename(checkpoint_info)).lower()
 
-    return "pix2pix" in ckpt_basename and not "pix2pix" in cfg_basename
+    return "pix2pix" in ckpt_basename and "pix2pix" not in cfg_basename
diff --git a/modules/sd_hijack_optimizations.py b/modules/sd_hijack_optimizations.py
index 372555ff..f00fe55c 100644
--- a/modules/sd_hijack_optimizations.py
+++ b/modules/sd_hijack_optimizations.py
@@ -49,7 +49,7 @@ def split_cross_attention_forward_v1(self, x, context=None, mask=None):
     v_in = self.to_v(context_v)

     del context, context_k, context_v, x

 

-    q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q_in, k_in, v_in))

+    q, k, v = (rearrange(t, 'b n (h d) -> (b h) n d', h=h) for t in (q_in, k_in, v_in))

     del q_in, k_in, v_in

 

     dtype = q.dtype

@@ -62,10 +62,10 @@ def split_cross_attention_forward_v1(self, x, context=None, mask=None):
             end = i + 2

             s1 = einsum('b i d, b j d -> b i j', q[i:end], k[i:end])

             s1 *= self.scale

-    

+

             s2 = s1.softmax(dim=-1)

             del s1

-    

+

             r1[i:end] = einsum('b i j, b j d -> b i d', s2, v[i:end])

             del s2

         del q, k, v

@@ -95,43 +95,43 @@ def split_cross_attention_forward(self, x, context=None, mask=None):
 

     with devices.without_autocast(disable=not shared.opts.upcast_attn):

         k_in = k_in * self.scale

-    

+

         del context, x

-    

-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q_in, k_in, v_in))

+

+        q, k, v = (rearrange(t, 'b n (h d) -> (b h) n d', h=h) for t in (q_in, k_in, v_in))

         del q_in, k_in, v_in

-    

+

         r1 = torch.zeros(q.shape[0], q.shape[1], v.shape[2], device=q.device, dtype=q.dtype)

-    

+

         mem_free_total = get_available_vram()

-    

+

         gb = 1024 ** 3

         tensor_size = q.shape[0] * q.shape[1] * k.shape[1] * q.element_size()

         modifier = 3 if q.element_size() == 2 else 2.5

         mem_required = tensor_size * modifier

         steps = 1

-    

+

         if mem_required > mem_free_total:

             steps = 2 ** (math.ceil(math.log(mem_required / mem_free_total, 2)))

             # print(f"Expected tensor size:{tensor_size/gb:0.1f}GB, cuda free:{mem_free_cuda/gb:0.1f}GB "

             #       f"torch free:{mem_free_torch/gb:0.1f} total:{mem_free_total/gb:0.1f} steps:{steps}")

-    

+

         if steps > 64:

             max_res = math.floor(math.sqrt(math.sqrt(mem_free_total / 2.5)) / 8) * 64

             raise RuntimeError(f'Not enough memory, use lower resolution (max approx. {max_res}x{max_res}). '

                                f'Need: {mem_required / 64 / gb:0.1f}GB free, Have:{mem_free_total / gb:0.1f}GB free')

-    

+

         slice_size = q.shape[1] // steps if (q.shape[1] % steps) == 0 else q.shape[1]

         for i in range(0, q.shape[1], slice_size):

             end = i + slice_size

             s1 = einsum('b i d, b j d -> b i j', q[:, i:end], k)

-    

+

             s2 = s1.softmax(dim=-1, dtype=q.dtype)

             del s1

-    

+

             r1[:, i:end] = einsum('b i j, b j d -> b i d', s2, v)

             del s2

-    

+

         del q, k, v

 

     r1 = r1.to(dtype)

@@ -228,8 +228,8 @@ def split_cross_attention_forward_invokeAI(self, x, context=None, mask=None):
 

     with devices.without_autocast(disable=not shared.opts.upcast_attn):

         k = k * self.scale

-    

-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))

+

+        q, k, v = (rearrange(t, 'b n (h d) -> (b h) n d', h=h) for t in (q, k, v))

         r = einsum_op(q, k, v)

     r = r.to(dtype)

     return self.to_out(rearrange(r, '(b h) n d -> b n (h d)', h=h))

@@ -256,6 +256,9 @@ def sub_quad_attention_forward(self, x, context=None, mask=None):
     k = k.unflatten(-1, (h, -1)).transpose(1,2).flatten(end_dim=1)

     v = v.unflatten(-1, (h, -1)).transpose(1,2).flatten(end_dim=1)

 

+    if q.device.type == 'mps':

+        q, k, v = q.contiguous(), k.contiguous(), v.contiguous()

+

     dtype = q.dtype

     if shared.opts.upcast_attn:

         q, k = q.float(), k.float()

@@ -293,7 +296,6 @@ def sub_quad_attention(q, k, v, q_chunk_size=1024, kv_chunk_size=None, kv_chunk_
     if chunk_threshold_bytes is not None and qk_matmul_size_bytes <= chunk_threshold_bytes:

         # the big matmul fits into our memory limit; do everything in 1 chunk,

         # i.e. send it down the unchunked fast-path

-        query_chunk_size = q_tokens

         kv_chunk_size = k_tokens

 

     with devices.without_autocast(disable=q.dtype == v.dtype):

@@ -332,7 +334,7 @@ def xformers_attention_forward(self, x, context=None, mask=None):
     k_in = self.to_k(context_k)

     v_in = self.to_v(context_v)

 

-    q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b n h d', h=h), (q_in, k_in, v_in))

+    q, k, v = (rearrange(t, 'b n (h d) -> b n h d', h=h) for t in (q_in, k_in, v_in))

     del q_in, k_in, v_in

 

     dtype = q.dtype

@@ -367,7 +369,7 @@ def scaled_dot_product_attention_forward(self, x, context=None, mask=None):
     q = q_in.view(batch_size, -1, h, head_dim).transpose(1, 2)

     k = k_in.view(batch_size, -1, h, head_dim).transpose(1, 2)

     v = v_in.view(batch_size, -1, h, head_dim).transpose(1, 2)

-    

+

     del q_in, k_in, v_in

 

     dtype = q.dtype

@@ -449,7 +451,7 @@ def cross_attention_attnblock_forward(self, x):
         h3 += x

 

         return h3

-    

+

 def xformers_attnblock_forward(self, x):

     try:

         h_ = x

@@ -458,7 +460,7 @@ def xformers_attnblock_forward(self, x):
         k = self.k(h_)

         v = self.v(h_)

         b, c, h, w = q.shape

-        q, k, v = map(lambda t: rearrange(t, 'b c h w -> b (h w) c'), (q, k, v))

+        q, k, v = (rearrange(t, 'b c h w -> b (h w) c') for t in (q, k, v))

         dtype = q.dtype

         if shared.opts.upcast_attn:

             q, k = q.float(), k.float()

@@ -480,7 +482,7 @@ def sdp_attnblock_forward(self, x):
     k = self.k(h_)

     v = self.v(h_)

     b, c, h, w = q.shape

-    q, k, v = map(lambda t: rearrange(t, 'b c h w -> b (h w) c'), (q, k, v))

+    q, k, v = (rearrange(t, 'b c h w -> b (h w) c') for t in (q, k, v))

     dtype = q.dtype

     if shared.opts.upcast_attn:

         q, k = q.float(), k.float()

@@ -504,7 +506,7 @@ def sub_quad_attnblock_forward(self, x):
     k = self.k(h_)

     v = self.v(h_)

     b, c, h, w = q.shape

-    q, k, v = map(lambda t: rearrange(t, 'b c h w -> b (h w) c'), (q, k, v))

+    q, k, v = (rearrange(t, 'b c h w -> b (h w) c') for t in (q, k, v))

     q = q.contiguous()

     k = k.contiguous()

     v = v.contiguous()

diff --git a/modules/sd_hijack_unet.py b/modules/sd_hijack_unet.py
index 15858263..ca1daf45 100644
--- a/modules/sd_hijack_unet.py
+++ b/modules/sd_hijack_unet.py
@@ -18,7 +18,7 @@ class TorchHijackForUnet:
         if hasattr(torch, item):

             return getattr(torch, item)

 

-        raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, item))

+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{item}'")

 

     def cat(self, tensors, *args, **kwargs):

         if len(tensors) == 2:

diff --git a/modules/sd_hijack_xlmr.py b/modules/sd_hijack_xlmr.py
index 4ac51c38..28528329 100644
--- a/modules/sd_hijack_xlmr.py
+++ b/modules/sd_hijack_xlmr.py
@@ -1,8 +1,6 @@
-import open_clip.tokenizer

 import torch

 

 from modules import sd_hijack_clip, devices

-from modules.shared import opts

 

 

 class FrozenXLMREmbedderWithCustomWords(sd_hijack_clip.FrozenCLIPEmbedderWithCustomWords):

diff --git a/modules/sd_models.py b/modules/sd_models.py
index 4f7613a1..4c9a0a1f 100644
--- a/modules/sd_models.py
+++ b/modules/sd_models.py
@@ -2,6 +2,8 @@ import collections
 import os.path

 import sys

 import gc

+import threading

+

 import torch

 import re

 import safetensors.torch

@@ -13,9 +15,9 @@ import ldm.modules.midas as midas
 from ldm.util import instantiate_from_config

 

 from modules import paths, shared, modelloader, devices, script_callbacks, sd_vae, sd_disable_initialization, errors, hashes, sd_models_config

-from modules.paths import models_path

 from modules.sd_hijack_inpainting import do_inpainting_hijack

 from modules.timer import Timer

+import tomesd

 

 model_dir = "Stable-diffusion"

 model_path = os.path.abspath(os.path.join(paths.models_path, model_dir))

@@ -45,7 +47,7 @@ class CheckpointInfo:
         self.model_name = os.path.splitext(name.replace("/", "_").replace("\\", "_"))[0]

         self.hash = model_hash(filename)

 

-        self.sha256 = hashes.sha256_from_cache(self.filename, "checkpoint/" + name)

+        self.sha256 = hashes.sha256_from_cache(self.filename, f"checkpoint/{name}")

         self.shorthash = self.sha256[0:10] if self.sha256 else None

 

         self.title = name if self.shorthash is None else f'{name} [{self.shorthash}]'

@@ -67,7 +69,7 @@ class CheckpointInfo:
             checkpoint_alisases[id] = self

 

     def calculate_shorthash(self):

-        self.sha256 = hashes.sha256(self.filename, "checkpoint/" + self.name)

+        self.sha256 = hashes.sha256(self.filename, f"checkpoint/{self.name}")

         if self.sha256 is None:

             return

 

@@ -85,8 +87,7 @@ class CheckpointInfo:
 

 try:

     # this silences the annoying "Some weights of the model checkpoint were not used when initializing..." message at start.

-

-    from transformers import logging, CLIPModel

+    from transformers import logging, CLIPModel  # noqa: F401

 

     logging.set_verbosity_error()

 except Exception:

@@ -165,7 +166,7 @@ def model_hash(filename):
 

 def select_checkpoint():

     model_checkpoint = shared.opts.sd_model_checkpoint

-        

+

     checkpoint_info = checkpoint_alisases.get(model_checkpoint, None)

     if checkpoint_info is not None:

         return checkpoint_info

@@ -237,7 +238,7 @@ def read_metadata_from_safetensors(filename):
             if isinstance(v, str) and v[0:1] == '{':

                 try:

                     res[k] = json.loads(v)

-                except Exception as e:

+                except Exception:

                     pass

 

         return res

@@ -372,7 +373,7 @@ def enable_midas_autodownload():
         if not os.path.exists(path):

             if not os.path.exists(midas_path):

                 mkdir(midas_path)

-    

+

             print(f"Downloading midas model weights for {model_type} to {path}")

             request.urlretrieve(midas_urls[model_type], path)

             print(f"{model_type} downloaded")

@@ -404,13 +405,39 @@ def repair_config(sd_config):
 sd1_clip_weight = 'cond_stage_model.transformer.text_model.embeddings.token_embedding.weight'

 sd2_clip_weight = 'cond_stage_model.model.transformer.resblocks.0.attn.in_proj_weight'

 

-def load_model(checkpoint_info=None, already_loaded_state_dict=None, time_taken_to_load_state_dict=None):

+

+class SdModelData:

+    def __init__(self):

+        self.sd_model = None

+        self.lock = threading.Lock()

+

+    def get_sd_model(self):

+        if self.sd_model is None:

+            with self.lock:

+                try:

+                    load_model()

+                except Exception as e:

+                    errors.display(e, "loading stable diffusion model")

+                    print("", file=sys.stderr)

+                    print("Stable diffusion model failed to load", file=sys.stderr)

+                    self.sd_model = None

+

+        return self.sd_model

+

+    def set_sd_model(self, v):

+        self.sd_model = v

+

+

+model_data = SdModelData()

+

+

+def load_model(checkpoint_info=None, already_loaded_state_dict=None):

     from modules import lowvram, sd_hijack

     checkpoint_info = checkpoint_info or select_checkpoint()

 

-    if shared.sd_model:

-        sd_hijack.model_hijack.undo_hijack(shared.sd_model)

-        shared.sd_model = None

+    if model_data.sd_model:

+        sd_hijack.model_hijack.undo_hijack(model_data.sd_model)

+        model_data.sd_model = None

         gc.collect()

         devices.torch_gc()

 

@@ -439,7 +466,7 @@ def load_model(checkpoint_info=None, already_loaded_state_dict=None, time_taken_
     try:

         with sd_disable_initialization.DisableInitialization(disable_clip=clip_is_included_into_sd):

             sd_model = instantiate_from_config(sd_config.model)

-    except Exception as e:

+    except Exception:

         pass

 

     if sd_model is None:

@@ -464,7 +491,7 @@ def load_model(checkpoint_info=None, already_loaded_state_dict=None, time_taken_
     timer.record("hijack")

 

     sd_model.eval()

-    shared.sd_model = sd_model

+    model_data.sd_model = sd_model

 

     sd_hijack.model_hijack.embedding_db.load_textual_inversion_embeddings(force_reload=True)  # Reload embeddings after model load as they may or may not fit the model

 

@@ -484,7 +511,7 @@ def reload_model_weights(sd_model=None, info=None):
     checkpoint_info = info or select_checkpoint()

 

     if not sd_model:

-        sd_model = shared.sd_model

+        sd_model = model_data.sd_model

 

     if sd_model is None:  # previous model load failed

         current_checkpoint_info = None

@@ -512,11 +539,11 @@ def reload_model_weights(sd_model=None, info=None):
         del sd_model

         checkpoints_loaded.clear()

         load_model(checkpoint_info, already_loaded_state_dict=state_dict)

-        return shared.sd_model

+        return model_data.sd_model

 

     try:

         load_model_weights(sd_model, checkpoint_info, state_dict, timer)

-    except Exception as e:

+    except Exception:

         print("Failed to load checkpoint, restoring previous")

         load_model_weights(sd_model, current_checkpoint_info, None, timer)

         raise

@@ -535,17 +562,15 @@ def reload_model_weights(sd_model=None, info=None):
 

     return sd_model

 

+

 def unload_model_weights(sd_model=None, info=None):

-    from modules import lowvram, devices, sd_hijack

+    from modules import devices, sd_hijack

     timer = Timer()

 

-    if shared.sd_model:

-

-        # shared.sd_model.cond_stage_model.to(devices.cpu)

-        # shared.sd_model.first_stage_model.to(devices.cpu)

-        shared.sd_model.to(devices.cpu)

-        sd_hijack.model_hijack.undo_hijack(shared.sd_model)

-        shared.sd_model = None

+    if model_data.sd_model:

+        model_data.sd_model.to(devices.cpu)

+        sd_hijack.model_hijack.undo_hijack(model_data.sd_model)

+        model_data.sd_model = None

         sd_model = None

         gc.collect()

         devices.torch_gc()

@@ -554,3 +579,25 @@ def unload_model_weights(sd_model=None, info=None):
     print(f"Unloaded weights {timer.summary()}.")

 

     return sd_model

+

+

+def apply_token_merging(sd_model, hr: bool):

+    """

+    Applies speed and memory optimizations from tomesd.

+

+    Args:

+        hr (bool): True if called in the context of a high-res pass

+    """

+

+    ratio = shared.opts.token_merging_ratio

+    if hr:

+        ratio = shared.opts.token_merging_ratio_hr

+

+    tomesd.apply_patch(

+        sd_model,

+        ratio=ratio,

+        use_rand=False,  # can cause issues with some samplers

+        merge_attn=True,

+        merge_crossattn=False,

+        merge_mlp=False

+    )

diff --git a/modules/sd_models_config.py b/modules/sd_models_config.py
index 9398f528..9bfe1237 100644
--- a/modules/sd_models_config.py
+++ b/modules/sd_models_config.py
@@ -1,4 +1,3 @@
-import re

 import os

 

 import torch

@@ -111,7 +110,7 @@ def find_checkpoint_config_near_filename(info):
     if info is None:

         return None

 

-    config = os.path.splitext(info.filename)[0] + ".yaml"

+    config = f"{os.path.splitext(info.filename)[0]}.yaml"

     if os.path.exists(config):

         return config

 

diff --git a/modules/sd_samplers.py b/modules/sd_samplers.py
index ff361f22..4f1bf21d 100644
--- a/modules/sd_samplers.py
+++ b/modules/sd_samplers.py
@@ -1,7 +1,7 @@
 from modules import sd_samplers_compvis, sd_samplers_kdiffusion, shared

 

 # imports for functions that previously were here and are used by other modules

-from modules.sd_samplers_common import samples_to_image_grid, sample_to_image

+from modules.sd_samplers_common import samples_to_image_grid, sample_to_image  # noqa: F401

 

 all_samplers = [

     *sd_samplers_kdiffusion.samplers_data_k_diffusion,

diff --git a/modules/sd_samplers_compvis.py b/modules/sd_samplers_compvis.py
index bfcc5574..b1ee3be7 100644
--- a/modules/sd_samplers_compvis.py
+++ b/modules/sd_samplers_compvis.py
@@ -55,7 +55,7 @@ class VanillaStableDiffusionSampler:
     def p_sample_ddim_hook(self, x_dec, cond, ts, unconditional_conditioning, *args, **kwargs):

         x_dec, ts, cond, unconditional_conditioning = self.before_sample(x_dec, ts, cond, unconditional_conditioning)

 

-        res = self.orig_p_sample_ddim(x_dec, cond, ts, unconditional_conditioning=unconditional_conditioning, *args, **kwargs)

+        res = self.orig_p_sample_ddim(x_dec, cond, ts, *args, unconditional_conditioning=unconditional_conditioning, **kwargs)

 

         x_dec, ts, cond, unconditional_conditioning, res = self.after_sample(x_dec, ts, cond, unconditional_conditioning, res)

 

@@ -83,7 +83,7 @@ class VanillaStableDiffusionSampler:
         conds_list, tensor = prompt_parser.reconstruct_multicond_batch(cond, self.step)

         unconditional_conditioning = prompt_parser.reconstruct_cond_batch(unconditional_conditioning, self.step)

 

-        assert all([len(conds) == 1 for conds in conds_list]), 'composition via AND is not supported for DDIM/PLMS samplers'

+        assert all(len(conds) == 1 for conds in conds_list), 'composition via AND is not supported for DDIM/PLMS samplers'

         cond = tensor

 

         # for DDIM, shapes must match, we can't just process cond and uncond independently;

diff --git a/modules/sd_samplers_kdiffusion.py b/modules/sd_samplers_kdiffusion.py
index eb98e599..61f23ad7 100644
--- a/modules/sd_samplers_kdiffusion.py
+++ b/modules/sd_samplers_kdiffusion.py
@@ -1,7 +1,6 @@
 from collections import deque

 import torch

 import inspect

-import einops

 import k_diffusion.sampling

 from modules import prompt_parser, devices, sd_samplers_common

 

@@ -9,6 +8,7 @@ from modules.shared import opts, state
 import modules.shared as shared

 from modules.script_callbacks import CFGDenoiserParams, cfg_denoiser_callback

 from modules.script_callbacks import CFGDenoisedParams, cfg_denoised_callback

+from modules.script_callbacks import AfterCFGCallbackParams, cfg_after_cfg_callback

 

 samplers_k_diffusion = [

     ('Euler a', 'sample_euler_ancestral', ['k_euler_a', 'k_euler_ancestral'], {}),

@@ -87,17 +87,17 @@ class CFGDenoiser(torch.nn.Module):
         conds_list, tensor = prompt_parser.reconstruct_multicond_batch(cond, self.step)

         uncond = prompt_parser.reconstruct_cond_batch(uncond, self.step)

 

-        assert not is_edit_model or all([len(conds) == 1 for conds in conds_list]), "AND is not supported for InstructPix2Pix checkpoint (unless using Image CFG scale = 1.0)"

+        assert not is_edit_model or all(len(conds) == 1 for conds in conds_list), "AND is not supported for InstructPix2Pix checkpoint (unless using Image CFG scale = 1.0)"

 

         batch_size = len(conds_list)

         repeats = [len(conds_list[i]) for i in range(batch_size)]

 

         if shared.sd_model.model.conditioning_key == "crossattn-adm":

             image_uncond = torch.zeros_like(image_cond)

-            make_condition_dict = lambda c_crossattn, c_adm: {"c_crossattn": c_crossattn, "c_adm": c_adm} 

+            make_condition_dict = lambda c_crossattn, c_adm: {"c_crossattn": c_crossattn, "c_adm": c_adm}

         else:

             image_uncond = image_cond

-            make_condition_dict = lambda c_crossattn, c_concat: {"c_crossattn": c_crossattn, "c_concat": [c_concat]} 

+            make_condition_dict = lambda c_crossattn, c_concat: {"c_crossattn": c_crossattn, "c_concat": [c_concat]}

 

         if not is_edit_model:

             x_in = torch.cat([torch.stack([x[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [x])

@@ -161,7 +161,7 @@ class CFGDenoiser(torch.nn.Module):
             fake_uncond = torch.cat([x_out[i:i+1] for i in denoised_image_indexes])

             x_out = torch.cat([x_out, fake_uncond])  # we skipped uncond denoising, so we put cond-denoised image to where the uncond-denoised image should be

 

-        denoised_params = CFGDenoisedParams(x_out, state.sampling_step, state.sampling_steps)

+        denoised_params = CFGDenoisedParams(x_out, state.sampling_step, state.sampling_steps, self.inner_model)

         cfg_denoised_callback(denoised_params)

 

         devices.test_for_nans(x_out, "unet")

@@ -181,6 +181,10 @@ class CFGDenoiser(torch.nn.Module):
         if self.mask is not None:

             denoised = self.init_latent * self.mask + self.nmask * denoised

 

+        after_cfg_callback_params = AfterCFGCallbackParams(denoised, state.sampling_step, state.sampling_steps)

+        cfg_after_cfg_callback(after_cfg_callback_params)

+        denoised = after_cfg_callback_params.x

+

         self.step += 1

         return denoised

 

@@ -198,7 +202,7 @@ class TorchHijack:
         if hasattr(torch, item):

             return getattr(torch, item)

 

-        raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, item))

+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{item}'")

 

     def randn_like(self, x):

         if self.sampler_noises:

@@ -317,7 +321,7 @@ class KDiffusionSampler:
 

         sigma_sched = sigmas[steps - t_enc - 1:]

         xi = x + noise * sigma_sched[0]

-        

+

         extra_params_kwargs = self.initialize(p)

         parameters = inspect.signature(self.func).parameters

 

@@ -340,9 +344,9 @@ class KDiffusionSampler:
         self.model_wrap_cfg.init_latent = x

         self.last_latent = x

         extra_args={

-            'cond': conditioning, 

-            'image_cond': image_conditioning, 

-            'uncond': unconditional_conditioning, 

+            'cond': conditioning,

+            'image_cond': image_conditioning,

+            'uncond': unconditional_conditioning,

             'cond_scale': p.cfg_scale,

             's_min_uncond': self.s_min_uncond

         }

@@ -375,9 +379,9 @@ class KDiffusionSampler:
 

         self.last_latent = x

         samples = self.launch_sampling(steps, lambda: self.func(self.model_wrap_cfg, x, extra_args={

-            'cond': conditioning, 

-            'image_cond': image_conditioning, 

-            'uncond': unconditional_conditioning, 

+            'cond': conditioning,

+            'image_cond': image_conditioning,

+            'uncond': unconditional_conditioning,

             'cond_scale': p.cfg_scale,

             's_min_uncond': self.s_min_uncond

         }, disable=False, callback=self.callback_state, **extra_params_kwargs))

diff --git a/modules/sd_vae.py b/modules/sd_vae.py
index 95262ca3..e4ff2994 100644
--- a/modules/sd_vae.py
+++ b/modules/sd_vae.py
@@ -1,8 +1,5 @@
-import torch
-import safetensors.torch
 import os
 import collections
-from collections import namedtuple
 from modules import paths, shared, devices, script_callbacks, sd_models
 import glob
 from copy import deepcopy
diff --git a/modules/shared.py b/modules/shared.py
index 6a2b3c2b..07f18b1b 100644
--- a/modules/shared.py
+++ b/modules/shared.py
@@ -1,12 +1,9 @@
-import argparse

 import datetime

 import json

 import os

 import sys

 import time

-import requests

 

-from PIL import Image

 import gradio as gr

 import tqdm

 

@@ -15,7 +12,8 @@ import modules.memmon
 import modules.styles

 import modules.devices as devices

 from modules import localization, script_loading, errors, ui_components, shared_items, cmd_args

-from modules.paths_internal import models_path, script_path, data_path, sd_configs_path, sd_default_config, sd_model_file, default_sd_model_file, extensions_dir, extensions_builtin_dir

+from modules.paths_internal import models_path, script_path, data_path, sd_configs_path, sd_default_config, sd_model_file, default_sd_model_file, extensions_dir, extensions_builtin_dir  # noqa: F401

+from ldm.models.diffusion.ddpm import LatentDiffusion

 

 demo = None

 

@@ -201,8 +199,9 @@ interrogator = modules.interrogate.InterrogateModels("interrogate")
 

 face_restorers = []

 

+

 class OptionInfo:

-    def __init__(self, default=None, label="", component=None, component_args=None, onchange=None, section=None, refresh=None):

+    def __init__(self, default=None, label="", component=None, component_args=None, onchange=None, section=None, refresh=None, comment_before='', comment_after=''):

         self.default = default

         self.label = label

         self.component = component

@@ -211,9 +210,33 @@ class OptionInfo:
         self.section = section

         self.refresh = refresh

 

+        self.comment_before = comment_before

+        """HTML text that will be added after label in UI"""

+

+        self.comment_after = comment_after

+        """HTML text that will be added before label in UI"""

+

+    def link(self, label, url):

+        self.comment_before += f"[<a href='{url}' target='_blank'>{label}</a>]"

+        return self

+

+    def js(self, label, js_func):

+        self.comment_before += f"[<a onclick='{js_func}(); return false'>{label}</a>]"

+        return self

+

+    def info(self, info):

+        self.comment_after += f"<span class='info'>({info})</span>"

+        return self

+

+    def needs_restart(self):

+        self.comment_after += " <span class='info'>(requires restart)</span>"

+        return self

+

+

+

 

 def options_section(section_identifier, options_dict):

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

+    for v in options_dict.values():

         v.section = section_identifier

 

     return options_dict

@@ -242,7 +265,7 @@ options_templates = {}
 options_templates.update(options_section(('saving-images', "Saving images/grids"), {

     "samples_save": OptionInfo(True, "Always save all generated images"),

     "samples_format": OptionInfo('png', 'File format for images'),

-    "samples_filename_pattern": OptionInfo("", "Images filename pattern", component_args=hide_dirs),

+    "samples_filename_pattern": OptionInfo("", "Images filename pattern", component_args=hide_dirs).link("wiki", "https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Custom-Images-Filename-Name-and-Subdirectory"),

     "save_images_add_number": OptionInfo(True, "Add number to filename when saving", component_args=hide_dirs),

 

     "grid_save": OptionInfo(True, "Always save all generated image grids"),

@@ -261,10 +284,10 @@ options_templates.update(options_section(('saving-images', "Saving images/grids"
     "save_mask_composite": OptionInfo(False, "For inpainting, save a masked composite"),

     "jpeg_quality": OptionInfo(80, "Quality for saved jpeg images", gr.Slider, {"minimum": 1, "maximum": 100, "step": 1}),

     "webp_lossless": OptionInfo(False, "Use lossless compression for webp images"),

-    "export_for_4chan": OptionInfo(True, "If the saved image file size is above the limit, or its either width or height are above the limit, save a downscaled copy as JPG"),

+    "export_for_4chan": OptionInfo(True, "Save copy of large images as JPG").info("if the file size is above the limit, or either width or height are above the limit"),

     "img_downscale_threshold": OptionInfo(4.0, "File size limit for the above option, MB", gr.Number),

     "target_side_length": OptionInfo(4000, "Width/height limit for the above option, in pixels", gr.Number),

-    "img_max_size_mp": OptionInfo(200, "Maximum image size, in megapixels", gr.Number),

+    "img_max_size_mp": OptionInfo(200, "Maximum image size", gr.Number).info("in megapixels"),

 

     "use_original_name_batch": OptionInfo(True, "Use original name for output filename during batch process in extras tab"),

     "use_upscaler_name_as_suffix": OptionInfo(False, "Use upscaler name as filename suffix in the extras tab"),

@@ -292,28 +315,26 @@ options_templates.update(options_section(('saving-to-dirs', "Saving to a directo
     "save_to_dirs": OptionInfo(True, "Save images to a subdirectory"),

     "grid_save_to_dirs": OptionInfo(True, "Save grids to a subdirectory"),

     "use_save_to_dirs_for_ui": OptionInfo(False, "When using \"Save\" button, save images to a subdirectory"),

-    "directories_filename_pattern": OptionInfo("[date]", "Directory name pattern", component_args=hide_dirs),

+    "directories_filename_pattern": OptionInfo("[date]", "Directory name pattern", component_args=hide_dirs).link("wiki", "https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Custom-Images-Filename-Name-and-Subdirectory"),

     "directories_max_prompt_words": OptionInfo(8, "Max prompt words for [prompt_words] pattern", gr.Slider, {"minimum": 1, "maximum": 20, "step": 1, **hide_dirs}),

 }))

 

 options_templates.update(options_section(('upscaling', "Upscaling"), {

-    "ESRGAN_tile": OptionInfo(192, "Tile size for ESRGAN upscalers. 0 = no tiling.", gr.Slider, {"minimum": 0, "maximum": 512, "step": 16}),

-    "ESRGAN_tile_overlap": OptionInfo(8, "Tile overlap, in pixels for ESRGAN upscalers. Low values = visible seam.", gr.Slider, {"minimum": 0, "maximum": 48, "step": 1}),

-    "realesrgan_enabled_models": OptionInfo(["R-ESRGAN 4x+", "R-ESRGAN 4x+ Anime6B"], "Select which Real-ESRGAN models to show in the web UI. (Requires restart)", gr.CheckboxGroup, lambda: {"choices": shared_items.realesrgan_models_names()}),

+    "ESRGAN_tile": OptionInfo(192, "Tile size for ESRGAN upscalers.", gr.Slider, {"minimum": 0, "maximum": 512, "step": 16}).info("0 = no tiling"),

+    "ESRGAN_tile_overlap": OptionInfo(8, "Tile overlap for ESRGAN upscalers.", gr.Slider, {"minimum": 0, "maximum": 48, "step": 1}).info("Low values = visible seam"),

+    "realesrgan_enabled_models": OptionInfo(["R-ESRGAN 4x+", "R-ESRGAN 4x+ Anime6B"], "Select which Real-ESRGAN models to show in the web UI.", gr.CheckboxGroup, lambda: {"choices": shared_items.realesrgan_models_names()}),

     "upscaler_for_img2img": OptionInfo(None, "Upscaler for img2img", gr.Dropdown, lambda: {"choices": [x.name for x in sd_upscalers]}),

-    "SCUNET_tile": OptionInfo(256, "Tile size for SCUNET upscalers. 0 = no tiling.", gr.Slider, {"minimum": 0, "maximum": 512, "step": 16}),

-    "SCUNET_tile_overlap": OptionInfo(8, "Tile overlap, in pixels for SCUNET upscalers. Low values = visible seam.", gr.Slider, {"minimum": 0, "maximum": 64, "step": 1}),

 }))

 

 options_templates.update(options_section(('face-restoration', "Face restoration"), {

     "face_restoration_model": OptionInfo("CodeFormer", "Face restoration model", gr.Radio, lambda: {"choices": [x.name() for x in face_restorers]}),

-    "code_former_weight": OptionInfo(0.5, "CodeFormer weight parameter; 0 = maximum effect; 1 = minimum effect", gr.Slider, {"minimum": 0, "maximum": 1, "step": 0.01}),

+    "code_former_weight": OptionInfo(0.5, "CodeFormer weight", gr.Slider, {"minimum": 0, "maximum": 1, "step": 0.01}).info("0 = maximum effect; 1 = minimum effect"),

     "face_restoration_unload": OptionInfo(False, "Move face restoration model from VRAM into RAM after processing"),

 }))

 

 options_templates.update(options_section(('system', "System"), {

     "show_warnings": OptionInfo(False, "Show warnings in console."),

-    "memmon_poll_rate": OptionInfo(8, "VRAM usage polls per second during generation. Set to 0 to disable.", gr.Slider, {"minimum": 0, "maximum": 40, "step": 1}),

+    "memmon_poll_rate": OptionInfo(8, "VRAM usage polls per second during generation.", gr.Slider, {"minimum": 0, "maximum": 40, "step": 1}).info("0 = disable"),

     "samples_log_stdout": OptionInfo(False, "Always print all generation info to standard output"),

     "multiple_tqdm": OptionInfo(True, "Add a second progress bar to the console that shows progress for an entire job."),

     "print_hypernet_extra": OptionInfo(False, "Print extra hypernetwork information to console."),

@@ -338,20 +359,22 @@ options_templates.update(options_section(('sd', "Stable Diffusion"), {
     "sd_model_checkpoint": OptionInfo(None, "Stable Diffusion checkpoint", gr.Dropdown, lambda: {"choices": list_checkpoint_tiles()}, refresh=refresh_checkpoints),

     "sd_checkpoint_cache": OptionInfo(0, "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", "SD VAE", gr.Dropdown, lambda: {"choices": shared_items.sd_vae_items()}, refresh=shared_items.refresh_vae_list),

+    "sd_vae": OptionInfo("Automatic", "SD VAE", gr.Dropdown, lambda: {"choices": shared_items.sd_vae_items()}, refresh=shared_items.refresh_vae_list).info("choose VAE model: Automatic = use one with same filename as checkpoint; None = use VAE from checkpoint"),

     "sd_vae_as_default": OptionInfo(True, "Ignore selected VAE for stable diffusion checkpoints that have their own .vae.pt next to them"),

     "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, "With img2img, do exactly the amount of steps the slider specifies (normally you'd do less with less denoising)."),

+    "img2img_fix_steps": OptionInfo(False, "With img2img, do exactly the amount of steps the slider specifies.").info("normally you'd do less with less denoising"),

     "img2img_background_color": OptionInfo("#ffffff", "With img2img, fill image's transparent parts with this color.", ui_components.FormColorPicker, {}),

     "enable_quantization": OptionInfo(False, "Enable quantization in K samplers for sharper and cleaner results. This may change existing seeds. Requires restart to apply."),

-    "enable_emphasis": OptionInfo(True, "Emphasis: use (text) to make model pay more attention to text and [text] to make it pay less attention"),

+    "enable_emphasis": OptionInfo(True, "Enable emphasis").info("use (text) to make model pay more attention to text and [text] to make it pay less attention"),

     "enable_batch_seeds": OptionInfo(True, "Make K-diffusion samplers produce same images in a batch as when making a single image"),

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

+    "comma_padding_backtrack": OptionInfo(20, "Prompt word wrap length limit", gr.Slider, {"minimum": 0, "maximum": 74, "step": 1}).info("in tokens - for texts shorter than specified, if they don't fit into 75 token limit, move them to the next 75 token chunk"),

+    "CLIP_stop_at_last_layers": OptionInfo(1, "Clip skip", gr.Slider, {"minimum": 1, "maximum": 12, "step": 1}).link("wiki", "https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Features#clip-skip").info("ignore last layers of CLIP nrtwork; 1 ignores none, 2 ignores one layer"),

     "upcast_attn": OptionInfo(False, "Upcast cross attention layer to float32"),

-    "randn_source": OptionInfo("GPU", "Random number generator source. Changes seeds drastically. Use CPU to produce the same picture across different vidocard vendors.", gr.Radio, {"choices": ["GPU", "CPU"]}),

+    "randn_source": OptionInfo("GPU", "Random number generator source.", gr.Radio, {"choices": ["GPU", "CPU"]}).info("changes seeds drastically; use CPU to produce the same picture across different vidocard vendors"),

+    "token_merging_ratio": OptionInfo(0.0, "Token merging ratio", gr.Slider, {"minimum": 0.0, "maximum": 0.9, "step": 0.1}).link("PR", "https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/9256").info("0=disable, higher=faster"),

+    "token_merging_ratio_hr": OptionInfo(0.0, "Togen merging ratio for high-res pass", gr.Slider, {"minimum": 0.0, "maximum": 0.9, "step": 0.1}),

 }))

 

 options_templates.update(options_section(('compatibility', "Compatibility"), {

@@ -363,80 +386,87 @@ options_templates.update(options_section(('compatibility', "Compatibility"), {
 }))

 

 options_templates.update(options_section(('interrogate', "Interrogate Options"), {

-    "interrogate_keep_models_in_memory": OptionInfo(False, "Interrogate: keep models in VRAM"),

-    "interrogate_return_ranks": OptionInfo(False, "Interrogate: include ranks of model tags matches in results (Has no effect on caption-based interrogators)."),

-    "interrogate_clip_num_beams": OptionInfo(1, "Interrogate: num_beams for BLIP", gr.Slider, {"minimum": 1, "maximum": 16, "step": 1}),

-    "interrogate_clip_min_length": OptionInfo(24, "Interrogate: minimum description length (excluding artists, etc..)", gr.Slider, {"minimum": 1, "maximum": 128, "step": 1}),

-    "interrogate_clip_max_length": OptionInfo(48, "Interrogate: maximum description length", gr.Slider, {"minimum": 1, "maximum": 256, "step": 1}),

-    "interrogate_clip_dict_limit": OptionInfo(1500, "CLIP: maximum number of lines in text file (0 = No limit)"),

+    "interrogate_keep_models_in_memory": OptionInfo(False, "Keep models in VRAM"),

+    "interrogate_return_ranks": OptionInfo(False, "Include ranks of model tags matches in results.").info("booru only"),

+    "interrogate_clip_num_beams": OptionInfo(1, "BLIP: num_beams", gr.Slider, {"minimum": 1, "maximum": 16, "step": 1}),

+    "interrogate_clip_min_length": OptionInfo(24, "BLIP: minimum description length", gr.Slider, {"minimum": 1, "maximum": 128, "step": 1}),

+    "interrogate_clip_max_length": OptionInfo(48, "BLIP: maximum description length", gr.Slider, {"minimum": 1, "maximum": 256, "step": 1}),

+    "interrogate_clip_dict_limit": OptionInfo(1500, "CLIP: maximum number of lines in text file").info("0 = No limit"),

     "interrogate_clip_skip_categories": OptionInfo([], "CLIP: skip inquire categories", gr.CheckboxGroup, lambda: {"choices": modules.interrogate.category_types()}, refresh=modules.interrogate.category_types),

-    "interrogate_deepbooru_score_threshold": OptionInfo(0.5, "Interrogate: deepbooru score threshold", gr.Slider, {"minimum": 0, "maximum": 1, "step": 0.01}),

-    "deepbooru_sort_alpha": OptionInfo(True, "Interrogate: deepbooru sort alphabetically"),

-    "deepbooru_use_spaces": OptionInfo(False, "use spaces for tags in deepbooru"),

-    "deepbooru_escape": OptionInfo(True, "escape (\\) brackets in deepbooru (so they are used as literal brackets and not for emphasis)"),

-    "deepbooru_filter_tags": OptionInfo("", "filter out those tags from deepbooru output (separated by comma)"),

+    "interrogate_deepbooru_score_threshold": OptionInfo(0.5, "deepbooru: score threshold", gr.Slider, {"minimum": 0, "maximum": 1, "step": 0.01}),

+    "deepbooru_sort_alpha": OptionInfo(True, "deepbooru: sort tags alphabetically").info("if not: sort by score"),

+    "deepbooru_use_spaces": OptionInfo(True, "deepbooru: use spaces in tags").info("if not: use underscores"),

+    "deepbooru_escape": OptionInfo(True, "deepbooru: escape (\\) brackets").info("so they are used as literal brackets and not for emphasis"),

+    "deepbooru_filter_tags": OptionInfo("", "deepbooru: filter out those tags").info("separate by comma"),

 }))

 

 options_templates.update(options_section(('extra_networks', "Extra Networks"), {

     "extra_networks_default_view": OptionInfo("cards", "Default view for Extra Networks", gr.Dropdown, {"choices": ["cards", "thumbs"]}),

     "extra_networks_default_multiplier": OptionInfo(1.0, "Multiplier for extra networks", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),

-    "extra_networks_card_width": OptionInfo(0, "Card width for Extra Networks (px)"),

-    "extra_networks_card_height": OptionInfo(0, "Card height for Extra Networks (px)"),

-    "extra_networks_add_text_separator": OptionInfo(" ", "Extra text to add before <...> when adding extra network to prompt"),

-    "sd_hypernetwork": OptionInfo("None", "Add hypernetwork to prompt", gr.Dropdown, lambda: {"choices": ["None"] + [x for x in hypernetworks.keys()]}, refresh=reload_hypernetworks),

+    "extra_networks_card_width": OptionInfo(0, "Card width for Extra Networks").info("in pixels"),

+    "extra_networks_card_height": OptionInfo(0, "Card height for Extra Networks").info("in pixels"),

+    "extra_networks_add_text_separator": OptionInfo(" ", "Extra networks separator").info("extra text to add before <...> when adding extra network to prompt"),

+    "sd_hypernetwork": OptionInfo("None", "Add hypernetwork to prompt", gr.Dropdown, lambda: {"choices": ["None", *hypernetworks]}, refresh=reload_hypernetworks),

 }))

 

 options_templates.update(options_section(('ui', "User interface"), {

+    "localization": OptionInfo("None", "Localization", gr.Dropdown, lambda: {"choices": ["None"] + list(localization.localizations.keys())}, refresh=lambda: localization.list_localizations(cmd_opts.localizations_dir)).needs_restart(),

+    "gradio_theme": OptionInfo("Default", "Gradio theme", ui_components.DropdownEditable, lambda: {"choices": ["Default"] + gradio_hf_hub_themes}).needs_restart(),

     "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, "When reading generation parameters from text into UI (from PNG info or pasted text), do not change the selected model/checkpoint."),

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

     "js_modal_lightbox_initially_zoomed": OptionInfo(True, "Show images zoomed in by default in full page image viewer"),

+    "js_modal_lightbox_gamepad": OptionInfo(True, "Navigate image viewer with gamepad"),

+    "js_modal_lightbox_gamepad_repeat": OptionInfo(250, "Gamepad repeat period, in milliseconds"),

     "show_progress_in_title": OptionInfo(True, "Show generation progress in window title."),

-    "samplers_in_dropdown": OptionInfo(True, "Use dropdown for sampler selection instead of radio group"),

-    "dimensions_and_batch_together": OptionInfo(True, "Show Width/Height and Batch sliders in same row"),

+    "samplers_in_dropdown": OptionInfo(True, "Use dropdown for sampler selection instead of radio group").needs_restart(),

+    "dimensions_and_batch_together": OptionInfo(True, "Show Width/Height and Batch sliders in same row").needs_restart(),

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

-    "keyedit_delimiters": OptionInfo(".,\/!?%^*;:{}=`~()", "Ctrl+up/down word delimiters"),

-    "quicksettings": OptionInfo("sd_model_checkpoint", "Quicksettings list"),

-    "hidden_tabs": OptionInfo([], "Hidden UI tabs (requires restart)", ui_components.DropdownMulti, lambda: {"choices": [x for x in tab_names]}),

+    "keyedit_delimiters": OptionInfo(".,\\/!?%^*;:{}=`~()", "Ctrl+up/down word delimiters"),

+    "quicksettings_list": OptionInfo(["sd_model_checkpoint"], "Quicksettings list", ui_components.DropdownMulti, lambda: {"choices": list(opts.data_labels.keys())}).js("info", "settingsHintsShowQuicksettings").info("setting entries that appear at the top of page rather than in settings tab").needs_restart(),

+    "hidden_tabs": OptionInfo([], "Hidden UI tabs", ui_components.DropdownMulti, lambda: {"choices": list(tab_names)}).needs_restart(),

     "ui_reorder": OptionInfo(", ".join(ui_reorder_categories), "txt2img/img2img UI item order"),

-    "ui_extra_networks_tab_reorder": OptionInfo("", "Extra networks tab order"),

-    "localization": OptionInfo("None", "Localization (requires restart)", gr.Dropdown, lambda: {"choices": ["None"] + list(localization.localizations.keys())}, refresh=lambda: localization.list_localizations(cmd_opts.localizations_dir)),

-    "gradio_theme": OptionInfo("Default", "Gradio theme (requires restart)", ui_components.DropdownEditable, lambda: {"choices": ["Default"] + gradio_hf_hub_themes})

+    "ui_extra_networks_tab_reorder": OptionInfo("", "Extra networks tab order").needs_restart(),

+}))

+

+options_templates.update(options_section(('infotext', "Infotext"), {

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

+    "add_version_to_infotext": OptionInfo(True, "Add program version to generation information"),

+    "disable_weights_auto_swap": OptionInfo(True, "When reading generation parameters from text into UI (from PNG info or pasted text), do not change the selected model/checkpoint."),

 }))

 

 options_templates.update(options_section(('ui', "Live previews"), {

     "show_progressbar": OptionInfo(True, "Show progressbar"),

     "live_previews_enable": OptionInfo(True, "Show live previews of the created image"),

+    "live_previews_image_format": OptionInfo("png", "Live preview file format", gr.Radio, {"choices": ["jpeg", "png", "webp"]}),

     "show_progress_grid": OptionInfo(True, "Show previews of all images generated in a batch as a grid"),

-    "show_progress_every_n_steps": OptionInfo(10, "Show new live preview image every N sampling steps. Set to -1 to show after completion of batch.", gr.Slider, {"minimum": -1, "maximum": 32, "step": 1}),

-    "show_progress_type": OptionInfo("Approx NN", "Image creation progress preview mode", gr.Radio, {"choices": ["Full", "Approx NN", "Approx cheap"]}),

+    "show_progress_every_n_steps": OptionInfo(10, "Live preview display period", gr.Slider, {"minimum": -1, "maximum": 32, "step": 1}).info("in sampling steps - show new live preview image every N sampling steps; -1 = only show after completion of batch"),

+    "show_progress_type": OptionInfo("Approx NN", "Live preview method", gr.Radio, {"choices": ["Full", "Approx NN", "Approx cheap"]}).info("Full = slow but pretty; Approx NN = fast but low quality; Approx cheap = super fast but terrible otherwise"),

     "live_preview_content": OptionInfo("Prompt", "Live preview subject", gr.Radio, {"choices": ["Combined", "Prompt", "Negative prompt"]}),

-    "live_preview_refresh_period": OptionInfo(1000, "Progressbar/preview update period, in milliseconds")

+    "live_preview_refresh_period": OptionInfo(1000, "Progressbar and preview update period").info("in milliseconds"),

 }))

 

 options_templates.update(options_section(('sampler-params', "Sampler parameters"), {

-    "hide_samplers": OptionInfo([], "Hide samplers in user interface (requires restart)", gr.CheckboxGroup, lambda: {"choices": [x.name for x in list_samplers()]}),

-    "eta_ddim": OptionInfo(0.0, "eta (noise multiplier) for DDIM", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),

-    "eta_ancestral": OptionInfo(1.0, "eta (noise multiplier) for ancestral samplers", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),

+    "hide_samplers": OptionInfo([], "Hide samplers in user interface", gr.CheckboxGroup, lambda: {"choices": [x.name for x in list_samplers()]}).needs_restart(),

+    "eta_ddim": OptionInfo(0.0, "Eta for DDIM", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}).info("noise multiplier; higher = more unperdictable results"),

+    "eta_ancestral": OptionInfo(1.0, "Eta for ancestral samplers", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}).info("noise multiplier; applies to Euler a and other samplers that have a in them"),

     "ddim_discretize": OptionInfo('uniform', "img2img DDIM discretize", gr.Radio, {"choices": ['uniform', 'quad']}),

     's_churn': OptionInfo(0.0, "sigma churn", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),

     's_min_uncond': OptionInfo(0, "Negative Guidance minimum sigma", gr.Slider, {"minimum": 0.0, "maximum": 4.0, "step": 0.01}),

     's_tmin':  OptionInfo(0.0, "sigma tmin",  gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),

     's_noise': OptionInfo(1.0, "sigma noise", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),

-    'eta_noise_seed_delta': OptionInfo(0, "Eta noise seed delta", gr.Number, {"precision": 0}),

-    'always_discard_next_to_last_sigma': OptionInfo(False, "Always discard next-to-last sigma"),

+    'eta_noise_seed_delta': OptionInfo(0, "Eta noise seed delta", gr.Number, {"precision": 0}).info("ENSD; does not improve anything, just produces different results for ancestral samplers - only useful for reproducing images"),

+    'always_discard_next_to_last_sigma': OptionInfo(False, "Always discard next-to-last sigma").link("PR", "https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/6044"),

     'uni_pc_variant': OptionInfo("bh1", "UniPC variant", gr.Radio, {"choices": ["bh1", "bh2", "vary_coeff"]}),

     'uni_pc_skip_type': OptionInfo("time_uniform", "UniPC skip type", gr.Radio, {"choices": ["time_uniform", "time_quadratic", "logSNR"]}),

-    'uni_pc_order': OptionInfo(3, "UniPC order (must be < sampling steps)", gr.Slider, {"minimum": 1, "maximum": 50, "step": 1}),

+    'uni_pc_order': OptionInfo(3, "UniPC order", gr.Slider, {"minimum": 1, "maximum": 50, "step": 1}).info("must be < sampling steps"),

     'uni_pc_lower_order_final': OptionInfo(True, "UniPC lower order final"),

 }))

 

@@ -453,6 +483,7 @@ options_templates.update(options_section((None, "Hidden options"), {
     "sd_checkpoint_hash": OptionInfo("", "SHA256 hash of the current checkpoint"),

 }))

 

+

 options_templates.update()

 

 

@@ -542,6 +573,10 @@ class Options:
         with open(filename, "r", encoding="utf8") as file:

             self.data = json.load(file)

 

+        # 1.1.1 quicksettings list migration

+        if self.data.get('quicksettings') is not None and self.data.get('quicksettings_list') is None:

+            self.data['quicksettings_list'] = [i.strip() for i in self.data.get('quicksettings').split(',')]

+

         bad_settings = 0

         for k, v in self.data.items():

             info = self.data_labels.get(k, None)

@@ -560,7 +595,9 @@ class Options:
             func()

 

     def dumpjson(self):

-        d = {k: self.data.get(k, self.data_labels.get(k).default) for k in self.data_labels.keys()}

+        d = {k: self.data.get(k, v.default) for k, v in self.data_labels.items()}

+        d["_comments_before"] = {k: v.comment_before for k, v in self.data_labels.items() if v.comment_before is not None}

+        d["_comments_after"] = {k: v.comment_after for k, v in self.data_labels.items() if v.comment_after is not None}

         return json.dumps(d)

 

     def add_option(self, key, info):

@@ -571,11 +608,11 @@ class Options:
 

         section_ids = {}

         settings_items = self.data_labels.items()

-        for k, item in settings_items:

+        for _, item in settings_items:

             if item.section not in section_ids:

                 section_ids[item.section] = len(section_ids)

 

-        self.data_labels = {k: v for k, v in sorted(settings_items, key=lambda x: section_ids[x[1].section])}

+        self.data_labels = dict(sorted(settings_items, key=lambda x: section_ids[x[1].section]))

 

     def cast_value(self, key, value):

         """casts an arbitrary to the same type as this setting's value with key

@@ -600,13 +637,37 @@ class Options:
         return value

 

 

-

 opts = Options()

 if os.path.exists(config_filename):

     opts.load(config_filename)

 

+

+class Shared(sys.modules[__name__].__class__):

+    """

+    this class is here to provide sd_model field as a property, so that it can be created and loaded on demand rather than

+    at program startup.

+    """

+

+    sd_model_val = None

+

+    @property

+    def sd_model(self):

+        import modules.sd_models

+

+        return modules.sd_models.model_data.get_sd_model()

+

+    @sd_model.setter

+    def sd_model(self, value):

+        import modules.sd_models

+

+        modules.sd_models.model_data.set_sd_model(value)

+

+

+sd_model: LatentDiffusion = None  # this var is here just for IDE's type checking; it cannot be accessed because the class field above will be accessed instead

+sys.modules[__name__].__class__ = Shared

+

 settings_components = None

-"""assinged from ui.py, a mapping on setting anmes to gradio components repsponsible for those settings"""

+"""assinged from ui.py, a mapping on setting names to gradio components repsponsible for those settings"""

 

 latent_upscale_default_mode = "Latent"

 latent_upscale_modes = {

@@ -620,8 +681,6 @@ latent_upscale_modes = {
 

 sd_upscalers = []

 

-sd_model = None

-

 clip_model = None

 

 progress_print_out = sys.stdout

@@ -634,14 +693,19 @@ def reload_gradio_theme(theme_name=None):
     if not theme_name:

         theme_name = opts.gradio_theme

 

+    default_theme_args = dict(

+        font=["Source Sans Pro", 'ui-sans-serif', 'system-ui', 'sans-serif'],

+        font_mono=['IBM Plex Mono', 'ui-monospace', 'Consolas', 'monospace'],

+    )

+

     if theme_name == "Default":

-        gradio_theme = gr.themes.Default()

+        gradio_theme = gr.themes.Default(**default_theme_args)

     else:

         try:

             gradio_theme = gr.themes.ThemeClass.from_hub(theme_name)

-        except requests.exceptions.ConnectionError:

-            print("Can't access HuggingFace Hub, falling back to default Gradio theme")

-            gradio_theme = gr.themes.Default()

+        except Exception as e:

+            errors.display(e, "changing gradio theme")

+            gradio_theme = gr.themes.Default(**default_theme_args)

 

 

 

@@ -701,3 +765,20 @@ def html(filename):
             return file.read()

 

     return ""

+

+

+def walk_files(path, allowed_extensions=None):

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

+        return

+

+    if allowed_extensions is not None:

+        allowed_extensions = set(allowed_extensions)

+

+    for root, _, files in os.walk(path, followlinks=True):

+        for filename in files:

+            if allowed_extensions is not None:

+                _, ext = os.path.splitext(filename)

+                if ext not in allowed_extensions:

+                    continue

+

+            yield os.path.join(root, filename)

diff --git a/modules/styles.py b/modules/styles.py
index 9ed85991..c22769cf 100644
--- a/modules/styles.py
+++ b/modules/styles.py
@@ -1,18 +1,9 @@
-# We need this so Python doesn't complain about the unknown StableDiffusionProcessing-typehint at runtime

-from __future__ import annotations

-

 import csv

 import os

 import os.path

 import typing

-import collections.abc as abc

-import tempfile

 import shutil

 

-if typing.TYPE_CHECKING:

-    # Only import this when code is being type-checked, it doesn't have any effect at runtime

-    from .processing import StableDiffusionProcessing

-

 

 class PromptStyle(typing.NamedTuple):

     name: str

@@ -74,7 +65,7 @@ class StyleDatabase:
     def save_styles(self, path: str) -> None:

         # Always keep a backup file around

         if os.path.exists(path):

-            shutil.copy(path, path + ".bak")

+            shutil.copy(path, f"{path}.bak")

 

         fd = os.open(path, os.O_RDWR|os.O_CREAT)

         with os.fdopen(fd, "w", encoding="utf-8-sig", newline='') as file:

diff --git a/modules/sub_quadratic_attention.py b/modules/sub_quadratic_attention.py
index 05595323..497568eb 100644
--- a/modules/sub_quadratic_attention.py
+++ b/modules/sub_quadratic_attention.py
@@ -179,7 +179,7 @@ def efficient_dot_product_attention(
             chunk_idx,
             min(query_chunk_size, q_tokens)
         )
-    
+
     summarize_chunk: SummarizeChunk = partial(_summarize_chunk, scale=scale)
     summarize_chunk: SummarizeChunk = partial(checkpoint, summarize_chunk) if use_checkpoint else summarize_chunk
     compute_query_chunk_attn: ComputeQueryChunkAttn = partial(
@@ -201,14 +201,15 @@ def efficient_dot_product_attention(
             key=key,
             value=value,
         )
-    
-    # TODO: maybe we should use torch.empty_like(query) to allocate storage in-advance,
-    # and pass slices to be mutated, instead of torch.cat()ing the returned slices
-    res = torch.cat([
-        compute_query_chunk_attn(
+
+    res = torch.zeros_like(query)
+    for i in range(math.ceil(q_tokens / query_chunk_size)):
+        attn_scores = compute_query_chunk_attn(
             query=get_query_chunk(i * query_chunk_size),
             key=key,
             value=value,
-        ) for i in range(math.ceil(q_tokens / query_chunk_size))
-    ], dim=1)
+        )
+
+        res[:, i * query_chunk_size:i * query_chunk_size + attn_scores.shape[1], :] = attn_scores
+
     return res
diff --git a/modules/textual_inversion/autocrop.py b/modules/textual_inversion/autocrop.py
index 68e1103c..8e667a4d 100644
--- a/modules/textual_inversion/autocrop.py
+++ b/modules/textual_inversion/autocrop.py
@@ -1,10 +1,8 @@
 import cv2

 import requests

 import os

-from collections import defaultdict

-from math import log, sqrt

 import numpy as np

-from PIL import Image, ImageDraw

+from PIL import ImageDraw

 

 GREEN = "#0F0"

 BLUE = "#00F"

@@ -12,63 +10,64 @@ RED = "#F00"
 

 

 def crop_image(im, settings):

-  """ Intelligently crop an image to the subject matter """

-

-  scale_by = 1

-  if is_landscape(im.width, im.height):

-    scale_by = settings.crop_height / im.height

-  elif is_portrait(im.width, im.height):

-    scale_by = settings.crop_width / im.width

-  elif is_square(im.width, im.height):

-    if is_square(settings.crop_width, settings.crop_height):

-      scale_by = settings.crop_width / im.width

-    elif is_landscape(settings.crop_width, settings.crop_height):

-      scale_by = settings.crop_width / im.width

-    elif is_portrait(settings.crop_width, settings.crop_height):

-      scale_by = settings.crop_height / im.height

-

-  im = im.resize((int(im.width * scale_by), int(im.height * scale_by)))

-  im_debug = im.copy()

-

-  focus = focal_point(im_debug, settings)

-

-  # take the focal point and turn it into crop coordinates that try to center over the focal

-  # point but then get adjusted back into the frame

-  y_half = int(settings.crop_height / 2)

-  x_half = int(settings.crop_width / 2)

-

-  x1 = focus.x - x_half

-  if x1 < 0:

-      x1 = 0

-  elif x1 + settings.crop_width > im.width:

-      x1 = im.width - settings.crop_width

-

-  y1 = focus.y - y_half

-  if y1 < 0:

-      y1 = 0

-  elif y1 + settings.crop_height > im.height:

-      y1 = im.height - settings.crop_height

-

-  x2 = x1 + settings.crop_width

-  y2 = y1 + settings.crop_height

-

-  crop = [x1, y1, x2, y2]

-

-  results = []

-

-  results.append(im.crop(tuple(crop)))

-

-  if settings.annotate_image:

-    d = ImageDraw.Draw(im_debug)

-    rect = list(crop)

-    rect[2] -= 1

-    rect[3] -= 1

-    d.rectangle(rect, outline=GREEN)

-    results.append(im_debug)

-    if settings.destop_view_image:

-      im_debug.show()

-

-  return results

+    """ Intelligently crop an image to the subject matter """

+

+    scale_by = 1

+    if is_landscape(im.width, im.height):

+        scale_by = settings.crop_height / im.height

+    elif is_portrait(im.width, im.height):

+        scale_by = settings.crop_width / im.width

+    elif is_square(im.width, im.height):

+        if is_square(settings.crop_width, settings.crop_height):

+            scale_by = settings.crop_width / im.width

+        elif is_landscape(settings.crop_width, settings.crop_height):

+            scale_by = settings.crop_width / im.width

+        elif is_portrait(settings.crop_width, settings.crop_height):

+            scale_by = settings.crop_height / im.height

+

+

+    im = im.resize((int(im.width * scale_by), int(im.height * scale_by)))

+    im_debug = im.copy()

+

+    focus = focal_point(im_debug, settings)

+

+    # take the focal point and turn it into crop coordinates that try to center over the focal

+    # point but then get adjusted back into the frame

+    y_half = int(settings.crop_height / 2)

+    x_half = int(settings.crop_width / 2)

+

+    x1 = focus.x - x_half

+    if x1 < 0:

+        x1 = 0

+    elif x1 + settings.crop_width > im.width:

+        x1 = im.width - settings.crop_width

+

+    y1 = focus.y - y_half

+    if y1 < 0:

+        y1 = 0

+    elif y1 + settings.crop_height > im.height:

+        y1 = im.height - settings.crop_height

+

+    x2 = x1 + settings.crop_width

+    y2 = y1 + settings.crop_height

+

+    crop = [x1, y1, x2, y2]

+

+    results = []

+

+    results.append(im.crop(tuple(crop)))

+

+    if settings.annotate_image:

+        d = ImageDraw.Draw(im_debug)

+        rect = list(crop)

+        rect[2] -= 1

+        rect[3] -= 1

+        d.rectangle(rect, outline=GREEN)

+        results.append(im_debug)

+        if settings.destop_view_image:

+            im_debug.show()

+

+    return results

 

 def focal_point(im, settings):

     corner_points = image_corner_points(im, settings) if settings.corner_points_weight > 0 else []

@@ -88,7 +87,7 @@ def focal_point(im, settings):
     corner_centroid = None

     if len(corner_points) > 0:

       corner_centroid = centroid(corner_points)

-      corner_centroid.weight = settings.corner_points_weight / weight_pref_total 

+      corner_centroid.weight = settings.corner_points_weight / weight_pref_total

       pois.append(corner_centroid)

 

     entropy_centroid = None

@@ -100,7 +99,7 @@ def focal_point(im, settings):
     face_centroid = None

     if len(face_points) > 0:

       face_centroid = centroid(face_points)

-      face_centroid.weight = settings.face_points_weight / weight_pref_total 

+      face_centroid.weight = settings.face_points_weight / weight_pref_total

       pois.append(face_centroid)

 

     average_point = poi_average(pois, settings)

@@ -111,7 +110,7 @@ def focal_point(im, settings):
       if corner_centroid is not None:

         color = BLUE

         box = corner_centroid.bounding(max_size * corner_centroid.weight)

-        d.text((box[0], box[1]-15), "Edge: %.02f" % corner_centroid.weight, fill=color)

+        d.text((box[0], box[1]-15), f"Edge: {corner_centroid.weight:.02f}", fill=color)

         d.ellipse(box, outline=color)

         if len(corner_points) > 1:

           for f in corner_points:

@@ -119,7 +118,7 @@ def focal_point(im, settings):
       if entropy_centroid is not None:

         color = "#ff0"

         box = entropy_centroid.bounding(max_size * entropy_centroid.weight)

-        d.text((box[0], box[1]-15), "Entropy: %.02f" % entropy_centroid.weight, fill=color)

+        d.text((box[0], box[1]-15), f"Entropy: {entropy_centroid.weight:.02f}", fill=color)

         d.ellipse(box, outline=color)

         if len(entropy_points) > 1:

           for f in entropy_points:

@@ -127,14 +126,14 @@ def focal_point(im, settings):
       if face_centroid is not None:

         color = RED

         box = face_centroid.bounding(max_size * face_centroid.weight)

-        d.text((box[0], box[1]-15), "Face: %.02f" % face_centroid.weight, fill=color)

+        d.text((box[0], box[1]-15), f"Face: {face_centroid.weight:.02f}", fill=color)

         d.ellipse(box, outline=color)

         if len(face_points) > 1:

           for f in face_points:

             d.rectangle(f.bounding(4), outline=color)

 

       d.ellipse(average_point.bounding(max_size), outline=GREEN)

-      

+

     return average_point

 

 

@@ -185,7 +184,7 @@ def image_face_points(im, settings):
         try:

           faces = classifier.detectMultiScale(gray, scaleFactor=1.1,

             minNeighbors=7, minSize=(minsize, minsize), flags=cv2.CASCADE_SCALE_IMAGE)

-        except:

+        except Exception:

           continue

 

         if len(faces) > 0:

@@ -262,10 +261,11 @@ def image_entropy(im):
     hist = hist[hist > 0]

     return -np.log2(hist / hist.sum()).sum()

 

+

 def centroid(pois):

-  x = [poi.x for poi in pois]

-  y = [poi.y for poi in pois]

-  return PointOfInterest(sum(x)/len(pois), sum(y)/len(pois))

+    x = [poi.x for poi in pois]

+    y = [poi.y for poi in pois]

+    return PointOfInterest(sum(x) / len(pois), sum(y) / len(pois))

 

 

 def poi_average(pois, settings):

@@ -283,59 +283,59 @@ def poi_average(pois, settings):
 

 

 def is_landscape(w, h):

-  return w > h

+    return w > h

 

 

 def is_portrait(w, h):

-  return h > w

+    return h > w

 

 

 def is_square(w, h):

-  return w == h

+    return w == h

 

 

 def download_and_cache_models(dirname):

-  download_url = 'https://github.com/opencv/opencv_zoo/blob/91fb0290f50896f38a0ab1e558b74b16bc009428/models/face_detection_yunet/face_detection_yunet_2022mar.onnx?raw=true'

-  model_file_name = 'face_detection_yunet.onnx'

+    download_url = 'https://github.com/opencv/opencv_zoo/blob/91fb0290f50896f38a0ab1e558b74b16bc009428/models/face_detection_yunet/face_detection_yunet_2022mar.onnx?raw=true'

+    model_file_name = 'face_detection_yunet.onnx'

 

-  if not os.path.exists(dirname):

-    os.makedirs(dirname)

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

+        os.makedirs(dirname)

 

-  cache_file = os.path.join(dirname, model_file_name)

-  if not os.path.exists(cache_file):

-    print(f"downloading face detection model from '{download_url}' to '{cache_file}'")

-    response = requests.get(download_url)

-    with open(cache_file, "wb") as f:

-      f.write(response.content)

+    cache_file = os.path.join(dirname, model_file_name)

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

+        print(f"downloading face detection model from '{download_url}' to '{cache_file}'")

+        response = requests.get(download_url)

+        with open(cache_file, "wb") as f:

+            f.write(response.content)

 

-  if os.path.exists(cache_file):

-    return cache_file

-  return None

+    if os.path.exists(cache_file):

+        return cache_file

+    return None

 

 

 class PointOfInterest:

-  def __init__(self, x, y, weight=1.0, size=10):

-    self.x = x

-    self.y = y

-    self.weight = weight

-    self.size = size

+    def __init__(self, x, y, weight=1.0, size=10):

+        self.x = x

+        self.y = y

+        self.weight = weight

+        self.size = size

 

-  def bounding(self, size):

-    return [

-      self.x - size//2,

-      self.y - size//2,

-      self.x + size//2,

-      self.y + size//2

-    ]

+    def bounding(self, size):

+        return [

+            self.x - size // 2,

+            self.y - size // 2,

+            self.x + size // 2,

+            self.y + size // 2

+        ]

 

 

 class Settings:

-  def __init__(self, crop_width=512, crop_height=512, corner_points_weight=0.5, entropy_points_weight=0.5, face_points_weight=0.5, annotate_image=False, dnn_model_path=None):

-    self.crop_width = crop_width

-    self.crop_height = crop_height

-    self.corner_points_weight = corner_points_weight

-    self.entropy_points_weight = entropy_points_weight

-    self.face_points_weight = face_points_weight

-    self.annotate_image = annotate_image

-    self.destop_view_image = False

-    self.dnn_model_path = dnn_model_path

+    def __init__(self, crop_width=512, crop_height=512, corner_points_weight=0.5, entropy_points_weight=0.5, face_points_weight=0.5, annotate_image=False, dnn_model_path=None):

+        self.crop_width = crop_width

+        self.crop_height = crop_height

+        self.corner_points_weight = corner_points_weight

+        self.entropy_points_weight = entropy_points_weight

+        self.face_points_weight = face_points_weight

+        self.annotate_image = annotate_image

+        self.destop_view_image = False

+        self.dnn_model_path = dnn_model_path

diff --git a/modules/textual_inversion/dataset.py b/modules/textual_inversion/dataset.py
index af9fbcf2..b9621fc9 100644
--- a/modules/textual_inversion/dataset.py
+++ b/modules/textual_inversion/dataset.py
@@ -72,7 +72,7 @@ class PersonalizedBase(Dataset):
             except Exception:

                 continue

 

-            text_filename = os.path.splitext(path)[0] + ".txt"

+            text_filename = f"{os.path.splitext(path)[0]}.txt"

             filename = os.path.basename(path)

 

             if os.path.exists(text_filename):

@@ -118,7 +118,7 @@ class PersonalizedBase(Dataset):
                 weight = torch.ones(latent_sample.shape)

             else:

                 weight = None

-            

+

             if latent_sampling_method == "random":

                 entry = DatasetEntry(filename=path, filename_text=filename_text, latent_dist=latent_dist, weight=weight)

             else:

@@ -243,4 +243,4 @@ class BatchLoaderRandom(BatchLoader):
         return self

 

 def collate_wrapper_random(batch):

-    return BatchLoaderRandom(batch)
\ No newline at end of file
+    return BatchLoaderRandom(batch)

diff --git a/modules/textual_inversion/image_embedding.py b/modules/textual_inversion/image_embedding.py
index 5593f88c..5858a55f 100644
--- a/modules/textual_inversion/image_embedding.py
+++ b/modules/textual_inversion/image_embedding.py
@@ -2,10 +2,8 @@ import base64
 import json

 import numpy as np

 import zlib

-from PIL import Image, PngImagePlugin, ImageDraw, ImageFont

-from fonts.ttf import Roboto

+from PIL import Image, ImageDraw, ImageFont

 import torch

-from modules.shared import opts

 

 

 class EmbeddingEncoder(json.JSONEncoder):

@@ -17,7 +15,7 @@ class EmbeddingEncoder(json.JSONEncoder):
 

 class EmbeddingDecoder(json.JSONDecoder):

     def __init__(self, *args, **kwargs):

-        json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)

+        json.JSONDecoder.__init__(self, *args, object_hook=self.object_hook, **kwargs)

 

     def object_hook(self, d):

         if 'TORCHTENSOR' in d:

@@ -136,11 +134,8 @@ def caption_image_overlay(srcimage, title, footerLeft, footerMid, footerRight, t
     image = srcimage.copy()

     fontsize = 32

     if textfont is None:

-        try:

-            textfont = ImageFont.truetype(opts.font or Roboto, fontsize)

-            textfont = opts.font or Roboto

-        except Exception:

-            textfont = Roboto

+        from modules.images import get_font

+        textfont = get_font(fontsize)

 

     factor = 1.5

     gradient = Image.new('RGBA', (1, image.size[1]), color=(0, 0, 0, 0))

diff --git a/modules/textual_inversion/learn_schedule.py b/modules/textual_inversion/learn_schedule.py
index f63fc72f..c56bea45 100644
--- a/modules/textual_inversion/learn_schedule.py
+++ b/modules/textual_inversion/learn_schedule.py
@@ -12,7 +12,7 @@ class LearnScheduleIterator:
         self.it = 0

         self.maxit = 0

         try:

-            for i, pair in enumerate(pairs):

+            for pair in pairs:

                 if not pair.strip():

                     continue

                 tmp = pair.split(':')

@@ -32,8 +32,8 @@ class LearnScheduleIterator:
                     self.maxit += 1

                     return

             assert self.rates

-        except (ValueError, AssertionError):

-            raise Exception('Invalid learning rate schedule. It should be a number or, for example, like "0.001:100, 0.00001:1000, 1e-5:10000" to have lr of 0.001 until step 100, 0.00001 until 1000, and 1e-5 until 10000.')

+        except (ValueError, AssertionError) as e:

+            raise Exception('Invalid learning rate schedule. It should be a number or, for example, like "0.001:100, 0.00001:1000, 1e-5:10000" to have lr of 0.001 until step 100, 0.00001 until 1000, and 1e-5 until 10000.') from e

 

 

     def __iter__(self):

diff --git a/modules/textual_inversion/preprocess.py b/modules/textual_inversion/preprocess.py
index 4a29151d..a009d8e8 100644
--- a/modules/textual_inversion/preprocess.py
+++ b/modules/textual_inversion/preprocess.py
@@ -1,13 +1,9 @@
 import os

 from PIL import Image, ImageOps

 import math

-import platform

-import sys

 import tqdm

-import time

 

 from modules import paths, shared, images, deepbooru

-from modules.shared import opts, cmd_opts

 from modules.textual_inversion import autocrop

 

 

@@ -63,9 +59,9 @@ def save_pic_with_caption(image, index, params: PreprocessParams, existing_capti
     image.save(os.path.join(params.dstdir, f"{basename}.png"))

 

     if params.preprocess_txt_action == 'prepend' and existing_caption:

-        caption = existing_caption + ' ' + caption

+        caption = f"{existing_caption} {caption}"

     elif params.preprocess_txt_action == 'append' and existing_caption:

-        caption = caption + ' ' + existing_caption

+        caption = f"{caption} {existing_caption}"

     elif params.preprocess_txt_action == 'copy' and existing_caption:

         caption = existing_caption

 

@@ -129,7 +125,7 @@ def multicrop_pic(image: Image, mindim, maxdim, minarea, maxarea, objective, thr
         default=None

     )

     return wh and center_crop(image, *wh)

-    

+

 

 def preprocess_work(process_src, process_dst, process_width, process_height, preprocess_txt_action, process_keep_original_size, process_flip, process_split, process_caption, process_caption_deepbooru=False, split_threshold=0.5, overlap_ratio=0.2, process_focal_crop=False, process_focal_crop_face_weight=0.9, process_focal_crop_entropy_weight=0.3, process_focal_crop_edges_weight=0.5, process_focal_crop_debug=False, process_multicrop=None, process_multicrop_mindim=None, process_multicrop_maxdim=None, process_multicrop_minarea=None, process_multicrop_maxarea=None, process_multicrop_objective=None, process_multicrop_threshold=None):

     width = process_width

@@ -174,7 +170,7 @@ def preprocess_work(process_src, process_dst, process_width, process_height, pre
         params.src = filename

 

         existing_caption = None

-        existing_caption_filename = os.path.splitext(filename)[0] + '.txt'

+        existing_caption_filename = f"{os.path.splitext(filename)[0]}.txt"

         if os.path.exists(existing_caption_filename):

             with open(existing_caption_filename, 'r', encoding="utf8") as file:

                 existing_caption = file.read()

diff --git a/modules/textual_inversion/textual_inversion.py b/modules/textual_inversion/textual_inversion.py
index 379df243..d489ed1e 100644
--- a/modules/textual_inversion/textual_inversion.py
+++ b/modules/textual_inversion/textual_inversion.py
@@ -1,7 +1,6 @@
 import os

 import sys

 import traceback

-import inspect

 from collections import namedtuple

 

 import torch

@@ -30,7 +29,7 @@ textual_inversion_templates = {}
 def list_textual_inversion_templates():

     textual_inversion_templates.clear()

 

-    for root, dirs, fns in os.walk(shared.cmd_opts.textual_inversion_templates_dir):

+    for root, _, fns in os.walk(shared.cmd_opts.textual_inversion_templates_dir):

         for fn in fns:

             path = os.path.join(root, fn)

 

@@ -69,7 +68,7 @@ class Embedding:
                 'hash': self.checksum(),

                 'optimizer_state_dict': self.optimizer_state_dict,

             }

-            torch.save(optimizer_saved_dict, filename + '.optim')

+            torch.save(optimizer_saved_dict, f"{filename}.optim")

 

     def checksum(self):

         if self.cached_checksum is not None:

@@ -167,8 +166,7 @@ class EmbeddingDatabase:
         # textual inversion embeddings

         if 'string_to_param' in data:

             param_dict = data['string_to_param']

-            if hasattr(param_dict, '_parameters'):

-                param_dict = getattr(param_dict, '_parameters')  # fix for torch 1.12.1 loading saved file from torch 1.11

+            param_dict = getattr(param_dict, '_parameters', param_dict)  # fix for torch 1.12.1 loading saved file from torch 1.11

             assert len(param_dict) == 1, 'embedding file has multiple terms in it'

             emb = next(iter(param_dict.items()))[1]

         # diffuser concepts

@@ -199,7 +197,7 @@ class EmbeddingDatabase:
         if not os.path.isdir(embdir.path):

             return

 

-        for root, dirs, fns in os.walk(embdir.path, followlinks=True):

+        for root, _, fns in os.walk(embdir.path, followlinks=True):

             for fn in fns:

                 try:

                     fullfn = os.path.join(root, fn)

@@ -216,7 +214,7 @@ class EmbeddingDatabase:
     def load_textual_inversion_embeddings(self, force_reload=False):

         if not force_reload:

             need_reload = False

-            for path, embdir in self.embedding_dirs.items():

+            for embdir in self.embedding_dirs.values():

                 if embdir.has_changed():

                     need_reload = True

                     break

@@ -229,7 +227,7 @@ class EmbeddingDatabase:
         self.skipped_embeddings.clear()

         self.expected_shape = self.get_expected_shape()

 

-        for path, embdir in self.embedding_dirs.items():

+        for embdir in self.embedding_dirs.values():

             self.load_from_dir(embdir)

             embdir.update()

 

@@ -325,16 +323,16 @@ def tensorboard_add(tensorboard_writer, loss, global_step, step, learn_rate, epo
     tensorboard_add_scaler(tensorboard_writer, f"Learn rate/train/epoch-{epoch_num}", learn_rate, step)

 

 def tensorboard_add_scaler(tensorboard_writer, tag, value, step):

-    tensorboard_writer.add_scalar(tag=tag, 

+    tensorboard_writer.add_scalar(tag=tag,

         scalar_value=value, global_step=step)

 

 def tensorboard_add_image(tensorboard_writer, tag, pil_image, step):

     # Convert a pil image to a torch tensor

     img_tensor = torch.as_tensor(np.array(pil_image, copy=True))

-    img_tensor = img_tensor.view(pil_image.size[1], pil_image.size[0], 

+    img_tensor = img_tensor.view(pil_image.size[1], pil_image.size[0],

         len(pil_image.getbands()))

     img_tensor = img_tensor.permute((2, 0, 1))

-                

+

     tensorboard_writer.add_image(tag, img_tensor, global_step=step)

 

 def validate_train_inputs(model_name, learn_rate, batch_size, gradient_step, data_root, template_file, template_filename, steps, save_model_every, create_image_every, log_directory, name="embedding"):

@@ -404,7 +402,7 @@ def train_embedding(id_task, embedding_name, learn_rate, batch_size, gradient_st
     if initial_step >= steps:

         shared.state.textinfo = "Model has already been trained beyond specified max steps"

         return embedding, filename

-    

+

     scheduler = LearnRateScheduler(learn_rate, steps, initial_step)

     clip_grad = torch.nn.utils.clip_grad_value_ if clip_grad_mode == "value" else \

         torch.nn.utils.clip_grad_norm_ if clip_grad_mode == "norm" else \

@@ -414,7 +412,7 @@ def train_embedding(id_task, embedding_name, learn_rate, batch_size, gradient_st
     # dataset loading may take a while, so input validations and early returns should be done before this

     shared.state.textinfo = f"Preparing dataset from {html.escape(data_root)}..."

     old_parallel_processing_allowed = shared.parallel_processing_allowed

-    

+

     if shared.opts.training_enable_tensorboard:

         tensorboard_writer = tensorboard_setup(log_directory)

 

@@ -437,11 +435,11 @@ def train_embedding(id_task, embedding_name, learn_rate, batch_size, gradient_st
     optimizer = torch.optim.AdamW([embedding.vec], lr=scheduler.learn_rate, weight_decay=0.0)

     if shared.opts.save_optimizer_state:

         optimizer_state_dict = None

-        if os.path.exists(filename + '.optim'):

-            optimizer_saved_dict = torch.load(filename + '.optim', map_location='cpu')

+        if os.path.exists(f"{filename}.optim"):

+            optimizer_saved_dict = torch.load(f"{filename}.optim", map_location='cpu')

             if embedding.checksum() == optimizer_saved_dict.get('hash', None):

                 optimizer_state_dict = optimizer_saved_dict.get('optimizer_state_dict', None)

-    

+

         if optimizer_state_dict is not None:

             optimizer.load_state_dict(optimizer_state_dict)

             print("Loaded existing optimizer from checkpoint")

@@ -470,7 +468,7 @@ def train_embedding(id_task, embedding_name, learn_rate, batch_size, gradient_st
     try:

         sd_hijack_checkpoint.add()

 

-        for i in range((steps-initial_step) * gradient_step):

+        for _ in range((steps-initial_step) * gradient_step):

             if scheduler.finished:

                 break

             if shared.state.interrupted:

@@ -487,7 +485,7 @@ def train_embedding(id_task, embedding_name, learn_rate, batch_size, gradient_st
 

                 if clip_grad:

                     clip_grad_sched.step(embedding.step)

-            

+

                 with devices.autocast():

                     x = batch.latent_sample.to(devices.device, non_blocking=pin_memory)

                     if use_weight:

@@ -515,7 +513,7 @@ def train_embedding(id_task, embedding_name, learn_rate, batch_size, gradient_st
                 # go back until we reach gradient accumulation steps

                 if (j + 1) % gradient_step != 0:

                     continue

-                

+

                 if clip_grad:

                     clip_grad(embedding.vec, clip_grad_sched.learn_rate)

 

@@ -599,17 +597,17 @@ def train_embedding(id_task, embedding_name, learn_rate, batch_size, gradient_st
                         data = torch.load(last_saved_file)

                         info.add_text("sd-ti-embedding", embedding_to_b64(data))

 

-                        title = "<{}>".format(data.get('name', '???'))

+                        title = f"<{data.get('name', '???')}>"

 

                         try:

                             vectorSize = list(data['string_to_param'].values())[0].shape[0]

-                        except Exception as e:

+                        except Exception:

                             vectorSize = '?'

 

                         checkpoint = sd_models.select_checkpoint()

                         footer_left = checkpoint.model_name

-                        footer_mid = '[{}]'.format(checkpoint.shorthash)

-                        footer_right = '{}v {}s'.format(vectorSize, steps_done)

+                        footer_mid = f'[{checkpoint.shorthash}]'

+                        footer_right = f'{vectorSize}v {steps_done}s'

 

                         captioned_image = caption_image_overlay(image, title, footer_left, footer_mid, footer_right)

                         captioned_image = insert_image_data_embed(captioned_image, data)

diff --git a/modules/txt2img.py b/modules/txt2img.py
index 16841d0f..f022381c 100644
--- a/modules/txt2img.py
+++ b/modules/txt2img.py
@@ -1,18 +1,15 @@
 import modules.scripts

-from modules import sd_samplers

+from modules import sd_samplers, processing

 from modules.generation_parameters_copypaste import create_override_settings_dict

-from modules.processing import StableDiffusionProcessing, Processed, StableDiffusionProcessingTxt2Img, \

-    StableDiffusionProcessingImg2Img, process_images

 from modules.shared import opts, cmd_opts

 import modules.shared as shared

-import modules.processing as processing

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

     override_settings = create_override_settings_dict(override_settings_texts)

 

-    p = StableDiffusionProcessingTxt2Img(

+    p = processing.StableDiffusionProcessingTxt2Img(

         sd_model=shared.sd_model,

         outpath_samples=opts.outdir_samples or opts.outdir_txt2img_samples,

         outpath_grids=opts.outdir_grids or opts.outdir_txt2img_grids,

@@ -53,7 +50,7 @@ def txt2img(id_task: str, prompt: str, negative_prompt: str, prompt_styles, step
     processed = modules.scripts.scripts_txt2img.run(p, *args)

 

     if processed is None:

-        processed = process_images(p)

+        processed = processing.process_images(p)

 

     p.close()

 

diff --git a/modules/ui.py b/modules/ui.py
index 7b45f131..ff25c4ce 100644
--- a/modules/ui.py
+++ b/modules/ui.py
@@ -1,29 +1,23 @@
-import html

 import json

-import math

 import mimetypes

 import os

-import platform

-import random

 import sys

-import tempfile

-import time

 import traceback

-from functools import partial, reduce

+from functools import reduce

 import warnings

 

 import gradio as gr

 import gradio.routes

 import gradio.utils

 import numpy as np

-from PIL import Image, PngImagePlugin

+from PIL import Image, PngImagePlugin  # noqa: F401

 from modules.call_queue import wrap_gradio_gpu_call, wrap_queued_call, wrap_gradio_call

 

-from modules import sd_hijack, sd_models, localization, script_callbacks, ui_extensions, deepbooru, sd_vae, extra_networks, postprocessing, ui_components, ui_common, ui_postprocessing, progress

-from modules.ui_components import FormRow, FormColumn, FormGroup, ToolButton, FormHTML

+from modules import sd_hijack, sd_models, localization, script_callbacks, ui_extensions, deepbooru, sd_vae, extra_networks, ui_common, ui_postprocessing, progress, ui_loadsave

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

 from modules.paths import script_path, data_path

 

-from modules.shared import opts, cmd_opts, restricted_opts

+from modules.shared import opts, cmd_opts

 

 import modules.codeformer_model

 import modules.generation_parameters_copypaste as parameters_copypaste

@@ -34,7 +28,6 @@ import modules.shared as shared
 import modules.styles

 import modules.textual_inversion.ui

 from modules import prompt_parser

-from modules.images import save_image

 from modules.sd_hijack import model_hijack

 from modules.sd_samplers import samplers, samplers_for_img2img

 from modules.textual_inversion import textual_inversion

@@ -93,16 +86,6 @@ def send_gradio_gallery_to_image(x):
         return None

     return image_from_url_text(x[0])

 

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

-    if hasattr(x, 'children'):

-        if isinstance(x, gr.Tabs) and x.elem_id is not None:

-            # Tabs element can't have a label, have to use elem_id instead

-            func(f"{path}/Tabs@{x.elem_id}", x)

-        for c in x.children:

-            visit(c, func, path)

-    elif x.label is not None:

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

-

 

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

     if name is None:

@@ -166,7 +149,7 @@ def process_interrogate(interrogation_function, mode, ii_input_dir, ii_output_di
             img = Image.open(image)

             filename = os.path.basename(image)

             left, _ = os.path.splitext(filename)

-            print(interrogation_function(img), file=open(os.path.join(ii_output_dir, left + ".txt"), 'a'))

+            print(interrogation_function(img), file=open(os.path.join(ii_output_dir, f"{left}.txt"), 'a'))

 

         return [gr.update(), None]

 

@@ -182,29 +165,29 @@ def interrogate_deepbooru(image):
 

 

 def create_seed_inputs(target_interface):

-    with FormRow(elem_id=target_interface + '_seed_row', variant="compact"):

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

+    with FormRow(elem_id=f"{target_interface}_seed_row", variant="compact"):

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

         seed.style(container=False)

-        random_seed = ToolButton(random_symbol, elem_id=target_interface + '_random_seed', label='Random seed')

-        reuse_seed = ToolButton(reuse_symbol, elem_id=target_interface + '_reuse_seed', label='Reuse seed')

+        random_seed = ToolButton(random_symbol, elem_id=f"{target_interface}_random_seed", label='Random seed')

+        reuse_seed = ToolButton(reuse_symbol, elem_id=f"{target_interface}_reuse_seed", label='Reuse seed')

 

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

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

 

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

     seed_extras = []

 

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

+    with FormRow(visible=False, elem_id=f"{target_interface}_subseed_row") as seed_extra_row_1:

         seed_extras.append(seed_extra_row_1)

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

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

         subseed.style(container=False)

-        random_subseed = ToolButton(random_symbol, elem_id=target_interface + '_random_subseed')

-        reuse_subseed = ToolButton(reuse_symbol, elem_id=target_interface + '_reuse_subseed')

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

+        random_subseed = ToolButton(random_symbol, elem_id=f"{target_interface}_random_subseed")

+        reuse_subseed = ToolButton(reuse_symbol, elem_id=f"{target_interface}_reuse_subseed")

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

 

     with FormRow(visible=False) as seed_extra_row_2:

         seed_extras.append(seed_extra_row_2)

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

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

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

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

 

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

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

@@ -246,7 +229,7 @@ def connect_reuse_seed(seed: gr.Number, reuse_seed: gr.Button, generation_info:
                 all_seeds = gen_info.get('all_seeds', [-1])

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

 

-        except json.decoder.JSONDecodeError as e:

+        except json.decoder.JSONDecodeError:

             if gen_info_string != '':

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

                 print(gen_info_string, file=sys.stderr)

@@ -423,7 +406,7 @@ def create_sampler_and_steps_selection(choices, tabname):
 def ordered_ui_categories():

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

 

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

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

         yield category

 

 

@@ -736,8 +719,8 @@ def create_ui():
                     with gr.TabItem('Batch', id='batch', elem_id="img2img_batch_tab") as tab_batch:

                         hidden = '<br>Disabled when launched with --hide-ui-dir-config.' if shared.cmd_opts.hide_ui_dir_config else ''

                         gr.HTML(

-                            f"<p style='padding-bottom: 1em;' class=\"text-gray-500\">Process images in a directory on the same machine where the server is running." +

-                            f"<br>Use an empty output directory to save pictures normally instead of writing to the output directory." +

+                            "<p style='padding-bottom: 1em;' class=\"text-gray-500\">Process images in a directory on the same machine where the server is running." +

+                            "<br>Use an empty output directory to save pictures normally instead of writing to the output directory." +

                             f"<br>Add inpaint batch mask directory to enable inpaint batch processing."

                             f"{hidden}</p>"

                         )

@@ -746,7 +729,6 @@ def create_ui():
                         img2img_batch_inpaint_mask_dir = gr.Textbox(label="Inpaint batch mask directory (required for inpaint batch processing only)", **shared.hide_dirs, elem_id="img2img_batch_inpaint_mask_dir")

 

                     img2img_tabs = [tab_img2img, tab_sketch, tab_inpaint, tab_inpaint_color, tab_inpaint_upload, tab_batch]

-                    img2img_image_inputs = [init_img, sketch, init_img_with_mask, inpaint_color_sketch]

 

                     for i, tab in enumerate(img2img_tabs):

                         tab.select(fn=lambda tabnum=i: tabnum, inputs=[], outputs=[img2img_selected_tab])

@@ -765,7 +747,7 @@ def create_ui():
                     )

                     button.click(

                         fn=lambda: None,

-                        _js="switch_to_"+name.replace(" ", "_"),

+                        _js=f"switch_to_{name.replace(' ', '_')}",

                         inputs=[],

                         outputs=[],

                     )

@@ -828,7 +810,7 @@ def create_ui():
                         with FormGroup():

                             with FormRow():

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

-                                image_cfg_scale = gr.Slider(minimum=0, maximum=3.0, step=0.05, label='Image CFG Scale', value=1.5, elem_id="img2img_image_cfg_scale", visible=shared.sd_model and shared.sd_model.cond_stage_key == "edit")

+                                image_cfg_scale = gr.Slider(minimum=0, maximum=3.0, step=0.05, label='Image CFG Scale', value=1.5, elem_id="img2img_image_cfg_scale", visible=False)

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

 

                     elif category == "seed":

@@ -1189,7 +1171,7 @@ def create_ui():
                         process_focal_crop_entropy_weight = gr.Slider(label='Focal point entropy weight', value=0.15, minimum=0.0, maximum=1.0, step=0.05, elem_id="train_process_focal_crop_entropy_weight")

                         process_focal_crop_edges_weight = gr.Slider(label='Focal point edges weight', value=0.5, minimum=0.0, maximum=1.0, step=0.05, elem_id="train_process_focal_crop_edges_weight")

                         process_focal_crop_debug = gr.Checkbox(label='Create debug image', elem_id="train_process_focal_crop_debug")

-                    

+

                     with gr.Column(visible=False) as process_multicrop_col:

                         gr.Markdown('Each image is center-cropped with an automatically chosen width and height.')

                         with gr.Row():

@@ -1201,7 +1183,7 @@ def create_ui():
                         with gr.Row():

                             process_multicrop_objective = gr.Radio(["Maximize area", "Minimize error"], value="Maximize area", label="Resizing objective", elem_id="train_process_multicrop_objective")

                             process_multicrop_threshold = gr.Slider(minimum=0, maximum=1, step=0.01, label="Error threshold", value=0.1, elem_id="train_process_multicrop_threshold")

-   

+

                     with gr.Row():

                         with gr.Column(scale=3):

                             gr.HTML(value="")

@@ -1230,7 +1212,7 @@ def create_ui():
                     )

 

                 def get_textual_inversion_template_names():

-                    return sorted([x for x in textual_inversion.textual_inversion_templates])

+                    return sorted(textual_inversion.textual_inversion_templates)

 

                 with gr.Tab(label="Train", id="train"):

                     gr.HTML(value="<p style='margin-bottom: 0.7em'>Train an embedding or Hypernetwork; you must specify a directory with a set of 1:1 ratio images <a href=\"https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Textual-Inversion\" style=\"font-weight:bold;\">[wiki]</a></p>")

@@ -1238,13 +1220,13 @@ def create_ui():
                         train_embedding_name = gr.Dropdown(label='Embedding', elem_id="train_embedding", choices=sorted(sd_hijack.model_hijack.embedding_db.word_embeddings.keys()))

                         create_refresh_button(train_embedding_name, sd_hijack.model_hijack.embedding_db.load_textual_inversion_embeddings, lambda: {"choices": sorted(sd_hijack.model_hijack.embedding_db.word_embeddings.keys())}, "refresh_train_embedding_name")

 

-                        train_hypernetwork_name = gr.Dropdown(label='Hypernetwork', elem_id="train_hypernetwork", choices=[x for x in shared.hypernetworks.keys()])

-                        create_refresh_button(train_hypernetwork_name, shared.reload_hypernetworks, lambda: {"choices": sorted([x for x in shared.hypernetworks.keys()])}, "refresh_train_hypernetwork_name")

+                        train_hypernetwork_name = gr.Dropdown(label='Hypernetwork', elem_id="train_hypernetwork", choices=sorted(shared.hypernetworks))

+                        create_refresh_button(train_hypernetwork_name, shared.reload_hypernetworks, lambda: {"choices": sorted(shared.hypernetworks)}, "refresh_train_hypernetwork_name")

 

                     with FormRow():

                         embedding_learn_rate = gr.Textbox(label='Embedding Learning rate', placeholder="Embedding Learning rate", value="0.005", elem_id="train_embedding_learn_rate")

                         hypernetwork_learn_rate = gr.Textbox(label='Hypernetwork Learning rate', placeholder="Hypernetwork Learning rate", value="0.00001", elem_id="train_hypernetwork_learn_rate")

-                    

+

                     with FormRow():

                         clip_grad_mode = gr.Dropdown(value="disabled", label="Gradient Clipping", choices=["disabled", "value", "norm"])

                         clip_grad_value = gr.Textbox(placeholder="Gradient clip value", value="0.1", show_label=False)

@@ -1290,8 +1272,8 @@ def create_ui():
 

             with gr.Column(elem_id='ti_gallery_container'):

                 ti_output = gr.Text(elem_id="ti_output", value="", show_label=False)

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

-                ti_progress = gr.HTML(elem_id="ti_progress", value="")

+                gr.Gallery(label='Output', show_label=False, elem_id='ti_gallery').style(columns=4)

+                gr.HTML(elem_id="ti_progress", value="")

                 ti_outcome = gr.HTML(elem_id="ti_error", value="")

 

         create_embedding.click(

@@ -1462,23 +1444,25 @@ def create_ui():
         elif t == bool:

             comp = gr.Checkbox

         else:

-            raise Exception(f'bad options item type: {str(t)} for key {key}')

+            raise Exception(f'bad options item type: {t} for key {key}')

 

-        elem_id = "setting_"+key

+        elem_id = f"setting_{key}"

 

         if info.refresh is not None:

             if is_quicksettings:

                 res = comp(label=info.label, value=fun(), elem_id=elem_id, **(args or {}))

-                create_refresh_button(res, info.refresh, info.component_args, "refresh_" + key)

+                create_refresh_button(res, info.refresh, info.component_args, f"refresh_{key}")

             else:

                 with FormRow():

                     res = comp(label=info.label, value=fun(), elem_id=elem_id, **(args or {}))

-                    create_refresh_button(res, info.refresh, info.component_args, "refresh_" + key)

+                    create_refresh_button(res, info.refresh, info.component_args, f"refresh_{key}")

         else:

             res = comp(label=info.label, value=fun(), elem_id=elem_id, **(args or {}))

 

         return res

 

+    loadsave = ui_loadsave.UiLoadsave(cmd_opts.ui_config_file)

+

     components = []

     component_dict = {}

     shared.settings_components = component_dict

@@ -1525,7 +1509,7 @@ def create_ui():
 

         result = gr.HTML(elem_id="settings_result")

 

-        quicksettings_names = [x.strip() for x in opts.quicksettings.split(",")]

+        quicksettings_names = opts.quicksettings_list

         quicksettings_names = {x: i for i, x in enumerate(quicksettings_names) if x != 'quicksettings'}

 

         quicksettings_list = []

@@ -1545,7 +1529,7 @@ def create_ui():
                         current_tab.__exit__()

 

                     gr.Group()

-                    current_tab = gr.TabItem(elem_id="settings_{}".format(elem_id), label=text)

+                    current_tab = gr.TabItem(elem_id=f"settings_{elem_id}", label=text)

                     current_tab.__enter__()

                     current_row = gr.Column(variant='compact')

                     current_row.__enter__()

@@ -1566,7 +1550,10 @@ def create_ui():
                 current_row.__exit__()

                 current_tab.__exit__()

 

-            with gr.TabItem("Actions", id="actions"):

+            with gr.TabItem("Defaults", id="defaults", elem_id="settings_tab_defaults"):

+                loadsave.create_ui()

+

+            with gr.TabItem("Actions", id="actions", elem_id="settings_tab_actions"):

                 request_notifications = gr.Button(value='Request browser notifications', elem_id="request_notifications")

                 download_localization = gr.Button(value='Download localization template', elem_id="download_localization")

                 reload_script_bodies = gr.Button(value='Reload custom script bodies (No ui updates, No restart)', variant='secondary', elem_id="settings_reload_script_bodies")

@@ -1574,11 +1561,11 @@ def create_ui():
                     unload_sd_model = gr.Button(value='Unload SD checkpoint to free VRAM', elem_id="sett_unload_sd_model")

                     reload_sd_model = gr.Button(value='Reload the last SD checkpoint back into VRAM', elem_id="sett_reload_sd_model")

 

-            with gr.TabItem("Licenses", id="licenses"):

+            with gr.TabItem("Licenses", id="licenses", elem_id="settings_tab_licenses"):

                 gr.HTML(shared.html("licenses.html"), elem_id="licenses")

 

             gr.Button(value="Show all pages", elem_id="settings_show_all_pages")

-            

+

 

         def unload_sd_weights():

             modules.sd_models.unload_model_weights()

@@ -1639,7 +1626,7 @@ def create_ui():
         (extras_interface, "Extras", "extras"),

         (pnginfo_interface, "PNG Info", "pnginfo"),

         (modelmerger_interface, "Checkpoint Merger", "modelmerger"),

-        (train_interface, "Train", "ti"),

+        (train_interface, "Train", "train"),

     ]

 

     interfaces += script_callbacks.ui_tabs_callback()

@@ -1654,7 +1641,7 @@ def create_ui():
 

     with gr.Blocks(theme=shared.gradio_theme, analytics_enabled=False, title="Stable Diffusion") as demo:

         with gr.Row(elem_id="quicksettings", variant="compact"):

-            for i, k, item in sorted(quicksettings_list, key=lambda x: quicksettings_names.get(x[1], x[0])):

+            for _i, k, _item in sorted(quicksettings_list, key=lambda x: quicksettings_names.get(x[1], x[0])):

                 component = create_setting_component(k, is_quicksettings=True)

                 component_dict[k] = component

 

@@ -1664,11 +1651,21 @@ def create_ui():
             for interface, label, ifid in interfaces:

                 if label in shared.opts.hidden_tabs:

                     continue

-                with gr.TabItem(label, id=ifid, elem_id='tab_' + ifid):

+                with gr.TabItem(label, id=ifid, elem_id=f"tab_{ifid}"):

                     interface.render()

 

+            for interface, _label, ifid in interfaces:

+                if ifid in ["extensions", "settings"]:

+                    continue

+

+                loadsave.add_block(interface, ifid)

+

+            loadsave.add_component(f"webui/Tabs@{tabs.elem_id}", tabs)

+

+            loadsave.setup_ui()

+

         if os.path.exists(os.path.join(script_path, "notification.mp3")):

-            audio_notification = gr.Audio(interactive=False, value=os.path.join(script_path, "notification.mp3"), elem_id="audio_notification", visible=False)

+            gr.Audio(interactive=False, value=os.path.join(script_path, "notification.mp3"), elem_id="audio_notification", visible=False)

 

         footer = shared.html("footer.html")

         footer = footer.format(versions=versions_html())

@@ -1681,7 +1678,7 @@ def create_ui():
             outputs=[text_settings, result],

         )

 

-        for i, k, item in quicksettings_list:

+        for _i, k, _item in quicksettings_list:

             component = component_dict[k]

             info = opts.data_labels[k]

 

@@ -1693,11 +1690,9 @@ def create_ui():
                 show_progress=info.refresh is not None,

             )

 

-        text_settings.change(

-            fn=lambda: gr.update(visible=shared.sd_model and shared.sd_model.cond_stage_key == "edit"),

-            inputs=[],

-            outputs=[image_cfg_scale],

-        )

+        update_image_cfg_scale_visibility = lambda: gr.update(visible=shared.sd_model and shared.sd_model.cond_stage_key == "edit")

+        text_settings.change(fn=update_image_cfg_scale_visibility, inputs=[], outputs=[image_cfg_scale])

+        demo.load(fn=update_image_cfg_scale_visibility, inputs=[], outputs=[image_cfg_scale])

 

         button_set_checkpoint = gr.Button('Change checkpoint', elem_id='change_checkpoint', visible=False)

         button_set_checkpoint.click(

@@ -1757,97 +1752,8 @@ def create_ui():
             ]

         )

 

-    ui_config_file = cmd_opts.ui_config_file

-    ui_settings = {}

-    settings_count = len(ui_settings)

-    error_loading = False

-

-    try:

-        if os.path.exists(ui_config_file):

-            with open(ui_config_file, "r", encoding="utf8") as file:

-                ui_settings = json.load(file)

-    except Exception:

-        error_loading = True

-        print("Error loading settings:", file=sys.stderr)

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

-

-    def loadsave(path, x):

-        def apply_field(obj, field, condition=None, init_field=None):

-            key = path + "/" + field

-

-            if getattr(obj, 'custom_script_source', None) is not None:

-              key = 'customscript/' + obj.custom_script_source + '/' + key

-

-            if getattr(obj, 'do_not_save_to_config', False):

-                return

-

-            saved_value = ui_settings.get(key, None)

-            if saved_value is None:

-                ui_settings[key] = getattr(obj, field)

-            elif condition and not condition(saved_value):

-                pass

-

-                # this warning is generally not useful;

-                # print(f'Warning: Bad ui setting value: {key}: {saved_value}; Default value "{getattr(obj, field)}" will be used instead.')

-            else:

-                setattr(obj, field, saved_value)

-                if init_field is not None:

-                    init_field(saved_value)

-

-        if type(x) in [gr.Slider, gr.Radio, gr.Checkbox, gr.Textbox, gr.Number, gr.Dropdown, ToolButton] and x.visible:

-            apply_field(x, 'visible')

-

-        if type(x) == gr.Slider:

-            apply_field(x, 'value')

-            apply_field(x, 'minimum')

-            apply_field(x, 'maximum')

-            apply_field(x, 'step')

-

-        if type(x) == gr.Radio:

-            apply_field(x, 'value', lambda val: val in x.choices)

-

-        if type(x) == gr.Checkbox:

-            apply_field(x, 'value')

-

-        if type(x) == gr.Textbox:

-            apply_field(x, 'value')

-

-        if type(x) == gr.Number:

-            apply_field(x, 'value')

-

-        if type(x) == gr.Dropdown:

-            def check_dropdown(val):

-                if getattr(x, 'multiselect', False):

-                    return all([value in x.choices for value in val])

-                else:

-                    return val in x.choices

-

-            apply_field(x, 'value', check_dropdown, getattr(x, 'init_field', None))

-

-        def check_tab_id(tab_id):

-            tab_items = list(filter(lambda e: isinstance(e, gr.TabItem), x.children))

-            if type(tab_id) == str:

-                tab_ids = [t.id for t in tab_items]

-                return tab_id in tab_ids

-            elif type(tab_id) == int:

-                return tab_id >= 0 and tab_id < len(tab_items)

-            else:

-                return False

-

-        if type(x) == gr.Tabs:

-            apply_field(x, 'selected', check_tab_id)

-

-    visit(txt2img_interface, loadsave, "txt2img")

-    visit(img2img_interface, loadsave, "img2img")

-    visit(extras_interface, loadsave, "extras")

-    visit(modelmerger_interface, loadsave, "modelmerger")

-    visit(train_interface, loadsave, "train")

-

-    loadsave(f"webui/Tabs@{tabs.elem_id}", tabs)

-

-    if not error_loading and (not os.path.exists(ui_config_file) or settings_count != len(ui_settings)):

-        with open(ui_config_file, "w", encoding="utf8") as file:

-            json.dump(ui_settings, file, indent=4)

+    loadsave.dump_defaults()

+    demo.ui_loadsave = loadsave

 

     # Required as a workaround for change() event not triggering when loading values from ui-config.json

     interp_description.value = update_interp_description(interp_method.value)

@@ -1865,12 +1771,11 @@ def webpath(fn):
 

 

 def javascript_html():

-    script_js = os.path.join(script_path, "script.js")

-    head = f'<script type="text/javascript" src="{webpath(script_js)}"></script>\n'

+    # Ensure localization is in `window` before scripts

+    head = f'<script type="text/javascript">{localization.localization_js(shared.opts.localization)}</script>\n'

 

-    inline = f"{localization.localization_js(shared.opts.localization)};"

-    if cmd_opts.theme is not None:

-        inline += f"set_theme('{cmd_opts.theme}');"

+    script_js = os.path.join(script_path, "script.js")

+    head += f'<script type="text/javascript" src="{webpath(script_js)}"></script>\n'

 

     for script in modules.scripts.list_scripts("javascript", ".js"):

         head += f'<script type="text/javascript" src="{webpath(script.path)}"></script>\n'

@@ -1878,7 +1783,8 @@ def javascript_html():
     for script in modules.scripts.list_scripts("javascript", ".mjs"):

         head += f'<script type="module" src="{webpath(script.path)}"></script>\n'

 

-    head += f'<script type="text/javascript">{inline}</script>\n'

+    if cmd_opts.theme:

+        head += f'<script type="text/javascript">set_theme(\"{cmd_opts.theme}\");</script>\n'

 

     return head

 

@@ -1925,7 +1831,7 @@ def versions_html():
 

     python_version = ".".join([str(x) for x in sys.version_info[0:3]])

     commit = launch.commit_hash()

-    short_commit = commit[0:8]

+    tag = launch.git_tag()

 

     if shared.xformers_available:

         import xformers

@@ -1934,15 +1840,31 @@ def versions_html():
         xformers_version = "N/A"

 

     return f"""

+version: <a href="https://github.com/AUTOMATIC1111/stable-diffusion-webui/commit/{commit}">{tag}</a>

+ •

 python: <span title="{sys.version}">{python_version}</span>

- • 

+ •

 torch: {getattr(torch, '__long_version__',torch.__version__)}

- • 

+ •

 xformers: {xformers_version}

- • 

+ •

 gradio: {gr.__version__}

- • 

-commit: <a href="https://github.com/AUTOMATIC1111/stable-diffusion-webui/commit/{commit}">{short_commit}</a>

- • 

+ •

 checkpoint: <a id="sd_checkpoint_hash">N/A</a>

 """

+

+

+def setup_ui_api(app):

+    from pydantic import BaseModel, Field

+    from typing import List

+

+    class QuicksettingsHint(BaseModel):

+        name: str = Field(title="Name of the quicksettings field")

+        label: str = Field(title="Label of the quicksettings field")

+

+    def quicksettings_hint():

+        return [QuicksettingsHint(name=k, label=v.label) for k, v in opts.data_labels.items()]

+

+    app.add_api_route("/internal/quicksettings-hint", quicksettings_hint, methods=["GET"], response_model=List[QuicksettingsHint])

+

+    app.add_api_route("/internal/ping", lambda: {}, methods=["GET"])

diff --git a/modules/ui_extensions.py b/modules/ui_extensions.py
index 99ac8756..af497733 100644
--- a/modules/ui_extensions.py
+++ b/modules/ui_extensions.py
@@ -61,7 +61,8 @@ def save_config_state(name):
     if not name:

         name = "Config"

     current_config_state["name"] = name

-    filename = os.path.join(config_states_dir, datetime.now().strftime("%Y_%m_%d-%H_%M_%S") + "_" + name + ".json")

+    timestamp = datetime.now().strftime('%Y_%m_%d-%H_%M_%S')

+    filename = os.path.join(config_states_dir, f"{timestamp}_{name}.json")

     print(f"Saving backup of webui/extension state to {filename}.")

     with open(filename, "w", encoding="utf-8") as f:

         json.dump(current_config_state, f)

@@ -466,7 +467,7 @@ def refresh_available_extensions_from_data(hide_tags, sort_column, filter_text="
                 <td>{html.escape(description)}<p class="info"><span class="date_added">Added: {html.escape(added)}</span></p></td>

                 <td>{install_code}</td>

             </tr>

-        

+

         """

 

         for tag in [x for x in extension_tags if x not in tags]:

@@ -489,7 +490,7 @@ def create_ui():
     config_states.list_config_states()

 

     with gr.Blocks(analytics_enabled=False) as ui:

-        with gr.Tabs(elem_id="tabs_extensions") as tabs:

+        with gr.Tabs(elem_id="tabs_extensions"):

             with gr.TabItem("Installed", id="installed"):

 

                 with gr.Row(elem_id="extensions_installed_top"):

@@ -534,9 +535,9 @@ def create_ui():
                     hide_tags = gr.CheckboxGroup(value=["ads", "localization", "installed"], label="Hide extensions with tags", choices=["script", "ads", "localization", "installed"])

                     sort_column = gr.Radio(value="newest first", label="Order", choices=["newest first", "oldest first", "a-z", "z-a", "internal order", ], type="index")

 

-                with gr.Row(): 

+                with gr.Row():

                     search_extensions_text = gr.Text(label="Search").style(container=False)

-                   

+

                 install_result = gr.HTML()

                 available_extensions_table = gr.HTML()

 

diff --git a/modules/ui_extra_networks.py b/modules/ui_extra_networks.py
index aa2f5d1b..0baccf56 100644
--- a/modules/ui_extra_networks.py
+++ b/modules/ui_extra_networks.py
@@ -1,4 +1,3 @@
-import glob

 import os.path

 import urllib.parse

 from pathlib import Path

@@ -27,11 +26,11 @@ def register_page(page):
 def fetch_file(filename: str = ""):

     from starlette.responses import FileResponse

 

-    if not any([Path(x).absolute() in Path(filename).absolute().parents for x in allowed_dirs]):

+    if not any(Path(x).absolute() in Path(filename).absolute().parents for x in allowed_dirs):

         raise ValueError(f"File cannot be fetched: {filename}. Must be in one of directories registered by extra pages.")

 

     ext = os.path.splitext(filename)[1].lower()

-    if ext not in (".png", ".jpg", ".webp"):

+    if ext not in (".png", ".jpg", ".jpeg", ".webp"):

         raise ValueError(f"File cannot be fetched: {filename}. Only png and jpg and webp.")

 

     # would profit from returning 304

@@ -69,7 +68,9 @@ class ExtraNetworksPage:
         pass

 

     def link_preview(self, filename):

-        return "./sd_extra_networks/thumb?filename=" + urllib.parse.quote(filename.replace('\\', '/')) + "&mtime=" + str(os.path.getmtime(filename))

+        quoted_filename = urllib.parse.quote(filename.replace('\\', '/'))

+        mtime = os.path.getmtime(filename)

+        return f"./sd_extra_networks/thumb?filename={quoted_filename}&mtime={mtime}"

 

     def search_terms_from_path(self, filename, possible_directories=None):

         abspath = os.path.abspath(filename)

@@ -89,19 +90,22 @@ class ExtraNetworksPage:
 

         subdirs = {}

         for parentdir in [os.path.abspath(x) for x in self.allowed_directories_for_previews()]:

-            for x in glob.glob(os.path.join(parentdir, '**/*'), recursive=True):

-                if not os.path.isdir(x):

-                    continue

+            for root, dirs, _ in os.walk(parentdir, followlinks=True):

+                for dirname in dirs:

+                    x = os.path.join(root, dirname)

 

-                subdir = os.path.abspath(x)[len(parentdir):].replace("\\", "/")

-                while subdir.startswith("/"):

-                    subdir = subdir[1:]

+                    if not os.path.isdir(x):

+                        continue

 

-                is_empty = len(os.listdir(x)) == 0

-                if not is_empty and not subdir.endswith("/"):

-                    subdir = subdir + "/"

+                    subdir = os.path.abspath(x)[len(parentdir):].replace("\\", "/")

+                    while subdir.startswith("/"):

+                        subdir = subdir[1:]

 

-                subdirs[subdir] = 1

+                    is_empty = len(os.listdir(x)) == 0

+                    if not is_empty and not subdir.endswith("/"):

+                        subdir = subdir + "/"

+

+                    subdirs[subdir] = 1

 

         if subdirs:

             subdirs = {"": 1, **subdirs}

@@ -157,8 +161,20 @@ class ExtraNetworksPage:
         if metadata:

             metadata_button = f"<div class='metadata-button' title='Show metadata' onclick='extraNetworksRequestMetadata(event, {json.dumps(self.name)}, {json.dumps(item['name'])})'></div>"

 

+        local_path = ""

+        filename = item.get("filename", "")

+        for reldir in self.allowed_directories_for_previews():

+            absdir = os.path.abspath(reldir)

+

+            if filename.startswith(absdir):

+                local_path = filename[len(absdir):]

+

+        # if this is true, the item must not be show in the default view, and must instead only be

+        # shown when searching for it

+        serach_only = "/." in local_path or "\\." in local_path

+

         args = {

-            "style": f"'{height}{width}{background_image}'",

+            "style": f"'display: none; {height}{width}{background_image}'",

             "prompt": item.get("prompt", None),

             "tabname": json.dumps(tabname),

             "local_preview": json.dumps(item["local_preview"]),

@@ -168,6 +184,7 @@ class ExtraNetworksPage:
             "save_card_preview": '"' + html.escape(f"""return saveCardPreview(event, {json.dumps(tabname)}, {json.dumps(item["local_preview"])})""") + '"',

             "search_term": item.get("search_term", ""),

             "metadata_button": metadata_button,

+            "serach_only": " search_only" if serach_only else "",

         }

 

         return self.card_page.format(**args)

@@ -177,7 +194,7 @@ class ExtraNetworksPage:
         Find a preview PNG for a given path (without extension) and call link_preview on it.

         """

 

-        preview_extensions = ["png", "jpg", "webp"]

+        preview_extensions = ["png", "jpg", "jpeg", "webp"]

         if shared.opts.samples_format not in preview_extensions:

             preview_extensions.append(shared.opts.samples_format)

 

@@ -209,6 +226,11 @@ def intialize():
 class ExtraNetworksUi:

     def __init__(self):

         self.pages = None

+        """gradio HTML components related to extra networks' pages"""

+

+        self.page_contents = None

+        """HTML content of the above; empty initially, filled when extra pages have to be shown"""

+

         self.stored_extra_pages = None

 

         self.button_save_preview = None

@@ -236,17 +258,22 @@ def pages_in_preferred_order(pages):
 def create_ui(container, button, tabname):

     ui = ExtraNetworksUi()

     ui.pages = []

+    ui.pages_contents = []

     ui.stored_extra_pages = pages_in_preferred_order(extra_pages.copy())

     ui.tabname = tabname

 

-    with gr.Tabs(elem_id=tabname+"_extra_tabs") as tabs:

+    with gr.Tabs(elem_id=tabname+"_extra_tabs"):

         for page in ui.stored_extra_pages:

-            with gr.Tab(page.title, id=page.title.lower().replace(" ", "_")):

+            page_id = page.title.lower().replace(" ", "_")

 

-                page_elem = gr.HTML(page.create_html(ui.tabname))

+            with gr.Tab(page.title, id=page_id):

+                elem_id = f"{tabname}_{page_id}_cards_html"

+                page_elem = gr.HTML('', elem_id=elem_id)

                 ui.pages.append(page_elem)

 

-    filter = gr.Textbox('', show_label=False, elem_id=tabname+"_extra_search", placeholder="Search...", visible=False)

+                page_elem.change(fn=lambda: None, _js='function(){applyExtraNetworkFilter(' + json.dumps(tabname) + '); return []}', inputs=[], outputs=[])

+

+    gr.Textbox('', show_label=False, elem_id=tabname+"_extra_search", placeholder="Search...", visible=False)

     button_refresh = gr.Button('Refresh', elem_id=tabname+"_extra_refresh")

 

     ui.button_save_preview = gr.Button('Save preview', elem_id=tabname+"_save_preview", visible=False)

@@ -254,19 +281,22 @@ def create_ui(container, button, tabname):
 

     def toggle_visibility(is_visible):

         is_visible = not is_visible

-        return is_visible, gr.update(visible=is_visible), gr.update(variant=("secondary-down" if is_visible else "secondary"))

+

+        if is_visible and not ui.pages_contents:

+            refresh()

+

+        return is_visible, gr.update(visible=is_visible), gr.update(variant=("secondary-down" if is_visible else "secondary")), *ui.pages_contents

 

     state_visible = gr.State(value=False)

-    button.click(fn=toggle_visibility, inputs=[state_visible], outputs=[state_visible, container, button])

+    button.click(fn=toggle_visibility, inputs=[state_visible], outputs=[state_visible, container, button, *ui.pages])

 

     def refresh():

-        res = []

-

         for pg in ui.stored_extra_pages:

             pg.refresh()

-            res.append(pg.create_html(ui.tabname))

 

-        return res

+        ui.pages_contents = [pg.create_html(ui.tabname) for pg in ui.stored_extra_pages]

+

+        return ui.pages_contents

 

     button_refresh.click(fn=refresh, inputs=[], outputs=ui.pages)

 

@@ -296,7 +326,7 @@ def setup_ui(ui, gallery):
 

         is_allowed = False

         for extra_page in ui.stored_extra_pages:

-            if any([path_is_parent(x, filename) for x in extra_page.allowed_directories_for_previews()]):

+            if any(path_is_parent(x, filename) for x in extra_page.allowed_directories_for_previews()):

                 is_allowed = True

                 break

 

diff --git a/modules/ui_loadsave.py b/modules/ui_loadsave.py
new file mode 100644
index 00000000..728fec9e
--- /dev/null
+++ b/modules/ui_loadsave.py
@@ -0,0 +1,208 @@
+import json

+import os

+

+import gradio as gr

+

+from modules import errors

+from modules.ui_components import ToolButton

+

+

+class UiLoadsave:

+    """allows saving and restorig default values for gradio components"""

+

+    def __init__(self, filename):

+        self.filename = filename

+        self.ui_settings = {}

+        self.component_mapping = {}

+        self.error_loading = False

+        self.finalized_ui = False

+

+        self.ui_defaults_view = None

+        self.ui_defaults_apply = None

+        self.ui_defaults_review = None

+

+        try:

+            if os.path.exists(self.filename):

+                self.ui_settings = self.read_from_file()

+        except Exception as e:

+            self.error_loading = True

+            errors.display(e, "loading settings")

+

+    def add_component(self, path, x):

+        """adds component to the registry of tracked components"""

+

+        assert not self.finalized_ui

+

+        def apply_field(obj, field, condition=None, init_field=None):

+            key = f"{path}/{field}"

+

+            if getattr(obj, 'custom_script_source', None) is not None:

+              key = f"customscript/{obj.custom_script_source}/{key}"

+

+            if getattr(obj, 'do_not_save_to_config', False):

+                return

+

+            saved_value = self.ui_settings.get(key, None)

+            if saved_value is None:

+                self.ui_settings[key] = getattr(obj, field)

+            elif condition and not condition(saved_value):

+                pass

+            else:

+                setattr(obj, field, saved_value)

+                if init_field is not None:

+                    init_field(saved_value)

+

+            if field == 'value' and key not in self.component_mapping:

+                self.component_mapping[key] = x

+

+        if type(x) in [gr.Slider, gr.Radio, gr.Checkbox, gr.Textbox, gr.Number, gr.Dropdown, ToolButton] and x.visible:

+            apply_field(x, 'visible')

+

+        if type(x) == gr.Slider:

+            apply_field(x, 'value')

+            apply_field(x, 'minimum')

+            apply_field(x, 'maximum')

+            apply_field(x, 'step')

+

+        if type(x) == gr.Radio:

+            apply_field(x, 'value', lambda val: val in x.choices)

+

+        if type(x) == gr.Checkbox:

+            apply_field(x, 'value')

+

+        if type(x) == gr.Textbox:

+            apply_field(x, 'value')

+

+        if type(x) == gr.Number:

+            apply_field(x, 'value')

+

+        if type(x) == gr.Dropdown:

+            def check_dropdown(val):

+                if getattr(x, 'multiselect', False):

+                    return all(value in x.choices for value in val)

+                else:

+                    return val in x.choices

+

+            apply_field(x, 'value', check_dropdown, getattr(x, 'init_field', None))

+

+        def check_tab_id(tab_id):

+            tab_items = list(filter(lambda e: isinstance(e, gr.TabItem), x.children))

+            if type(tab_id) == str:

+                tab_ids = [t.id for t in tab_items]

+                return tab_id in tab_ids

+            elif type(tab_id) == int:

+                return 0 <= tab_id < len(tab_items)

+            else:

+                return False

+

+        if type(x) == gr.Tabs:

+            apply_field(x, 'selected', check_tab_id)

+

+    def add_block(self, x, path=""):

+        """adds all components inside a gradio block x to the registry of tracked components"""

+

+        if hasattr(x, 'children'):

+            if isinstance(x, gr.Tabs) and x.elem_id is not None:

+                # Tabs element can't have a label, have to use elem_id instead

+                self.add_component(f"{path}/Tabs@{x.elem_id}", x)

+            for c in x.children:

+                self.add_block(c, path)

+        elif x.label is not None:

+            self.add_component(f"{path}/{x.label}", x)

+

+    def read_from_file(self):

+        with open(self.filename, "r", encoding="utf8") as file:

+            return json.load(file)

+

+    def write_to_file(self, current_ui_settings):

+        with open(self.filename, "w", encoding="utf8") as file:

+            json.dump(current_ui_settings, file, indent=4)

+

+    def dump_defaults(self):

+        """saves default values to a file unless tjhe file is present and there was an error loading default values at start"""

+

+        if self.error_loading and os.path.exists(self.filename):

+            return

+

+        self.write_to_file(self.ui_settings)

+

+    def iter_changes(self, current_ui_settings, values):

+        """

+        given a dictionary with defaults from a file and current values from gradio elements, returns

+        an iterator over tuples of values that are not the same between the file and the current;

+        tuple contents are: path, old value, new value

+        """

+

+        for (path, component), new_value in zip(self.component_mapping.items(), values):

+            old_value = current_ui_settings.get(path)

+

+            choices = getattr(component, 'choices', None)

+            if isinstance(new_value, int) and choices:

+                if new_value >= len(choices):

+                    continue

+

+                new_value = choices[new_value]

+

+            if new_value == old_value:

+                continue

+

+            if old_value is None and new_value == '' or new_value == []:

+                continue

+

+            yield path, old_value, new_value

+

+    def ui_view(self, *values):

+        text = ["<table><thead><tr><th>Path</th><th>Old value</th><th>New value</th></thead><tbody>"]

+

+        for path, old_value, new_value in self.iter_changes(self.read_from_file(), values):

+            if old_value is None:

+                old_value = "<span class='ui-defaults-none'>None</span>"

+

+            text.append(f"<tr><td>{path}</td><td>{old_value}</td><td>{new_value}</td></tr>")

+

+        if len(text) == 1:

+            text.append("<tr><td colspan=3>No changes</td></tr>")

+

+        text.append("</tbody>")

+        return "".join(text)

+

+    def ui_apply(self, *values):

+        num_changed = 0

+

+        current_ui_settings = self.read_from_file()

+

+        for path, _, new_value in self.iter_changes(current_ui_settings.copy(), values):

+            num_changed += 1

+            current_ui_settings[path] = new_value

+

+        if num_changed == 0:

+            return "No changes."

+

+        self.write_to_file(current_ui_settings)

+

+        return f"Wrote {num_changed} changes."

+

+    def create_ui(self):

+        """creates ui elements for editing defaults UI, without adding any logic to them"""

+

+        gr.HTML(

+            f"This page allows you to change default values in UI elements on other tabs.<br />"

+            f"Make your changes, press 'View changes' to review the changed default values,<br />"

+            f"then press 'Apply' to write them to {self.filename}.<br />"

+            f"New defaults will apply after you restart the UI.<br />"

+        )

+

+        with gr.Row():

+            self.ui_defaults_view = gr.Button(value='View changes', elem_id="ui_defaults_view", variant="secondary")

+            self.ui_defaults_apply = gr.Button(value='Apply', elem_id="ui_defaults_apply", variant="primary")

+

+        self.ui_defaults_review = gr.HTML("")

+

+    def setup_ui(self):

+        """adds logic to elements created with create_ui; all add_block class must be made before this"""

+

+        assert not self.finalized_ui

+        self.finalized_ui = True

+

+        self.ui_defaults_view.click(fn=self.ui_view, inputs=list(self.component_mapping.values()), outputs=[self.ui_defaults_review])

+        self.ui_defaults_apply.click(fn=self.ui_apply, inputs=list(self.component_mapping.values()), outputs=[self.ui_defaults_review])

diff --git a/modules/ui_postprocessing.py b/modules/ui_postprocessing.py
index f25639e5..c7dc1154 100644
--- a/modules/ui_postprocessing.py
+++ b/modules/ui_postprocessing.py
@@ -1,5 +1,5 @@
 import gradio as gr

-from modules import scripts_postprocessing, scripts, shared, gfpgan_model, codeformer_model, ui_common, postprocessing, call_queue

+from modules import scripts, shared, ui_common, postprocessing, call_queue

 import modules.generation_parameters_copypaste as parameters_copypaste

 

 

diff --git a/modules/ui_tempdir.py b/modules/ui_tempdir.py
index 21945235..f05049e1 100644
--- a/modules/ui_tempdir.py
+++ b/modules/ui_tempdir.py
@@ -23,7 +23,7 @@ def register_tmp_file(gradio, filename):
 

 def check_tmp_file(gradio, filename):

     if hasattr(gradio, 'temp_file_sets'):

-        return any([filename in fileset for fileset in gradio.temp_file_sets])

+        return any(filename in fileset for fileset in gradio.temp_file_sets)

 

     if hasattr(gradio, 'temp_dirs'):

         return any(Path(temp_dir).resolve() in Path(filename).resolve().parents for temp_dir in gradio.temp_dirs)

@@ -36,7 +36,7 @@ def save_pil_to_file(pil_image, dir=None):
     if already_saved_as and os.path.isfile(already_saved_as):

         register_tmp_file(shared.demo, already_saved_as)

 

-        file_obj = Savedfile(already_saved_as)

+        file_obj = Savedfile(f'{already_saved_as}?{os.path.getmtime(already_saved_as)}')

         return file_obj

 

     if shared.opts.temp_dir != "":

@@ -72,7 +72,7 @@ def cleanup_tmpdr():
     if temp_dir == "" or not os.path.isdir(temp_dir):

         return

 

-    for root, dirs, files in os.walk(temp_dir, topdown=False):

+    for root, _, files in os.walk(temp_dir, topdown=False):

         for name in files:

             _, extension = os.path.splitext(name)

             if extension != ".png":

diff --git a/modules/upscaler.py b/modules/upscaler.py
index e2eaa730..8acb6e96 100644
--- a/modules/upscaler.py
+++ b/modules/upscaler.py
@@ -2,8 +2,6 @@ import os
 from abc import abstractmethod
 
 import PIL
-import numpy as np
-import torch
 from PIL import Image
 
 import modules.shared
@@ -43,9 +41,9 @@ class Upscaler:
             os.makedirs(self.model_path, exist_ok=True)
 
         try:
-            import cv2
+            import cv2  # noqa: F401
             self.can_tile = True
-        except:
+        except Exception:
             pass
 
     @abstractmethod
@@ -57,7 +55,7 @@ class Upscaler:
         dest_w = int(img.width * scale)
         dest_h = int(img.height * scale)
 
-        for i in range(3):
+        for _ in range(3):
             shape = (img.width, img.height)
 
             img = self.do_upscale(img, selected_model)
diff --git a/modules/xlmr.py b/modules/xlmr.py
index beab3fdf..a407a3ca 100644
--- a/modules/xlmr.py
+++ b/modules/xlmr.py
@@ -1,4 +1,4 @@
-from transformers import BertPreTrainedModel,BertModel,BertConfig
+from transformers import BertPreTrainedModel, BertConfig
 import torch.nn as nn
 import torch
 from transformers.models.xlm_roberta.configuration_xlm_roberta import XLMRobertaConfig
@@ -28,7 +28,7 @@ class BertSeriesModelWithTransformation(BertPreTrainedModel):
     config_class = BertSeriesConfig
 
     def __init__(self, config=None, **kargs):
-        # modify initialization for autoloading 
+        # modify initialization for autoloading
         if config is None:
             config = XLMRobertaConfig()
             config.attention_probs_dropout_prob= 0.1
@@ -74,7 +74,7 @@ class BertSeriesModelWithTransformation(BertPreTrainedModel):
         text["attention_mask"] = torch.tensor(
             text['attention_mask']).to(device)
         features = self(**text)
-        return features['projection_state'] 
+        return features['projection_state']
 
     def forward(
         self,
@@ -134,4 +134,4 @@ class BertSeriesModelWithTransformation(BertPreTrainedModel):
 
 class RobertaSeriesModelWithTransformation(BertSeriesModelWithTransformation):
     base_model_prefix = 'roberta'
-    config_class= RobertaSeriesConfig
\ No newline at end of file
+    config_class= RobertaSeriesConfig