Upload 10 files

default_pipeline 2.py

@@ -0,0 +1,420 @@
+import modules.core as core
+import os
+import gc
+import torch
+import numpy as np
+import modules.path
+import modules.virtual_memory as virtual_memory
+import comfy.model_management
+
+from comfy.model_base import BaseModel, SDXL, SDXLRefiner
+from modules.settings import default_settings
+from modules.patch import set_comfy_adm_encoding, set_fooocus_adm_encoding, cfg_patched, patched_model_function
+from modules.expansion import FooocusExpansion
+
+
+xl_base: core.StableDiffusionModel = None
+xl_base_hash = ''
+
+xl_refiner: core.StableDiffusionModel = None
+xl_refiner_hash = ''
+
+xl_base_patched: core.StableDiffusionModel = None
+xl_base_patched_hash = ''
+
+clip_vision: core.StableDiffusionModel = None
+clip_vision_hash = ''
+
+controlnet_canny: core.StableDiffusionModel = None
+controlnet_canny_hash = ''
+
+controlnet_depth: core.StableDiffusionModel = None
+controlnet_depth_hash = ''
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def refresh_base_model(name):
+    global xl_base, xl_base_hash, xl_base_patched, xl_base_patched_hash
+
+    filename = os.path.abspath(os.path.realpath(os.path.join(modules.path.modelfile_path, name)))
+    model_hash = filename
+
+    if xl_base_hash == model_hash:
+        return
+
+    if xl_base is not None:
+        xl_base = None
+
+    if xl_base_patched is not None:
+        xl_base_patched = None
+
+    xl_base = core.load_model(filename)
+    if not isinstance(xl_base.unet.model, BaseModel):
+        print(f'Model not supported: {name}, using default base model instead.')
+        xl_base = None
+        xl_base_hash = ''
+        refresh_base_model(modules.path.default_base_model_name)
+        xl_base_hash = model_hash
+        xl_base_patched = xl_base
+        xl_base_patched_hash = ''
+        return
+
+    if not isinstance(xl_base.unet.model, SDXL):
+        print('WARNING: loading non-SDXL base model.')
+
+    xl_base_hash = model_hash
+    xl_base_patched = xl_base
+    xl_base_patched_hash = ''
+    print(f'Base model loaded: {model_hash}')
+    return
+
+
+def is_base_sdxl():
+    assert xl_base is not None
+    return isinstance(xl_base.unet.model, SDXL)
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def refresh_refiner_model(name):
+    global xl_refiner, xl_refiner_hash
+
+    filename = os.path.abspath(os.path.realpath(os.path.join(modules.path.modelfile_path, name)))
+    model_hash = filename
+
+    if xl_refiner_hash == model_hash:
+        return
+
+    if name == 'None':
+        xl_refiner = None
+        xl_refiner_hash = ''
+        print(f'Refiner unloaded.')
+        return
+
+    if xl_refiner is not None:
+        xl_refiner = None
+
+    xl_refiner = core.load_model(filename)
+    if not isinstance(xl_refiner.unet.model, SDXLRefiner):
+        print('Model not supported. Fooocus only support SDXL refiner as the refiner.')
+        xl_refiner = None
+        xl_refiner_hash = ''
+        print(f'Refiner unloaded.')
+        return
+
+    xl_refiner_hash = model_hash
+    print(f'Refiner model loaded: {model_hash}')
+
+    xl_refiner.vae = None
+    return
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def patch_base(loras, freeu, b1, b2, s1, s2):
+    global xl_base, xl_base_patched, xl_base_patched_hash
+    if xl_base_patched_hash == str(loras + [freeu, b1, b2, s1, s2]):
+        return
+
+    model = xl_base
+    for name, weight in loras:
+        if name == 'None':
+            continue
+
+        if os.path.exists(name):
+            filename = name
+        else:
+            filename = os.path.join(modules.path.lorafile_path, name)
+
+        assert os.path.exists(filename), 'Lora file not found!'
+
+        model = core.load_sd_lora(model, filename, strength_model=weight, strength_clip=weight)
+    if freeu:
+        xl_base_patched = core.freeu(model, b1, b2, s1, s2)
+    else:
+        xl_base_patched = model
+    xl_base_patched_hash = str(loras + [freeu, b1, b2, s1, s2])
+    print(f'LoRAs loaded: {loras}')
+    if freeu:
+        print(f'FreeU applied: {[b1, b2, s1, s2]}')
+
+    return
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def refresh_clip_vision():
+    global clip_vision, clip_vision_hash
+    if clip_vision_hash == str(clip_vision):
+        return
+
+    model_name = modules.path.default_clip_vision_name
+    filename = os.path.join(modules.path.clip_vision_path, model_name)
+    clip_vision = core.load_clip_vision(filename)
+
+    clip_vision_hash = model_name
+    print(f'CLIP Vision model loaded: {clip_vision_hash}')
+
+    return
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def refresh_controlnet_canny(name=None):
+    global controlnet_canny, controlnet_canny_hash
+    if controlnet_canny_hash == str(controlnet_canny):
+        return
+
+    model_name = modules.path.default_controlnet_canny_name if name == None else name
+    filename = os.path.join(modules.path.controlnet_path, model_name)
+    controlnet_canny = core.load_controlnet(filename)
+
+    controlnet_canny_hash = model_name
+    print(f'ControlNet model loaded: {controlnet_canny_hash}')
+
+    return
+
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def refresh_controlnet_depth(name=None):
+    global controlnet_depth, controlnet_depth_hash
+    if controlnet_depth_hash == str(controlnet_depth):
+        return
+
+    model_name = modules.path.default_controlnet_depth_name if name == None else name
+    filename = os.path.join(modules.path.controlnet_path, model_name)
+    controlnet_depth = core.load_controlnet(filename)
+
+    controlnet_depth_hash = model_name
+    print(f'ControlNet model loaded: {controlnet_depth_hash}')
+
+    return
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def set_clip_skips(base_clip_skip, refiner_clip_skip):
+    xl_base_patched.clip.clip_layer(base_clip_skip)
+    if xl_refiner is not None:
+        xl_refiner.clip.clip_layer(refiner_clip_skip)
+    return
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def apply_prompt_strength(base_cond, refiner_cond, prompt_strength=1.0):
+    if prompt_strength >= 0 and prompt_strength < 1.0:
+        base_cond = core.set_conditioning_strength(base_cond, prompt_strength)
+
+    if xl_refiner is not None:
+        if prompt_strength >= 0 and prompt_strength < 1.0:
+            refiner_cond = core.set_conditioning_strength(refiner_cond, prompt_strength)
+    else:
+        refiner_cond = None
+    return base_cond, refiner_cond
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def apply_revision(base_cond, revision=False, revision_strengths=[], clip_vision_outputs=[]):
+    if revision:
+        set_comfy_adm_encoding()
+        for i in range(len(clip_vision_outputs)):
+            if revision_strengths[i % 4] != 0:
+                base_cond = core.apply_adm(base_cond, clip_vision_outputs[i % 4], revision_strengths[i % 4], 0)
+    else:
+        set_fooocus_adm_encoding()
+    return base_cond
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def clip_encode_single(clip, text, verbose=False):
+    cached = clip.fcs_cond_cache.get(text, None)
+    if cached is not None:
+        if verbose:
+            print(f'[CLIP Cached] {text}')
+        return cached
+    tokens = clip.tokenize(text)
+    result = clip.encode_from_tokens(tokens, return_pooled=True)
+    clip.fcs_cond_cache[text] = result
+    if verbose:
+        print(f'[CLIP Encoded] {text}')
+    return result
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def clip_encode(sd, texts, pool_top_k=1):
+    if sd is None:
+        return None
+    if sd.clip is None:
+        return None
+    if not isinstance(texts, list):
+        return None
+    if len(texts) == 0:
+        return None
+
+    clip = sd.clip
+    cond_list = []
+    pooled_acc = 0
+
+    for i, text in enumerate(texts):
+        cond, pooled = clip_encode_single(clip, text)
+        cond_list.append(cond)
+        if i < pool_top_k:
+            pooled_acc += pooled
+
+    return [[torch.cat(cond_list, dim=1), {"pooled_output": pooled_acc}]]
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def clear_sd_cond_cache(sd):
+    if sd is None:
+        return None
+    if sd.clip is None:
+        return None
+    sd.clip.fcs_cond_cache = {}
+    return
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def clear_all_caches():
+    clear_sd_cond_cache(xl_base_patched)
+    clear_sd_cond_cache(xl_refiner)
+    gc.collect()
+    comfy.model_management.soft_empty_cache()
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def refresh_everything(refiner_model_name, base_model_name, loras, freeu, b1, b2, s1, s2):
+    refresh_refiner_model(refiner_model_name)
+    if xl_refiner is not None:
+        virtual_memory.try_move_to_virtual_memory(xl_refiner.unet.model)
+        virtual_memory.try_move_to_virtual_memory(xl_refiner.clip.cond_stage_model)
+
+    refresh_base_model(base_model_name)
+    virtual_memory.load_from_virtual_memory(xl_base.unet.model)
+
+    patch_base(loras, freeu, b1, b2, s1, s2)
+    clear_all_caches()
+    return
+
+
+refresh_everything(
+    refiner_model_name=default_settings['refiner_model'],
+    base_model_name=default_settings['base_model'],
+    loras=[(default_settings['lora_1_model'], default_settings['lora_1_weight']),
+        (default_settings['lora_2_model'], default_settings['lora_2_weight']),
+        (default_settings['lora_3_model'], default_settings['lora_3_weight']),
+        (default_settings['lora_4_model'], default_settings['lora_4_weight']),
+        (default_settings['lora_5_model'], default_settings['lora_5_weight'])],
+    freeu=default_settings['freeu'],
+    b1=default_settings['freeu_b1'],
+    b2=default_settings['freeu_b2'],
+    s1=default_settings['freeu_s1'],
+    s2=default_settings['freeu_s2']
+)
+
+expansion = FooocusExpansion()
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def patch_all_models():
+    assert xl_base is not None
+    assert xl_base_patched is not None
+
+    xl_base.unet.model_options['sampler_cfg_function'] = cfg_patched
+    xl_base.unet.model_options['model_function_wrapper'] = patched_model_function
+
+    xl_base_patched.unet.model_options['sampler_cfg_function'] = cfg_patched
+    xl_base_patched.unet.model_options['model_function_wrapper'] = patched_model_function
+
+    if xl_refiner is not None:
+        xl_refiner.unet.model_options['sampler_cfg_function'] = cfg_patched
+        xl_refiner.unet.model_options['model_function_wrapper'] = patched_model_function
+
+    return
+
+
+@torch.no_grad()
+@torch.inference_mode()
+def process_diffusion(positive_cond, negative_cond, steps, switch, width, height, image_seed, sampler_name, scheduler, cfg, img2img, input_image, start_step,
+        control_lora_canny, canny_edge_low, canny_edge_high, canny_start, canny_stop, canny_strength,
+        control_lora_depth, depth_start, depth_stop, depth_strength, callback, latent=None, denoise=1.0, tiled=False):
+
+    patch_all_models()
+
+    if xl_refiner is not None:
+        virtual_memory.try_move_to_virtual_memory(xl_refiner.unet.model)
+    virtual_memory.load_from_virtual_memory(xl_base.unet.model)
+
+    if img2img and input_image != None:
+        initial_latent = core.encode_vae(vae=xl_base_patched.vae, pixels=input_image)
+        force_full_denoise = False
+    elif latent is None:
+        initial_latent = core.generate_empty_latent(width=width, height=height, batch_size=1)
+        force_full_denoise = True
+    else:
+        initial_latent = latent
+        force_full_denoise = False
+
+    positive_conditions = positive_cond[0]
+    negative_conditions = negative_cond[0]
+
+    if control_lora_canny and input_image != None:
+        edges_image = core.detect_edge(input_image, canny_edge_low, canny_edge_high)
+        positive_conditions, negative_conditions = core.apply_controlnet(positive_conditions, negative_conditions,
+            controlnet_canny, edges_image, canny_strength, canny_start, canny_stop)
+
+    if control_lora_depth and input_image != None:
+        positive_conditions, negative_conditions = core.apply_controlnet(positive_conditions, negative_conditions,
+            controlnet_depth, input_image, depth_strength, depth_start, depth_stop)
+
+    if xl_refiner is not None and is_base_sdxl():
+        positive_conditions_refiner = positive_cond[1]
+        negative_conditions_refiner = negative_cond[1]
+
+        sampled_latent = core.ksampler_with_refiner(
+            model=xl_base_patched.unet,
+            positive=positive_conditions,
+            negative=negative_conditions,
+            refiner=xl_refiner.unet,
+            refiner_positive=positive_conditions_refiner,
+            refiner_negative=negative_conditions_refiner,
+            refiner_switch_step=switch,
+            latent=initial_latent,
+            steps=steps, start_step=start_step, last_step=steps,
+            disable_noise=False, force_full_denoise=force_full_denoise, denoise=denoise,
+            seed=image_seed,
+            sampler_name=sampler_name,
+            scheduler=scheduler,
+            cfg=cfg,
+            callback_function=callback
+        )
+    else:
+        sampled_latent = core.ksampler(
+            model=xl_base_patched.unet,
+            positive=positive_conditions,
+            negative=negative_conditions,
+            latent=initial_latent,
+            steps=steps, start_step=start_step, last_step=steps,
+            disable_noise=False, force_full_denoise=force_full_denoise, denoise=denoise,
+            seed=image_seed,
+            sampler_name=sampler_name,
+            scheduler=scheduler,
+            cfg=cfg,
+            callback_function=callback
+        )
+
+    decoded_latent = core.decode_vae(vae=xl_base_patched.vae, latent_image=sampled_latent, tiled=tiled)
+    images = core.pytorch_to_numpy(decoded_latent)
+
+    return images

external_hypernetwork.py

@@ -0,0 +1,121 @@
+# https://github.com/comfyanonymous/ComfyUI/blob/master/nodes.py 
+
+import ldm_patched.modules.utils
+import ldm_patched.utils.path_utils
+import torch
+
+def load_hypernetwork_patch(path, strength):
+    sd = ldm_patched.modules.utils.load_torch_file(path, safe_load=True)
+    activation_func = sd.get('activation_func', 'linear')
+    is_layer_norm = sd.get('is_layer_norm', False)
+    use_dropout = sd.get('use_dropout', False)
+    activate_output = sd.get('activate_output', False)
+    last_layer_dropout = sd.get('last_layer_dropout', False)
+
+    valid_activation = {
+        "linear": torch.nn.Identity,
+        "relu": torch.nn.ReLU,
+        "leakyrelu": torch.nn.LeakyReLU,
+        "elu": torch.nn.ELU,
+        "swish": torch.nn.Hardswish,
+        "tanh": torch.nn.Tanh,
+        "sigmoid": torch.nn.Sigmoid,
+        "softsign": torch.nn.Softsign,
+        "mish": torch.nn.Mish,
+    }
+
+    if activation_func not in valid_activation:
+        print("Unsupported Hypernetwork format, if you report it I might implement it.", path, " ", activation_func, is_layer_norm, use_dropout, activate_output, last_layer_dropout)
+        return None
+
+    out = {}
+
+    for d in sd:
+        try:
+            dim = int(d)
+        except:
+            continue
+
+        output = []
+        for index in [0, 1]:
+            attn_weights = sd[dim][index]
+            keys = attn_weights.keys()
+
+            linears = filter(lambda a: a.endswith(".weight"), keys)
+            linears = list(map(lambda a: a[:-len(".weight")], linears))
+            layers = []
+
+            i = 0
+            while i < len(linears):
+                lin_name = linears[i]
+                last_layer = (i == (len(linears) - 1))
+                penultimate_layer = (i == (len(linears) - 2))
+
+                lin_weight = attn_weights['{}.weight'.format(lin_name)]
+                lin_bias = attn_weights['{}.bias'.format(lin_name)]
+                layer = torch.nn.Linear(lin_weight.shape[1], lin_weight.shape[0])
+                layer.load_state_dict({"weight": lin_weight, "bias": lin_bias})
+                layers.append(layer)
+                if activation_func != "linear":
+                    if (not last_layer) or (activate_output):
+                        layers.append(valid_activation[activation_func]())
+                if is_layer_norm:
+                    i += 1
+                    ln_name = linears[i]
+                    ln_weight = attn_weights['{}.weight'.format(ln_name)]
+                    ln_bias = attn_weights['{}.bias'.format(ln_name)]
+                    ln = torch.nn.LayerNorm(ln_weight.shape[0])
+                    ln.load_state_dict({"weight": ln_weight, "bias": ln_bias})
+                    layers.append(ln)
+                if use_dropout:
+                    if (not last_layer) and (not penultimate_layer or last_layer_dropout):
+                        layers.append(torch.nn.Dropout(p=0.3))
+                i += 1
+
+            output.append(torch.nn.Sequential(*layers))
+        out[dim] = torch.nn.ModuleList(output)
+
+    class hypernetwork_patch:
+        def __init__(self, hypernet, strength):
+            self.hypernet = hypernet
+            self.strength = strength
+        def __call__(self, q, k, v, extra_options):
+            dim = k.shape[-1]
+            if dim in self.hypernet:
+                hn = self.hypernet[dim]
+                k = k + hn[0](k) * self.strength
+                v = v + hn[1](v) * self.strength
+
+            return q, k, v
+
+        def to(self, device):
+            for d in self.hypernet.keys():
+                self.hypernet[d] = self.hypernet[d].to(device)
+            return self
+
+    return hypernetwork_patch(out, strength)
+
+class HypernetworkLoader:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model": ("MODEL",),
+                              "hypernetwork_name": (ldm_patched.utils.path_utils.get_filename_list("hypernetworks"), ),
+                              "strength": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "load_hypernetwork"
+
+    CATEGORY = "loaders"
+
+    def load_hypernetwork(self, model, hypernetwork_name, strength):
+        hypernetwork_path = ldm_patched.utils.path_utils.get_full_path("hypernetworks", hypernetwork_name)
+        model_hypernetwork = model.clone()
+        patch = load_hypernetwork_patch(hypernetwork_path, strength)
+        if patch is not None:
+            model_hypernetwork.set_model_attn1_patch(patch)
+            model_hypernetwork.set_model_attn2_patch(patch)
+        return (model_hypernetwork,)
+
+NODE_CLASS_MAPPINGS = {
+    "HypernetworkLoader": HypernetworkLoader
+}

external_mask.py

@@ -0,0 +1,365 @@
+# https://github.com/comfyanonymous/ComfyUI/blob/master/nodes.py 
+
+import numpy as np
+import scipy.ndimage
+import torch
+import ldm_patched.modules.utils
+
+from ldm_patched.contrib.external import MAX_RESOLUTION
+
+def composite(destination, source, x, y, mask = None, multiplier = 8, resize_source = False):
+    source = source.to(destination.device)
+    if resize_source:
+        source = torch.nn.functional.interpolate(source, size=(destination.shape[2], destination.shape[3]), mode="bilinear")
+
+    source = ldm_patched.modules.utils.repeat_to_batch_size(source, destination.shape[0])
+
+    x = max(-source.shape[3] * multiplier, min(x, destination.shape[3] * multiplier))
+    y = max(-source.shape[2] * multiplier, min(y, destination.shape[2] * multiplier))
+
+    left, top = (x // multiplier, y // multiplier)
+    right, bottom = (left + source.shape[3], top + source.shape[2],)
+
+    if mask is None:
+        mask = torch.ones_like(source)
+    else:
+        mask = mask.to(destination.device, copy=True)
+        mask = torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(source.shape[2], source.shape[3]), mode="bilinear")
+        mask = ldm_patched.modules.utils.repeat_to_batch_size(mask, source.shape[0])
+
+    # calculate the bounds of the source that will be overlapping the destination
+    # this prevents the source trying to overwrite latent pixels that are out of bounds
+    # of the destination
+    visible_width, visible_height = (destination.shape[3] - left + min(0, x), destination.shape[2] - top + min(0, y),)
+
+    mask = mask[:, :, :visible_height, :visible_width]
+    inverse_mask = torch.ones_like(mask) - mask
+
+    source_portion = mask * source[:, :, :visible_height, :visible_width]
+    destination_portion = inverse_mask  * destination[:, :, top:bottom, left:right]
+
+    destination[:, :, top:bottom, left:right] = source_portion + destination_portion
+    return destination
+
+class LatentCompositeMasked:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "destination": ("LATENT",),
+                "source": ("LATENT",),
+                "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+                "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+                "resize_source": ("BOOLEAN", {"default": False}),
+            },
+            "optional": {
+                "mask": ("MASK",),
+            }
+        }
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "composite"
+
+    CATEGORY = "latent"
+
+    def composite(self, destination, source, x, y, resize_source, mask = None):
+        output = destination.copy()
+        destination = destination["samples"].clone()
+        source = source["samples"]
+        output["samples"] = composite(destination, source, x, y, mask, 8, resize_source)
+        return (output,)
+
+class ImageCompositeMasked:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "destination": ("IMAGE",),
+                "source": ("IMAGE",),
+                "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "resize_source": ("BOOLEAN", {"default": False}),
+            },
+            "optional": {
+                "mask": ("MASK",),
+            }
+        }
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "composite"
+
+    CATEGORY = "image"
+
+    def composite(self, destination, source, x, y, resize_source, mask = None):
+        destination = destination.clone().movedim(-1, 1)
+        output = composite(destination, source.movedim(-1, 1), x, y, mask, 1, resize_source).movedim(1, -1)
+        return (output,)
+
+class MaskToImage:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "mask": ("MASK",),
+                }
+        }
+
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "mask_to_image"
+
+    def mask_to_image(self, mask):
+        result = mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])).movedim(1, -1).expand(-1, -1, -1, 3)
+        return (result,)
+
+class ImageToMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "image": ("IMAGE",),
+                    "channel": (["red", "green", "blue", "alpha"],),
+                }
+        }
+
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "image_to_mask"
+
+    def image_to_mask(self, image, channel):
+        channels = ["red", "green", "blue", "alpha"]
+        mask = image[:, :, :, channels.index(channel)]
+        return (mask,)
+
+class ImageColorToMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "image": ("IMAGE",),
+                    "color": ("INT", {"default": 0, "min": 0, "max": 0xFFFFFF, "step": 1, "display": "color"}),
+                }
+        }
+
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "image_to_mask"
+
+    def image_to_mask(self, image, color):
+        temp = (torch.clamp(image, 0, 1.0) * 255.0).round().to(torch.int)
+        temp = torch.bitwise_left_shift(temp[:,:,:,0], 16) + torch.bitwise_left_shift(temp[:,:,:,1], 8) + temp[:,:,:,2]
+        mask = torch.where(temp == color, 255, 0).float()
+        return (mask,)
+
+class SolidMask:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "value": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "width": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),
+                "height": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),
+            }
+        }
+
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("MASK",)
+
+    FUNCTION = "solid"
+
+    def solid(self, value, width, height):
+        out = torch.full((1, height, width), value, dtype=torch.float32, device="cpu")
+        return (out,)
+
+class InvertMask:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "mask": ("MASK",),
+            }
+        }
+
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("MASK",)
+
+    FUNCTION = "invert"
+
+    def invert(self, mask):
+        out = 1.0 - mask
+        return (out,)
+
+class CropMask:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "width": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),
+                "height": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),
+            }
+        }
+
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("MASK",)
+
+    FUNCTION = "crop"
+
+    def crop(self, mask, x, y, width, height):
+        mask = mask.reshape((-1, mask.shape[-2], mask.shape[-1]))
+        out = mask[:, y:y + height, x:x + width]
+        return (out,)
+
+class MaskComposite:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "destination": ("MASK",),
+                "source": ("MASK",),
+                "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "operation": (["multiply", "add", "subtract", "and", "or", "xor"],),
+            }
+        }
+
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("MASK",)
+
+    FUNCTION = "combine"
+
+    def combine(self, destination, source, x, y, operation):
+        output = destination.reshape((-1, destination.shape[-2], destination.shape[-1])).clone()
+        source = source.reshape((-1, source.shape[-2], source.shape[-1]))
+
+        left, top = (x, y,)
+        right, bottom = (min(left + source.shape[-1], destination.shape[-1]), min(top + source.shape[-2], destination.shape[-2]))
+        visible_width, visible_height = (right - left, bottom - top,)
+
+        source_portion = source[:, :visible_height, :visible_width]
+        destination_portion = destination[:, top:bottom, left:right]
+
+        if operation == "multiply":
+            output[:, top:bottom, left:right] = destination_portion * source_portion
+        elif operation == "add":
+            output[:, top:bottom, left:right] = destination_portion + source_portion
+        elif operation == "subtract":
+            output[:, top:bottom, left:right] = destination_portion - source_portion
+        elif operation == "and":
+            output[:, top:bottom, left:right] = torch.bitwise_and(destination_portion.round().bool(), source_portion.round().bool()).float()
+        elif operation == "or":
+            output[:, top:bottom, left:right] = torch.bitwise_or(destination_portion.round().bool(), source_portion.round().bool()).float()
+        elif operation == "xor":
+            output[:, top:bottom, left:right] = torch.bitwise_xor(destination_portion.round().bool(), source_portion.round().bool()).float()
+
+        output = torch.clamp(output, 0.0, 1.0)
+
+        return (output,)
+
+class FeatherMask:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "left": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "top": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "right": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "bottom": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+            }
+        }
+
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("MASK",)
+
+    FUNCTION = "feather"
+
+    def feather(self, mask, left, top, right, bottom):
+        output = mask.reshape((-1, mask.shape[-2], mask.shape[-1])).clone()
+
+        left = min(left, output.shape[-1])
+        right = min(right, output.shape[-1])
+        top = min(top, output.shape[-2])
+        bottom = min(bottom, output.shape[-2])
+
+        for x in range(left):
+            feather_rate = (x + 1.0) / left
+            output[:, :, x] *= feather_rate
+
+        for x in range(right):
+            feather_rate = (x + 1) / right
+            output[:, :, -x] *= feather_rate
+
+        for y in range(top):
+            feather_rate = (y + 1) / top
+            output[:, y, :] *= feather_rate
+
+        for y in range(bottom):
+            feather_rate = (y + 1) / bottom
+            output[:, -y, :] *= feather_rate
+
+        return (output,)
+    
+class GrowMask:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "expand": ("INT", {"default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1}),
+                "tapered_corners": ("BOOLEAN", {"default": True}),
+            },
+        }
+    
+    CATEGORY = "mask"
+
+    RETURN_TYPES = ("MASK",)
+
+    FUNCTION = "expand_mask"
+
+    def expand_mask(self, mask, expand, tapered_corners):
+        c = 0 if tapered_corners else 1
+        kernel = np.array([[c, 1, c],
+                           [1, 1, 1],
+                           [c, 1, c]])
+        mask = mask.reshape((-1, mask.shape[-2], mask.shape[-1]))
+        out = []
+        for m in mask:
+            output = m.numpy()
+            for _ in range(abs(expand)):
+                if expand < 0:
+                    output = scipy.ndimage.grey_erosion(output, footprint=kernel)
+                else:
+                    output = scipy.ndimage.grey_dilation(output, footprint=kernel)
+            output = torch.from_numpy(output)
+            out.append(output)
+        return (torch.stack(out, dim=0),)
+
+
+
+NODE_CLASS_MAPPINGS = {
+    "LatentCompositeMasked": LatentCompositeMasked,
+    "ImageCompositeMasked": ImageCompositeMasked,
+    "MaskToImage": MaskToImage,
+    "ImageToMask": ImageToMask,
+    "ImageColorToMask": ImageColorToMask,
+    "SolidMask": SolidMask,
+    "InvertMask": InvertMask,
+    "CropMask": CropMask,
+    "MaskComposite": MaskComposite,
+    "FeatherMask": FeatherMask,
+    "GrowMask": GrowMask,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ImageToMask": "Convert Image to Mask",
+    "MaskToImage": "Convert Mask to Image",
+}

external_post_processing.py

@@ -0,0 +1,278 @@
+# https://github.com/comfyanonymous/ComfyUI/blob/master/nodes.py 
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from PIL import Image
+import math
+
+import ldm_patched.modules.utils
+
+
+class Blend:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image1": ("IMAGE",),
+                "image2": ("IMAGE",),
+                "blend_factor": ("FLOAT", {
+                    "default": 0.5,
+                    "min": 0.0,
+                    "max": 1.0,
+                    "step": 0.01
+                }),
+                "blend_mode": (["normal", "multiply", "screen", "overlay", "soft_light", "difference"],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "blend_images"
+
+    CATEGORY = "image/postprocessing"
+
+    def blend_images(self, image1: torch.Tensor, image2: torch.Tensor, blend_factor: float, blend_mode: str):
+        image2 = image2.to(image1.device)
+        if image1.shape != image2.shape:
+            image2 = image2.permute(0, 3, 1, 2)
+            image2 = ldm_patched.modules.utils.common_upscale(image2, image1.shape[2], image1.shape[1], upscale_method='bicubic', crop='center')
+            image2 = image2.permute(0, 2, 3, 1)
+
+        blended_image = self.blend_mode(image1, image2, blend_mode)
+        blended_image = image1 * (1 - blend_factor) + blended_image * blend_factor
+        blended_image = torch.clamp(blended_image, 0, 1)
+        return (blended_image,)
+
+    def blend_mode(self, img1, img2, mode):
+        if mode == "normal":
+            return img2
+        elif mode == "multiply":
+            return img1 * img2
+        elif mode == "screen":
+            return 1 - (1 - img1) * (1 - img2)
+        elif mode == "overlay":
+            return torch.where(img1 <= 0.5, 2 * img1 * img2, 1 - 2 * (1 - img1) * (1 - img2))
+        elif mode == "soft_light":
+            return torch.where(img2 <= 0.5, img1 - (1 - 2 * img2) * img1 * (1 - img1), img1 + (2 * img2 - 1) * (self.g(img1) - img1))
+        elif mode == "difference":
+            return img1 - img2
+        else:
+            raise ValueError(f"Unsupported blend mode: {mode}")
+
+    def g(self, x):
+        return torch.where(x <= 0.25, ((16 * x - 12) * x + 4) * x, torch.sqrt(x))
+
+def gaussian_kernel(kernel_size: int, sigma: float, device=None):
+    x, y = torch.meshgrid(torch.linspace(-1, 1, kernel_size, device=device), torch.linspace(-1, 1, kernel_size, device=device), indexing="ij")
+    d = torch.sqrt(x * x + y * y)
+    g = torch.exp(-(d * d) / (2.0 * sigma * sigma))
+    return g / g.sum()
+
+class Blur:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "blur_radius": ("INT", {
+                    "default": 1,
+                    "min": 1,
+                    "max": 31,
+                    "step": 1
+                }),
+                "sigma": ("FLOAT", {
+                    "default": 1.0,
+                    "min": 0.1,
+                    "max": 10.0,
+                    "step": 0.1
+                }),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "blur"
+
+    CATEGORY = "image/postprocessing"
+
+    def blur(self, image: torch.Tensor, blur_radius: int, sigma: float):
+        if blur_radius == 0:
+            return (image,)
+
+        batch_size, height, width, channels = image.shape
+
+        kernel_size = blur_radius * 2 + 1
+        kernel = gaussian_kernel(kernel_size, sigma, device=image.device).repeat(channels, 1, 1).unsqueeze(1)
+
+        image = image.permute(0, 3, 1, 2) # Torch wants (B, C, H, W) we use (B, H, W, C)
+        padded_image = F.pad(image, (blur_radius,blur_radius,blur_radius,blur_radius), 'reflect')
+        blurred = F.conv2d(padded_image, kernel, padding=kernel_size // 2, groups=channels)[:,:,blur_radius:-blur_radius, blur_radius:-blur_radius]
+        blurred = blurred.permute(0, 2, 3, 1)
+
+        return (blurred,)
+
+class Quantize:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "colors": ("INT", {
+                    "default": 256,
+                    "min": 1,
+                    "max": 256,
+                    "step": 1
+                }),
+                "dither": (["none", "floyd-steinberg", "bayer-2", "bayer-4", "bayer-8", "bayer-16"],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "quantize"
+
+    CATEGORY = "image/postprocessing"
+
+    def bayer(im, pal_im, order):
+        def normalized_bayer_matrix(n):
+            if n == 0:
+                return np.zeros((1,1), "float32")
+            else:
+                q = 4 ** n
+                m = q * normalized_bayer_matrix(n - 1)
+                return np.bmat(((m-1.5, m+0.5), (m+1.5, m-0.5))) / q
+
+        num_colors = len(pal_im.getpalette()) // 3
+        spread = 2 * 256 / num_colors
+        bayer_n = int(math.log2(order))
+        bayer_matrix = torch.from_numpy(spread * normalized_bayer_matrix(bayer_n) + 0.5)
+
+        result = torch.from_numpy(np.array(im).astype(np.float32))
+        tw = math.ceil(result.shape[0] / bayer_matrix.shape[0])
+        th = math.ceil(result.shape[1] / bayer_matrix.shape[1])
+        tiled_matrix = bayer_matrix.tile(tw, th).unsqueeze(-1)
+        result.add_(tiled_matrix[:result.shape[0],:result.shape[1]]).clamp_(0, 255)
+        result = result.to(dtype=torch.uint8)
+
+        im = Image.fromarray(result.cpu().numpy())
+        im = im.quantize(palette=pal_im, dither=Image.Dither.NONE)
+        return im
+
+    def quantize(self, image: torch.Tensor, colors: int, dither: str):
+        batch_size, height, width, _ = image.shape
+        result = torch.zeros_like(image)
+
+        for b in range(batch_size):
+            im = Image.fromarray((image[b] * 255).to(torch.uint8).numpy(), mode='RGB')
+
+            pal_im = im.quantize(colors=colors) # Required as described in https://github.com/python-pillow/Pillow/issues/5836
+
+            if dither == "none":
+                quantized_image = im.quantize(palette=pal_im, dither=Image.Dither.NONE)
+            elif dither == "floyd-steinberg":
+                quantized_image = im.quantize(palette=pal_im, dither=Image.Dither.FLOYDSTEINBERG)
+            elif dither.startswith("bayer"):
+                order = int(dither.split('-')[-1])
+                quantized_image = Quantize.bayer(im, pal_im, order)
+
+            quantized_array = torch.tensor(np.array(quantized_image.convert("RGB"))).float() / 255
+            result[b] = quantized_array
+
+        return (result,)
+
+class Sharpen:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "sharpen_radius": ("INT", {
+                    "default": 1,
+                    "min": 1,
+                    "max": 31,
+                    "step": 1
+                }),
+                "sigma": ("FLOAT", {
+                    "default": 1.0,
+                    "min": 0.1,
+                    "max": 10.0,
+                    "step": 0.1
+                }),
+                "alpha": ("FLOAT", {
+                    "default": 1.0,
+                    "min": 0.0,
+                    "max": 5.0,
+                    "step": 0.1
+                }),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "sharpen"
+
+    CATEGORY = "image/postprocessing"
+
+    def sharpen(self, image: torch.Tensor, sharpen_radius: int, sigma:float, alpha: float):
+        if sharpen_radius == 0:
+            return (image,)
+
+        batch_size, height, width, channels = image.shape
+
+        kernel_size = sharpen_radius * 2 + 1
+        kernel = gaussian_kernel(kernel_size, sigma, device=image.device) * -(alpha*10)
+        center = kernel_size // 2
+        kernel[center, center] = kernel[center, center] - kernel.sum() + 1.0
+        kernel = kernel.repeat(channels, 1, 1).unsqueeze(1)
+
+        tensor_image = image.permute(0, 3, 1, 2) # Torch wants (B, C, H, W) we use (B, H, W, C)
+        tensor_image = F.pad(tensor_image, (sharpen_radius,sharpen_radius,sharpen_radius,sharpen_radius), 'reflect')
+        sharpened = F.conv2d(tensor_image, kernel, padding=center, groups=channels)[:,:,sharpen_radius:-sharpen_radius, sharpen_radius:-sharpen_radius]
+        sharpened = sharpened.permute(0, 2, 3, 1)
+
+        result = torch.clamp(sharpened, 0, 1)
+
+        return (result,)
+
+class ImageScaleToTotalPixels:
+    upscale_methods = ["nearest-exact", "bilinear", "area", "bicubic", "lanczos"]
+    crop_methods = ["disabled", "center"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "image": ("IMAGE",), "upscale_method": (s.upscale_methods,),
+                              "megapixels": ("FLOAT", {"default": 1.0, "min": 0.01, "max": 16.0, "step": 0.01}),
+                            }}
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "upscale"
+
+    CATEGORY = "image/upscaling"
+
+    def upscale(self, image, upscale_method, megapixels):
+        samples = image.movedim(-1,1)
+        total = int(megapixels * 1024 * 1024)
+
+        scale_by = math.sqrt(total / (samples.shape[3] * samples.shape[2]))
+        width = round(samples.shape[3] * scale_by)
+        height = round(samples.shape[2] * scale_by)
+
+        s = ldm_patched.modules.utils.common_upscale(samples, width, height, upscale_method, "disabled")
+        s = s.movedim(1,-1)
+        return (s,)
+
+NODE_CLASS_MAPPINGS = {
+    "ImageBlend": Blend,
+    "ImageBlur": Blur,
+    "ImageQuantize": Quantize,
+    "ImageSharpen": Sharpen,
+    "ImageScaleToTotalPixels": ImageScaleToTotalPixels,
+}

external_sdupscale.py

@@ -0,0 +1,49 @@
+# https://github.com/comfyanonymous/ComfyUI/blob/master/nodes.py 
+
+import torch
+import ldm_patched.contrib.external
+import ldm_patched.modules.utils
+
+class SD_4XUpscale_Conditioning:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "images": ("IMAGE",),
+                              "positive": ("CONDITIONING",),
+                              "negative": ("CONDITIONING",),
+                              "scale_ratio": ("FLOAT", {"default": 4.0, "min": 0.0, "max": 10.0, "step": 0.01}),
+                              "noise_augmentation": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001}),
+                             }}
+    RETURN_TYPES = ("CONDITIONING", "CONDITIONING", "LATENT")
+    RETURN_NAMES = ("positive", "negative", "latent")
+
+    FUNCTION = "encode"
+
+    CATEGORY = "conditioning/upscale_diffusion"
+
+    def encode(self, images, positive, negative, scale_ratio, noise_augmentation):
+        width = max(1, round(images.shape[-2] * scale_ratio))
+        height = max(1, round(images.shape[-3] * scale_ratio))
+
+        pixels = ldm_patched.modules.utils.common_upscale((images.movedim(-1,1) * 2.0) - 1.0, width // 4, height // 4, "bilinear", "center")
+
+        out_cp = []
+        out_cn = []
+
+        for t in positive:
+            n = [t[0], t[1].copy()]
+            n[1]['concat_image'] = pixels
+            n[1]['noise_augmentation'] = noise_augmentation
+            out_cp.append(n)
+
+        for t in negative:
+            n = [t[0], t[1].copy()]
+            n[1]['concat_image'] = pixels
+            n[1]['noise_augmentation'] = noise_augmentation
+            out_cn.append(n)
+
+        latent = torch.zeros([images.shape[0], 4, height // 4, width // 4])
+        return (out_cp, out_cn, {"samples":latent})
+
+NODE_CLASS_MAPPINGS = {
+    "SD_4XUpscale_Conditioning": SD_4XUpscale_Conditioning,
+}

external_upscale_model.py

@@ -0,0 +1,68 @@
+# https://github.com/comfyanonymous/ComfyUI/blob/master/nodes.py 
+
+import os
+from ldm_patched.pfn import model_loading
+from ldm_patched.modules import model_management
+import torch
+import ldm_patched.modules.utils
+import ldm_patched.utils.path_utils
+
+class UpscaleModelLoader:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model_name": (ldm_patched.utils.path_utils.get_filename_list("upscale_models"), ),
+                             }}
+    RETURN_TYPES = ("UPSCALE_MODEL",)
+    FUNCTION = "load_model"
+
+    CATEGORY = "loaders"
+
+    def load_model(self, model_name):
+        model_path = ldm_patched.utils.path_utils.get_full_path("upscale_models", model_name)
+        sd = ldm_patched.modules.utils.load_torch_file(model_path, safe_load=True)
+        if "module.layers.0.residual_group.blocks.0.norm1.weight" in sd:
+            sd = ldm_patched.modules.utils.state_dict_prefix_replace(sd, {"module.":""})
+        out = model_loading.load_state_dict(sd).eval()
+        return (out, )
+
+
+class ImageUpscaleWithModel:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "upscale_model": ("UPSCALE_MODEL",),
+                              "image": ("IMAGE",),
+                              }}
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "upscale"
+
+    CATEGORY = "image/upscaling"
+
+    def upscale(self, upscale_model, image):
+        device = model_management.get_torch_device()
+        upscale_model.to(device)
+        in_img = image.movedim(-1,-3).to(device)
+        free_memory = model_management.get_free_memory(device)
+
+        tile = 512
+        overlap = 32
+
+        oom = True
+        while oom:
+            try:
+                steps = in_img.shape[0] * ldm_patched.modules.utils.get_tiled_scale_steps(in_img.shape[3], in_img.shape[2], tile_x=tile, tile_y=tile, overlap=overlap)
+                pbar = ldm_patched.modules.utils.ProgressBar(steps)
+                s = ldm_patched.modules.utils.tiled_scale(in_img, lambda a: upscale_model(a), tile_x=tile, tile_y=tile, overlap=overlap, upscale_amount=upscale_model.scale, pbar=pbar)
+                oom = False
+            except model_management.OOM_EXCEPTION as e:
+                tile //= 2
+                if tile < 128:
+                    raise e
+
+        upscale_model.cpu()
+        s = torch.clamp(s.movedim(-3,-1), min=0, max=1.0)
+        return (s,)
+
+NODE_CLASS_MAPPINGS = {
+    "UpscaleModelLoader": UpscaleModelLoader,
+    "ImageUpscaleWithModel": ImageUpscaleWithModel
+}

html.py

@@ -0,0 +1,111 @@
+css = '''
+.loader-container {
+  display: flex; /* Use flex to align items horizontally */
+  align-items: center; /* Center items vertically within the container */
+  white-space: nowrap; /* Prevent line breaks within the container */
+}
+
+.loader {
+  border: 8px solid #f3f3f3; /* Light grey */
+  border-top: 8px solid #3498db; /* Blue */
+  border-radius: 50%;
+  width: 30px;
+  height: 30px;
+  animation: spin 2s linear infinite;
+}
+
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+
+/* Style the progress bar */
+progress {
+  appearance: none; /* Remove default styling */
+  height: 20px; /* Set the height of the progress bar */
+  border-radius: 5px; /* Round the corners of the progress bar */
+  background-color: #f3f3f3; /* Light grey background */
+  width: 100%;
+}
+
+/* Style the progress bar container */
+.progress-container {
+  margin-left: 20px;
+  margin-right: 20px;
+  flex-grow: 1; /* Allow the progress container to take up remaining space */
+}
+
+/* Set the color of the progress bar fill */
+progress::-webkit-progress-value {
+  background-color: #3498db; /* Blue color for the fill */
+}
+
+progress::-moz-progress-bar {
+  background-color: #3498db; /* Blue color for the fill in Firefox */
+}
+
+/* Style the text on the progress bar */
+progress::after {
+  content: attr(value '%'); /* Display the progress value followed by '%' */
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  color: white; /* Set text color */
+  font-size: 14px; /* Set font size */
+}
+
+/* Style other texts */
+.loader-container > span {
+  margin-left: 5px; /* Add spacing between the progress bar and the text */
+}
+
+.progress-bar > .generating {
+  display: none !important;
+}
+
+.progress-bar{
+  height: 30px !important;
+}
+
+.type_row{
+  height: 96px !important;
+}
+
+.type_small_row{
+  height: 40px !important;
+}
+
+.scroll-hide{
+  resize: none !important;
+}
+
+.refresh_button{
+  border: none !important;
+  background: none !important;
+  font-size: none !important;
+  box-shadow: none !important;
+}
+
+.advanced_check_row{
+  width: 250px !important;
+}
+
+.min_check{
+  min-width: min(1px, 100%) !important;
+}
+
+'''
+progress_html = '''
+<div class="loader-container">
+  <div class="loader"></div>
+  <div class="progress-container">
+    <progress value="*number*" max="100"></progress>
+  </div>
+  <span>*text*</span>
+</div>
+'''
+
+
+def make_progress_html(number, text):
+    return progress_html.replace('*number*', str(number)).replace('*text*', text)

paths-example.json.txt

@@ -0,0 +1,14 @@
+{
+    "path_checkpoints": "../models/checkpoints/",
+    "path_loras": "../models/loras/",
+    "path_embeddings": "../models/embeddings/",
+    "path_clip_vision": "../models/clip_vision/",
+    "path_controlnet": "../models/controlnet/",
+    "path_vae_approx": "../models/vae_approx/",
+    "path_fooocus_expansion": "../models/prompt_expansion/fooocus_expansion/",
+    "path_upscale_models": "../models/upscale_models/",
+    "path_inpaint_models": "../models/inpaint/",
+    "path_styles": "../sdxl_styles/",
+    "path_wildcards": "../wildcards/",
+    "path_outputs": "../outputs/"
+}

requirements_versions 2.txt

@@ -0,0 +1,17 @@
+torchsde==0.2.5
+einops==0.4.1
+transformers==4.30.2
+safetensors==0.3.1
+accelerate==0.21.0
+aiohttp==3.8.5
+pyyaml==6.0
+Pillow==9.4.0
+scipy==1.9.3
+tqdm==4.64.1
+psutil==5.9.5
+numpy==1.23.5
+pytorch_lightning==1.9.4
+omegaconf==2.2.3
+gradio==3.41.2
+pygit2==1.12.2
+fastapi==0.94.0

settings-example.json.txt

@@ -0,0 +1,65 @@
+{
+    "advanced_mode": true,
+    "image_number": 1,
+    "save_metadata_json": true,
+    "save_metadata_image": true,
+    "output_format": "jpg",
+    "seed_random": false,
+    "same_seed_for_all": false,
+    "seed": 0,
+    "styles": ["Default (Slightly Cinematic)"],
+    "prompt_expansion": true,
+    "prompt": "",
+    "negative_prompt": "",
+    "performance": "Speed",
+    "custom_steps": 24,
+    "custom_switch": 0.75,
+    "img2img_mode": false,
+    "img2img_start_step": 0.06,
+    "img2img_denoise": 0.94,
+    "img2img_scale": 1.0,
+    "control_lora_canny": false,
+    "canny_edge_low": 0.2,
+    "canny_edge_high": 0.8,
+    "canny_start": 0.0,
+    "canny_stop": 0.4,
+    "canny_strength": 0.8,
+    "canny_model": "control-lora-canny-rank128.safetensors",
+    "control_lora_depth": false,
+    "depth_start": 0.0,
+    "depth_stop": 0.4,
+    "depth_strength": 0.8,
+    "depth_model": "control-lora-depth-rank128.safetensors",
+    "keep_input_names": false,
+    "revision": false,
+    "positive_prompt_strength": 1.0,
+    "negative_prompt_strength": 1.0,
+    "revision_strength_1": 1.0,
+    "revision_strength_2": 1.0,
+    "revision_strength_3": 1.0,
+    "revision_strength_4": 1.0,
+    "resolution": "1152�896 (9:7)",
+    "sampler": "dpmpp_2m_sde_gpu",
+    "scheduler": "karras",
+    "cfg": 7.0,
+    "base_clip_skip": -2,
+    "refiner_clip_skip": -2,
+    "sharpness": 2.0,
+    "base_model": "sd_xl_base_1.0_0.9vae.safetensors",
+    "refiner_model": "sd_xl_refiner_1.0_0.9vae.safetensors",
+    "lora_1_model": "sd_xl_offset_example-lora_1.0.safetensors",
+    "lora_1_weight": 0.5,
+    "lora_2_model": "None",
+    "lora_2_weight": 0.5,
+    "lora_3_model": "None",
+    "lora_3_weight": 0.5,
+    "lora_4_model": "None",
+    "lora_4_weight": 0.5,
+    "lora_5_model": "None",
+    "lora_5_weight": 0.5,
+    "freeu": false,
+    "freeu_b1": 1.01,
+    "freeu_b2": 1.02,
+    "freeu_s1": 0.99,
+    "freeu_s2": 0.95
+}