Merge branch 'master' of https://github.com/AUTOMATIC1111/stable-diffusion-webui

23 files changed, 719 insertions, 175 deletions

diff --git a/modules/api/api.py b/modules/api/api.py
index 6c06d449..a49f3755 100644
--- a/modules/api/api.py
+++ b/modules/api/api.py
@@ -1,14 +1,18 @@
+import base64
+import io
 import time
 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, HTTPException
+from fastapi import APIRouter, Depends, FastAPI, HTTPException
 import modules.shared as shared
-from modules import devices
 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 modules.sd_models import checkpoints_list
+from modules.realesrgan_model import get_realesrgan_models
+from typing import List
 
 def upscaler_to_index(name: str):
     try:
@@ -29,8 +33,14 @@ def setUpscalers(req: dict):
     return reqDict
 
 
+def encode_pil_to_base64(image):
+    buffer = io.BytesIO()
+    image.save(buffer, format="png")
+    return base64.b64encode(buffer.getvalue())
+
+
 class Api:
-    def __init__(self, app, queue_lock):
+    def __init__(self, app: FastAPI, queue_lock: Lock):
         self.router = APIRouter()
         self.app = app
         self.queue_lock = queue_lock
@@ -40,6 +50,19 @@ class Api:
         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/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])
 
     def text2imgapi(self, txt2imgreq: StableDiffusionTxt2ImgProcessingAPI):
         sampler_index = sampler_to_index(txt2imgreq.sampler_index)
@@ -170,12 +193,79 @@ class Api:
 
         progress = min(progress, 1)
 
+        shared.state.set_current_image()
+
         current_image = None
         if shared.state.current_image and not req.skip_current_image:
             current_image = encode_pil_to_base64(shared.state.current_image)
 
         return ProgressResponse(progress=progress, eta_relative=eta_relative, state=shared.state.dict(), current_image=current_image)
 
+    def interruptapi(self):
+        shared.state.interrupt()
+
+        return {}
+        
+    def get_config(self):
+        options = {}
+        for key in shared.opts.data.keys():
+            metadata = shared.opts.data_labels.get(key)
+            if(metadata is not None):
+                options.update({key: shared.opts.data.get(key, shared.opts.data_labels.get(key).default)})
+            else:
+                options.update({key: shared.opts.data.get(key, None)})
+        
+        return options
+        
+    def set_config(self, req: OptionsModel):
+        reqDict = vars(req)
+        for o in reqDict:
+            setattr(shared.opts, o, reqDict[o])
+
+        shared.opts.save(shared.config_filename)
+        return
+
+    def get_cmd_flags(self):
+        return vars(shared.cmd_opts)
+
+    def get_samplers(self):
+        return [{"name":sampler[0], "aliases":sampler[2], "options":sampler[3]} for sampler in all_samplers]
+
+    def get_upscalers(self):
+        upscalers = []
+        
+        for upscaler in shared.sd_upscalers:
+            u = upscaler.scaler
+            upscalers.append({"name":u.name, "model_name":u.model_name, "model_path":u.model_path, "model_url":u.model_url})
+        
+        return upscalers
+        
+    def get_sd_models(self):
+        return [{"title":x.title, "model_name":x.model_name, "hash":x.hash, "filename": x.filename, "config": x.config} for x in checkpoints_list.values()]
+
+    def get_hypernetworks(self):
+        return [{"name": name, "path": shared.hypernetworks[name]} for name in shared.hypernetworks]
+
+    def get_face_restorers(self):
+        return [{"name":x.name(), "cmd_dir": getattr(x, "cmd_dir", None)} for x in shared.face_restorers]
+
+    def get_realesrgan_models(self):
+        return [{"name":x.name,"path":x.data_path, "scale":x.scale} for x in get_realesrgan_models(None)]
+    
+    def get_promp_styles(self):
+        styleList = []
+        for k in shared.prompt_styles.styles:
+            style = shared.prompt_styles.styles[k] 
+            styleList.append({"name":style[0], "prompt": style[1], "negative_prompr": style[2]})
+
+        return styleList
+
+    def get_artists_categories(self):
+        return shared.artist_db.cats
+
+    def get_artists(self):
+        return [{"name":x[0], "score":x[1], "category":x[2]} for x in shared.artist_db.artists]
+
     def launch(self, server_name, port):
         self.app.include_router(self.router)
         uvicorn.run(self.app, host=server_name, port=port)
diff --git a/modules/api/models.py b/modules/api/models.py
index 9ee42a17..2ae75f43 100644
--- a/modules/api/models.py
+++ b/modules/api/models.py
@@ -1,11 +1,11 @@
 import inspect
-from click import prompt
 from pydantic import BaseModel, Field, create_model
-from typing import Any, Optional
+from typing import Any, Optional, Union
 from typing_extensions import Literal
 from inflection import underscore
 from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img
-from modules.shared import sd_upscalers
+from modules.shared import sd_upscalers, opts, parser
+from typing import List
 
 API_NOT_ALLOWED = [
     "self",
@@ -109,12 +109,12 @@ StableDiffusionImg2ImgProcessingAPI = PydanticModelGenerator(
 ).generate_model()
 
 class TextToImageResponse(BaseModel):
-    images: list[str] = Field(default=None, title="Image", description="The generated image in base64 format.")
+    images: List[str] = Field(default=None, title="Image", description="The generated image in base64 format.")
     parameters: dict
     info: str
 
 class ImageToImageResponse(BaseModel):
-    images: list[str] = Field(default=None, title="Image", description="The generated image in base64 format.")
+    images: List[str] = Field(default=None, title="Image", description="The generated image in base64 format.")
     parameters: dict
     info: str
 
@@ -131,6 +131,7 @@ class ExtrasBaseRequest(BaseModel):
     upscaler_1: str = Field(default="None", title="Main upscaler", description=f"The name of the main upscaler to use, it has to be one of this list: {' , '.join([x.name for x in sd_upscalers])}")
     upscaler_2: str = Field(default="None", title="Secondary upscaler", description=f"The name of the secondary upscaler to use, it has to be one of this list: {' , '.join([x.name for x in sd_upscalers])}")
     extras_upscaler_2_visibility: float = Field(default=0, title="Secondary upscaler visibility", ge=0, le=1, allow_inf_nan=False, description="Sets the visibility of secondary upscaler, values should be between 0 and 1.")
+    upscale_first: bool = Field(default=False, title="Upscale first", description="Should the upscaler run before restoring faces?")
 
 class ExtraBaseResponse(BaseModel):
     html_info: str = Field(title="HTML info", description="A series of HTML tags containing the process info.")
@@ -146,10 +147,10 @@ class FileData(BaseModel):
     name: str = Field(title="File name")
 
 class ExtrasBatchImagesRequest(ExtrasBaseRequest):
-    imageList: list[FileData] = Field(title="Images", description="List of images to work on. Must be Base64 strings")
+    imageList: List[FileData] = Field(title="Images", description="List of images to work on. Must be Base64 strings")
 
 class ExtrasBatchImagesResponse(ExtraBaseResponse):
-    images: list[str] = Field(title="Images", description="The generated images in base64 format.")
+    images: List[str] = Field(title="Images", description="The generated images in base64 format.")
 
 class PNGInfoRequest(BaseModel):
     image: str = Field(title="Image", description="The base64 encoded PNG image")
@@ -165,3 +166,68 @@ class ProgressResponse(BaseModel):
     eta_relative: float = Field(title="ETA in secs")
     state: dict = Field(title="State", description="The current state snapshot")
     current_image: str = Field(default=None, title="Current image", description="The current image in base64 format. opts.show_progress_every_n_steps is required for this to work.")
+
+fields = {}
+for key, value in opts.data.items():
+    metadata = opts.data_labels.get(key)
+    optType = opts.typemap.get(type(value), type(value))
+
+    if (metadata is not None):
+        fields.update({key: (Optional[optType], Field(
+            default=metadata.default ,description=metadata.label))})
+    else:
+        fields.update({key: (Optional[optType], Field())})
+
+OptionsModel = create_model("Options", **fields)
+
+flags = {}
+_options = vars(parser)['_option_string_actions']
+for key in _options:
+    if(_options[key].dest != 'help'):
+        flag = _options[key]
+        _type = str 
+        if(_options[key].default != None): _type = type(_options[key].default) 
+        flags.update({flag.dest: (_type,Field(default=flag.default, description=flag.help))})
+
+FlagsModel = create_model("Flags", **flags)
+
+class SamplerItem(BaseModel):
+    name: str = Field(title="Name")
+    aliases: list[str]  = Field(title="Aliases")
+    options: dict[str, str] = Field(title="Options")
+
+class UpscalerItem(BaseModel):
+    name: str = Field(title="Name")
+    model_name: str | None = Field(title="Model Name")
+    model_path: str | None = Field(title="Path")
+    model_url: str | None = Field(title="URL")
+
+class SDModelItem(BaseModel):
+    title: str = Field(title="Title")
+    model_name: str = Field(title="Model Name")
+    hash: str = Field(title="Hash")
+    filename: str = Field(title="Filename")
+    config: str = Field(title="Config file")
+
+class HypernetworkItem(BaseModel):
+    name: str = Field(title="Name")
+    path: str | None = Field(title="Path")
+
+class FaceRestorerItem(BaseModel):
+    name: str = Field(title="Name")
+    cmd_dir: str | None = Field(title="Path")
+
+class RealesrganItem(BaseModel):
+    name: str = Field(title="Name")
+    path: str | None = Field(title="Path")
+    scale: int | None = Field(title="Scale")
+
+class PromptStyleItem(BaseModel):
+    name: str = Field(title="Name")
+    prompt: str | None = Field(title="Prompt")
+    negative_prompt: str | None = Field(title="Negative Prompt")
+
+class ArtistItem(BaseModel):
+    name: str = Field(title="Name")
+    score: float = Field(title="Score")
+    category: str = Field(title="Category")
\ No newline at end of file
diff --git a/modules/esrgan_model.py b/modules/esrgan_model.py
index a13cf6ac..c61669b4 100644
--- a/modules/esrgan_model.py
+++ b/modules/esrgan_model.py
@@ -50,6 +50,7 @@ def mod2normal(state_dict):
 def resrgan2normal(state_dict, nb=23):

     # this code is copied from https://github.com/victorca25/iNNfer

     if "conv_first.weight" in state_dict and "body.0.rdb1.conv1.weight" in state_dict:

+        re8x = 0

         crt_net = {}

         items = []

         for k, v in state_dict.items():

@@ -75,10 +76,18 @@ def resrgan2normal(state_dict, nb=23):
         crt_net['model.3.bias'] = state_dict['conv_up1.bias']

         crt_net['model.6.weight'] = state_dict['conv_up2.weight']

         crt_net['model.6.bias'] = state_dict['conv_up2.bias']

-        crt_net['model.8.weight'] = state_dict['conv_hr.weight']

-        crt_net['model.8.bias'] = state_dict['conv_hr.bias']

-        crt_net['model.10.weight'] = state_dict['conv_last.weight']

-        crt_net['model.10.bias'] = state_dict['conv_last.bias']

+

+        if 'conv_up3.weight' in state_dict:

+            # modification supporting: https://github.com/ai-forever/Real-ESRGAN/blob/main/RealESRGAN/rrdbnet_arch.py

+            re8x = 3

+            crt_net['model.9.weight'] = state_dict['conv_up3.weight']

+            crt_net['model.9.bias'] = state_dict['conv_up3.bias']

+

+        crt_net[f'model.{8+re8x}.weight'] = state_dict['conv_hr.weight']

+        crt_net[f'model.{8+re8x}.bias'] = state_dict['conv_hr.bias']

+        crt_net[f'model.{10+re8x}.weight'] = state_dict['conv_last.weight']

+        crt_net[f'model.{10+re8x}.bias'] = state_dict['conv_last.bias']

+

         state_dict = crt_net

     return state_dict

 

diff --git a/modules/extras.py b/modules/extras.py
index 4d51088b..71b93a06 100644
--- a/modules/extras.py
+++ b/modules/extras.py
@@ -136,10 +136,11 @@ def run_extras(extras_mode, resize_mode, image, image_folder, input_dir, output_
 

     def run_upscalers_blend(params: List[UpscaleParams], image: Image.Image, info: str) -> Tuple[Image.Image, str]:

         blended_result: Image.Image = None

+        image_hash: str = hash(np.array(image.getdata()).tobytes())

         for upscaler in params:

             upscale_args = (upscaler.upscaler_idx, upscaling_resize, resize_mode,

                             upscaling_resize_w, upscaling_resize_h, upscaling_crop)

-            cache_key = LruCache.Key(image_hash=hash(np.array(image.getdata()).tobytes()),

+            cache_key = LruCache.Key(image_hash=image_hash,

                                      info_hash=hash(info),

                                      args_hash=hash(upscale_args))

             cached_entry = cached_images.get(cache_key)

diff --git a/modules/hypernetworks/hypernetwork.py b/modules/hypernetworks/hypernetwork.py
index a11e01d6..6e1a10cf 100644
--- a/modules/hypernetworks/hypernetwork.py
+++ b/modules/hypernetworks/hypernetwork.py
@@ -35,7 +35,8 @@ class HypernetworkModule(torch.nn.Module):
     }

     activation_dict.update({cls_name.lower(): cls_obj for cls_name, cls_obj in inspect.getmembers(torch.nn.modules.activation) if inspect.isclass(cls_obj) and cls_obj.__module__ == 'torch.nn.modules.activation'})

 

-    def __init__(self, dim, state_dict=None, layer_structure=None, activation_func=None, weight_init='Normal', add_layer_norm=False, use_dropout=False):

+    def __init__(self, dim, state_dict=None, layer_structure=None, activation_func=None, weight_init='Normal',

+                 add_layer_norm=False, use_dropout=False, activate_output=False, last_layer_dropout=True):

         super().__init__()

 

         assert layer_structure is not None, "layer_structure must not be None"

@@ -48,8 +49,8 @@ class HypernetworkModule(torch.nn.Module):
             # Add a fully-connected layer

             linears.append(torch.nn.Linear(int(dim * layer_structure[i]), int(dim * layer_structure[i+1])))

 

-            # Add an activation func

-            if activation_func == "linear" or activation_func is None:

+            # Add an activation func except last layer

+            if activation_func == "linear" or activation_func is None or (i >= len(layer_structure) - 2 and not activate_output):

                 pass

             elif activation_func in self.activation_dict:

                 linears.append(self.activation_dict[activation_func]())

@@ -60,8 +61,8 @@ class HypernetworkModule(torch.nn.Module):
             if add_layer_norm:

                 linears.append(torch.nn.LayerNorm(int(dim * layer_structure[i+1])))

 

-            # Add dropout expect last layer

-            if use_dropout and i < len(layer_structure) - 3:

+            # Add dropout except last layer

+            if use_dropout and (i < len(layer_structure) - 3 or last_layer_dropout and i < len(layer_structure) - 2):

                 linears.append(torch.nn.Dropout(p=0.3))

 

         self.linear = torch.nn.Sequential(*linears)

@@ -75,7 +76,7 @@ class HypernetworkModule(torch.nn.Module):
                     w, b = layer.weight.data, layer.bias.data

                     if weight_init == "Normal" or type(layer) == torch.nn.LayerNorm:

                         normal_(w, mean=0.0, std=0.01)

-                        normal_(b, mean=0.0, std=0.005)

+                        normal_(b, mean=0.0, std=0)

                     elif weight_init == 'XavierUniform':

                         xavier_uniform_(w)

                         zeros_(b)

@@ -127,7 +128,7 @@ class Hypernetwork:
     filename = None

     name = None

 

-    def __init__(self, name=None, enable_sizes=None, layer_structure=None, activation_func=None, weight_init=None, add_layer_norm=False, use_dropout=False):

+    def __init__(self, name=None, enable_sizes=None, layer_structure=None, activation_func=None, weight_init=None, add_layer_norm=False, use_dropout=False, activate_output=False, **kwargs):

         self.filename = None

         self.name = name

         self.layers = {}

@@ -139,11 +140,15 @@ class Hypernetwork:
         self.weight_init = weight_init

         self.add_layer_norm = add_layer_norm

         self.use_dropout = use_dropout

+        self.activate_output = activate_output

+        self.last_layer_dropout = kwargs['last_layer_dropout'] if 'last_layer_dropout' in kwargs else True

 

         for size in enable_sizes or []:

             self.layers[size] = (

-                HypernetworkModule(size, None, self.layer_structure, self.activation_func, self.weight_init, self.add_layer_norm, self.use_dropout),

-                HypernetworkModule(size, None, self.layer_structure, self.activation_func, self.weight_init, self.add_layer_norm, self.use_dropout),

+                HypernetworkModule(size, None, self.layer_structure, self.activation_func, self.weight_init,

+                                   self.add_layer_norm, self.use_dropout, self.activate_output, last_layer_dropout=self.last_layer_dropout),

+                HypernetworkModule(size, None, self.layer_structure, self.activation_func, self.weight_init,

+                                   self.add_layer_norm, self.use_dropout, self.activate_output, last_layer_dropout=self.last_layer_dropout),

             )

 

     def weights(self):

@@ -171,7 +176,9 @@ class Hypernetwork:
         state_dict['use_dropout'] = self.use_dropout

         state_dict['sd_checkpoint'] = self.sd_checkpoint

         state_dict['sd_checkpoint_name'] = self.sd_checkpoint_name

-

+        state_dict['activate_output'] = self.activate_output

+        state_dict['last_layer_dropout'] = self.last_layer_dropout

+        

         torch.save(state_dict, filename)

 

     def load(self, filename):

@@ -191,12 +198,17 @@ class Hypernetwork:
         print(f"Layer norm is set to {self.add_layer_norm}")

         self.use_dropout = state_dict.get('use_dropout', False)

         print(f"Dropout usage is set to {self.use_dropout}" )

+        self.activate_output = state_dict.get('activate_output', True)

+        print(f"Activate last layer is set to {self.activate_output}")

+        self.last_layer_dropout = state_dict.get('last_layer_dropout', False)

 

         for size, sd in state_dict.items():

             if type(size) == int:

                 self.layers[size] = (

-                    HypernetworkModule(size, sd[0], self.layer_structure, self.activation_func, self.weight_init, self.add_layer_norm, self.use_dropout),

-                    HypernetworkModule(size, sd[1], self.layer_structure, self.activation_func, self.weight_init, self.add_layer_norm, self.use_dropout),

+                    HypernetworkModule(size, sd[0], self.layer_structure, self.activation_func, self.weight_init,

+                                       self.add_layer_norm, self.use_dropout, self.activate_output, last_layer_dropout=self.last_layer_dropout),

+                    HypernetworkModule(size, sd[1], self.layer_structure, self.activation_func, self.weight_init,

+                                       self.add_layer_norm, self.use_dropout, self.activate_output, last_layer_dropout=self.last_layer_dropout),

                 )

 

         self.name = state_dict.get('name', self.name)

diff --git a/modules/images.py b/modules/images.py
index a0728553..ae705cbd 100644
--- a/modules/images.py
+++ b/modules/images.py
@@ -510,8 +510,9 @@ def save_image(image, path, basename, seed=None, prompt=None, extension='png', i
 

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

         pnginfo_data = PngImagePlugin.PngInfo()

-        for k, v in params.pnginfo.items():

-            pnginfo_data.add_text(k, str(v))

+        if opts.enable_pnginfo:

+            for k, v in params.pnginfo.items():

+                pnginfo_data.add_text(k, str(v))

 

         image.save(fullfn, quality=opts.jpeg_quality, pnginfo=pnginfo_data)

 

diff --git a/modules/img2img.py b/modules/img2img.py
index 35c5df9b..be9f3653 100644
--- a/modules/img2img.py
+++ b/modules/img2img.py
@@ -81,7 +81,8 @@ def img2img(mode: int, prompt: str, negative_prompt: str, prompt_style: str, pro
         mask = None

 

     # Use the EXIF orientation of photos taken by smartphones.

-    image = ImageOps.exif_transpose(image) 

+    if image is not None:

+        image = ImageOps.exif_transpose(image) 

 

     assert 0. <= denoising_strength <= 1., 'can only work with strength in [0.0, 1.0]'

 

@@ -137,6 +138,8 @@ def img2img(mode: int, prompt: str, negative_prompt: str, prompt_style: str, pro
         if processed is None:

             processed = process_images(p)

 

+    p.close()

+

     shared.total_tqdm.clear()

 

     generation_info_js = processed.js()

diff --git a/modules/interrogate.py b/modules/interrogate.py
index 65b05d34..9769aa34 100644
--- a/modules/interrogate.py
+++ b/modules/interrogate.py
@@ -56,9 +56,9 @@ class InterrogateModels:
         import clip

 

         if self.running_on_cpu:

-            model, preprocess = clip.load(clip_model_name, device="cpu")

+            model, preprocess = clip.load(clip_model_name, device="cpu", download_root=shared.cmd_opts.clip_models_path)

         else:

-            model, preprocess = clip.load(clip_model_name)

+            model, preprocess = clip.load(clip_model_name, download_root=shared.cmd_opts.clip_models_path)

 

         model.eval()

         model = model.to(devices.device_interrogate)

diff --git a/modules/masking.py b/modules/masking.py
index fd8d9241..a5c4d2da 100644
--- a/modules/masking.py
+++ b/modules/masking.py
@@ -49,7 +49,7 @@ def expand_crop_region(crop_region, processing_width, processing_height, image_w
     ratio_processing = processing_width / processing_height

 

     if ratio_crop_region > ratio_processing:

-        desired_height = (x2 - x1) * ratio_processing

+        desired_height = (x2 - x1) / ratio_processing

         desired_height_diff = int(desired_height - (y2-y1))

         y1 -= desired_height_diff//2

         y2 += desired_height_diff - desired_height_diff//2

diff --git a/modules/modelloader.py b/modules/modelloader.py
index b0f2f33d..e4a6f8ac 100644
--- a/modules/modelloader.py
+++ b/modules/modelloader.py
@@ -85,6 +85,9 @@ def cleanup_models():
     src_path = os.path.join(root_path, "ESRGAN")
     dest_path = os.path.join(models_path, "ESRGAN")
     move_files(src_path, dest_path)
+    src_path = os.path.join(models_path, "BSRGAN")
+    dest_path = os.path.join(models_path, "ESRGAN")
+    move_files(src_path, dest_path, ".pth")
     src_path = os.path.join(root_path, "gfpgan")
     dest_path = os.path.join(models_path, "GFPGAN")
     move_files(src_path, dest_path)
diff --git a/modules/processing.py b/modules/processing.py
index 57d3a523..03c9143d 100644
--- a/modules/processing.py
+++ b/modules/processing.py
@@ -134,11 +134,7 @@ class StableDiffusionProcessing():
             # Dummy zero conditioning if we're not using inpainting model.

             # Still takes up a bit of memory, but no encoder call.

             # Pretty sure we can just make this a 1x1 image since its not going to be used besides its batch size.

-            return torch.zeros(

-                x.shape[0], 5, 1, 1, 

-                dtype=x.dtype, 

-                device=x.device

-            )

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

 

         height = height or self.height

         width = width or self.width

@@ -156,11 +152,7 @@ class StableDiffusionProcessing():
     def img2img_image_conditioning(self, source_image, latent_image, image_mask = None):

         if self.sampler.conditioning_key not in {'hybrid', 'concat'}:

             # Dummy zero conditioning if we're not using inpainting model.

-            return torch.zeros(

-                latent_image.shape[0], 5, 1, 1,

-                dtype=latent_image.dtype,

-                device=latent_image.device

-            )

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

 

         # Handle the different mask inputs

         if image_mask is not None:

@@ -174,11 +166,11 @@ class StableDiffusionProcessing():
                 # Inpainting model uses a discretized mask as input, so we round to either 1.0 or 0.0

                 conditioning_mask = torch.round(conditioning_mask)

         else:

-            conditioning_mask = torch.ones(1, 1, *source_image.shape[-2:])

+            conditioning_mask = source_image.new_ones(1, 1, *source_image.shape[-2:])

 

         # Create another latent image, this time with a masked version of the original input.

         # Smoothly interpolate between the masked and unmasked latent conditioning image using a parameter.

-        conditioning_mask = conditioning_mask.to(source_image.device)

+        conditioning_mask = conditioning_mask.to(source_image.device).to(source_image.dtype)

         conditioning_image = torch.lerp(

             source_image,

             source_image * (1.0 - conditioning_mask),

@@ -199,9 +191,13 @@ class StableDiffusionProcessing():
     def init(self, all_prompts, all_seeds, all_subseeds):

         pass

 

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

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

         raise NotImplementedError()

 

+    def close(self):

+        self.sd_model = None

+        self.sampler = None

+

 

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

@@ -422,13 +418,13 @@ def process_images(p: StableDiffusionProcessing) -> Processed:
 

     try:

         for k, v in p.override_settings.items():

-            opts.data[k] = v  # we don't call onchange for simplicity which makes changing model, hypernet impossible

+            setattr(opts, k, v) # we don't call onchange for simplicity which makes changing model, hypernet impossible

 

         res = process_images_inner(p)

 

     finally:

         for k, v in stored_opts.items():

-            opts.data[k] = v

+            setattr(opts, k, v)

 

     return res

 

@@ -505,6 +501,9 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             if len(prompts) == 0:

                 break

 

+            if p.scripts is not None:

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

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

@@ -517,7 +516,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
                 shared.state.job = f"Batch {n+1} out of {p.n_iter}"

 

             with devices.autocast():

-                samples_ddim = p.sample(conditioning=c, unconditional_conditioning=uc, seeds=seeds, subseeds=subseeds, subseed_strength=p.subseed_strength)

+                samples_ddim = p.sample(conditioning=c, unconditional_conditioning=uc, seeds=seeds, subseeds=subseeds, subseed_strength=p.subseed_strength, prompts=prompts)

 

             samples_ddim = samples_ddim.to(devices.dtype_vae)

             x_samples_ddim = decode_first_stage(p.sd_model, samples_ddim)

@@ -597,9 +596,6 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
     if p.scripts is not None:

         p.scripts.postprocess(p, res)

 

-    p.sd_model = None

-    p.sampler = None

-

     return res

 

 

@@ -648,7 +644,7 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
             self.truncate_x = int(self.firstphase_width - firstphase_width_truncated) // opt_f

             self.truncate_y = int(self.firstphase_height - firstphase_height_truncated) // opt_f

 

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

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

 

         if not self.enable_hr:

@@ -661,9 +657,28 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
 

         samples = samples[:, :, self.truncate_y//2:samples.shape[2]-self.truncate_y//2, self.truncate_x//2:samples.shape[3]-self.truncate_x//2]

 

+        """saves image before applying hires fix, if enabled in options; takes as an arguyment either an image or batch with latent space images"""

+        def save_intermediate(image, index):

+            if not opts.save or self.do_not_save_samples or not opts.save_images_before_highres_fix:

+                return

+

+            if not isinstance(image, Image.Image):

+                image = sd_samplers.sample_to_image(image, index)

+

+            images.save_image(image, self.outpath_samples, "", seeds[index], prompts[index], opts.samples_format, suffix="-before-highres-fix")

+

         if opts.use_scale_latent_for_hires_fix:

+            for i in range(samples.shape[0]):

+                save_intermediate(samples, i)

+

             samples = torch.nn.functional.interpolate(samples, size=(self.height // opt_f, self.width // opt_f), mode="bilinear")

 

+            # Avoid making the inpainting conditioning unless necessary as 

+            # this does need some extra compute to decode / encode the image again.

+            if getattr(self, "inpainting_mask_weight", shared.opts.inpainting_mask_weight) < 1.0:

+                image_conditioning = self.img2img_image_conditioning(decode_first_stage(self.sd_model, samples), samples)

+            else: