Merge branch 'master' into cors-regex

27 files changed, 624 insertions, 300 deletions

diff --git a/modules/api/api.py b/modules/api/api.py
index 688469ad..79b2c818 100644
--- a/modules/api/api.py
+++ b/modules/api/api.py
@@ -5,16 +5,22 @@ import uvicorn
 from threading import Lock
 from gradio.processing_utils import encode_pil_to_base64, decode_base64_to_file, decode_base64_to_image
 from fastapi import APIRouter, Depends, FastAPI, HTTPException
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+from secrets import compare_digest
+
 import modules.shared as shared
+from modules import sd_samplers
 from modules.api.models import *
 from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img, process_images
-from modules.sd_samplers import all_samplers
 from modules.extras import run_extras, run_pnginfo
 from PIL import PngImagePlugin
 from modules.sd_models import checkpoints_list
 from modules.realesrgan_model import get_realesrgan_models
 from typing import List
 
+if shared.cmd_opts.deepdanbooru:
+    from modules.deepbooru import get_deepbooru_tags
+
 def upscaler_to_index(name: str):
     try:
         return [x.name.lower() for x in shared.sd_upscalers].index(name.lower())
@@ -22,8 +28,12 @@ def upscaler_to_index(name: str):
         raise HTTPException(status_code=400, detail=f"Invalid upscaler, needs to be on of these: {' , '.join([x.name for x in sd_upscalers])}")
 
 
-sampler_to_index = lambda name: next(filter(lambda row: name.lower() == row[1].name.lower(), enumerate(all_samplers)), None)
+def validate_sampler_name(name):
+    config = sd_samplers.all_samplers_map.get(name, None)
+    if config is None:
+        raise HTTPException(status_code=404, detail="Sampler not found")
 
+    return name
 
 def setUpscalers(req: dict):
     reqDict = vars(req)
@@ -54,39 +64,53 @@ def encode_pil_to_base64(image):
 
 class Api:
     def __init__(self, app: FastAPI, queue_lock: Lock):
+        if shared.cmd_opts.api_auth:
+            self.credenticals = dict()
+            for auth in shared.cmd_opts.api_auth.split(","):
+                user, password = auth.split(":")
+                self.credenticals[user] = password
+
         self.router = APIRouter()
         self.app = app
         self.queue_lock = queue_lock
-        self.app.add_api_route("/sdapi/v1/txt2img", self.text2imgapi, methods=["POST"], response_model=TextToImageResponse)
-        self.app.add_api_route("/sdapi/v1/img2img", self.img2imgapi, methods=["POST"], response_model=ImageToImageResponse)
-        self.app.add_api_route("/sdapi/v1/extra-single-image", self.extras_single_image_api, methods=["POST"], response_model=ExtrasSingleImageResponse)
-        self.app.add_api_route("/sdapi/v1/extra-batch-images", self.extras_batch_images_api, methods=["POST"], response_model=ExtrasBatchImagesResponse)
-        self.app.add_api_route("/sdapi/v1/png-info", self.pnginfoapi, methods=["POST"], response_model=PNGInfoResponse)
-        self.app.add_api_route("/sdapi/v1/progress", self.progressapi, methods=["GET"], response_model=ProgressResponse)
-        self.app.add_api_route("/sdapi/v1/interrogate", self.interrogateapi, methods=["POST"])
-        self.app.add_api_route("/sdapi/v1/interrupt", self.interruptapi, methods=["POST"])
-        self.app.add_api_route("/sdapi/v1/options", self.get_config, methods=["GET"], response_model=OptionsModel)
-        self.app.add_api_route("/sdapi/v1/options", self.set_config, methods=["POST"])
-        self.app.add_api_route("/sdapi/v1/cmd-flags", self.get_cmd_flags, methods=["GET"], response_model=FlagsModel)
-        self.app.add_api_route("/sdapi/v1/samplers", self.get_samplers, methods=["GET"], response_model=List[SamplerItem])
-        self.app.add_api_route("/sdapi/v1/upscalers", self.get_upscalers, methods=["GET"], response_model=List[UpscalerItem])
-        self.app.add_api_route("/sdapi/v1/sd-models", self.get_sd_models, methods=["GET"], response_model=List[SDModelItem])
-        self.app.add_api_route("/sdapi/v1/hypernetworks", self.get_hypernetworks, methods=["GET"], response_model=List[HypernetworkItem])
-        self.app.add_api_route("/sdapi/v1/face-restorers", self.get_face_restorers, methods=["GET"], response_model=List[FaceRestorerItem])
-        self.app.add_api_route("/sdapi/v1/realesrgan-models", self.get_realesrgan_models, methods=["GET"], response_model=List[RealesrganItem])
-        self.app.add_api_route("/sdapi/v1/prompt-styles", self.get_promp_styles, methods=["GET"], response_model=List[PromptStyleItem])
-        self.app.add_api_route("/sdapi/v1/artist-categories", self.get_artists_categories, methods=["GET"], response_model=List[str])
-        self.app.add_api_route("/sdapi/v1/artists", self.get_artists, methods=["GET"], response_model=List[ArtistItem])
+        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/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.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_promp_styles, methods=["GET"], response_model=List[PromptStyleItem])
+        self.add_api_route("/sdapi/v1/artist-categories", self.get_artists_categories, methods=["GET"], response_model=List[str])
+        self.add_api_route("/sdapi/v1/artists", self.get_artists, methods=["GET"], response_model=List[ArtistItem])
+
+    def add_api_route(self, path: str, endpoint, **kwargs):
+        if shared.cmd_opts.api_auth:
+            return self.app.add_api_route(path, endpoint, dependencies=[Depends(self.auth)], **kwargs)
+        return self.app.add_api_route(path, endpoint, **kwargs)
+
+    def auth(self, credenticals: HTTPBasicCredentials = Depends(HTTPBasic())):
+        if credenticals.username in self.credenticals:
+            if compare_digest(credenticals.password, self.credenticals[credenticals.username]):
+                return True
+
+        raise HTTPException(status_code=401, detail="Incorrect username or password", headers={"WWW-Authenticate": "Basic"})
 
     def text2imgapi(self, txt2imgreq: StableDiffusionTxt2ImgProcessingAPI):
-        sampler_index = sampler_to_index(txt2imgreq.sampler_index)
-
-        if sampler_index is None:
-            raise HTTPException(status_code=404, detail="Sampler not found")
-
         populate = txt2imgreq.copy(update={ # Override __init__ params
             "sd_model": shared.sd_model,
-            "sampler_index": sampler_index[0],
+            "sampler_name": validate_sampler_name(txt2imgreq.sampler_index),
             "do_not_save_samples": True,
             "do_not_save_grid": True
             }
@@ -106,12 +130,6 @@ class Api:
         return TextToImageResponse(images=b64images, parameters=vars(txt2imgreq), info=processed.js())
 
     def img2imgapi(self, img2imgreq: StableDiffusionImg2ImgProcessingAPI):
-        sampler_index = sampler_to_index(img2imgreq.sampler_index)
-
-        if sampler_index is None:
-            raise HTTPException(status_code=404, detail="Sampler not found")
-
-
         init_images = img2imgreq.init_images
         if init_images is None:
             raise HTTPException(status_code=404, detail="Init image not found")
@@ -120,10 +138,9 @@ class Api:
         if mask:
             mask = decode_base64_to_image(mask)
 
-
         populate = img2imgreq.copy(update={ # Override __init__ params
             "sd_model": shared.sd_model,
-            "sampler_index": sampler_index[0],
+            "sampler_name": validate_sampler_name(img2imgreq.sampler_index),
             "do_not_save_samples": True,
             "do_not_save_grid": True,
             "mask": mask
@@ -220,11 +237,20 @@ class Api:
         if image_b64 is None:
             raise HTTPException(status_code=404, detail="Image not found") 
 
-        img = self.__base64_to_image(image_b64)
+        img = decode_base64_to_image(image_b64)
+        img = img.convert('RGB')
 
         # Override object param
         with self.queue_lock:
-            processed = shared.interrogator.interrogate(img)
+            if interrogatereq.model == "clip":
+                processed = shared.interrogator.interrogate(img)
+            elif interrogatereq.model == "deepdanbooru":
+                if shared.cmd_opts.deepdanbooru:
+                    processed = get_deepbooru_tags(img)
+                else:
+                    raise HTTPException(status_code=404, detail="Model not found. Add --deepdanbooru when launching for using the model.")
+            else:
+                raise HTTPException(status_code=404, detail="Model not found")
         
         return InterrogateResponse(caption=processed)
 
@@ -233,6 +259,9 @@ class Api:
 
         return {}
 
+    def skip(self):
+        shared.state.skip()
+
     def get_config(self):
         options = {}
         for key in shared.opts.data.keys():
@@ -244,14 +273,9 @@ class Api:
 
         return options
 
-    def set_config(self, req: OptionsModel):
-        # currently req has all options fields even if you send a dict like { "send_seed": false }, which means it will
-        # overwrite all options with default values.
-        raise RuntimeError('Setting options via API is not supported')
-
-        reqDict = vars(req)
-        for o in reqDict:
-            setattr(shared.opts, o, reqDict[o])
+    def set_config(self, req: Dict[str, Any]):
+        for k, v in req.items():
+            shared.opts.set(k, v)
 
         shared.opts.save(shared.config_filename)
         return
@@ -260,7 +284,7 @@ class Api:
         return vars(shared.cmd_opts)
 
     def get_samplers(self):
-        return [{"name":sampler[0], "aliases":sampler[2], "options":sampler[3]} for sampler in all_samplers]
+        return [{"name": sampler[0], "aliases":sampler[2], "options":sampler[3]} for sampler in sd_samplers.all_samplers]
 
     def get_upscalers(self):
         upscalers = []
diff --git a/modules/api/models.py b/modules/api/models.py
index 34dbfa16..f77951fc 100644
--- a/modules/api/models.py
+++ b/modules/api/models.py
@@ -170,14 +170,15 @@ class ProgressResponse(BaseModel):
 
 class InterrogateRequest(BaseModel):
     image: str = Field(default="", title="Image", description="Image to work on, must be a Base64 string containing the image's data.")
+    model: str = Field(default="clip", title="Model", description="The interrogate model used.")
 
 class InterrogateResponse(BaseModel):
     caption: str = Field(default=None, title="Caption", description="The generated caption for the image.")
 
 fields = {}
-for key, value in opts.data.items():
-    metadata = opts.data_labels.get(key)
-    optType = opts.typemap.get(type(value), type(value))
+for key, metadata in opts.data_labels.items():
+    value = opts.data.get(key)
+    optType = opts.typemap.get(type(metadata.default), type(value))
 
     if (metadata is not None):
         fields.update({key: (Optional[optType], Field(
diff --git a/modules/devices.py b/modules/devices.py
index 7511e1dc..67165bf6 100644
--- a/modules/devices.py
+++ b/modules/devices.py
@@ -3,16 +3,27 @@ import contextlib
 import torch
 from modules import errors
 
-# has_mps is only available in nightly pytorch (for now), `getattr` for compatibility
-has_mps = getattr(torch, 'has_mps', False)
 
-cpu = torch.device("cpu")
+# has_mps is only available in nightly pytorch (for now) and MasOS 12.3+.
+# check `getattr` and try it for compatibility
+def has_mps() -> bool:
+    if not getattr(torch, 'has_mps', False):
+        return False
+    try:
+        torch.zeros(1).to(torch.device("mps"))
+        return True
+    except Exception:
+        return False
+
 
 def extract_device_id(args, name):
     for x in range(len(args)):
-        if name in args[x]: return args[x+1]
+        if name in args[x]:
+            return args[x + 1]
+
     return None
 
+
 def get_optimal_device():
     if torch.cuda.is_available():
         from modules import shared
@@ -25,7 +36,7 @@ def get_optimal_device():
         else:
             return torch.device("cuda")
 
-    if has_mps:
+    if has_mps():
         return torch.device("mps")
 
     return cpu
@@ -45,10 +56,12 @@ def enable_tf32():
 
 errors.run(enable_tf32, "Enabling TF32")
 
+cpu = torch.device("cpu")
 device = device_interrogate = device_gfpgan = device_swinir = device_esrgan = device_scunet = device_codeformer = None
 dtype = torch.float16
 dtype_vae = torch.float16
 
+
 def randn(seed, shape):
     # Pytorch currently doesn't handle setting randomness correctly when the metal backend is used.
     if device.type == 'mps':
@@ -82,6 +95,11 @@ def autocast(disable=False):
 
     return torch.autocast("cuda")
 
+
 # MPS workaround for https://github.com/pytorch/pytorch/issues/79383
-def mps_contiguous(input_tensor, device): return input_tensor.contiguous() if device.type == 'mps' else input_tensor
-def mps_contiguous_to(input_tensor, device): return mps_contiguous(input_tensor, device).to(device)
+def mps_contiguous(input_tensor, device):
+    return input_tensor.contiguous() if device.type == 'mps' else input_tensor
+
+
+def mps_contiguous_to(input_tensor, device):
+    return mps_contiguous(input_tensor, device).to(device)
diff --git a/modules/extensions.py b/modules/extensions.py
index 8e0977fd..db9c4200 100644
--- a/modules/extensions.py
+++ b/modules/extensions.py
@@ -6,7 +6,6 @@ import git
 

 from modules import paths, shared

 

-

 extensions = []

 extensions_dir = os.path.join(paths.script_path, "extensions")

 

@@ -66,9 +65,12 @@ class Extension:
         self.can_update = False

         self.status = "latest"

 

-    def pull(self):

+    def fetch_and_reset_hard(self):

         repo = git.Repo(self.path)

-        repo.remotes.origin.pull()

+        # Fix: `error: Your local changes to the following files would be overwritten by merge`,

+        # because WSL2 Docker set 755 file permissions instead of 644, this results to the error.

+        repo.git.fetch('--all')

+        repo.git.reset('--hard', 'origin')

 

 

 def list_extensions():

@@ -84,3 +86,4 @@ def list_extensions():
 

         extension = Extension(name=dirname, path=path, enabled=dirname not in shared.opts.disabled_extensions)

         extensions.append(extension)

+

diff --git a/modules/generation_parameters_copypaste.py b/modules/generation_parameters_copypaste.py
index 985ec95e..1408ea05 100644
--- a/modules/generation_parameters_copypaste.py
+++ b/modules/generation_parameters_copypaste.py
@@ -73,6 +73,7 @@ def integrate_settings_paste_fields(component_dict):
         'sd_hypernetwork': 'Hypernet',

         'sd_hypernetwork_strength': 'Hypernet strength',

         'CLIP_stop_at_last_layers': 'Clip skip',

+        'inpainting_mask_weight': 'Conditional mask weight',

         'sd_model_checkpoint': 'Model hash',

     }

     settings_paste_fields = [

diff --git a/modules/hypernetworks/hypernetwork.py b/modules/hypernetworks/hypernetwork.py
index 7f182712..fbb87dd1 100644
--- a/modules/hypernetworks/hypernetwork.py
+++ b/modules/hypernetworks/hypernetwork.py
@@ -12,7 +12,7 @@ import torch
 import tqdm

 from einops import rearrange, repeat

 from ldm.util import default

-from modules import devices, processing, sd_models, shared

+from modules import devices, processing, sd_models, shared, sd_samplers

 from modules.textual_inversion import textual_inversion

 from modules.textual_inversion.learn_schedule import LearnRateScheduler

 from torch import einsum

@@ -535,7 +535,7 @@ def train_hypernetwork(hypernetwork_name, learn_rate, batch_size, data_root, log
                 p.prompt = preview_prompt

                 p.negative_prompt = preview_negative_prompt

                 p.steps = preview_steps

-                p.sampler_index = preview_sampler_index

+                p.sampler_name = sd_samplers.samplers[preview_sampler_index].name

                 p.cfg_scale = preview_cfg_scale

                 p.seed = preview_seed

                 p.width = preview_width

diff --git a/modules/images.py b/modules/images.py
index ae705cbd..26d5b7a9 100644
--- a/modules/images.py
+++ b/modules/images.py
@@ -303,7 +303,7 @@ class FilenameGenerator:
         'width': lambda self: self.image.width,

         'height': lambda self: self.image.height,

         'styles': lambda self: self.p and sanitize_filename_part(", ".join([style for style in self.p.styles if not style == "None"]) or "None", replace_spaces=False),

-        'sampler': lambda self: self.p and sanitize_filename_part(sd_samplers.samplers[self.p.sampler_index].name, replace_spaces=False),

+        'sampler': lambda self: self.p and sanitize_filename_part(self.p.sampler_name, replace_spaces=False),

         'model_hash': lambda self: getattr(self.p, "sd_model_hash", shared.sd_model.sd_model_hash),

         'date': lambda self: datetime.datetime.now().strftime('%Y-%m-%d'),

         'datetime': lambda self, *args: self.datetime(*args),  # accepts formats: [datetime], [datetime<Format>], [datetime<Format><Time Zone>]

diff --git a/modules/img2img.py b/modules/img2img.py
index be9f3653..9fc5b693 100644
--- a/modules/img2img.py
+++ b/modules/img2img.py
@@ -6,7 +6,7 @@ import traceback
 import numpy as np

 from PIL import Image, ImageOps, ImageChops

 

-from modules import devices

+from modules import devices, sd_samplers

 from modules.processing import Processed, StableDiffusionProcessingImg2Img, process_images

 from modules.shared import opts, state

 import modules.shared as shared

@@ -99,7 +99,7 @@ def img2img(mode: int, prompt: str, negative_prompt: str, prompt_style: str, pro
         seed_resize_from_h=seed_resize_from_h,

         seed_resize_from_w=seed_resize_from_w,

         seed_enable_extras=seed_enable_extras,

-        sampler_index=sampler_index,

+        sampler_index=sd_samplers.samplers_for_img2img[sampler_index].name,

         batch_size=batch_size,

         n_iter=n_iter,

         steps=steps,

diff --git a/modules/ngrok.py b/modules/ngrok.py
index 5c5f349a..10d2179f 100644
--- a/modules/ngrok.py
+++ b/modules/ngrok.py
@@ -1,14 +1,23 @@
 from pyngrok import ngrok, conf, exception
 
-
 def connect(token, port, region):
+    account = None
     if token == None:
         token = 'None'
+    else:
+        if ':' in token:
+            # token = authtoken:username:password
+            account = token.split(':')[1] + ':' + token.split(':')[-1]
+            token = token.split(':')[0]
+
     config = conf.PyngrokConfig(
         auth_token=token, region=region
     )
     try:
-        public_url = ngrok.connect(port, pyngrok_config=config).public_url
+        if account == None:
+            public_url = ngrok.connect(port, pyngrok_config=config).public_url
+        else:
+            public_url = ngrok.connect(port, pyngrok_config=config, auth=account).public_url
     except exception.PyngrokNgrokError:
         print(f'Invalid ngrok authtoken, ngrok connection aborted.\n'
               f'Your token: {token}, get the right one on https://dashboard.ngrok.com/get-started/your-authtoken')
diff --git a/modules/processing.py b/modules/processing.py
index 03c9143d..accb31d1 100644
--- a/modules/processing.py
+++ b/modules/processing.py
@@ -2,6 +2,7 @@ import json
 import math

 import os

 import sys

+import warnings

 

 import torch

 import numpy as np

@@ -66,19 +67,15 @@ def apply_overlay(image, paste_loc, index, overlays):
 

     return image

 

-def get_correct_sampler(p):

-    if isinstance(p, modules.processing.StableDiffusionProcessingTxt2Img):

-        return sd_samplers.samplers

-    elif isinstance(p, modules.processing.StableDiffusionProcessingImg2Img):

-        return sd_samplers.samplers_for_img2img

-    elif isinstance(p, modules.api.processing.StableDiffusionProcessingAPI):

-        return sd_samplers.samplers

 

 class StableDiffusionProcessing():

     """

     The first set of paramaters: sd_models -> do_not_reload_embeddings represent the minimum required to create a StableDiffusionProcessing

     """

-    def __init__(self, sd_model=None, outpath_samples=None, outpath_grids=None, prompt: str = "", styles: List[str] = None, seed: int = -1, subseed: int = -1, subseed_strength: float = 0, seed_resize_from_h: int = -1, seed_resize_from_w: int = -1, seed_enable_extras: bool = True, sampler_index: int = 0, batch_size: int = 1, n_iter: int = 1, steps: int = 50, cfg_scale: float = 7.0, width: int = 512, height: int = 512, restore_faces: bool = False, tiling: bool = False, do_not_save_samples: bool = False, do_not_save_grid: bool = False, extra_generation_params: Dict[Any, Any] = None, overlay_images: Any = None, negative_prompt: str = None, eta: float = None, do_not_reload_embeddings: bool = False, denoising_strength: float = 0, ddim_discretize: str = None, s_churn: float = 0.0, s_tmax: float = None, s_tmin: float = 0.0, s_noise: float = 1.0, override_settings: Dict[str, Any] = None):

+    def __init__(self, sd_model=None, outpath_samples=None, outpath_grids=None, prompt: str = "", styles: List[str] = None, seed: int = -1, subseed: int = -1, subseed_strength: float = 0, seed_resize_from_h: int = -1, seed_resize_from_w: int = -1, seed_enable_extras: bool = True, sampler_name: str = None, batch_size: int = 1, n_iter: int = 1, steps: int = 50, cfg_scale: float = 7.0, width: int = 512, height: int = 512, restore_faces: bool = False, tiling: bool = False, do_not_save_samples: bool = False, do_not_save_grid: bool = False, extra_generation_params: Dict[Any, Any] = None, overlay_images: Any = None, negative_prompt: str = None, eta: float = None, do_not_reload_embeddings: bool = False, denoising_strength: float = 0, ddim_discretize: str = None, s_churn: float = 0.0, s_tmax: float = None, s_tmin: float = 0.0, s_noise: float = 1.0, override_settings: Dict[str, Any] = None, sampler_index: int = None):

+        if sampler_index is not None:

+            warnings.warn("sampler_index argument for StableDiffusionProcessing does not do anything; use sampler_name")

+

         self.sd_model = sd_model

         self.outpath_samples: str = outpath_samples

         self.outpath_grids: str = outpath_grids

@@ -91,7 +88,7 @@ class StableDiffusionProcessing():
         self.subseed_strength: float = subseed_strength

         self.seed_resize_from_h: int = seed_resize_from_h

         self.seed_resize_from_w: int = seed_resize_from_w

-        self.sampler_index: int = sampler_index

+        self.sampler_name: str = sampler_name

         self.batch_size: int = batch_size

         self.n_iter: int = n_iter

         self.steps: int = steps

@@ -116,6 +113,7 @@ class StableDiffusionProcessing():
         self.s_tmax = s_tmax or float('inf')  # not representable as a standard ui option

         self.s_noise = s_noise or opts.s_noise

         self.override_settings = {k: v for k, v in (override_settings or {}).items() if k not in shared.restricted_opts}

+        self.is_using_inpainting_conditioning = False

 

         if not seed_enable_extras:

             self.subseed = -1

@@ -126,6 +124,7 @@ class StableDiffusionProcessing():
         self.scripts = None

         self.script_args = None

         self.all_prompts = None

+        self.all_negative_prompts = None

         self.all_seeds = None

         self.all_subseeds = None

 

@@ -136,6 +135,8 @@ class StableDiffusionProcessing():
             # Pretty sure we can just make this a 1x1 image since its not going to be used besides its batch size.

             return x.new_zeros(x.shape[0], 5, 1, 1)

 

+        self.is_using_inpainting_conditioning = True

+

         height = height or self.height

         width = width or self.width

 

@@ -154,6 +155,8 @@ class StableDiffusionProcessing():
             # Dummy zero conditioning if we're not using inpainting model.

             return latent_image.new_zeros(latent_image.shape[0], 5, 1, 1)

 

+        self.is_using_inpainting_conditioning = True

+

         # Handle the different mask inputs

         if image_mask is not None:

             if torch.is_tensor(image_mask):

@@ -200,7 +203,7 @@ class StableDiffusionProcessing():
 

 

 class Processed:

-    def __init__(self, p: StableDiffusionProcessing, images_list, seed=-1, info="", subseed=None, all_prompts=None, all_seeds=None, all_subseeds=None, index_of_first_image=0, infotexts=None):

+    def __init__(self, p: StableDiffusionProcessing, images_list, seed=-1, info="", subseed=None, all_prompts=None, all_negative_prompts=None, all_seeds=None, all_subseeds=None, index_of_first_image=0, infotexts=None):

         self.images = images_list

         self.prompt = p.prompt

         self.negative_prompt = p.negative_prompt

@@ -210,8 +213,7 @@ class Processed:
         self.info = info

         self.width = p.width

         self.height = p.height

-        self.sampler_index = p.sampler_index

-        self.sampler = sd_samplers.samplers[p.sampler_index].name

+        self.sampler_name = p.sampler_name

         self.cfg_scale = p.cfg_scale

         self.steps = p.steps

         self.batch_size = p.batch_size

@@ -238,17 +240,20 @@ class Processed:
         self.negative_prompt = self.negative_prompt if type(self.negative_prompt) != list else self.negative_prompt[0]

         self.seed = int(self.seed if type(self.seed) != list else self.seed[0]) if self.seed is not None else -1

         self.subseed = int(self.subseed if type(self.subseed) != list else self.subseed[0]) if self.subseed is not None else -1

+        self.is_using_inpainting_conditioning = p.is_using_inpainting_conditioning

 

-        self.all_prompts = all_prompts or [self.prompt]

-        self.all_seeds = all_seeds or [self.seed]

-        self.all_subseeds = all_subseeds or [self.subseed]

+        self.all_prompts = all_prompts or p.all_prompts or [self.prompt]

+        self.all_negative_prompts = all_negative_prompts or p.all_negative_prompts or [self.negative_prompt]

+        self.all_seeds = all_seeds or p.all_seeds or [self.seed]

+        self.all_subseeds = all_subseeds or p.all_subseeds or [self.subseed]

         self.infotexts = infotexts or [info]

 

     def js(self):

         obj = {

-            "prompt": self.prompt,

+            "prompt": self.all_prompts[0],

             "all_prompts": self.all_prompts,

-            "negative_prompt": self.negative_prompt,

+            "negative_prompt": self.all_negative_prompts[0],

+            "all_negative_prompts": self.all_negative_prompts,

             "seed": self.seed,

             "all_seeds": self.all_seeds,

             "subseed": self.subseed,

@@ -256,8 +261,7 @@ class Processed:
             "subseed_strength": self.subseed_strength,

             "width": self.width,

             "height": self.height,

-            "sampler_index": self.sampler_index,

-            "sampler": self.sampler,

+            "sampler_name": self.sampler_name,

             "cfg_scale": self.cfg_scale,

             "steps": self.steps,

             "batch_size": self.batch_size,

@@ -273,6 +277,7 @@ class Processed:
             "styles": self.styles,

             "job_timestamp": self.job_timestamp,

             "clip_skip": self.clip_skip,

+            "is_using_inpainting_conditioning": self.is_using_inpainting_conditioning,

         }

 

         return json.dumps(obj)

@@ -384,7 +389,7 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments, iteration
 

     generation_params = {

         "Steps": p.steps,

-        "Sampler": get_correct_sampler(p)[p.sampler_index].name,

+        "Sampler": p.sampler_name,

         "CFG scale": p.cfg_scale,

         "Seed": all_seeds[index],

         "Face restoration": (opts.face_restoration_model if p.restore_faces else None),

@@ -399,6 +404,7 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments, iteration
         "Variation seed strength": (None if p.subseed_strength == 0 else p.subseed_strength),

         "Seed resize from": (None if p.seed_resize_from_w == 0 or p.seed_resize_from_h == 0 else f"{p.seed_resize_from_w}x{p.seed_resize_from_h}"),

         "Denoising strength": getattr(p, 'denoising_strength', None),

+        "Conditional mask weight": getattr(p, "inpainting_mask_weight", shared.opts.inpainting_mask_weight) if p.is_using_inpainting_conditioning else None,

         "Eta": (None if p.sampler is None or p.sampler.eta == p.sampler.default_eta else p.sampler.eta),

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

@@ -408,7 +414,7 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments, iteration
 

     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.negative_prompt if p.negative_prompt else ""

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

 

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

 

@@ -437,10 +443,6 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
     else:

         assert p.prompt is not None

 

-    with open(os.path.join(shared.script_path, "params.txt"), "w", encoding="utf8") as file:

-        processed = Processed(p, [], p.seed, "")

-        file.write(processed.infotext(p, 0))

-

     devices.torch_gc()

 

     seed = get_fixed_seed(p.seed)

@@ -451,12 +453,15 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
 

     comments = {}

 

-    shared.prompt_styles.apply_styles(p)

-

     if type(p.prompt) == list:

-        p.all_prompts = p.prompt

+        p.all_prompts = [shared.prompt_styles.apply_styles_to_prompt(x, p.styles) for x in p.prompt]

+    else:

+        p.all_prompts = p.batch_size * p.n_iter * [shared.prompt_styles.apply_styles_to_prompt(p.prompt, p.styles)]

+

+    if type(p.negative_prompt) == list:

+        p.all_negative_prompts = [shared.prompt_styles.apply_negative_styles_to_prompt(x, p.styles) for x in p.negative_prompt]

     else:

-        p.all_prompts = p.batch_size * p.n_iter * [p.prompt]

+        p.all_negative_prompts = p.batch_size * p.n_iter * [shared.prompt_styles.apply_negative_styles_to_prompt(p.negative_prompt, p.styles)]

 

     if type(seed) == list:

         p.all_seeds = seed

@@ -471,6 +476,10 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
     def infotext(iteration=0, position_in_batch=0):

         return create_infotext(p, p.all_prompts, p.all_seeds, p.all_subseeds, comments, iteration, position_in_batch)

 

+    with open(os.path.join(shared.script_path, "params.txt"), "w", encoding="utf8") as file:

+        processed = Processed(p, [], p.seed, "")

+        file.write(processed.infotext(p, 0))

+

     if os.path.exists(cmd_opts.embeddings_dir) and not p.do_not_reload_embeddings:

         model_hijack.embedding_db.load_textual_inversion_embeddings()

 

@@ -495,6 +504,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
                 break

 

             prompts = p.all_prompts[n * p.batch_size:(n + 1) * p.batch_size]

+            negative_prompts = p.all_negative_prompts[n * p.batch_size:(n + 1) * p.batch_size]

             seeds = p.all_seeds[n * p.batch_size:(n + 1) * p.batch_size]

             subseeds = p.all_subseeds[n * p.batch_size:(n + 1) * p.batch_size]

 

@@ -505,7 +515,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
                 p.scripts.process_batch(p, batch_number=n, prompts=prompts, seeds=seeds, subseeds=subseeds)

 

             with devices.autocast():

-                uc = prompt_parser.get_learned_conditioning(shared.sd_model, len(prompts) * [p.negative_prompt], p.steps)

+                uc = prompt_parser.get_learned_conditioning(shared.sd_model, negative_prompts, p.steps)

                 c = prompt_parser.get_multicond_learned_conditioning(shared.sd_model, prompts, p.steps)

 

             if len(model_hijack.comments) > 0:

@@ -591,7 +601,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
 

     devices.torch_gc()

 

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

+    res = Processed(p, output_images, p.all_seeds[0], infotext() + "".join(["\n\n" + x for x 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)

@@ -645,7 +655,7 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
             self.truncate_y = int(self.firstphase_height - firstphase_height_truncated) // opt_f

 

     def sample(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):

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

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

 

         if not self.enable_hr:

             x = create_random_tensors([opt_C, self.height // opt_f, self.width // opt_f], seeds=seeds, subseeds=subseeds, subseed_strength=self.subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)

@@ -706,7 +716,7 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
 

         shared.state.nextjob()

 

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

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

 

         noise = create_random_tensors(samples.shape[1:], seeds=seeds, subseeds=subseeds, subseed_strength=subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)

 

@@ -730,7 +740,6 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
         self.denoising_strength: float = denoising_strength

         self.init_latent = None

         self.image_mask = mask

-        #self.image_unblurred_mask = None

         self.latent_mask = None

         self.mask_for_overlay = None

         self.mask_blur = mask_blur

@@ -743,39 +752,39 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
         self.image_conditioning = None

 

     def init(self, all_prompts, all_seeds, all_subseeds):

-        self.sampler = sd_samplers.create_sampler_with_index(sd_samplers.samplers_for_img2img, self.sampler_index, self.sd_model)

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

         crop_region = None

 

-        if self.image_mask is not None:

-            self.image_mask = self.image_mask.convert('L')

+        image_mask = self.image_mask

 

-            if self.inpainting_mask_invert:

-                self.image_mask = ImageOps.invert(self.image_mask)

+        if image_mask is not None:

+            image_mask = image_mask.convert('L')

 

-            #self.image_unblurred_mask = self.image_mask

+            if self.inpainting_mask_invert:

+                image_mask = ImageOps.invert(image_mask)

 

             if self.mask_blur > 0:

-                self.image_mask = self.image_mask.filter(ImageFilter.GaussianBlur(self.mask_blur))

+                image_mask = image_mask.filter(ImageFilter.GaussianBlur(self.mask_blur))

 

             if self.inpaint_full_res:

-                self.mask_for_overlay = self.image_mask

-                mask = self.image_mask.convert('L')

+                self.mask_for_overlay = image_mask

+                mask = image_mask.convert('L')

                 crop_region = masking.get_crop_region(np.array(mask), self.inpaint_full_res_padding)

                 crop_region = masking.expand_crop_region(crop_region, self.width, self.height, mask.width, mask.height)

                 x1, y1, x2, y2 = crop_region

 

                 mask = mask.crop(crop_region)

-                self.image_mask = images.resize_image(2, mask, self.width, self.height)

+                image_mask = images.resize_image(2, mask, self.width, self.height)

                 self.paste_to = (x1, y1, x2-x1, y2-y1)

             else:

-                self.image_mask = images.resize_image(self.resize_mode, self.image_mask, self.width, self.height)

-                np_mask = np.array(self.image_mask)

+                image_mask = images.resize_image(self.resize_mode, image_mask, self.width, self.height)

+                np_mask = np.array(image_mask)

                 np_mask = np.clip((np_mask.astype(np.float32)) * 2, 0, 255).astype(np.uint8)

                 self.mask_for_overlay = Image.fromarray(np_mask)

 

             self.overlay_images = []

 

-        latent_mask = self.latent_mask if self.latent_mask is not None else self.image_mask

+        latent_mask = self.latent_mask if self.latent_mask is not None else image_mask

 

         add_color_corrections = opts.img2img_color_correction and self.color_corrections is None

         if add_color_corrections:

@@ -787,7 +796,7 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
             if crop_region is None:

                 image = images.resize_image(self.resize_mode, image, self.width, self.height)

 

-            if self.image_mask is not None:

+            if image_mask is not None:

                 image_masked = Image.new('RGBa', (image.width, image.height))

                 image_masked.paste(image.convert("RGBA").convert("RGBa"), mask=ImageOps.invert(self.mask_for_overlay.convert('L')))

 

@@ -797,7 +806,7 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
                 image = image.crop(crop_region)

                 image = images.resize_image(2, image, self.width, self.height)

 

-            if self.image_mask is not None:

+            if image_mask is not None:

                 if self.inpainting_fill != 1:

                     image = masking.fill(image, latent_mask)

 

@@ -829,7 +838,7 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
 

         self.init_latent = self.sd_model.get_first_stage_encoding(self.sd_model.encode_first_stage(image))

 

-        if self.image_mask is not None:

+        if image_mask is not None:

             init_mask = latent_mask

             latmask = init_mask.convert('RGB').resize((self.init_latent.shape[3], self.init_latent.shape[2]))

             latmask = np.moveaxis(np.array(latmask, dtype=np.float32), 2, 0) / 255

@@ -846,7 +855,7 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
             elif self.inpainting_fill == 3:

                 self.init_latent = self.init_latent * self.mask

 

-        self.image_conditioning = self.img2img_image_conditioning(image, self.init_latent, self.image_mask)

+        self.image_conditioning = self.img2img_image_conditioning(image, self.init_latent, image_mask)

 

     def sample(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):

         x = create_random_tensors([opt_C, self.height // opt_f, self.width // opt_f], seeds=seeds, subseeds=subseeds, subseed_strength=self.subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)

diff --git a/modules/script_callbacks.py b/modules/script_callbacks.py
index 74dfb880..8e22f875 100644
--- a/modules/script_callbacks.py
+++ b/modules/script_callbacks.py
@@ -7,6 +7,7 @@ from typing import Optional
 from fastapi import FastAPI

 from gradio import Blocks

 

+

 def report_exception(c, job):

     print(f"Error executing callback {job} for {c.script}", file=sys.stderr)

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

@@ -45,15 +46,23 @@ class CFGDenoiserParams:
         """Total number of sampling steps planned"""

 

 

+class UiTrainTabParams:

+    def __init__(self, txt2img_preview_params):

+        self.txt2img_preview_params = txt2img_preview_params

+

+

 ScriptCallback = namedtuple("ScriptCallback", ["script", "callback"])

 callback_map = dict(

     callbacks_app_started=[],

     callbacks_model_loaded=[],

     callbacks_ui_tabs=[],

+    callbacks_ui_train_tabs=[],

     callbacks_ui_settings=[],

     callbacks_before_image_saved=[],

     callbacks_image_saved=[],

-    callbacks_cfg_denoiser=[]

+    callbacks_cfg_denoiser=[],

+    callbacks_before_component=[],

+    callbacks_after_component=[],

 )

 

 

@@ -61,6 +70,7 @@ def clear_callbacks():
     for callback_list in callback_map.values():

         callback_list.clear()

 

+

 def app_started_callback(demo: Optional[Blocks], app: FastAPI):

     for c in callback_map['callbacks_app_started']:

         try:

@@ -79,7 +89,7 @@ def model_loaded_callback(sd_model):
 

 def ui_tabs_callback():

     res = []

-    

+

     for c in callback_map['callbacks_ui_tabs']:

         try:

             res += c.callback() or []

@@ -89,6 +99,14 @@ def ui_tabs_callback():
     return res

 

 

+def ui_train_tabs_callback(params: UiTrainTabParams):

+    for c in callback_map['callbacks_ui_train_tabs']:

+        try:

+            c.callback(params)

+        except Exception:

+            report_exception(c, 'callbacks_ui_train_tabs')

+

+

 def ui_settings_callback():

     for c in callback_map['callbacks_ui_settings']:

         try:

@@ -121,6 +139,22 @@ def cfg_denoiser_callback(params: CFGDenoiserParams):
             report_exception(c, 'cfg_denoiser_callback')

 

 

+def before_component_callback(component, **kwargs):

+    for c in callback_map['callbacks_before_component']:

+        try:

+            c.callback(component, **kwargs)

+        except Exception:

+            report_exception(c, 'before_component_callback')

+

+

+def after_component_callback(component, **kwargs):

+    for c in callback_map['callbacks_after_component']:

+        try:

+            c.callback(component, **kwargs)

+        except Exception:

+            report_exception(c, 'after_component_callback')

+

+

 def add_callback(callbacks, fun):

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

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

@@ -169,6 +203,13 @@ def on_ui_tabs(callback):
     add_callback(callback_map['callbacks_ui_tabs'], callback)

 

 

+def on_ui_train_tabs(callback):

+    """register a function to be called when the UI is creating new tabs for the train tab.

+    Create your new tabs with gr.Tab.

+    """

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

+

+

 def on_ui_settings(callback):

     """register a function to be called before UI settings are populated; add your settings

     by using shared.opts.add_option(shared.OptionInfo(...)) """

@@ -197,3 +238,20 @@ def on_cfg_denoiser(callback):
         - params: CFGDenoiserParams - parameters to be passed to the inner model and sampling state details.

     """

     add_callback(callback_map['callbacks_cfg_denoiser'], callback)

+

+

+def on_before_component(callback):

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

+    The callback is called with arguments:

+        - component - gradio component that is about to be created.

+        - **kwargs - args to gradio.components.IOComponent.__init__ function

+

+    Use elem_id/label fields of kwargs to figure out which component it is.

+    This can be useful to inject your own components somewhere in the middle of vanilla UI.

+    """

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

+

+

+def on_after_component(callback):

+    """register a function to be called after a component is created. See on_before_component for more."""

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

diff --git a/modules/script_loading.py b/modules/script_loading.py
new file mode 100644
index 00000000..f93f0951
--- /dev/null
+++ b/modules/script_loading.py
@@ -0,0 +1,34 @@
+import os

+import sys

+import traceback

+from types import ModuleType

+

+

+def load_module(path):

+    with open(path, "r", encoding="utf8") as file:

+        text = file.read()

+

+    compiled = compile(text, path, 'exec')

+    module = ModuleType(os.path.basename(path))

+    exec(compiled, module.__dict__)

+

+    return module

+

+

+def preload_extensions(extensions_dir, parser):

+    if not os.path.isdir(extensions_dir):

+        return

+

+    for dirname in sorted(os.listdir(extensions_dir)):

+        preload_script = os.path.join(extensions_dir, dirname, "preload.py")

+        if not os.path.isfile(preload_script):

+            continue

+

+        try:

+            module = load_module(preload_script)

+            if hasattr(module, 'preload'):

+                module.preload(parser)

+

+        except Exception:

+            print(f"Error running preload() for {preload_script}", file=sys.stderr)

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

diff --git a/modules/scripts.py b/modules/scripts.py
index 637b2329..b934d881 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -6,7 +6,7 @@ from collections import namedtuple
 import gradio as gr

 

 from modules.processing import StableDiffusionProcessing

-from modules import shared, paths, script_callbacks, extensions

+from modules import shared, paths, script_callbacks, extensions, script_loading

 

 AlwaysVisible = object()

 

@@ -17,6 +17,9 @@ class Script:
     args_to = None

     alwayson = False

 

+    is_txt2img = False

+    is_img2img = False

+

     """A gr.Group component that has all script's UI inside it"""

     group = None

 

@@ -93,6 +96,23 @@ class Script:
 

         pass

 

+    def before_component(self, component, **kwargs):

+        """

+        Called before a component is created.

+        Use elem_id/label fields of kwargs to figure out which component it is.

+        This can be useful to inject your own components somewhere in the middle of vanilla UI.

+        You can return created components in the ui() function to add them to the list of arguments for your processing functions

+        """

+

+        pass

+

+    def after_component(self, component, **kwargs):

+        """

+        Called after a component is created. Same as above.

+        """

+

+        pass

+

     def describe(self):

         """unused"""

         return ""

@@ -140,7 +160,7 @@ def list_files_with_name(filename):
             continue

 

         path = os.path.join(dirpath, filename)

-        if os.path.isfile(filename):

+        if os.path.isfile(path):

             res.append(path)

 

     return res

@@ -161,13 +181,7 @@ def load_scripts():
                 sys.path = [scriptfile.basedir] + sys.path

             current_basedir = scriptfile.basedir

 

-            with open(scriptfile.path, "r", encoding="utf8") as file:

-                text = file.read()

-

-            from types import ModuleType

-            compiled = compile(text, scriptfile.path, 'exec')

-            module = ModuleType(scriptfile.filename)

-            exec(compiled, module.__dict__)

+            module = script_loading.load_module(scriptfile.path)

 

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

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

@@ -201,12 +215,18 @@ class ScriptRunner:
         self.titles = []

         self.infotext_fields = []

 

-    def setup_ui(self, is_img2img):

+    def initialize_scripts(self, is_img2img):

+        self.scripts.clear()

+        self.alwayson_scripts.clear()

+        self.selectable_scripts.clear()

+

         for script_class, path, basedir in scripts_data:

             script = script_class()

             script.filename = path

+            script.is_txt2img = not is_img2img

+            script.is_img2img = is_img2img

 

-            visibility = script.show(is_img2img)

+            visibility = script.show(script.is_img2img)

 

             if visibility == AlwaysVisible:

                 self.scripts.append(script)

@@ -217,6 +237,7 @@ class ScriptRunner:
                 self.scripts.append(script)

                 self.selectable_scripts.append(script)

 

+    def setup_ui(self):

         self.titles = [wrap_call(script.title, script.filename, "title") or f"{script.filename} [error]" for script in self.selectable_scripts]

 

         inputs = [None]

@@ -226,7 +247,7 @@ class ScriptRunner:
             script.args_from = len(inputs)

             script.args_to = len(inputs)

 

-            controls = wrap_call(script.ui, script.filename, "ui", is_img2img)

+            controls = wrap_call(script.ui, script.filename, "ui", script.is_img2img)

 

             if controls is None:

                 return

@@ -326,33 +347,44 @@ class ScriptRunner:
                 print(f"Error running postprocess: {script.filename}", file=sys.stderr)

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

 

+    def before_component(self, component, **kwargs):

+        for script in self.scripts:

+            try:

+                script.before_component(component, **kwargs)

+            except Exception:

+                print(f"Error running before_component: {script.filename}", file=sys.stderr)

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

+

+    def after_component(self, component, **kwargs):

+        for script in self.scripts:

+            try:

+                script.after_component(component, **kwargs)

+            except Exception:

+                print(f"Error running after_component: {script.filename}", file=sys.stderr)

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

+

     def reload_sources(self, cache):

         for si, script in list(enumerate(self.scripts)):

-            with open(script.filename, "r", encoding="utf8") as file:

-                args_from = script.args_from

-                args_to = script.args_to

-                filename = script.filename

-                text = file.read()

+            args_from = script.args_from

+            args_to = script.args_to

+            filename = script.filename

 

-                from types import ModuleType

+            module = cache.get(filename, None)

+            if module is None:

+                module = script_loading.load_module(script.filename)

+                cache[filename] = module

 

-                module = cache.get(filename, None)

-                if module is None:

-                    compiled = compile(text, filename, 'exec')

-                    module = ModuleType(script.filename)

-                    exec(compiled, module.__dict__)

-                    cache[filename] = module

-

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

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

-                        self.scripts[si] = script_class()

-                        self.scripts[si].filename = filename

-                        self.scripts[si].args_from = args_from

-                        self.scripts[si].args_to = args_to

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

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

+                    self.scripts[si] = script_class()

+                    self.scripts[si].filename = filename

+                    self.scripts[si].args_from = args_from

+                    self.scripts[si].args_to = args_to

 

 

 scripts_txt2img = ScriptRunner()

 scripts_img2img = ScriptRunner()

+scripts_current: ScriptRunner = None

 

 

 def reload_script_body_only():

@@ -369,3 +401,22 @@ def reload_scripts():
     scripts_txt2img = ScriptRunner()

     scripts_img2img = ScriptRunner()

 

+

+def IOComponent_init(self, *args, **kwargs):

+    if scripts_current is not None:

+        scripts_current.before_component(self, **kwargs)

+

+    script_callbacks.before_component_callback(self, **kwargs)

+

+    res = original_IOComponent_init(self, *args, **kwargs)

+

+    script_callbacks.after_component_callback(self, **kwargs)

+

+    if scripts_current is not None:

+        scripts_current.after_component(self, **kwargs)

+

+    return res

+

+

+original_IOComponent_init = gr.components.IOComponent.__init__

+gr.components.IOComponent.__init__ = IOComponent_init

diff --git a/modules/sd_hijack.py b/modules/sd_hijack.py
index bc49d235..eaedac13 100644
--- a/modules/sd_hijack.py
+++ b/modules/sd_hijack.py
@@ -14,6 +14,8 @@ from modules.sd_hijack_optimizations import invokeAI_mps_available
 

 import ldm.modules.attention

 import ldm.modules.diffusionmodules.model

+import ldm.models.diffusion.ddim

+import ldm.models.diffusion.plms

 

 attention_CrossAttention_forward = ldm.modules.attention.CrossAttention.forward

 diffusionmodules_model_nonlinearity = ldm.modules.diffusionmodules.model.nonlinearity

@@ -94,8 +96,8 @@ class StableDiffusionModelHijack:
         if type(model_embeddings.token_embedding) == EmbeddingsWithFixes:

             model_embeddings.token_embedding = model_embeddings.token_embedding.wrapped

 

+        self.apply_circular(False)

         self.layers = None

-        self.circular_enabled = False

         self.clip = None

 

     def apply_circular(self, enable):

@@ -406,3 +408,23 @@ def add_circular_option_to_conv_2d():
 

 

 model_hijack = StableDiffusionModelHijack()

+

+

+def register_buffer(self, name, attr):

+    """

+    Fix register buffer bug for Mac OS.

+    """

+

+    if type(attr) == torch.Tensor:

+        if attr.device != devices.device:

+

+            if devices.has_mps():

+                attr = attr.to(device="mps", dtype=torch.float32)

+            else:

+                attr = attr.to(devices.device)

+

+    setattr(self, name, attr)

+

+

+ldm.models.diffusion.ddim.DDIMSampler.register_buffer = register_buffer

+ldm.models.diffusion.plms.PLMSSampler.register_buffer = register_buffer

diff --git a/modules/sd_hijack_inpainting.py b/modules/sd_hijack_inpainting.py
index fd92a335..46714a4f 100644
--- a/modules/sd_hijack_inpainting.py
+++ b/modules/sd_hijack_inpainting.py
@@ -328,4 +328,5 @@ def do_inpainting_hijack():
     ldm.models.diffusion.ddim.DDIMSampler.sample = sample_ddim
 
     ldm.models.diffusion.plms.PLMSSampler.p_sample_plms = p_sample_plms
-    ldm.models.diffusion.plms.PLMSSampler.sample = sample_plms
\ No newline at end of file
+    ldm.models.diffusion.plms.PLMSSampler.sample = sample_plms
+
diff --git a/modules/sd_models.py b/modules/sd_models.py
index 34c57bfa..c59151e0 100644
--- a/modules/sd_models.py
+++ b/modules/sd_models.py
@@ -163,13 +163,14 @@ def load_model_weights(model, checkpoint_info, vae_file="auto"):
     checkpoint_file = checkpoint_info.filename

     sd_model_hash = checkpoint_info.hash

 

-    if shared.opts.sd_checkpoint_cache > 0 and hasattr(model, "sd_checkpoint_info"):

-        sd_vae.restore_base_vae(model)

-        checkpoints_loaded[model.sd_checkpoint_info] = model.state_dict().copy()

+    cache_enabled = shared.opts.sd_checkpoint_cache > 0

 

-    vae_file = sd_vae.resolve_vae(checkpoint_file, vae_file=vae_file)

-

-    if checkpoint_info not in checkpoints_loaded:

+    if cache_enabled and checkpoint_info in checkpoints_loaded:

+        # use checkpoint cache

+        print(f"Loading weights [{sd_model_hash}] from cache")

+        model.load_state_dict(checkpoints_loaded[checkpoint_info])

+    else:

+        # load from file

         print(f"Loading weights [{sd_model_hash}] from {checkpoint_file}")

 

         pl_sd = torch.load(checkpoint_file, map_location=shared.weight_load_location)

@@ -180,6 +181,10 @@ def load_model_weights(model, checkpoint_info, vae_file="auto"):
         del pl_sd

         model.load_state_dict(sd, strict=False)

         del sd

+        

+        if cache_enabled:

+            # cache newly loaded model

+            checkpoints_loaded[checkpoint_info] = model.state_dict().copy()

 

         if shared.cmd_opts.opt_channelslast:

             model.to(memory_format=torch.channels_last)

@@ -199,20 +204,16 @@ def load_model_weights(model, checkpoint_info, vae_file="auto"):
 

         model.first_stage_model.to(devices.dtype_vae)

 

-    else:

-        vae_name = sd_vae.get_filename(vae_file) if vae_file else None

-        vae_message = f" with {vae_name} VAE" if vae_name else ""

-        print(f"Loading weights [{sd_model_hash}]{vae_message} from cache")

-        model.load_state_dict(checkpoints_loaded[checkpoint_info])

-

-    if shared.opts.sd_checkpoint_cache > 0:

-        while len(checkpoints_loaded) > shared.opts.sd_checkpoint_cache:

+    # clean up cache if limit is reached

+    if cache_enabled:

+        while len(checkpoints_loaded) > shared.opts.sd_checkpoint_cache + 1: # we need to count the current model

             checkpoints_loaded.popitem(last=False)  # LRU

 

     model.sd_model_hash = sd_model_hash

     model.sd_model_checkpoint = checkpoint_file

     model.sd_checkpoint_info = checkpoint_info

 

+    vae_file = sd_vae.resolve_vae(checkpoint_file, vae_file=vae_file)

     sd_vae.load_vae(model, vae_file)

 

 

diff --git a/modules/sd_samplers.py b/modules/sd_samplers.py
index 783992d2..4fe67854 100644
--- a/modules/sd_samplers.py
+++ b/modules/sd_samplers.py
@@ -46,16 +46,23 @@ all_samplers = [
     SamplerData('DDIM', lambda model: VanillaStableDiffusionSampler(ldm.models.diffusion.ddim.DDIMSampler, model), [], {}),

     SamplerData('PLMS', lambda model: VanillaStableDiffusionSampler(ldm.models.diffusion.plms.PLMSSampler, model), [], {}),

 ]

+all_samplers_map = {x.name: x for x in all_samplers}

 

 samplers = []

 samplers_for_img2img = []

 

 

-def create_sampler_with_index(list_of_configs, index, model):

-    config = list_of_configs[index]

+def create_sampler(name, model):

+    if name is not None:

+        config = all_samplers_map.get(name, None)

+    else:

+        config = all_samplers[0]

+

+    assert config is not None, f'bad sampler name: {name}'

+

     sampler = config.constructor(model)

     sampler.config = config

-    

+

     return sampler

 

 

diff --git a/modules/sd_vae.py b/modules/sd_vae.py
index 71e7a6e6..9c120975 100644
--- a/modules/sd_vae.py
+++ b/modules/sd_vae.py
@@ -83,47 +83,54 @@ def refresh_vae_list(vae_path=vae_path, model_path=model_path):
     return vae_list
 
 
-def resolve_vae(checkpoint_file, vae_file="auto"):
+def get_vae_from_settings(vae_file="auto"):
+    # else, we load from settings, if not set to be default
+    if vae_file == "auto" and shared.opts.sd_vae is not None:
+        # if saved VAE settings isn't recognized, fallback to auto
+        vae_file = vae_dict.get(shared.opts.sd_vae, "auto")
+        # if VAE selected but not found, fallback to auto
+        if vae_file not in default_vae_values and not os.path.isfile(vae_file):
+            vae_file = "auto"
+            print(f"Selected VAE doesn't exist: {vae_file}")
+    return vae_file
+
+
+def resolve_vae(checkpoint_file=None, vae_file="auto"):
     global first_load, vae_dict, vae_list
 
     # if vae_file argument is provided, it takes priority, but not saved
     if vae_file and vae_file not in default_vae_list:
         if not os.path.isfile(vae_file):
+            print(f"VAE provided as function argument doesn't exist: {vae_file}")
             vae_file = "auto"
-            print("VAE provided as function argument doesn't exist")
     # for the first load, if vae-path is provided, it takes priority, saved, and failure is reported
     if first_load and shared.cmd_opts.vae_path is not None:
         if os.path.isfile(shared.cmd_opts.vae_path):
             vae_file = shared.cmd_opts.vae_path
             shared.opts.data['sd_vae'] = get_filename(vae_file)
         else:
-            print("VAE provided as command line argument doesn't exist")
-    # else, we load from settings
-    if vae_file == "auto" and shared.opts.sd_vae is not None:
-        # if saved VAE settings isn't recognized, fallback to auto
-        vae_file = vae_dict.get(shared.opts.sd_vae, "auto")
-        # if VAE selected but not found, fallback to auto
-        if vae_file not in default_vae_values and not os.path.isfile(vae_file):
-            vae_file = "auto"
-            print("Selected VAE doesn't exist")
+            print(f"VAE provided as command line argument doesn't exist: {vae_file}")
+    # fallback to selector in settings, if vae selector not set to act as default fallback
+    if not shared.opts.sd_vae_as_default:
+        vae_file = get_vae_from_settings(vae_file)
     # vae-path cmd arg takes priority for auto
     if vae_file == "auto" and shared.cmd_opts.vae_path is not None:
         if os.path.isfile(shared.cmd_opts.vae_path):
             vae_file = shared.cmd_opts.vae_path
-            print("Using VAE provided as command line argument")
+            print(f"Using VAE provided as command line argument: {vae_file}")
     # if still not found, try look for ".vae.pt" beside model
     model_path = os.path.splitext(checkpoint_file)[0]
     if vae_file == "auto":
         vae_file_try = model_path + ".vae.pt"
         if os.path.isfile(vae_file_try):
             vae_file = vae_file_try
-            print("Using VAE found beside selected model")
+            print(f"Using VAE found similar to selected model: {vae_file}")
     # if still not found, try look for ".vae.ckpt" beside model
     if vae_file == "auto":
         vae_file_try = model_path + ".vae.ckpt"
         if os.path.isfile(vae_file_try):
             vae_file = vae_file_try
-            print("Using VAE found beside selected model")
+            print(f"Using VAE found similar to selected model: {vae_file}")
     # No more fallbacks for auto
     if vae_file == "auto":
         vae_file = None
@@ -139,6 +146,7 @@ def load_vae(model, vae_file=None):
     # save_settings = False
 
     if vae_file:
+        assert os.path.isfile(vae_file), f"VAE file doesn't exist: {vae_file}"
         print(f"Loading VAE weights from: {vae_file}")
         vae_ckpt = torch.load(vae_file, map_location=shared.weight_load_location)
         vae_dict_1 = {k: v for k, v in vae_ckpt["state_dict"].items() if k[0:4] != "loss" and k not in vae_ignore_keys}
diff --git a/modules/shared.py b/modules/shared.py
index 55de286d..3af7d97b 100644
--- a/modules/shared.py
+++ b/modules/shared.py
@@ -3,7 +3,6 @@ import datetime
 import json

 import os

 import sys

-from collections import OrderedDict

 import time

 

 import gradio as gr

@@ -15,7 +14,7 @@ import modules.memmon
 import modules.sd_models

 import modules.styles

 import modules.devices as devices

-from modules import sd_samplers, sd_models, localization, sd_vae

+from modules import sd_samplers, sd_models, localization, sd_vae, extensions, script_loading

 from modules.hypernetworks import hypernetwork

 from modules.paths import models_path, script_path, sd_path

 

@@ -82,6 +81,7 @@ parser.add_argument("--enable-console-prompts", action='store_true', help="print
 parser.add_argument('--vae-path', type=str, help='Path to Variational Autoencoders model', default=None)

 parser.add_argument("--disable-safe-unpickle", action='store_true', help="disable checking pytorch models for malicious code", default=False)

 parser.add_argument("--api", action='store_true', help="use api=True to launch the API together with the webui (use --nowebui instead for only the API)")

+parser.add_argument("--api-auth", type=str, help='Set authentication for API like "username:password"; or comma-delimit multiple like "u1:p1,u2:p2,u3:p3"', default=None)

 parser.add_argument("--nowebui", action='store_true', help="use api=True to launch the API instead of the webui")

 parser.add_argument("--ui-debug-mode", action='store_true', help="Don't load model to quickly launch UI")

 parser.add_argument("--device-id", type=str, help="Select the default CUDA device to use (export CUDA_VISIBLE_DEVICES=0,1,etc might be needed before)", default=None)

@@ -92,7 +92,10 @@ parser.add_argument("--tls-keyfile", type=str, help="Partially enables TLS, requ
 parser.add_argument("--tls-certfile", type=str, help="Partially enables TLS, requires --tls-keyfile to fully function", default=None)

 parser.add_argument("--server-name", type=str, help="Sets hostname of server", default=None)

 

+script_loading.preload_extensions(extensions.extensions_dir, parser)

+

 cmd_opts = parser.parse_args()

+

 restricted_opts = {

     "samples_filename_pattern",

     "directories_filename_pattern",

@@ -105,7 +108,7 @@ restricted_opts = {
     "outdir_save",

 }

 

-cmd_opts.disable_extension_access = (cmd_opts.share or cmd_opts.listen) and not cmd_opts.enable_insecure_extension_access

+cmd_opts.disable_extension_access = (cmd_opts.share or cmd_opts.listen or cmd_opts.server_name) and not cmd_opts.enable_insecure_extension_access

 

 devices.device, devices.device_interrogate, devices.device_gfpgan, devices.device_swinir, devices.device_esrgan, devices.device_scunet, devices.device_codeformer = \

 (devices.cpu if any(y in cmd_opts.use_cpu for y in [x, 'all']) else devices.get_optimal_device() for x in ['sd', 'interrogate', 'gfpgan', 'swinir', 'esrgan', 'scunet', 'codeformer'])

@@ -320,6 +323,8 @@ options_templates.update(options_section(('system', "System"), {
 

 options_templates.update(options_section(('training', "Training"), {

     "unload_models_when_training": OptionInfo(False, "Move VAE and CLIP to RAM when training if possible. Saves VRAM."),

+    "shuffle_tags": OptionInfo(False, "Shuffleing tags by ',' when create texts."),

+    "tag_drop_out": OptionInfo(0, "Dropout tags when create texts", gr.Slider, {"minimum": 0, "maximum": 1, "step": 0.1}),

     "save_optimizer_state": OptionInfo(False, "Saves Optimizer state as separate *.optim file. Training can be resumed with HN itself and matching optim file."),

     "dataset_filename_word_regex": OptionInfo("", "Filename word regex"),

     "dataset_filename_join_string": OptionInfo(" ", "Filename join string"),

@@ -331,7 +336,8 @@ options_templates.update(options_section(('training', "Training"), {
 options_templates.update(options_section(('sd', "Stable Diffusion"), {

     "sd_model_checkpoint": OptionInfo(None, "Stable Diffusion checkpoint", gr.Dropdown, lambda: {"choices": modules.sd_models.checkpoint_tiles()}, refresh=sd_models.list_models),

     "sd_checkpoint_cache": OptionInfo(0, "Checkpoints to cache in RAM", gr.Slider, {"minimum": 0, "maximum": 10, "step": 1}),

-    "sd_vae": OptionInfo("auto", "SD VAE", gr.Dropdown, lambda: {"choices": list(sd_vae.vae_list)}, refresh=sd_vae.refresh_vae_list),

+    "sd_vae": OptionInfo("auto", "SD VAE", gr.Dropdown, lambda: {"choices": sd_vae.vae_list}, refresh=sd_vae.refresh_vae_list),

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

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

     "sd_hypernetwork_strength": OptionInfo(1.0, "Hypernetwork strength", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.001}),

     "inpainting_mask_weight": OptionInfo(1.0, "Inpainting conditioning mask strength", gr.Slider, {"minimum": 0.0, "maximum": 1.0, "step": 0.01}),

@@ -433,6 +439,23 @@ class Options:
 

         return super(Options, self).__getattribute__(item)

 

+    def set(self, key, value):

+        """sets an option and calls its onchange callback, returning True if the option changed and False otherwise"""

+

+        oldval = self.data.get(key, None)

+        if oldval == value:

+            return False

+

+        try:

+            setattr(self, key, value)

+        except RuntimeError:

+            return False

+

+        if self.data_labels[key].onchange is not None:

+            self.data_labels[key].onchange()

+

+        return True

+

     def save(self, filename):

         assert not cmd_opts.freeze_settings, "saving settings is disabled"

 

diff --git a/modules/styles.py b/modules/styles.py
index 3bf5c5b6..ce6e71ca 100644
--- a/modules/styles.py
+++ b/modules/styles.py
@@ -65,17 +65,6 @@ class StyleDatabase:
     def apply_negative_styles_to_prompt(self, prompt, styles):

         return apply_styles_to_prompt(prompt, [self.styles.get(x, self.no_style).negative_prompt for x in styles])

 

-    def apply_styles(self, p: StableDiffusionProcessing) -> None:

-        if isinstance(p.prompt, list):

-            p.prompt = [self.apply_styles_to_prompt(prompt, p.styles) for prompt in p.prompt]

-        else:

-            p.prompt = self.apply_styles_to_prompt(p.prompt, p.styles)

-

-        if isinstance(p.negative_prompt, list):

-            p.negative_prompt = [self.apply_negative_styles_to_prompt(prompt, p.styles) for prompt in p.negative_prompt]

-        else:

-            p.negative_prompt = self.apply_negative_styles_to_prompt(p.negative_prompt, p.styles)

-

     def save_styles(self, path: str) -> None:

         # Write to temporary file first, so we don't nuke the file if something goes wrong

         fd, temp_path = tempfile.mkstemp(".csv")

diff --git a/modules/textual_inversion/dataset.py b/modules/textual_inversion/dataset.py
index ad726577..eb75c376 100644
--- a/modules/textual_inversion/dataset.py
+++ b/modules/textual_inversion/dataset.py
@@ -98,7 +98,12 @@ class PersonalizedBase(Dataset):
     def create_text(self, filename_text):

         text = random.choice(self.lines)

         text = text.replace("[name]", self.placeholder_token)

-        text = text.replace("[filewords]", filename_text)

+        tags = filename_text.split(',')

+        if shared.opts.tag_drop_out != 0:

+            tags = [t for t in tags if random.random() > shared.opts.tag_drop_out]

+        if shared.opts.shuffle_tags:

+            random.shuffle(tags)

+        text = text.replace("[filewords]", ','.join(tags))

         return text

 

     def __len__(self):

diff --git a/modules/textual_inversion/preprocess.py b/modules/textual_inversion/preprocess.py
index e13b1894..488aa5b5 100644
--- a/modules/textual_inversion/preprocess.py
+++ b/modules/textual_inversion/preprocess.py
@@ -35,6 +35,84 @@ def preprocess(process_src, process_dst, process_width, process_height, preproce
             deepbooru.release_process()

 

 

+def listfiles(dirname):

+    return os.listdir(dirname)

+

+

+class PreprocessParams:

+    src = None

+    dstdir = None

+    subindex = 0

+    flip = False

+    process_caption = False

+    process_caption_deepbooru = False

+    preprocess_txt_action = None

+

+

+def save_pic_with_caption(image, index, params: PreprocessParams, existing_caption=None):

+    caption = ""

+

+    if params.process_caption:

+        caption += shared.interrogator.generate_caption(image)

+

+    if params.process_caption_deepbooru:

+        if len(caption) > 0:

+            caption += ", "

+        caption += deepbooru.get_tags_from_process(image)

+

+    filename_part = params.src

+    filename_part = os.path.splitext(filename_part)[0]

+    filename_part = os.path.basename(filename_part)

+

+    basename = f"{index:05}-{params.subindex}-{filename_part}"

+    image.save(os.path.join(params.dstdir, f"{basename}.png"))

+

+    if params.preprocess_txt_action == 'prepend' and existing_caption:

+        caption = existing_caption + ' ' + caption

+    elif params.preprocess_txt_action == 'append' and existing_caption:

+        caption = caption + ' ' + existing_caption

+    elif params.preprocess_txt_action == 'copy' and existing_caption:

+        caption = existing_caption

+

+    caption = caption.strip()

+

+    if len(caption) > 0:

+        with open(os.path.join(params.dstdir, f"{basename}.txt"), "w", encoding="utf8") as file:

+            file.write(caption)

+

+    params.subindex += 1

+

+

+def save_pic(image, index, params, existing_caption=None):

+    save_pic_with_caption(image, index, params, existing_caption=existing_caption)

+

+    if params.flip:

+        save_pic_with_caption(ImageOps.mirror(image), index, params, existing_caption=existing_caption)

+

+

+def split_pic(image, inverse_xy, width, height, overlap_ratio):

+    if inverse_xy:

+        from_w, from_h = image.height, image.width

+        to_w, to_h = height, width

+    else:

+        from_w, from_h = image.width, image.height

+        to_w, to_h = width, height

+    h = from_h * to_w // from_w

+    if inverse_xy:

+        image = image.resize((h, to_w))

+    else:

+        image = image.resize((to_w, h))

+

+    split_count = math.ceil((h - to_h * overlap_ratio) / (to_h * (1.0 - overlap_ratio)))

+    y_step = (h - to_h) / (split_count - 1)

+    for i in range(split_count):

+        y = int(y_step * i)

+        if inverse_xy:

+            splitted = image.crop((y, 0, y + to_h, to_w))

+        else:

+            splitted = image.crop((0, y, to_w, y + to_h))

+        yield splitted

+

 

 def preprocess_work(process_src, process_dst, process_width, process_height, preprocess_txt_action, 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):

     width = process_width

@@ -48,82 +126,28 @@ def preprocess_work(process_src, process_dst, process_width, process_height, pre
 

     os.makedirs(dst, exist_ok=True)

 

-    files = os.listdir(src)

+    files = listfiles(src)

 

     shared.state.textinfo = "Preprocessing..."

     shared.state.job_count = len(files)

 

-    def save_pic_with_caption(image, index, existing_caption=None):

-        caption = ""

-

-        if process_caption:

-            caption += shared.interrogator.generate_caption(image)

-

-        if process_caption_deepbooru:

-            if len(caption) > 0:

-                caption += ", "

-            caption += deepbooru.get_tags_from_process(image)

-

-        filename_part = filename

-        filename_part = os.path.splitext(filename_part)[0]

-        filename_part = os.path.basename(filename_part)

-

-        basename = f"{index:05}-{subindex[0]}-{filename_part}"

-        image.save(os.path.join(dst, f"{basename}.png"))

-

-        if preprocess_txt_action == 'prepend' and existing_caption:

-            caption = existing_caption + ' ' + caption

-        elif preprocess_txt_action == 'append' and existing_caption:

-            caption = caption + ' ' + existing_caption

-        elif preprocess_txt_action == 'copy' and existing_caption:

-            caption = existing_caption

-

-        caption = caption.strip()

-        

-        if len(caption) > 0:

-            with open(os.path.join(dst, f"{basename}.txt"), "w", encoding="utf8") as file:

-                file.write(caption)

-

-        subindex[0] += 1

-

-    def save_pic(image, index, existing_caption=None):

-        save_pic_with_caption(image, index, existing_caption=existing_caption)

-

-        if process_flip:

-            save_pic_with_caption(ImageOps.mirror(image), index, existing_caption=existing_caption)

-

-    def split_pic(image, inverse_xy):

-        if inverse_xy:

-            from_w, from_h = image.height, image.width

-            to_w, to_h = height, width

-        else:

-            from_w, from_h = image.width, image.height

-            to_w, to_h = width, height

-        h = from_h * to_w // from_w

-        if inverse_xy:

-            image = image.resize((h, to_w))

-        else:

-            image = image.resize((to_w, h))

-

-        split_count = math.ceil((h - to_h * overlap_ratio) / (to_h * (1.0 - overlap_ratio)))

-        y_step = (h - to_h) / (split_count - 1)

-        for i in range(split_count):

-            y = int(y_step * i)

-            if inverse_xy:

-                splitted = image.crop((y, 0, y + to_h, to_w))

-            else:

-                splitted = image.crop((0, y, to_w, y + to_h))

-            yield splitted

-

+    params = PreprocessParams()

+    params.dstdir = dst

+    params.flip = process_flip

+    params.process_caption = process_caption

+    params.process_caption_deepbooru = process_caption_deepbooru

+    params.preprocess_txt_action = preprocess_txt_action

 

     for index, imagefile in enumerate(tqdm.tqdm(files)):

-        subindex = [0]

+        params.subindex = 0

         filename = os.path.join(src, imagefile)

         try:

             img = Image.open(filename).convert("RGB")

         except Exception:

             continue

 

+        params.src = filename

+

         existing_caption = None

         existing_caption_filename = os.path.splitext(filename)[0] + '.txt'

         if os.path.exists(existing_caption_filename):

@@ -143,8 +167,8 @@ def preprocess_work(process_src, process_dst, process_width, process_height, pre
         process_default_resize = True

 

         if process_split and ratio < 1.0 and ratio <= split_threshold:

-            for splitted in split_pic(img, inverse_xy):

-                save_pic(splitted, index, existing_caption=existing_caption)

+            for splitted in split_pic(img, inverse_xy, width, height, overlap_ratio):

+                save_pic(splitted, index, params, existing_caption=existing_caption)

             process_default_resize = False

 

         if process_focal_crop and img.height != img.width:

@@ -165,11 +189,11 @@ def preprocess_work(process_src, process_dst, process_width, process_height, pre
                 dnn_model_path = dnn_model_path,

             )

             for focal in autocrop.crop_image(img, autocrop_settings):

-                save_pic(focal, index, existing_caption=existing_caption)

+                save_pic(focal, index, params, existing_caption=existing_caption)

             process_default_resize = False

 

         if process_default_resize:

             img = images.resize_image(1, img, width, height)

-            save_pic(img, index, existing_caption=existing_caption)

+            save_pic(img, index, params, existing_caption=existing_caption)

 

-        shared.state.nextjob()
\ No newline at end of file
+        shared.state.nextjob()

diff --git a/modules/textual_inversion/textual_inversion.py b/modules/textual_inversion/textual_inversion.py
index 0aeb0459..5e4d8688 100644
--- a/modules/textual_inversion/textual_inversion.py
+++ b/modules/textual_inversion/textual_inversion.py
@@ -10,7 +10,7 @@ import csv
 

 from PIL import Image, PngImagePlugin

 

-from modules import shared, devices, sd_hijack, processing, sd_models, images

+from modules import shared, devices, sd_hijack, processing, sd_models, images, sd_samplers

 import modules.textual_inversion.dataset

 from modules.textual_inversion.learn_schedule import LearnRateScheduler

 

@@ -345,7 +345,7 @@ def train_embedding(embedding_name, learn_rate, batch_size, data_root, log_direc
                 p.prompt = preview_prompt

                 p.negative_prompt = preview_negative_prompt

                 p.steps = preview_steps

-                p.sampler_index = preview_sampler_index

+                p.sampler_name = sd_samplers.samplers[preview_sampler_index].name

                 p.cfg_scale = preview_cfg_scale

                 p.seed = preview_seed

                 p.width = preview_width

diff --git a/modules/textual_inversion/ui.py b/modules/textual_inversion/ui.py
index d679e6f4..35c4feef 100644
--- a/modules/textual_inversion/ui.py
+++ b/modules/textual_inversion/ui.py
@@ -18,7 +18,7 @@ def create_embedding(name, initialization_text, nvpt, overwrite_old):
 def preprocess(*args):

     modules.textual_inversion.preprocess.preprocess(*args)

 

-    return "Preprocessing finished.", ""

+    return f"Preprocessing {'interrupted' if shared.state.interrupted else 'finished'}.", ""

 

 

 def train_embedding(*args):

diff --git a/modules/txt2img.py b/modules/txt2img.py
index 8e4e8677..c8f81176 100644
--- a/modules/txt2img.py
+++ b/modules/txt2img.py
@@ -1,4 +1,5 @@
 import modules.scripts

+from modules import sd_samplers

 from modules.processing import StableDiffusionProcessing, Processed, StableDiffusionProcessingTxt2Img, \

     StableDiffusionProcessingImg2Img, process_images

 from modules.shared import opts, cmd_opts

@@ -21,7 +22,7 @@ def txt2img(prompt: str, negative_prompt: str, prompt_style: str, prompt_style2:
         seed_resize_from_h=seed_resize_from_h,

         seed_resize_from_w=seed_resize_from_w,

         seed_enable_extras=seed_enable_extras,

-        sampler_index=sampler_index,

+        sampler_name=sd_samplers.samplers[sampler_index].name,

         batch_size=batch_size,

         n_iter=n_iter,

         steps=steps,

diff --git a/modules/ui.py b/modules/ui.py
index 34c31ef1..a5953fce 100644
--- a/modules/ui.py
+++ b/modules/ui.py
@@ -69,8 +69,11 @@ sample_img2img = sample_img2img if os.path.exists(sample_img2img) else None
 css_hide_progressbar = """

 .wrap .m-12 svg { display:none!important; }

 .wrap .m-12::before { content:"Loading..." }

+.wrap .z-20 svg { display:none!important; }

+.wrap .z-20::before { content:"Loading..." }

 .progress-bar { display:none!important; }

 .meta-text { display:none!important; }

+.meta-text-center { display:none!important; }

 """

 

 # Using constants for these since the variation selector isn't visible.

@@ -142,7 +145,7 @@ def save_files(js_data, images, do_make_zip, index):
                 filenames.append(os.path.basename(txt_fullfn))

                 fullfns.append(txt_fullfn)

 

-        writer.writerow([data["prompt"], data["seed"], data["width"], data["height"], data["sampler"], data["cfg_scale"], data["steps"], filenames[0], data["negative_prompt"]])

+        writer.writerow([data["prompt"], data["seed"], data["width"], data["height"], data["sampler_name"], data["cfg_scale"], data["steps"], filenames[0], data["negative_prompt"]])

 

     # Make Zip

     if do_make_zip:

@@ -566,6 +569,19 @@ def apply_setting(key, value):
     return value

 

 

+def update_generation_info(args):

+    generation_info, html_info, img_index = args

+    try:

+        generation_info = json.loads(generation_info)

+        if img_index < 0 or img_index >= len(generation_info["infotexts"]):

+            return html_info

+        return plaintext_to_html(generation_info["infotexts"][img_index])

+    except Exception:

+        pass

+    # if the json parse or anything else fails, just return the old html_info

+    return html_info

+

+

 def create_refresh_button(refresh_component, refresh_method, refreshed_args, elem_id):

     def refresh():

         refresh_method()

@@ -638,6 +654,15 @@ Requested path was: {f}
                     with gr.Group():

                         html_info = gr.HTML()

                         generation_info = gr.Textbox(visible=False)

+                        if tabname == 'txt2img' or tabname == 'img2img':

+                            generation_info_button = gr.Button(visible=False, elem_id=f"{tabname}_generation_info_button")

+                            generation_info_button.click(

+                                fn=update_generation_info,

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

+                                inputs=[generation_info, html_info],

+                                outputs=[html_info],

+                                preprocess=False

+                            )

 

                         save.click(

                             fn=wrap_gradio_call(save_files),

@@ -670,6 +695,9 @@ def create_ui(wrap_gradio_gpu_call):
 

     parameters_copypaste.reset()

 

+    modules.scripts.scripts_current = modules.scripts.scripts_txt2img

+    modules.scripts.scripts_txt2img.initialize_scripts(is_img2img=False)

+

     with gr.Blocks(analytics_enabled=False) as txt2img_interface:

         txt2img_prompt, roll, txt2img_prompt_style, txt2img_negative_prompt, txt2img_prompt_style2, submit, _, _, txt2img_prompt_style_apply, txt2img_save_style, txt2img_paste, token_counter, token_button = create_toprow(is_img2img=False)

         dummy_component = gr.Label(visible=False)

@@ -712,7 +740,7 @@ def create_ui(wrap_gradio_gpu_call):
                 seed, reuse_seed, subseed, reuse_subseed, subseed_strength, seed_resize_from_h, seed_resize_from_w, seed_checkbox = create_seed_inputs()

 

                 with gr.Group():

-                    custom_inputs = modules.scripts.scripts_txt2img.setup_ui(is_img2img=False)

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

 

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

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

@@ -821,6 +849,9 @@ def create_ui(wrap_gradio_gpu_call):
 

             token_button.click(fn=update_token_counter, inputs=[txt2img_prompt, steps], outputs=[token_counter])

 

+    modules.scripts.scripts_current = modules.scripts.scripts_img2img

+    modules.scripts.scripts_img2img.initialize_scripts(is_img2img=True)

+

     with gr.Blocks(analytics_enabled=False) as img2img_interface:

         img2img_prompt, roll, img2img_prompt_style, img2img_negative_prompt, img2img_prompt_style2, submit, img2img_interrogate, img2img_deepbooru, img2img_prompt_style_apply, img2img_save_style, img2img_paste, token_counter, token_button = create_toprow(is_img2img=True)

 

@@ -891,7 +922,7 @@ def create_ui(wrap_gradio_gpu_call):
                 seed, reuse_seed, subseed, reuse_subseed, subseed_strength, seed_resize_from_h, seed_resize_from_w, seed_checkbox = create_seed_inputs()

 

                 with gr.Group():

-                    custom_inputs = modules.scripts.scripts_img2img.setup_ui(is_img2img=True)

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

 

             img2img_gallery, generation_info, html_info = create_output_panel("img2img", opts.outdir_img2img_samples)

             parameters_copypaste.bind_buttons({"img2img": img2img_paste}, None, img2img_prompt)

@@ -1040,6 +1071,8 @@ def create_ui(wrap_gradio_gpu_call):
             parameters_copypaste.add_paste_fields("img2img", init_img, img2img_paste_fields)

             parameters_copypaste.add_paste_fields("inpaint", init_img_with_mask, img2img_paste_fields)

 

+    modules.scripts.scripts_current = None

+

     with gr.Blocks(analytics_enabled=False) as extras_interface:

         with gr.Row().style(equal_height=False):

             with gr.Column(variant='panel'):

@@ -1227,7 +1260,9 @@ def create_ui(wrap_gradio_gpu_call):
                             gr.HTML(value="")

 

                         with gr.Column():

-                            run_preprocess = gr.Button(value="Preprocess", variant='primary')

+                            with gr.Row():

+                                interrupt_preprocessing = gr.Button("Interrupt")

+                                run_preprocess = gr.Button(value="Preprocess", variant='primary')

 

                     process_split.change(

                         fn=lambda show: gr_show(show),

@@ -1270,6 +1305,10 @@ def create_ui(wrap_gradio_gpu_call):
                         train_hypernetwork = gr.Button(value="Train Hypernetwork", variant='primary')

                         train_embedding = gr.Button(value="Train Embedding", variant='primary')

 

+                params = script_callbacks.UiTrainTabParams(txt2img_preview_params)

+

+                script_callbacks.ui_train_tabs_callback(params)

+

             with gr.Column():

                 progressbar = gr.HTML(elem_id="ti_progressbar")

                 ti_output = gr.Text(elem_id="ti_output", value="", show_label=False)

@@ -1396,6 +1435,12 @@ def create_ui(wrap_gradio_gpu_call):
             outputs=[],

         )

 

+        interrupt_preprocessing.click(

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

+            inputs=[],

+            outputs=[],

+        )

+

     def create_setting_component(key, is_quicksettings=False):

         def fun():

             return opts.data[key] if key in opts.data else opts.data_labels[key].default

@@ -1447,16 +1492,9 @@ def create_ui(wrap_gradio_gpu_call):
             if comp == dummy_component:

                 continue

 

-            oldval = opts.data.get(key, None)

-            try:

-                setattr(opts, key, value)

-            except RuntimeError:

-                continue

-            if oldval != value:

-                if opts.data_labels[key].onchange is not None:

-                    opts.data_labels[key].onchange()

-

+            if opts.set(key, value):

                 changed.append(key)

+

         try:

             opts.save(shared.config_filename)

         except RuntimeError:

@@ -1467,15 +1505,8 @@ def create_ui(wrap_gradio_gpu_call):
         if not opts.same_type(value, opts.data_labels[key].default):

             return gr.update(visible=True), opts.dumpjson()

 

-        oldval = opts.data.get(key, None)

-        try:

-            setattr(opts, key, value)

-        except Exception:

-            return gr.update(value=oldval), opts.dumpjson()

-

-        if oldval != value:

-            if opts.data_labels[key].onchange is not None:

-                opts.data_labels[key].onchange()

+        if not opts.set(key, value):

+            return gr.update(value=getattr(opts, key)), opts.dumpjson()

 

         opts.save(shared.config_filename)

 

@@ -1752,7 +1783,7 @@ def create_ui(wrap_gradio_gpu_call):
     return demo

 

 

-def load_javascript(raw_response):

+def reload_javascript():

     with open(os.path.join(script_path, "script.js"), "r", encoding="utf8") as jsfile:

         javascript = f'<script>{jsfile.read()}</script>'

 

@@ -1768,7 +1799,7 @@ def load_javascript(raw_response):
     javascript += f"\n<script>{localization.localization_js(shared.opts.localization)}</script>"

 

     def template_response(*args, **kwargs):

-        res = raw_response(*args, **kwargs)

+        res = shared.GradioTemplateResponseOriginal(*args, **kwargs)

         res.body = res.body.replace(

             b'</head>', f'{javascript}</head>'.encode("utf8"))

         res.init_headers()

@@ -1777,4 +1808,5 @@ def load_javascript(raw_response):
     gradio.routes.templates.TemplateResponse = template_response

 

 

-reload_javascript = partial(load_javascript, gradio.routes.templates.TemplateResponse)

+if not hasattr(shared, 'GradioTemplateResponseOriginal'):

+    shared.GradioTemplateResponseOriginal = gradio.routes.templates.TemplateResponse

diff --git a/modules/ui_extensions.py b/modules/ui_extensions.py
index 02ab9643..030f011e 100644
--- a/modules/ui_extensions.py
+++ b/modules/ui_extensions.py
@@ -36,9 +36,9 @@ def apply_and_restart(disable_list, update_list):
             continue

 

         try:

-            ext.pull()

+            ext.fetch_and_reset_hard()

         except Exception:

-            print(f"Error pulling updates for {ext.name}:", file=sys.stderr)

+            print(f"Error getting updates for {ext.name}:", file=sys.stderr)

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

 

     shared.opts.disabled_extensions = disabled

@@ -134,6 +134,9 @@ def install_extension_from_url(dirname, url):
 

         os.rename(tmpdir, target_dir)

 

+        import launch

+        launch.run_extension_installer(target_dir)

+

         extensions.list_extensions()

         return [extension_table(), html.escape(f"Installed into {target_dir}. Use Installed tab to restart.")]

     finally: